clanka 0.3.0 → 0.4.0

package/src/CompactionTransport.test.ts

@@ -0,0 +1,228 @@
+import { OpenAiClient } from "@effect/ai-openai"
+import { OpenAiClient as CompatClient } from "@effect/ai-openai-compat"
+import { assert, describe, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Stream from "effect/Stream"
+import * as AiError from "effect/unstable/ai/AiError"
+import * as LanguageModel from "effect/unstable/ai/LanguageModel"
+import * as Prompt from "effect/unstable/ai/Prompt"
+import * as HttpClient from "effect/unstable/http/HttpClient"
+import type * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
+import * as Codex from "./Codex.ts"
+import * as Compaction from "./Compaction.ts"
+import * as Copilot from "./Copilot.ts"
+
+const user = (text: string) =>
+  Prompt.makeMessage("user", {
+    content: [Prompt.makePart("text", { text })],
+  })
+const history = Prompt.fromMessages([
+  user("old context ".repeat(1_000)),
+  user("continue"),
+])
+const summaryPrompt = Compaction.summarizerPrompt({
+  previousSummary: Option.none(),
+  messages: history.content,
+})
+
+// Use the real provider model and client. Stop at the transport boundary so no
+// credentials, network access, or permissive scripted LanguageModel are involved.
+const captureHttp = () => {
+  const requests: Array<HttpClientRequest.HttpClientRequest> = []
+  const client = HttpClient.make((request) =>
+    Effect.sync(() => {
+      requests.push(request)
+      return HttpClientResponse.fromWeb(
+        request,
+        new Response(
+          JSON.stringify({
+            error: {
+              message: "transport probe",
+              type: "invalid_request_error",
+            },
+          }),
+          { status: 400, headers: { "content-type": "application/json" } },
+        ),
+      )
+    }),
+  )
+  return { requests, layer: Layer.succeed(HttpClient.HttpClient, client) }
+}
+
+const body = (
+  request: HttpClientRequest.HttpClientRequest,
+): Record<string, unknown> => {
+  if (request.body._tag !== "Uint8Array")
+    throw new Error("expected a JSON request body")
+  return JSON.parse(new TextDecoder().decode(request.body.body))
+}
+
+const compact = Compaction.compact({
+  prompt: history,
+  reason: "threshold",
+}).pipe(
+  Effect.provide(Compaction.CompactionConfig.layer({ keepRecentTokens: 100 })),
+)
+
+const streamedSummary = Effect.gen(function* () {
+  const ai = yield* LanguageModel.LanguageModel
+  const transform = yield* Compaction.SummarizerTransform
+  return yield* transform(
+    ai.streamText({ prompt: summaryPrompt }).pipe(Stream.runDrain),
+  )
+})
+
+const socketError = AiError.make({
+  module: "test/socket",
+  method: "createResponseStream",
+  reason: new AiError.InvalidRequestError({ description: "transport probe" }),
+})
+
+describe("Compaction provider transport", () => {
+  it.effect("sets stream: true on the Codex HTTP summarization request", () =>
+    Effect.gen(function* () {
+      const http = captureHttp()
+      const exit = yield* compact.pipe(
+        Effect.provide(
+          Codex.model("gpt-6-astra").pipe(
+            Layer.provide(
+              OpenAiClient.layer({ apiUrl: "https://codex.test" }).pipe(
+                Layer.provide(http.layer),
+              ),
+            ),
+          ),
+        ),
+        Effect.exit,
+      )
+      assert.isTrue(Exit.isFailure(exit))
+      assert.strictEqual(http.requests.length, 1)
+      assert.strictEqual(http.requests[0]!.url, "https://codex.test/responses")
+      const request = body(http.requests[0]!)
+      assert.strictEqual(
+        request.stream,
+        true,
+        "Codex rejects non-streaming responses with HTTP 400",
+      )
+      assert.isFalse("max_output_tokens" in request)
+      assert.deepStrictEqual(request.tools ?? [], [])
+    }),
+  )
+
+  it.effect(
+    "routes compaction through the installed OpenAiSocket rather than HTTP",
+    () =>
+      Effect.gen(function* () {
+        const http = captureHttp()
+        const requests: Array<
+          Parameters<
+            OpenAiClient.OpenAiSocket["Service"]["createResponseStream"]
+          >[0]
+        > = []
+        const exit = yield* compact.pipe(
+          Effect.provideService(OpenAiClient.OpenAiSocket, {
+            createResponseStream: (request) =>
+              Effect.suspend(() => {
+                requests.push(request)
+                return Effect.fail(socketError)
+              }),
+          }),
+          Effect.provide(
+            Codex.model("gpt-6-astra").pipe(
+              Layer.provide(
+                OpenAiClient.layer({ apiUrl: "https://codex.test" }).pipe(
+                  Layer.provide(http.layer),
+                ),
+              ),
+            ),
+          ),
+          Effect.exit,
+        )
+        assert.strictEqual(
+          http.requests.length,
+          0,
+          "generateText bypasses the websocket and must not be used here",
+        )
+        assert.strictEqual(requests.length, 1)
+        assert.deepStrictEqual(exit, Exit.fail(socketError))
+        assert.isFalse("max_output_tokens" in requests[0]!)
+        assert.deepStrictEqual(requests[0]!.tools ?? [], [])
+      }),
+  )
+
+  it.effect(
+    "omits the unsupported Codex output-token cap even when streaming is selected",
+    () =>
+      Effect.gen(function* () {
+        const http = captureHttp()
+        yield* streamedSummary.pipe(
+          Effect.provide(
+            Codex.model("gpt-6-astra").pipe(
+              Layer.provide(
+                OpenAiClient.layer({ apiUrl: "https://codex.test" }).pipe(
+                  Layer.provide(http.layer),
+                ),
+              ),
+            ),
+          ),
+          Effect.exit,
+        )
+        assert.strictEqual(http.requests.length, 1)
+        const request = body(http.requests[0]!)
+        assert.strictEqual(request.stream, true)
+        // The live Codex backend rejects this parameter; a 4k cap is unavailable.
+        assert.isFalse(
+          "max_output_tokens" in request,
+          "Codex does not support max_output_tokens",
+        )
+        assert.deepInclude(request.input, {
+          role: "system",
+          content: [{ type: "input_text", text: Compaction.summarizerSystem }],
+        })
+      }),
+  )
+
+  it.effect(
+    "retains Copilot's 4k wire-level cap only for the streamed summary",
+    () =>
+      Effect.gen(function* () {
+        const http = captureHttp()
+        yield* Effect.gen(function* () {
+          yield* streamedSummary.pipe(Effect.exit)
+          const ai = yield* LanguageModel.LanguageModel
+          yield* ai
+            .streamText({ prompt: "continue" })
+            .pipe(Stream.runDrain, Effect.exit)
+        }).pipe(
+          Effect.provide(
+            Copilot.model("gpt-4.1").pipe(
+              Layer.provide(
+                CompatClient.layer({ apiUrl: "https://copilot.test" }).pipe(
+                  Layer.provide(http.layer),
+                ),
+              ),
+            ),
+          ),
+        )
+        assert.strictEqual(http.requests.length, 2)
+        assert.strictEqual(
+          http.requests[0]!.url,
+          "https://copilot.test/chat/completions",
+        )
+        const summary = body(http.requests[0]!)
+        const continuation = body(http.requests[1]!)
+        assert.strictEqual(summary.stream, true)
+        // The compatibility client translates max_output_tokens to max_tokens.
+        assert.strictEqual(summary.max_tokens, 4_000)
+        assert.deepStrictEqual(summary.tools ?? [], [])
+        assert.isFalse(
+          "max_tokens" in continuation,
+          "summary override must not leak into the next model call",
+        )
+        assert.strictEqual(continuation.stream, true)
+      }),
+  )
+})

package/src/Copilot.ts

@@ -6,6 +6,7 @@ import * as Layer from "effect/Layer"
 import * as Struct from "effect/Struct"
 import { API_URL, GithubCopilotAuth } from "./CopilotAuth.ts"
 import { AgentModelConfig } from "./Agent.ts"
+import * as Compaction from "./Compaction.ts"
 import * as Model from "effect/unstable/ai/Model"
 import type * as LanguageModel from "effect/unstable/ai/LanguageModel"
 
@@ -34,7 +35,7 @@ export const model = (
   Model.make(
     "openai",
     model,
-    Layer.merge(
+    Layer.mergeAll(
       OpenAiLanguageModel.layer({
         model,
         config: Struct.omit(options ?? {}, ["systemPromptTransform"]),
@@ -42,5 +43,11 @@ export const model = (
       AgentModelConfig.layer({
         systemPromptTransform: options?.systemPromptTransform,
       }),
+      // Cap compaction summaries; Copilot honours max_output_tokens.
+      Layer.succeed(Compaction.SummarizerTransform, (effect) =>
+        OpenAiLanguageModel.withConfigOverride(effect, {
+          max_output_tokens: Compaction.summarizerMaxOutputTokens,
+        }),
+      ),
     ),
   )

package/src/OutputFormatter.ts

@@ -98,6 +98,15 @@ ${output.summary}\n\n`
           case "Usage": {
             return `${prefix}${chalkInfoHeading(`${infoIcon} Usage:`)} ${numberFormat.format(output.contextTokens)} context / ${numberFormat.format(output.inputTokens)} input / ${numberFormat.format(output.outputTokens)} output\n\n`
           }
+          case "ExecuteOutputCapped": {
+            return `${prefix}${chalkInfoHeading(`${infoIcon} Output capped:`)} ${numberFormat.format(output.charsBefore)} chars reduced to ${numberFormat.format(output.charsAfter)}\n\n`
+          }
+          case "CompactionStarted": {
+            return `${prefix}${chalkInfoHeading(`${infoIcon} Compacting context (${output.reason})...`)}\n\n`
+          }
+          case "CompactionEnded": {
+            return `${prefix}${chalkInfoHeading(`${infoIcon} Context compacted (${output.reason}):`)} ~${numberFormat.format(output.tokensBefore)} tokens to ~${numberFormat.format(output.tokensAfter)}\n\n`
+          }
         }
       }),
       Stream.catchIf(

package/src/cli.ts

@@ -12,6 +12,7 @@ import * as AgentExecutor from "./AgentExecutor.ts"
 import * as Codex from "./Codex.ts"
 import * as Copilot from "./Copilot.ts"
 import * as Agent from "./Agent.ts"
+import * as Compaction from "./Compaction.ts"
 import * as Stream from "effect/Stream"
 import * as OutputFormatter from "./OutputFormatter.ts"
 import * as Stdio from "effect/Stdio"
@@ -28,7 +29,7 @@ import * as Option from "effect/Option"
 import { OpenAiClient, OpenAiEmbeddingModel } from "@effect/ai-openai"
 import { DeviceCodeHandler } from "./index.ts"
 
-const version = "0.0.1"
+const version = "1.0.0"
 
 type Provider = "openai" | "copilot"
 
@@ -122,6 +123,16 @@ const prompt = Flag.String("prompt").pipe(
   Flag.optional,
 )
 
+// Kill switch: `--no-compaction` or CLANKA_COMPACTION=false.
+const compaction = Flag.Boolean("compaction").pipe(
+  Flag.withDescription(
+    "Auto-compact the conversation history when it nears the context window. Disable with --no-compaction or CLANKA_COMPACTION=false; the execute output cap stays on.",
+  ),
+  Flag.withFallbackConfig(
+    Config.Boolean("CLANKA_COMPACTION").pipe(Config.withDefault(true)),
+  ),
+)
+
 const Kvs = Layer.unwrap(
   Effect.gen(function* () {
     const path = yield* Path.Path
@@ -182,7 +193,7 @@ const acpModel = Flag.String("model").pipe(
   Flag.withDefault("openai/gpt-6-astra/medium"),
 )
 
-const acp = Command.make("acp", { model: acpModel }).pipe(
+const acp = Command.make("acp", { model: acpModel, compaction }).pipe(
   Command.withDescription(
     "Run as an Agent Client Protocol (ACP) server over stdio",
   ),
@@ -200,16 +211,23 @@ const acp = Command.make("acp", { model: acpModel }).pipe(
         ),
     }),
   ),
-  Command.provide(
+  Command.provide(({ compaction }) =>
     Layer.mergeAll(
       Agent.ConversationMode.layer(true),
       Layer.succeed(Logger.LogToStderr, true),
       DeviceCodeHandler.layerLog,
+      Compaction.CompactionConfig.layer({ enabled: compaction }),
     ),
   ),
 )
 
-Command.make("clanka", { provider, model, semantic, prompt }).pipe(
+Command.make("clanka", {
+  provider,
+  model,
+  semantic,
+  prompt,
+  compaction,
+}).pipe(
   Command.withHandler(
     Effect.fnUntraced(function* ({
       provider,
@@ -264,8 +282,11 @@ Command.make("clanka", { provider, model, semantic, prompt }).pipe(
       )
     }),
   ),
-  Command.provide(({ prompt }) =>
-    Agent.ConversationMode.layer(Option.isNone(prompt)),
+  Command.provide(({ prompt, compaction }) =>
+    Layer.mergeAll(
+      Agent.ConversationMode.layer(Option.isNone(prompt)),
+      Compaction.CompactionConfig.layer({ enabled: compaction }),
+    ),
   ),
   Command.withSubcommands([acp]),
   Command.run({

package/src/index.ts

@@ -12,6 +12,7 @@ export * as Agent from "./Agent.ts"
  * @since 1.0.0
  */
 export * as AgentExecutor from "./AgentExecutor.ts"
+export * as AgentSkills from "./AgentSkills.ts"
 
 /**
  * @since 1.0.0
@@ -33,6 +34,11 @@ export * as Codex from "./Codex.ts"
  */
 export * as CodeChunker from "./CodeChunker.ts"
 
+/**
+ * @since 1.0.0
+ */
+export * as Compaction from "./Compaction.ts"
+
 /**
  * @since 1.0.0
  */