agent-sh 0.14.8 → 0.14.10

package/dist/agent/live-view.js

@@ -0,0 +1,238 @@
+import { stripMeta } from "./llm-client.js";
+export class LiveView {
+    messages = [];
+    messagesDirty = true;
+    cachedMessagesJson = null;
+    instanceId;
+    handlers;
+    lastApiTokenCount = null;
+    lastApiMessageCount = 0;
+    // Mid-tool-pair user/system messages are buffered and flushed after
+    // the trailing tool_result — splicing into the gap breaks
+    // reasoning_content pairing on strict providers.
+    pendingMessages = [];
+    constructor(handlers, instanceId = "0000") {
+        this.handlers = handlers ?? null;
+        this.instanceId = instanceId;
+    }
+    getMessagesJson() {
+        if (this.messagesDirty || this.cachedMessagesJson === null) {
+            this.cachedMessagesJson = JSON.stringify(this.messages);
+            this.messagesDirty = false;
+        }
+        return this.cachedMessagesJson;
+    }
+    invalidateMessagesCache() {
+        this.messagesDirty = true;
+        this.cachedMessagesJson = null;
+    }
+    addUserMessage(text) {
+        this.messages.push({ role: "user", content: text });
+        this.invalidateMessagesCache();
+    }
+    addAssistantMessage(content, toolCalls, extras) {
+        const hasToolCalls = !!toolCalls?.length;
+        // Promote reasoning into content on reasoning-only turns; strict
+        // providers (DeepSeek native) reject content="" with no tool_calls.
+        if (!content && !hasToolCalls) {
+            const r = (extras?.reasoning_content ?? extras?.reasoning);
+            if (typeof r === "string" && r)
+                content = r;
+        }
+        if (!content && !hasToolCalls)
+            return;
+        const base = {
+            role: "assistant",
+            content: hasToolCalls ? (content ?? null) : content,
+        };
+        if (hasToolCalls) {
+            base.tool_calls = toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: tc.function,
+            }));
+        }
+        if (extras)
+            Object.assign(base, extras);
+        this.messages.push(base);
+        this.invalidateMessagesCache();
+    }
+    addToolResult(toolCallId, content, isError = false) {
+        if (typeof content === "string") {
+            this.messages.push({ role: "tool", tool_call_id: toolCallId, content });
+        }
+        else {
+            const parts = [];
+            for (const img of content) {
+                parts.push({ type: "image_url", image_url: { url: `data:${img.mimeType};base64,${img.data}` } });
+            }
+            const label = isError ? `Error: [${content.length} image(s)]` : `[${content.length} image(s)]`;
+            parts.unshift({ type: "text", text: label });
+            this.messages.push({ role: "tool", tool_call_id: toolCallId, content: parts });
+        }
+        this.invalidateMessagesCache();
+        this.flushPendingMessages();
+    }
+    addToolResultInline(content) {
+        this.messages.push({ role: "user", content });
+        this.invalidateMessagesCache();
+        this.flushPendingMessages();
+    }
+    /** Safe from any context: queues if mid-tool-pair, appends otherwise. */
+    addSystemNote(text) {
+        if (this.hasOpenToolCalls()) {
+            this.pendingMessages.push({ kind: "system", text });
+            return;
+        }
+        this.messages.push({ role: "user", content: text });
+        this.invalidateMessagesCache();
+    }
+    appendUserMessage(text) {
+        if (this.hasOpenToolCalls()) {
+            this.pendingMessages.push({ kind: "user", text });
+            return;
+        }
+        this.addUserMessage(text);
+    }
+    hasOpenToolCalls() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const msg = this.messages[i];
+            if (msg.role === "tool")
+                continue;
+            if (msg.role !== "assistant")
+                return false;
+            if (!("tool_calls" in msg) || !msg.tool_calls)
+                return false;
+            const answered = new Set();
+            for (let j = i + 1; j < this.messages.length; j++) {
+                const m = this.messages[j];
+                if (m.role !== "tool")
+                    break;
+                answered.add(m.tool_call_id);
+            }
+            return msg.tool_calls.some((tc) => !answered.has(tc.id));
+        }
+        return false;
+    }
+    flushPendingMessages() {
+        if (this.pendingMessages.length === 0)
+            return;
+        if (this.hasOpenToolCalls())
+            return;
+        const pending = this.pendingMessages;
+        this.pendingMessages = [];
+        for (const m of pending) {
+            if (m.kind === "user") {
+                this.addUserMessage(m.text);
+            }
+            else {
+                this.messages.push({ role: "user", content: m.text });
+            }
+        }
+        this.invalidateMessagesCache();
+    }
+    getMessages() {
+        return this.normalizeReasoningConsistency(this.stubDanglingToolCalls(this.dropOrphanToolMessages(this.messages)));
+    }
+    get() {
+        return this.messages;
+    }
+    forLLM() {
+        return this.getMessages().map(stripMeta);
+    }
+    replace(msgs) {
+        this.replaceMessages(msgs);
+    }
+    link(index, entryId) {
+        const m = this.messages[index];
+        if (!m)
+            throw new Error(`LiveView.link: no message at index ${index}`);
+        const am = m;
+        am.meta = { ...am.meta, entryId };
+    }
+    /** DeepSeek 400s on tool messages without a matching tool_call;
+     *  compaction can leave such orphans. */
+    dropOrphanToolMessages(messages) {
+        const knownIds = new Set();
+        const result = [];
+        for (const msg of messages) {
+            if (msg.role === "assistant" && "tool_calls" in msg && msg.tool_calls) {
+                for (const tc of msg.tool_calls)
+                    knownIds.add(tc.id);
+            }
+            if (msg.role === "tool" && !knownIds.has(msg.tool_call_id)) {
+                continue;
+            }
+            result.push(msg);
+        }
+        return result;
+    }
+    /** Stub missing tool results after a mid-execution interrupt so
+     *  DeepSeek doesn't 400 on dangling tool_calls. */
+    stubDanglingToolCalls(messages) {
+        const result = [];
+        let i = 0;
+        while (i < messages.length) {
+            const msg = messages[i];
+            result.push(msg);
+            i++;
+            if (msg.role !== "assistant" || !("tool_calls" in msg) || !msg.tool_calls)
+                continue;
+            const seen = new Set();
+            while (i < messages.length && messages[i].role === "tool") {
+                const t = messages[i];
+                seen.add(t.tool_call_id);
+                result.push(t);
+                i++;
+            }
+            for (const tc of msg.tool_calls) {
+                if (!seen.has(tc.id)) {
+                    result.push({ role: "tool", tool_call_id: tc.id, content: "[cancelled]" });
+                }
+            }
+        }
+        return result;
+    }
+    /** DeepSeek 400s if any assistant in a thinking-mode conversation
+     *  is missing `reasoning_content`. Cross-alias `reasoning` (from
+     *  OpenRouter) and stub gaps with "". */
+    normalizeReasoningConsistency(messages) {
+        const needsNormalize = messages.some((m) => m.role === "assistant" && (m.reasoning !== undefined ||
+            m.reasoning_content !== undefined ||
+            m.reasoning_details !== undefined));
+        if (!needsNormalize)
+            return messages;
+        return messages.map((m) => {
+            if (m.role !== "assistant")
+                return m;
+            const a = m;
+            if (a.reasoning_content !== undefined)
+                return m;
+            return { ...m, reasoning_content: a.reasoning ?? "" };
+        });
+    }
+    /** Invalidates the API token baseline since the new array's count is unknown. */
+    replaceMessages(messages) {
+        this.messages = messages;
+        this.invalidateMessagesCache();
+        this.lastApiTokenCount = null;
+        this.lastApiMessageCount = 0;
+        this.flushPendingMessages();
+    }
+    updateApiTokenCount(promptTokens) {
+        this.lastApiTokenCount = promptTokens;
+        this.lastApiMessageCount = this.messages.length;
+    }
+    estimatePromptTokens() {
+        if (this.lastApiTokenCount === null)
+            return this.estimateTokens();
+        const trailing = this.messages.length - this.lastApiMessageCount;
+        if (trailing <= 0)
+            return this.lastApiTokenCount;
+        const trailingMessages = this.messages.slice(this.lastApiMessageCount);
+        return this.lastApiTokenCount + Math.ceil(JSON.stringify(trailingMessages).length / 4);
+    }
+    estimateTokens() {
+        return Math.ceil(this.getMessagesJson().length / 4);
+    }
+}

package/dist/agent/llm-client.d.ts

@@ -11,6 +11,7 @@ export type { ChatCompletionMessageParam, ChatCompletionTool };
 export type AgentShMessage = ChatCompletionMessageParam & {
     meta?: Record<string, unknown>;
 };
+export declare function stripMeta(m: ChatCompletionMessageParam): ChatCompletionMessageParam;
 export interface LlmClientConfig {
     apiKey: string;
     baseURL?: string;

package/dist/agent/llm-client.js

@@ -6,7 +6,7 @@
  * (command suggestions, completions).
  */
 import OpenAI from "openai";
-function stripMeta(m) {
+export function stripMeta(m) {
     if (!("meta" in m))
         return m;
     const { meta: _meta, ...rest } = m;

package/dist/agent/providers/ollama.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ollama provider — local daemon or Ollama Cloud.
+ *
+ * Cloud auth:  agent-sh auth login ollama-cloud
+ * Local host:  OLLAMA_HOST (default http://localhost:11434)
+ *
+ * Catalog comes from /api/tags; per-model context length is fetched
+ * from /api/show. Chat goes through the OpenAI-compatible /v1 shim.
+ */
+import type { AgentContext } from "../host-types.js";
+export default function activate(ctx: AgentContext): void;

package/dist/agent/providers/ollama.js

@@ -0,0 +1,72 @@
+import { resolveApiKey } from "../../cli/auth/keys.js";
+const ECHO_REASONING_PATTERNS = [/deepseek/i];
+export default function activate(ctx) {
+    const cloudKey = resolveApiKey("ollama-cloud").key ?? process.env.OLLAMA_API_KEY;
+    const host = cloudKey
+        ? "https://ollama.com"
+        : (process.env.OLLAMA_HOST ?? "http://localhost:11434").replace(/\/$/, "");
+    const id = cloudKey ? "ollama-cloud" : "ollama";
+    const sdkKey = cloudKey || "no-key";
+    const noAuth = !cloudKey;
+    const baseURL = `${host}/v1`;
+    const headers = {};
+    if (cloudKey)
+        headers.Authorization = `Bearer ${cloudKey}`;
+    ctx.agent.providers.configure(id, {
+        reasoningParams: (level) => {
+            if (level === "off")
+                return { reasoning_effort: "none" };
+            return { reasoning_effort: level === "xhigh" ? "high" : level };
+        },
+    });
+    ctx.agent.providers.register({ id, apiKey: sdkKey, baseURL, models: [], noAuth });
+    fetchCatalog(host, headers).then((models) => {
+        if (models.length === 0)
+            return;
+        ctx.agent.providers.register({
+            id,
+            apiKey: sdkKey,
+            baseURL,
+            defaultModel: models[0].id,
+            models,
+            noAuth,
+        });
+    }).catch(() => { });
+}
+async function fetchCatalog(host, headers) {
+    const tagsRes = await fetch(`${host}/api/tags`, { headers });
+    if (!tagsRes.ok)
+        return [];
+    const tagsData = await tagsRes.json();
+    const names = (tagsData.models ?? []).map((m) => m.name);
+    if (names.length === 0)
+        return [];
+    const ctxs = await Promise.all(names.map((name) => fetchContextLength(host, headers, name).catch(() => undefined)));
+    return names.map((name, i) => ({
+        id: name,
+        contextWindow: ctxs[i],
+        echoReasoning: ECHO_REASONING_PATTERNS.some((re) => re.test(name)),
+    }));
+}
+async function fetchContextLength(host, headers, name) {
+    const res = await fetch(`${host}/api/show`, {
+        method: "POST",
+        headers: { ...headers, "Content-Type": "application/json" },
+        body: JSON.stringify({ name }),
+    });
+    if (!res.ok)
+        return undefined;
+    const data = await res.json();
+    const info = data.model_info ?? {};
+    const arch = info["general.architecture"];
+    if (arch) {
+        const ctx = info[`${arch}.context_length`];
+        if (typeof ctx === "number")
+            return ctx;
+    }
+    for (const [k, v] of Object.entries(info)) {
+        if (k.endsWith(".context_length") && typeof v === "number")
+            return v;
+    }
+    return undefined;
+}

package/dist/agent/providers/opencode.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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";
+export default function activate(ctx: AgentContext): void;

package/dist/agent/providers/opencode.js

@@ -0,0 +1,112 @@
+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"];
+// ── Helpers ──────────────────────────────────────────────────────
+async function fetchJson(url) {
+    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();
+}
+function findEntry(provider, id) {
+    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, meta) {
+    const raw = meta?.modalities?.input;
+    const modalities = Array.isArray(raw)
+        ? raw.filter((v) => 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) {
+    if (level === "off")
+        return { reasoning_effort: "none" };
+    return { reasoning_effort: level === "xhigh" ? "high" : level };
+}
+// ── Activation ───────────────────────────────────────────────────
+export default function activate(ctx) {
+    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, prov, fb) => (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() {
+    try {
+        const payload = await fetchJson(MODELS_DEV_ENDPOINT);
+        if (!payload || typeof payload !== "object" || Array.isArray(payload))
+            return undefined;
+        return payload;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function fetchModelIds(baseURL) {
+    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();
+        if (!Array.isArray(payload.data))
+            return [];
+        return [...new Set(payload.data.map((e) => e.id).filter(Boolean))];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/agent/providers/zai-coding-plan.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Z.AI Coding Plan — Zhipu AI's subscription GLM models for coding.
+ */
+import type { AgentContext } from "../host-types.js";
+export default function activate(ctx: AgentContext): void;

package/dist/agent/providers/zai-coding-plan.js

@@ -0,0 +1,26 @@
+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, _model) {
+    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) {
+    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/dist/agent/session-store.d.ts

@@ -0,0 +1,90 @@
+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 declare function newEntryId(): string;
+export declare function summarizeMessage(m: AgentShMessage): string;
+/** For displayed user text. Loops because both wrappers can stack at the head. */
+export declare function stripContextWrappers(content: string): string;
+export declare function renderEvictedSummary(evicted: AgentShMessage[]): string;
+export declare class SessionStore {
+    private entriesPath;
+    private leafPath;
+    private entries;
+    private rootId;
+    private activeLeaf;
+    private pendingHeader;
+    readonly id: string;
+    constructor(filePath: string, opts?: {
+        create?: {
+            cwd: string;
+            sessionId: string;
+        };
+    });
+    /** Deferred so an opened-but-unused session leaves no files on disk. */
+    private flushHeader;
+    getActiveLeaf(): string;
+    setActiveLeaf(id: string): void;
+    getRootId(): string;
+    getEntry(id: string): SessionEntry | undefined;
+    getAllEntries(): SessionEntry[];
+    appendMessages(messages: AgentShMessage[]): Promise<string[]>;
+    appendShellExchange(e: {
+        command: string;
+        output: string;
+        exitCode: number | null;
+        cwd?: string;
+        private?: boolean;
+    }): Promise<string>;
+    appendCompaction(firstKeptId: string, tokensBefore: number, summary?: string): Promise<string>;
+    /** Returns oldest-first. */
+    getBranch(leafId?: string): SessionEntry[];
+    /** 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): AgentShMessage[];
+    /** Parallel entryIds array — null for the synthetic compaction-summary
+     *  slot — so callers can map message indices back to on-disk ids. */
+    buildBranchWithIds(leafId?: string): {
+        messages: AgentShMessage[];
+        entryIds: (string | null)[];
+    };
+    getPreview(): string;
+    private load;
+    private lastEntryId;
+    private persistLeaf;
+}