agent-sh 0.14.0 → 0.14.2

package/examples/extensions/claude-code-bridge/index.ts

@@ -21,6 +21,7 @@ export default function activate(ctx: ExtensionContext): void {
   };
 
   let activeQuery: Query | null = null;
+  let sessionId: string | null = null;
   const listeners: Array<{ event: string; fn: Function }> = [];
 
   // ── Tool display helpers ────────────────────────────────────────
@@ -97,6 +98,7 @@ export default function activate(ctx: ExtensionContext): void {
             allowedTools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
             permissionMode: "acceptEdits",
             includePartialMessages: true,
+            ...(sessionId ? { resume: sessionId } : {}),
           },
         });
 
@@ -138,6 +140,7 @@ export default function activate(ctx: ExtensionContext): void {
                   const kind = toolKind(meta.name);
                   bus.emit("agent:tool-started", {
                     title: meta.name,
+                    name: meta.name,
                     toolCallId: meta.id,
                     kind,
                     icon: toolIcon(meta.name),
@@ -174,6 +177,7 @@ export default function activate(ctx: ExtensionContext): void {
                   const kind = toolKind(b.name);
                   bus.emit("agent:tool-started", {
                     title: b.name,
+                    name: b.name,
                     toolCallId: b.id,
                     kind,
                     icon: toolIcon(b.name),
@@ -262,8 +266,11 @@ export default function activate(ctx: ExtensionContext): void {
               // Tool still running — nothing to do, TUI spinner already active
               break;
 
-            case "result":
+            case "result": {
+              const sid = (message as any).session_id;
+              if (typeof sid === "string" && sid) sessionId = sid;
               break;
+            }
           }
         }
 
@@ -291,7 +298,7 @@ export default function activate(ctx: ExtensionContext): void {
     };
 
     const onCancel = () => { activeQuery?.interrupt(); };
-    const onReset = () => { /* each query() is a new session */ };
+    const onReset = () => { sessionId = null; };
 
     bus.on("agent:submit", onSubmit);
     bus.on("agent:cancel-request", onCancel);

package/examples/extensions/claude-code-bridge/package.json

@@ -6,7 +6,7 @@
   "main": "index.ts",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.0",
-    "agent-sh": "^0.9.0",
+    "agent-sh": "^0.14.0",
     "zod": "^4.0.0"
   }
 }

package/examples/extensions/opencode-bridge/index.ts

@@ -13,6 +13,7 @@ import {
   type ToolPart,
   type QuestionRequest,
   type QuestionInfo,
+  type PermissionRequest,
 } from "@opencode-ai/sdk/v2";
 import type { ExtensionContext } from "agent-sh/types";
 import type { InteractiveSession } from "agent-sh/agent/types";
@@ -60,7 +61,8 @@ function parseUnifiedDiff(patch: string): DiffResult | null {
 }
 
 export default function activate(ctx: ExtensionContext): void {
-  const { bus, call } = ctx; const { compositor } = ctx.shell;
+  const { bus, call } = ctx;
+  const compositor = ctx.shell?.compositor;
 
   const cwd = (): string => {
     const v = call("cwd");
@@ -94,6 +96,18 @@ export default function activate(ctx: ExtensionContext): void {
   let turnIdleSeen = false;
   let turnError: string | null = null;
 
+  let pickerOpen = false;
+  const eventQueue: Event[] = [];
+  const drainQueue = (): void => {
+    const events = eventQueue.splice(0);
+    for (const ev of events) handleEvent(ev);
+  };
+
+  // After Ctrl+C, opencode emits a tail of tool / error state for the
+  // aborted turn. Suppress until the next turn so it doesn't restart the
+  // spinner or replay dead tool entries.
+  let cancelledTurn = false;
+
   const listeners: Array<{ event: string; fn: Function }> = [];
 
   function toolKind(name: string): string {
@@ -133,6 +147,7 @@ export default function activate(ctx: ExtensionContext): void {
       announcedTools.add(callID);
       bus.emit("agent:tool-started", {
         title: toolName,
+        name: toolName,
         toolCallId: callID,
         kind,
         locations: toolLocations(state.input ?? {}),
@@ -194,12 +209,24 @@ export default function activate(ctx: ExtensionContext): void {
 
 
   function handleEvent(event: Event): void {
+    if (pickerOpen) { eventQueue.push(event); return; }
     if (!sessionId) return;
     const evType = (event as any).type as string;
     const props = (event as any).properties ?? {};
     const sid = props.sessionID;
     if (typeof sid === "string" && sid !== sessionId) return;
 
+    if (cancelledTurn) {
+      // Only let through what unblocks onSubmit. Clearing the flag earlier
+      // (e.g. on session.error) lets the trailing bash part.updated slip
+      // past and restart the spinner.
+      if (evType === "session.idle" || evType === "session.error") {
+        turnIdleSeen = true;
+        pendingTurnEnd?.();
+      }
+      return;
+    }
+
     switch (evType) {
       // message.part.delta is undocumented in the SDK's Event union but
       // the SSE consumer yields it. Drop chunks for unknown partIDs —
@@ -242,72 +269,143 @@ export default function activate(ctx: ExtensionContext): void {
       case "question.asked": {
         const req = props as QuestionRequest;
         if (!runtime) break;
+        if (!compositor) {
+          runtime.client.question
+            .reject({ requestID: req.id, directory: sessionDirectory ?? undefined })
+            .catch(() => { /* best-effort */ });
+          bus.emit("ui:error", {
+            message: `opencode-bridge: rejected interactive question (no shell host): ${req.questions.map((q) => q.question).join("; ")}`,
+          });
+          break;
+        }
+        pickerOpen = true;
         const ui = createToolUI(bus, compositor.surface("agent"));
         ui.custom(createQuestionSession(req.questions)).then(async (result: QuestionResult) => {
-          if (!runtime) return;
-          // Record the question + answer as a synthetic tool entry so the
-          // timeline shows what was asked and what the user picked.
-          const callID = `question-${req.id}`;
-          const detail = req.questions.length === 1
-            ? req.questions[0]!.question
-            : req.questions.map((q, i) => `${q.header || `Q${i + 1}`}: ${q.question}`).join("; ");
-          bus.emit("agent:tool-started", {
-            title: "question",
-            toolCallId: callID,
-            kind: "execute",
-            displayDetail: detail,
-          });
-          if (result.cancelled) {
+          try {
+            if (!runtime) return;
+            // Record the question + answer as a synthetic tool entry so the
+            // timeline shows what was asked and what the user picked.
+            const callID = `question-${req.id}`;
+            const detail = req.questions.length === 1
+              ? req.questions[0]!.question
+              : req.questions.map((q, i) => `${q.header || `Q${i + 1}`}: ${q.question}`).join("; ");
+            bus.emit("agent:tool-started", {
+              title: "question",
+              name: "question",
+              toolCallId: callID,
+              kind: "execute",
+              displayDetail: detail,
+            });
+            if (result.cancelled) {
+              bus.emitTransform("agent:tool-completed", {
+                toolCallId: callID,
+                exitCode: 1,
+                rawOutput: "cancelled",
+                kind: "execute",
+                resultDisplay: { summary: "cancelled" },
+              });
+              runtime.client.question
+                .reject({ requestID: req.id, directory: sessionDirectory ?? undefined })
+                .catch(() => { /* best-effort */ });
+              return;
+            }
+            const summary = result.answers.length === 1
+              ? result.answers[0]!.join(", ")
+              : result.answers
+                  .map((ans, i) => `${req.questions[i]!.header || `Q${i + 1}`}: ${ans.join(", ")}`)
+                  .join("; ");
+            bus.emitTransform("agent:tool-completed", {
+              toolCallId: callID,
+              exitCode: 0,
+              rawOutput: summary,
+              kind: "execute",
+              resultDisplay: { summary },
+            });
+            try {
+              await runtime.client.question.reply({
+                requestID: req.id,
+                answers: result.answers,
+                directory: sessionDirectory ?? undefined,
+              });
+            } catch (err) {
+              bus.emit("agent:error", {
+                message: err instanceof Error ? err.message : String(err),
+              });
+            }
+          } finally {
+            pickerOpen = false;
+            if (result.cancelled) {
+              eventQueue.length = 0;
+              cancelledTurn = true;
+              pendingTurnEnd?.();
+            } else {
+              drainQueue();
+            }
+          }
+        });
+        break;
+      }
+      case "permission.asked": {
+        const req = props as PermissionRequest;
+        if (!runtime) break;
+        const detail = req.patterns.length > 0
+          ? `${req.permission}: ${req.patterns.join(", ")}`
+          : req.permission;
+        const finish = (reply: "once" | "always" | "reject", opts?: { note?: string; skipReply?: boolean }) => {
+          if (reply === "reject") {
+            const callID = `permission-${req.id}`;
+            const summary = opts?.note ? `denied (${opts.note})` : `denied: ${detail}`;
+            bus.emit("agent:tool-started", {
+              title: "permission",
+              name: "permission",
+              toolCallId: callID,
+              kind: "execute",
+              displayDetail: detail,
+            });
             bus.emitTransform("agent:tool-completed", {
               toolCallId: callID,
               exitCode: 1,
-              rawOutput: "cancelled",
+              rawOutput: summary,
               kind: "execute",
-              resultDisplay: { summary: "cancelled" },
+              resultDisplay: { summary },
             });
-            runtime.client.question
-              .reject({ requestID: req.id, directory: sessionDirectory ?? undefined })
-              .catch(() => { /* best-effort */ });
-            return;
           }
-          const summary = result.answers.length === 1
-            ? result.answers[0]!.join(", ")
-            : result.answers
-                .map((ans, i) => `${req.questions[i]!.header || `Q${i + 1}`}: ${ans.join(", ")}`)
-                .join("; ");
-          bus.emitTransform("agent:tool-completed", {
-            toolCallId: callID,
-            exitCode: 0,
-            rawOutput: summary,
-            kind: "execute",
-            resultDisplay: { summary },
+          if (!runtime || opts?.skipReply) return;
+          runtime.client.permission
+            .reply({ requestID: req.id, reply, directory: sessionDirectory ?? undefined })
+            .catch((err) => {
+              bus.emit("agent:error", {
+                message: err instanceof Error ? err.message : String(err),
+              });
+            });
+        };
+        if (!compositor) {
+          finish("reject", { note: "no shell host" });
+          bus.emit("ui:error", {
+            message: `opencode-bridge: rejected permission (no shell host): ${detail}`,
           });
+          break;
+        }
+        pickerOpen = true;
+        const ui = createToolUI(bus, compositor.surface("agent"));
+        ui.custom(createPermissionSession(req, bus)).then((result: PermissionResult) => {
           try {
-            await runtime.client.question.reply({
-              requestID: req.id,
-              answers: result.answers,
-              directory: sessionDirectory ?? undefined,
-            });
-          } catch (err) {
-            bus.emit("agent:error", {
-              message: err instanceof Error ? err.message : String(err),
-            });
+            finish(result.reply, result.cancelled ? { skipReply: true } : undefined);
+          } finally {
+            pickerOpen = false;
+            if (result.cancelled) {
+              // Let onSubmit's finally emit the single agent:processing-done;
+              // a second one here races and stacks prompts.
+              eventQueue.length = 0;
+              cancelledTurn = true;
+              pendingTurnEnd?.();
+            } else {
+              drainQueue();
+            }
           }
         });
         break;
       }
-      // Without a reply the gated tool hangs forever. The bridge has no
-      // interactive approval UI, so auto-approve — mirrors claude-code-
-      // bridge's permissionMode: "acceptEdits". Set permission.edit:
-      // "allow" in opencode.json to skip the round-trip entirely.
-      case "permission.asked": {
-        const requestID = props.id as string | undefined;
-        if (!requestID || !runtime) break;
-        runtime.client.permission
-          .reply({ requestID, reply: "once", directory: sessionDirectory ?? undefined })
-          .catch(() => { /* approval is best-effort */ });
-        break;
-      }
     }
   }
 
@@ -339,6 +437,7 @@ export default function activate(ctx: ExtensionContext): void {
       bus.emit("agent:query", { query: userQuery });
       bus.emit("agent:processing-start", {});
       turnText = "";
+      cancelledTurn = false;
       turnIdleSeen = false;
       turnError = null;
       // Set the idle waiter BEFORE prompt() so a fast session.idle can't
@@ -471,6 +570,7 @@ export default function activate(ctx: ExtensionContext): void {
 // ── Interactive question picker ──────────────────────────────────
 
 type QuestionResult = { answers: string[][]; cancelled: boolean };
+type PermissionResult = { reply: "once" | "always" | "reject"; cancelled?: boolean };
 
 function isKey(data: string, key: string): boolean {
   switch (key) {
@@ -601,3 +701,58 @@ function createQuestionSession(questions: QuestionInfo[]): InteractiveSession<Qu
     },
   };
 }
+
+function createPermissionSession(
+  req: PermissionRequest,
+  bus: { on: (e: "agent:cancel-request", fn: () => void) => void; off: (e: "agent:cancel-request", fn: () => void) => void },
+): InteractiveSession<PermissionResult> {
+  let cancelHandler: (() => void) | null = null;
+  // Cast widens onMount: the vendored agent-sh type still declares the 1-arg signature.
+  const onMount = ((_invalidate: () => void, done: (r: PermissionResult) => void): void => {
+    cancelHandler = () => done({ reply: "reject", cancelled: true });
+    bus.on("agent:cancel-request", cancelHandler);
+  }) as InteractiveSession<PermissionResult>["onMount"];
+  return {
+    onMount,
+    onUnmount() {
+      if (cancelHandler) bus.off("agent:cancel-request", cancelHandler);
+      cancelHandler = null;
+    },
+    render(_width) {
+      const lines: string[] = [];
+      lines.push(` ${p.warning}${p.bold}Permission required: ${req.permission}${p.reset}`);
+
+      const meta = req.metadata ?? {};
+      const cmd = typeof meta.command === "string" ? meta.command : null;
+      const file = typeof meta.file === "string"
+        ? meta.file
+        : typeof meta.path === "string" ? meta.path : null;
+      if (cmd) {
+        for (const line of cmd.split("\n").slice(0, 6)) {
+          lines.push(`   ${p.dim}${line}${p.reset}`);
+        }
+      } else if (file) {
+        lines.push(`   ${p.dim}${file}${p.reset}`);
+      }
+
+      if (req.patterns.length > 0 && !cmd && !file) {
+        for (const pat of req.patterns) {
+          lines.push(`   ${p.dim}${pat}${p.reset}`);
+        }
+      }
+
+      lines.push(` ${p.dim}[y] allow once  [a] allow always  [n] reject${p.reset}`);
+      return lines;
+    },
+
+    handleInput(data, done) {
+      if (isKey(data, "escape") || data === "n" || data === "N") {
+        done({ reply: "reject" });
+      } else if (data === "y" || data === "Y" || isKey(data, "enter")) {
+        done({ reply: "once" });
+      } else if (data === "a" || data === "A") {
+        done({ reply: "always" });
+      }
+    },
+  };
+}

package/examples/extensions/opencode-bridge/package.json

@@ -6,6 +6,6 @@
   "main": "index.ts",
   "dependencies": {
     "@opencode-ai/sdk": "^1.14.41",
-    "agent-sh": "^0.12.0"
+    "agent-sh": "^0.14.0"
   }
 }

package/examples/extensions/opencode-provider.ts

@@ -0,0 +1,252 @@
+/**
+ * opencode-provider — OpenCode Zen & Go LLM providers for agent-sh
+ *
+ * Registers two providers with runtime model discovery:
+ *   - opencode     — Zen tier (https://opencode.ai/zen/v1)
+ *   - opencode-go  — Go tier  (https://opencode.ai/zen/go/v1)
+ *
+ * Both are OpenAI-compatible endpoints. OpenCode's backend proxies
+ * all models (OpenAI, Anthropic, Google, etc.) through them — no
+ * per-model transport routing needed at the agent-sh level.
+ *
+ * ## Setup
+ *   export OPENCODE_***REDACTED***
+ *   agent-sh -e ./examples/extensions/opencode-provider.ts
+ *
+ *   # Or add to settings.json:
+ *   { "extensions": ["./examples/extensions/opencode-provider.ts"] }
+ *
+ *   # Or store via auth:
+ *   agent-sh auth login opencode
+ *
+ * ## Model discovery
+ * On startup the extension:
+ *   1. Fetches official /models endpoints (authoritative model list)
+ *   2. Merges metadata from models.dev (context windows, reasoning flags)
+ *   3. Falls back to models.dev membership → conservative defaults
+ *
+ * Usage:
+ *   /model          — tab-completes all discovered models
+ *   /provider       — switch between opencode / opencode-go
+ */
+
+import type { AgentContext } from "agent-sh/types";
+import { resolveApiKey } from "agent-sh/auth";
+
+// ── Constants ──────────────────────────────────────────────────────
+
+const ZEN_BASE_URL = "https://opencode.ai/zen/v1";
+const GO_BASE_URL = "https://opencode.ai/zen/go/v1";
+const ZEN_MODELS_ENDPOINT = `${ZEN_BASE_URL}/models`;
+const GO_MODELS_ENDPOINT = `${GO_BASE_URL}/models`;
+const MODELS_DEV_ENDPOINT = "https://models.dev/api.json";
+
+/** Conservative defaults when models.dev metadata is unavailable. */
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+const DEFAULT_MAX_TOKENS = 16_384;
+
+// ── Fallback model lists (curated; kept in sync with OpenCode docs) ──
+
+// Single fallback model per tier — the live /models catalog replaces these on startup.
+const ZEN_FALLBACK_MODELS = ["claude-sonnet-4-6"];
+
+const GO_FALLBACK_MODELS = ["gpt-5.2"];
+
+// ── Types ───────────────────────────────────────────────────────────
+
+interface ModelsDevLimit {
+  context?: number;
+  output?: number;
+}
+
+interface ModelsDevModelEntry {
+  id?: string;
+  name?: string;
+  reasoning?: boolean;
+  limit?: ModelsDevLimit;
+  modalities?: { input?: readonly string[] };
+}
+
+interface ModelsDevProviderEntry {
+  models?: Record<string, ModelsDevModelEntry>;
+}
+
+type ModelsDevResponse = Record<string, ModelsDevProviderEntry>;
+
+interface OpenCodeModelListEntry {
+  id?: string;
+}
+
+interface OpenCodeModelListResponse {
+  data?: OpenCodeModelListEntry[];
+}
+
+interface ModelDef {
+  id: string;
+  reasoning: boolean;
+  contextWindow: number;
+  maxTokens: number;
+  modalities: ("text" | "image")[];
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+async function fetchJson<T>(url: string): Promise<T> {
+  const res = await fetch(url, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} from ${url}`);
+  }
+  return res.json() as T;
+}
+
+function normalizePosNum(v: unknown): number | undefined {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : undefined;
+}
+
+// ── models.dev ──────────────────────────────────────────────────────
+
+async function fetchModelsDev(): Promise<ModelsDevResponse | undefined> {
+  try {
+    const payload = await fetchJson<ModelsDevResponse>(MODELS_DEV_ENDPOINT);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return undefined;
+    return payload;
+  } catch {
+    return undefined;
+  }
+}
+
+function getModelsDevModel(
+  provider: ModelsDevProviderEntry | undefined,
+  modelId: string,
+): ModelsDevModelEntry | undefined {
+  const direct = provider?.models?.[modelId];
+  if (direct) return direct;
+  if (!provider?.models) return undefined;
+  for (const m of Object.values(provider.models)) {
+    if (m.id === modelId) return m;
+  }
+  return undefined;
+}
+
+// ── Official /models ────────────────────────────────────────────────
+
+async function fetchOfficialModelIds(url: string): Promise<string[]> {
+  try {
+    const payload = await fetchJson<OpenCodeModelListResponse>(url);
+    if (!Array.isArray(payload.data)) throw new Error("Unexpected format");
+    const ids = new Set<string>();
+    for (const entry of payload.data) {
+      if (typeof entry.id === "string" && entry.id.trim()) {
+        ids.add(entry.id.trim());
+      }
+    }
+    return Array.from(ids);
+  } catch {
+    return [];
+  }
+}
+
+// ── Merge ───────────────────────────────────────────────────────────
+
+function resolveModel(
+  modelId: string,
+  metadata: ModelsDevModelEntry | undefined,
+): ModelDef {
+  const rawModalities = metadata?.modalities?.input;
+  const modalities: ("text" | "image")[] = Array.isArray(rawModalities)
+    ? rawModalities.filter((v): v is "text" | "image" => v === "text" || v === "image")
+    : ["text"];
+  return {
+    id: modelId,
+    reasoning: metadata?.reasoning ?? false,
+    contextWindow: normalizePosNum(metadata?.limit?.context) ?? DEFAULT_CONTEXT_WINDOW,
+    maxTokens: normalizePosNum(metadata?.limit?.output) ?? DEFAULT_MAX_TOKENS,
+    modalities,
+  };
+}
+
+// ── Reasoning params (OpenAI-compatible) ────────────────────────────
+
+function buildReasoningParams(level: string): Record<string, unknown> {
+  if (level === "off") return {};
+  return { reasoning_effort: level === "xhigh" ? "high" : level };
+}
+
+// ── Activation ──────────────────────────────────────────────────────
+
+export default function activate(ctx: AgentContext): void {
+  const apiKey =
+    process.env.OPENCODE_API_KEY ??
+    resolveApiKey("opencode").key ?? undefined;
+
+  // ── Phase 1: register both providers synchronously with fallback models ──
+
+  ctx.agent.providers.configure("opencode", { reasoningParams: buildReasoningParams });
+  ctx.agent.providers.register({
+    id: "opencode",
+    apiKey,
+    baseURL: ZEN_BASE_URL,
+    defaultModel: ZEN_FALLBACK_MODELS[0],
+    models: ZEN_FALLBACK_MODELS,
+    supportsReasoningEffort: true,
+  });
+
+  ctx.agent.providers.configure("opencode-go", { reasoningParams: buildReasoningParams });
+  ctx.agent.providers.register({
+    id: "opencode-go",
+    apiKey,
+    baseURL: GO_BASE_URL,
+    defaultModel: GO_FALLBACK_MODELS[0],
+    models: GO_FALLBACK_MODELS,
+    supportsReasoningEffort: true,
+  });
+
+  if (!apiKey) return;
+
+  // ── Phase 2: fetch live catalogs and re-register with enriched metadata ──
+
+  fetchModelsDev()
+    .then(async (modelsDev) => {
+      const zenProvider = modelsDev?.opencode;
+      const goProvider = modelsDev?.["opencode-go"];
+
+      const [zenIds, goIds] = await Promise.all([
+        fetchOfficialModelIds(ZEN_MODELS_ENDPOINT),
+        fetchOfficialModelIds(GO_MODELS_ENDPOINT),
+      ]);
+
+      const resolveModels = (
+        ids: string[],
+        provider: ModelsDevProviderEntry | undefined,
+        fallback: string[],
+      ): ModelDef[] => {
+        const source = ids.length > 0 ? ids : fallback;
+        return source.map((id) => resolveModel(id, getModelsDevModel(provider, id)));
+      };
+
+      const zenModels = resolveModels(zenIds, zenProvider, ZEN_FALLBACK_MODELS);
+      const goModels = resolveModels(goIds, goProvider, GO_FALLBACK_MODELS);
+
+      ctx.agent.providers.register({
+        id: "opencode",
+        apiKey,
+        baseURL: ZEN_BASE_URL,
+        defaultModel: zenModels[0]?.id ?? ZEN_FALLBACK_MODELS[0],
+        models: zenModels,
+        supportsReasoningEffort: true,
+      });
+
+      ctx.agent.providers.register({
+        id: "opencode-go",
+        apiKey,
+        baseURL: GO_BASE_URL,
+        defaultModel: goModels[0]?.id ?? GO_FALLBACK_MODELS[0],
+        models: goModels,
+        supportsReasoningEffort: true,
+      });
+    })
+    .catch(() => {});
+}

package/examples/extensions/pi-bridge/index.ts

@@ -206,6 +206,7 @@ export default function activate(ctx: ExtensionContext): void {
             }
             bus.emit("agent:tool-started", {
               title: ev.toolName,
+              name: ev.toolName,
               toolCallId: ev.toolCallId,
               kind: kindForTool(ev.toolName),
               rawInput: ev.args,