@akanjs/devkit 3.0.0-beta.14 → 3.0.0-beta.16

package/codeAgent/agent/CodeAgentEventMapper.ts

@@ -0,0 +1,260 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+import {
+  type CodeAgentEventBody,
+  type CodeAgentStopReason,
+  type CodeAgentToolOp,
+  type CodeAgentToolSummary,
+  codeAgentClip,
+  codeAgentLabelChars,
+  codeAgentOutputChars,
+} from "akanjs/common";
+
+const toolOps: { [key: string]: CodeAgentToolOp } = {
+  read: "read",
+  write: "write",
+  edit: "write",
+  ls: "list",
+  find: "search",
+  grep: "search",
+  bash: "execute",
+};
+
+/**
+ * Narrows the engine's event stream into the akan wire.
+ *
+ * One turn here is one user prompt, not one LLM round trip: the engine's `turn_start` fires once per round trip
+ * inside a run, which is an engine detail no host should have to fold. `agent_start`/`agent_end` are the
+ * boundaries a person perceives, so they become our `turn_start`/`turn_end`.
+ */
+export class CodeAgentEventMapper {
+  #turn = 0;
+  #turnId = "";
+  #outcome: CodeAgentStopReason | undefined;
+  readonly #openTools = new Map<string, CodeAgentToolSummary>();
+  readonly #blocked = new Map<string, string>();
+
+  get turnId() {
+    return this.#turnId;
+  }
+
+  map(event: AgentSessionEvent): CodeAgentEventBody[] {
+    switch (event.type) {
+      case "agent_start":
+        this.#turn += 1;
+        this.#turnId = `t${this.#turn}`;
+        // A hint left by an abort that hit an idle session must not colour the turn after it.
+        this.#outcome = undefined;
+        return [{ type: "turn_start", turnId: this.#turnId }];
+      case "agent_end":
+        // `turn_end` is last by contract. The engine finalizes the assistant message before the run ends even
+        // when the run was aborted, so a host that closes the turn on this frame has already seen it.
+        return [
+          ...this.flushBlocked(),
+          { type: "turn_end", turnId: this.#turnId, stopReason: this.#stopReason(event) },
+        ];
+      case "agent_settled":
+        return [{ type: "idle" }];
+      case "message_update":
+        return this.#mapDelta(event);
+      case "message_end":
+        return this.#mapMessage(event);
+      case "tool_execution_start": {
+        const tool = this.#summary(event.toolCallId, event.toolName, event.args);
+        this.#openTools.set(event.toolCallId, tool);
+        return [{ type: "tool_start", turnId: this.#turnId, tool }];
+      }
+      case "tool_execution_update":
+        return [
+          {
+            type: "tool_progress",
+            turnId: this.#turnId,
+            toolCallId: event.toolCallId,
+            text: codeAgentClip(CodeAgentEventMapper.#renderToolText(event.partialResult), codeAgentLabelChars),
+          },
+        ];
+      case "tool_execution_end":
+        return [this.#mapToolEnd(event)];
+      case "queue_update":
+        return [{ type: "queue", steering: [...event.steering], followUp: [...event.followUp] }];
+      case "compaction_start":
+        return [{ type: "compaction", phase: "start", reason: event.reason }];
+      case "compaction_end":
+        return [{ type: "compaction", phase: "end", reason: event.reason }];
+      case "auto_retry_start":
+        return [
+          {
+            type: "retry",
+            attempt: event.attempt,
+            maxAttempts: event.maxAttempts,
+            delayMs: event.delayMs,
+            message: event.errorMessage,
+          },
+        ];
+      default:
+        return [];
+    }
+  }
+
+  /**
+   * Records that a call was refused before it ran.
+   *
+   * The refusal arrives in the `tool_call` hook, which fires **before** `tool_execution_start` — measured: a
+   * blocked call produces no start event at all, and then a `tool_execution_end` carrying `isError`. So the
+   * start frame is synthesised here and the engine's own end frame is relabelled `blocked`, rather than
+   * synthesising a terminal frame that would arrive twice.
+   */
+  markBlocked(toolCallId: string, toolName: string, args: unknown, reason: string): CodeAgentEventBody[] {
+    this.#blocked.set(toolCallId, reason);
+    if (this.#openTools.has(toolCallId)) return [];
+    const tool = this.#summary(toolCallId, toolName, args);
+    this.#openTools.set(toolCallId, tool);
+    return [{ type: "tool_start", turnId: this.#turnId, tool }];
+  }
+
+  /** A refusal the engine never closed would leave a row open forever, so the turn boundary sweeps them. */
+  flushBlocked(): CodeAgentEventBody[] {
+    const frames: CodeAgentEventBody[] = [];
+    for (const [toolCallId, reason] of this.#blocked) {
+      const tool = this.#openTools.get(toolCallId);
+      if (!tool) continue;
+      this.#openTools.delete(toolCallId);
+      frames.push({
+        type: "tool_end",
+        turnId: this.#turnId,
+        tool,
+        outcome: "blocked",
+        output: reason,
+        truncated: false,
+      });
+    }
+    this.#blocked.clear();
+    return frames;
+  }
+
+  #mapToolEnd(event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>): CodeAgentEventBody {
+    const tool = this.#openTools.get(event.toolCallId) ?? this.#summary(event.toolCallId, event.toolName, undefined);
+    this.#openTools.delete(event.toolCallId);
+    const reason = this.#blocked.get(event.toolCallId);
+    this.#blocked.delete(event.toolCallId);
+    const full = reason ?? CodeAgentEventMapper.#renderToolText(event.result);
+    return {
+      type: "tool_end",
+      turnId: this.#turnId,
+      tool,
+      outcome: reason ? "blocked" : event.isError ? "error" : "ok",
+      output: codeAgentClip(full, codeAgentOutputChars),
+      truncated: full.length > codeAgentOutputChars,
+    };
+  }
+
+  /**
+   * Records how this turn is ending, from the side that actually knows.
+   *
+   * Consumed once, by the next `agent_end`. See {@link CodeAgentEventMapper.#stopReason} for why the engine's
+   * own report cannot be trusted for this.
+   */
+  noteOutcome(reason: CodeAgentStopReason) {
+    this.#outcome = reason;
+  }
+
+  /**
+   * **The engine does not report an abort.** Measured: interrupting a streaming turn finalizes the partial
+   * assistant message with `stopReason: "stop"` — the provider stream was cut, and from the engine's side that
+   * is an ordinary stop. Trusting it reports `done` for every interrupt, and a host then has no way to tell a
+   * finished answer from a truncated one.
+   *
+   * So the core's own record wins: it is the party that called `abort()`, and the party that suspended the
+   * turn to ask a question. The engine's report is only the fallback.
+   */
+  #stopReason(event: Extract<AgentSessionEvent, { type: "agent_end" }>): CodeAgentStopReason {
+    const noted = this.#outcome;
+    this.#outcome = undefined;
+    if (noted) return noted;
+    if (event.willRetry) return "error";
+    const last = event.messages.at(-1) as { stopReason?: string } | undefined;
+    if (last?.stopReason === "aborted") return "aborted";
+    if (last?.stopReason === "error") return "error";
+    // The engine's vocabulary is `stop | length | toolUse | error | aborted`. Branching on only the two that
+    // read as failures lets `length` — the model hitting its output cap — leave as `done`, and a half-written
+    // answer is then stored, and replayed to the next turn, as a finished one.
+    if (last?.stopReason === "length") return "truncated";
+    return "done";
+  }
+
+  #summary(toolCallId: string, name: string, args: unknown): CodeAgentToolSummary {
+    const path = CodeAgentEventMapper.#pathOf(args);
+    return {
+      toolCallId,
+      name,
+      op: toolOps[name] ?? "other",
+      ...(path ? { path } : {}),
+      title: codeAgentClip(`${name}${CodeAgentEventMapper.#renderArgs(args)}`, codeAgentLabelChars),
+    };
+  }
+
+  #mapDelta(event: Extract<AgentSessionEvent, { type: "message_update" }>): CodeAgentEventBody[] {
+    const inner = event.assistantMessageEvent;
+    if (inner.type === "text_delta") return [{ type: "text_delta", turnId: this.#turnId, text: inner.delta }];
+    if (inner.type === "thinking_delta") return [{ type: "thinking_delta", turnId: this.#turnId, text: inner.delta }];
+    return [];
+  }
+
+  #mapMessage(event: Extract<AgentSessionEvent, { type: "message_end" }>): CodeAgentEventBody[] {
+    const message = event.message as { role?: string; content?: unknown };
+    if (message.role !== "assistant" && message.role !== "user") return [];
+    const text = CodeAgentEventMapper.#renderContent(message.content);
+    if (!text) return [];
+    return [{ type: "message", turnId: this.#turnId, role: message.role, text }];
+  }
+
+  static #pathOf(args: unknown) {
+    if (!args || typeof args !== "object") return undefined;
+    const value = (args as { path?: unknown }).path;
+    return typeof value === "string" && value ? value : undefined;
+  }
+
+  /**
+   * A one-line rendering, never the values themselves: a `write` call's argument is the whole new file body and
+   * an `edit` call's is every replacement in it.
+   */
+  static #renderArgs(args: unknown) {
+    if (!args || typeof args !== "object") return "";
+    const entries = Object.entries(args as Record<string, unknown>).filter(([, value]) => value !== undefined);
+    if (!entries.length) return "";
+    const rendered = entries.map(([key, value]) => `${key}=${CodeAgentEventMapper.#renderArgValue(value)}`).join(" ");
+    return `(${codeAgentClip(rendered, 120)})`;
+  }
+
+  /**
+   * A structured argument is described by its shape, not stringified.
+   *
+   * `String({})` is `"[object Object]"` and an array of them is that repeated — which is where an `edit` call's
+   * replacement list ends up, so the row says nothing about a call that changed three places in a file.
+   */
+  static #renderArgValue(value: unknown) {
+    if (Array.isArray(value)) return `${value.length} item${value.length === 1 ? "" : "s"}`;
+    if (value && typeof value === "object") {
+      const keys = Object.keys(value as Record<string, unknown>).length;
+      return `{${keys} key${keys === 1 ? "" : "s"}}`;
+    }
+    return codeAgentClip(String(value), 60);
+  }
+
+  static #renderContent(content: unknown): string {
+    if (typeof content === "string") return content;
+    if (!Array.isArray(content)) return "";
+    return content
+      .filter(
+        (part): part is { type: string; text: string } => !!part && typeof part === "object" && part.type === "text",
+      )
+      .map((part) => part.text)
+      .join("");
+  }
+
+  static #renderToolText(value: unknown): string {
+    if (typeof value === "string") return value;
+    if (value && typeof value === "object" && "content" in value)
+      return CodeAgentEventMapper.#renderContent((value as { content: unknown }).content);
+    return value === undefined ? "" : JSON.stringify(value);
+  }
+}

package/codeAgent/agent/CodeAgentGate.ts

@@ -0,0 +1,119 @@
+import path from "node:path";
+import type { CodeAgentProfile } from "akanjs/common";
+
+const writeTools = new Set(["write", "edit"]);
+const commandTools = new Set(["bash"]);
+
+export interface GateVerdict {
+  /** `undefined` means the call may run without asking. */
+  block?: string;
+  approval?: string;
+}
+
+/**
+ * Decides, per tool call, whether the profile lets it through, needs a human, or is refused outright.
+ *
+ * Paths are checked here rather than inside a replacement for the engine's file operations because a refusal
+ * has to reach the model as a reason it can act on. An operations port that throws produces a stack trace the
+ * model reads as a bug in the tool, and it retries.
+ */
+export class CodeAgentGate {
+  readonly #profile: CodeAgentProfile;
+  readonly #deny: Bun.Glob[];
+  readonly #allow: Bun.Glob[];
+  readonly #deniedFragments: string[];
+
+  constructor(profile: CodeAgentProfile) {
+    this.#profile = profile;
+    this.#deny = (profile.paths.deny ?? []).map((pattern) => new Bun.Glob(pattern));
+    this.#allow = (profile.paths.allow ?? []).map((pattern) => new Bun.Glob(pattern));
+    this.#deniedFragments = [...new Set((profile.paths.deny ?? []).map(CodeAgentGate.#fragmentOf).filter(Boolean))];
+  }
+
+  verdict(toolName: string, args: unknown): GateVerdict {
+    const target = CodeAgentGate.#pathOf(args);
+    if (target) {
+      const denied = this.#deniedReason(target);
+      if (denied) return { block: denied };
+    }
+    const command = CodeAgentGate.#commandOf(args);
+    if (command) {
+      const denied = this.#deniedCommandReason(command);
+      if (denied) return { block: denied };
+    }
+    if (!this.#needsApproval(toolName)) return {};
+    return { approval: CodeAgentGate.#summarize(toolName, args) };
+  }
+
+  /**
+   * A shell command naming a denied file is refused on the literal text.
+   *
+   * ⚠️ **This is a speed bump, not a boundary.** A shell can reach any path the process can — through a
+   * variable, a glob, a subshell, `base64`, anything — and gating it properly would mean interpreting the
+   * command. The real boundary is the container the `pod` profile runs in. What this does buy is that the
+   * obvious accident, `cat .env`, does not put a live key into a transcript that is then persisted and
+   * replayed on every later turn.
+   */
+  #deniedCommandReason(command: string) {
+    const hit = this.#deniedFragments.find((fragment) => command.includes(fragment));
+    if (!hit) return undefined;
+    return `The command names "${hit}", which the profile's deny list covers. Ask the user for the value instead of reading the file.`;
+  }
+
+  #deniedReason(target: string) {
+    const absolute = path.isAbsolute(target) ? target : path.resolve(this.#profile.paths.root, target);
+    const relative = path.relative(this.#profile.paths.root, absolute);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+      return `Path is outside the agent root (${this.#profile.paths.root}).`;
+    if (this.#deny.some((glob) => glob.match(absolute) || glob.match(relative)))
+      return "Path is on the profile's deny list (secrets and environment files are never readable).";
+    if (this.#allow.length && !this.#allow.some((glob) => glob.match(absolute) || glob.match(relative)))
+      return "Path is outside the profile's allow list.";
+    return undefined;
+  }
+
+  #needsApproval(toolName: string) {
+    switch (this.#profile.approval) {
+      case "never":
+        return false;
+      case "writes":
+        return writeTools.has(toolName);
+      case "commands":
+        return commandTools.has(toolName);
+      case "all":
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  // A recursive secrets glob is only useful as the literal `secrets/`; a glob cannot be matched against a shell
+  // line. A pattern with a wildcard left in the middle yields nothing matchable, so it is dropped rather than
+  // guessed at.
+  static #fragmentOf(pattern: string) {
+    const trimmed = pattern
+      .replace(/^\*\*\//, "")
+      .replace(/\/\*\*$/, "/")
+      .replace(/^\*+/, "");
+    return trimmed.includes("*") ? "" : trimmed;
+  }
+
+  static #commandOf(args: unknown) {
+    if (!args || typeof args !== "object") return undefined;
+    const value = (args as { command?: unknown }).command;
+    return typeof value === "string" && value ? value : undefined;
+  }
+
+  static #pathOf(args: unknown) {
+    if (!args || typeof args !== "object") return undefined;
+    const value = (args as { path?: unknown }).path;
+    return typeof value === "string" && value ? value : undefined;
+  }
+
+  static #summarize(toolName: string, args: unknown) {
+    const record = (args ?? {}) as Record<string, unknown>;
+    if (toolName === "bash") return `run: ${String(record.command ?? "").slice(0, 200)}`;
+    const target = CodeAgentGate.#pathOf(args);
+    return target ? `${toolName} ${target}` : toolName;
+  }
+}

package/codeAgent/agent/CodeAgentRpcHost.ts

@@ -0,0 +1,96 @@
+import type { CodeAgentCommand, CodeAgentEvent, CodeAgentReply, CodeAgentRequest } from "akanjs/common";
+import type { CodeAgent } from "./CodeAgent";
+
+/**
+ * Serves one code agent over stdio as newline-delimited akan wire frames.
+ *
+ * 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
+ * consumer.
+ *
+ * stdout carries frames and nothing else. That only holds because `consoleToStderr` was imported before the
+ * engine: under Bun the engine's own stdout guard misses `console.log`, which writes to fd 1 natively.
+ */
+export class CodeAgentRpcHost {
+  readonly #agent: CodeAgent;
+  readonly #write: (line: string) => void;
+  #buffer = "";
+
+  constructor(agent: CodeAgent, write: (line: string) => void = (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();
+    const decoder = new TextDecoder();
+    for await (const chunk of input) await this.#push(decoder.decode(chunk, { stream: true }));
+    await this.#agent.abort().catch(() => {});
+  }
+
+  async #push(text: string) {
+    this.#buffer += text;
+    let index = this.#buffer.indexOf("\n");
+    while (index >= 0) {
+      const line = this.#buffer.slice(0, index).trim();
+      this.#buffer = this.#buffer.slice(index + 1);
+      if (line) await this.#handle(line);
+      index = this.#buffer.indexOf("\n");
+    }
+  }
+
+  async #handle(line: string) {
+    let request: CodeAgentRequest;
+    try {
+      request = JSON.parse(line) as CodeAgentRequest;
+    } catch {
+      return this.#emit({ type: "error", message: "malformed command frame", fatal: false, seq: -1 });
+    }
+    try {
+      this.#reply({ type: "reply", id: request.id, ok: true, data: await this.#run(request.command) });
+    } catch (error) {
+      this.#reply({ type: "reply", id: request.id, ok: false, error: String(error) });
+    }
+  }
+
+  /**
+   * `prompt` answers as soon as the turn is accepted, not when it finishes — a client that had to wait for the
+   * reply could not send `abort`, which is the one command that matters while a turn runs.
+   */
+  async #run(command: CodeAgentCommand): Promise<unknown> {
+    switch (command.type) {
+      case "prompt":
+        void this.#agent.prompt(command.message, command.images);
+        return { accepted: true };
+      case "answer":
+        return { handled: await this.#agent.answer(command.questionId, command.answer) };
+      case "approve":
+        return { handled: await this.#agent.approve(command.approvalId, command.approved) };
+      case "abort":
+        await this.#agent.abort();
+        return { aborted: true };
+      case "compact":
+        await this.#agent.compact(command.instructions);
+        return { compacted: true };
+      case "set_model":
+        await this.#agent.setModel({ provider: command.provider, id: command.modelId });
+        return await this.#agent.state();
+      case "get_state":
+        return await this.#agent.state(command.sinceSeq === undefined ? {} : { sinceSeq: command.sinceSeq });
+      case "shutdown":
+        this.#agent.dispose();
+        return { shutdown: true };
+      default:
+        throw new Error(`Unsupported command: ${command.type}`);
+    }
+  }
+
+  #emit(event: CodeAgentEvent) {
+    this.#write(`${JSON.stringify({ type: "event", event })}\n`);
+  }
+
+  #reply(reply: CodeAgentReply) {
+    this.#write(`${JSON.stringify(reply)}\n`);
+  }
+}

package/codeAgent/agent/CodeAgentStreamPrinter.ts

@@ -0,0 +1,93 @@
+import { type CodeAgentEvent, codeAgentEventLabel } from "akanjs/common";
+import chalk from "chalk";
+
+export interface CodeAgentStreamPrinterOptions {
+  /** One JSON object per line instead of prose, for a pipe that parses. */
+  json?: boolean;
+  thinking?: boolean;
+  write?: (text: string) => void;
+}
+
+/**
+ * Prints the akan wire to a terminal, reading nothing but the contract.
+ *
+ * That restriction is the point: the TUI and the web host read the same events, so anything this printer cannot
+ * render is a hole in the contract rather than a missing feature of one host.
+ */
+export class CodeAgentStreamPrinter {
+  readonly #options: CodeAgentStreamPrinterOptions;
+  readonly #write: (text: string) => void;
+  #streaming = false;
+
+  constructor(options: CodeAgentStreamPrinterOptions = {}) {
+    this.#options = options;
+    this.#write = options.write ?? ((text) => process.stdout.write(text));
+  }
+
+  print(event: CodeAgentEvent) {
+    if (this.#options.json) return this.#write(`${JSON.stringify(event)}\n`);
+    switch (event.type) {
+      case "text_delta":
+        this.#streaming = true;
+        return this.#write(event.text);
+      case "thinking_delta":
+        if (!this.#options.thinking) return;
+        this.#streaming = true;
+        return this.#write(chalk.dim(event.text));
+      case "message":
+        return;
+      case "tool_start":
+        return this.#line(chalk.cyan(`→ ${event.tool.title}`));
+      case "tool_progress":
+        return;
+      case "tool_end":
+        return this.#line(CodeAgentStreamPrinter.#toolEnd(event));
+      case "session":
+        return this.#line(chalk.dim(codeAgentEventLabel(event)));
+      case "turn_end":
+        // Every other reason is one the operator already knows: they typed the prompt, or pressed the key.
+        // A truncated answer is the one that looks exactly like a finished one unless it is said out loud.
+        if (event.stopReason === "truncated") return this.#line(chalk.yellow(codeAgentEventLabel(event)));
+        return;
+      case "turn_start":
+      case "idle":
+      case "queue":
+      case "context":
+        return;
+      case "question":
+        return this.#line(chalk.yellow(`? ${event.question.prompt}`));
+      case "approval":
+        return this.#line(chalk.yellow(`approve? ${event.request.summary}`));
+      case "notice":
+        return this.#line(CodeAgentStreamPrinter.#notice(event.level, event.message));
+      case "error":
+        return this.#line(chalk.red(`error: ${event.message}`));
+      default:
+        return this.#line(chalk.dim(codeAgentEventLabel(event)));
+    }
+  }
+
+  /** Closes a half-written streamed line so the exit code and the shell prompt do not land mid-sentence. */
+  finish() {
+    if (this.#streaming) this.#write("\n");
+    this.#streaming = false;
+  }
+
+  #line(text: string) {
+    if (this.#streaming) this.#write("\n");
+    this.#streaming = false;
+    this.#write(`${text}\n`);
+  }
+
+  static #toolEnd(event: Extract<CodeAgentEvent, { type: "tool_end" }>) {
+    if (event.outcome === "ok") return chalk.green(`✓ ${event.tool.title}`);
+    if (event.outcome === "blocked") return chalk.yellow(`⦸ ${event.tool.title} — ${event.output}`);
+    return chalk.red(`✗ ${event.tool.title} — ${event.output.split("\n")[0] ?? ""}`);
+  }
+
+  static #notice(level: "info" | "warning" | "error", message: string) {
+    if (level === "error") return chalk.red(message);
+    if (level === "warning") return chalk.yellow(message);
+    return chalk.dim(message);
+  }
+}

package/codeAgent/agent/CodeAgentUi.ts

@@ -0,0 +1,52 @@
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+
+export interface CodeAgentUiHandlers {
+  ask(prompt: string, kind: "text" | "select" | "confirm", choices?: string[]): Promise<string | undefined>;
+  notify(level: "info" | "warning" | "error", message: string): void;
+}
+
+/**
+ * The engine's UI port, answered by the akan wire instead of by a terminal.
+ *
+ * Only the four dialog calls and `notify` mean anything off a TUI; the rest of the port paints widgets, footers
+ * and editors that exist solely inside the engine's own interactive shell. They are no-ops here rather than
+ * throws — an extension that sets a status line should not take the turn down with it.
+ */
+export class CodeAgentUi {
+  readonly #handlers: CodeAgentUiHandlers;
+
+  constructor(handlers: CodeAgentUiHandlers) {
+    this.#handlers = handlers;
+  }
+
+  context(): ExtensionUIContext {
+    const noop = () => {};
+    const ui = {
+      select: async (title: string, options: string[]) => await this.#handlers.ask(title, "select", options),
+      confirm: async (title: string, message: string) => {
+        const answer = await this.#handlers.ask(message ? `${title}: ${message}` : title, "confirm");
+        return answer === "yes" || answer === "true";
+      },
+      input: async (title: string) => await this.#handlers.ask(title, "text"),
+      notify: (message: string, type: "info" | "warning" | "error" = "info") => this.#handlers.notify(type, message),
+      editor: async (title: string, prefill?: string) => (await this.#handlers.ask(title, "text")) ?? prefill,
+      onTerminalInput: () => noop,
+      setStatus: noop,
+      setWorkingMessage: noop,
+      setWorkingVisible: noop,
+      setWorkingIndicator: noop,
+      setHiddenThinkingLabel: noop,
+      setWidget: noop,
+      setFooter: noop,
+      setHeader: noop,
+      setTitle: noop,
+      custom: async () => undefined,
+      pasteToEditor: noop,
+      setEditorText: noop,
+      getEditorText: () => "",
+      addAutocompleteProvider: noop,
+      setCustomEditorComponent: noop,
+    };
+    return ui as unknown as ExtensionUIContext;
+  }
+}