feat(diagrams): add provider and model tracking for diagram creation and rendering

Author: iptoux

src-tauri/src/agent/mermaid/commands.rs

@@ -39,6 +39,9 @@ pub fn mermaid_create_diagram(
         kind.as_deref().unwrap_or(""),
         task_id,
         id,
+        // UI-triggered manual creation: no generating model to record.
+        None,
+        None,
     )
 }
 

src-tauri/src/agent/mermaid/store.rs

@@ -41,6 +41,15 @@ pub struct DiagramMeta {
     pub task_id: Option<String>,
     /// Creation time, ms since UNIX epoch.
     pub created_ms: u64,
+    /// Provider that generated the diagram (e.g. `openrouter`), as
+    /// `AgentProviderKind::as_str`. Absent for diagrams created before this was
+    /// recorded.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    /// Model id that generated the diagram (e.g. `openai/gpt-5`). Absent for
+    /// diagrams created before this was recorded.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
 }
 
 /// A diagram with its source code loaded. Returned to the frontend gallery.
@@ -135,6 +144,7 @@ fn slugify_unique(title: &str, existing: &[DiagramMeta]) -> String {
 
 /// Persist a new diagram under the given plan. Returns the stored record
 /// (with a freshly-allocated id when `id` is `None`).
+#[allow(clippy::too_many_arguments)]
 pub fn create_diagram(
     ws: &str,
     slug: &str,
@@ -143,6 +153,8 @@ pub fn create_diagram(
     kind: &str,
     task_id: Option<String>,
     id: Option<String>,
+    provider: Option<String>,
+    model: Option<String>,
 ) -> Result<DiagramRecord, String> {
     let dir = diagrams_dir(ws, slug)?;
     let mut manifest = read_manifest(&dir);
@@ -163,6 +175,8 @@ pub fn create_diagram(
         kind: kind.trim().to_string(),
         task_id: task_id.filter(|t| !t.trim().is_empty()),
         created_ms: now_ms(),
+        provider: provider.filter(|p| !p.trim().is_empty()),
+        model: model.filter(|m| !m.trim().is_empty()),
     };
 
     fs::create_dir_all(&dir).map_err(|e| format!("create diagrams dir: {e}"))?;
@@ -230,10 +244,14 @@ mod tests {
             "flowchart",
             Some("setup-auth".into()),
             None,
+            Some("openrouter".into()),
+            Some("openai/gpt-5".into()),
         )
         .unwrap();
         assert_eq!(rec.meta.id, "auth-flow");
         assert_eq!(rec.meta.task_id.as_deref(), Some("setup-auth"));
+        assert_eq!(rec.meta.provider.as_deref(), Some("openrouter"));
+        assert_eq!(rec.meta.model.as_deref(), Some("openai/gpt-5"));
 
         let listed = list_diagrams(&ws, "my-plan").unwrap();
         assert_eq!(listed.len(), 1);
@@ -246,15 +264,18 @@ mod tests {
     #[test]
     fn id_collisions_get_suffixed() {
         let ws = tmp_ws();
-        let a = create_diagram(&ws, "p", "Flow", "a", "flowchart", None, None).unwrap();
-        let b = create_diagram(&ws, "p", "Flow", "b", "flowchart", None, None).unwrap();
+        let a = create_diagram(&ws, "p", "Flow", "a", "flowchart", None, None, None, None).unwrap();
+        let b = create_diagram(&ws, "p", "Flow", "b", "flowchart", None, None, None, None).unwrap();
         assert_eq!(a.meta.id, "flow");
         assert_eq!(b.meta.id, "flow-2");
     }
 
     #[test]
     fn rejects_path_traversal_id() {
         let ws = tmp_ws();
-        assert!(create_diagram(&ws, "p", "x", "c", "k", None, Some("../evil".into())).is_err());
+        assert!(
+            create_diagram(&ws, "p", "x", "c", "k", None, Some("../evil".into()), None, None)
+                .is_err()
+        );
     }
 }

src-tauri/src/agent/mermaid/tool.rs

@@ -31,6 +31,20 @@ struct DiagramOut {
     task_id: Option<String>,
     plan_slug: Option<String>,
     persisted: bool,
+    /// Provider/model that generated this diagram, when known. Stamped for both
+    /// persisted and ephemeral diagrams so the gallery can show it.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    provider: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    model: Option<String>,
+}
+
+/// Provider/model that issued a `mermaid_create*` call, threaded from the
+/// dispatch context so each diagram records what generated it.
+#[derive(Clone, Default)]
+pub struct DiagramOrigin {
+    pub provider: Option<String>,
+    pub model: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -40,13 +54,13 @@ struct DiagramsEnvelope {
 
 /// Result of building/persisting a set of diagrams: a JSON string ready for the
 /// tool `content`, or an error message.
-pub fn run_create(ws: &str, args: &Value) -> Result<String, String> {
+pub fn run_create(ws: &str, args: &Value, origin: &DiagramOrigin) -> Result<String, String> {
     let one = parse_one(args)?;
-    let out = build_one(ws, one)?;
+    let out = build_one(ws, one, origin)?;
     finish(vec![out])
 }
 
-pub fn run_create_many(ws: &str, args: &Value) -> Result<String, String> {
+pub fn run_create_many(ws: &str, args: &Value, origin: &DiagramOrigin) -> Result<String, String> {
     let plan_slug = opt_str(args, "plan_slug");
     let items = args
         .get("diagrams")
@@ -65,7 +79,7 @@ pub fn run_create_many(ws: &str, args: &Value) -> Result<String, String> {
         if spec.plan_slug.is_none() {
             spec.plan_slug = plan_slug.clone();
         }
-        out.push(build_one(ws, spec)?);
+        out.push(build_one(ws, spec, origin)?);
     }
     finish(out)
 }
@@ -98,7 +112,7 @@ fn parse_one(v: &Value) -> Result<Spec, String> {
     })
 }
 
-fn build_one(ws: &str, spec: Spec) -> Result<DiagramOut, String> {
+fn build_one(ws: &str, spec: Spec, origin: &DiagramOrigin) -> Result<DiagramOut, String> {
     match &spec.plan_slug {
         Some(slug) => {
             let rec = store::create_diagram(
@@ -109,6 +123,8 @@ fn build_one(ws: &str, spec: Spec) -> Result<DiagramOut, String> {
                 &spec.kind,
                 spec.task_id.clone(),
                 spec.id,
+                origin.provider.clone(),
+                origin.model.clone(),
             )?;
             Ok(DiagramOut {
                 id: rec.meta.id,
@@ -118,6 +134,8 @@ fn build_one(ws: &str, spec: Spec) -> Result<DiagramOut, String> {
                 task_id: rec.meta.task_id,
                 plan_slug: Some(slug.clone()),
                 persisted: true,
+                provider: rec.meta.provider,
+                model: rec.meta.model,
             })
         }
         None => Ok(DiagramOut {
@@ -128,6 +146,8 @@ fn build_one(ws: &str, spec: Spec) -> Result<DiagramOut, String> {
             task_id: spec.task_id,
             plan_slug: None,
             persisted: false,
+            provider: origin.provider.clone(),
+            model: origin.model.clone(),
         }),
     }
 }
@@ -174,25 +194,39 @@ mod tests {
 
     #[test]
     fn ephemeral_when_no_plan_slug() {
+        let origin = DiagramOrigin {
+            provider: Some("openrouter".into()),
+            model: Some("openai/gpt-5".into()),
+        };
         let out = run_create(
             "/nonexistent-ws-ignored",
             &json!({ "title": "Flow", "code": "flowchart TD\n A-->B" }),
+            &origin,
         )
         .unwrap();
         assert!(out.contains("\"persisted\":false"));
         assert!(out.contains("\"id\":\"flow\""));
+        // Origin is stamped onto ephemeral diagrams too.
+        assert!(out.contains("\"provider\":\"openrouter\""));
+        assert!(out.contains("\"model\":\"openai/gpt-5\""));
     }
 
     #[test]
     fn rejects_oversize_code() {
         let big = "x".repeat(MAX_CODE_BYTES + 1);
-        let err = run_create("/ws", &json!({ "title": "T", "code": big })).unwrap_err();
+        let err = run_create(
+            "/ws",
+            &json!({ "title": "T", "code": big }),
+            &DiagramOrigin::default(),
+        )
+        .unwrap_err();
         assert!(err.contains("byte limit"));
     }
 
     #[test]
     fn many_rejects_empty() {
-        let err = run_create_many("/ws", &json!({ "diagrams": [] })).unwrap_err();
+        let err = run_create_many("/ws", &json!({ "diagrams": [] }), &DiagramOrigin::default())
+            .unwrap_err();
         assert!(err.contains("empty"));
     }
 }

src-tauri/src/agent/subagent_runner.rs

@@ -357,6 +357,7 @@ pub async fn run_one_subagent(
                                 &args,
                                 groups,
                                 root_guard.as_ref(),
+                                ctx,
                             );
                             let tool_elapsed_ms =
                                 tool_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
@@ -501,8 +502,13 @@ pub async fn run_one_subagent(
                         ToolCallOutcome::NotSubmit => {
                             let args: Value = serde_json::from_str(&args_str).unwrap_or(json!({}));
                             let tool_start = Instant::now();
-                            let outcome =
-                                execute_subagent_tool(&name, &args, groups, root_guard.as_ref());
+                            let outcome = execute_subagent_tool(
+                                &name,
+                                &args,
+                                groups,
+                                root_guard.as_ref(),
+                                ctx,
+                            );
                             let tool_elapsed_ms =
                                 tool_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
                             state.push(AgentEvent::TurnUsage {
@@ -615,20 +621,20 @@ fn execute_subagent_tool(
     args: &Value,
     groups: &[ToolGroup],
     root: Option<&WorkspaceRootGuard>,
+    ctx: &DispatchContext,
 ) -> tools::ToolOutcome {
-    let shell_write = groups.contains(&ToolGroup::ShellWrite);
-    if name == "shell_exec" {
-        tools::execute_server_tool(
-            name,
-            args,
-            root,
-            Some(tools::ToolExecOpts {
-                shell_writes: shell_write,
-            }),
-        )
-    } else {
-        tools::execute_server_tool(name, args, root, None)
-    }
+    let shell_write = name == "shell_exec" && groups.contains(&ToolGroup::ShellWrite);
+    // Stamp the subagent's own provider/model so diagrams it creates record it.
+    tools::execute_server_tool(
+        name,
+        args,
+        root,
+        Some(tools::ToolExecOpts {
+            shell_writes: shell_write,
+            provider: Some(ctx.settings.provider.as_str().to_string()),
+            model: Some(ctx.settings.model_id.clone()),
+        }),
+    )
 }
 
 fn finish_subagent(state: &Arc<AgentEngineState>, agent_id: &str, result: &Value) {

src-tauri/src/agent/tool_dispatch.rs

@@ -51,7 +51,7 @@ pub async fn dispatch_tool(
             },
         }
     } else {
-        dispatch_regular_tool(state, call_id, name, args, root).await
+        dispatch_regular_tool(state, call_id, name, args, root, ctx).await
     };
     state.pop_parent();
     outcome
@@ -270,6 +270,7 @@ async fn dispatch_regular_tool(
     name: &str,
     args: &Value,
     root: Option<&WorkspaceRootGuard>,
+    ctx: Option<&DispatchContext>,
 ) -> tools::ToolOutcome {
     // MCP-server tools are not in the static registry; route them to the live
     // client runtime before the normal lookup.
@@ -291,7 +292,16 @@ async fn dispatch_regular_tool(
     };
 
     match def.site {
-        ToolSite::Server => tools::execute_server_tool(name, args, root, None),
+        ToolSite::Server => {
+            // Stamp the active provider/model so created diagrams record what
+            // generated them.
+            let opts = ctx.map(|c| tools::ToolExecOpts {
+                shell_writes: false,
+                provider: Some(c.settings.provider.as_str().to_string()),
+                model: Some(c.settings.model_id.clone()),
+            });
+            tools::execute_server_tool(name, args, root, opts)
+        }
         ToolSite::Client => wait_for_client_tool(state, call_id, name).await,
     }
 }

src-tauri/src/agent/tools.rs

@@ -233,10 +233,13 @@ pub struct ToolDef {
     pub site: ToolSite,
 }
 
-/// Options for server-tool execution (shell write mode, etc.).
-#[derive(Clone, Copy, Debug, Default)]
+/// Options for server-tool execution (shell write mode, generating model, etc.).
+#[derive(Clone, Debug, Default)]
 pub struct ToolExecOpts {
     pub shell_writes: bool,
+    /// Provider/model that issued the call, stamped onto created diagrams.
+    pub provider: Option<String>,
+    pub model: Option<String>,
 }
 
 /// Output of an in-process server-tool execution.
@@ -1650,7 +1653,12 @@ pub fn execute_server_tool(
     root: Option<&WorkspaceRootGuard>,
     opts: Option<ToolExecOpts>,
 ) -> ToolOutcome {
-    let shell_writes = opts.map(|o| o.shell_writes).unwrap_or(false);
+    let opts = opts.unwrap_or_default();
+    let shell_writes = opts.shell_writes;
+    let origin = crate::agent::mermaid::tool::DiagramOrigin {
+        provider: opts.provider.clone(),
+        model: opts.model.clone(),
+    };
     match name {
         "environment_detect" => crate::agent::environment::tool_environment_detect(root),
         "shell_exec" => crate::agent::shell_exec::tool_shell_exec(args, root, shell_writes),
@@ -1701,8 +1709,8 @@ pub fn execute_server_tool(
         "plan_rename" => tool_plan_rename(args, root),
         "plan_load" => tool_plan_load(args, root),
         "plan_sync_from_tasks" => tool_plan_sync_from_tasks(args, root),
-        "mermaid_create" => tool_mermaid_create(args, root),
-        "mermaid_create_many" => tool_mermaid_create_many(args, root),
+        "mermaid_create" => tool_mermaid_create(args, root, &origin),
+        "mermaid_create_many" => tool_mermaid_create_many(args, root, &origin),
         "kanban_board_load" => tool_kanban_board_load(root),
         "kanban_layout_save" => tool_kanban_layout_save(args, root),
         "kanban_task_create" => tool_kanban_task_create(args, root),
@@ -2901,23 +2909,31 @@ fn tool_plan_create(args: &Value, root: Option<&WorkspaceRootGuard>) -> ToolOutc
     }
 }
 
-fn tool_mermaid_create(args: &Value, root: Option<&WorkspaceRootGuard>) -> ToolOutcome {
+fn tool_mermaid_create(
+    args: &Value,
+    root: Option<&WorkspaceRootGuard>,
+    origin: &crate::agent::mermaid::tool::DiagramOrigin,
+) -> ToolOutcome {
     let ws = match workspace_string(root) {
         Ok(s) => s,
         Err(out) => return out,
     };
-    match crate::agent::mermaid::tool::run_create(&ws, args) {
+    match crate::agent::mermaid::tool::run_create(&ws, args, origin) {
         Ok(content) => ToolOutcome { ok: true, content },
         Err(e) => err_outcome(e),
     }
 }
 
-fn tool_mermaid_create_many(args: &Value, root: Option<&WorkspaceRootGuard>) -> ToolOutcome {
+fn tool_mermaid_create_many(
+    args: &Value,
+    root: Option<&WorkspaceRootGuard>,
+    origin: &crate::agent::mermaid::tool::DiagramOrigin,
+) -> ToolOutcome {
     let ws = match workspace_string(root) {
         Ok(s) => s,
         Err(out) => return out,
     };
-    match crate::agent::mermaid::tool::run_create_many(&ws, args) {
+    match crate::agent::mermaid::tool::run_create_many(&ws, args, origin) {
         Ok(content) => ToolOutcome { ok: true, content },
         Err(e) => err_outcome(e),
     }

src-tauri/src/plans.rs

@@ -1303,6 +1303,8 @@ mod tests {
             "flowchart",
             None,
             None,
+            None,
+            None,
         )
         .unwrap();