core: persist v2 tool metadata

Author: thdxr

packages/opencode/src/v2/session-message-updater.ts

@@ -49,15 +49,15 @@ export function update<Result>(adapter: Adapter<Result>, event: SessionEvent.Eve
 
   const latestTool = (assistant: DraftAssistant | undefined, callID?: string) =>
     assistant?.content.findLast(
-      (item): item is DraftTool => item.type === "tool" && (callID === undefined || item.callID === callID),
+      (item): item is DraftTool => item.type === "tool" && (callID === undefined || item.id === callID),
     )
 
   const latestText = (assistant: DraftAssistant | undefined) =>
     assistant?.content.findLast((item): item is DraftText => item.type === "text")
 
   const latestReasoning = (assistant: DraftAssistant | undefined, reasoningID: string) =>
     assistant?.content.findLast(
-      (item): item is DraftReasoning => item.type === "reasoning" && item.reasoningID === reasoningID,
+      (item): item is DraftReasoning => item.type === "reasoning" && item.id === reasoningID,
     )
 
   SessionEvent.All.match(event, {
@@ -128,7 +128,7 @@ export function update<Result>(adapter: Adapter<Result>, event: SessionEvent.Eve
           produce(currentAssistant, (draft) => {
             draft.content.push({
               type: "tool",
-              callID: event.data.callID,
+              id: event.data.callID,
               name: event.data.name,
               time: {
                 created: event.data.timestamp,
@@ -160,6 +160,7 @@ export function update<Result>(adapter: Adapter<Result>, event: SessionEvent.Eve
           produce(currentAssistant, (draft) => {
             const match = latestTool(draft, event.data.callID)
             if (match) {
+              match.provider = event.data.provider
               match.time.ran = event.data.timestamp
               match.state = {
                 status: "running",
@@ -191,6 +192,8 @@ export function update<Result>(adapter: Adapter<Result>, event: SessionEvent.Eve
           produce(currentAssistant, (draft) => {
             const match = latestTool(draft, event.data.callID)
             if (match && match.state.status === "running") {
+              match.provider = event.data.provider
+              match.time.completed = event.data.timestamp
               match.state = {
                 status: "completed",
                 input: match.state.input,
@@ -208,6 +211,8 @@ export function update<Result>(adapter: Adapter<Result>, event: SessionEvent.Eve
           produce(currentAssistant, (draft) => {
             const match = latestTool(draft, event.data.callID)
             if (match && match.state.status === "running") {
+              match.provider = event.data.provider
+              match.time.completed = event.data.timestamp
               match.state = {
                 status: "error",
                 error: event.data.error,
@@ -226,7 +231,7 @@ export function update<Result>(adapter: Adapter<Result>, event: SessionEvent.Eve
           produce(currentAssistant, (draft) => {
             draft.content.push({
               type: "reasoning",
-              reasoningID: event.data.reasoningID,
+              id: event.data.reasoningID,
               text: "",
             })
           }),

packages/opencode/src/v2/session-message.ts

@@ -93,8 +93,12 @@ export type ToolState = Schema.Schema.Type<typeof ToolState>
 
 export class AssistantTool extends Schema.Class<AssistantTool>("Session.Message.Assistant.Tool")({
   type: Schema.Literal("tool"),
-  callID: Schema.String,
+  id: Schema.String,
   name: Schema.String,
+  provider: Schema.Struct({
+    executed: Schema.Boolean,
+    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+  }).pipe(Schema.optional),
   state: ToolState,
   time: Schema.Struct({
     created: Schema.DateTimeUtcFromMillis,
@@ -111,7 +115,7 @@ export class AssistantText extends Schema.Class<AssistantText>("Session.Message.
 
 export class AssistantReasoning extends Schema.Class<AssistantReasoning>("Session.Message.Assistant.Reasoning")({
   type: Schema.Literal("reasoning"),
-  reasoningID: Schema.String,
+  id: Schema.String,
   text: Schema.String,
 }) {}
 

packages/opencode/test/v2/session-message-updater.test.ts

@@ -79,3 +79,61 @@ test("text ended populates assistant text content", () => {
   if (state.messages[0]?.type !== "assistant") return
   expect(state.messages[0].content).toEqual([{ type: "text", text: "hello assistant" }])
 })
+
+test("tool completion stores completed timestamp", () => {
+  const state: SessionMessageUpdater.MemoryState = { messages: [] }
+  const sessionID = SessionID.make("session")
+  const callID = "call"
+
+  SessionMessageUpdater.update(SessionMessageUpdater.memory(state), {
+    type: "session.next.step.started",
+    data: {
+      id: SessionEvent.ID.create(),
+      sessionID,
+      timestamp: DateTime.makeUnsafe(1),
+      agent: "build",
+      model: { id: "model", providerID: "provider" },
+    },
+  } satisfies SessionEvent.Event)
+
+  SessionMessageUpdater.update(SessionMessageUpdater.memory(state), {
+    type: "session.next.tool.input.started",
+    data: {
+      sessionID,
+      timestamp: DateTime.makeUnsafe(2),
+      callID,
+      name: "bash",
+    },
+  } satisfies SessionEvent.Event)
+
+  SessionMessageUpdater.update(SessionMessageUpdater.memory(state), {
+    type: "session.next.tool.called",
+    data: {
+      sessionID,
+      timestamp: DateTime.makeUnsafe(3),
+      callID,
+      tool: "bash",
+      input: { command: "pwd" },
+      provider: { executed: true, metadata: { source: "provider" } },
+    },
+  } satisfies SessionEvent.Event)
+
+  SessionMessageUpdater.update(SessionMessageUpdater.memory(state), {
+    type: "session.next.tool.success",
+    data: {
+      sessionID,
+      timestamp: DateTime.makeUnsafe(4),
+      callID,
+      structured: {},
+      content: [{ type: "text", text: "/tmp" }],
+      provider: { executed: true, metadata: { status: "done" } },
+    },
+  } satisfies SessionEvent.Event)
+
+  expect(state.messages[0]?.type).toBe("assistant")
+  if (state.messages[0]?.type !== "assistant") return
+  expect(state.messages[0].content[0]?.type).toBe("tool")
+  if (state.messages[0].content[0]?.type !== "tool") return
+  expect(state.messages[0].content[0].time.completed).toEqual(DateTime.makeUnsafe(4))
+  expect(state.messages[0].content[0].provider).toEqual({ executed: true, metadata: { status: "done" } })
+})