feat(inference): Phase 3 P3-B — crate-native turn path + delete compatible*.rs [WIP]

src/bin/inference_probe.rs

@@ -32,10 +32,11 @@ use anyhow::{Context, Result};
 use clap::Parser;
 use openhuman_core::openhuman::agent::Agent;
 use openhuman_core::openhuman::config::Config;
-use openhuman_core::openhuman::inference::provider::create_chat_provider;
-use openhuman_core::openhuman::inference::provider::traits::{ChatMessage, ChatRequest};
-use openhuman_core::openhuman::tools::traits::ToolSpec;
+use openhuman_core::openhuman::inference::provider::create_chat_model_with_model_id;
 use serde_json::json;
+use tinyagents::harness::message::Message;
+use tinyagents::harness::model::ModelRequest;
+use tinyagents::harness::tool::ToolSchema;
 
 #[derive(Parser, Debug)]
 #[command(name = "inference-probe")]
@@ -117,14 +118,16 @@ async fn run_harness(config: &Config, prompt: &str) -> Result<()> {
 }
 
 async fn run_raw(config: &Config, role: &str, raw_mode: &str, prompt: &str) -> Result<()> {
-    let (provider, model_name) =
-        create_chat_provider(role, config).context("create_chat_provider failed")?;
+    let (chat_model, model_name) = create_chat_model_with_model_id(role, config, 0.4)
+        .context("create_chat_model_with_model_id failed")?;
     eprintln!("[probe] mode = raw");
     eprintln!("[probe] role = {role}");
     eprintln!("[probe] resolved model = {model_name}");
     eprintln!(
-        "[probe] provider.supports_native_tools() = {}",
-        provider.supports_native_tools()
+        "[probe] model.profile.tool_calling = {}",
+        chat_model
+            .profile()
+            .is_some_and(|profile| profile.tool_calling)
     );
     eprintln!("[probe] raw_mode = {raw_mode}");
 
@@ -149,82 +152,77 @@ Emit tool calls as `<tool_call>name[arg1|arg2]</tool_call>` blocks.
         "You are a helpful assistant. Use the provided tools when the user asks something \
          a tool can answer.";
 
-    let (system, tools_for_request): (&str, Option<Vec<ToolSpec>>) = match raw_mode {
+    let (system, tools_for_request): (&str, Option<Vec<ToolSchema>>) = match raw_mode {
         "native" => (
             native_system,
             Some(vec![
-                ToolSpec {
-                    name: "get_weather".into(),
-                    description: "Get the current weather for a city.".into(),
-                    parameters: json!({
+                ToolSchema::new(
+                    "get_weather",
+                    "Get the current weather for a city.",
+                    json!({
                         "type": "object",
                         "properties": {
                             "city": {"type": "string"},
                             "unit": {"type": "string", "enum": ["metric", "imperial"]}
                         },
                         "required": ["city"]
                     }),
-                },
-                ToolSpec {
-                    name: "list_files".into(),
-                    description: "List files in a directory.".into(),
-                    parameters: json!({
+                ),
+                ToolSchema::new(
+                    "list_files",
+                    "List files in a directory.",
+                    json!({
                         "type": "object",
                         "properties": {"path": {"type": "string"}},
                         "required": ["path"]
                     }),
-                },
+                ),
             ]),
         ),
         "pformat" => (pformat_system, None),
         other => anyhow::bail!("unknown --raw-mode {other:?}"),
     };
 
-    let messages = vec![
-        ChatMessage::system(system),
-        ChatMessage::user(prompt.to_string()),
-    ];
-
-    let request = ChatRequest {
-        messages: &messages,
-        tools: tools_for_request.as_deref(),
-        stream: None,
-        max_tokens: None,
-    };
+    let mut request = ModelRequest::new(vec![Message::system(system), Message::user(prompt)])
+        .with_model(model_name.clone())
+        .with_temperature(0.4);
+    if let Some(tools) = tools_for_request {
+        request = request.with_tools(tools);
+    }
 
-    eprintln!("[probe] >>> raw provider.chat()...");
+    eprintln!("[probe] >>> raw ChatModel::invoke()...");
     let started = std::time::Instant::now();
-    let response = provider
-        .chat(request, &model_name, 0.4)
+    let response = chat_model
+        .invoke(&(), request)
         .await
-        .context("provider.chat() failed")?;
+        .context("ChatModel::invoke() failed")?;
     let elapsed = started.elapsed();
     eprintln!("[probe] <<< {elapsed:?}");
 
     println!();
     println!("=== RAW RESPONSE TEXT ===");
-    println!("{}", response.text_or_empty());
+    println!("{}", response.text());
     println!("=== /RAW RESPONSE TEXT ===");
 
-    let text = response.text_or_empty();
+    let text = response.text();
     let saw_pformat = text.contains("<tool_call>") || text.contains("<toolcall>");
-    let saw_native = !response.tool_calls.is_empty();
+    let saw_native = !response.tool_calls().is_empty();
     eprintln!(
         "[probe] response.tool_calls.len() = {}",
-        response.tool_calls.len()
+        response.tool_calls().len()
     );
     eprintln!(
         "[probe] response contains <tool_call> tag = {}",
         saw_pformat
     );
     if saw_native {
-        for tc in &response.tool_calls {
+        for tc in response.tool_calls() {
             // Print tool name + arg byte-count only — raw arguments may
             // contain user content / secrets and must not land in logs.
             eprintln!(
                 "[probe]   native tool_call name={} arg_bytes={}",
                 tc.name,
-                tc.arguments.len()
+                tc.arguments.to_string().len()
             );
         }
     }

src/openhuman/agent/harness/graph.rs

@@ -77,7 +77,7 @@ pub(crate) async fn run_channel_turn_via_graph(
     // Phase 3 / Motion A): the harness graph names crate model types only, and
     // reads native-tool / vision capability + telemetry id off the built bundle.
     let context_window = source.effective_context_window(model).await;
-    let turn_models = source.build(model, temperature, context_window);
+    let turn_models = source.build(model, temperature, context_window)?;
 
     // Native-tool support drives the durable history-suffix dispatcher (native
     // envelope vs prompt-guided text) at the end of this turn; capture it before

src/openhuman/agent/harness/session/builder/factory.rs

@@ -14,7 +14,7 @@ use crate::openhuman::agent::host_runtime;
 use crate::openhuman::agent_memory::memory_loader::DefaultMemoryLoader;
 use crate::openhuman::config::Config;
 use crate::openhuman::context::prompt::SystemPromptBuilder;
-use crate::openhuman::inference::provider::{self, Provider};
+use crate::openhuman::inference::provider;
 use crate::openhuman::memory::Memory;
 use crate::openhuman::memory_store;
 use crate::openhuman::memory_tools::ToolMemoryCaptureHook;
@@ -476,14 +476,21 @@ impl Agent {
         // double-retry every transient error. Cross-route fallback is likewise
         // the crate registry `FallbackPolicy`, so `config.reliability.*` no longer
         // layers on the turn path (it still governs the non-seam provider paths).
-        let (provider, mut model_name): (Box<dyn Provider>, String) =
-            crate::openhuman::inference::provider::create_chat_provider(provider_role, config)?;
+        let (resolved_chat_model, mut model_name) =
+            crate::openhuman::inference::provider::create_chat_model_with_model_id(
+                provider_role,
+                config,
+                config.default_temperature,
+            )?;
+        let supports_native = resolved_chat_model
+            .profile()
+            .map_or(true, |profile| profile.tool_calling);
         log::info!(
             "[session-builder] agent_id={} provider_role={} resolved_model={} supports_native_tools={}",
             agent_id,
             provider_role,
             model_name,
-            provider.supports_native_tools()
+            supports_native
         );
         let target_agent_id = target_def
             .map(|def| def.id.as_str())
@@ -530,7 +537,6 @@ impl Agent {
         // the choice string now so the provider borrow doesn't conflict
         // with the later `provider` move into the builder.
         let dispatcher_choice = config.agent.tool_dispatcher.clone();
-        let supports_native = provider.supports_native_tools();
 
         // Build prompt builder — either the default "orchestrator /
         // main agent" layout that bootstraps from workspace identity
@@ -693,23 +699,12 @@ impl Agent {
                 > = if config.learning.reflection_source
                     == crate::openhuman::config::ReflectionSource::Cloud
                 {
-                    // Reflection always calls with the `hint:reasoning` route +
-                    // 0.3 temperature (formerly `simple_chat(prompt,
-                    // "hint:reasoning", 0.3)`), so bake both into the wrapped
-                    // model. The routed provider still resolves the hint per call.
-                    let routed = provider::create_routed_provider(
-                        config.inference_url.as_deref(),
-                        config.api_url.as_deref(),
-                        config.api_key.as_deref(),
-                        &config.reliability,
-                        &config.model_routes,
-                        &model_name,
-                    )?;
-                    Some(provider::chat_model_from_provider(
-                        routed,
-                        "hint:reasoning".to_string(),
-                        0.3,
-                    ))
+                    let (model, resolved_model) =
+                        provider::create_chat_model_with_model_id("reasoning", config, 0.3)?;
+                    log::debug!(
+                        "[learning] built crate-native reflection model resolved_model={resolved_model}"
+                    );
+                    Some(model)
                 } else {
                     None
                 };
@@ -1140,8 +1135,13 @@ impl Agent {
             None
         };
 
+        // Crate-native turn models (Phase 3 P3-B): the production main-turn agent
+        // builds crate `ChatModel`s from `(provider_role, config)` without retaining
+        // a host provider. The
+        // `agent_harness_e2e` mock now serves SSE for streaming, so the crate-native
+        // streaming path is exercised end-to-end.
         let mut builder = Agent::builder()
-            .provider(provider)
+            .crate_native_provider(provider_role, std::sync::Arc::new(config.clone()))
             .tools(tools)
             .visible_tool_names(visible)
             .memory(memory)

src/openhuman/agent/harness/session/builder/setters.rs

@@ -78,6 +78,23 @@ impl AgentBuilder {
         self
     }
 
+    /// Sets the AI provider as a **crate-native** turn-model source (Phase 3 P3-B):
+    /// `build`/`build_summarizer` construct crate `ChatModel`s from `(role, config)`
+    /// via `create_turn_chat_model` (managed → `OpenHumanBackendModel`, local/cloud →
+    /// crate `OpenAiModel`) instead of wrapping `provider` in `ProviderModel`s.
+    /// Used by the production session factory; the plain
+    /// [`provider`](Self::provider) setter (Provider path) stays for tests that
+    /// inject a mock they observe.
+    pub fn crate_native_provider(
+        mut self,
+        role: impl Into<String>,
+        config: Arc<crate::openhuman::config::Config>,
+    ) -> Self {
+        self.turn_model_source =
+            Some(crate::openhuman::tinyagents::TurnModelSource::new_crate_native(role, config));
+        self
+    }
+
     /// Sets the available tools for the agent.
     pub fn tools(mut self, tools: Vec<Box<dyn Tool>>) -> Self {
         self.tools = Some(tools);

src/openhuman/agent/harness/session/turn/core.rs

@@ -879,7 +879,7 @@ impl Agent {
             .await;
         let turn_models =
             self.turn_model_source
-                .build(effective_model, temperature, context_window);
+                .build(effective_model, temperature, context_window)?;
 
         // Honor custom/BYOK vision models too: they can set `model_vision` even
         // when the provider capability bit is false, and must still rehydrate