chore: generate

packages/opencode/src/provider/provider.ts

@@ -557,8 +557,11 @@ export namespace Provider {
 
       const metadata = iife(() => {
         if (input.options?.metadata) return input.options.metadata
-        try { return JSON.parse(input.options?.headers?.["cf-aig-metadata"]) }
+        try {
-        catch { return undefined }
+          return JSON.parse(input.options?.headers?.["cf-aig-metadata"])
+        } catch {
+          return undefined
+        }
       })
       const opts = {
         metadata,
@@ -572,7 +575,7 @@ export namespace Provider {
         accountId,
         gateway,
         apiKey: apiToken,
-        ...(Object.values(opts).some(v => v !== undefined) ? { options: opts } : {}),
+        ...(Object.values(opts).some((v) => v !== undefined) ? { options: opts } : {}),
       })
       const unified = createUnified()
 

packages/opencode/test/session/session.test.ts

@@ -73,66 +73,70 @@ describe("session.started event", () => {
 })
 
 describe("step-finish token propagation via Bus event", () => {
-  test("non-zero tokens propagate through PartUpdated event", async () => {
+  test(
-    await Instance.provide({
+    "non-zero tokens propagate through PartUpdated event",
-      directory: projectRoot,
+    async () => {
-      fn: async () => {
+      await Instance.provide({
-        const session = await Session.create({})
+        directory: projectRoot,
+        fn: async () => {
+          const session = await Session.create({})
 
-        const messageID = Identifier.ascending("message")
+          const messageID = Identifier.ascending("message")
-        await Session.updateMessage({
+          await Session.updateMessage({
-          id: messageID,
+            id: messageID,
-          sessionID: session.id,
+            sessionID: session.id,
-          role: "user",
+            role: "user",
-          time: { created: Date.now() },
+            time: { created: Date.now() },
-          agent: "user",
+            agent: "user",
-          model: { providerID: "test", modelID: "test" },
+            model: { providerID: "test", modelID: "test" },
-          tools: {},
+            tools: {},
-          mode: "",
+            mode: "",
-        } as unknown as MessageV2.Info)
+          } as unknown as MessageV2.Info)
 
-        let received: MessageV2.Part | undefined
+          let received: MessageV2.Part | undefined
-        const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, (event) => {
+          const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, (event) => {
-          received = event.properties.part
+            received = event.properties.part
-        })
+          })
 
-        const tokens = {
+          const tokens = {
-          total: 1500,
+            total: 1500,
-          input: 500,
+            input: 500,
-          output: 800,
+            output: 800,
-          reasoning: 200,
+            reasoning: 200,
-          cache: { read: 100, write: 50 },
+            cache: { read: 100, write: 50 },
-        }
+          }
 
-        const partInput = {
+          const partInput = {
-          id: Identifier.ascending("part"),
+            id: Identifier.ascending("part"),
-          messageID,
+            messageID,
-          sessionID: session.id,
+            sessionID: session.id,
-          type: "step-finish" as const,
+            type: "step-finish" as const,
-          reason: "stop",
+            reason: "stop",
-          cost: 0.005,
+            cost: 0.005,
-          tokens,
+            tokens,
-        }
+          }
 
-        await Session.updatePart(partInput)
+          await Session.updatePart(partInput)
 
-        await new Promise((resolve) => setTimeout(resolve, 100))
+          await new Promise((resolve) => setTimeout(resolve, 100))
 
-        expect(received).toBeDefined()
+          expect(received).toBeDefined()
-        expect(received!.type).toBe("step-finish")
+          expect(received!.type).toBe("step-finish")
-        const finish = received as MessageV2.StepFinishPart
+          const finish = received as MessageV2.StepFinishPart
-        expect(finish.tokens.input).toBe(500)
+          expect(finish.tokens.input).toBe(500)
-        expect(finish.tokens.output).toBe(800)
+          expect(finish.tokens.output).toBe(800)
-        expect(finish.tokens.reasoning).toBe(200)
+          expect(finish.tokens.reasoning).toBe(200)
-        expect(finish.tokens.total).toBe(1500)
+          expect(finish.tokens.total).toBe(1500)
-        expect(finish.tokens.cache.read).toBe(100)
+          expect(finish.tokens.cache.read).toBe(100)
-        expect(finish.tokens.cache.write).toBe(50)
+          expect(finish.tokens.cache.write).toBe(50)
-        expect(finish.cost).toBe(0.005)
+          expect(finish.cost).toBe(0.005)
-        expect(received).not.toBe(partInput)
+          expect(received).not.toBe(partInput)
 
-        unsub()
+          unsub()
-        await Session.remove(session.id)
+          await Session.remove(session.id)
-      },
+        },
-    })
+      })
-  }, { timeout: 30000 })
+    },
+    { timeout: 30000 },
+  )
 })