clanka 0.0.4 → 0.0.5

package/src/Agent.ts

@@ -17,7 +17,13 @@ import {
   ServiceMap,
   Stream,
 } from "effect"
-import { LanguageModel, Prompt, Tool, Toolkit } from "effect/unstable/ai"
+import {
+  AiError,
+  LanguageModel,
+  Prompt,
+  Tool,
+  Toolkit,
+} from "effect/unstable/ai"
 import {
   AgentToolHandlers,
   AgentTools,
@@ -28,7 +34,6 @@ import {
 import { Executor } from "./Executor.ts"
 import { ToolkitRenderer } from "./ToolkitRenderer.ts"
 import { ModelName, ProviderName } from "effect/unstable/ai/Model"
-import { OpenAiLanguageModel } from "@effect/ai-openai"
 import { type StreamPart } from "effect/unstable/ai/Response"
 import type { ChildProcessSpawner } from "effect/unstable/process"
 
@@ -37,7 +42,7 @@ import type { ChildProcessSpawner } from "effect/unstable/process"
  * @category Models
  */
 export interface Agent {
-  readonly output: Stream.Stream<Output, AgentFinished>
+  readonly output: Stream.Stream<Output, AgentFinished | AiError.AiError>
 
   /**
    * Send a message to the agent to steer its behavior. This is useful for
@@ -50,18 +55,6 @@ export interface Agent {
   steer(message: string): Effect.Effect<void>
 }
 
-/**
- * A layer that provides most of the common services needed to run an agent.
- *
- * @since 1.0.0
- * @category Services
- */
-export const layerServices: Layer.Layer<
-  Tool.HandlersFor<typeof AgentTools.tools> | Executor | ToolkitRenderer,
-  never,
-  FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner
-> = Layer.mergeAll(AgentToolHandlers, Executor.layer, ToolkitRenderer.layer)
-
 /**
  * Start an agent in the given directory with the given prompt and tools.
  *
@@ -112,50 +105,30 @@ export const make: <
   const fs = yield* FileSystem.FileSystem
   const pathService = yield* Path.Path
   const executor = yield* Executor
+  const renderer = yield* ToolkitRenderer
   const allTools = Toolkit.merge(AgentTools, options.tools ?? Toolkit.empty)
+  const allToolsDts = renderer.render(allTools)
   const tools = yield* allTools
+  const singleTool = yield* SingleTools.asEffect().pipe(
+    Effect.provide(SingleToolHandlers),
+  )
   const services = yield* Effect.services<
     | Tool.HandlerServices<{}>
     | LanguageModel.LanguageModel
     | ProviderName
     | ModelName
   >()
+
   const pendingMessages = new Set<{
     readonly message: string
     readonly resume: (effect: Effect.Effect<void>) => void
   }>()
 
-  let system = yield* generateSystem(allTools)
-
   const agentsMd = yield* pipe(
     fs.readFileString(pathService.resolve(options.directory, "AGENTS.md")),
     Effect.option,
   )
 
-  if (Option.isSome(agentsMd)) {
-    system += `
-# AGENTS.md
-
-The following instructions are from ./AGENTS.md in the current directory.
-You do not need to read this file again.
-
-**ALWAYS follow these instructions when completing tasks**:
-
-<!-- AGENTS.md start -->
-${agentsMd.value}
-<!-- AGENTS.md end -->
-`
-  }
-
-  if (options.system) {
-    system += `\n${options.system}\n`
-  }
-
-  const withSystemPrompt = OpenAiLanguageModel.withConfigOverride({
-    store: false,
-    instructions: system,
-  })
-
   let agentCounter = 0
 
   const outputBuffer = new Map<number, Array<Output>>()
@@ -166,13 +139,35 @@ ${agentsMd.value}
     prompt: Prompt.Prompt,
   ) => Stream.Stream<
     Output,
-    AgentFinished,
+    AgentFinished | AiError.AiError,
     LanguageModel.LanguageModel | ProviderName
   > = Effect.fnUntraced(function* (agentId, prompt) {
     const ai = yield* LanguageModel.LanguageModel
-    const provider = yield* ProviderName
+    const modelConfig = yield* AgentModelConfig
+    const singleToolMode = modelConfig.supportsNoTools !== false
     const deferred = yield* Deferred.make<string>()
-    const output = yield* Queue.make<Output, AgentFinished>()
+    const output = yield* Queue.make<Output, AgentFinished | AiError.AiError>()
+
+    let system = generateSystem(allToolsDts, !singleToolMode)
+
+    if (Option.isSome(agentsMd)) {
+      system += `
+# AGENTS.md
+
+The following instructions are from ./AGENTS.md in the current directory.
+You do not need to read this file again.
+
+**ALWAYS follow these instructions when completing tasks**:
+
+<!-- AGENTS.md start -->
+${agentsMd.value}
+<!-- AGENTS.md end -->
+`
+    }
+
+    if (options.system) {
+      system += `\n${options.system}\n`
+    }
 
     function maybeSend(agentId: number, part: Output, lock = false) {
       if (currentOutputAgent === null || currentOutputAgent === agentId) {
@@ -233,13 +228,14 @@ ${prompt}`),
               return Effect.void
             }),
             Effect.as(""),
-            Effect.catch((finished) => {
+            Effect.catchTag("AgentFinished", (finished) => {
               Queue.offerUnsafe(
                 output,
                 new SubagentComplete({ id, summary: finished.summary }),
               )
               return Effect.succeed(finished.summary)
             }),
+            Effect.orDie,
           )
         }).pipe(
           options.subagentModel
@@ -252,25 +248,31 @@ ${prompt}`),
       ServiceMap.add(TaskCompleteDeferred, deferred),
     )
 
-    if (provider !== "openai") {
+    const executeScript = Effect.fnUntraced(function* (script: string) {
+      maybeSend(agentId, new ScriptEnd())
+      const output = yield* pipe(
+        executor.execute({ tools, script }),
+        Stream.mkString,
+        Effect.provideServices(taskServices),
+      )
+      maybeSend(agentId, new ScriptOutput({ output }))
+      return output
+    })
+
+    if (!modelConfig.systemPromptTransform) {
       prompt = Prompt.setSystem(prompt, system)
     }
 
     let currentScript = ""
     yield* Effect.gen(function* () {
       while (true) {
-        if (currentScript.length > 0) {
-          maybeSend(agentId, new ScriptStart({ script: currentScript }))
-          const result = yield* pipe(
-            executor.execute({
-              tools,
-              script: currentScript,
-            }),
-            Stream.mkString,
-          )
-          maybeSend(agentId, new ScriptEnd({ output: result }))
+        if (!singleToolMode && currentScript.length > 0) {
+          const result = yield* executeScript(currentScript)
           prompt = Prompt.concat(prompt, [
-            { role: "assistant", content: `Javascript output:\n\n${result}` },
+            {
+              role: modelConfig.supportsAssistantPrefill ? "assistant" : "user",
+              content: `Javascript output:\n\n${result}`,
+            },
           ])
           currentScript = ""
         }
@@ -297,16 +299,26 @@ ${prompt}`),
           pendingMessages.clear()
         }
 
-        let response = Array.empty<StreamPart<{}>>()
+        // oxlint-disable-next-line typescript/no-explicit-any
+        let response = Array.empty<StreamPart<any>>()
         let reasoningStarted = false
         let hadReasoningDelta = false
         yield* pipe(
-          ai.streamText({ prompt }),
+          ai.streamText(
+            singleToolMode ? { prompt, toolkit: singleTool } : { prompt },
+          ),
           Stream.takeUntil((part) => {
-            if (part.type === "text-end" && currentScript.trim().length > 0) {
+            if (
+              !singleToolMode &&
+              part.type === "text-end" &&
+              currentScript.trim().length > 0
+            ) {
               return true
             }
-            if (part.type === "reasoning-end" && pendingMessages.size > 0) {
+            if (
+              (part.type === "text-end" || part.type === "reasoning-end") &&
+              pendingMessages.size > 0
+            ) {
               return true
             }
             return false
@@ -317,11 +329,43 @@ ${prompt}`),
             for (const part of parts) {
               switch (part.type) {
                 case "text-start":
+                  if (singleToolMode) {
+                    reasoningStarted = true
+                    break
+                  }
                   currentScript = ""
                   break
-                case "text-delta":
+                case "text-delta": {
+                  if (singleToolMode) {
+                    hadReasoningDelta = true
+                    if (reasoningStarted) {
+                      reasoningStarted = false
+                      maybeSend(agentId, new ReasoningStart(), true)
+                    }
+                    maybeSend(
+                      agentId,
+                      new ReasoningDelta({ delta: part.delta }),
+                    )
+                    break
+                  }
+                  if (currentScript === "" && part.delta.length > 0) {
+                    maybeSend(agentId, new ScriptStart(), true)
+                  }
+                  maybeSend(agentId, new ScriptDelta({ delta: part.delta }))
                   currentScript += part.delta
                   break
+                }
+                case "text-end": {
+                  if (singleToolMode) {
+                    reasoningStarted = false
+                    if (hadReasoningDelta) {
+                      hadReasoningDelta = false
+                      const sent = maybeSend(agentId, new ReasoningEnd())
+                      if (sent) flushBuffer()
+                    }
+                  }
+                  break
+                }
                 case "reasoning-start":
                   reasoningStarted = true
                   break
@@ -354,14 +398,25 @@ ${prompt}`),
               return err.isRetryable
             },
           }),
-          provider === "openai" ? withSystemPrompt : identity,
+          modelConfig.systemPromptTransform
+            ? (effect) => modelConfig.systemPromptTransform!(system, effect)
+            : identity,
         )
         prompt = Prompt.concat(prompt, Prompt.fromResponseParts(response))
         currentScript = currentScript.trim()
       }
     }).pipe(
-      Effect.provideServices(taskServices),
+      Effect.provideServices(
+        taskServices.pipe(
+          ServiceMap.add(ScriptExecutor, (script) => {
+            maybeSend(agentId, new ScriptStart())
+            maybeSend(agentId, new ScriptDelta({ delta: script }))
+            return executeScript(script)
+          }),
+        ),
+      ),
       Effect.provideServices(services),
+      Effect.catchCause((cause) => Queue.failCause(output, cause)),
       Effect.forkScoped,
     )
 
@@ -386,28 +441,18 @@ ${prompt}`),
   // oxlint-disable-next-line typescript/no-explicit-any
 }) as any
 
-// oxlint-disable-next-line typescript/no-explicit-any
-const generateSystem = Effect.fn(function* (tools: Toolkit.Toolkit<any>) {
-  const renderer = yield* ToolkitRenderer
+const generateSystem = (
+  // oxlint-disable-next-line typescript/no-explicit-any
+  toolsDts: string,
+  multi: boolean,
+) => {
+  const toolMd = multi
+    ? generateSystemMulti(toolsDts)
+    : generateSystemSingle(toolsDts)
 
   return `You are a professional software engineer. You are precise, thoughtful and concise. You make changes with care and always do the due diligence to ensure the best possible outcome. You make no mistakes.
 
-To do your job, only respond with javascript code that will be executed for you.
-
-- Do not add any markdown formatting, just code.
-- Use \`console.log\` to print any output you need.
-- Top level await is supported.
-- **Prefer using the functions provided** over the bash tool
-
-**When you have completed your task**, call the "taskComplete" function with the final output.
-
-You have the following functions available to you:
-
-\`\`\`ts
-${renderer.render(tools)}
-
-declare const fetch: typeof globalThis.fetch
-\`\`\`
+${toolMd}
 
 Here is how you would read a file:
 
@@ -438,8 +483,96 @@ Javascript output:
 - Only add comments when necessary.
 - Use the "subagent" tool to delegate large tasks / exploration. Run multiple subagents in parallel with Promise.all
 `
+}
+
+// oxlint-disable-next-line typescript/no-explicit-any
+const generateSystemMulti = (toolsDts: string) => {
+  return `From now on only respond with javascript code that will be executed for you.
+
+- Use \`console.log\` to print any output you need.
+- Top level await is supported.
+- **Prefer using the functions provided** over the bash tool
+
+**When you have completed your task**, call the "taskComplete" function with the final output.
+
+You have the following functions available to you:
+
+\`\`\`ts
+${toolsDts}
+
+declare const fetch: typeof globalThis.fetch
+\`\`\``
+}
+
+// oxlint-disable-next-line typescript/no-explicit-any
+const generateSystemSingle = (toolsDts: string) => {
+  return `Use the "execute" tool to run javascript code to do your work.
+
+- Use \`console.log\` to print any output you need.
+- Top level await is supported.
+- **Prefer using the functions provided** over the bash tool
+
+You have the following functions available to you:
+
+\`\`\`ts
+${toolsDts}
+
+declare const fetch: typeof globalThis.fetch
+\`\`\``
+}
+
+class ScriptExecutor extends ServiceMap.Service<
+  ScriptExecutor,
+  (script: string) => Effect.Effect<string>
+>()("clanka/Agent/ScriptExecutor") {}
+
+const SingleTools = Toolkit.make(
+  Tool.make("execute", {
+    description: "Execute javascript code and return the output",
+    parameters: Schema.Struct({
+      script: Schema.String,
+    }),
+    success: Schema.String,
+    dependencies: [ScriptExecutor],
+  }),
+)
+const SingleToolHandlers = SingleTools.toLayer({
+  execute: Effect.fnUntraced(function* ({ script }) {
+    const execute = yield* ScriptExecutor
+    return yield* execute(script)
+  }),
 })
 
+/**
+ * @since 1.0.0
+ * @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
+}>("clanka/Agent/SystemPromptTransform", {
+  defaultValue: () => ({}),
+}) {
+  static readonly layer = (options: typeof AgentModelConfig.Service) =>
+    Layer.succeed(AgentModelConfig, options)
+}
+
+/**
+ * A layer that provides most of the common services needed to run an agent.
+ *
+ * @since 1.0.0
+ * @category Services
+ */
+export const layerServices: Layer.Layer<
+  Tool.HandlersFor<typeof AgentTools.tools> | Executor | ToolkitRenderer,
+  never,
+  FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner
+> = Layer.mergeAll(AgentToolHandlers, Executor.layer, ToolkitRenderer.layer)
+
 /**
  * @since 1.0.0
  * @category Output
@@ -475,8 +608,17 @@ export class ReasoningEnd extends Schema.TaggedClass<ReasoningEnd>()(
  */
 export class ScriptStart extends Schema.TaggedClass<ScriptStart>()(
   "ScriptStart",
+  {},
+) {}
+
+/**
+ * @since 1.0.0
+ * @category Output
+ */
+export class ScriptDelta extends Schema.TaggedClass<ScriptDelta>()(
+  "ScriptDelta",
   {
-    script: Schema.String,
+    delta: Schema.String,
   },
 ) {}
 
@@ -484,9 +626,21 @@ export class ScriptStart extends Schema.TaggedClass<ScriptStart>()(
  * @since 1.0.0
  * @category Output
  */
-export class ScriptEnd extends Schema.TaggedClass<ScriptEnd>()("ScriptEnd", {
-  output: Schema.String,
-}) {}
+export class ScriptEnd extends Schema.TaggedClass<ScriptEnd>()(
+  "ScriptEnd",
+  {},
+) {}
+
+/**
+ * @since 1.0.0
+ * @category Output
+ */
+export class ScriptOutput extends Schema.TaggedClass<ScriptOutput>()(
+  "ScriptOutput",
+  {
+    output: Schema.String,
+  },
+) {}
 
 /**
  * @since 1.0.0
@@ -534,14 +688,18 @@ export type ContentPart =
   | ReasoningDelta
   | ReasoningEnd
   | ScriptStart
+  | ScriptDelta
   | ScriptEnd
+  | ScriptOutput
 
 export const ContentPart = Schema.Union([
   ReasoningStart,
   ReasoningDelta,
   ReasoningEnd,
   ScriptStart,
+  ScriptDelta,
   ScriptEnd,
+  ScriptOutput,
 ])
 
 /**
@@ -575,7 +733,9 @@ export const Output = Schema.Union([
   ReasoningDelta,
   ReasoningEnd,
   ScriptStart,
+  ScriptDelta,
   ScriptEnd,
+  ScriptOutput,
   SubagentStart,
   SubagentComplete,
   SubagentPart,

package/src/Codex.ts

@@ -1,14 +1,29 @@
 /**
  * @since 1.0.0
  */
-import { OpenAiClient } from "@effect/ai-openai"
+import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai"
 import { Layer } from "effect"
 import { CodexAuth } from "./CodexAuth.ts"
+import { AgentModelConfig } from "./Agent.ts"
 
 /**
  * @since 1.0.0
  * @category Layers
  */
-export const CodexAiClient = OpenAiClient.layer({
+export const layerModelConfig = AgentModelConfig.layer({
+  systemPromptTransform: (system, effect) =>
+    OpenAiLanguageModel.withConfigOverride(effect, {
+      store: false,
+      instructions: system,
+    }),
+  supportsAssistantPrefill: true,
+  supportsNoTools: true,
+})
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layer = OpenAiClient.layer({
   apiUrl: "https://chatgpt.com/backend-api/codex",
-}).pipe(Layer.provide(CodexAuth.layerClient))
+}).pipe(Layer.merge(layerModelConfig), Layer.provide(CodexAuth.layerClient))

package/src/GithubCopilot.ts

@@ -0,0 +1,14 @@
+/**
+ * @since 1.0.0
+ */
+import { OpenAiClient } from "@effect/ai-openai-compat"
+import { Layer } from "effect"
+import { API_URL, GithubCopilotAuth } from "./GithubCopilotAuth.ts"
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layer = OpenAiClient.layer({
+  apiUrl: API_URL,
+}).pipe(Layer.provide(GithubCopilotAuth.layerClient))