@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/codebuddy/providers/ollama-native-transport.js

@@ -0,0 +1,387 @@
+/**
+ * Ollama transport that can actually carry a context limit.
+ *
+ * `CODEBUDDY_MAX_CONTEXT` is documented as overriding the context window "for
+ * every consumer", and every Code Buddy consumer honours it — but the SERVER
+ * never heard about it. Ollama takes a per-request context size only as
+ * `options.num_ctx` on its NATIVE `/api/chat` endpoint; the OpenAI-compatible
+ * `/v1/chat/completions` silently drops unknown fields (measured on Ollama
+ * 0.30.7: `options.num_ctx`, a top-level `num_ctx` and `context_length` all
+ * ignored) and the runner is then loaded at the model's full declared window —
+ * 262 144 tokens and 24 GB of VRAM for a 2.5 GB model.
+ *
+ * So for Ollama, and only for Ollama, the already-built OpenAI-compatible
+ * payload is translated to the native endpoint and the native answer back to
+ * the OpenAI shape. Everything around it — retry, circuit breaker, extended
+ * thinking, JSON retry, turn metrics, error classification — stays on the one
+ * pipeline it always used.
+ *
+ * @module codebuddy/providers/ollama-native-transport
+ */
+import { getModelToolConfig } from '../../config/model-tools.js';
+const TAGS_PROBE_TIMEOUT_MS = 300;
+const tagsProbeCache = new Map();
+/** Test seam — drop memoized `GET /api/tags` answers. */
+export function resetOllamaEndpointCache() {
+    tagsProbeCache.clear();
+}
+function withHttpScheme(raw) {
+    return /^https?:\/\//i.test(raw) ? raw : `http://${raw}`;
+}
+function canonicalHostname(hostname) {
+    const host = hostname.toLowerCase().replace(/^\[|\]$/g, '');
+    if (host === 'localhost' || host === '::1' || host === '0.0.0.0')
+        return '127.0.0.1';
+    return host;
+}
+/** `http://127.0.0.1:11435/v1` → `http://127.0.0.1:11435`. */
+export function ollamaEndpointOrigin(baseURL) {
+    try {
+        const url = new URL(withHttpScheme(baseURL.trim()));
+        if (!url.hostname)
+            return null;
+        return `${url.protocol}//${canonicalHostname(url.hostname)}${url.port ? `:${url.port}` : ''}`.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+export function isLoopbackLlmHost(baseURL) {
+    try {
+        const host = canonicalHostname(new URL(withHttpScheme(baseURL.trim())).hostname);
+        return host === '127.0.0.1';
+    }
+    catch {
+        return false;
+    }
+}
+function declaredProvider(env) {
+    return env.CODEBUDDY_PROVIDER?.trim().toLowerCase() ?? '';
+}
+function originsMatch(baseURL, configured) {
+    if (!configured?.trim())
+        return false;
+    const left = ollamaEndpointOrigin(baseURL);
+    const right = ollamaEndpointOrigin(configured);
+    return left !== null && right !== null && left === right;
+}
+/**
+ * `true` when this base URL is served by Ollama.
+ *
+ * Order (sync, no I/O):
+ *   1. `CODEBUDDY_PROVIDER=ollama` — the operator already named the runtime.
+ *   2. The URL is the origin of `OLLAMA_HOST` / `OLLAMA_BASE_URL`.
+ *   3. A memoized loopback `GET /api/tags` probe previously succeeded.
+ *
+ * LM Studio / vLLM on the same loopback port stay on `/v1`: an explicit
+ * non-ollama provider short-circuits, and their `/api/tags` is not 200.
+ * A hostname containing "ollama" or the historical `:11434` port is NOT
+ * enough on its own — that is what broke a daemon on 11435.
+ */
+export function isOllamaEndpoint(baseURL, env = process.env) {
+    const provider = declaredProvider(env);
+    if (provider === 'ollama')
+        return true;
+    if (provider && provider !== 'ollama')
+        return false;
+    if (originsMatch(baseURL, env.OLLAMA_HOST) || originsMatch(baseURL, env.OLLAMA_BASE_URL)) {
+        return true;
+    }
+    if (isLoopbackLlmHost(baseURL)) {
+        try {
+            const parsed = new URL(withHttpScheme(baseURL.trim()));
+            if (parsed.port === '11434' || parsed.pathname.toLowerCase().includes('/ollama')) {
+                return true;
+            }
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    const origin = ollamaEndpointOrigin(baseURL);
+    return origin !== null && tagsProbeCache.get(origin) === true;
+}
+async function probeOllamaTags(origin, fetchImpl, timeoutMs = TAGS_PROBE_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetchImpl(`${origin}/api/tags`, {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return false;
+        if (typeof response.json !== 'function')
+            return false;
+        const body = await response.json();
+        return Boolean(body && typeof body === 'object' && Array.isArray(body.models));
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Async counterpart of `isOllamaEndpoint`. On a loopback URL with no
+ * provider/host hint, probes `GET /api/tags` (200, ≤ 300 ms) and memos
+ * the answer per origin so later sync checks are free.
+ */
+export async function resolveOllamaEndpoint(baseURL, env = process.env, fetchImpl = globalThis.fetch) {
+    if (isOllamaEndpoint(baseURL, env))
+        return true;
+    const provider = declaredProvider(env);
+    if (provider && provider !== 'ollama')
+        return false;
+    if (!isLoopbackLlmHost(baseURL))
+        return false;
+    const origin = ollamaEndpointOrigin(baseURL);
+    if (!origin)
+        return false;
+    if (tagsProbeCache.has(origin))
+        return tagsProbeCache.get(origin) === true;
+    const ok = await probeOllamaTags(origin, fetchImpl);
+    tagsProbeCache.set(origin, ok);
+    return ok;
+}
+/**
+ * Opt-out for an operator who would rather keep the OpenAI-compat endpoint
+ * (and its 262 144-token default) than the native one.
+ */
+export function isOllamaNativeChatEnabled(env = process.env) {
+    const raw = env.CODEBUDDY_OLLAMA_NATIVE_CHAT?.trim().toLowerCase();
+    return raw !== 'false' && raw !== '0' && raw !== 'off';
+}
+/** `http://host:11434/v1` → `http://host:11434/api/chat`. */
+export function ollamaNativeChatUrl(baseURL) {
+    return `${baseURL.replace(/\/v1\/?$/i, '').replace(/\/+$/, '')}/api/chat`;
+}
+/**
+ * The context window the server must honour. Read through
+ * `getModelToolConfig`, so `CODEBUDDY_MAX_CONTEXT` — applied there at call
+ * time, above the declared table AND above runtime discovery — wins here too.
+ */
+export function resolveOllamaNumCtx(model) {
+    const { contextWindow } = getModelToolConfig(model);
+    return Number.isSafeInteger(contextWindow) && (contextWindow ?? 0) > 0 ? contextWindow : undefined;
+}
+function parseArguments(raw) {
+    if (raw && typeof raw === 'object' && !Array.isArray(raw))
+        return raw;
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * OpenAI messages → native messages. Two shapes genuinely differ: assistant
+ * `tool_calls[].function.arguments` is a JSON string upstream and an object
+ * here, and a `tool` result is bound by `tool_call_id` upstream but by
+ * `tool_name` here — resolved from the assistant turn that requested it, so a
+ * multi-turn tool loop keeps its pairing.
+ */
+export function toOllamaNativeMessages(messages) {
+    const nameByCallId = new Map();
+    for (const message of messages) {
+        for (const call of message.tool_calls ?? []) {
+            if (call.id && call.function?.name)
+                nameByCallId.set(call.id, call.function.name);
+        }
+    }
+    return messages.map((message) => {
+        const { tool_call_id: toolCallId, tool_calls: toolCalls, ...rest } = message;
+        const next = { ...rest };
+        if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+            next.tool_calls = toolCalls.map((call) => ({
+                ...(call.id ? { id: call.id } : {}),
+                function: { name: call.function?.name ?? '', arguments: parseArguments(call.function?.arguments) },
+            }));
+        }
+        if (message.role === 'tool') {
+            const toolName = typeof toolCallId === 'string' ? nameByCallId.get(toolCallId) : undefined;
+            if (toolName)
+                next.tool_name = toolName;
+        }
+        return next;
+    });
+}
+/** Ollama's `think` accepts a level or a boolean; `none` means "do not think". */
+function toOllamaThink(reasoningEffort) {
+    const effort = reasoningEffort?.trim().toLowerCase();
+    if (!effort)
+        return undefined;
+    if (effort === 'none' || effort === 'off' || effort === 'minimal')
+        return false;
+    if (effort === 'low' || effort === 'medium' || effort === 'high')
+        return effort;
+    return undefined;
+}
+/**
+ * Qwen3 (and other "thinking" weights) dump the whole answer into
+ * `message.thinking` / `/v1` `reasoning` and leave `content` empty unless
+ * `think` is false. A one-shot `-p` with no tool loop must disable that.
+ *
+ * Recent Ollama `/api/chat` accepts `think` as a boolean (or low/medium/high).
+ */
+export function isOllamaThinkingModel(model) {
+    const cfg = getModelToolConfig(model);
+    if (cfg.supportsReasoning)
+        return true;
+    if ((cfg.strengths ?? []).includes('thinking'))
+        return true;
+    const name = model.toLowerCase();
+    if (/thinking|reasoner|qwq|\br1\b/.test(name))
+        return true;
+    return name.includes('qwen3') && !name.includes('instruct');
+}
+export function shouldDisableOllamaThink(payload, env = process.env) {
+    if (!isOllamaThinkingModel(payload.model))
+        return false;
+    const hasTools = Array.isArray(payload.tools) && payload.tools.length > 0;
+    const headless = env.CODEBUDDY_HEADLESS === 'true';
+    return !hasTools || headless;
+}
+/** OpenAI-compat payload → native `/api/chat` body, carrying `num_ctx`. */
+export function toOllamaNativeRequest(payload, numCtx) {
+    const options = {};
+    if (numCtx !== undefined)
+        options.num_ctx = numCtx;
+    if (typeof payload.max_tokens === 'number')
+        options.num_predict = payload.max_tokens;
+    if (typeof payload.temperature === 'number')
+        options.temperature = payload.temperature;
+    if (typeof payload.top_p === 'number')
+        options.top_p = payload.top_p;
+    if (payload.stop !== undefined)
+        options.stop = Array.isArray(payload.stop) ? payload.stop : [payload.stop];
+    const think = toOllamaThink(payload.reasoning_effort)
+        ?? (shouldDisableOllamaThink(payload) ? false : undefined);
+    return {
+        model: payload.model,
+        messages: toOllamaNativeMessages(payload.messages),
+        stream: payload.stream === true,
+        ...(payload.tools && payload.tools.length > 0 ? { tools: payload.tools } : {}),
+        ...(payload.response_format?.type === 'json_object' ? { format: 'json' } : {}),
+        ...(think === undefined ? {} : { think }),
+        ...(Object.keys(options).length > 0 ? { options } : {}),
+    };
+}
+function toOpenAiToolCalls(toolCalls) {
+    return (toolCalls ?? []).flatMap((call, index) => {
+        const name = call.function?.name;
+        if (!name)
+            return [];
+        return [{
+                id: call.id || `ollama-tool-${index}`,
+                type: 'function',
+                function: { name, arguments: JSON.stringify(call.function?.arguments ?? {}) },
+            }];
+    });
+}
+function toFinishReason(data, hasToolCalls) {
+    if (hasToolCalls)
+        return 'tool_calls';
+    return data.done_reason === 'length' ? 'length' : 'stop';
+}
+function toUsage(data) {
+    if (typeof data.prompt_eval_count !== 'number' || typeof data.eval_count !== 'number')
+        return undefined;
+    return {
+        prompt_tokens: data.prompt_eval_count,
+        completion_tokens: data.eval_count,
+        total_tokens: data.prompt_eval_count + data.eval_count,
+    };
+}
+/** Native answer → the `chat.completion` object the provider already handles. */
+export function fromOllamaNativeResponse(data, fallbackModel) {
+    const toolCalls = toOpenAiToolCalls(data.message?.tool_calls);
+    return {
+        id: `chatcmpl-ollama-${Date.now()}`,
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: data.model || fallbackModel,
+        choices: [{
+                index: 0,
+                message: {
+                    role: data.message?.role || 'assistant',
+                    content: data.message?.content ?? '',
+                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                },
+                finish_reason: toFinishReason(data, toolCalls.length > 0),
+            }],
+        ...(toUsage(data) ? { usage: toUsage(data) } : {}),
+    };
+}
+/** One NDJSON line → one OpenAI streaming chunk. */
+export function toOpenAiChunk(data, fallbackModel, isFirst) {
+    const toolCalls = toOpenAiToolCalls(data.message?.tool_calls);
+    const delta = {};
+    if (isFirst || data.message?.role)
+        delta.role = data.message?.role || 'assistant';
+    if (data.message?.content)
+        delta.content = data.message.content;
+    if (toolCalls.length > 0) {
+        delta.tool_calls = toolCalls.map((call, index) => ({ index, ...call }));
+    }
+    return {
+        id: `chatcmpl-ollama-${fallbackModel}`,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model: data.model || fallbackModel,
+        choices: [{
+                index: 0,
+                delta,
+                finish_reason: data.done === true ? toFinishReason(data, toolCalls.length > 0) : null,
+            }],
+        ...(data.done === true && toUsage(data) ? { usage: toUsage(data) } : {}),
+    };
+}
+/** NDJSON body → OpenAI chunks. A malformed line is skipped, never fatal. */
+export async function* streamOllamaNative(body, fallbackModel) {
+    const reader = body?.getReader();
+    if (!reader)
+        throw new Error('Ollama returned an empty response body');
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let emitted = 0;
+    const emit = function* (line) {
+        if (!line.trim())
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        yield toOpenAiChunk(parsed, fallbackModel, emitted === 0);
+        emitted++;
+    };
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (value)
+                buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines)
+                yield* emit(line);
+            if (done)
+                break;
+        }
+        buffer += decoder.decode();
+        yield* emit(buffer);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+//# sourceMappingURL=ollama-native-transport.js.map

package/dist/codebuddy/providers/provider-agy-cli.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Antigravity (`agy`) CLI subprocess provider.
+ *
+ * The provider is deliberately text-only: Code Buddy owns tool execution,
+ * permissions, memory, and the agent loop. `agy` is constrained to plan mode
+ * and its sandbox, and receives no undocumented flags.
+ */
+import type { ChatCompletionChunk } from 'openai/resources/chat';
+import type { ChatOptions, CodeBuddyMessage, CodeBuddyResponse, CodeBuddyTool } from '../client.js';
+import type { Provider } from './provider-interface.js';
+export interface AgyCliProviderOptions {
+    binaryPath: string;
+    model: string;
+    defaultMaxTokens: number;
+    requestTimeoutMs?: number;
+    extraEnv?: Record<string, string>;
+}
+export declare class AgyCliProvider implements Provider {
+    private readonly binaryPath;
+    private model;
+    private readonly requestTimeoutMs;
+    private readonly extraEnv;
+    constructor(options: AgyCliProviderOptions);
+    setModel(model: string): void;
+    getProviderName(): string;
+    chat(messages: CodeBuddyMessage[], _tools?: CodeBuddyTool[], options?: ChatOptions): Promise<CodeBuddyResponse>;
+    chatStream(messages: CodeBuddyMessage[], _tools?: CodeBuddyTool[], options?: ChatOptions): AsyncGenerator<ChatCompletionChunk, void, unknown>;
+}
+export declare function formatMessagesForAgy(messages: CodeBuddyMessage[]): string;

package/dist/codebuddy/providers/provider-agy-cli.js

@@ -0,0 +1,264 @@
+/**
+ * Antigravity (`agy`) CLI subprocess provider.
+ *
+ * The provider is deliberately text-only: Code Buddy owns tool execution,
+ * permissions, memory, and the agent loop. `agy` is constrained to plan mode
+ * and its sandbox, and receives no undocumented flags.
+ */
+import { spawn } from 'node:child_process';
+const STDOUT_BYTES_CAP = 10 * 1024 * 1024;
+const STDERR_BYTES_CAP = 1024 * 1024;
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const KILL_GRACE_MS = 5_000;
+const ANSI_ESCAPE_PATTERN = new RegExp(`${String.fromCharCode(27)}(?:[@-Z\\-_]|\\[[0-?]*[ -/]*[@-~])`, 'g');
+const ADVISOR_BOUNDARY = [
+    '# External advisor boundary',
+    'Return analysis as plain text only.',
+    'Do not edit files, run commands, invoke tools, or ask for permissions.',
+    'Code Buddy is the sole tool executor and will independently verify your answer.',
+].join('\n');
+export class AgyCliProvider {
+    binaryPath;
+    model;
+    requestTimeoutMs;
+    extraEnv;
+    constructor(options) {
+        if (!options.binaryPath?.trim()) {
+            throw new Error('AgyCliProvider: binaryPath is required');
+        }
+        if (!options.model?.trim()) {
+            throw new Error('AgyCliProvider: model is required');
+        }
+        this.binaryPath = options.binaryPath;
+        this.model = options.model;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.extraEnv = options.extraEnv ?? {};
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    getProviderName() {
+        return 'agy-cli';
+    }
+    async chat(messages, _tools, options) {
+        const model = options?.model ?? this.model;
+        const prompt = formatMessagesForAgy(messages);
+        const result = await runAgy({
+            binaryPath: this.binaryPath,
+            model,
+            prompt,
+            timeoutMs: options?.timeoutMs ?? this.requestTimeoutMs,
+            extraEnv: this.extraEnv,
+            signal: options?.signal,
+        });
+        if (result.exitCode !== 0) {
+            throw mapAgyError(result.exitCode, result.stderr || result.stdout);
+        }
+        const content = stripAnsi(result.stdout).trim();
+        if (!content) {
+            throw new Error('agy-cli: subprocess returned an empty response');
+        }
+        return {
+            choices: [{
+                    message: { role: 'assistant', content },
+                    finish_reason: 'stop',
+                }],
+        };
+    }
+    async *chatStream(messages, _tools, options) {
+        const model = options?.model ?? this.model;
+        const prompt = formatMessagesForAgy(messages);
+        const child = spawnAgy(this.binaryPath, model, prompt, this.extraEnv);
+        const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
+        const stderrChunks = [];
+        let stderrBytes = 0;
+        let stdoutBytes = 0;
+        let terminalError = null;
+        const timeout = setTimeout(() => {
+            terminalError = new Error(`agy-cli: timeout after ${timeoutMs}ms`);
+            killChild(child);
+        }, timeoutMs);
+        const abort = () => {
+            terminalError = new Error('agy-cli: request aborted');
+            killChild(child);
+        };
+        options?.signal?.addEventListener('abort', abort, { once: true });
+        child.stderr.on('data', (chunk) => {
+            stderrBytes += chunk.length;
+            if (stderrBytes <= STDERR_BYTES_CAP)
+                stderrChunks.push(chunk);
+        });
+        child.on('error', (error) => {
+            terminalError = new Error(`agy-cli: failed to spawn ${this.binaryPath} — ${error.message}`);
+        });
+        try {
+            for await (const raw of child.stdout) {
+                const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+                stdoutBytes += chunk.length;
+                if (stdoutBytes > STDOUT_BYTES_CAP) {
+                    terminalError = new Error(`agy-cli: stdout exceeded ${STDOUT_BYTES_CAP} bytes`);
+                    killChild(child);
+                    break;
+                }
+                const content = stripAnsi(chunk.toString('utf-8'));
+                if (!content)
+                    continue;
+                yield makeChunk(model, content, null);
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+            options?.signal?.removeEventListener('abort', abort);
+        }
+        const exitCode = await waitForExit(child);
+        if (terminalError)
+            throw terminalError;
+        if (exitCode !== 0) {
+            throw mapAgyError(exitCode, Buffer.concat(stderrChunks).toString('utf-8'));
+        }
+        yield makeChunk(model, '', 'stop');
+    }
+}
+export function formatMessagesForAgy(messages) {
+    const blocks = [ADVISOR_BOUNDARY];
+    for (const message of messages) {
+        if (!message)
+            continue;
+        const content = extractMessageText(message);
+        if (!content)
+            continue;
+        const role = message.role === 'system'
+            ? 'System'
+            : message.role === 'assistant'
+                ? 'Assistant'
+                : message.role === 'tool'
+                    ? 'Tool result supplied by Code Buddy'
+                    : 'User';
+        blocks.push(`# ${role}\n${content}`);
+    }
+    return blocks.join('\n\n');
+}
+function extractMessageText(message) {
+    const content = message.content;
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => {
+        if (typeof part === 'string')
+            return part;
+        if (part && typeof part === 'object' && 'text' in part) {
+            return part.text ?? '';
+        }
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function spawnAgy(binaryPath, model, prompt, extraEnv) {
+    return spawn(binaryPath, [
+        '--print', prompt,
+        '--mode', 'plan',
+        '--sandbox',
+        '--model', model,
+        '--print-timeout', '5m',
+    ], {
+        shell: false,
+        env: { ...process.env, ...extraEnv },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+}
+function runAgy(options) {
+    return new Promise((resolve, reject) => {
+        const child = spawnAgy(options.binaryPath, options.model, options.prompt, options.extraEnv);
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let failure = null;
+        const fail = (error) => {
+            if (failure)
+                return;
+            failure = error;
+            killChild(child);
+        };
+        const timeout = setTimeout(() => fail(new Error(`agy-cli: timeout after ${options.timeoutMs}ms`)), options.timeoutMs);
+        const abort = () => fail(new Error('agy-cli: request aborted'));
+        options.signal?.addEventListener('abort', abort, { once: true });
+        child.stdout.on('data', (chunk) => {
+            stdoutBytes += chunk.length;
+            if (stdoutBytes > STDOUT_BYTES_CAP) {
+                fail(new Error(`agy-cli: stdout exceeded ${STDOUT_BYTES_CAP} bytes`));
+                return;
+            }
+            stdoutChunks.push(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrBytes += chunk.length;
+            if (stderrBytes <= STDERR_BYTES_CAP)
+                stderrChunks.push(chunk);
+        });
+        child.on('error', (error) => {
+            clearTimeout(timeout);
+            options.signal?.removeEventListener('abort', abort);
+            reject(new Error(`agy-cli: failed to spawn ${options.binaryPath} — ${error.message}`));
+        });
+        child.on('close', (exitCode) => {
+            clearTimeout(timeout);
+            options.signal?.removeEventListener('abort', abort);
+            if (failure) {
+                reject(failure);
+                return;
+            }
+            resolve({
+                stdout: Buffer.concat(stdoutChunks).toString('utf-8'),
+                stderr: Buffer.concat(stderrChunks).toString('utf-8'),
+                exitCode,
+            });
+        });
+    });
+}
+function makeChunk(model, content, finishReason) {
+    return {
+        id: 'agy-cli-stream',
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [{
+                index: 0,
+                delta: content ? { role: 'assistant', content } : {},
+                finish_reason: finishReason,
+            }],
+    };
+}
+function stripAnsi(value) {
+    return value.replace(ANSI_ESCAPE_PATTERN, '');
+}
+function mapAgyError(exitCode, details) {
+    const summary = stripAnsi(details).trim().slice(0, 500);
+    return new Error(`agy-cli: subprocess exited with code ${exitCode} — ${summary || 'no details'}`);
+}
+function killChild(child) {
+    try {
+        child.kill('SIGTERM');
+    }
+    catch {
+        return;
+    }
+    setTimeout(() => {
+        try {
+            if (!child.killed)
+                child.kill('SIGKILL');
+        }
+        catch {
+            // The process already exited.
+        }
+    }, KILL_GRACE_MS).unref?.();
+}
+function waitForExit(child) {
+    if (child.exitCode !== null)
+        return Promise.resolve(child.exitCode);
+    return new Promise((resolve) => child.once('close', resolve));
+}
+//# sourceMappingURL=provider-agy-cli.js.map