clanka 0.8.3 → 0.8.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clanka",
   "type": "module",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "publishConfig": {
     "access": "public"
   },
@@ -25,10 +25,10 @@
     "url": "https://github.com/Effectful-Tech/clanka.git"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@modelcontextprotocol/sdk": "^1.32.0",
     "@silvia-odwyer/photon-node": "^0.3.4",
     "@vscode/ripgrep": "^1.18.0",
-    "chalk": "^6.0.0",
+    "chalk": "^6.0.1",
     "glob": "^13.0.6",
     "sqlite-vec": "0.1.9",
     "tree-sitter": "^0.21.1",
@@ -37,31 +37,31 @@
     "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/tsgo": "0.45.0",
-    "@effect/vitest": "https://pkg.pr.new/Effect-TS/effect/@effect/vitest@b3032f0",
-    "@types/node": "^26.1.1",
+    "@effect/ai-openai": "4.0.1",
+    "@effect/ai-openai-compat": "4.0.1",
+    "@effect/platform-node": "4.0.0",
+    "@effect/sql-sqlite-node": "4.0.1",
+    "@effect/tsgo": "0.48.0",
+    "@effect/vitest": "4.0.1",
+    "@types/node": "^26.6.4",
     "@types/turndown": "^5.0.6",
-    "effect": "https://pkg.pr.new/Effect-TS/effect/effect@b3032f0",
+    "effect": "4.0.1",
     "husky": "^9.1.7",
-    "lint-staged": "^17.5.1",
-    "oxlint": "^1.83.0",
-    "prettier": "^3.9.7",
+    "lint-staged": "^17.6.0",
+    "oxlint": "^1.86.0",
+    "prettier": "^3.9.9",
     "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
-    "vitest": "^5.0.1"
+    "vitest": "^5.0.3"
   },
   "lint-staged": {
     "*.{ts,tsx}": [

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,

package/src/AgentSkills.test.ts

@@ -106,6 +106,7 @@ const withLocalExecutor = <A, E, R>(
             HERMES_HOME: process.env.HERMES_HOME,
           }
           process.env.HOME = roots.home
+          // @ts-expect-error
           if (hermesHome === undefined) delete process.env.HERMES_HOME
           else process.env.HERMES_HOME = hermesHome
           return previous

package/src/AgentTools.ts

@@ -489,7 +489,7 @@ export const AgentToolHandlersNoDeps = AgentToolsWithSearch.toLayer(
         )
       }),
       bash: Effect.fn("AgentTools.bash")(function* (options) {
-        const timeoutMs = Math.min(options.timeoutMs ?? 120_000, 240_000)
+        const timeoutMs = Math.min(options.timeoutMs ?? 600_000, 600_000)
         yield* Effect.logInfo(`Calling "bash"`).pipe(
           Effect.annotateLogs({
             ...options,
@@ -539,6 +539,7 @@ export const AgentToolHandlersNoDeps = AgentToolsWithSearch.toLayer(
       applyPatch: Effect.fn("AgentTools.applyPatch")(function* (patchText) {
         yield* Effect.logInfo(`Calling "applyPatch"`)
         const cwd = yield* CurrentDirectory
+        // oxlint-disable-next-line unicorn/consistent-function-scoping
         const fail = (path: string, reason: "delete" | "update") =>
           Effect.fail(
             new ApplyPatchError({

package/src/Compaction.test.ts

@@ -454,6 +454,7 @@ describe("Compaction.isContextLengthError", () => {
 
 describe("Compaction.split", () => {
   // Each execute result is ~8k chars => ~2k tokens per tool message.
+  // oxlint-disable-next-line unicorn/consistent-function-scoping
   const dump = (i: number) => filler(`dump${i}`, 8_000)
   const conversation = [
     user("first request"),