agent-sh 0.13.2 → 0.13.4

package/dist/agent/agent-loop.js

@@ -87,7 +87,7 @@ export class AgentLoop {
     // doing X." Addresses Q3 in QUESTIONS.md.
     lastErrorByTool = new Map(); // tool → error summary
     lastErrorByFile = new Map(); // file path → error summary
-    static THINKING_LEVELS = ["off", "low", "medium", "high"];
+    static THINKING_LEVELS = ["off", "low", "medium", "high", "xhigh"];
     bus;
     llmClient;
     handlers;
@@ -168,8 +168,13 @@ export class AgentLoop {
             ];
             if (prev) {
                 const newIdx = this.modes.findIndex((m) => m.model === prev.model && m.provider === prev.provider);
-                if (newIdx !== -1)
+                if (newIdx !== -1) {
                     this.currentModeIndex = newIdx;
+                    const next = this.modes[newIdx];
+                    if (next.providerConfig && next.providerConfig !== prev.providerConfig) {
+                        this.llmClient.reconfigure({ ...next.providerConfig, model: next.model });
+                    }
+                }
             }
             if (activePreserved && prev) {
                 this.bus.emit("ui:info", {
@@ -507,7 +512,8 @@ export class AgentLoop {
             return mode.buildReasoningParams(this.thinkingLevel);
         if (this.thinkingLevel === "off")
             return {};
-        return { reasoning_effort: this.thinkingLevel };
+        const effort = this.thinkingLevel === "xhigh" ? "high" : this.thinkingLevel;
+        return { reasoning_effort: effort };
     }
     get currentMode() {
         return this.modes[this.currentModeIndex];
@@ -1076,12 +1082,15 @@ export class AgentLoop {
                 streamedCalls: streamedToolCalls,
             });
             fullResponseText += text;
-            // Record the assistant message via protocol
-            this.toolProtocol.recordAssistant(this.conversation, text, toolCalls, extras);
-            this.bus.emit("conversation:message-appended", {
-                role: "assistant",
-                content: text,
-            });
+            if (text || toolCalls.length > 0) {
+                this.toolProtocol.recordAssistant(this.conversation, text, toolCalls, extras);
+                this.bus.emit("conversation:message-appended", {
+                    role: "assistant",
+                    content: text,
+                });
+            }
+            if (signal.aborted)
+                break;
             // No tool calls → agent is done
             if (toolCalls.length === 0) {
                 this.conversation.eagerNucleateAgent(fullResponseText);
@@ -1201,7 +1210,7 @@ export class AgentLoop {
                     signal });
                 // Truncate large outputs to avoid blowing context.
                 let content = result.content;
-                const maxBytes = tool.maxResultBytes ?? 16_384; // ~4k tokens
+                const maxBytes = tool.maxResultBytes ?? 100_000; // ~25k tokens
                 if (content.length > maxBytes) {
                     const headBytes = Math.floor(maxBytes * 0.6);
                     const tailBytes = maxBytes - headBytes;
@@ -1502,83 +1511,90 @@ export class AgentLoop {
         };
         this.bus.emit("llm:request", requestParams);
         const stream = await this.llmClient.stream({ ...requestParams, signal });
-        for await (const chunk of stream) {
-            if (signal.aborted)
-                break;
-            this.bus.emit("llm:chunk", { chunk });
-            // Token usage (may arrive in a chunk with empty choices)
-            if (chunk.usage) {
-                const u = chunk.usage;
-                const promptTokens = u.prompt_tokens ?? 0;
-                this.bus.emit("agent:usage", {
-                    prompt_tokens: promptTokens,
-                    completion_tokens: u.completion_tokens ?? 0,
-                    total_tokens: u.total_tokens ?? 0,
-                });
-                // Feed accurate token count back to conversation state
-                if (promptTokens > 0) {
-                    this.conversation.updateApiTokenCount(promptTokens);
-                }
-            }
-            const choice = chunk.choices[0];
-            if (!choice)
-                continue;
-            const delta = choice.delta;
-            // Text content
-            if (delta?.content) {
-                text += delta.content;
-                // Filter tool tags from display output (inline mode)
-                const displayText = streamFilter
-                    ? streamFilter.feed(delta.content)
-                    : delta.content;
-                if (displayText) {
-                    this.bus.emitTransform("agent:response-chunk", {
-                        blocks: [{ type: "text", text: displayText }],
+        try {
+            for await (const chunk of stream) {
+                if (signal.aborted)
+                    break;
+                this.bus.emit("llm:chunk", { chunk });
+                // Token usage (may arrive in a chunk with empty choices)
+                if (chunk.usage) {
+                    const u = chunk.usage;
+                    const promptTokens = u.prompt_tokens ?? 0;
+                    this.bus.emit("agent:usage", {
+                        prompt_tokens: promptTokens,
+                        completion_tokens: u.completion_tokens ?? 0,
+                        total_tokens: u.total_tokens ?? 0,
                     });
+                    // Feed accurate token count back to conversation state
+                    if (promptTokens > 0) {
+                        this.conversation.updateApiTokenCount(promptTokens);
+                    }
                 }
-            }
-            const d = delta;
-            for (const name of ["reasoning", "reasoning_content"]) {
-                if (typeof d?.[name] === "string" && d[name].length > 0) {
-                    reasoning += d[name];
-                    reasoningField ??= name;
-                    this.bus.emit("agent:thinking-chunk", { text: d[name] });
-                }
-            }
-            if (Array.isArray(d?.reasoning_details)) {
-                for (const x of d.reasoning_details) {
-                    const idx = typeof x?.index === "number" ? x.index : reasoningDetailsByIndex.size;
-                    const prev = reasoningDetailsByIndex.get(idx);
-                    if (!prev) {
-                        reasoningDetailsByIndex.set(idx, { ...x });
+                const choice = chunk.choices[0];
+                if (!choice)
+                    continue;
+                const delta = choice.delta;
+                // Text content
+                if (delta?.content) {
+                    text += delta.content;
+                    // Filter tool tags from display output (inline mode)
+                    const displayText = streamFilter
+                        ? streamFilter.feed(delta.content)
+                        : delta.content;
+                    if (displayText) {
+                        this.bus.emitTransform("agent:response-chunk", {
+                            blocks: [{ type: "text", text: displayText }],
+                        });
                     }
-                    else {
-                        if (typeof x.text === "string")
-                            prev.text = (prev.text ?? "") + x.text;
-                        for (const [k, v] of Object.entries(x))
-                            if (k !== "text" && prev[k] === undefined)
-                                prev[k] = v;
+                }
+                const d = delta;
+                for (const name of ["reasoning", "reasoning_content"]) {
+                    if (typeof d?.[name] === "string" && d[name].length > 0) {
+                        reasoning += d[name];
+                        reasoningField ??= name;
+                        this.bus.emit("agent:thinking-chunk", { text: d[name] });
                     }
                 }
-            }
-            // Tool calls (streamed incrementally)
-            if (delta?.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    const idx = tc.index;
-                    if (!pendingToolCalls[idx]) {
-                        pendingToolCalls[idx] = {
-                            id: tc.id,
-                            name: tc.function.name,
-                            argumentsJson: "",
-                        };
+                if (Array.isArray(d?.reasoning_details)) {
+                    for (const x of d.reasoning_details) {
+                        const idx = typeof x?.index === "number" ? x.index : reasoningDetailsByIndex.size;
+                        const prev = reasoningDetailsByIndex.get(idx);
+                        if (!prev) {
+                            reasoningDetailsByIndex.set(idx, { ...x });
+                        }
+                        else {
+                            if (typeof x.text === "string")
+                                prev.text = (prev.text ?? "") + x.text;
+                            for (const [k, v] of Object.entries(x))
+                                if (k !== "text" && prev[k] === undefined)
+                                    prev[k] = v;
+                        }
                     }
-                    if (tc.function?.arguments) {
-                        pendingToolCalls[idx].argumentsJson +=
-                            tc.function.arguments;
+                }
+                // Tool calls (streamed incrementally)
+                if (delta?.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        const idx = tc.index;
+                        if (!pendingToolCalls[idx]) {
+                            pendingToolCalls[idx] = {
+                                id: tc.id,
+                                name: tc.function.name,
+                                argumentsJson: "",
+                            };
+                        }
+                        if (tc.function?.arguments) {
+                            pendingToolCalls[idx].argumentsJson +=
+                                tc.function.arguments;
+                        }
                     }
                 }
             }
         }
+        catch (e) {
+            // On abort, fall through with whatever was accumulated so far.
+            if (!signal.aborted)
+                throw e;
+        }
         // Flush any buffered content from the stream filter
         if (streamFilter) {
             const remaining = streamFilter.flush();

package/dist/agent/index.js

@@ -15,7 +15,9 @@ function persistedModelFor(providerName) {
     return getSettings().providers?.[providerName]?.defaultModel;
 }
 function defaultReasoningBuilder(level) {
-    return level === "off" ? {} : { reasoning_effort: level };
+    if (level === "off")
+        return {};
+    return { reasoning_effort: level === "xhigh" ? "high" : level };
 }
 function mergeCaps(settingsCaps, payloadCaps, modelIds) {
     if (!settingsCaps)
@@ -118,11 +120,12 @@ export default function agentBackend(ctx) {
     ctx.define("llm:get-client", () => llmClient);
     ctx.define("llm:invoke", (messages, opts) => {
         const effort = opts?.reasoningEffort;
+        const clampedEffort = effort === "xhigh" ? "high" : effort;
         return llmClient.complete({
             messages: messages,
             max_tokens: opts?.maxTokens,
             model: opts?.model,
-            ...(effort && effort !== "off" ? { reasoning_effort: effort } : {}),
+            ...(clampedEffort && clampedEffort !== "off" ? { reasoning_effort: clampedEffort } : {}),
         });
     });
     let modes = [];

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

@@ -2,6 +2,8 @@
  * Cloud OpenAI (api.openai.com). reasoning_effort vocabulary diverges per
  * family: o-series has no off; gpt-5-codex floors at "low"; plain gpt-5
  * floors at "minimal"; gpt-5.1+ accepts "none" as documented full off.
+ * Top tier: only gpt-5.1-codex-max and gpt-5.[4-9]+ accept "xhigh"; others
+ * clamp to "high".
  */
 import type { AgentContext } from "../host-types.js";
 export default function activate(ctx: AgentContext): void;

package/dist/agent/providers/openai.js

@@ -18,9 +18,16 @@ function offEffortFor(model) {
         return "minimal";
     return null;
 }
+function supportsXhigh(model) {
+    if (model.startsWith("gpt-5.1-codex-max"))
+        return true;
+    return /^gpt-5\.[4-9]/.test(model);
+}
 function buildReasoningParams(level, model) {
-    if (level !== "off")
-        return { reasoning_effort: level };
+    if (level !== "off") {
+        const effort = level === "xhigh" && !(model && supportsXhigh(model)) ? "high" : level;
+        return { reasoning_effort: effort };
+    }
     const off = model ? offEffortFor(model) : null;
     return off ? { reasoning_effort: off } : {};
 }

package/dist/utils/diff-renderer.d.ts

@@ -14,6 +14,12 @@ export interface DiffRenderOptions {
     /** Enable syntax highlighting on diff lines. Default true. */
     syntaxHighlight?: boolean;
 }
+export declare function detectLanguage(filePath?: string): string | undefined;
+/**
+ * Syntax-highlight a single line of code.
+ * Returns the original text if highlighting fails or no language detected.
+ */
+export declare function highlightLine(text: string, language?: string): string;
 /** Select display mode based on available terminal width. */
 export declare function selectMode(width: number): DiffDisplayMode;
 /** Render a diff result as an array of ANSI-formatted terminal lines. */

package/dist/utils/diff-renderer.js

@@ -25,7 +25,7 @@ const EXT_TO_LANG = {
     ".hs": "haskell", ".ml": "ocaml", ".clj": "clojure",
     ".vim": "vim", ".dockerfile": "dockerfile",
 };
-function detectLanguage(filePath) {
+export function detectLanguage(filePath) {
     if (!filePath)
         return undefined;
     const dot = filePath.lastIndexOf(".");
@@ -44,7 +44,7 @@ function detectLanguage(filePath) {
  * Syntax-highlight a single line of code.
  * Returns the original text if highlighting fails or no language detected.
  */
-function highlightLine(text, language) {
+export function highlightLine(text, language) {
     if (!language || text.trim() === "")
         return text;
     try {

package/examples/extensions/ash-acp-bridge/src/index.ts

@@ -446,10 +446,13 @@ function getModelsPayload(): Record<string, unknown> | undefined {
   if (!core) return undefined;
   const info = core.bus.emitPipe("config:get-models", { models: [], active: null });
   if (!info.models.length) return undefined;
+  const idFor = (m: { model: string; provider: string }) =>
+    m.provider ? `${m.model}@${m.provider}` : m.model;
+  const current = info.active ?? info.models[0]!;
   return {
-    currentModelId: info.active?.model ?? info.models[0]?.model,
+    currentModelId: idFor(current),
     availableModels: info.models.map((m) => ({
-      modelId: m.model,
+      modelId: idFor(m),
       name: m.provider ? `${m.provider}/${m.model}` : m.model,
       description: m.provider ? `Provider: ${m.provider}` : "",
     })),

package/examples/extensions/ashi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanyilun/ashi",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Ash in an interactive TUI — agent-sh's built-in agent without the shell underneath",
   "type": "module",
   "main": "dist/cli.js",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.74.0",
-    "agent-sh": "^0.13.2",
+    "agent-sh": "^0.13.3",
     "chalk": "^5.5.0",
     "cli-highlight": "^2.1.11"
   },

package/examples/extensions/ashi/src/cli.ts

@@ -145,7 +145,7 @@ async function main(): Promise<void> {
   registerDefaultToolRenderers(ctx);
 
   ctx.advise("conversation:format-prior-history", () => null);
-  ctx.advise("system-prompt:build", (base) => `${base}\n\n<cwd>${process.cwd()}</cwd>`);
+  ctx.advise("system-prompt:build", (next) => `${next()}\n\n<cwd>${process.cwd()}</cwd>`);
 
   const handle = mountAshi(ctx, getStore, capture);
   stopFrontend = handle.stop;

package/examples/extensions/ashi/src/default-renderers.ts

@@ -17,8 +17,8 @@ const TOOL_ICON: Record<string, string> = {
 };
 
 function iconPrefix(name: string): string {
-  const icon = TOOL_ICON[name];
-  return icon ? `${theme.fg("warning", icon)} ` : "";
+  const icon = TOOL_ICON[name] ?? "⚙";
+  return `${theme.fg("warning", icon)} `;
 }
 
 interface StatusOpts { exitCode: number | null; elapsedMs: number; summary?: string }
@@ -145,7 +145,7 @@ function pathOnlyLabel(name: string, args: ToolCallArgs): string {
 
 function genericLabel(args: ToolCallArgs): string {
   const detail = args.displayDetail ? ` ${muted(args.displayDetail)}` : "";
-  return `${bold(args.title)}${detail}`;
+  return `${iconPrefix(args.name)}${bold(args.title)}${detail}`;
 }
 
 export function registerDefaultToolRenderers(ctx: ExtensionContext): void {

package/examples/extensions/ashi/src/frontend.ts

@@ -40,7 +40,7 @@ import { resumeSession } from "./session-commands.js";
 import { applyBranchMessages } from "./commands.js";
 import type { Capture } from "./capture.js";
 import { execSync } from "node:child_process";
-import { renderDiff } from "agent-sh/utils/diff-renderer.js";
+import { renderDiff, detectLanguage, highlightLine } from "agent-sh/utils/diff-renderer.js";
 import { renderBoxFrame } from "agent-sh/utils/box-frame.js";
 
 interface DiffStats { added: number; removed: number; isNewFile: boolean; isIdentical: boolean }
@@ -53,10 +53,10 @@ function buildDiffRenderer(
     const boxW = Math.max(40, width);
     const contentW = Math.max(20, boxW - 4);
     const inner = diff.isNewFile
-      ? renderNewFilePreview(diff, 30)
+      ? renderNewFilePreview(diff, 30, filePath)
       : ((): string[] => {
           const lines = renderDiff(diff, {
-            width: contentW, filePath, trueColor: true, maxLines: 30, mode: "unified",
+            width: contentW, filePath, trueColor: true, maxLines: Number.MAX_SAFE_INTEGER, mode: "unified",
           });
           return lines.length > 1 ? ["", ...lines.slice(1), ""] : lines;
         })();
@@ -71,14 +71,16 @@ function buildDiffRenderer(
 function renderNewFilePreview(
   diff: { hunks?: { lines: { type: string; text: string }[] }[] },
   maxLines: number,
+  filePath: string,
 ): string[] {
   const lines = diff.hunks?.[0]?.lines.filter((l) => l.type === "added") ?? [];
   const shown = lines.slice(0, maxLines);
   const overflow = lines.length - shown.length;
   const noW = String(shown.length).length || 1;
+  const lang = detectLanguage(filePath);
   const body = shown.map((l, i) => {
     const no = String(i + 1).padStart(noW);
-    return `${theme.fg("muted", `${no} │`)} ${l.text}`;
+    return `${theme.fg("muted", `${no} │`)} ${highlightLine(l.text, lang)}`;
   });
   if (overflow > 0) body.push(theme.fg("muted", `… ${overflow} more lines`));
   return ["", ...body, ""];

package/examples/extensions/ollama.ts

@@ -1,41 +1,47 @@
 /**
- * Ollama provider extension — local daemon and Ollama Cloud.
+ * Ollama provider extension — local daemon or Ollama Cloud.
  *
- *   OLLAMA_API_KEY  → Ollama Cloud (https://ollama.com)
- *   OLLAMA_HOST     → local host override (default http://localhost:11434)
+ * Cloud auth (any of):
+ *   agent-sh auth login ollama-cloud   # preferred
+ *   OLLAMA_API_KEY=...                 # env fallback
+ *
+ * Local host:
+ *   OLLAMA_HOST (default http://localhost:11434)
  *
  * Catalog comes from /api/tags; per-model context length is fetched
  * from /api/show (model_info["${arch}.context_length"]). Chat goes
  * through the OpenAI-compatible /v1/chat/completions shim.
  *
- * Setup (cloud):
- *   export OLLAMA_API_KEY="your-key"
- *
- * Setup (local):
- *   ollama serve   # default http://localhost:11434
- *
  * Usage:
  *   agent-sh -e ./examples/extensions/ollama.ts
  *
  *   # Or add to settings.json:
  *   { "extensions": ["./examples/extensions/ollama.ts"] }
  */
-import type { ExtensionContext } from "agent-sh/types";
+import { resolveApiKey } from "agent-sh/auth";
+import type { AgentContext } from "agent-sh/types";
 
 const ECHO_REASONING_PATTERNS: RegExp[] = [/deepseek/i];
 
-export default function activate(ctx: ExtensionContext): void {
-  const apiKey = process.env.OLLAMA_API_KEY;
-  const host = apiKey
+export default function activate(ctx: AgentContext): void {
+  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 = apiKey ? "ollama-cloud" : "ollama";
+  const id = cloudKey ? "ollama-cloud" : "ollama";
 
   // OpenAI SDK rejects an empty apiKey; the local daemon ignores the value.
-  const sdkKey = apiKey || "no-key";
+  const sdkKey = cloudKey || "no-key";
   const baseURL = `${host}/v1`;
   const headers: Record<string, string> = {};
-  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  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.bus.emit("provider:register", { id, apiKey: sdkKey, baseURL, models: [] });
 

package/examples/extensions/zai-coding-plan.ts

@@ -0,0 +1,40 @@
+/**
+ * Z.AI Coding Plan — Zhipu AI's subscription GLM models for coding tools.
+ *
+ * Auth:  agent-sh auth login zai-coding-plan
+ * Usage: agent-sh -e ./examples/extensions/zai-coding-plan.ts
+ */
+import { resolveApiKey } from "agent-sh/auth";
+import type { AgentContext } from "agent-sh/types";
+
+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);
+  const apiKey = key ?? process.env.ZAI_API_KEY ?? process.env.ZHIPU_API_KEY;
+  if (!apiKey) return;
+
+  ctx.agent.providers.configure(ID, { reasoningParams: buildReasoningParams });
+
+  ctx.bus.emit("provider:register", {
+    id: ID,
+    apiKey: apiKey,
+    baseURL: BASE_URL,
+    defaultModel: DEFAULT_MODELS[0].id,
+    models: DEFAULT_MODELS,
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.13.2",
+  "version": "0.13.4",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core/index.js",
@@ -101,6 +101,10 @@
     "./cli/auth": {
       "types": "./dist/cli/auth/cli.d.ts",
       "default": "./dist/cli/auth/cli.js"
+    },
+    "./auth": {
+      "types": "./dist/cli/auth/keys.d.ts",
+      "default": "./dist/cli/auth/keys.js"
     }
   },
   "files": [