clanka 0.7.7 → 0.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clanka",
   "type": "module",
-  "version": "0.7.7",
+  "version": "0.8.0",
   "publishConfig": {
     "access": "public"
   },

package/src/Acp.test.ts

@@ -154,6 +154,108 @@ describe("Acp", () => {
     ),
   )
 
+  it.effect("reports cache usage in the ACP usage extension", () =>
+    withStore(
+      Effect.scoped(
+        Effect.gen(function* () {
+          const server = yield* makeServer(() =>
+            parts(
+              { type: "text-start", id: "1" },
+              { type: "text-delta", id: "1", delta: "done" },
+              { type: "text-end", id: "1" },
+              {
+                type: "finish",
+                reason: "stop",
+                usage: {
+                  inputTokens: {
+                    total: 120,
+                    cacheRead: 30,
+                    cacheWrite: 6,
+                  },
+                  outputTokens: { total: 12 },
+                },
+              },
+            ),
+          )
+          const created = yield* server.request(1, "session/new", {
+            cwd: "/tmp",
+          })
+          const sessionId: string = created.result.sessionId
+
+          yield* server.request(2, "session/prompt", {
+            sessionId,
+            prompt: [{ type: "text", text: "hello" }],
+          })
+
+          assert.deepStrictEqual(
+            server
+              .updates(sessionId)
+              .find((update) => update.sessionUpdate === "usage_update"),
+            {
+              sessionUpdate: "usage_update",
+              usage: {
+                inputTokens: 120,
+                outputTokens: 12,
+                cacheRead: 30,
+                cacheWrite: 6,
+              },
+            },
+          )
+        }),
+      ),
+    ),
+  )
+
+  it.effect(
+    "reports zero cache usage when the provider omits cache fields",
+    () =>
+      withStore(
+        Effect.scoped(
+          Effect.gen(function* () {
+            const server = yield* makeServer(() =>
+              parts(
+                { type: "text-start", id: "1" },
+                { type: "text-delta", id: "1", delta: "done" },
+                { type: "text-end", id: "1" },
+                {
+                  type: "finish",
+                  reason: "stop",
+                  usage: {
+                    inputTokens: { total: 120 },
+                    outputTokens: { total: 12 },
+                  },
+                },
+              ),
+            )
+            const created = yield* server.request(1, "session/new", {
+              cwd: "/tmp",
+            })
+            const sessionId: string = created.result.sessionId
+
+            yield* server.request(2, "session/prompt", {
+              sessionId,
+              prompt: [{ type: "text", text: "hello" }],
+            })
+
+            assert.deepStrictEqual(
+              server
+                .updates(sessionId)
+                .find((update) => update.sessionUpdate === "usage_update"),
+              {
+                sessionUpdate: "usage_update",
+                usage: {
+                  inputTokens: 120,
+                  outputTokens: 12,
+                  cacheRead: 0,
+                  cacheWrite: 0,
+                },
+              },
+            )
+          }),
+        ),
+      ),
+  )
+
   it.effect("applies model and thought-level changes to the next turn", () =>
     withStore(
       Effect.scoped(

package/src/Acp.ts

@@ -655,6 +655,8 @@ export const make = Effect.fnUntraced(function* <RAgent, RModel>(
             usage: {
               inputTokens: part.inputTokens,
               outputTokens: part.outputTokens,
+              cacheRead: part.cacheRead,
+              cacheWrite: part.cacheWrite,
             },
           })
         case "ErrorRetry":

package/src/Agent.test.ts

@@ -18,7 +18,7 @@ import type * as Response from "effect/unstable/ai/Response"
 import * as ResponseIdTracker from "effect/unstable/ai/ResponseIdTracker"
 import * as Agent from "./Agent.ts"
 import * as AgentExecutor from "./AgentExecutor.ts"
-import type * as AgentOutput from "./AgentOutput.ts"
+import * as AgentOutput from "./AgentOutput.ts"
 import * as Compaction from "./Compaction.ts"
 
 const capabilities = new AgentExecutor.Capabilities({
@@ -310,11 +310,19 @@ const toolCall = (id: string, script: string): Response.StreamPartEncoded => ({
 const finish = (
   contextTokens: number,
   reason: "stop" | "tool-calls" = "tool-calls",
+  cache: {
+    readonly read?: number | undefined
+    readonly write?: number | undefined
+  } = {},
 ): Response.StreamPartEncoded => ({
   type: "finish",
   reason,
   usage: {
-    inputTokens: { total: contextTokens },
+    inputTokens: {
+      total: contextTokens,
+      cacheRead: cache.read,
+      cacheWrite: cache.write,
+    },
     outputTokens: { total: 10 },
   },
 })
@@ -524,6 +532,50 @@ it.layer(localExecutorLayer, { excludeTestServices: true })(
 
 // --- tests -------------------------------------------------------------------
 
+describe("Agent usage", () => {
+  it.effect("accumulates provider cache reads and writes", () =>
+    Effect.gen(function* () {
+      const { exit, outputs } = yield* runAgentCollect({
+        executor: makeExecutor(() => Stream.succeed("done")),
+        respond: (_call, index) => {
+          switch (index) {
+            case 0:
+              return Stream.fromIterable([
+                toolCall("call-1", "console.log('done')"),
+                finish(100, "tool-calls", { read: 25, write: 5 }),
+              ])
+            case 1:
+              return Stream.fromIterable([
+                ...text("complete"),
+                finish(60, "stop", { read: 15, write: 3 }),
+              ])
+            default:
+              return Stream.die(`unexpected model call #${index}`)
+          }
+        },
+      })
+
+      assert.deepStrictEqual(exit, Exit.succeed("complete"))
+      assert.deepStrictEqual(outputsOfTag(outputs, "Usage"), [
+        new AgentOutput.Usage({
+          contextTokens: 100,
+          inputTokens: 100,
+          outputTokens: 10,
+          cacheRead: 25,
+          cacheWrite: 5,
+        }),
+        new AgentOutput.Usage({
+          contextTokens: 60,
+          inputTokens: 160,
+          outputTokens: 20,
+          cacheRead: 40,
+          cacheWrite: 8,
+        }),
+      ])
+    }),
+  )
+})
+
 describe("Agent execute output cap", () => {
   const dump = "DUMP-HEAD " + filler("log", 40_000) + " DUMP-TAIL"
 

package/src/Agent.ts

@@ -211,6 +211,8 @@ ${content}
     const output = yield* Queue.make<Output, AgentFinished | AiError.AiError>()
     let inputTokens = 0
     let outputTokens = 0
+    let cacheRead = 0
+    let cacheWrite = 0
     const prompt = opts.disableHistory ? MutableRef.make(Prompt.empty) : history
 
     MutableRef.update(prompt, Prompt.concat(opts.prompt))
@@ -536,6 +538,12 @@ ${content}
                   if (usage.outputTokens.total !== undefined) {
                     outputTokens += usage.outputTokens.total
                   }
+                  if (usage.inputTokens.cacheRead !== undefined) {
+                    cacheRead += usage.inputTokens.cacheRead
+                  }
+                  if (usage.inputTokens.cacheWrite !== undefined) {
+                    cacheWrite += usage.inputTokens.cacheWrite
+                  }
                   if (usage.inputTokens.total !== undefined) {
                     lastContextTokens = usage.inputTokens.total
                     inputTokens += usage.inputTokens.total
@@ -545,6 +553,8 @@ ${content}
                         contextTokens: usage.inputTokens.total,
                         inputTokens,
                         outputTokens,
+                        cacheRead,
+                        cacheWrite,
                       }),
                     })
                   }

package/src/AgentOutput.ts

@@ -87,6 +87,14 @@ export class Usage extends Schema.TaggedClass<Usage>()("Usage", {
   contextTokens: Schema.Number,
   inputTokens: Schema.Number,
   outputTokens: Schema.Number,
+  /**
+   * Cumulative cache reads included in `inputTokens`. Zero is not proof of no cache activity.
+   */
+  cacheRead: Schema.Number,
+  /**
+   * Cumulative cache writes included in `inputTokens`. Zero is not proof of no cache activity.
+   */
+  cacheWrite: Schema.Number,
 }) {}
 
 /**