clanka 0.1.11 → 0.1.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clanka",
   "type": "module",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "publishConfig": {
     "access": "public"
   },
@@ -23,35 +23,35 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "@vscode/ripgrep": "^1.17.0",
+    "@vscode/ripgrep": "^1.17.1",
     "chalk": "^5.6.2",
     "glob": "^13.0.6",
     "turndown": "^7.2.2"
   },
   "peerDependencies": {
-    "@effect/ai-openai": "4.0.0-beta.31",
-    "@effect/ai-openai-compat": "4.0.0-beta.31",
-    "effect": "4.0.0-beta.31"
+    "@effect/ai-openai": "4.0.0-beta.32",
+    "@effect/ai-openai-compat": "4.0.0-beta.32",
+    "effect": "4.0.0-beta.32"
   },
   "devDependencies": {
-    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/changelog-github": "^0.6.0",
     "@changesets/cli": "^2.29.8",
-    "@effect/ai-openai": "4.0.0-beta.31",
-    "@effect/ai-openai-compat": "4.0.0-beta.31",
-    "@effect/language-service": "^0.75.1",
-    "@effect/platform-node": "4.0.0-beta.31",
-    "@effect/vitest": "4.0.0-beta.31",
-    "@linear/sdk": "^75.0.0",
-    "@types/node": "^25.3.5",
+    "@effect/ai-openai": "4.0.0-beta.32",
+    "@effect/ai-openai-compat": "4.0.0-beta.32",
+    "@effect/language-service": "^0.80.0",
+    "@effect/platform-node": "4.0.0-beta.32",
+    "@effect/vitest": "4.0.0-beta.32",
+    "@linear/sdk": "^77.0.0",
+    "@types/node": "^25.5.0",
     "@types/turndown": "^5.0.6",
-    "@typescript/native-preview": "7.0.0-dev.20260219.1",
-    "effect": "4.0.0-beta.31",
+    "@typescript/native-preview": "7.0.0-dev.20260315.1",
+    "effect": "4.0.0-beta.32",
     "husky": "^9.1.7",
-    "lint-staged": "^16.2.7",
-    "oxlint": "^1.49.0",
+    "lint-staged": "^16.4.0",
+    "oxlint": "^1.55.0",
     "prettier": "^3.8.1",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.0"
   },
   "lint-staged": {
     "*.{ts,tsx}": [

package/src/Agent.ts

@@ -19,7 +19,7 @@ import * as Effect from "effect/Effect"
 import * as Stream from "effect/Stream"
 import type * as Scope from "effect/Scope"
 import * as LanguageModel from "effect/unstable/ai/LanguageModel"
-import type * as AiError from "effect/unstable/ai/AiError"
+import * as AiError from "effect/unstable/ai/AiError"
 import * as ServiceMap from "effect/ServiceMap"
 import * as Option from "effect/Option"
 import { identity, pipe } from "effect/Function"
@@ -31,6 +31,7 @@ import * as Layer from "effect/Layer"
 import * as Tool from "effect/unstable/ai/Tool"
 import * as Toolkit from "effect/unstable/ai/Toolkit"
 import * as Semaphore from "effect/Semaphore"
+import * as Schedule from "effect/Schedule"
 
 /**
  * @since 1.0.0
@@ -167,7 +168,6 @@ ${content}
     >()
     let finalSummary = Option.none<string>()
 
-    const singleToolMode = modelConfig.supportsNoTools !== true
     const output = yield* Queue.make<Output, AgentFinished | AiError.AiError>()
     const prompt = opts.disableHistory ? MutableRef.make(Prompt.empty) : history
 
@@ -176,7 +176,7 @@ ${content}
     const generateSystem =
       typeof opts.system === "function" ? opts.system : defaultSystem
 
-    const toolInstructions = generateSystemTools(toolsDts, !singleToolMode)
+    const toolInstructions = generateSystemTools(toolsDts)
     let system = generateSystem({
       toolInstructions,
       agentsMd: Option.getOrElse(agentsMd, () => ""),
@@ -295,25 +295,8 @@ ${content}
       MutableRef.update(prompt, Prompt.setSystem(system))
     }
 
-    let currentScript = ""
     yield* Effect.gen(function* () {
       while (true) {
-        if (!singleToolMode && currentScript.length > 0) {
-          const result = yield* executeScript(currentScript)
-          MutableRef.update(
-            prompt,
-            Prompt.concat([
-              {
-                role: modelConfig.supportsAssistantPrefill
-                  ? "assistant"
-                  : "user",
-                content: `Console output from executing javascript code:\n\n${result}`,
-              },
-            ]),
-          )
-          currentScript = ""
-        }
-
         if (Option.isSome(finalSummary)) {
           yield* Queue.fail(
             output,
@@ -343,19 +326,8 @@ ${content}
         let reasoningStarted = false
         let hadReasoningDelta = false
         yield* pipe(
-          ai.streamText(
-            singleToolMode
-              ? { prompt: prompt.current, toolkit: singleTool }
-              : { prompt: prompt.current },
-          ),
+          ai.streamText({ prompt: prompt.current, toolkit: singleTool }),
           Stream.takeUntil((part) => {
-            if (
-              !singleToolMode &&
-              part.type === "text-end" &&
-              currentScript.trim().length > 0
-            ) {
-              return true
-            }
             if (
               (part.type === "text-end" || part.type === "reasoning-end") &&
               pendingMessages.size > 0
@@ -370,68 +342,10 @@ ${content}
             for (const part of parts) {
               switch (part.type) {
                 case "text-start":
-                  if (singleToolMode) {
-                    if (hadReasoningDelta) {
-                      hadReasoningDelta = false
-                      maybeSend({
-                        agentId,
-                        part: new ReasoningEnd(),
-                        release: true,
-                      })
-                    }
-                    reasoningStarted = true
-                    break
-                  }
-                  currentScript = ""
-                  break
-                case "text-delta": {
-                  if (singleToolMode) {
-                    hadReasoningDelta = true
-                    if (reasoningStarted) {
-                      reasoningStarted = false
-                      maybeSend({
-                        agentId,
-                        part: new ReasoningStart(),
-                        acquire: true,
-                      })
-                    }
-                    maybeSend({
-                      agentId,
-                      part: new ReasoningDelta({ delta: part.delta }),
-                    })
-                    break
-                  }
-                  if (currentScript === "" && part.delta.length > 0) {
-                    maybeSend({
-                      agentId,
-                      part: new ScriptStart(),
-                      acquire: true,
-                    })
-                  }
-                  maybeSend({
-                    agentId,
-                    part: new ScriptDelta({ delta: part.delta }),
-                  })
-                  currentScript += part.delta
-                  break
-                }
-                case "text-end": {
-                  if (singleToolMode) {
-                    reasoningStarted = false
-                    if (hadReasoningDelta) {
-                      hadReasoningDelta = false
-                      maybeSend({
-                        agentId,
-                        part: new ReasoningEnd(),
-                        release: true,
-                      })
-                    }
-                  }
-                  break
-                }
                 case "reasoning-start":
                   reasoningStarted = true
                   break
+                case "text-delta":
                 case "reasoning-delta":
                   hadReasoningDelta = true
                   if (reasoningStarted) {
@@ -447,6 +361,7 @@ ${content}
                     part: new ReasoningDelta({ delta: part.delta }),
                   })
                   break
+                case "text-end":
                 case "reasoning-end":
                   reasoningStarted = false
                   if (hadReasoningDelta) {
@@ -468,8 +383,12 @@ ${content}
           Effect.retry({
             while: (err) => {
               response = []
+              if (err.isRetryable) {
+                maybeSend({ agentId, part: new ErrorRetry({ error: err }) })
+              }
               return err.isRetryable
             },
+            schedule: retryPolicy,
           }),
           modelConfig.systemPromptTransform
             ? (effect) => modelConfig.systemPromptTransform!(system, effect)
@@ -479,7 +398,6 @@ ${content}
           prompt,
           Prompt.concat(Prompt.fromResponseParts(response)),
         )
-        currentScript = currentScript.trim()
       }
     }).pipe(
       Effect.provideService(ScriptExecutor, (script) => {
@@ -526,6 +444,11 @@ ${content}
   })
 })
 
+const retryPolicy = Schedule.exponential(100, 1.5).pipe(
+  Schedule.either(Schedule.spaced(5000)),
+  Schedule.jittered,
+)
+
 const defaultSystem = (options: {
   readonly toolInstructions: string
   readonly agentsMd: string | null
@@ -540,12 +463,28 @@ ${options.toolInstructions}
 ${options.agentsMd}
 `
 
-const generateSystemTools = (toolsDts: string, multi: boolean) => {
-  const toolMd = multi
-    ? generateSystemMulti(toolsDts)
-    : generateSystemSingle(toolsDts)
+const generateSystemTools = (
+  toolsDts: string,
+) => `**YOU ONLY HAVE ACCESS TO ONE TOOL** "execute", to run javascript code to do your work.
+
+- Use \`console.log\` to print any output you need.
+- Top level await is supported.
+- AVOID passing scripts into the "bash" function, and instead write javascript.
+- Do as much work as possible in a single script, using \`Promise.all\` to run multiple functions in parallel.
+- Variables **are not shared** between executions, so you must include all necessary code in each script you execute.
+
+**When you have fully completed your task**, call the "taskComplete" function with the final output.
+DO NOT output the final result without wrapping it with "taskComplete".
+Make sure every detail of the task is done before calling "taskComplete".
+
+You have the following functions available to you:
 
-  return `${toolMd}
+\`\`\`ts
+${toolsDts}
+
+/** The global Fetch API available for making HTTP requests. */
+declare const fetch: typeof globalThis.fetch
+\`\`\`
 
 For example, here is how you would read a file. First you would respond with
 javascript code that uses the "readFile" function:
@@ -562,51 +501,12 @@ console.log(JSON.parse(content))
 And then you will revieve back the console output:
 
 \`\`\`
-Console output from executing javascript code:
-
 [22:44:53.054] INFO (#47): Calling "readFile" { path: 'package.json' }
 {
   "name": "my-project",
   "version": "1.0.0"
 }
 \`\`\``
-}
-
-const generateSystemMulti = (toolsDts: string) => {
-  return `You complete your tasks by **only writing javascript code** to interact with your environment.
-
-${systemToolsCommon(toolsDts)}`
-}
-
-// oxlint-disable-next-line typescript/no-explicit-any
-const generateSystemSingle = (toolsDts: string) => {
-  return `**YOU ONLY HAVE ACCESS TO ONE TOOL** "execute", to run javascript code to do your work.
-
-${systemToolsCommon(toolsDts)}`
-}
-
-const systemToolsCommon = (
-  toolsDts: string,
-) => `- Use \`console.log\` to print any output you need.
-- Top level await is supported.
-- AVOID passing scripts into the "bash" function, and instead write javascript.
-- PREFER the "search" function over "rg" for finding information or code
-- Do as much work as possible in a single script, using \`Promise.all\` to run multiple functions in parallel.
-- Variables **are not shared** between executions, so you must include all necessary code in each script you execute.
-- Make use of the "delegate" tool to delegate exploration and small research tasks. You can delegate multiple tasks in parallel with Promise.all
-
-**When you have fully completed your task**, call the "taskComplete" function with the final output.
-DO NOT output the final result without wrapping it with "taskComplete".
-Make sure every detail of the task is done before calling "taskComplete".
-
-You have the following functions available to you:
-
-\`\`\`ts
-${toolsDts}
-
-/** The global Fetch API available for making HTTP requests. */
-declare const fetch: typeof globalThis.fetch
-\`\`\``
 
 class ScriptExecutor extends ServiceMap.Service<
   ScriptExecutor,
@@ -690,12 +590,12 @@ export const layerSubagentModel = <E, R>(
  * @category System prompts
  */
 export class AgentModelConfig extends ServiceMap.Reference<{
-  readonly systemPromptTransform?: <A, E, R>(
-    system: string,
-    effect: Effect.Effect<A, E, R>,
-  ) => Effect.Effect<A, E, R>
-  readonly supportsAssistantPrefill?: boolean | undefined
-  readonly supportsNoTools?: boolean | undefined
+  readonly systemPromptTransform?:
+    | (<A, E, R>(
+        system: string,
+        effect: Effect.Effect<A, E, R>,
+      ) => Effect.Effect<A, E, R>)
+    | undefined
 }>("clanka/Agent/SystemPromptTransform", {
   defaultValue: () => ({}),
 }) {
@@ -776,6 +676,14 @@ export class ScriptEnd extends Schema.TaggedClass<ScriptEnd>()(
   {},
 ) {}
 
+/**
+ * @since 1.0.0
+ * @category Output
+ */
+export class ErrorRetry extends Schema.TaggedClass<ErrorRetry>()("ErrorRetry", {
+  error: AiError.AiError,
+}) {}
+
 /**
  * @since 1.0.0
  * @category Output
@@ -825,6 +733,7 @@ export type ContentPart =
   | ScriptDelta
   | ScriptEnd
   | ScriptOutput
+  | ErrorRetry
 
 export const ContentPart = Schema.Union([
   ReasoningStart,
@@ -834,6 +743,7 @@ export const ContentPart = Schema.Union([
   ScriptDelta,
   ScriptEnd,
   ScriptOutput,
+  ErrorRetry,
 ])
 
 /**
@@ -875,6 +785,7 @@ export const Output = Schema.Union([
   SubagentStart,
   SubagentComplete,
   SubagentPart,
+  ErrorRetry,
 ])
 
 /**

package/src/AgentTools.ts

@@ -20,7 +20,6 @@ import { pipe } from "effect/Function"
 import * as Array from "effect/Array"
 import * as Data from "effect/Data"
 import * as Layer from "effect/Layer"
-import * as Duration from "effect/Duration"
 
 /**
  * @since 1.0.0
@@ -75,14 +74,51 @@ export const AgentTools = Toolkit.make(
     success: Schema.NullOr(Schema.String),
     dependencies: [CurrentDirectory],
   }),
-  Tool.make("search", {
-    description: "Find information from a description",
+  Tool.make("rg", {
+    description: "Search for a pattern in files using ripgrep",
+    parameters: Schema.Struct({
+      pattern: Schema.String,
+      glob: Schema.optional(Schema.String).annotate({
+        documentation: "--glob",
+      }),
+      maxLines: Schema.optional(Schema.Finite).annotate({
+        documentation:
+          "The total maximum number of lines to return across all files (default: 500)",
+      }),
+    }),
+    success: Schema.String,
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("delegate", {
+    description:
+      "Delegate a task to another software engineer / sub-agent. Returns the result of the task.",
     parameters: Schema.String.annotate({
-      identifier: "description",
+      identifier: "task",
     }),
     success: Schema.String,
     dependencies: [SubagentExecutor],
   }),
+  Tool.make("glob", {
+    description: "Find files matching a glob pattern.",
+    parameters: Schema.String.annotate({
+      identifier: "pattern",
+    }),
+    success: Schema.Array(Schema.String),
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("bash", {
+    description: "Run a bash command and return the output",
+    parameters: Schema.Struct({
+      command: Schema.String,
+      timeoutMs: Schema.optional(Schema.Finite).annotate({
+        documentation: "Timeout in ms (default: 120000)",
+      }),
+    }).annotate({
+      identifier: "command",
+    }),
+    success: Schema.String,
+    dependencies: [CurrentDirectory],
+  }),
   Tool.make("writeFile", {
     description:
       "Write content to a file, creating parent directories if needed. PREFER USING applyPatch to update existing files.",
@@ -132,43 +168,6 @@ export const AgentTools = Toolkit.make(
     success: Schema.Array(Schema.String),
     dependencies: [CurrentDirectory],
   }),
-  Tool.make("rg", {
-    description:
-      "Search for a pattern in files using ripgrep. Prefer the search function unless finding something specific",
-    parameters: Schema.Struct({
-      pattern: Schema.String,
-      glob: Schema.optional(Schema.String).annotate({
-        documentation: "--glob",
-      }),
-      maxLines: Schema.optional(Schema.Finite).annotate({
-        documentation:
-          "The total maximum number of lines to return across all files (default: 500)",
-      }),
-    }),
-    success: Schema.String,
-    dependencies: [CurrentDirectory],
-  }),
-  Tool.make("glob", {
-    description: "Find files matching a glob pattern.",
-    parameters: Schema.String.annotate({
-      identifier: "pattern",
-    }),
-    success: Schema.Array(Schema.String),
-    dependencies: [CurrentDirectory],
-  }),
-  Tool.make("bash", {
-    description: "Run a bash command and return the output",
-    parameters: Schema.Struct({
-      command: Schema.String,
-      timeoutMs: Schema.optional(Schema.Finite).annotate({
-        documentation: "Timeout in ms (default: 120000)",
-      }),
-    }).annotate({
-      identifier: "command",
-    }),
-    success: Schema.String,
-    dependencies: [CurrentDirectory],
-  }),
   Tool.make("gh", {
     description: "Use the GitHub CLI to run a command and return the output",
     parameters: Schema.Array(Schema.String).annotate({
@@ -177,15 +176,6 @@ export const AgentTools = Toolkit.make(
     success: Schema.String,
     dependencies: [CurrentDirectory],
   }),
-  Tool.make("delegate", {
-    description:
-      "Delegate a task to another software engineer. Returns the result of the task.",
-    parameters: Schema.String.annotate({
-      identifier: "task",
-    }),
-    success: Schema.String,
-    dependencies: [SubagentExecutor],
-  }),
   Tool.make("webSearch", {
     description: "Search the web for recent information.",
     parameters: ExaSearch.ExaSearchOptions,
@@ -356,11 +346,11 @@ export const AgentToolHandlersNoDeps = AgentTools.toLayer(
         return yield* Effect.promise(() => Glob.glob(pattern, { cwd }))
       }),
       bash: Effect.fn("AgentTools.bash")(function* (options) {
-        const timeout = Duration.millis(options.timeoutMs ?? 120_000)
+        const timeoutMs = options.timeoutMs ?? 120_000
         yield* Effect.logInfo(`Calling "bash"`).pipe(
           Effect.annotateLogs({
             ...options,
-            timeoutMs: Duration.format(timeout),
+            timeoutMs,
           }),
         )
         const cwd = yield* CurrentDirectory
@@ -370,13 +360,9 @@ export const AgentToolHandlersNoDeps = AgentTools.toLayer(
         })
         return yield* execute(cmd).pipe(
           Effect.timeoutOrElse({
-            duration: timeout,
+            duration: timeoutMs,
             onTimeout: () =>
-              Effect.die(
-                new Error(
-                  `Command timed out after ${Duration.format(timeout)}`,
-                ),
-              ),
+              Effect.die(new Error(`Command timed out after ${timeoutMs}ms`)),
           }),
         )
       }, Effect.orDie),
@@ -544,21 +530,9 @@ export const AgentToolHandlersNoDeps = AgentTools.toLayer(
       delegate: Effect.fn("AgentTools.delegate")(function* (prompt) {
         yield* Effect.logInfo(`Calling "delegate"`)
         const spawn = yield* SubagentExecutor
-        return yield* spawn(`You have been asked using the "delegate" function to complete the following task. Try to avoid using the "delegate" or "search" functions yourself unless strictly necessary:
+        return yield* spawn(`You have been asked using the "delegate" function to complete the following task. Try to avoid using the "delegate" function yourself unless strictly necessary:
 
 ${prompt}`)
-      }, Effect.orDie),
-      search: Effect.fn("AgentTools.search")(function* (description) {
-        yield* Effect.logInfo(`Calling "search"`)
-        const spawn = yield* SubagentExecutor
-        return yield* spawn(`You are to find the following information as fast as possible:
-
-${description}
-
-Requirements:
-- DO NOT call the "search" or "delegate" functions.
-- Output a concise report with file names, line numbers, and code snippets.
-- If nothing relevant is found, say so clearly.`)
       }, Effect.orDie),
       taskComplete: Effect.fn("AgentTools.taskComplete")(function* (message) {
         const deferred = yield* TaskCompleter

package/src/Codex.ts

@@ -40,11 +40,7 @@ export const model = (
       OpenAiLanguageModel.layer({
         model,
         config: {
-          ...Struct.omit(options ?? {}, [
-            "reasoning",
-            "supportsNoTools",
-            "supportsAssistantPrefill",
-          ]),
+          ...Struct.omit(options ?? {}, ["reasoning"]),
           store: false,
           reasoning: {
             effort: options?.reasoning?.effort ?? "medium",
@@ -57,8 +53,6 @@ export const model = (
           OpenAiLanguageModel.withConfigOverride(effect, {
             instructions: system,
           }),
-        supportsAssistantPrefill: options?.supportsAssistantPrefill ?? true,
-        supportsNoTools: options?.supportsNoTools ?? true,
       }),
     ).pipe(Layer.provide(layerClient)),
   )

package/src/Copilot.ts

@@ -45,8 +45,7 @@ export const model = (
         ]),
       }),
       AgentModelConfig.layer({
-        supportsAssistantPrefill: options?.supportsAssistantPrefill ?? false,
-        supportsNoTools: options?.supportsNoTools ?? false,
+        systemPromptTransform: options?.systemPromptTransform,
       }),
     ).pipe(Layer.provide(layerClient)),
   )

package/src/OutputFormatter.ts

@@ -10,6 +10,7 @@ import * as Stream from "effect/Stream"
 import type { AgentFinished, Output } from "./Agent.ts"
 import chalk from "chalk"
 import type * as Prompt from "effect/unstable/ai/Prompt"
+import * as Cause from "effect/Cause"
 
 /**
  * @since 1.0.0
@@ -73,6 +74,9 @@ ${output.summary}\n\n`
               : output.output
           return `${prefix}${chalkScriptHeading(`${scriptIcon} Script output`)}\n\n${chalk.dim(truncated)}\n\n`
         }
+        case "ErrorRetry": {
+          return `${prefix}${chalk.red(`Error: ${output.error}. Retrying...`)}\n\n${chalk.dim(Cause.pretty(Cause.fail(output.error)))}\n\n`
+        }
       }
     }),
     Stream.catchTag("AgentFinished", (finished) =>