@akanjs/devkit 3.0.0-beta.18 → 3.0.0-beta.19

package/codeAgent/agent/CodeAgent.ts

@@ -1,7 +1,6 @@
 import {
   type AgentSession,
   createAgentSession,
-  DEFAULT_COMPACTION_SETTINGS,
   DefaultResourceLoader,
   type ExtensionAPI,
   type InlineExtension,
@@ -37,6 +36,8 @@ import { akanCodePaths } from "./akanCodePaths";
 import { CodeAgentAsks } from "./CodeAgentAsks";
 import { CodeAgentEventMapper } from "./CodeAgentEventMapper";
 import { CodeAgentGate } from "./CodeAgentGate";
+import { CodeAgentProxy } from "./CodeAgentProxy";
+import { CodeAgentSuspended } from "./CodeAgentSuspended";
 import { CodeAgentUi } from "./CodeAgentUi";
 import { CodeMailbox } from "./CodeMailbox";
 import { CodeSessionFork } from "./CodeSessionFork";
@@ -77,6 +78,7 @@ export class CodeAgent {
   readonly #gate: CodeAgentGate;
   readonly #mapper = new CodeAgentEventMapper();
   readonly #asks = new CodeAgentAsks();
+  #suspended = new CodeAgentSuspended(null);
   readonly #listeners = new Set<(event: CodeAgentEvent) => void>();
   #session: AgentSession | undefined;
   #disposePlugins: (() => void) | undefined;
@@ -106,9 +108,9 @@ export class CodeAgent {
     const cwd = options.cwd ?? workspaceRoot;
     const agent = new CodeAgent(options.profile);
     const settingsManager = AkanCodeServices.settings();
-    const modelRuntime = await AkanCodeServices.runtime(workspaceRoot);
+    const modelRuntime = await AkanCodeServices.runtime(workspaceRoot, CodeAgentProxy.fromEnv(options.profile));
     const model = await akanCodeModel(modelRuntime, options.model);
-    const compaction = DEFAULT_COMPACTION_SETTINGS;
+    const compaction = settingsManager.getCompactionSettings(model);
     const modelWarnings = akanCodeModelWarnings(model, compaction.reserveTokens + compaction.keepRecentTokens);
 
     const akan = await AkanCodePlugins.build({
@@ -153,9 +155,11 @@ export class CodeAgent {
     agent.#disposePlugins = akan.dispose;
     agent.#mcp = akan.mcp;
     agent.#workspaceRoot = workspaceRoot;
-    if (options.profile.session.store === "file") agent.#sessionDir = akanCodePaths.sessionsDir(workspaceRoot);
+    if (options.profile.session.store !== "memory") agent.#sessionDir = akanCodePaths.sessionsDir(workspaceRoot);
     await agent.#attach(session, options.mode ?? "print");
-    if (agent.#sessionDir) agent.#openMail(akanCodePaths.mailDir(workspaceRoot), cwd);
+    agent.#suspended = new CodeAgentSuspended(CodeAgentSuspended.fileOf(agent.#sessionDir, agent.sessionId));
+    if (agent.#sessionDir && options.profile.session.store === "file")
+      agent.#openMail(akanCodePaths.mailDir(workspaceRoot), cwd);
     for (const message of modelWarnings) agent.#emit({ type: "notice", level: "warning", message });
     return agent;
   }
@@ -262,6 +266,10 @@ export class CodeAgent {
   announce() {
     this.#emit({ type: "session", info: this.info });
     this.#restore();
+    //* A resumed worker says again what it is still waiting on, or a host that reattached has no card to answer.
+    const { question, approvals } = this.#suspended;
+    if (question) this.#emit({ type: "question", question });
+    for (const request of approvals) this.#emit({ type: "approval", request });
   }
 
   /**
@@ -346,10 +354,13 @@ export class CodeAgent {
       return true;
     }
     if (this.#profile.interaction.question !== "suspend") return false;
-    this.#emit({ type: "question_resolved", questionId, answer, rendered });
+    const suspended = this.#suspended.takeQuestion(questionId);
+    if (!suspended) return false;
+    const suspendedRendered = codeAgentRenderAnswer(suspended, answer);
+    this.#emit({ type: "question_resolved", questionId, answer, rendered: suspendedRendered });
     // The answer has to reach the model as prose: compaction and the next turn read message content only, so
     // an answer that exists solely as structure is one the agent will not remember being given.
-    await this.prompt(`The user answered: ${rendered}\nContinue the task.`);
+    await this.prompt(`The user answered: ${suspendedRendered}\nContinue the task.`);
     return true;
   }
 
@@ -359,6 +370,7 @@ export class CodeAgent {
       return true;
     }
     if (this.#profile.interaction.approval !== "suspend") return false;
+    if (!this.#suspended.takeApproval(approvalId)) return false;
     this.#emit({ type: "approval_resolved", approvalId, approved });
     if (approved) await this.prompt("The user approved the pending action. Retry it and continue.");
     return true;
@@ -561,17 +573,16 @@ export class CodeAgent {
     // Nobody to ask means nobody to refuse: a pod would otherwise deny every write it was created to make.
     if (!this.#profile.ui.canPrompt) return true;
     const approvalId = this.#asks.nextId("a");
-    this.#emit({
-      type: "approval",
-      request: {
-        approvalId,
-        toolCallId,
-        name,
-        summary: codeAgentClip(summary, codeAgentLabelChars),
-        policy: this.#profile.approval,
-      },
-    });
+    const request = {
+      approvalId,
+      toolCallId,
+      name,
+      summary: codeAgentClip(summary, codeAgentLabelChars),
+      policy: this.#profile.approval,
+    };
+    this.#emit({ type: "approval", request });
     if (this.#profile.interaction.approval === "suspend") {
+      this.#suspended.addApproval(request);
       this.#mapper.noteOutcome("awaiting");
       return false;
     }
@@ -586,10 +597,14 @@ export class CodeAgent {
    * between them. An empty answer is a skip, which is a real answer and not a failure.
    */
   async ask(spec: Omit<CodeAgentQuestion, "questionId">) {
-    if (!this.#profile.ui.canPrompt) return undefined;
     const question: CodeAgentQuestion = { questionId: this.#asks.nextId("q"), ...spec };
+    if (!this.#profile.ui.canPrompt) {
+      this.#emit({ type: "question_skipped", question, reason: "no-host" });
+      return undefined;
+    }
     this.#emit({ type: "question", question });
     if (this.#profile.interaction.question === "suspend") {
+      this.#suspended.setQuestion(question);
       this.#mapper.noteOutcome("awaiting");
       return undefined;
     }

package/codeAgent/agent/CodeAgentAsks.ts

@@ -19,6 +19,8 @@ export class CodeAgentAsks {
   #question: { question: CodeAgentQuestion; deferred: Deferred<string> } | undefined;
   readonly #approvals = new Map<string, Deferred<boolean>>();
   #nextId = 0;
+  //* Ids outlive the process on a suspending session, so a resumed worker must not hand out `q1` a second time.
+  readonly #epoch = Date.now().toString(36);
 
   get pendingQuestionId() {
     return this.#question?.question.questionId;
@@ -35,7 +37,7 @@ export class CodeAgentAsks {
 
   nextId(prefix: string) {
     this.#nextId += 1;
-    return `${prefix}${this.#nextId}`;
+    return `${prefix}${this.#epoch}.${this.#nextId}`;
   }
 
   openQuestion(question: CodeAgentQuestion) {

package/codeAgent/agent/CodeAgentEventMapper.ts

@@ -79,7 +79,15 @@ export class CodeAgentEventMapper {
       case "compaction_start":
         return [{ type: "compaction", phase: "start", reason: event.reason }];
       case "compaction_end":
-        return [{ type: "compaction", phase: "end", reason: event.reason }];
+        return [
+          {
+            type: "compaction",
+            phase: "end",
+            reason: event.reason,
+            ...(event.errorMessage ? { error: event.errorMessage } : {}),
+            ...(event.aborted ? { aborted: true } : {}),
+          },
+        ];
       case "auto_retry_start":
         return [
           {

package/codeAgent/agent/CodeAgentProxy.ts

@@ -0,0 +1,91 @@
+import { readFile } from "node:fs/promises";
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import type { CodeAgentProfile } from "akanjs/common";
+import { akanCodeDefaultModel } from "./akanCodeModel";
+
+interface PreparedRequest {
+  model: { provider: string; baseUrl?: string };
+  options: { apiKey?: string };
+}
+
+type PrepareRequest = (model: unknown, options?: Record<string, unknown>) => Promise<PreparedRequest>;
+
+export interface CodeAgentProxyOptions {
+  baseUrl: string;
+  providers: string[];
+  tokenFile?: string;
+  token?: string;
+}
+
+/**
+ * Routes every model request through a host's LLM proxy, so a pod never holds a provider key: the host mints a
+ * short-lived token, writes it to a file, and rotates it there while the worker keeps running.
+ *
+ * `baseUrl` may carry `{provider}` for a proxy that fronts several providers under one host.
+ */
+export class CodeAgentProxy {
+  static readonly placeholderKey = "akan-code-proxy";
+
+  readonly baseUrl: string;
+  readonly providers: string[];
+  readonly #tokenFile?: string;
+  readonly #token?: string;
+
+  constructor({ baseUrl, providers, tokenFile, token }: CodeAgentProxyOptions) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.providers = providers;
+    this.#tokenFile = tokenFile;
+    this.#token = token;
+    if (!tokenFile && !token)
+      throw new Error("AKAN_CODE_PROXY_URL needs AKAN_CODE_PROXY_TOKEN_FILE or AKAN_CODE_PROXY_TOKEN");
+  }
+
+  static fromEnv(profile?: CodeAgentProfile): CodeAgentProxy | null {
+    const baseUrl = process.env.AKAN_CODE_PROXY_URL?.trim() || profile?.network.proxyBaseUrl;
+    if (!baseUrl) return null;
+    const providers = (process.env.AKAN_CODE_PROXY_PROVIDERS ?? akanCodeDefaultModel.provider)
+      .split(",")
+      .map((provider) => provider.trim())
+      .filter(Boolean);
+    return new CodeAgentProxy({
+      baseUrl,
+      providers,
+      tokenFile: process.env.AKAN_CODE_PROXY_TOKEN_FILE?.trim() || undefined,
+      token: process.env.AKAN_CODE_PROXY_TOKEN?.trim() || undefined,
+    });
+  }
+
+  baseUrlFor(provider: string) {
+    return this.baseUrl.replaceAll("{provider}", provider);
+  }
+
+  //* Read per request, not cached: the host rotates a token that outlives no single turn, and a worker holding the
+  //* first one would start failing half an hour into a session it is still running.
+  async token() {
+    if (!this.#tokenFile) return this.#token ?? "";
+    const token = (await readFile(this.#tokenFile, "utf8")).trim();
+    if (!token) throw new Error(`${this.#tokenFile} is empty`);
+    return token;
+  }
+
+  /**
+   * `prepareRequest` is the one path every stream, completion, compaction and cache-warm request takes, which is
+   * why it is wrapped rather than the public stream methods. It is private in the engine's typings, so its
+   * absence after an engine upgrade fails here at boot instead of sending a request with no key.
+   */
+  async apply(runtime: ModelRuntime) {
+    const target = runtime as unknown as { prepareRequest?: PrepareRequest };
+    const original = target.prepareRequest?.bind(runtime);
+    if (!original) throw new Error("The model runtime no longer exposes prepareRequest; update CodeAgentProxy");
+    for (const provider of this.providers) await runtime.setRuntimeApiKey(provider, CodeAgentProxy.placeholderKey);
+    target.prepareRequest = async (model, options = {}) => {
+      const apiKey = await this.token();
+      const prepared = await original(model, { ...options, apiKey });
+      return {
+        ...prepared,
+        model: { ...prepared.model, baseUrl: this.baseUrlFor(prepared.model.provider) },
+        options: { ...prepared.options, apiKey },
+      };
+    };
+  }
+}

package/codeAgent/agent/CodeAgentRpcHost.ts

@@ -2,7 +2,7 @@ import type { CodeAgentCommand, CodeAgentEvent, CodeAgentReply, CodeAgentRequest
 import type { CodeAgent } from "./CodeAgent";
 
 /**
- * Serves one code agent over stdio as newline-delimited akan wire frames.
+ * Serves one code agent as newline-delimited akan wire frames, over stdio or whatever transport attaches.
  *
  * The protocol is **ours**, not the engine's: a host — the web relay, a pod runner, a test harness — reads the
  * same events the in-process API emits, so an engine upgrade stops at the core instead of reaching every
@@ -13,23 +13,41 @@ import type { CodeAgent } from "./CodeAgent";
  */
 export class CodeAgentRpcHost {
   readonly #agent: CodeAgent;
-  readonly #write: (line: string) => void;
+  #write: ((line: string) => void) | null;
   #buffer = "";
+  #started = false;
+  #resolveShutdown: () => void = () => {};
+  readonly shutdown = new Promise<void>((resolve) => {
+    this.#resolveShutdown = resolve;
+  });
 
-  constructor(agent: CodeAgent, write: (line: string) => void = (line) => process.stdout.write(line)) {
+  constructor(agent: CodeAgent, write: ((line: string) => void) | null = (line) => process.stdout.write(line)) {
     this.#agent = agent;
     this.#write = write;
   }
 
   async serve(input: AsyncIterable<Uint8Array> = process.stdin) {
-    this.#agent.on((event) => this.#emit(event));
-    this.#agent.announce();
+    this.start();
     const decoder = new TextDecoder();
-    for await (const chunk of input) await this.#push(decoder.decode(chunk, { stream: true }));
+    for await (const chunk of input) await this.feed(decoder.decode(chunk, { stream: true }));
     await this.#agent.abort().catch(() => {});
   }
 
-  async #push(text: string) {
+  start() {
+    if (this.#started) return;
+    this.#started = true;
+    this.#agent.on((event) => this.#emit(event));
+    this.#agent.announce();
+  }
+
+  //* Frames emitted while no client is attached are dropped here and kept in the agent's replay buffer; a client
+  //* that attaches catches up with `get_state { sinceSeq }` instead of receiving a burst it did not ask for.
+  attach(write: ((line: string) => void) | null) {
+    this.#write = write;
+    this.#buffer = "";
+  }
+
+  async feed(text: string) {
     this.#buffer += text;
     let index = this.#buffer.indexOf("\n");
     while (index >= 0) {
@@ -52,6 +70,8 @@ export class CodeAgentRpcHost {
     } catch (error) {
       this.#reply({ type: "reply", id: request.id, ok: false, error: String(error) });
     }
+    //* After the reply, so a socket transport that closes on shutdown has already written the acknowledgement.
+    if (request.command?.type === "shutdown") this.#resolveShutdown();
   }
 
   /**
@@ -87,10 +107,10 @@ export class CodeAgentRpcHost {
   }
 
   #emit(event: CodeAgentEvent) {
-    this.#write(`${JSON.stringify({ type: "event", event })}\n`);
+    this.#write?.(`${JSON.stringify({ type: "event", event })}\n`);
   }
 
   #reply(reply: CodeAgentReply) {
-    this.#write(`${JSON.stringify(reply)}\n`);
+    this.#write?.(`${JSON.stringify(reply)}\n`);
   }
 }

package/codeAgent/agent/CodeAgentRpcListener.ts

@@ -0,0 +1,117 @@
+import { existsSync, rmSync } from "node:fs";
+import type { Socket, SocketListener } from "bun";
+import type { CodeAgentRpcHost } from "./CodeAgentRpcHost";
+
+export type CodeAgentRpcAddress = { unix: string } | { hostname: string; port: number };
+
+interface ClientState {
+  pending: Buffer | null;
+  decoder: TextDecoder;
+}
+
+/**
+ * `akan code --rpc-listen <unix:PATH | tcp:[HOST:]PORT>` — the RPC host on a socket instead of stdio, so the agent
+ * outlives the process driving it. A control plane that restarts reconnects and resumes with
+ * `get_state { sinceSeq }`; the turn it was watching kept running in the meantime.
+ *
+ * One client at a time: a new connection replaces the old one, which is what a reconnecting control plane whose
+ * previous socket has not timed out yet needs. TCP binds 127.0.0.1 unless a host is named, because the wire has
+ * no authentication of its own — reach a pod through its unix socket and whatever the orchestrator already
+ * authenticates.
+ */
+export class CodeAgentRpcListener {
+  readonly #host: CodeAgentRpcHost;
+  readonly #address: CodeAgentRpcAddress;
+  #listener: SocketListener<ClientState> | null = null;
+  #client: Socket<ClientState> | null = null;
+
+  constructor(host: CodeAgentRpcHost, address: CodeAgentRpcAddress) {
+    this.#host = host;
+    this.#address = address;
+  }
+
+  static parse(spec: string): CodeAgentRpcAddress {
+    if (spec.startsWith("unix:")) return { unix: spec.slice("unix:".length) };
+    const rest = spec.startsWith("tcp:") ? spec.slice("tcp:".length) : spec;
+    const separator = rest.lastIndexOf(":");
+    const hostname = separator >= 0 ? rest.slice(0, separator) : "127.0.0.1";
+    const port = Number(separator >= 0 ? rest.slice(separator + 1) : rest);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535)
+      throw new Error(`--rpc-listen takes unix:<path> or tcp:[host:]<port>, not "${spec}"`);
+    return { hostname: hostname || "127.0.0.1", port };
+  }
+
+  get port() {
+    return this.#listener && "port" in this.#listener ? this.#listener.port : null;
+  }
+
+  listen() {
+    if ("unix" in this.#address && existsSync(this.#address.unix)) rmSync(this.#address.unix);
+    const socket = {
+      open: (client: Socket<ClientState>) => this.#open(client),
+      data: (client: Socket<ClientState>, data: Buffer) => this.#data(client, data),
+      drain: (client: Socket<ClientState>) => this.#drain(client),
+      close: (client: Socket<ClientState>) => this.#close(client),
+      error: (client: Socket<ClientState>) => this.#close(client),
+    };
+    this.#listener =
+      "unix" in this.#address
+        ? Bun.listen<ClientState>({ unix: this.#address.unix, socket })
+        : Bun.listen<ClientState>({ hostname: this.#address.hostname, port: this.#address.port, socket });
+    this.#host.start();
+    return this;
+  }
+
+  async serve() {
+    if (!this.#listener) this.listen();
+    await this.#host.shutdown;
+    this.stop();
+  }
+
+  stop() {
+    this.#client?.end();
+    this.#client = null;
+    this.#host.attach(null);
+    this.#listener?.stop(true);
+    this.#listener = null;
+    if ("unix" in this.#address && existsSync(this.#address.unix)) rmSync(this.#address.unix);
+  }
+
+  #open(client: Socket<ClientState>) {
+    client.data = { pending: null, decoder: new TextDecoder() };
+    const previous = this.#client;
+    this.#client = client;
+    previous?.end();
+    this.#host.attach((line) => this.#write(client, line));
+  }
+
+  #data(client: Socket<ClientState>, data: Buffer) {
+    if (client !== this.#client) return;
+    void this.#host.feed(client.data.decoder.decode(data, { stream: true }));
+  }
+
+  //* A socket write may take only part of a frame; the rest waits for `drain`, and frames behind it queue in order.
+  #write(client: Socket<ClientState>, line: string) {
+    if (client !== this.#client) return;
+    const bytes = Buffer.from(line);
+    if (client.data.pending) {
+      client.data.pending = Buffer.concat([client.data.pending, bytes]);
+      return;
+    }
+    const written = client.write(bytes);
+    if (written < bytes.length) client.data.pending = bytes.subarray(Math.max(0, written));
+  }
+
+  #drain(client: Socket<ClientState>) {
+    const pending = client.data.pending;
+    if (!pending) return;
+    const written = client.write(pending);
+    client.data.pending = written < pending.length ? pending.subarray(Math.max(0, written)) : null;
+  }
+
+  #close(client: Socket<ClientState>) {
+    if (client !== this.#client) return;
+    this.#client = null;
+    this.#host.attach(null);
+  }
+}

package/codeAgent/agent/CodeAgentSuspended.ts

@@ -0,0 +1,92 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import type { CodeAgentApprovalRequest, CodeAgentQuestion } from "akanjs/common";
+
+interface SuspendedState {
+  question?: CodeAgentQuestion;
+  approvals: CodeAgentApprovalRequest[];
+}
+
+/**
+ * What a suspending profile is waiting on after its turn ended — the question it asked and the approvals it
+ * parked. The turn is gone, so nothing in memory holds them; this does, and on a file-backed session it writes
+ * them beside the session so a worker that restarts and resumes still knows what it asked.
+ *
+ * Taking an ask removes it, which is what makes an answer idempotent: a second tab or a retried frame finds
+ * nothing to take and is refused instead of opening a second turn.
+ */
+export class CodeAgentSuspended {
+  readonly #file: string | null;
+  #state: SuspendedState;
+
+  constructor(file: string | null) {
+    this.#file = file;
+    this.#state = CodeAgentSuspended.#read(file);
+  }
+
+  static fileOf(sessionDir: string | undefined, sessionId: string) {
+    return sessionDir ? path.join(sessionDir, `${sessionId}.suspended.json`) : null;
+  }
+
+  get question() {
+    return this.#state.question;
+  }
+
+  get approvals(): readonly CodeAgentApprovalRequest[] {
+    return this.#state.approvals;
+  }
+
+  //* A new question replaces the old one: asking ends the turn, so the earlier question has nobody left to answer it.
+  setQuestion(question: CodeAgentQuestion) {
+    this.#state = { ...this.#state, question };
+    this.#save();
+  }
+
+  addApproval(request: CodeAgentApprovalRequest) {
+    this.#state = { ...this.#state, approvals: [...this.#state.approvals, request] };
+    this.#save();
+  }
+
+  takeQuestion(questionId: string) {
+    const question = this.#state.question;
+    if (question?.questionId !== questionId) return undefined;
+    this.#state = { approvals: this.#state.approvals };
+    this.#save();
+    return question;
+  }
+
+  takeApproval(approvalId: string) {
+    const request = this.#state.approvals.find((approval) => approval.approvalId === approvalId);
+    if (!request) return undefined;
+    this.#state = { ...this.#state, approvals: this.#state.approvals.filter((approval) => approval !== request) };
+    this.#save();
+    return request;
+  }
+
+  //* A prompt the user typed instead of answering moves the conversation on; the parked asks belong to a turn it replaced.
+  clear() {
+    if (!this.#state.question && !this.#state.approvals.length) return;
+    this.#state = { approvals: [] };
+    this.#save();
+  }
+
+  #save() {
+    if (!this.#file) return;
+    if (!this.#state.question && !this.#state.approvals.length) {
+      rmSync(this.#file, { force: true });
+      return;
+    }
+    mkdirSync(path.dirname(this.#file), { recursive: true });
+    writeFileSync(this.#file, `${JSON.stringify(this.#state)}\n`);
+  }
+
+  static #read(file: string | null): SuspendedState {
+    if (!file || !existsSync(file)) return { approvals: [] };
+    try {
+      const parsed = JSON.parse(readFileSync(file, "utf8")) as Partial<SuspendedState>;
+      return { ...(parsed.question ? { question: parsed.question } : {}), approvals: parsed.approvals ?? [] };
+    } catch {
+      return { approvals: [] };
+    }
+  }
+}

package/codeAgent/agent/akanCodeModel.ts

@@ -13,7 +13,7 @@ export interface CodeAgentModelRef {
 }
 
 /** DeepSeek's million-token window is what makes a 26k-token `AGENTS.md` affordable on every turn. */
-export const akanCodeDefaultModel: CodeAgentModelRef = { provider: "deepseek", id: "deepseek-v4-flash" };
+export const akanCodeDefaultModel: CodeAgentModelRef = { provider: "deepseek", id: "deepseek-flash" };
 
 /**
  * Models the catalogue declares text-only that take a picture anyway.

package/codeAgent/agent/akanContextFiles.test.ts

@@ -22,7 +22,8 @@ const loaded = (root: string, name = "AGENTS.md"): AkanContextFile[] => [
   { path: path.join(root, name), content: "the workspace guide" },
 ];
 
-const namesOf = (files: AkanContextFile[], root: string) => files.map((file) => path.relative(root, file.path));
+const namesOf = (files: AkanContextFile[], root: string) =>
+  files.map((file) => path.relative(root, file.path).split(path.sep).join("/"));
 
 afterEach(() => {
   for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });

package/codeAgent/agent/codeAgentContract.test.ts

@@ -292,6 +292,23 @@ describe("CodeAgentEventMapper", () => {
     const frames = mapper.map({ type: "agent_end", messages: [{ stopReason: "aborted" }], willRetry: false } as never);
     expect(frames).toEqual([{ type: "turn_end", turnId: "t1", stopReason: "aborted" }]);
   });
+
+  test("a compaction that failed or was cancelled carries that, not just its reason", () => {
+    const mapper = new CodeAgentEventMapper();
+    const end = (fields: object) =>
+      mapper.map({
+        type: "compaction_end",
+        reason: "threshold",
+        result: undefined,
+        willRetry: false,
+        ...fields,
+      } as never);
+    expect(end({ aborted: false, errorMessage: "Auto-compaction failed: 529" })).toEqual([
+      { type: "compaction", phase: "end", reason: "threshold", error: "Auto-compaction failed: 529" },
+    ]);
+    expect(end({ aborted: true })).toEqual([{ type: "compaction", phase: "end", reason: "threshold", aborted: true }]);
+    expect(end({ aborted: false })).toEqual([{ type: "compaction", phase: "end", reason: "threshold" }]);
+  });
 });
 
 describe("CodeAgentStreamPrinter", () => {

package/codeAgent/agent/codeAgentProxy.test.ts

@@ -0,0 +1,74 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { AkanCodeServices } from "./AkanCodeServices";
+import { akanCodeDefaultModel, akanCodeModel } from "./akanCodeModel";
+import { CodeAgentProxy } from "./CodeAgentProxy";
+
+const seen: { path: string; auth: string | null }[] = [];
+let proxy: ReturnType<typeof Bun.serve>;
+let home = "";
+let realHome: string | undefined;
+let realKey: string | undefined;
+
+const chunk = (delta: object, finish: string | null = null) =>
+  `data: ${JSON.stringify({
+    id: "c1",
+    object: "chat.completion.chunk",
+    created: 0,
+    model: akanCodeDefaultModel.id,
+    choices: [{ index: 0, delta, finish_reason: finish }],
+  })}\n\n`;
+
+beforeAll(() => {
+  home = mkdtempSync(path.join(tmpdir(), "akan-code-proxy-test-"));
+  realHome = process.env.AKAN_CODE_HOME;
+  realKey = process.env.DEEPSEEK_API_KEY;
+  process.env.AKAN_CODE_HOME = home;
+  process.env.DEEPSEEK_API_KEY = "real-provider-key-must-not-leave";
+  proxy = Bun.serve({
+    port: 0,
+    fetch: (req) => {
+      seen.push({ path: new URL(req.url).pathname, auth: req.headers.get("authorization") });
+      const body = `${chunk({ role: "assistant", content: "pong" })}${chunk({}, "stop")}data: [DONE]\n\n`;
+      return new Response(body, { headers: { "content-type": "text/event-stream" } });
+    },
+  });
+});
+
+afterAll(() => {
+  proxy.stop(true);
+  rmSync(home, { recursive: true, force: true });
+  if (realHome === undefined) delete process.env.AKAN_CODE_HOME;
+  else process.env.AKAN_CODE_HOME = realHome;
+  if (realKey === undefined) delete process.env.DEEPSEEK_API_KEY;
+  else process.env.DEEPSEEK_API_KEY = realKey;
+});
+
+describe("CodeAgentProxy", () => {
+  test("sends every request to the proxy with the token read from its file at that moment", async () => {
+    const tokenFile = path.join(home, "token");
+    writeFileSync(tokenFile, "session-token-1\n");
+    const codeProxy = new CodeAgentProxy({
+      baseUrl: `http://127.0.0.1:${proxy.port}/llm/{provider}/v1`,
+      providers: [akanCodeDefaultModel.provider],
+      tokenFile,
+    });
+    const runtime = await AkanCodeServices.runtime(home, codeProxy);
+    const model = await akanCodeModel(runtime);
+    expect(model?.provider).toBe("deepseek");
+    const context = { messages: [{ role: "user" as const, content: "ping", timestamp: Date.now() }] };
+    if (!model) throw new Error("no model");
+    const first = await runtime.completeSimple(model, context);
+    writeFileSync(tokenFile, "session-token-2\n");
+    await runtime.completeSimple(model, context);
+    expect(first.content).toEqual([expect.objectContaining({ type: "text", text: "pong" })]);
+    expect(seen.map((request) => request.auth)).toEqual(["Bearer session-token-1", "Bearer session-token-2"]);
+    expect(seen.every((request) => request.path.startsWith("/llm/deepseek/v1/"))).toBe(true);
+  });
+
+  test("refuses to start with a proxy URL and no token source", () => {
+    expect(() => new CodeAgentProxy({ baseUrl: "https://proxy", providers: ["deepseek"] })).toThrow("TOKEN");
+  });
+});