agent-sh 0.15.0 → 0.15.2

package/src/agent/providers/opencode.ts

@@ -0,0 +1,142 @@
+/**
+ * OpenCode Zen & Go providers — runtime model discovery via /models +
+ * models.dev metadata enrichment.
+ *
+ * Registers two providers:
+ *   - opencode     — Zen tier  (https://opencode.ai/zen/v1)
+ *   - opencode-go  — Go tier   (https://opencode.ai/zen/go/v1)
+ */
+import type { AgentContext } from "../host-types.js";
+import { resolveApiKey } from "../../cli/auth/keys.js";
+
+const ZEN_BASE_URL = "https://opencode.ai/zen/v1";
+const GO_BASE_URL = "https://opencode.ai/zen/go/v1";
+const MODELS_DEV_ENDPOINT = "https://models.dev/api.json";
+
+const DEFAULT_CTX = 128_000;
+const DEFAULT_MAX_TOKENS = 16_384;
+
+const ZEN_FALLBACK = ["claude-sonnet-4-6"];
+const GO_FALLBACK = ["gpt-5.2"];
+
+// ── Types ────────────────────────────────────────────────────────
+
+interface ModelsDevLimit { context?: number; output?: number; }
+interface ModelsDevEntry {
+  id?: string; name?: string; reasoning?: boolean;
+  limit?: ModelsDevLimit; modalities?: { input?: readonly string[] };
+}
+type ModelsDevResponse = Record<string, { models?: Record<string, ModelsDevEntry> }>;
+
+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}`);
+  return res.json() as T;
+}
+
+function findEntry(provider: ModelsDevResponse[string] | undefined, id: string): ModelsDevEntry | undefined {
+  const direct = provider?.models?.[id];
+  if (direct) return direct;
+  if (!provider?.models) return undefined;
+  return Object.values(provider.models).find((m) => m.id === id);
+}
+
+function resolveModel(id: string, meta: ModelsDevEntry | undefined): ModelDef {
+  const raw = meta?.modalities?.input;
+  const modalities: ("text" | "image")[] = Array.isArray(raw)
+    ? raw.filter((v): v is "text" | "image" => v === "text" || v === "image")
+    : ["text"];
+  return {
+    id,
+    reasoning: meta?.reasoning ?? false,
+    contextWindow: (typeof meta?.limit?.context === "number" && meta.limit.context > 0)
+      ? meta.limit.context : DEFAULT_CTX,
+    maxTokens: (typeof meta?.limit?.output === "number" && meta.limit.output > 0)
+      ? meta.limit.output : DEFAULT_MAX_TOKENS,
+    modalities,
+  };
+}
+
+function reasoningParams(level: string): Record<string, unknown> {
+  if (level === "off") return { reasoning_effort: "none" };
+  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;
+
+  ctx.agent.providers.configure("opencode", { reasoningParams });
+  ctx.agent.providers.register({
+    id: "opencode", apiKey, baseURL: ZEN_BASE_URL,
+    defaultModel: ZEN_FALLBACK[0], models: ZEN_FALLBACK,
+    supportsReasoningEffort: true,
+  });
+
+  ctx.agent.providers.configure("opencode-go", { reasoningParams });
+  ctx.agent.providers.register({
+    id: "opencode-go", apiKey, baseURL: GO_BASE_URL,
+    defaultModel: GO_FALLBACK[0], models: GO_FALLBACK,
+    supportsReasoningEffort: true,
+  });
+
+  if (!apiKey) return;
+
+  fetchModelsDev()
+    .then(async (md) => {
+      const zenIds = await fetchModelIds(ZEN_BASE_URL);
+      const goIds = await fetchModelIds(GO_BASE_URL);
+
+      const resolve = (ids: string[], prov: ModelsDevResponse[string] | undefined, fb: string[]) =>
+        (ids.length > 0 ? ids : fb).map((id) => resolveModel(id, findEntry(prov, id)));
+
+      const zen = resolve(zenIds, md?.opencode, ZEN_FALLBACK);
+      const go = resolve(goIds, md?.["opencode-go"], GO_FALLBACK);
+
+      ctx.agent.providers.register({
+        id: "opencode", apiKey, baseURL: ZEN_BASE_URL,
+        defaultModel: zen[0]?.id ?? ZEN_FALLBACK[0], models: zen,
+        supportsReasoningEffort: true,
+      });
+      ctx.agent.providers.register({
+        id: "opencode-go", apiKey, baseURL: GO_BASE_URL,
+        defaultModel: go[0]?.id ?? GO_FALLBACK[0], models: go,
+        supportsReasoningEffort: true,
+      });
+    })
+    .catch(() => {});
+}
+
+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; }
+}
+
+async function fetchModelIds(baseURL: string): Promise<string[]> {
+  try {
+    const res = await fetch(`${baseURL}/models`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (!res.ok) return [];
+    const payload = await res.json() as { data?: { id: string }[] };
+    if (!Array.isArray(payload.data)) return [];
+    return [...new Set(payload.data.map((e) => e.id).filter(Boolean))];
+  } catch { return []; }
+}

package/src/agent/providers/openrouter.ts

@@ -0,0 +1,105 @@
+/**
+ * Built-in OpenRouter provider — auto-activates when OPENROUTER_API_KEY is set.
+ * Registers curated defaults synchronously so the first query works, then
+ * fetches the full catalog to populate /model autocomplete.
+ */
+import type { AgentContext } from "../host-types.js";
+import { getSettings } from "../../core/settings.js";
+import { resolveApiKey } from "../../cli/auth/keys.js";
+
+const BASE_URL = "https://openrouter.ai/api/v1";
+
+const DEFAULT_MODELS = ["deepseek/deepseek-v4-flash"];
+
+// Built-in defaults for models requiring reasoning_content echoed back
+// (server 400s without it). Extend or override in settings.json:
+//   providers.openrouter.echoReasoningPatterns = ["deepseek", "..."]
+//   providers.openrouter.models[*].echoReasoning = true | false
+const BUILTIN_ECHO_REASONING_PATTERNS: RegExp[] = [/deepseek/i];
+
+// `effort: "none"` is the documented disable; honored by OpenAI/Grok, ignored
+// by Anthropic/Gemini/DeepSeek-via-OpenRouter (use native deepseek for a hard off).
+function buildReasoningParams(level: string, _model?: string): Record<string, unknown> {
+  return level === "off"
+    ? { reasoning: { effort: "none" } }
+    : { reasoning: { effort: level } };
+}
+
+interface OpenRouterModel {
+  id: string;
+  supported_parameters?: string[];
+  context_length?: number;
+  architecture?: { input_modalities?: string[] };
+}
+
+/** OpenRouter's input_modalities → the text/image subset; undefined when absent
+ *  so the fail-closed image guard treats the model as text-only. */
+function toModalities(input?: string[]): ("text" | "image")[] | undefined {
+  if (!Array.isArray(input)) return undefined;
+  const out = input.filter((v): v is "text" | "image" => v === "text" || v === "image");
+  return out.length ? out : undefined;
+}
+
+export default function activate(ctx: AgentContext): void {
+  const apiKey = resolveApiKey("openrouter").key;
+  ctx.agent.providers.configure("openrouter", { reasoningParams: buildReasoningParams });
+  ctx.agent.providers.register({
+    id: "openrouter",
+    apiKey: apiKey ?? undefined,
+    baseURL: BASE_URL,
+    defaultModel: DEFAULT_MODELS[0],
+    models: DEFAULT_MODELS,
+  });
+  if (!apiKey) return;
+
+  fetchModels(apiKey).then((models) => {
+    if (models.length === 0) return;
+    const userOverrides = readUserOverrides();
+    const patterns = readEchoPatterns();
+    ctx.agent.providers.register({
+      id: "openrouter",
+      apiKey,
+      baseURL: BASE_URL,
+      defaultModel: DEFAULT_MODELS[0],
+      supportsReasoningEffort: true,
+      models: models.map((m) => ({
+        id: m.id,
+        reasoning: m.supported_parameters?.includes("reasoning") ?? false,
+        contextWindow: m.context_length,
+        echoReasoning: userOverrides.get(m.id) ?? patterns.some((re) => re.test(m.id)),
+        modalities: toModalities(m.architecture?.input_modalities),
+      })),
+    });
+  }).catch(() => { /* keep curated defaults */ });
+}
+
+function readEchoPatterns(): RegExp[] {
+  const userPatterns = getSettings().providers?.openrouter?.echoReasoningPatterns ?? [];
+  const compiled: RegExp[] = [];
+  for (const src of userPatterns) {
+    try { compiled.push(new RegExp(src, "i")); }
+    catch { /* skip invalid pattern */ }
+  }
+  return [...BUILTIN_ECHO_REASONING_PATTERNS, ...compiled];
+}
+
+function readUserOverrides(): Map<string, boolean> {
+  const out = new Map<string, boolean>();
+  const models = getSettings().providers?.openrouter?.models;
+  if (!Array.isArray(models)) return out;
+  for (const m of models) {
+    if (typeof m === "object" && m && m.echoReasoning !== undefined) {
+      out.set(m.id, m.echoReasoning);
+    }
+  }
+  return out;
+}
+
+async function fetchModels(apiKey: string): Promise<OpenRouterModel[]> {
+  const res = await fetch(`${BASE_URL}/models`, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+  });
+  if (!res.ok) return [];
+  const data = await res.json() as { data?: OpenRouterModel[] };
+  return data.data ?? [];
+}

package/src/agent/providers/zai-coding-plan.ts

@@ -0,0 +1,33 @@
+/**
+ * Z.AI Coding Plan — Zhipu AI's subscription GLM models for coding.
+ */
+import type { AgentContext } from "../host-types.js";
+import { resolveApiKey } from "../../cli/auth/keys.js";
+
+const BASE_URL = "https://api.z.ai/api/coding/paas/v4";
+const ID = "zai-coding-plan";
+
+const DEFAULT_MODELS = [
+  { id: "glm-5.1",     reasoning: true, contextWindow: 200_000 },
+  { id: "glm-5-turbo", reasoning: true, contextWindow: 200_000 },
+  { id: "glm-4.7",     reasoning: true, contextWindow: 204_800 },
+  { id: "glm-4.5-air", reasoning: true, contextWindow: 131_072 },
+];
+
+function buildReasoningParams(level: string, _model?: string): Record<string, unknown> {
+  if (level === "off") return { thinking: { type: "disabled" } };
+  const effort = level === "xhigh" ? "high" : level;
+  return { thinking: { type: "enabled" }, reasoning_effort: effort };
+}
+
+export default function activate(ctx: AgentContext): void {
+  const { key } = resolveApiKey(ID);
+  ctx.agent.providers.configure(ID, { reasoningParams: buildReasoningParams });
+  ctx.agent.providers.register({
+    id: ID,
+    apiKey: key ?? process.env.ZAI_API_KEY ?? process.env.ZHIPU_API_KEY,
+    baseURL: BASE_URL,
+    defaultModel: DEFAULT_MODELS[0].id,
+    models: DEFAULT_MODELS,
+  });
+}

package/src/agent/session-store.ts

@@ -0,0 +1,336 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import type { AgentShMessage } from "./llm-client.js";
+export type { AgentShMessage } from "./llm-client.js";
+
+export interface SessionHeaderEntry {
+  type: "session";
+  id: string;
+  parentId: null;
+  timestamp: number;
+  cwd: string;
+  version: 1;
+}
+
+export interface MessageEntry {
+  type: "message";
+  id: string;
+  parentId: string;
+  timestamp: number;
+  message: AgentShMessage;
+}
+
+export interface CompactionEntry {
+  type: "compaction";
+  id: string;
+  parentId: string;
+  timestamp: number;
+  firstKeptId: string;
+  tokensBefore: number;
+  summary?: string;
+}
+
+/** Omitted from buildMessages — the agent already saw it via <shell_events>. */
+export interface ShellExchangeEntry {
+  type: "shell-exchange";
+  id: string;
+  parentId: string;
+  timestamp: number;
+  command: string;
+  output: string;
+  exitCode: number | null;
+  cwd?: string;
+  private?: boolean;
+}
+
+export type SessionEntry =
+  | SessionHeaderEntry
+  | MessageEntry
+  | CompactionEntry
+  | ShellExchangeEntry;
+
+export function newEntryId(): string {
+  return crypto.randomBytes(4).toString("hex");
+}
+
+function extractText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((p) => {
+      if (typeof p === "string") return p;
+      const part = p as { text?: string; content?: string };
+      return part?.text ?? part?.content ?? "";
+    }).join(" ");
+  }
+  return "";
+}
+
+function snippet(text: string, max: number): string {
+  const cleaned = String(text ?? "").replace(/\s+/g, " ").trim();
+  if (cleaned.length <= max) return cleaned || "(empty)";
+  return cleaned.slice(0, max) + "…";
+}
+
+export function summarizeMessage(m: AgentShMessage): string {
+  const role = m.role ?? "?";
+  if (role === "assistant") {
+    const tc = (m as { tool_calls?: Array<{ function?: { name?: string; arguments?: string } }> }).tool_calls;
+    if (Array.isArray(tc) && tc.length > 0) {
+      const tools = tc.map((t) => {
+        const name = t.function?.name ?? "tool";
+        const args = t.function?.arguments;
+        return args ? `${name}(${snippet(args, 200)})` : name;
+      }).join(", ");
+      const text = extractText(m.content);
+      const prefix = text ? `${snippet(text, 400)} → ` : "";
+      return `assistant: ${prefix}called ${tools}`;
+    }
+  }
+  if (role === "tool") {
+    const text = typeof m.content === "string" ? m.content : extractText(m.content);
+    const isErr = /^error\b|: error\b/i.test(text.slice(0, 200));
+    return `tool result: ${snippet(text, isErr ? 1000 : 400)}`;
+  }
+  if (role === "user") {
+    return `user: ${snippet(extractText(m.content), 1000)}`;
+  }
+  return `${role}: ${snippet(extractText(m.content), 500)}`;
+}
+
+/** For displayed user text. Loops because both wrappers can stack at the head. */
+export function stripContextWrappers(content: string): string {
+  let out = content;
+  for (;;) {
+    const next = out.replace(/^\s*<(query_context|dynamic_context)>[\s\S]*?<\/\1>\s*/, "");
+    if (next === out) return out;
+    out = next;
+  }
+}
+
+export function renderEvictedSummary(evicted: AgentShMessage[]): string {
+  const lines = evicted.map((m) => `- ${summarizeMessage(m)}`);
+  return `${lines.length} message(s) elided\n${lines.join("\n")}`;
+}
+
+export class SessionStore {
+  private entriesPath: string;
+  private leafPath: string;
+  private entries = new Map<string, SessionEntry>();
+  private rootId = "";
+  private activeLeaf = "";
+  private pendingHeader: SessionHeaderEntry | null = null;
+  readonly id: string;
+
+  constructor(filePath: string, opts?: { create?: { cwd: string; sessionId: string } }) {
+    this.entriesPath = filePath;
+    this.leafPath = filePath + ".leaf";
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+
+    if (opts?.create) {
+      this.id = opts.create.sessionId;
+      const header: SessionHeaderEntry = {
+        type: "session",
+        id: opts.create.sessionId,
+        parentId: null,
+        timestamp: Date.now(),
+        cwd: opts.create.cwd,
+        version: 1,
+      };
+      this.entries.set(header.id, header);
+      this.rootId = header.id;
+      this.activeLeaf = header.id;
+      this.pendingHeader = header;
+    } else {
+      this.id = "";
+      this.load();
+      if (!this.rootId) throw new Error(`session file lacks a session header: ${filePath}`);
+      this.id = this.rootId;
+    }
+  }
+
+  /** Deferred so an opened-but-unused session leaves no files on disk. */
+  private flushHeader(): void {
+    if (!this.pendingHeader) return;
+    const headerLine = JSON.stringify(this.pendingHeader) + "\n";
+    this.pendingHeader = null;
+    fs.writeFileSync(this.entriesPath, headerLine);
+    this.persistLeaf();
+  }
+
+  getActiveLeaf(): string { return this.activeLeaf; }
+  setActiveLeaf(id: string): void {
+    if (!this.entries.has(id)) throw new Error(`unknown entry: ${id}`);
+    this.activeLeaf = id;
+    this.persistLeaf();
+  }
+  getRootId(): string { return this.rootId; }
+  getEntry(id: string): SessionEntry | undefined { return this.entries.get(id); }
+  getAllEntries(): SessionEntry[] { return [...this.entries.values()]; }
+
+  async appendMessages(messages: AgentShMessage[]): Promise<string[]> {
+    if (messages.length === 0) return [];
+    this.flushHeader();
+    let parent = this.activeLeaf;
+    const lines: string[] = [];
+    const newIds: string[] = [];
+    for (const m of messages) {
+      const e: MessageEntry = {
+        type: "message",
+        id: newEntryId(),
+        parentId: parent,
+        timestamp: Date.now(),
+        message: m,
+      };
+      this.entries.set(e.id, e);
+      lines.push(JSON.stringify(e));
+      newIds.push(e.id);
+      parent = e.id;
+    }
+    this.activeLeaf = parent;
+    await fsp.appendFile(this.entriesPath, lines.join("\n") + "\n");
+    this.persistLeaf();
+    return newIds;
+  }
+
+  async appendShellExchange(e: {
+    command: string;
+    output: string;
+    exitCode: number | null;
+    cwd?: string;
+    private?: boolean;
+  }): Promise<string> {
+    this.flushHeader();
+    const entry: ShellExchangeEntry = {
+      type: "shell-exchange",
+      id: newEntryId(),
+      parentId: this.activeLeaf,
+      timestamp: Date.now(),
+      command: e.command,
+      output: e.output,
+      exitCode: e.exitCode,
+      ...(e.cwd !== undefined ? { cwd: e.cwd } : {}),
+      ...(e.private ? { private: true } : {}),
+    };
+    this.entries.set(entry.id, entry);
+    this.activeLeaf = entry.id;
+    await fsp.appendFile(this.entriesPath, JSON.stringify(entry) + "\n");
+    this.persistLeaf();
+    return entry.id;
+  }
+
+  async appendCompaction(firstKeptId: string, tokensBefore: number, summary?: string): Promise<string> {
+    if (!this.entries.has(firstKeptId)) throw new Error(`firstKeptId unknown: ${firstKeptId}`);
+    this.flushHeader();
+    const e: CompactionEntry = {
+      type: "compaction",
+      id: newEntryId(),
+      parentId: this.activeLeaf,
+      timestamp: Date.now(),
+      firstKeptId,
+      tokensBefore,
+      ...(summary !== undefined ? { summary } : {}),
+    };
+    this.entries.set(e.id, e);
+    this.activeLeaf = e.id;
+    await fsp.appendFile(this.entriesPath, JSON.stringify(e) + "\n");
+    this.persistLeaf();
+    return e.id;
+  }
+
+  /** Returns oldest-first. */
+  getBranch(leafId: string = this.activeLeaf): SessionEntry[] {
+    const out: SessionEntry[] = [];
+    const seen = new Set<string>();
+    let cur: string | null = leafId;
+    while (cur && !seen.has(cur)) {
+      seen.add(cur);
+      const e = this.entries.get(cur);
+      if (!e) break;
+      out.push(e);
+      cur = e.parentId;
+    }
+    return out.reverse();
+  }
+
+  /** Latest compaction on the branch replaces the evicted prefix with
+   *  its stored summary, or a rendered one if no summary was stored. */
+  buildMessages(leafId: string = this.activeLeaf): AgentShMessage[] {
+    return this.buildBranchWithIds(leafId).messages;
+  }
+
+  /** Parallel entryIds array — null for the synthetic compaction-summary
+   *  slot — so callers can map message indices back to on-disk ids. */
+  buildBranchWithIds(leafId: string = this.activeLeaf): { messages: AgentShMessage[]; entryIds: (string | null)[] } {
+    const branch = this.getBranch(leafId);
+    let compactionIdx = -1;
+    for (let i = branch.length - 1; i >= 0; i--) {
+      if (branch[i]!.type === "compaction") { compactionIdx = i; break; }
+    }
+    const messages: AgentShMessage[] = [];
+    const entryIds: (string | null)[] = [];
+    let startIdx = 0;
+    if (compactionIdx >= 0) {
+      const c = branch[compactionIdx] as CompactionEntry;
+      const firstKeptIdx = branch.findIndex((e) => e.id === c.firstKeptId);
+      startIdx = firstKeptIdx >= 0 ? firstKeptIdx : 0;
+      const summary = c.summary ?? renderEvictedSummary(
+        branch.slice(0, startIdx)
+          .filter((e): e is MessageEntry => e.type === "message")
+          .map((e) => e.message),
+      );
+      messages.push({ role: "user", content: `[Compacted conversation summary]\n${summary}` });
+      entryIds.push(null);
+    }
+    for (let i = startIdx; i < branch.length; i++) {
+      const e = branch[i]!;
+      if (e.type === "message") {
+        messages.push(e.message);
+        entryIds.push(e.id);
+      }
+    }
+    return { messages, entryIds };
+  }
+
+  getPreview(): string {
+    for (const e of this.entries.values()) {
+      if (e.type === "message" && e.message.role === "user") {
+        const raw = typeof e.message.content === "string" ? e.message.content : "";
+        const txt = stripContextWrappers(raw).replace(/\s+/g, " ").trim();
+        if (txt) return txt.slice(0, 80);
+      }
+    }
+    return "(empty)";
+  }
+
+  private load(): void {
+    let raw: string;
+    try { raw = fs.readFileSync(this.entriesPath, "utf-8"); }
+    catch { return; }
+    for (const line of raw.split("\n")) {
+      if (!line) continue;
+      try {
+        const e = JSON.parse(line) as SessionEntry;
+        if (!e.id) continue;
+        this.entries.set(e.id, e);
+        if (e.type === "session") this.rootId = e.id;
+      } catch { /* skip malformed */ }
+    }
+    try {
+      this.activeLeaf = fs.readFileSync(this.leafPath, "utf-8").trim();
+      if (!this.entries.has(this.activeLeaf)) this.activeLeaf = this.rootId;
+    } catch { this.activeLeaf = this.lastEntryId(); }
+  }
+
+  private lastEntryId(): string {
+    let lastId = this.rootId;
+    for (const e of this.entries.values()) lastId = e.id;
+    return lastId;
+  }
+
+  private persistLeaf(): void {
+    if (this.pendingHeader) return;
+    fs.writeFileSync(this.leafPath, this.activeLeaf);
+  }
+}