feat: add provider qualification to models and implement incremental SSE streaming

Author: jacobjmc

src-tauri/src/backend/app_server.rs

@@ -542,19 +542,25 @@ fn spawn_sse_reader<E: EventSink>(
                                     }
                                 };
 
-                                // Filter events by directory — only process events for this workspace.
+                                // OpenCode SSE format wraps events:
+                                //   { "directory": "...", "payload": { "type": "...", "properties": {...} } }
+                                // Extract directory from top level; unwrap payload for translation.
                                 let event_dir = value
-                                    .get("properties")
-                                    .and_then(|p| p.get("directory"))
+                                    .get("directory")
                                     .and_then(|d| d.as_str())
                                     .unwrap_or("");
                                 if !event_dir.is_empty() && event_dir != workspace_path {
                                     continue;
                                 }
 
+                                let payload = match value.get("payload") {
+                                    Some(p) => p,
+                                    None => &value, // fallback: treat top-level as payload
+                                };
+
                                 let translated = {
                                     let mut ts = session.translation_state.lock().await;
-                                    event_translator::translate_sse_event(&value, &mut ts)
+                                    event_translator::translate_sse_event(payload, &mut ts)
                                 };
 
                                 for translated_msg in translated {

src-tauri/src/backend/event_translator.rs

@@ -26,6 +26,8 @@ pub(crate) struct SessionTranslationState {
     agent_message_item_id: Option<String>,
     /// Stable item ID for the current reasoning stream.
     reasoning_item_id: Option<String>,
+    /// OpenCode part ID for the current reasoning part (used to route `message.part.delta` events).
+    reasoning_part_id: Option<String>,
     /// Stable item ID for contiguous user-message chunk streams.
     pub(crate) user_message_item_id: Option<String>,
     /// Buffered text for contiguous user-message chunk streams.
@@ -41,6 +43,7 @@ impl SessionTranslationState {
             tool_call_items: HashMap::new(),
             agent_message_item_id: None,
             reasoning_item_id: None,
+            reasoning_part_id: None,
             user_message_item_id: None,
             user_message_text: String::new(),
         }
@@ -58,6 +61,7 @@ impl SessionTranslationState {
         self.tool_call_items.clear();
         self.agent_message_item_id = None;
         self.reasoning_item_id = None;
+        self.reasoning_part_id = None;
         self.user_message_item_id = None;
         self.user_message_text.clear();
     }
@@ -69,6 +73,7 @@ impl SessionTranslationState {
         self.tool_call_items.clear();
         self.agent_message_item_id = None;
         self.reasoning_item_id = None;
+        self.reasoning_part_id = None;
         self.user_message_item_id = None;
         self.user_message_text.clear();
     }
@@ -107,6 +112,7 @@ impl SessionTranslationState {
         self.tool_call_items.clear();
         self.agent_message_item_id = None;
         self.reasoning_item_id = None;
+        self.reasoning_part_id = None;
     }
 }
 
@@ -132,6 +138,7 @@ pub(crate) fn translate_sse_event(
 
     match event_type {
         "message.part.updated" => translate_part_updated(properties, state),
+        "message.part.delta" => translate_part_delta(properties, state),
         "message.updated" => translate_message_updated(properties, state),
         "session.status" => translate_session_status(properties, state),
         "permission.updated" => translate_sse_permission(properties, state),
@@ -201,6 +208,11 @@ fn translate_part_updated(properties: &Value, state: &mut SessionTranslationStat
         }
 
         "reasoning" => {
+            // Track the OpenCode part ID so `message.part.delta` events can be
+            // routed to reasoning vs text.
+            if let Some(pid) = part.get("id").and_then(|v| v.as_str()) {
+                state.reasoning_part_id = Some(pid.to_string());
+            }
             if delta.is_empty() {
                 return vec![];
             }
@@ -222,6 +234,66 @@ fn translate_part_updated(properties: &Value, state: &mut SessionTranslationStat
     }
 }
 
+// ---------------------------------------------------------------------------
+// message.part.delta — incremental text/reasoning streaming chunks
+// ---------------------------------------------------------------------------
+
+fn translate_part_delta(properties: &Value, state: &mut SessionTranslationState) -> Vec<Value> {
+    let delta = match properties.get("delta").and_then(|v| v.as_str()) {
+        Some(d) if !d.is_empty() => d,
+        _ => return vec![],
+    };
+
+    if let Some(sid) = properties.get("sessionID").and_then(|v| v.as_str()) {
+        if !sid.is_empty() {
+            state.session_id = sid.to_string();
+        }
+    }
+
+    let field = properties
+        .get("field")
+        .and_then(|v| v.as_str())
+        .unwrap_or("text");
+    let thread_id = state.session_id.clone();
+    let turn_id = state.current_turn_id.clone();
+
+    match field {
+        "text" => {
+            let part_id = properties
+                .get("partID")
+                .and_then(|v| v.as_str())
+                .unwrap_or_default();
+
+            if let Some(ref reasoning_part_id) = state.reasoning_part_id {
+                if part_id == reasoning_part_id {
+                    let item_id = state.reasoning_item();
+                    return vec![json!({
+                        "method": "item/reasoning/textDelta",
+                        "params": {
+                            "threadId": thread_id,
+                            "turnId": turn_id,
+                            "itemId": item_id,
+                            "delta": delta
+                        }
+                    })];
+                }
+            }
+
+            let item_id = state.agent_message_item();
+            vec![json!({
+                "method": "item/agentMessage/delta",
+                "params": {
+                    "threadId": thread_id,
+                    "turnId": turn_id,
+                    "itemId": item_id,
+                    "delta": delta
+                }
+            })]
+        }
+        _ => vec![],
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Tool part translation
 // ---------------------------------------------------------------------------
@@ -362,24 +434,36 @@ fn translate_message_updated(
         Some(i) => i,
         None => return vec![],
     };
+
+    if let Some(sid) = info.get("sessionID").and_then(|v| v.as_str()) {
+        if !sid.is_empty() {
+            state.session_id = sid.to_string();
+        }
+    }
+
     let thread_id = state.session_id.clone();
 
-    // Extract token usage from message info if available.
-    let input_tokens = info
-        .get("inputTokens")
+    // Token usage: try nested `tokens` object first (current format), then flat keys (legacy).
+    let tokens = info.get("tokens");
+    let input_tokens = tokens
+        .and_then(|t| t.get("input"))
+        .or_else(|| info.get("inputTokens"))
         .and_then(|v| v.as_u64())
         .unwrap_or(0);
-    let output_tokens = info
-        .get("outputTokens")
+    let output_tokens = tokens
+        .and_then(|t| t.get("output"))
+        .or_else(|| info.get("outputTokens"))
         .and_then(|v| v.as_u64())
         .unwrap_or(0);
-    let cached_tokens = info
-        .get("cachedInputTokens")
+    let cached_tokens = tokens
+        .and_then(|t| t.get("cache").and_then(|c| c.get("read")))
+        .or_else(|| info.get("cachedInputTokens"))
         .or_else(|| info.get("cacheReadInputTokens"))
         .and_then(|v| v.as_u64())
         .unwrap_or(0);
-    let reasoning_tokens = info
-        .get("reasoningOutputTokens")
+    let reasoning_tokens = tokens
+        .and_then(|t| t.get("reasoning"))
+        .or_else(|| info.get("reasoningOutputTokens"))
         .or_else(|| info.get("reasoningTokens"))
         .and_then(|v| v.as_u64())
         .unwrap_or(0);
@@ -953,4 +1037,113 @@ mod tests {
         let events = translate_sse_event(&event, &mut state);
         assert_eq!(events[0]["params"]["delta"], " line with trailing space ");
     }
+
+    #[test]
+    fn part_delta_text_produces_agent_message_delta() {
+        let mut state = make_state();
+        let event = json!({
+            "type": "message.part.delta",
+            "properties": {
+                "sessionID": "ses_test123",
+                "messageID": "msg_1",
+                "partID": "prt_text_1",
+                "field": "text",
+                "delta": "hello"
+            }
+        });
+        let events = translate_sse_event(&event, &mut state);
+        assert_eq!(events.len(), 1);
+        assert_eq!(events[0]["method"], "item/agentMessage/delta");
+        assert_eq!(events[0]["params"]["threadId"], "ses_test123");
+        assert_eq!(events[0]["params"]["delta"], "hello");
+    }
+
+    #[test]
+    fn part_delta_routes_reasoning_by_part_id() {
+        let mut state = make_state();
+
+        // First, announce a reasoning part via message.part.updated.
+        let reasoning_announce = json!({
+            "type": "message.part.updated",
+            "properties": {
+                "part": {
+                    "type": "reasoning",
+                    "id": "prt_reasoning_1",
+                    "sessionID": "ses_test123",
+                    "text": ""
+                }
+            }
+        });
+        translate_sse_event(&reasoning_announce, &mut state);
+
+        // Now a delta for that reasoning part should produce reasoning event.
+        let delta_event = json!({
+            "type": "message.part.delta",
+            "properties": {
+                "sessionID": "ses_test123",
+                "partID": "prt_reasoning_1",
+                "field": "text",
+                "delta": "thinking..."
+            }
+        });
+        let events = translate_sse_event(&delta_event, &mut state);
+        assert_eq!(events.len(), 1);
+        assert_eq!(events[0]["method"], "item/reasoning/textDelta");
+        assert_eq!(events[0]["params"]["delta"], "thinking...");
+    }
+
+    #[test]
+    fn nested_token_format_produces_token_usage() {
+        let mut state = make_state();
+        let event = json!({
+            "type": "message.updated",
+            "properties": {
+                "info": {
+                    "sessionID": "ses_test123",
+                    "tokens": {
+                        "total": 6000,
+                        "input": 5000,
+                        "output": 1000,
+                        "reasoning": 50,
+                        "cache": { "read": 200, "write": 0 }
+                    }
+                }
+            }
+        });
+        let events = translate_sse_event(&event, &mut state);
+        assert_eq!(events.len(), 1);
+        assert_eq!(events[0]["method"], "thread/tokenUsage/updated");
+        assert_eq!(
+            events[0]["params"]["tokenUsage"]["total"]["inputTokens"],
+            5000
+        );
+        assert_eq!(
+            events[0]["params"]["tokenUsage"]["total"]["outputTokens"],
+            1000
+        );
+        assert_eq!(
+            events[0]["params"]["tokenUsage"]["total"]["cachedInputTokens"],
+            200
+        );
+        assert_eq!(
+            events[0]["params"]["tokenUsage"]["total"]["reasoningOutputTokens"],
+            50
+        );
+    }
+
+    #[test]
+    fn part_delta_empty_delta_returns_empty() {
+        let mut state = make_state();
+        let event = json!({
+            "type": "message.part.delta",
+            "properties": {
+                "sessionID": "ses_test123",
+                "partID": "prt_1",
+                "field": "text",
+                "delta": ""
+            }
+        });
+        let events = translate_sse_event(&event, &mut state);
+        assert!(events.is_empty());
+    }
 }

src-tauri/src/shared/codex_core.rs

@@ -739,9 +739,13 @@ pub(crate) async fn send_user_message_core<E: EventSink>(
     let requested_model = normalize_optional_string(model);
     let requested_effort = normalize_optional_string(effort);
     if let Some(ref model_id) = requested_model {
-        // REST API accepts model as { providerID, modelID } but modelID alone
-        // may work depending on the server version. Include both fields.
-        body["model"] = json!({ "modelID": model_id });
+        // REST API requires model as { providerID, modelID }.
+        // The frontend sends a qualified "provider/model" string.
+        if let Some((provider, mid)) = model_id.split_once('/') {
+            body["model"] = json!({ "providerID": provider, "modelID": mid });
+        } else {
+            body["model"] = json!({ "modelID": model_id });
+        }
     }
     if let Some(ref effort_level) = requested_effort {
         body["effort"] = json!(effort_level);
@@ -880,13 +884,31 @@ pub(crate) async fn model_list_core(
                 .to_string();
             let qualified_id = format!("{provider_id}/{model_id}");
             let is_default = model_id == default_for_provider;
+
+            // Variants keys are reasoning effort levels (e.g. "low", "medium", "high", "max").
+            let variants = model
+                .get("variants")
+                .and_then(|v| v.as_object())
+                .cloned()
+                .unwrap_or_default();
+            let efforts: Vec<Value> = variants
+                .keys()
+                .map(|k| json!({ "reasoningEffort": k, "description": "" }))
+                .collect();
+            let default_effort = ["medium", "high"]
+                .iter()
+                .find(|e| variants.contains_key(**e))
+                .map(|e| json!(e))
+                .unwrap_or(json!(null));
+
             data.push(json!({
                 "id": qualified_id,
                 "model": model_id,
+                "provider": provider_id,
                 "displayName": display_name,
                 "description": "",
-                "supportedReasoningEfforts": [],
-                "defaultReasoningEffort": null,
+                "supportedReasoningEfforts": efforts,
+                "defaultReasoningEffort": default_effort,
                 "isDefault": is_default,
             }));
         }

src/App.tsx

@@ -487,7 +487,7 @@ function MainApp() {
     getWorkspacePromptsDir,
     getGlobalPromptsDir,
   } = useCustomPrompts({ activeWorkspace, onDebug: addDebugEntry });
-  const resolvedModel = selectedModel?.model ?? null;
+  const resolvedModel = selectedModel?.id ?? null;
   const resolvedEffort = reasoningSupported ? selectedEffort : null;
 
   const { collaborationModePayload } = useCollaborationModeSelection({

src/features/composer/components/Composer.tsx

@@ -57,7 +57,7 @@ type ComposerProps = {
   collaborationModes: { id: string; label: string }[];
   selectedCollaborationModeId: string | null;
   onSelectCollaborationMode: (id: string | null) => void;
-  models: { id: string; displayName: string; model: string }[];
+  models: { id: string; displayName: string; model: string; provider: string }[];
   selectedModelId: string | null;
   onSelectModel: (id: string) => void;
   reasoningOptions: string[];