@vellumai/assistant 0.10.0-dev.202606232234.a0ec2ee → 0.10.0-dev.202606232330.324e2b5

package/openapi.yaml

@@ -25994,6 +25994,13 @@ paths:
                           type: boolean
                         messageId:
                           type: string
+                        toolUseId:
+                          type: string
+                        input:
+                          type: object
+                          propertyNames:
+                            type: string
+                          additionalProperties: {}
                       required:
                         - type
                         - content

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.0-dev.202606232234.a0ec2ee",
+  "version": "0.10.0-dev.202606232330.324e2b5",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/subagent-detail.test.ts

@@ -130,6 +130,33 @@ describe("parseSubagentMessages", () => {
     expect(result.objective).toBe("Research vampire lore");
   });
 
+  test("emits toolUseId and raw input on tool_use, toolUseId on tool_result", () => {
+    const messages = [
+      msg("user", [{ type: "text", text: "Do something" }]),
+      msg("assistant", [
+        {
+          type: "tool_use",
+          id: "t-abc",
+          name: "bash",
+          input: { command: "ls -la" },
+        },
+      ]),
+      msg("user", [
+        { type: "tool_result", tool_use_id: "t-abc", content: "total 0" },
+      ]),
+    ];
+
+    const result = parseSubagentMessages("sub-1", messages);
+    const toolUse = result.events.find((e) => e.type === "tool_use");
+    expect(toolUse).toBeDefined();
+    expect(toolUse!.toolUseId).toBe("t-abc");
+    expect(toolUse!.input).toEqual({ command: "ls -la" });
+
+    const toolResult = result.events.find((e) => e.type === "tool_result");
+    expect(toolResult).toBeDefined();
+    expect(toolResult!.toolUseId).toBe("t-abc");
+  });
+
   test("includes messageId on text events from assistant messages", () => {
     const messages = [
       msg("user", [{ type: "text", text: "Do something" }]),

package/src/__tests__/subagent-disposal.test.ts

@@ -326,3 +326,68 @@ describe("SubagentManager terminal disposal", () => {
     asInternals(manager).stopSweep();
   });
 });
+
+describe("SubagentManager.abort usage", () => {
+  test("emits the conversation's latest usage on abort, not zeros", () => {
+    const manager = new SubagentManager();
+    const sent: ServerMessage[] = [];
+    const sender = (msg: ServerMessage) => sent.push(msg);
+
+    const subagentId = "sa-abort-usage";
+    // state.usage starts at {0,0,0}; the live (fake) conversation has accrued
+    // usage (makeFakeConversation → {100, 50, 0.005}). Wire `sender` as the
+    // stored parent sender so `setStatus` routes the terminal event through it.
+    injectFakeSubagent(manager, subagentId, makeState(subagentId), sender);
+
+    const aborted = manager.abort(subagentId, sender, undefined, {
+      suppressNotification: true,
+    });
+    expect(aborted).toBe(true);
+
+    const statusMsg = sent.find(
+      (m): m is Extract<ServerMessage, { type: "subagent_status_changed" }> =>
+        m.type === "subagent_status_changed",
+    );
+    expect(statusMsg).toBeDefined();
+    expect(statusMsg!.status).toBe("aborted");
+    // The emitted usage is the conversation's accrued total — NOT the {0,0,0}
+    // init — so the client doesn't flush the token panel to zero on stop.
+    expect(statusMsg!.usage).toEqual({
+      inputTokens: 100,
+      outputTokens: 50,
+      estimatedCost: 0.005,
+    });
+
+    asInternals(manager).stopSweep();
+  });
+
+  test("keeps the last-known state.usage when the conversation was already released", () => {
+    const manager = new SubagentManager();
+    const sent: ServerMessage[] = [];
+    const sender = (msg: ServerMessage) => sent.push(msg);
+
+    const subagentId = "sa-abort-no-conv";
+    // No live conversation (released), but state carries a last-known usage —
+    // the abort must surface that, not overwrite it.
+    const state = makeState(subagentId, {
+      usage: { inputTokens: 320, outputTokens: 80, estimatedCost: 0.004 },
+    });
+    injectFakeSubagent(manager, subagentId, state, sender, null);
+
+    manager.abort(subagentId, sender, undefined, {
+      suppressNotification: true,
+    });
+
+    const statusMsg = sent.find(
+      (m): m is Extract<ServerMessage, { type: "subagent_status_changed" }> =>
+        m.type === "subagent_status_changed",
+    );
+    expect(statusMsg!.usage).toEqual({
+      inputTokens: 320,
+      outputTokens: 80,
+      estimatedCost: 0.004,
+    });
+
+    asInternals(manager).stopSweep();
+  });
+});

package/src/api/responses/subagent-detail.ts

@@ -31,6 +31,23 @@ export const SubagentDetailEventSchema = z.object({
   toolName: z.string().optional(),
   isError: z.boolean().optional(),
   messageId: z.string().optional(),
+  /**
+   * Tool-call id — the `tool_use.id` on a tool-call event and the referencing
+   * `tool_use_id` on its tool-result event, in the daemon's canonical
+   * content-block format. That format is provider-agnostic: every provider
+   * (Anthropic, OpenAI, Gemini, …) normalizes its native tool calls into these
+   * `tool_use`/`tool_result` blocks (see `providers/types.ts`), so this id is
+   * present regardless of which model produced the call. Lets the web client
+   * pair a result with its call and key the nested tool-detail view, so tool
+   * pills on reloaded/history subagents are clickable (not just live ones).
+   */
+  toolUseId: z.string().optional(),
+  /**
+   * Raw tool input object on tool-call events. (`content` also carries a
+   * JSON-stringified copy for back-compat / label derivation.) Surfaced in the
+   * tool-detail view's input section.
+   */
+  input: z.record(z.string(), z.unknown()).optional(),
 });
 
 export type SubagentDetailEvent = z.infer<typeof SubagentDetailEventSchema>;

package/src/runtime/routes/subagents-routes.ts

@@ -39,6 +39,8 @@ export interface SubagentDetailResult {
     toolName?: string;
     isError?: boolean;
     messageId?: string;
+    toolUseId?: string;
+    input?: Record<string, unknown>;
   }>;
 }
 
@@ -112,6 +114,8 @@ export function parseSubagentMessages(
           type: "tool_use",
           content: JSON.stringify(input),
           toolName: name,
+          toolUseId: id || undefined,
+          input,
         });
         if (id) pendingTools.set(id, name);
       } else if (
@@ -147,6 +151,7 @@ export function parseSubagentMessages(
           content: resultContent,
           toolName: toolName ?? "unknown",
           isError,
+          toolUseId: toolUseId || undefined,
         });
       }
     }

package/src/subagent/manager.ts

@@ -553,6 +553,15 @@ export class SubagentManager {
       ),
     );
     managed.state.completedAt = Date.now();
+    // Capture the conversation's latest usage before emitting the terminal
+    // status. `subagent_status_changed` ships `state.usage`, and the abort path
+    // (unlike the completion/failure paths, which sync at agent-loop exit) would
+    // otherwise send the {0,0,0} init usage — zeroing the client's token counts
+    // even though those tokens were already spent. `usageStats` accrues per LLM
+    // turn (see conversation-usage.ts), so this is the most recent total.
+    if (managed.conversation) {
+      managed.state.usage = { ...managed.conversation.usageStats };
+    }
     if (parentSendToClient) {
       // Route the status update through the stored parent sender so the
       // owning conversation's UI chip updates, even when the abort comes from a