agent-sh 0.4.0 → 0.5.0

package/dist/settings.js

@@ -12,6 +12,9 @@ const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
 const DEFAULTS = {
     extensions: [],
     historySize: 500,
+    providers: {},
+    defaultProvider: undefined,
+    defaultBackend: "agent-sh",
     contextWindowSize: 20,
     contextBudget: 16384,
     shellTruncateThreshold: 10,
@@ -21,7 +24,9 @@ const DEFAULTS = {
     maxCommandOutputLines: 3,
     readOutputMaxLines: 0,
     diffMaxLines: 20,
-    enableMcp: true,
+    skillPaths: [],
+    startupBanner: true,
+    promptIndicator: true,
 };
 let cached = null;
 /** Load settings from disk (cached after first call). */
@@ -31,7 +36,10 @@ export function getSettings() {
             const raw = fs.readFileSync(SETTINGS_PATH, "utf-8");
             cached = JSON.parse(raw);
         }
-        catch {
+        catch (err) {
+            if (err instanceof SyntaxError) {
+                console.error(`[agent-sh] Warning: invalid JSON in ${SETTINGS_PATH}: ${err.message}`);
+            }
             cached = {};
         }
     }
@@ -59,3 +67,38 @@ export function getExtensionSettings(namespace, defaults) {
 export function reloadSettings() {
     cached = null;
 }
+/**
+ * Expand $ENV_VAR references in a string.
+ * Supports $VAR and ${VAR} syntax.
+ */
+export function expandEnvVars(value) {
+    return value.replace(/\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, braced, plain) => {
+        const name = braced || plain;
+        return process.env[name] ?? "";
+    });
+}
+/**
+ * Resolve a provider config by name from settings.
+ * Returns null if provider not found.
+ */
+export function resolveProvider(name) {
+    const settings = getSettings();
+    const provider = settings.providers?.[name];
+    if (!provider)
+        return null;
+    const models = provider.models ?? (provider.defaultModel ? [provider.defaultModel] : []);
+    const defaultModel = provider.defaultModel ?? models[0];
+    return {
+        id: name,
+        apiKey: provider.apiKey ? expandEnvVars(provider.apiKey) : undefined,
+        baseURL: provider.baseURL,
+        defaultModel,
+        models: models.length ? models : (defaultModel ? [defaultModel] : []),
+        contextWindow: provider.contextWindow,
+    };
+}
+/** Get all configured provider names. */
+export function getProviderNames() {
+    const settings = getSettings();
+    return Object.keys(settings.providers ?? {});
+}

package/dist/shell.js

@@ -4,6 +4,7 @@ import * as path from "path";
 import * as pty from "node-pty";
 import { InputHandler } from "./input-handler.js";
 import { OutputParser } from "./output-parser.js";
+import { getSettings } from "./settings.js";
 export class Shell {
     ptyProcess;
     bus;
@@ -40,13 +41,16 @@ export class Shell {
         let shellArgs;
         const osc7Cmd = 'printf "\\e]7;file://%s%s\\a" "$(hostname)" "$PWD"';
         const promptMarker = 'printf "\\e]9999;PROMPT\\a"';
+        const titleCmd = 'printf "\\e]0;⚡ agent-sh: %s\\a" "${PWD/#$HOME/~}"';
         this.isZsh = isZsh;
+        const settings = getSettings();
+        const showIndicator = settings.promptIndicator !== false;
         if (isZsh) {
             // For zsh: use ZDOTDIR to source user's real config, then append
             // our hooks via precmd_functions (additive — doesn't clobber p10k/omz).
             this.tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-sh-"));
             const userZdotdir = env.ZDOTDIR || env.HOME || os.homedir();
-            fs.writeFileSync(path.join(this.tmpDir, ".zshrc"), [
+            const zshrcLines = [
                 `ZDOTDIR="${userZdotdir}"`,
                 `[ -f "${userZdotdir}/.zshrc" ] && source "${userZdotdir}/.zshrc"`,
                 "",
@@ -54,32 +58,19 @@ export class Shell {
                 "__agent_sh_precmd() {",
                 `  ${osc7Cmd}`,
                 `  ${promptMarker}`,
+                ...(showIndicator ? [`  ${titleCmd}`] : []),
                 "}",
                 "precmd_functions+=(__agent_sh_precmd)",
                 "",
-                "# End-of-prompt marker via zle-line-init (fires after prompt is rendered)",
-                "# Chain onto existing widget (p10k uses zle-line-init) rather than clobbering",
-                'if (( ${+widgets[zle-line-init]} )); then',
-                "  zle -A zle-line-init __agent_sh_orig_line_init",
-                "  __agent_sh_line_init() {",
-                "    zle __agent_sh_orig_line_init",
-                '    printf "\\e]9998;READY\\a"',
-                "  }",
-                "else",
-                "  __agent_sh_line_init() {",
-                '    printf "\\e]9998;READY\\a"',
-                "  }",
-                "fi",
-                "zle -N zle-line-init __agent_sh_line_init",
-                "",
-                "# Hidden widget to trigger prompt redraw from Node.js side",
-                "# Bound to an unused escape sequence that no real key produces",
-                "__agent_sh_redraw() {",
-                "  zle reset-prompt",
+                "# Preexec hook: emit actual command text so agent-sh can track",
+                "# history-recalled and tab-completed commands accurately",
+                "__agent_sh_preexec() {",
+                '  printf "\\e]9997;%s\\a" "$1"',
                 "}",
-                "zle -N __agent_sh_redraw",
-                "bindkey '\\e[9999~' __agent_sh_redraw",
-            ].join("\n") + "\n");
+                "preexec_functions+=(__agent_sh_preexec)",
+            ];
+            zshrcLines.push("", "# End-of-prompt marker via zle-line-init (fires after prompt is rendered)", "# Chain onto existing widget (p10k uses zle-line-init) rather than clobbering", 'if (( ${+widgets[zle-line-init]} )); then', "  zle -A zle-line-init __agent_sh_orig_line_init", "  __agent_sh_line_init() {", "    zle __agent_sh_orig_line_init", '    printf "\\e]9998;READY\\a"', "  }", "else", "  __agent_sh_line_init() {", '    printf "\\e]9998;READY\\a"', "  }", "fi", "zle -N zle-line-init __agent_sh_line_init", "", "# Hidden widget to trigger prompt redraw from Node.js side", "# Bound to an unused escape sequence that no real key produces", "__agent_sh_redraw() {", "  zle reset-prompt", "}", "zle -N __agent_sh_redraw", "bindkey '\\e[9999~' __agent_sh_redraw");
+            fs.writeFileSync(path.join(this.tmpDir, ".zshrc"), zshrcLines.join("\n") + "\n");
             env.ZDOTDIR = this.tmpDir;
             shellArgs = ["--no-globalrcs"];
         }
@@ -88,15 +79,29 @@ export class Shell {
             // real bashrc then appends our hooks. No HOME override needed.
             this.tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-sh-"));
             const userHome = env.HOME || os.homedir();
-            fs.writeFileSync(path.join(this.tmpDir, ".bashrc"), [
+            const bashrcLines = [
                 `[ -f "${userHome}/.bashrc" ] && source "${userHome}/.bashrc"`,
                 "",
                 "# agent-sh hooks (invisible OSC sequences for cwd + prompt detection)",
-                `PROMPT_COMMAND="\${PROMPT_COMMAND:+\$PROMPT_COMMAND;}${osc7Cmd}; ${promptMarker}"`,
+                `PROMPT_COMMAND="\${PROMPT_COMMAND:+\$PROMPT_COMMAND;}__agent_sh_preexec_ran=0; ${osc7Cmd}; ${promptMarker}${showIndicator ? `; ${titleCmd}` : ""}"`,
+                "",
+                "# Preexec hook via DEBUG trap: emit actual command text so agent-sh",
+                "# can track history-recalled and tab-completed commands accurately",
+                "__agent_sh_preexec_ran=0",
+                "__agent_sh_emit_preexec() {",
+                '  [[ $__agent_sh_preexec_ran == 1 ]] && return',
+                '  [[ -n $COMP_LINE ]] && return',
+                "  __agent_sh_preexec_ran=1",
+                "  local this_cmd",
+                `  this_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+                `  printf '\\e]9997;%s\\a' "$this_cmd"`,
+                "}",
+                "trap '__agent_sh_emit_preexec' DEBUG",
                 "",
                 "# End-of-prompt marker: append to PS1 (\\[...\\] marks it zero-width)",
                 'case "$PS1" in *9998*) ;; *) PS1="${PS1}\\[\\e]9998;READY\\a\\]";; esac',
-            ].join("\n") + "\n");
+            ];
+            fs.writeFileSync(path.join(this.tmpDir, ".bashrc"), bashrcLines.join("\n") + "\n");
             shellArgs = ["--rcfile", path.join(this.tmpDir, ".bashrc")];
         }
         // Pause stdin before spawning PTY to avoid TTY contention on macOS.
@@ -259,6 +264,7 @@ export class Shell {
             this.echoSkip = true;
             this.paused = false;
             process.stdout.write("\n");
+            this.bus.emit("shell:agent-exec-start", {});
             const output = await new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
                     this.bus.off("shell:command-done", handler);
@@ -276,6 +282,7 @@ export class Shell {
             });
             this.paused = true;
             this.echoSkip = false;
+            this.bus.emit("shell:agent-exec-done", {});
             return { ...payload, output: output.output, cwd: output.cwd, done: true };
         });
     }

package/dist/types.d.ts

@@ -1,18 +1,38 @@
 import type { EventBus } from "./event-bus.js";
 import type { ContextManager } from "./context-manager.js";
-import type { AcpClient } from "./acp-client.js";
+import type { LlmClient } from "./utils/llm-client.js";
 import type { ColorPalette } from "./utils/palette.js";
 import type { BlockTransformOptions, FencedBlockTransformOptions } from "./utils/stream-transform.js";
+import type { ToolDefinition } from "./agent/types.js";
 export type { ContentBlock } from "./event-bus.js";
 export type { BlockTransformOptions, FencedBlockTransformOptions } from "./utils/stream-transform.js";
+/** A model entry in the cycling list, optionally tied to a provider. */
+export interface AgentMode {
+    model: string;
+    /** Provider id — when cycling changes provider, LlmClient is reconfigured. */
+    provider?: string;
+    /** Provider-specific config for reconfiguring LlmClient on switch. */
+    providerConfig?: {
+        apiKey: string;
+        baseURL?: string;
+    };
+    /** Context window size in tokens (for usage display). */
+    contextWindow?: number;
+    /** Model supports reasoning/thinking tokens. */
+    reasoning?: boolean;
+    /** Provider supports the reasoning_effort parameter. */
+    supportsReasoningEffort?: boolean;
+}
 export interface AgentShellConfig {
-    agentCommand: string;
-    agentArgs: string[];
     shell?: string;
     model?: string;
     extensions?: string[];
-    /** Full shell environment (from user's rc files) for agent subprocess. */
-    shellEnv?: Record<string, string>;
+    /** API key for OpenAI-compatible provider. */
+    apiKey?: string;
+    /** Base URL for OpenAI-compatible API. */
+    baseURL?: string;
+    /** Named provider to use from settings.json. */
+    provider?: string;
 }
 /**
  * Context passed to user/third-party extensions.
@@ -23,7 +43,8 @@ export interface AgentShellConfig {
 export interface ExtensionContext {
     bus: EventBus;
     contextManager: ContextManager;
-    getAcpClient: () => AcpClient;
+    /** LLM client for fast-path features (null in ACP mode). */
+    llmClient: LlmClient | null;
     quit: () => void;
     /** Override color palette slots for theming. */
     setPalette: (overrides: Partial<ColorPalette>) => void;
@@ -33,6 +54,12 @@ export interface ExtensionContext {
     createFencedBlockTransform: (opts: FencedBlockTransformOptions) => void;
     /** Read extension-namespaced settings from ~/.agent-sh/settings.json. */
     getExtensionSettings: <T extends Record<string, unknown>>(namespace: string, defaults: T) => T;
+    /** Register a slash command available in any input mode. */
+    registerCommand: (name: string, description: string, handler: (args: string) => Promise<void> | void) => void;
+    /** Register a tool for the built-in agent. No-op when using bridge backends. */
+    registerTool: (tool: ToolDefinition) => void;
+    /** Get all registered tools (for subagent tool subsets). Returns [] when using bridge backends. */
+    getTools: () => ToolDefinition[];
     /** Register a named handler. */
     define: (name: string, fn: (...args: any[]) => any) => void;
     /** Wrap a named handler. Receives `next` (original) + args. */

package/dist/utils/box-frame.d.ts

@@ -6,8 +6,10 @@ export interface BoxFrameOptions {
     style?: BorderStyle;
     /** Border color (ANSI escape). Default DIM. */
     borderColor?: string;
-    /** Title text shown in the top border. */
+    /** Title text shown on the left of the top border. */
     title?: string;
+    /** Title text shown on the right of the top border. */
+    titleRight?: string;
     /** Footer lines shown below a divider, inside the box. */
     footer?: string[];
 }

package/dist/utils/box-frame.js

@@ -30,11 +30,18 @@ export function renderBoxFrame(content, opts) {
     // Content area width = total - 2 borders - 2 padding spaces
     const innerW = Math.max(1, width - 4);
     const output = [];
-    // Top border (with optional title)
-    if (opts.title) {
-        const titleVis = visibleLen(opts.title);
-        const afterDashes = Math.max(1, width - titleVis - 4);
-        output.push(`${bc}${b.tl}${p.reset} ${opts.title} ${bc}${b.h.repeat(afterDashes)}${b.tr}${p.reset}`);
+    // Top border (with optional left/right titles)
+    if (opts.title || opts.titleRight) {
+        const leftPart = opts.title
+            ? `${p.reset} ${opts.title} ${bc}`
+            : "";
+        const leftVis = opts.title ? visibleLen(opts.title) + 2 : 0; // +2 for spaces
+        const rightPart = opts.titleRight
+            ? `${p.reset} ${opts.titleRight} ${bc}`
+            : "";
+        const rightVis = opts.titleRight ? visibleLen(opts.titleRight) + 2 : 0;
+        const dashCount = Math.max(1, width - 2 - leftVis - rightVis);
+        output.push(`${bc}${b.tl}${leftPart}${b.h.repeat(dashCount)}${rightPart}${b.tr}${p.reset}`);
     }
     else {
         output.push(`${bc}${b.tl}${b.h.repeat(width - 2)}${b.tr}${p.reset}`);

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

@@ -0,0 +1,45 @@
+/**
+ * Thin, stateless wrapper around the OpenAI SDK.
+ * No agent-sh knowledge — just a configured client.
+ *
+ * Used by both AgentLoop (full tool loop) and fast-path features
+ * (command suggestions, completions).
+ */
+import OpenAI from "openai";
+import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources/chat/completions.js";
+export type { ChatCompletionMessageParam, ChatCompletionTool };
+export interface LlmClientConfig {
+    apiKey: string;
+    baseURL?: string;
+    model: string;
+}
+export declare class LlmClient {
+    private config;
+    private client;
+    model: string;
+    constructor(config: LlmClientConfig);
+    /** Swap the underlying client config at runtime (e.g. provider switch). */
+    reconfigure(newConfig: LlmClientConfig): void;
+    /**
+     * Create a streaming chat completion.
+     * Returns an async iterable of chunks.
+     */
+    stream(opts: {
+        messages: ChatCompletionMessageParam[];
+        tools?: ChatCompletionTool[];
+        model?: string;
+        max_tokens?: number;
+        /** Reasoning effort level (e.g. "low", "medium", "high"). Provider-dependent. */
+        reasoning_effort?: string;
+        signal?: AbortSignal;
+    }): import("openai").APIPromise<import("openai/core/streaming.mjs").Stream<OpenAI.Chat.Completions.ChatCompletionChunk>>;
+    /**
+     * Single-shot completion (no streaming) — for fast-path features.
+     * Returns the text content of the first choice.
+     */
+    complete(opts: {
+        messages: ChatCompletionMessageParam[];
+        model?: string;
+        max_tokens?: number;
+    }): Promise<string>;
+}

package/dist/utils/llm-client.js

@@ -0,0 +1,60 @@
+/**
+ * Thin, stateless wrapper around the OpenAI SDK.
+ * No agent-sh knowledge — just a configured client.
+ *
+ * Used by both AgentLoop (full tool loop) and fast-path features
+ * (command suggestions, completions).
+ */
+import OpenAI from "openai";
+export class LlmClient {
+    config;
+    client;
+    model;
+    constructor(config) {
+        this.config = config;
+        this.client = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: config.baseURL,
+        });
+        this.model = config.model;
+    }
+    /** Swap the underlying client config at runtime (e.g. provider switch). */
+    reconfigure(newConfig) {
+        this.config = newConfig;
+        this.client = new OpenAI({
+            apiKey: newConfig.apiKey,
+            baseURL: newConfig.baseURL,
+        });
+        this.model = newConfig.model;
+    }
+    /**
+     * Create a streaming chat completion.
+     * Returns an async iterable of chunks.
+     */
+    stream(opts) {
+        const body = {
+            model: opts.model ?? this.model,
+            messages: opts.messages,
+            tools: opts.tools?.length ? opts.tools : undefined,
+            max_tokens: opts.max_tokens ?? 8192,
+            stream: true,
+            stream_options: { include_usage: true },
+            ...(opts.reasoning_effort
+                ? { reasoning_effort: opts.reasoning_effort }
+                : {}),
+        };
+        return this.client.chat.completions.create(body, { signal: opts.signal });
+    }
+    /**
+     * Single-shot completion (no streaming) — for fast-path features.
+     * Returns the text content of the first choice.
+     */
+    async complete(opts) {
+        const response = await this.client.chat.completions.create({
+            model: opts.model ?? this.model,
+            messages: opts.messages,
+            max_tokens: opts.max_tokens ?? 1024,
+        });
+        return response.choices[0]?.message?.content ?? "";
+    }
+}

package/dist/utils/markdown.js

@@ -224,9 +224,9 @@ export class MarkdownRenderer {
         const h4 = line.match(/^#{4,} (.+)/);
         if (h4)
             return `${p.bold}${h4[1]}${p.reset}`;
-        // Horizontal rule
+        // Horizontal rule — subtle short separator, not full-width
         if (/^(-{3,}|_{3,}|\*{3,})\s*$/.test(line)) {
-            return `${p.muted}${"─".repeat(this.contentWidth)}${p.reset}`;
+            return "";
         }
         // Blockquote
         const bq = line.match(/^>\s?(.*)/);

package/dist/utils/stream-transform.js

@@ -19,37 +19,23 @@
 export function createBlockTransform(bus, opts) {
     let buffer = "";
     bus.onPipe("agent:response-chunk", (e) => {
-        // Process text from e.text and from text blocks in e.blocks
         const outBlocks = [];
-        if (e.blocks) {
-            for (const block of e.blocks) {
-                if (block.type === "text") {
-                    // Run delimiter detection on text blocks
-                    buffer += block.text;
-                    const { blocks: parsed, pending } = processBuffer(buffer, opts);
-                    buffer = pending;
-                    outBlocks.push(...parsed);
-                }
-                else {
-                    // Pass through non-text blocks unchanged
-                    outBlocks.push(block);
-                }
+        for (const block of e.blocks) {
+            if (block.type === "text") {
+                buffer += block.text;
+                const { blocks: parsed, pending } = processBuffer(buffer, opts);
+                buffer = pending;
+                outBlocks.push(...parsed);
+            }
+            else {
+                outBlocks.push(block);
             }
         }
-        // Also process any raw text not yet in blocks
-        if (e.text) {
-            buffer += e.text;
-            const { blocks: parsed, pending } = processBuffer(buffer, opts);
-            buffer = pending;
-            outBlocks.push(...parsed);
-        }
-        return { ...e, text: "", blocks: outBlocks };
+        return { blocks: outBlocks };
     });
     bus.onPipe("agent:response-done", (e) => {
         if (buffer) {
-            // Unclosed pattern — flush as text
             bus.emitTransform("agent:response-chunk", {
-                text: buffer,
                 blocks: [{ type: "text", text: buffer }],
             });
             buffer = "";
@@ -66,35 +52,23 @@ export function createFencedBlockTransform(bus, opts) {
     bus.onPipe("agent:response-chunk", (e) => {
         if (flushing)
             return e; // pass through during flush to avoid re-buffering
-        // Collect text from blocks or raw text
+        // Separate text blocks (to buffer) from non-text blocks (pass through)
         let incoming = "";
-        if (e.blocks) {
-            // Process text blocks, pass through non-text blocks
-            const passthrough = [];
-            for (const block of e.blocks) {
-                if (block.type === "text") {
-                    incoming += block.text;
-                }
-                else {
-                    passthrough.push(block);
-                }
+        const passthrough = [];
+        for (const block of e.blocks) {
+            if (block.type === "text") {
+                incoming += block.text;
+            }
+            else {
+                passthrough.push(block);
             }
-            const { blocks, pending } = processFencedBuffer(buffer + incoming, opts, inFence, fenceMatch, fenceLines);
-            buffer = pending.text;
-            inFence = pending.inFence;
-            fenceMatch = pending.fenceMatch;
-            fenceLines = pending.fenceLines;
-            return { ...e, text: "", blocks: [...passthrough, ...blocks] };
         }
-        // No blocks yet — work with raw text
-        incoming = buffer + e.text;
-        const { blocks, pending } = processFencedBuffer(incoming, opts, inFence, fenceMatch, fenceLines);
+        const { blocks, pending } = processFencedBuffer(buffer + incoming, opts, inFence, fenceMatch, fenceLines);
         buffer = pending.text;
         inFence = pending.inFence;
         fenceMatch = pending.fenceMatch;
         fenceLines = pending.fenceLines;
-        const existing = e.blocks ?? [];
-        return { ...e, text: "", blocks: [...existing, ...blocks] };
+        return { blocks: [...passthrough, ...blocks] };
     });
     function flushBuffer() {
         if (!buffer && !inFence)
@@ -110,7 +84,6 @@ export function createFencedBlockTransform(bus, opts) {
         if (remaining) {
             flushing = true;
             bus.emitTransform("agent:response-chunk", {
-                text: "",
                 blocks: [{ type: "text", text: remaining }],
             });
             flushing = false;

package/dist/utils/tool-display.js

@@ -73,6 +73,15 @@ export function renderToolCall(tool, width) {
                 if (typeof raw.command === "string") {
                     detail = `$ ${raw.command}`;
                 }
+                else if (typeof raw.pattern === "string") {
+                    // grep/glob — show the search pattern
+                    const target = typeof raw.path === "string" ? ` ${shortenPath(raw.path, cwd)}` : "";
+                    detail = `${raw.pattern}${target}`;
+                }
+                else if (typeof raw.path === "string") {
+                    // read_file, write_file, etc.
+                    detail = shortenPath(raw.path, cwd);
+                }
                 else if (typeof raw.operation === "string") {
                     detail = raw.operation;
                     if (raw.ids && Array.isArray(raw.ids)) {
@@ -83,20 +92,21 @@ export function renderToolCall(tool, width) {
                     }
                 }
                 else {
-                    detail = formatRawInput(tool.rawInput, width - tool.title.length - 6);
+                    detail = formatRawInput(tool.rawInput, width - 4);
                 }
             }
         }
     }
-    // Render as single line: ► title: detail
-    const maxDetailW = Math.max(1, width - tool.title.length - 6);
+    // Render as single line: icon + detail (icon implies the tool type)
+    // Falls back to icon + title when no detail is available
+    const maxDetailW = Math.max(1, width - 4);
     if (detail) {
         if (detail.length > maxDetailW)
             detail = detail.slice(0, maxDetailW - 1) + "…";
-        lines.push(`${p.warning}${p.bold}${icon} ${tool.title}${p.reset}${p.dim}: ${detail}${p.reset}`);
+        lines.push(`${p.warning}${icon}${p.reset} ${p.dim}${detail}${p.reset}`);
     }
     else {
-        lines.push(`${p.warning}${p.bold}${icon} ${tool.title}${p.reset}`);
+        lines.push(`${p.warning}${icon} ${tool.title}${p.reset}`);
     }
     // Show additional file locations on separate lines (if more than one)
     if (mode === "full" && tool.locations && tool.locations.length > 1) {

package/examples/extensions/claude-code-bridge/README.md

@@ -0,0 +1,35 @@
+# claude-code-bridge
+
+Runs Claude Code as an agent-sh backend using the official [@anthropic-ai/claude-agent-sdk](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk).
+
+## Install
+
+```bash
+# Copy or symlink into your extensions directory
+cp -r examples/extensions/claude-code-bridge ~/.agent-sh/extensions/claude-code-bridge
+
+# Install dependencies
+cd ~/.agent-sh/extensions/claude-code-bridge
+npm install
+```
+
+## Configure
+
+Set as default backend in `~/.agent-sh/settings.json`:
+
+```json
+{
+  "defaultBackend": "claude-code"
+}
+```
+
+Or switch at runtime:
+
+```
+? /backend claude-code
+```
+
+## Requirements
+
+- `ANTHROPIC_API_KEY` must be set in your environment
+- Claude Code manages its own model selection — no model configuration needed in agent-sh