clanka 0.8.2 → 0.8.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clanka",
   "type": "module",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "publishConfig": {
     "access": "public"
   },
@@ -37,24 +37,24 @@
     "turndown": "^7.2.4"
   },
   "peerDependencies": {
-    "@effect/ai-openai": ">=4.0.0-rc.115 <4.0.1",
-    "@effect/ai-openai-compat": ">=4.0.0-rc.115 <4.0.1",
-    "@effect/platform-node": ">=4.0.0-rc.115 <4.0.1",
-    "@effect/sql-sqlite-node": ">=4.0.0-rc.115 <4.0.1",
-    "effect": ">=4.0.0-rc.115 <4.0.1"
+    "@effect/ai-openai": "^4.0.0",
+    "@effect/ai-openai-compat": "^4.0.0",
+    "@effect/platform-node": "^4.0.0",
+    "@effect/sql-sqlite-node": "^4.0.0",
+    "effect": "^4.0.0"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^1.0.1",
     "@changesets/cli": "^3.0.3",
-    "@effect/ai-openai": "https://pkg.pr.new/Effect-TS/effect/@effect/ai-openai@b3032f0",
-    "@effect/ai-openai-compat": "https://pkg.pr.new/Effect-TS/effect/@effect/ai-openai-compat@b3032f0",
-    "@effect/platform-node": "https://pkg.pr.new/Effect-TS/effect/@effect/platform-node@b3032f0",
-    "@effect/sql-sqlite-node": "https://pkg.pr.new/Effect-TS/effect/@effect/sql-sqlite-node@b3032f0",
+    "@effect/ai-openai": "4.0.0",
+    "@effect/ai-openai-compat": "4.0.0",
+    "@effect/platform-node": "4.0.0",
+    "@effect/sql-sqlite-node": "4.0.0",
     "@effect/tsgo": "0.45.0",
-    "@effect/vitest": "https://pkg.pr.new/Effect-TS/effect/@effect/vitest@b3032f0",
+    "@effect/vitest": "4.0.0",
     "@types/node": "^26.1.1",
     "@types/turndown": "^5.0.6",
-    "effect": "https://pkg.pr.new/Effect-TS/effect/effect@b3032f0",
+    "effect": "4.0.0",
     "husky": "^9.1.7",
     "lint-staged": "^17.5.1",
     "oxlint": "^1.83.0",

package/src/Acp.test.ts

@@ -169,6 +169,7 @@ describe("Acp", () => {
                 usage: {
                   inputTokens: {
                     total: 120,
+                    uncached: 84,
                     cacheRead: 30,
                     cacheWrite: 6,
                   },
@@ -194,10 +195,10 @@ describe("Acp", () => {
             {
               sessionUpdate: "usage_update",
               usage: {
-                inputTokens: 120,
+                inputTokens: 84,
                 outputTokens: 12,
-                cacheRead: 30,
-                cacheWrite: 6,
+                cachedReadTokens: 30,
+                cachedWriteTokens: 6,
               },
             },
           )
@@ -246,8 +247,8 @@ describe("Acp", () => {
                 usage: {
                   inputTokens: 120,
                   outputTokens: 12,
-                  cacheRead: 0,
-                  cacheWrite: 0,
+                  cachedReadTokens: 0,
+                  cachedWriteTokens: 0,
                 },
               },
             )

package/src/Acp.ts

@@ -653,10 +653,13 @@ export const make = Effect.fnUntraced(function* <RAgent, RModel>(
           return update(session.id, {
             sessionUpdate: "usage_update",
             usage: {
-              inputTokens: part.inputTokens,
+              inputTokens: Math.max(
+                0,
+                part.inputTokens - part.cacheRead - part.cacheWrite,
+              ),
               outputTokens: part.outputTokens,
-              cacheRead: part.cacheRead,
-              cacheWrite: part.cacheWrite,
+              cachedReadTokens: part.cacheRead,
+              cachedWriteTokens: part.cacheWrite,
             },
           })
         case "ErrorRetry":

package/src/AgentExecutor.test.ts

@@ -0,0 +1,133 @@
+import { assert, describe, it } from "@effect/vitest"
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
+import * as Layer from "effect/Layer"
+import * as Stream from "effect/Stream"
+import * as HttpServer from "effect/http/HttpServer"
+import * as RpcClient from "effect/rpc/RpcClient"
+import * as RpcSerialization from "effect/rpc/RpcSerialization"
+import * as RpcServer from "effect/rpc/RpcServer"
+import * as AgentExecutor from "./AgentExecutor.ts"
+
+const withRpc = <A, E, R>(
+  f: (
+    executor: AgentExecutor.AgentExecutor["Service"],
+  ) => Effect.Effect<A, E, R>,
+) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const directory = yield* fs.makeTempDirectoryScoped()
+    const { protocol, httpEffect } =
+      yield* RpcServer.makeProtocolWithHttpEffect()
+    yield* Layer.build(
+      AgentExecutor.layerRpcServer({ directory }).pipe(
+        Layer.provide(Layer.succeed(RpcServer.Protocol, protocol)),
+      ),
+    )
+    yield* HttpServer.serveEffect(httpEffect)
+    return yield* Effect.gen(function* () {
+      const executor = yield* AgentExecutor.AgentExecutor
+      return yield* f(executor).pipe(Effect.timeout("2 seconds"))
+    }).pipe(
+      Effect.provide(
+        AgentExecutor.layerRpc.pipe(
+          Layer.provide(RpcClient.layerProtocolHttp({ url: "" })),
+        ),
+      ),
+    )
+  }).pipe(
+    Effect.provide(
+      Layer.mergeAll(
+        RpcSerialization.layerNdjson,
+        NodeHttpServer.layerTest,
+        NodeServices.layer,
+      ),
+    ),
+    Effect.scoped,
+  )
+
+describe("RPC subagent executor", () => {
+  it.live("routes concurrent delegates to their originating scripts", () =>
+    withRpc((executor) =>
+      Effect.gen(function* () {
+        const firstStarted = yield* Deferred.make<void>()
+        const secondStarted = yield* Deferred.make<void>()
+        const outputs = yield* Effect.all(
+          [
+            executor
+              .execute({
+                script: 'console.log("first:" + await delegate("first"))',
+                onTaskComplete: () => Effect.void,
+                onImage: () => Effect.void,
+                onSubagent: (prompt) =>
+                  Effect.gen(function* () {
+                    assert.isTrue(prompt.endsWith("\n\nfirst"))
+                    yield* Deferred.succeed(firstStarted, undefined)
+                    yield* Deferred.await(secondStarted)
+                    return "first-output"
+                  }),
+              })
+              .pipe(Stream.runCollect),
+            executor
+              .execute({
+                script: 'console.log("second:" + await delegate("second"))',
+                onTaskComplete: () => Effect.void,
+                onImage: () => Effect.void,
+                onSubagent: (prompt) =>
+                  Effect.gen(function* () {
+                    assert.isTrue(prompt.endsWith("\n\nsecond"))
+                    yield* Deferred.succeed(secondStarted, undefined)
+                    yield* Deferred.await(firstStarted)
+                    return "second-output"
+                  }),
+              })
+              .pipe(Stream.runCollect),
+          ],
+          { concurrency: "unbounded" },
+        )
+        assert.isTrue(outputs[0].join("").endsWith("first:first-output\n"))
+        assert.isTrue(outputs[1].join("").endsWith("second:second-output\n"))
+      }),
+    ),
+  )
+
+  it.live(
+    "completes nested delegation while the parent stream is waiting",
+    () =>
+      withRpc((executor) =>
+        Effect.gen(function* () {
+          const output = yield* executor
+            .execute({
+              script: 'console.log("parent:" + await delegate("outer"))',
+              onTaskComplete: () => Effect.void,
+              onImage: () => Effect.void,
+              onSubagent: (prompt) =>
+                Effect.gen(function* () {
+                  assert.isTrue(prompt.endsWith("\n\nouter"))
+                  const childOutput = yield* executor
+                    .execute({
+                      script: 'console.log("child:" + await delegate("inner"))',
+                      onTaskComplete: () => Effect.void,
+                      onImage: () => Effect.void,
+                      onSubagent: (innerPrompt) =>
+                        Effect.sync(() => {
+                          assert.isTrue(innerPrompt.endsWith("\n\ninner"))
+                          return "inner-output"
+                        }),
+                    })
+                    .pipe(Stream.runCollect)
+                  assert.isTrue(
+                    childOutput.join("").endsWith("child:inner-output\n"),
+                  )
+                  return childOutput.join("").trim().split("\n").at(-1)!
+                }),
+            })
+            .pipe(Stream.runCollect)
+          assert.isTrue(output.join("").endsWith("parent:child:inner-output\n"))
+        }),
+      ),
+  )
+})

package/src/AgentExecutor.ts

@@ -422,6 +422,7 @@ export const layerRpcServer = <Toolkit extends Toolkit.Any = never>(options: {
             number,
             (effect: Effect.Effect<string>) => void
           >()
+          let subagentId = 0
 
           return Rpcs.of({
             capabilities: () => local.capabilities,
@@ -438,8 +439,6 @@ export const layerRpcServer = <Toolkit extends Toolkit.Any = never>(options: {
                 typeof ExecuteOutput.Type,
                 Cause.Done
               >()
-              let subagentId = 0
-
               yield* pipe(
                 local.execute({
                   script,