clanka 0.7.2 → 0.7.3

package/package.json

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

package/src/Agent.test.ts

@@ -1,4 +1,7 @@
 import { assert, describe, it } from "@effect/vitest"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import * as FileSystem from "effect/FileSystem"
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient"
 import * as Effect from "effect/Effect"
 import * as Duration from "effect/Duration"
 import * as Exit from "effect/Exit"
@@ -404,6 +407,121 @@ const assertCompactedShape = (
   return prompt.content.slice(2)
 }
 
+const localExecutorLayer = Layer.unwrap(
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const directory = yield* fs.makeTempDirectoryScoped()
+    return AgentExecutor.layerLocal({ directory })
+  }),
+).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer)))
+
+const invalidCompletions = [
+  'taskComplete({ output: "done" })',
+  "taskComplete()",
+  "taskComplete(undefined)",
+  "taskComplete(null)",
+  "taskComplete(42)",
+  "taskComplete(true)",
+  'taskComplete(["done"])',
+  'taskComplete({ summary: "done" })',
+]
+
+it.layer(localExecutorLayer, { excludeTestServices: true })(
+  "taskComplete through the real VM executor",
+  (it) => {
+    for (const summary of ["done", "", "First line\nSecond line"]) {
+      it.effect(`finishes with string summary ${JSON.stringify(summary)}`, () =>
+        AgentExecutor.AgentExecutor.use((executor) =>
+          runAgentCollect({
+            conversationMode: false,
+            executor,
+            respond: (_call, index) =>
+              index === 0
+                ? Stream.fromIterable([
+                    toolCall(
+                      "complete",
+                      `await taskComplete(${JSON.stringify(summary)})`,
+                    ),
+                  ])
+                : Stream.die("completion must not require another model call"),
+          }).pipe(
+            Effect.map(({ exit, calls }) => {
+              assert.deepStrictEqual(exit, Exit.succeed(summary))
+              assert.strictEqual(calls.length, 1)
+            }),
+          ),
+        ),
+      )
+    }
+
+    for (const invocation of invalidCompletions) {
+      it.effect(`rejects ${invocation} without completing`, () =>
+        AgentExecutor.AgentExecutor.use((executor) =>
+          Effect.gen(function* () {
+            const summaries: Array<string> = []
+            const output = yield* executor
+              .execute({
+                script: `try { await ${invocation}; console.log("ACCEPTED") } catch (error) { console.log("REJECTED:", String(error)) } console.log("SCRIPT_SURVIVED")`,
+                onTaskComplete: (summary) =>
+                  Effect.sync(() => {
+                    summaries.push(summary)
+                  }),
+                onSubagent: () => Effect.succeed(""),
+                onImage: () => Effect.void,
+              })
+              .pipe(Stream.mkString)
+            assert.deepStrictEqual(
+              summaries,
+              [],
+              "invalid input must not reach TaskCompleter",
+            )
+            assert.include(output, "REJECTED:")
+            assert.match(output, /string/i)
+            assert.include(output, "SCRIPT_SURVIVED")
+            assert.notInclude(output, "ACCEPTED")
+          }),
+        ),
+      )
+
+      it.effect(
+        `survives ${invocation} and completes on the next model call`,
+        () =>
+          AgentExecutor.AgentExecutor.use((executor) =>
+            runAgentCollect({
+              conversationMode: false,
+              executor,
+              respond: (_call, index) => {
+                switch (index) {
+                  case 0:
+                    return Stream.fromIterable([
+                      toolCall("invalid", `await ${invocation}`),
+                    ])
+                  case 1:
+                    return Stream.fromIterable([
+                      toolCall("retry", 'await taskComplete("recovered")'),
+                    ])
+                  default:
+                    return Stream.die("unexpected model call after completion")
+                }
+              },
+            }).pipe(
+              Effect.map(({ exit, calls }) => {
+                assert.deepStrictEqual(exit, Exit.succeed("recovered"))
+                assert.strictEqual(calls.length, 2)
+                const [result] = toolResults(calls[1]!.prompt)
+                assert.isDefined(
+                  result,
+                  "the model must receive the recoverable tool error",
+                )
+                assert.match(String(result!.result), /string/i)
+              }),
+            ),
+          ),
+      )
+    }
+  },
+)
+
 // --- tests -------------------------------------------------------------------
 
 describe("Agent execute output cap", () => {

package/src/AgentTools.ts

@@ -273,6 +273,7 @@ export const AgentTools = Toolkit.make(
       identifier: "output",
     }),
     dependencies: [TaskCompleter],
+    failure: Schema.String,
   }),
 )
 
@@ -722,7 +723,14 @@ export const AgentToolHandlersNoDeps = AgentToolsWithSearch.toLayer(
 
 ${prompt}`)
       }, Effect.orDie),
-      taskComplete: Effect.fn("AgentTools.taskComplete")(function* (message) {
+      taskComplete: Effect.fn("AgentTools.taskComplete")(function* (
+        message: unknown,
+      ) {
+        if (typeof message !== "string") {
+          return yield* Effect.fail(
+            'taskComplete requires a string argument. Pass your final output directly, for example: taskComplete("done").',
+          )
+        }
         const deferred = yield* TaskCompleter
         yield* deferred(message)
       }),