@otto-code/server 0.5.0

package/dist/server/server/agent/providers/openai-compat-agent.js

@@ -0,0 +1,2536 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { buildCompatToolPreviewDetail, buildOpenAIToolsPayload, COMPAT_TOOL_SPECS, executeCompatTool, findCompatToolSpec, isPathInsideWorkspace, } from "./openai-compat-tools.js";
+import { ottoToolGroupForName } from "@otto-code/protocol/provider-config";
+import { buildOpenAICompatFeatures, normalizeOpenAICompatAutoCompact, normalizeOpenAICompatReasoningEffort, OPENAI_COMPAT_AUTO_COMPACT_FALLBACK, OPENAI_COMPAT_AUTO_COMPACT_VALUES, OPENAI_COMPAT_DEFAULT_THINKING_OPTION_ID, OPENAI_COMPAT_THINKING_OPTIONS, } from "./openai-compat-feature-definitions.js";
+import { OpenAICompatMcpManager } from "./openai-compat-mcp.js";
+import { ottoToolPermissionKind } from "./openai-compat-otto-tool-permissions.js";
+import { stripInternalOttoMcpServer } from "../runtime-mcp-config.js";
+/**
+ * Native provider for OpenAI-compatible HTTP endpoints (LM Studio, Ollama,
+ * vLLM, llama.cpp server, gateways). The daemon talks to the endpoint
+ * directly — model discovery via GET {base}/models, streaming chat via
+ * POST {base}/chat/completions. No external agent binary is involved, so
+ * availability means "the server is reachable", not "a CLI is installed".
+ *
+ * Tool support: the daemon is the tool runtime. Function-calling models get a
+ * built-in coding toolset (read/list/grep/write/edit/shell) executed in the
+ * agent's cwd, with permission gating per mode.
+ */
+export const OPENAI_COMPAT_EXTENDS = "openai-compatible";
+const DEFAULT_CATALOG_TIMEOUT_MS = 10000;
+/** Upper bound on model→tool→model rounds within a single turn. */
+const MAX_TOOL_ROUNDS = 50;
+/**
+ * Per-tool-result budget for the compaction payload. Large results keep their
+ * head and tail — truncating harder starves the summarizer of the material
+ * (file contents, diffs, command output) the summary is supposed to preserve.
+ */
+const TOOL_RESULT_HEAD_CHARS = 3000;
+const TOOL_RESULT_TAIL_CHARS = 1000;
+/**
+ * Compaction keeps the most recent slice of the conversation verbatim and only
+ * summarizes the older history before it. Summarization is lossy, so we confine
+ * it to the distant past where the loss is cheap; recent turns (the files just
+ * read, the diff just applied, the error being debugged) stay intact.
+ * Default only — tunable per provider via `compaction.keepRecentTokens`.
+ */
+const COMPACTION_KEEP_RECENT_TOKENS = 20000;
+/**
+ * Resolve the provider-level auto-compact default that applies when an agent
+ * has no explicit `auto_compact` feature value. `autoCompact: false` wins over
+ * any configured threshold.
+ */
+function resolveAutoCompactDefault(compaction) {
+    if (compaction?.autoCompact === false) {
+        return "off";
+    }
+    if (typeof compaction?.thresholdPercent === "number") {
+        const candidate = String(compaction.thresholdPercent);
+        if (OPENAI_COMPAT_AUTO_COMPACT_VALUES.includes(candidate)) {
+            return candidate;
+        }
+    }
+    return OPENAI_COMPAT_AUTO_COMPACT_FALLBACK;
+}
+function resolveKeepRecentTokens(compaction) {
+    return typeof compaction?.keepRecentTokens === "number" && compaction.keepRecentTokens > 0
+        ? compaction.keepRecentTokens
+        : COMPACTION_KEEP_RECENT_TOKENS;
+}
+/**
+ * Pre-summarization pruning (zero-LLM) reclaims context before we spend a model
+ * call: uneventful tool results are elided and oversized older tool outputs are
+ * truncated, while the newest tool outputs are protected so live work is never
+ * trimmed out from under the model.
+ */
+const PRUNE_PROTECT_RECENT_TOOL_TOKENS = 12000;
+const PRUNE_TOOL_RESULT_MIN_CHARS = 2000;
+const PRUNE_TOOL_RESULT_HEAD_CHARS = 800;
+const PRUNE_TOOL_RESULT_TAIL_CHARS = 400;
+const UNEVENTFUL_RESULT_PLACEHOLDER = "[Uneventful result elided]";
+/**
+ * True when a tool result carries no signal worth keeping in context — empty
+ * output, zero-match searches, or a bare timeout/no-op acknowledgement. These
+ * are elided wholesale during pruning. Kept conservative on purpose: anything
+ * ambiguous is left intact for the summarizer to judge.
+ */
+export function isUneventfulToolResult(content) {
+    const trimmed = content.trim();
+    if (trimmed.length === 0) {
+        return true;
+    }
+    if (trimmed === UNEVENTFUL_RESULT_PLACEHOLDER) {
+        return false;
+    }
+    return [
+        /^no matches found\.?$/iu,
+        /^no results? found\.?$/iu,
+        /^found 0 (?:matches|results|files)\b/iu,
+        /^0 results?\b/iu,
+        /^no files? found\.?$/iu,
+        /^\(?no output\)?\.?$/iu,
+        /^command (?:completed|finished|exited) with no output\.?$/iu,
+        /^no changes\b/iu,
+    ].some((pattern) => pattern.test(trimmed));
+}
+/** Built-in slash command available for every OpenAI-compatible session. */
+const COMPACT_COMMAND = {
+    name: "compact",
+    description: "Compress the conversation history to free up context space",
+    argumentHint: "[instruction]",
+    kind: "command",
+};
+const CAPABILITIES = {
+    supportsStreaming: true,
+    supportsSessionPersistence: true,
+    supportsDynamicModes: false,
+    // The daemon itself is the MCP client for this provider: configured servers
+    // (provider config merged with per-agent config) are connected per session
+    // and their tools exposed to the model. See OpenAICompatMcpManager.
+    supportsMcpServers: true,
+    // The daemon owns this provider's tool loop, so we inject Otto's tool catalog
+    // (browser_*, preview_*, agent management, …) directly rather than via an MCP
+    // client the local model's runtime doesn't have. See ottoTools handling below.
+    supportsNativeOttoTools: true,
+    supportsReasoningStream: true,
+    supportsToolInvocations: true,
+    supportsRewindConversation: true,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
+};
+// Icons/colorTiers live here (not in AGENT_PROVIDER_DEFINITIONS) because
+// openai-compatible providers are registered dynamically, so the registry's
+// definition-based mode decoration has nothing to merge from.
+export const OPENAI_COMPAT_MODES = [
+    {
+        id: "default",
+        label: "Always Ask",
+        description: "Prompts for permission before running commands or editing files",
+        icon: "ShieldQuestionMark",
+        colorTier: "neutral",
+    },
+    {
+        id: "acceptEdits",
+        label: "Accept File Edits",
+        description: "Automatically approves file edits inside the workspace; still asks before running commands",
+        icon: "ShieldPerson",
+        colorTier: "safe",
+    },
+    {
+        id: "plan",
+        label: "Read Only",
+        description: "Only read tools are available — no edits or commands; web fetches still ask",
+        icon: "ShieldToggle",
+        colorTier: "planning",
+    },
+    {
+        id: "bypassPermissions",
+        label: "Bypass",
+        description: "Skip all permission prompts (use with caution)",
+        icon: "PrivacyTip",
+        colorTier: "dangerous",
+        isUnattended: true,
+    },
+];
+const VALID_MODE_IDS = new Set(OPENAI_COMPAT_MODES.map((mode) => mode.id));
+/** Permission-prompt description per builtin tool kind ("read" never prompts). */
+const COMPAT_TOOL_PROMPT_DESCRIPTIONS = {
+    read: "Wants to read from the workspace",
+    edit: "Wants to modify a file",
+    execute: "Wants to run a shell command",
+    network: "Wants to fetch content from the web",
+};
+/** Mirror of the opencode provider's parser: `/name rest` → command + args. */
+function parseSlashCommandInput(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/") || trimmed.length <= 1) {
+        return null;
+    }
+    const withoutPrefix = trimmed.slice(1);
+    const firstWhitespaceIdx = withoutPrefix.search(/\s/u);
+    const commandName = firstWhitespaceIdx === -1 ? withoutPrefix : withoutPrefix.slice(0, firstWhitespaceIdx);
+    if (!commandName || commandName.includes("/")) {
+        return null;
+    }
+    const rawArgs = firstWhitespaceIdx === -1 ? "" : withoutPrefix.slice(firstWhitespaceIdx + 1).trim();
+    return { commandName, args: rawArgs.length > 0 ? rawArgs : null };
+}
+function toWireMessage(message) {
+    if (message.role === "system" || message.role === "user") {
+        return { role: message.role, content: message.content };
+    }
+    if (message.role === "assistant") {
+        return {
+            role: message.role,
+            content: message.content,
+            ...(message.tool_calls ? { tool_calls: message.tool_calls } : {}),
+        };
+    }
+    return message;
+}
+/**
+ * Fold a reconstructed tool result's raw text into whichever field the
+ * preview detail's type uses for it. Only the flat result text survives
+ * persistence — structured metadata that a live run attaches (numMatches,
+ * webResults, exitCode, ...) isn't recoverable from a bare
+ * { name, arguments, result-text } tuple, so callers only get the text back.
+ */
+function attachReconstructedOutput(detail, outputText) {
+    switch (detail.type) {
+        case "shell":
+            return { ...detail, output: outputText };
+        case "read":
+            return { ...detail, content: outputText };
+        case "search":
+            return { ...detail, content: outputText };
+        case "fetch":
+            return { ...detail, result: outputText };
+        case "plain_text":
+            return { ...detail, text: outputText };
+        case "unknown":
+            return { ...detail, output: outputText };
+        default:
+            return detail;
+    }
+}
+/**
+ * Reconstruct a tool_call timeline item from a persisted assistant tool call
+ * plus its matching "tool" result message. Used to replay history on resume,
+ * where the only surviving record is the raw chat-format conversation.
+ */
+function buildReconstructedToolCallItem(call, resultMessage, cwd) {
+    let args = {};
+    try {
+        const parsed = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+        if (parsed && typeof parsed === "object") {
+            args = parsed;
+        }
+    }
+    catch {
+        // Malformed persisted arguments shouldn't block reload — fall back to {}.
+    }
+    const baseDetail = buildCompatToolPreviewDetail(call.function.name, args, cwd);
+    return {
+        type: "tool_call",
+        callId: call.id,
+        name: call.function.name,
+        detail: resultMessage
+            ? attachReconstructedOutput(baseDetail, resultMessage.content)
+            : baseDetail,
+        // No matching "tool" result means the turn was interrupted before the
+        // result came back (e.g. the app closed mid-call).
+        status: resultMessage ? "completed" : "canceled",
+        error: null,
+    };
+}
+export function normalizeOpenAICompatBaseUrl(value) {
+    const withoutTrailingSlashes = value.trim().replace(/\/+$/u, "");
+    if (withoutTrailingSlashes.endsWith("/v1")) {
+        return withoutTrailingSlashes;
+    }
+    return `${withoutTrailingSlashes}/v1`;
+}
+function resolveEndpoint(env, label) {
+    const rawBaseUrl = env?.["OPENAI_BASE_URL"]?.trim();
+    if (!rawBaseUrl) {
+        throw new Error(`${label} has no server URL configured. Set OPENAI_BASE_URL in the provider settings.`);
+    }
+    const apiKey = env?.["OPENAI_API_KEY"]?.trim() || null;
+    return { baseUrl: normalizeOpenAICompatBaseUrl(rawBaseUrl), apiKey };
+}
+function buildHeaders(endpoint) {
+    const headers = { "Content-Type": "application/json" };
+    if (endpoint.apiKey) {
+        headers["Authorization"] = `Bearer ${endpoint.apiKey}`;
+    }
+    return headers;
+}
+function unreachableError(label, endpoint, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    return new Error(`Cannot reach ${label} at ${endpoint.baseUrl} (${detail}). Make sure the server is running and the URL is correct.`);
+}
+function promptToText(prompt) {
+    if (typeof prompt === "string") {
+        return prompt;
+    }
+    return prompt
+        .flatMap((block) => (block.type === "text" ? [block.text] : []))
+        .join("\n")
+        .trim();
+}
+async function* readLines(body) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for await (const chunk of body) {
+        buffer += decoder.decode(chunk, { stream: true });
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+            yield buffer.slice(0, newlineIndex).replace(/\r$/u, "");
+            buffer = buffer.slice(newlineIndex + 1);
+            newlineIndex = buffer.indexOf("\n");
+        }
+    }
+    const rest = buffer.trim();
+    if (rest) {
+        yield rest;
+    }
+}
+function parseToolCallDeltas(deltaRecord) {
+    const raw = deltaRecord.tool_calls;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw.flatMap((entry, position) => {
+        if (!entry || typeof entry !== "object") {
+            return [];
+        }
+        const record = entry;
+        const fn = record.function && typeof record.function === "object"
+            ? record.function
+            : {};
+        return [
+            {
+                index: typeof record.index === "number" ? record.index : position,
+                ...(typeof record.id === "string" && record.id ? { id: record.id } : {}),
+                ...(typeof fn.name === "string" && fn.name ? { name: fn.name } : {}),
+                ...(typeof fn.arguments === "string" ? { argumentsChunk: fn.arguments } : {}),
+            },
+        ];
+    });
+}
+function parseStreamChunk(json) {
+    const result = {
+        content: null,
+        reasoning: null,
+        toolCalls: [],
+        finishReason: null,
+        usage: null,
+    };
+    if (!json || typeof json !== "object") {
+        return result;
+    }
+    const chunk = json;
+    const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
+    const firstChoice = choices[0];
+    if (firstChoice && typeof firstChoice === "object") {
+        const choiceRecord = firstChoice;
+        if (typeof choiceRecord.finish_reason === "string") {
+            result.finishReason = choiceRecord.finish_reason;
+        }
+        const delta = choiceRecord.delta;
+        if (delta && typeof delta === "object") {
+            const deltaRecord = delta;
+            if (typeof deltaRecord.content === "string" && deltaRecord.content.length > 0) {
+                result.content = deltaRecord.content;
+            }
+            const reasoning = deltaRecord.reasoning_content ?? deltaRecord.reasoning;
+            if (typeof reasoning === "string" && reasoning.length > 0) {
+                result.reasoning = reasoning;
+            }
+            result.toolCalls = parseToolCallDeltas(deltaRecord);
+        }
+    }
+    const usage = chunk.usage;
+    if (usage && typeof usage === "object") {
+        const usageRecord = usage;
+        result.usage = {
+            ...(typeof usageRecord.prompt_tokens === "number"
+                ? { inputTokens: usageRecord.prompt_tokens }
+                : {}),
+            ...(typeof usageRecord.completion_tokens === "number"
+                ? { outputTokens: usageRecord.completion_tokens }
+                : {}),
+        };
+    }
+    return result;
+}
+function parseModelList(json) {
+    if (!json || typeof json !== "object") {
+        return [];
+    }
+    const data = json.data;
+    if (!Array.isArray(data)) {
+        return [];
+    }
+    return data.flatMap((entry) => {
+        if (entry && typeof entry === "object" && typeof entry.id === "string") {
+            return [entry.id];
+        }
+        return [];
+    });
+}
+/**
+ * Optional per-model context-length fields seen across OpenAI-compatible
+ * servers. LM Studio's native listing reports `loaded_context_length` (the
+ * window the loaded instance actually runs with) ahead of the model's
+ * theoretical `max_context_length`; vLLM extends /v1/models with
+ * `max_model_len`; other gateways use `context_length`/`context_window`.
+ */
+const MODEL_CONTEXT_LENGTH_FIELDS = [
+    "loaded_context_length",
+    "max_context_length",
+    "max_model_len",
+    "context_length",
+    "context_window",
+];
+function parseModelContextLength(entry) {
+    for (const field of MODEL_CONTEXT_LENGTH_FIELDS) {
+        const value = entry[field];
+        if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+            return value;
+        }
+    }
+    return null;
+}
+function parseModelContextLengths(json) {
+    const lengths = new Map();
+    if (!json || typeof json !== "object") {
+        return lengths;
+    }
+    const data = json.data;
+    if (!Array.isArray(data)) {
+        return lengths;
+    }
+    for (const entry of data) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        if (typeof record.id !== "string")
+            continue;
+        const contextLength = parseModelContextLength(record);
+        if (contextLength !== null) {
+            lengths.set(record.id, contextLength);
+        }
+    }
+    return lengths;
+}
+/**
+ * Rough token estimate for the breakdown split (~4 chars/token). The split is
+ * proportional only; the total is corrected to the server-measured
+ * prompt_tokens when one has been observed.
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function parseToolCallPayloads(raw) {
+    if (!Array.isArray(raw)) {
+        return null;
+    }
+    const calls = raw.flatMap((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return [];
+        }
+        const record = entry;
+        const fn = record.function && typeof record.function === "object"
+            ? record.function
+            : null;
+        if (typeof record.id !== "string" ||
+            !fn ||
+            typeof fn.name !== "string" ||
+            typeof fn.arguments !== "string") {
+            return [];
+        }
+        return [
+            { id: record.id, type: "function", function: { name: fn.name, arguments: fn.arguments } },
+        ];
+    });
+    return calls.length > 0 ? calls : null;
+}
+function restoreMessages(metadata) {
+    const raw = metadata?.["messages"];
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const parsed = raw.flatMap((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return [];
+        }
+        const record = entry;
+        const { role, content } = record;
+        if (typeof content !== "string") {
+            return [];
+        }
+        if (role === "system" || role === "user") {
+            const messageId = typeof record.messageId === "string" ? record.messageId : undefined;
+            const isCompactionSummary = record.isCompactionSummary === true;
+            return [
+                {
+                    role,
+                    content,
+                    ...(messageId ? { messageId } : {}),
+                    ...(isCompactionSummary ? { isCompactionSummary: true } : {}),
+                },
+            ];
+        }
+        if (role === "assistant") {
+            const toolCalls = parseToolCallPayloads(record.tool_calls);
+            const reasoning = typeof record.reasoning === "string" ? record.reasoning : undefined;
+            return [
+                {
+                    role,
+                    content,
+                    ...(reasoning ? { reasoning } : {}),
+                    ...(toolCalls ? { tool_calls: toolCalls } : {}),
+                },
+            ];
+        }
+        if (role === "tool" && typeof record.tool_call_id === "string") {
+            return [{ role, content, tool_call_id: record.tool_call_id }];
+        }
+        return [];
+    });
+    return sanitizeRestoredMessages(parsed);
+}
+/**
+ * Persistence trims to the last N messages, which can orphan tool messages
+ * from their assistant tool_calls (or vice versa). OpenAI-compatible servers
+ * reject such conversations, so repair the boundary: drop orphan tool
+ * results and strip tool_calls that have no results following them.
+ */
+function sanitizeRestoredMessages(messages) {
+    const result = [];
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (message.role === "tool") {
+            continue; // reached only when not consumed by an assistant tool_calls below
+        }
+        if (message.role !== "assistant" || !message.tool_calls) {
+            result.push(message);
+            continue;
+        }
+        const callIds = new Set(message.tool_calls.map((call) => call.id));
+        const results = [];
+        let cursor = index + 1;
+        while (cursor < messages.length) {
+            const candidate = messages[cursor];
+            if (candidate.role !== "tool" || !callIds.has(candidate.tool_call_id)) {
+                break;
+            }
+            results.push(candidate);
+            cursor += 1;
+        }
+        if (results.length === message.tool_calls.length) {
+            result.push(message, ...results);
+            index = cursor - 1;
+        }
+        else if (message.content || message.reasoning) {
+            result.push({
+                role: "assistant",
+                content: message.content,
+                ...(message.reasoning ? { reasoning: message.reasoning } : {}),
+            });
+        }
+    }
+    return result;
+}
+export class OpenAICompatAgentClient {
+    constructor(options) {
+        this.capabilities = CAPABILITIES;
+        this.provider = options.providerId;
+        this.logger = options.logger;
+        this.label = options.label;
+        this.env = options.env;
+        this.ottoToolGroups = options.ottoToolGroups ?? null;
+        this.mcpServers = options.mcpServers ?? null;
+        this.mcpToolPermissions = options.mcpToolPermissions ?? "always-ask";
+        this.compaction = options.compaction ?? null;
+        this.managedProcesses = options.managedProcesses ?? null;
+    }
+    async isAvailable() {
+        // Nothing to install — availability is endpoint reachability, surfaced
+        // through fetchCatalog so the UI shows a configuration error, not
+        // "not installed".
+        return true;
+    }
+    async fetchCatalog(options) {
+        const endpoint = resolveEndpoint(this.env, this.label);
+        const timeoutMs = options.timeoutMs ?? DEFAULT_CATALOG_TIMEOUT_MS;
+        let response;
+        try {
+            response = await fetch(`${endpoint.baseUrl}/models`, {
+                headers: buildHeaders(endpoint),
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+        }
+        catch (error) {
+            throw unreachableError(this.label, endpoint, error);
+        }
+        if (!response.ok) {
+            throw new Error(`${this.label} at ${endpoint.baseUrl} responded ${response.status} to /models. Check the URL and API key.`);
+        }
+        const listing = await response.json();
+        const modelIds = parseModelList(listing);
+        const contextLengths = parseModelContextLengths(listing);
+        const models = modelIds.map((id, index) => {
+            const model = {
+                provider: this.provider,
+                id,
+                label: id,
+                isDefault: index === 0,
+                // Whether a given endpoint model honors reasoning_effort isn't
+                // discoverable from /models, so every model advertises the full set
+                // with "off" as the safe default (off omits the parameter entirely).
+                thinkingOptions: [...OPENAI_COMPAT_THINKING_OPTIONS],
+                defaultThinkingOptionId: OPENAI_COMPAT_DEFAULT_THINKING_OPTION_ID,
+            };
+            const contextWindowMaxTokens = contextLengths.get(id);
+            if (typeof contextWindowMaxTokens === "number") {
+                model.contextWindowMaxTokens = contextWindowMaxTokens;
+            }
+            return model;
+        });
+        return { models, modes: OPENAI_COMPAT_MODES };
+    }
+    async getDiagnostic() {
+        let endpoint;
+        try {
+            endpoint = resolveEndpoint(this.env, this.label);
+        }
+        catch (error) {
+            return { diagnostic: error instanceof Error ? error.message : String(error) };
+        }
+        try {
+            const catalog = await this.fetchCatalog({ scope: "global", force: true });
+            return {
+                diagnostic: [
+                    `${this.label} (OpenAI-compatible endpoint)`,
+                    `  URL: ${endpoint.baseUrl}`,
+                    `  Auth: ${endpoint.apiKey ? "API key configured" : "none"}`,
+                    `  Models: ${catalog.models.length}`,
+                    `  Status: reachable`,
+                ].join("\n"),
+            };
+        }
+        catch (error) {
+            return {
+                diagnostic: [
+                    `${this.label} (OpenAI-compatible endpoint)`,
+                    `  URL: ${endpoint.baseUrl}`,
+                    `  Auth: ${endpoint.apiKey ? "API key configured" : "none"}`,
+                    `  Status: ${error instanceof Error ? error.message : String(error)}`,
+                ].join("\n"),
+            };
+        }
+    }
+    async listFeatures(config) {
+        const autoCompactDefault = resolveAutoCompactDefault(this.compaction);
+        const hideAutoCompact = this.compaction?.hideSelector === true;
+        return buildOpenAICompatFeatures({
+            autoCompact: hideAutoCompact
+                ? autoCompactDefault
+                : normalizeOpenAICompatAutoCompact(config.featureValues?.["auto_compact"], autoCompactDefault),
+            autoCompactDefault,
+            hideAutoCompact,
+        });
+    }
+    async createSession(config, launchContext) {
+        return new OpenAICompatAgentSession({
+            providerId: this.provider,
+            label: this.label,
+            env: this.env,
+            config,
+            sessionId: randomUUID(),
+            messages: [],
+            logger: this.logger,
+            ottoTools: launchContext?.ottoTools ?? null,
+            ottoToolGroups: this.ottoToolGroups,
+            mcpServers: this.mcpServers,
+            mcpToolPermissions: this.mcpToolPermissions,
+            compaction: this.compaction,
+            managedProcesses: this.managedProcesses,
+        });
+    }
+    async resumeSession(handle, overrides, launchContext) {
+        const metadata = (handle.metadata ?? {});
+        const model = typeof metadata.model === "string" ? metadata.model : undefined;
+        const modeId = typeof metadata.modeId === "string" ? metadata.modeId : undefined;
+        return new OpenAICompatAgentSession({
+            providerId: this.provider,
+            label: this.label,
+            env: this.env,
+            config: {
+                provider: this.provider,
+                cwd: overrides?.cwd ?? process.cwd(),
+                ...(model ? { model } : {}),
+                ...(modeId ? { modeId } : {}),
+                ...overrides,
+            },
+            sessionId: handle.sessionId,
+            messages: restoreMessages(metadata),
+            logger: this.logger,
+            ottoTools: launchContext?.ottoTools ?? null,
+            ottoToolGroups: this.ottoToolGroups,
+            mcpServers: this.mcpServers,
+            mcpToolPermissions: this.mcpToolPermissions,
+            compaction: this.compaction,
+            managedProcesses: this.managedProcesses,
+        });
+    }
+}
+function isZodType(schema) {
+    return typeof schema.safeParseAsync === "function";
+}
+/** Convert an Otto tool's Zod input schema into the JSON Schema the OpenAI `tools` payload expects. */
+function ottoToolParameters(tool) {
+    const schema = tool.inputSchema;
+    if (!schema) {
+        return { type: "object", properties: {} };
+    }
+    try {
+        const zodSchema = isZodType(schema) ? schema : z.object(schema);
+        const jsonSchema = z.toJSONSchema(zodSchema);
+        delete jsonSchema.$schema;
+        return jsonSchema;
+    }
+    catch {
+        // A schema JSON Schema can't represent (e.g. transforms) still leaves the
+        // tool callable; executeTool validates the args when it runs.
+        return { type: "object", properties: {} };
+    }
+}
+/** Flatten an Otto tool result into the text fed back to the model. */
+function ottoResultToText(result) {
+    const texts = result.content
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text);
+    if (texts.length > 0) {
+        return texts.join("\n");
+    }
+    if (result.structuredContent !== undefined) {
+        try {
+            return JSON.stringify(result.structuredContent, null, 2);
+        }
+        catch {
+            return String(result.structuredContent);
+        }
+    }
+    return result.isError ? "Tool failed" : "Done.";
+}
+export class OpenAICompatAgentSession {
+    constructor(options) {
+        this.capabilities = CAPABILITIES;
+        this.listeners = new Set();
+        this.eventHistory = [];
+        this.pendingPermissions = new Map();
+        /** Connection failures already surfaced as timeline warnings. */
+        this.mcpFailuresAnnounced = false;
+        /**
+         * Loop protection: set when an auto-compaction failed or couldn't bring
+         * usage back under the threshold, so the next round doesn't immediately
+         * retry. Cleared once measured usage drops below the threshold again
+         * (rewind, manual /compact, model switch to a larger window).
+         */
+        this.autoCompactDisarmed = false;
+        this.activeTurn = null;
+        /** Resolved context window for the active model; null until (or unless) discovered. */
+        this.contextWindowMaxTokens = null;
+        /** Model the cached context window was resolved for; re-probe after a model switch. */
+        this.contextWindowProbedModel = null;
+        /** Exact context size (prompt + completion tokens) measured by the server on the last round. */
+        this.lastContextTokens = null;
+        this.provider = options.providerId;
+        this.label = options.label;
+        this.env = options.env;
+        this.logger = options.logger;
+        this.id = options.sessionId;
+        this.cwd = options.config.cwd;
+        this.config = options.config;
+        this.ottoTools = options.ottoTools ?? null;
+        this.ottoToolGroups = options.ottoToolGroups ?? null;
+        this.mcpToolPermissions = options.mcpToolPermissions ?? "always-ask";
+        // Provider-level servers merged with per-agent config; the per-agent entry
+        // wins per server name. The daemon-injected internal "otto" MCP server is
+        // stripped — this provider receives Otto tools natively, and connecting to
+        // it over MCP as well would double them.
+        const perAgentServers = stripInternalOttoMcpServer(options.config).mcpServers;
+        const mergedServers = {
+            ...options.mcpServers,
+            ...perAgentServers,
+        };
+        this.mcpManager =
+            Object.keys(mergedServers).length > 0
+                ? new OpenAICompatMcpManager({
+                    servers: mergedServers,
+                    providerId: options.providerId,
+                    cwd: options.config.cwd,
+                    logger: options.logger,
+                    managedProcesses: options.managedProcesses ?? null,
+                })
+                : null;
+        this.modelId = options.config.model ?? null;
+        this.modeId =
+            options.config.modeId && VALID_MODE_IDS.has(options.config.modeId)
+                ? options.config.modeId
+                : "default";
+        // Effort comes from the model-level thinking option like every other
+        // provider. COMPAT(openaiCompatReasoningFeature): added in v0.4.5 — agents
+        // created before the unification persisted the value as the
+        // featureValues.reasoning_effort select instead; drop the fallback when
+        // floor >= v0.4.5 (target 2027-01).
+        this.reasoningEffort = normalizeOpenAICompatReasoningEffort(options.config.thinkingOptionId || options.config.featureValues?.["reasoning_effort"]);
+        this.autoCompactDefault = resolveAutoCompactDefault(options.compaction);
+        this.autoCompactHidden = options.compaction?.hideSelector === true;
+        this.autoCompact = this.autoCompactHidden
+            ? this.autoCompactDefault
+            : normalizeOpenAICompatAutoCompact(options.config.featureValues?.["auto_compact"], this.autoCompactDefault);
+        this.keepRecentTokens = resolveKeepRecentTokens(options.compaction);
+        // The system message is always rebuilt so cwd/mode/config changes take
+        // effect on resume; restored copies of it are dropped first.
+        this.messages = options.messages.filter((message) => message.role !== "system");
+        this.messages.unshift({ role: "system", content: this.buildSystemPrompt(options.config) });
+        this.rebuildEventHistory();
+    }
+    /**
+     * Rebuild replayable history from the current conversation so a resumed or
+     * rewound session still backfills its transcript, tool calls included.
+     * There is no separate durable store for tool traffic — `this.messages` is
+     * the only record that survives a resume, so tool_call items are
+     * reconstructed from each assistant message's `tool_calls` plus the
+     * matching "tool" result message. User messages keep their persisted
+     * messageId so the durable timeline and the provider conversation agree on
+     * rewind targets.
+     */
+    rebuildEventHistory() {
+        this.eventHistory.length = 0;
+        for (const [index, message] of this.messages.entries()) {
+            if (message.role === "user") {
+                if (!message.content)
+                    continue;
+                this.eventHistory.push({
+                    type: "timeline",
+                    provider: this.provider,
+                    item: {
+                        type: "user_message",
+                        text: message.content,
+                        messageId: message.messageId ?? randomUUID(),
+                    },
+                });
+                continue;
+            }
+            if (message.role !== "assistant")
+                continue;
+            // Live order within a round is reasoning → assistant text → tool calls;
+            // replay mirrors it.
+            if (message.reasoning) {
+                this.eventHistory.push({
+                    type: "timeline",
+                    provider: this.provider,
+                    item: { type: "reasoning", text: message.reasoning },
+                });
+            }
+            if (message.content) {
+                this.eventHistory.push({
+                    type: "timeline",
+                    provider: this.provider,
+                    item: { type: "assistant_message", text: message.content, messageId: randomUUID() },
+                });
+            }
+            for (const call of message.tool_calls ?? []) {
+                const resultMessage = this.messages
+                    .slice(index + 1)
+                    .find((candidate) => candidate.role === "tool" && candidate.tool_call_id === call.id);
+                this.eventHistory.push({
+                    type: "timeline",
+                    provider: this.provider,
+                    item: buildReconstructedToolCallItem(call, resultMessage, this.cwd),
+                });
+            }
+        }
+    }
+    get features() {
+        return buildOpenAICompatFeatures({
+            autoCompact: this.autoCompact,
+            autoCompactDefault: this.autoCompactDefault,
+            hideAutoCompact: this.autoCompactHidden,
+        });
+    }
+    async setThinkingOption(thinkingOptionId) {
+        // null clears back to the model default; "off" omits reasoning_effort
+        // from requests entirely.
+        if (thinkingOptionId === null) {
+            this.reasoningEffort = OPENAI_COMPAT_DEFAULT_THINKING_OPTION_ID;
+            return;
+        }
+        if (normalizeOpenAICompatReasoningEffort(thinkingOptionId) !== thinkingOptionId) {
+            throw new Error(`Invalid effort option: ${String(thinkingOptionId)}`);
+        }
+        this.reasoningEffort = thinkingOptionId;
+    }
+    async applyPersonality(update) {
+        this.config.personalitySnapshot = update.personalitySnapshot;
+        this.config.systemPrompt = update.systemPrompt;
+        this.config.daemonAppendSystemPrompt = update.daemonAppendSystemPrompt;
+        // The daemon owns this conversation: the system prompt is just messages[0],
+        // re-sent wholesale on every request, so rebuilding it in place applies the
+        // new personality prompt from the very next turn — no session restart.
+        const rebuilt = { role: "system", content: this.buildSystemPrompt(this.config) };
+        if (this.messages[0]?.role === "system") {
+            this.messages[0] = rebuilt;
+        }
+        else {
+            this.messages.unshift(rebuilt);
+        }
+    }
+    async setFeature(featureId, value) {
+        // COMPAT(openaiCompatReasoningFeature): added in v0.4.5 — effort is no
+        // longer advertised as a feature, but old clients may still send the
+        // reasoning_effort select; drop when floor >= v0.4.5 (target 2027-01).
+        if (featureId === "reasoning_effort") {
+            if (normalizeOpenAICompatReasoningEffort(value) !== value) {
+                throw new Error(`Invalid reasoning effort value: ${String(value)}`);
+            }
+            this.reasoningEffort = value;
+            return;
+        }
+        if (featureId === "auto_compact") {
+            if (!OPENAI_COMPAT_AUTO_COMPACT_VALUES.includes(value)) {
+                throw new Error(`Invalid auto-compact value: ${String(value)}`);
+            }
+            this.autoCompact = value;
+            // A deliberate setting change is a fresh mandate — retry even if a
+            // previous auto-compaction was paused for lack of gain.
+            this.autoCompactDisarmed = false;
+            return;
+        }
+        throw new Error(`Unknown feature: ${featureId}`);
+    }
+    /**
+     * Live re-apply of provider-level compaction config so settings edits reach
+     * running chats without a restart. Sessions still sitting on the old default
+     * follow the new default; an explicit per-agent pick is kept unless the
+     * selector is hidden, which always forces the default.
+     */
+    applyCompactionConfig(compaction) {
+        const previousDefault = this.autoCompactDefault;
+        const previousHidden = this.autoCompactHidden;
+        const previousValue = this.autoCompact;
+        this.autoCompactDefault = resolveAutoCompactDefault(compaction);
+        this.autoCompactHidden = compaction?.hideSelector === true;
+        this.keepRecentTokens = resolveKeepRecentTokens(compaction);
+        if (this.autoCompactHidden || previousValue === previousDefault) {
+            this.autoCompact = this.autoCompactDefault;
+        }
+        if (this.autoCompact !== previousValue) {
+            // Same fresh-mandate rule as setFeature: a deliberate settings change
+            // re-arms a paused auto-compaction.
+            this.autoCompactDisarmed = false;
+        }
+        return (this.autoCompact !== previousValue ||
+            this.autoCompactHidden !== previousHidden ||
+            this.autoCompactDefault !== previousDefault);
+    }
+    buildSystemPrompt(config) {
+        const parts = [
+            [
+                `You are a coding agent running inside Otto against ${this.label}.`,
+                `Workspace directory: ${this.cwd}`,
+                `Platform: ${process.platform}`,
+                "Use the available tools to read, search, and modify files and to run shell commands.",
+                "Prefer tools over guessing: inspect files before editing them and verify your changes.",
+                "When the task is complete, reply with a concise summary of what you did.",
+            ].join("\n"),
+            this.buildPreviewWorkflowPrompt(),
+            config.systemPrompt?.trim(),
+            config.daemonAppendSystemPrompt?.trim(),
+        ];
+        return parts.filter((part) => Boolean(part)).join("\n\n");
+    }
+    /**
+     * Workflow doctrine for the preview/browser tool families. Tool descriptions
+     * alone don't reliably steer local models, so when both families are exposed
+     * the system prompt spells out the split: preview_start owns dev servers and
+     * their designated tab; browser_new_tab is for everything else.
+     */
+    buildPreviewWorkflowPrompt() {
+        const hasTool = (name) => Boolean(this.ottoTools?.getTool(name)) && this.isOttoToolGroupEnabled(name);
+        const hasPreview = hasTool("preview_start");
+        const hasBrowser = hasTool("browser_snapshot");
+        if (!hasPreview && !hasBrowser) {
+            return null;
+        }
+        const lines = ["## Verifying changes in the browser"];
+        if (hasPreview) {
+            lines.push("- Start dev servers with preview_start — never with run_command or other shell commands. It manages the process, its logs (preview_logs), and its preview tab.");
+        }
+        if (hasPreview && hasBrowser) {
+            lines.push("- preview_start returns browser.browserId: the server's designated preview tab, the same tab the user watches. Verify your changes against that browserId with browser_snapshot, browser_inspect, browser_logs, browser_click, and browser_screenshot.", "- Never open a dev server URL with browser_new_tab or in another tab — the daemon rejects it. browser_new_tab is only for external sites and general browsing.");
+        }
+        if (hasBrowser) {
+            lines.push("- After changing code that a running dev server renders, verify it: reload or snapshot the page, check browser_logs for errors, then share proof (a snapshot or screenshot) instead of asking the user to check manually.");
+        }
+        return lines.join("\n");
+    }
+    availableToolSpecs() {
+        return COMPAT_TOOL_SPECS.filter((spec) => {
+            // Read-only "plan" mode offers no actions against the local machine.
+            // "network" tools (web_fetch) stay available for research but prompt.
+            if (this.modeId === "plan" && spec.kind !== "read" && spec.kind !== "network")
+                return false;
+            // The builtin web tools (web_search/web_fetch) are gated by the "web"
+            // tool group, just like the injected Otto tool groups.
+            if (ottoToolGroupForName(spec.name) === "web" && !this.isOttoToolGroupEnabled(spec.name)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    toolNeedsApproval(spec, args) {
+        if (spec.kind === "read")
+            return false;
+        if (this.modeId === "bypassPermissions")
+            return false;
+        if (this.modeId === "acceptEdits" && spec.kind === "edit") {
+            // Auto-approval is scoped to the workspace: a write to ~/.bashrc or
+            // Otto's own config is not the "file edits" the mode label promises,
+            // so anything outside the cwd subtree still prompts.
+            const target = args["path"];
+            return typeof target !== "string" || !isPathInsideWorkspace(this.cwd, target);
+        }
+        // Everything else that can act — execute always, and network because an
+        // unprompted web_fetch is an exfiltration channel for unprompted reads.
+        return true;
+    }
+    /**
+     * Otto's injected catalog (browser_*, preview_*, agent management, …) rendered
+     * as OpenAI function specs so the local model can call them. Excluded in
+     * read-only "plan" mode since they can take actions; builtin coding tools win
+     * on name collisions. Empty when no catalog was injected (e.g. tools disabled).
+     */
+    /** Whether an Otto tool's group is enabled for this provider (null groups = all). */
+    isOttoToolGroupEnabled(name) {
+        const groups = this.ottoToolGroups;
+        return !groups || groups.includes(ottoToolGroupForName(name));
+    }
+    /**
+     * Connect the configured MCP servers before the first model round. A server
+     * that fails to connect is skipped — surfaced once as a timeline warning,
+     * never fatal to the session.
+     */
+    async ensureMcpReady(turn) {
+        if (!this.mcpManager) {
+            return;
+        }
+        await this.mcpManager.ensureConnected();
+        if (this.mcpFailuresAnnounced) {
+            return;
+        }
+        this.mcpFailuresAnnounced = true;
+        for (const failure of this.mcpManager.failures) {
+            this.emit({
+                type: "timeline",
+                provider: this.provider,
+                turnId: turn.turnId,
+                item: {
+                    type: "error",
+                    message: `MCP server '${failure.name}' unavailable: ${failure.error}`,
+                },
+            });
+        }
+    }
+    /** Built-in slash commands plus MCP prompts from connected servers. */
+    async listCommands() {
+        const commands = [COMPACT_COMMAND];
+        if (!this.mcpManager) {
+            return commands;
+        }
+        const prompts = await this.mcpManager.listPrompts();
+        return commands.concat(prompts.map((prompt) => ({
+            name: prompt.commandName,
+            description: prompt.description ?? `MCP prompt from server '${prompt.serverName}'`,
+            argumentHint: prompt.argumentNames.join(" "),
+        })));
+    }
+    /**
+     * Handle `/compact [instruction]` by summarizing the older conversation
+     * history while keeping the most recent slice verbatim, then splicing the
+     * summary in ahead of the retained tail. Runs entirely in-process — no
+     * external compaction service. Returns the turn's usage so the caller can
+     * attach it to turn_completed.
+     *
+     * Pipeline (adapted from oh-my-pi's compaction design):
+     *   1. Prune tool outputs (zero-LLM): elide uneventful results, truncate
+     *      oversized older ones, protect the newest.
+     *   2. Split at the keep-recent boundary: [system] + [older → summarize] +
+     *      [recent → keep verbatim].
+     *   3. Summarize the older region. If a prior compaction summary is present,
+     *      merge into it (incremental update) instead of re-summarizing a summary.
+     *   4. Rebuild: [system, summary, ...recent].
+     */
+    async handleCompact(turn, instruction, trigger) {
+        this.emit({
+            type: "timeline",
+            provider: this.provider,
+            turnId: turn.turnId,
+            item: { type: "compaction", status: "loading", trigger },
+        });
+        // Pre-compaction context size: prefer the server-measured figure from the
+        // last round (what the context ring currently shows); fall back to a local
+        // estimate of the full request payload.
+        const preTokens = this.lastContextTokens ?? this.estimateFullContextTokens();
+        // 1. Zero-LLM pruning first, so both the summary input and the retained
+        //    tail are already free of noise and oversized old tool dumps.
+        this.pruneToolOutputs();
+        // 2. Split at the keep-recent boundary. keepFromIndex is the first message
+        //    (after the system prompt at index 0) that stays verbatim.
+        const keepFromIndex = this.computeCompactionKeepFromIndex();
+        const summarizeRegion = this.messages.slice(1, keepFromIndex);
+        const keptRegion = this.messages.slice(keepFromIndex);
+        if (summarizeRegion.length === 0) {
+            // Nothing old enough to summarize (conversation already within the
+            // keep-recent budget). Report a no-op rather than summarizing nothing.
+            const postTokens = this.estimateFullContextTokens();
+            this.lastContextTokens = postTokens;
+            this.emit({
+                type: "timeline",
+                provider: this.provider,
+                turnId: turn.turnId,
+                item: { type: "compaction", status: "completed", trigger, preTokens, postTokens },
+            });
+            const maxTokens = await this.resolveContextWindowMaxTokens();
+            const usage = {
+                contextWindowUsedTokens: postTokens,
+                ...(maxTokens !== null ? { contextWindowMaxTokens: maxTokens } : {}),
+            };
+            this.emit({ type: "usage_updated", provider: this.provider, usage, turnId: turn.turnId });
+            return usage;
+        }
+        // 3. Incremental update when a prior summary sits in the region: feed it as
+        //    <previous-summary> and merge the newer messages into it, rather than
+        //    summarizing a summary (which degrades badly across repeated compacts).
+        const priorSummaryIndex = summarizeRegion.findIndex((message) => message.role === "user" && message.isCompactionSummary === true);
+        const priorSummary = priorSummaryIndex >= 0 ? summarizeRegion[priorSummaryIndex].content : null;
+        const messagesToSummarize = priorSummaryIndex >= 0
+            ? summarizeRegion.filter((_, index) => index !== priorSummaryIndex)
+            : summarizeRegion;
+        const conversationText = this.serializeConversationForCompaction(messagesToSummarize);
+        const endpoint = resolveEndpoint(this.env, this.label);
+        const model = await this.resolveModel(endpoint);
+        const systemPrompt = priorSummary !== null
+            ? this.buildCompactionUpdateSystemPrompt(instruction)
+            : this.buildCompactionSystemPrompt(instruction);
+        const userContent = priorSummary !== null
+            ? `<previous-summary>\n${priorSummary}\n</previous-summary>\n\n<new-messages>\n${conversationText}\n</new-messages>`
+            : conversationText;
+        const summaryResult = await this.runCompactionCompletion({
+            endpoint,
+            model,
+            systemPrompt,
+            userContent,
+            signal: turn.abort.signal,
+        });
+        const summary = summaryResult.content;
+        // 4. Rebuild: system + summary (marked for future incremental updates) +
+        //    the retained recent tail, untouched.
+        this.messages.length = 0;
+        this.messages.push({ role: "system", content: this.buildSystemPrompt(this.config) });
+        this.messages.push({
+            role: "user",
+            content: summary,
+            messageId: randomUUID(),
+            isCompactionSummary: true,
+        });
+        // Assistant ack keeps the roles alternating so the next user turn doesn't
+        // sit directly after the synthetic summary user message.
+        this.messages.push({ role: "assistant", content: "Conversation history has been compacted." });
+        this.messages.push(...keptRegion);
+        // Post-compaction context size. Must count the rebuilt system prompt and
+        // the tool schemas — both are re-sent with every request — or the ring
+        // reads near-zero here and jumps back up on the next real turn.
+        const postTokens = this.estimateFullContextTokens();
+        this.lastContextTokens = postTokens;
+        this.emit({
+            type: "timeline",
+            provider: this.provider,
+            turnId: turn.turnId,
+            item: {
+                type: "compaction",
+                status: "completed",
+                trigger,
+                preTokens,
+                postTokens,
+            },
+        });
+        // usage_updated replaces agent.lastUsage wholesale and the client hides
+        // the context ring unless both bounds are present, so the compaction
+        // usage must carry the post-compaction context size alongside the
+        // request's own token cost.
+        const maxTokens = await this.resolveContextWindowMaxTokens();
+        const usageData = summaryResult.usage;
+        const usage = {
+            ...(typeof usageData?.prompt_tokens === "number"
+                ? { inputTokens: usageData.prompt_tokens }
+                : {}),
+            ...(typeof usageData?.completion_tokens === "number"
+                ? { outputTokens: usageData.completion_tokens }
+                : {}),
+            contextWindowUsedTokens: postTokens,
+            ...(maxTokens !== null ? { contextWindowMaxTokens: maxTokens } : {}),
+        };
+        this.emit({
+            type: "usage_updated",
+            provider: this.provider,
+            usage,
+            turnId: turn.turnId,
+        });
+        return usage;
+    }
+    /**
+     * Auto-compaction check, run at turn start (before the new user message
+     * joins the conversation, so it always survives verbatim) and before every
+     * subsequent model round. Uses the freshest server-measured context size —
+     * the active turn's last round, falling back to the previous turn's final
+     * figure. Endpoints that report no context length never auto-compact:
+     * without a denominator there is no percentage (manual /compact still
+     * works).
+     *
+     * Loop protection: a compaction that fails or can't bring usage back under
+     * the threshold disarms the trigger. Without that, a conversation whose
+     * retained tail alone exceeds the threshold would re-summarize on every
+     * round, burning a model call each time for no reclaimed space. The trigger
+     * re-arms once measured usage drops below the threshold by other means
+     * (rewind, manual /compact, a model switch to a larger window) or when the
+     * user changes the auto-compact setting.
+     *
+     * Auto-compaction failures never fail the user's turn — the turn proceeds
+     * with the uncompacted conversation (interrupts still propagate).
+     */
+    async maybeAutoCompact(turn) {
+        if (this.autoCompact === "off") {
+            return;
+        }
+        const maxTokens = await this.resolveContextWindowMaxTokens();
+        if (maxTokens === null) {
+            return;
+        }
+        const threshold = Math.floor((Number(this.autoCompact) / 100) * maxTokens);
+        const used = turn.usage && typeof turn.usage.inputTokens === "number"
+            ? turn.usage.inputTokens + (turn.usage.outputTokens ?? 0)
+            : this.lastContextTokens;
+        if (used === null || used < threshold) {
+            if (used !== null) {
+                this.autoCompactDisarmed = false;
+            }
+            return;
+        }
+        if (this.autoCompactDisarmed) {
+            return;
+        }
+        let usage;
+        try {
+            usage = await this.handleCompact(turn, null, "auto");
+        }
+        catch (error) {
+            // Settle the "loading" compaction row before deciding how to proceed.
+            this.emit({
+                type: "timeline",
+                provider: this.provider,
+                turnId: turn.turnId,
+                item: { type: "compaction", status: "failed", trigger: "auto" },
+            });
+            if (turn.abort.signal.aborted) {
+                throw error;
+            }
+            this.autoCompactDisarmed = true;
+            const message = error instanceof Error ? error.message : String(error);
+            this.emit({
+                type: "timeline",
+                provider: this.provider,
+                turnId: turn.turnId,
+                item: {
+                    type: "error",
+                    message: `Auto-compaction failed: ${message}. Auto-compaction is paused until context usage drops below the threshold — run /compact to retry manually.`,
+                },
+            });
+            return;
+        }
+        // The pre-compaction round figures no longer describe the conversation;
+        // the next round's stream re-measures it.
+        turn.usage = null;
+        const postTokens = usage.contextWindowUsedTokens ?? this.lastContextTokens;
+        if (typeof postTokens === "number" && postTokens >= threshold) {
+            this.autoCompactDisarmed = true;
+            this.emit({
+                type: "timeline",
+                provider: this.provider,
+                turnId: turn.turnId,
+                item: {
+                    type: "error",
+                    message: `Auto-compaction reclaimed too little space (still ~${postTokens} of ` +
+                        `${maxTokens} tokens). Auto-compaction is paused until usage ` +
+                        `drops below the ${this.autoCompact}% threshold — run /compact with an ` +
+                        `instruction, rewind, or start a fresh agent.`,
+                },
+            });
+        }
+    }
+    /**
+     * Pre-summarization pruning (zero-LLM). Mutates the message array in place:
+     * elides uneventful tool results everywhere, then truncates oversized tool
+     * results older than the protected-recent window to head + tail. Structure is
+     * never changed (only tool `content`), so tool_call ordering stays valid.
+     */
+    pruneToolOutputs() {
+        for (const message of this.messages) {
+            if (message.role === "tool" && isUneventfulToolResult(message.content)) {
+                message.content = UNEVENTFUL_RESULT_PLACEHOLDER;
+            }
+        }
+        // Walk tool results newest → oldest; protect the freshest by token budget,
+        // truncate the rest.
+        let protectedTokens = 0;
+        for (let index = this.messages.length - 1; index >= 0; index -= 1) {
+            const message = this.messages[index];
+            if (message.role !== "tool") {
+                continue;
+            }
+            const tokens = estimateTokens(message.content);
+            if (protectedTokens < PRUNE_PROTECT_RECENT_TOOL_TOKENS) {
+                protectedTokens += tokens;
+                continue;
+            }
+            if (message.content.length > PRUNE_TOOL_RESULT_MIN_CHARS) {
+                const { content } = message;
+                message.content = `${content.slice(0, PRUNE_TOOL_RESULT_HEAD_CHARS)}\n[... ${content.length - PRUNE_TOOL_RESULT_HEAD_CHARS - PRUNE_TOOL_RESULT_TAIL_CHARS} chars pruned ...]\n${content.slice(-PRUNE_TOOL_RESULT_TAIL_CHARS)}`;
+            }
+        }
+    }
+    /**
+     * Index of the first message (after the system prompt at 0) to keep verbatim
+     * through compaction: walk newest → oldest accumulating token estimates until
+     * the keep-recent budget is exceeded, then advance past any leading tool
+     * results so the retained tail never starts with a tool message orphaned from
+     * its assistant tool_calls. Returns messages.length when the whole
+     * conversation is older than the budget (summarize everything, keep none).
+     */
+    computeCompactionKeepFromIndex() {
+        let keepFrom = this.messages.length;
+        let recentTokens = 0;
+        for (let index = this.messages.length - 1; index >= 1; index -= 1) {
+            recentTokens += estimateTokens(JSON.stringify(this.messages[index]));
+            if (recentTokens > this.keepRecentTokens) {
+                break;
+            }
+            keepFrom = index;
+        }
+        // Never keep the entire conversation: a manual /compact should always
+        // compress something, so a conversation within the budget summarizes fully.
+        if (keepFrom <= 1) {
+            return this.messages.length;
+        }
+        // Don't strand tool results at the head of the retained tail.
+        while (keepFrom < this.messages.length && this.messages[keepFrom].role === "tool") {
+            keepFrom += 1;
+        }
+        return keepFrom;
+    }
+    /**
+     * POST a non-streaming chat completion for compaction and return the assistant
+     * text plus raw usage. Throws on transport failure or an empty response.
+     */
+    async runCompactionCompletion(options) {
+        const response = await fetch(`${options.endpoint.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: buildHeaders(options.endpoint),
+            signal: options.signal,
+            body: JSON.stringify({
+                model: options.model,
+                messages: [
+                    { role: "system", content: options.systemPrompt },
+                    { role: "user", content: options.userContent },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            const bodyText = await response.text().catch(() => "");
+            throw new Error(`${this.label} responded ${response.status} to /chat/completions${bodyText ? `: ${bodyText.slice(0, 400)}` : ""}`);
+        }
+        const data = (await response.json());
+        const choices = Array.isArray(data.choices) ? data.choices : [];
+        const firstChoice = choices[0];
+        if (!firstChoice || typeof firstChoice !== "object") {
+            throw new Error(`${this.label} returned an empty compaction response`);
+        }
+        const responseMessage = firstChoice.message;
+        if (!responseMessage || typeof responseMessage !== "object") {
+            throw new Error(`${this.label} returned an empty compaction response`);
+        }
+        const rawContent = responseMessage.content;
+        const content = typeof rawContent === "string" ? rawContent : "";
+        if (!content) {
+            throw new Error(`${this.label} returned an empty compaction summary`);
+        }
+        const usage = data.usage && typeof data.usage === "object"
+            ? data.usage
+            : undefined;
+        return { content, ...(usage ? { usage } : {}) };
+    }
+    /**
+     * Local estimate of the full next-request context: conversation messages
+     * (including the system prompt) plus the tool schemas that are re-sent with
+     * every request. Char-based, so it's approximate — the next real turn's
+     * server-measured usage replaces it.
+     */
+    estimateFullContextTokens() {
+        const toolsPayload = [
+            ...buildOpenAIToolsPayload(this.availableToolSpecs()),
+            ...this.buildOttoToolPayload(),
+            ...this.buildMcpToolPayload(),
+        ];
+        return (estimateTokens(JSON.stringify(toolsPayload)) +
+            this.messages.reduce((sum, message) => sum + estimateTokens(JSON.stringify(message)), 0));
+    }
+    /**
+     * Serialize the given conversation messages into a text blob suitable for a
+     * compaction prompt. Tool calls are summarized rather than included verbatim
+     * to keep the payload manageable.
+     */
+    serializeConversationForCompaction(messages) {
+        const lines = [];
+        const conversationMessages = messages.filter((message) => message.role !== "system");
+        for (const message of conversationMessages) {
+            if (message.role === "user") {
+                lines.push(`[user]: ${message.content}`);
+            }
+            else if (message.role === "assistant") {
+                if (message.tool_calls && message.tool_calls.length > 0) {
+                    const toolSummaries = message.tool_calls
+                        .map((call) => {
+                        let argsPreview = "";
+                        try {
+                            const parsed = JSON.parse(call.function.arguments);
+                            argsPreview = ` (${JSON.stringify(parsed).slice(0, 500)})`;
+                        }
+                        catch {
+                            argsPreview = ` (${call.function.arguments.slice(0, 500)})`;
+                        }
+                        return `  - called ${call.function.name}${argsPreview}`;
+                    })
+                        .join("\n");
+                    lines.push(`[assistant]: (tool calls)`);
+                    lines.push(toolSummaries);
+                    if (message.content) {
+                        lines.push(`  text: ${message.content}`);
+                    }
+                }
+                else {
+                    lines.push(`[assistant]: ${message.content}`);
+                }
+            }
+            else if (message.role === "tool") {
+                // Keep head + tail of large results: file reads and command output
+                // carry their signal at both ends, and the summarizer can't preserve
+                // what it never sees.
+                const content = message.content;
+                const contentPreview = content.length > TOOL_RESULT_HEAD_CHARS + TOOL_RESULT_TAIL_CHARS
+                    ? `${content.slice(0, TOOL_RESULT_HEAD_CHARS)}\n[... ${content.length - TOOL_RESULT_HEAD_CHARS - TOOL_RESULT_TAIL_CHARS} chars truncated ...]\n${content.slice(-TOOL_RESULT_TAIL_CHARS)}`
+                    : content;
+                lines.push(`[tool result ${message.tool_call_id}]: ${contentPreview}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    /**
+     * System prompt for a fresh compaction summary. The older conversation is
+     * summarized while recent messages are kept verbatim, so this summary becomes
+     * the model's memory of the distant past — it must preserve exact references,
+     * not paraphrase them away. Modeled on oh-my-pi's structured handoff format.
+     */
+    buildCompactionSystemPrompt(instruction) {
+        const base = `You summarize a coding-agent conversation into a structured handoff summary so another LLM can resume the task. Only the older part of the conversation is being summarized; recent messages are retained verbatim after your summary. Preserve detail — a thorough summary is expected. Do NOT aim for brevity.
+
+NEVER continue the conversation. NEVER answer questions found in it. Output ONLY the structured summary below.
+
+If the conversation ends with an unanswered question or a request awaiting a response (e.g. "run this and paste the output"), you MUST preserve that exact question/request under Critical Context.
+
+Use this format (omit a section only if it truly does not apply):
+
+## Goal
+[The user's goals; list multiple if the session covers different tasks.]
+
+## Constraints & Preferences
+- [Requirements, constraints, and preferences the user stated]
+
+## Progress
+### Done
+- [x] [Completed changes/tasks]
+### In Progress
+- [ ] [Work underway when compaction ran]
+### Blocked
+- [Anything preventing progress]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Files & Changes
+- [Exact path — what was read/created/modified and why it matters; include the important code snippets verbatim]
+
+## Next Steps
+1. [Ordered next actions, aligned with the user's most recent request]
+
+## Critical Context
+- [Important data, exact error messages, repository state (branch, uncommitted changes), and any pending question awaiting a user response]
+
+## Additional Notes
+[Anything important not captured above]
+
+You MUST preserve exact file paths, function names, error messages, and relevant tool outputs or command results.`;
+        const instructionPart = instruction
+            ? `\n\nAdditional user instruction — follow it for emphasis and focus, on top of the format above:\n<user-instruction>${instruction}</user-instruction>`
+            : "";
+        return base + instructionPart;
+    }
+    /**
+     * System prompt for an incremental compaction: merge newer messages into an
+     * existing summary rather than re-summarizing a summary (which degrades fast
+     * across repeated compacts). The prior summary arrives in <previous-summary>
+     * tags and the newer messages in <new-messages> tags.
+     */
+    buildCompactionUpdateSystemPrompt(instruction) {
+        const base = `You update an existing structured handoff summary by incorporating newer conversation messages, so another LLM can resume the task. The prior summary is in <previous-summary> tags; the newer messages are in <new-messages> tags.
+
+NEVER continue the conversation. NEVER answer questions found in it. Output ONLY the updated structured summary.
+
+Rules:
+- Preserve ALL information from the previous summary that is still relevant.
+- Fold in new progress, decisions, files, and context from the newer messages.
+- Move items from "In Progress" to "Done" when completed; update "Next Steps".
+- You MAY drop anything the newer messages made irrelevant.
+- If the newer messages end with an unanswered question or a request awaiting a response, record it under Critical Context (replacing a prior pending question once answered).
+- You MUST preserve exact file paths, function names, error messages, and relevant tool outputs or command results.
+
+Keep the same section format as the previous summary (## Goal, ## Constraints & Preferences, ## Progress with Done/In Progress/Blocked, ## Key Decisions, ## Files & Changes, ## Next Steps, ## Critical Context, ## Additional Notes).`;
+        const instructionPart = instruction
+            ? `\n\nAdditional user instruction — follow it for emphasis and focus:\n<user-instruction>${instruction}</user-instruction>`
+            : "";
+        return base + instructionPart;
+    }
+    /**
+     * When the typed prompt is `/mcp_{server}_{prompt} args`, resolve it via
+     * prompts/get and feed the resolved text to the model. The remainder of the
+     * line maps to the prompt's first declared argument (multi-argument prompts
+     * receive only that one). Any resolution failure falls back to sending the
+     * raw text as a plain prompt, matching the opencode provider.
+     */
+    async resolveMcpPromptText(promptText) {
+        const manager = this.mcpManager;
+        if (!manager) {
+            return promptText;
+        }
+        const parsed = parseSlashCommandInput(promptText);
+        if (!parsed || !parsed.commandName.startsWith("mcp_")) {
+            return promptText;
+        }
+        try {
+            const prompts = await manager.listPrompts();
+            const binding = prompts.find((prompt) => prompt.commandName === parsed.commandName);
+            if (!binding) {
+                return promptText;
+            }
+            return await manager.getPrompt(binding, parsed.args);
+        }
+        catch (error) {
+            this.logger?.warn({ err: error, commandName: parsed.commandName }, "Failed to resolve MCP prompt command; falling back to plain prompt input");
+            return promptText;
+        }
+    }
+    /**
+     * MCP tools rendered as OpenAI function specs under namespaced
+     * mcp_{server}_{tool} names. Hard-excluded in read-only "plan" mode — MCP
+     * tools are opaque and may take actions regardless of what they claim.
+     */
+    buildMcpToolPayload() {
+        if (!this.mcpManager || this.modeId === "plan") {
+            return [];
+        }
+        return this.mcpManager.getToolBindings().map((binding) => ({
+            type: "function",
+            function: {
+                name: binding.modelName,
+                description: binding.description,
+                parameters: binding.parameters,
+            },
+        }));
+    }
+    buildOttoToolPayload() {
+        if (!this.ottoTools || this.modeId === "plan") {
+            return [];
+        }
+        const payload = [];
+        for (const tool of this.ottoTools.tools.values()) {
+            if (findCompatToolSpec(tool.name) || !this.isOttoToolGroupEnabled(tool.name)) {
+                continue;
+            }
+            payload.push({
+                type: "function",
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: ottoToolParameters(tool),
+                },
+            });
+        }
+        return payload;
+    }
+    async run(prompt, options) {
+        const { turnId } = await this.startTurn(prompt, options);
+        const turn = this.activeTurn;
+        if (!turn || turn.turnId !== turnId) {
+            throw new Error(`${this.label} turn did not start`);
+        }
+        return turn.completed;
+    }
+    async startTurn(prompt, options) {
+        if (this.activeTurn) {
+            throw new Error(`${this.label} already has an active turn`);
+        }
+        const turnId = randomUUID();
+        let resolve;
+        let reject;
+        const completed = new Promise((promiseResolve, promiseReject) => {
+            resolve = promiseResolve;
+            reject = promiseReject;
+        });
+        // startTurn callers observe failure via turn_failed events, not this
+        // promise — swallow to avoid unhandled rejections. run() awaits the same
+        // promise and still sees the rejection.
+        completed.catch(() => { });
+        const turn = {
+            turnId,
+            assistantMessageId: randomUUID(),
+            abort: new AbortController(),
+            roundText: "",
+            roundReasoning: "",
+            finalTextParts: [],
+            pendingToolCalls: new Map(),
+            finishReason: null,
+            usage: null,
+            resolve,
+            reject,
+            completed,
+        };
+        this.activeTurn = turn;
+        const promptText = promptToText(prompt);
+        // One id shared by the timeline item and the conversation entry so
+        // revertConversation can map a timeline user_message back to its message.
+        const userMessageId = options?.messageId ?? randomUUID();
+        this.emit({
+            type: "timeline",
+            provider: this.provider,
+            turnId,
+            item: {
+                type: "user_message",
+                text: promptText,
+                messageId: userMessageId,
+            },
+        });
+        void this.executeTurn(turn, promptText, userMessageId);
+        return { turnId };
+    }
+    async executeTurn(turn, promptText, userMessageId) {
+        this.emit({ type: "turn_started", provider: this.provider, turnId: turn.turnId });
+        // Intercept built-in slash commands before delegating to the model.
+        const slashCommand = parseSlashCommandInput(promptText);
+        if (slashCommand && slashCommand.commandName === "compact") {
+            let usage;
+            try {
+                usage = await this.handleCompact(turn, slashCommand.args, "manual");
+            }
+            catch (error) {
+                // Settle the "loading" compaction row — without this it spins
+                // forever. Clients that predate the "failed" status drop this event
+                // and keep the spinning row, which matches their pre-fix behavior.
+                this.emit({
+                    type: "timeline",
+                    provider: this.provider,
+                    turnId: turn.turnId,
+                    item: { type: "compaction", status: "failed", trigger: "manual" },
+                });
+                this.settleTurnFailure(turn, error);
+                return;
+            }
+            if (this.activeTurn !== turn) {
+                return;
+            }
+            this.activeTurn = null;
+            // turn_completed is the manager's terminal signal — without it the
+            // foreground turn stream never ends and the agent stays "running".
+            this.emit({
+                type: "turn_completed",
+                provider: this.provider,
+                turnId: turn.turnId,
+                usage,
+            });
+            turn.resolve({
+                sessionId: this.id,
+                finalText: "",
+                usage,
+                timeline: [],
+                canceled: false,
+            });
+            return;
+        }
+        try {
+            await this.ensureMcpReady(turn);
+            // The timeline keeps the typed `/command args` text; the model receives
+            // the resolved MCP prompt (or the raw text when nothing matches).
+            const modelText = await this.resolveMcpPromptText(promptText);
+            // Turn-start auto-compaction runs before the new user message joins the
+            // conversation: when the whole history is summarized ("never keep the
+            // entire conversation"), the instruction the model is about to act on
+            // must not be folded into the summary with it.
+            await this.maybeAutoCompact(turn);
+            this.messages.push({ role: "user", content: modelText, messageId: userMessageId });
+            await this.runToolLoop(turn);
+        }
+        catch (error) {
+            this.settleTurnFailure(turn, error);
+            return;
+        }
+        if (this.activeTurn !== turn) {
+            return;
+        }
+        this.activeTurn = null;
+        const finalText = turn.finalTextParts.join("\n\n");
+        const usage = await this.buildTurnUsage(turn);
+        this.emit({
+            type: "turn_completed",
+            provider: this.provider,
+            turnId: turn.turnId,
+            ...(usage ? { usage } : {}),
+        });
+        turn.resolve({
+            sessionId: this.id,
+            finalText,
+            ...(usage ? { usage } : {}),
+            timeline: [],
+            canceled: false,
+        });
+    }
+    async runToolLoop(turn) {
+        // Warm the context-window cache before streaming: emitStreamUsageUpdated
+        // runs on the hot chunk path and can only read the cached value, and a
+        // usage_updated without contextWindowMaxTokens blanks the client's
+        // context ring (agent.lastUsage is replaced wholesale, and the ring
+        // needs both bounds). Cached per model, so this is one probe per session.
+        await this.resolveContextWindowMaxTokens();
+        for (let round = 0; round < MAX_TOOL_ROUNDS; round += 1) {
+            // Round 0 was already checked at turn start; re-check between tool
+            // rounds so a long tool loop compacts mid-turn instead of overflowing.
+            if (round > 0) {
+                await this.maybeAutoCompact(turn);
+            }
+            await this.streamCompletion(turn);
+            const toolCalls = [...turn.pendingToolCalls.entries()]
+                .sort(([a], [b]) => a - b)
+                .map(([, call]) => call);
+            if (turn.roundText || turn.roundReasoning || toolCalls.length > 0) {
+                this.messages.push({
+                    role: "assistant",
+                    content: turn.roundText,
+                    ...(turn.roundReasoning ? { reasoning: turn.roundReasoning } : {}),
+                    ...(toolCalls.length > 0
+                        ? {
+                            tool_calls: toolCalls.map((call) => ({
+                                id: call.id,
+                                type: "function",
+                                function: { name: call.name, arguments: call.argumentsJson },
+                            })),
+                        }
+                        : {}),
+                });
+            }
+            if (turn.roundText) {
+                turn.finalTextParts.push(turn.roundText);
+            }
+            // Consumed — settleTurnFailure must not re-append these if a later
+            // tool round gets interrupted.
+            turn.roundText = "";
+            turn.roundReasoning = "";
+            if (toolCalls.length === 0) {
+                return;
+            }
+            for (const call of toolCalls) {
+                if (turn.abort.signal.aborted) {
+                    throw new Error("Interrupted");
+                }
+                const resultContent = await this.executeToolCall(turn, call);
+                this.messages.push({ role: "tool", content: resultContent, tool_call_id: call.id });
+            }
+            if (turn.abort.signal.aborted) {
+                throw new Error("Interrupted");
+            }
+        }
+        this.emit({
+            type: "timeline",
+            provider: this.provider,
+            turnId: turn.turnId,
+            item: {
+                type: "error",
+                message: `Stopped after ${MAX_TOOL_ROUNDS} tool rounds without a final answer.`,
+            },
+        });
+    }
+    parseToolCallArgs(turn, call) {
+        try {
+            const parsed = call.argumentsJson ? JSON.parse(call.argumentsJson) : {};
+            return {
+                args: parsed && typeof parsed === "object" ? parsed : {},
+            };
+        }
+        catch {
+            this.emitToolItem(turn, call, "failed", buildCompatToolPreviewDetail(call.name, {}, this.cwd), "Invalid tool arguments (malformed JSON)");
+            return { error: `Error: arguments for ${call.name} were not valid JSON` };
+        }
+    }
+    async executeToolCall(turn, call) {
+        const spec = findCompatToolSpec(call.name);
+        const parsed = this.parseToolCallArgs(turn, call);
+        if ("error" in parsed) {
+            return parsed.error;
+        }
+        const args = parsed.args;
+        // Otto catalog tools are dispatched to the catalog, not the builtin coding
+        // tools. Builtins take precedence on name; plan mode offers neither actions
+        // nor Otto tools, so a plan-mode call for one falls through to "not available".
+        if (!spec && this.modeId !== "plan") {
+            const ottoTool = this.isOttoToolGroupEnabled(call.name)
+                ? this.ottoTools?.getTool(call.name)
+                : undefined;
+            if (ottoTool) {
+                return this.executeOttoToolCall(turn, call, args, ottoTool);
+            }
+            // MCP tools live under namespaced mcp_{server}_{tool} names, so they can
+            // never collide with (or shadow) builtins or Otto tools.
+            const mcpBinding = this.mcpManager?.resolveTool(call.name);
+            if (mcpBinding) {
+                return this.executeMcpToolCall(turn, call, args, mcpBinding);
+            }
+        }
+        const previewDetail = buildCompatToolPreviewDetail(call.name, args, this.cwd);
+        if (!spec || !this.availableToolSpecs().some((candidate) => candidate.name === spec.name)) {
+            this.emitToolItem(turn, call, "failed", previewDetail, `Tool ${call.name} is not available`);
+            return `Error: tool ${call.name} is not available in the current mode`;
+        }
+        if (this.toolNeedsApproval(spec, args)) {
+            const response = await this.requestPermission(turn, {
+                name: spec.name,
+                title: spec.name,
+                description: COMPAT_TOOL_PROMPT_DESCRIPTIONS[spec.kind],
+                args,
+                detail: previewDetail,
+            });
+            if (response.behavior === "deny") {
+                this.emitToolItem(turn, call, "failed", previewDetail, "Denied by user");
+                if (response.interrupt) {
+                    turn.abort.abort();
+                }
+                const message = response.message?.trim();
+                return message
+                    ? `The user declined this tool call: ${message}`
+                    : "The user declined this tool call.";
+            }
+        }
+        this.emitToolItem(turn, call, "running", previewDetail, null);
+        const outcome = await executeCompatTool({
+            name: call.name,
+            arguments: args,
+            cwd: this.cwd,
+            signal: turn.abort.signal,
+        });
+        if (turn.abort.signal.aborted) {
+            this.emitToolItem(turn, call, "canceled", outcome.detail, null);
+            return outcome.output;
+        }
+        this.emitToolItem(turn, call, outcome.isError ? "failed" : "completed", outcome.detail, outcome.isError ? outcome.output : null);
+        return outcome.output;
+    }
+    /**
+     * MCP tools are opaque — the daemon cannot know whether one is destructive.
+     * default mode always asks; acceptEdits asks unless the provider opted into
+     * "trust-read-only" AND the server self-declares readOnlyHint (that
+     * annotation is untrusted, so it never skips prompts in default mode);
+     * bypassPermissions auto-approves like everything else. Plan mode never
+     * reaches here — MCP tools are excluded from the payload entirely.
+     */
+    mcpToolNeedsApproval(binding) {
+        if (this.modeId === "bypassPermissions")
+            return false;
+        if (this.modeId === "acceptEdits") {
+            return !(this.mcpToolPermissions === "trust-read-only" && binding.readOnlyHint);
+        }
+        return true;
+    }
+    async executeMcpToolCall(turn, call, args, binding) {
+        const manager = this.mcpManager;
+        if (!manager) {
+            return `Error: tool ${call.name} is not available`;
+        }
+        const detail = { type: "unknown", input: args, output: null };
+        if (this.mcpToolNeedsApproval(binding)) {
+            const response = await this.requestPermission(turn, {
+                name: binding.modelName,
+                title: `${binding.serverName}: ${binding.toolName}`,
+                description: `Wants to run an MCP tool from server '${binding.serverName}'`,
+                args,
+                detail,
+            });
+            if (response.behavior === "deny") {
+                this.emitToolItem(turn, call, "failed", detail, "Denied by user");
+                if (response.interrupt) {
+                    turn.abort.abort();
+                }
+                const message = response.message?.trim();
+                return message
+                    ? `The user declined this tool call: ${message}`
+                    : "The user declined this tool call.";
+            }
+        }
+        this.emitToolItem(turn, call, "running", detail, null);
+        const outcome = await manager.callTool(binding, args, { signal: turn.abort.signal });
+        if (turn.abort.signal.aborted) {
+            this.emitToolItem(turn, call, "canceled", { ...detail, output: outcome.output }, null);
+            return outcome.output;
+        }
+        this.emitToolItem(turn, call, outcome.isError ? "failed" : "completed", { ...detail, output: outcome.output }, outcome.isError ? outcome.output : null);
+        return outcome.output;
+    }
+    /**
+     * Otto tools skip prompts only when classified read-only; "interact" tools
+     * are auto-approved in acceptEdits like file edits, and "execute" tools
+     * always prompt outside bypassPermissions. CLI providers get this gating
+     * from their own permission system in front of the MCP client — here the
+     * daemon is the runtime, so it prompts itself.
+     * See openai-compat-otto-tool-permissions.ts.
+     */
+    ottoToolNeedsApproval(name) {
+        const kind = ottoToolPermissionKind(name);
+        if (kind === "read")
+            return false;
+        if (this.modeId === "bypassPermissions")
+            return false;
+        if (this.modeId === "acceptEdits")
+            return kind === "execute";
+        return true;
+    }
+    async executeOttoToolCall(turn, call, args, tool) {
+        const catalog = this.ottoTools;
+        if (!catalog) {
+            return `Error: tool ${call.name} is not available`;
+        }
+        const detail = { type: "unknown", input: args, output: null };
+        if (this.ottoToolNeedsApproval(tool.name)) {
+            const response = await this.requestPermission(turn, {
+                name: tool.name,
+                title: tool.name,
+                description: ottoToolPermissionKind(tool.name) === "execute"
+                    ? "Wants to run an Otto tool that can execute code or manage agents"
+                    : "Wants to interact with the Otto browser or preview servers",
+                args,
+                detail,
+            });
+            if (response.behavior === "deny") {
+                this.emitToolItem(turn, call, "failed", detail, "Denied by user");
+                if (response.interrupt) {
+                    turn.abort.abort();
+                }
+                const message = response.message?.trim();
+                return message
+                    ? `The user declined this tool call: ${message}`
+                    : "The user declined this tool call.";
+            }
+        }
+        this.emitToolItem(turn, call, "running", { type: "unknown", input: args, output: null }, null);
+        try {
+            const result = await catalog.executeTool(tool.name, args, { signal: turn.abort.signal });
+            const output = ottoResultToText(result);
+            if (turn.abort.signal.aborted) {
+                this.emitToolItem(turn, call, "canceled", { type: "unknown", input: args, output }, null);
+                return output;
+            }
+            this.emitToolItem(turn, call, result.isError ? "failed" : "completed", { type: "unknown", input: args, output }, result.isError ? output : null);
+            return output;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.emitToolItem(turn, call, "failed", { type: "unknown", input: args, output: null }, message);
+            return `Error: ${message}`;
+        }
+    }
+    emitToolItem(turn, call, status, detail, error) {
+        this.emit({
+            type: "timeline",
+            provider: this.provider,
+            turnId: turn.turnId,
+            item: status === "failed"
+                ? {
+                    type: "tool_call",
+                    callId: call.id,
+                    name: call.name,
+                    detail,
+                    status,
+                    error: error ?? "Tool failed",
+                }
+                : { type: "tool_call", callId: call.id, name: call.name, detail, status, error: null },
+        });
+    }
+    async requestPermission(turn, input) {
+        const request = {
+            id: randomUUID(),
+            provider: this.provider,
+            name: input.name,
+            kind: "tool",
+            title: input.title,
+            description: input.description,
+            input: input.args,
+            detail: input.detail,
+        };
+        const response = await new Promise((resolve) => {
+            this.pendingPermissions.set(request.id, { request, resolve });
+            this.emit({
+                type: "permission_requested",
+                provider: this.provider,
+                request,
+                turnId: turn.turnId,
+            });
+        });
+        return response;
+    }
+    async streamCompletion(turn) {
+        const endpoint = resolveEndpoint(this.env, this.label);
+        const model = await this.resolveModel(endpoint);
+        turn.assistantMessageId = randomUUID();
+        turn.roundText = "";
+        turn.roundReasoning = "";
+        turn.pendingToolCalls = new Map();
+        turn.finishReason = null;
+        const toolSpecs = this.availableToolSpecs();
+        const toolsPayload = [
+            ...buildOpenAIToolsPayload(toolSpecs),
+            ...this.buildOttoToolPayload(),
+            ...this.buildMcpToolPayload(),
+        ];
+        const response = await fetch(`${endpoint.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: buildHeaders(endpoint),
+            signal: turn.abort.signal,
+            body: JSON.stringify({
+                model,
+                messages: this.messages.map(toWireMessage),
+                stream: true,
+                stream_options: { include_usage: true },
+                ...(this.reasoningEffort !== "off" ? { reasoning_effort: this.reasoningEffort } : {}),
+                ...(toolsPayload.length > 0 ? { tools: toolsPayload, tool_choice: "auto" } : {}),
+            }),
+        });
+        if (!response.ok) {
+            const bodyText = await response.text().catch(() => "");
+            throw new Error(`${this.label} responded ${response.status} to /chat/completions${bodyText ? `: ${bodyText.slice(0, 400)}` : ""}`);
+        }
+        if (!response.body) {
+            throw new Error(`${this.label} returned an empty response body`);
+        }
+        for await (const line of readLines(response.body)) {
+            if (!line.startsWith("data:"))
+                continue;
+            const payload = line.slice(5).trim();
+            if (!payload || payload === "[DONE]")
+                continue;
+            this.applyStreamPayload(turn, payload);
+        }
+    }
+    applyStreamPayload(turn, payload) {
+        let parsed;
+        try {
+            parsed = JSON.parse(payload);
+        }
+        catch {
+            return;
+        }
+        const delta = parseStreamChunk(parsed);
+        if (delta.reasoning) {
+            turn.roundReasoning += delta.reasoning;
+            this.emit({
+                type: "timeline",
+                provider: this.provider,
+                turnId: turn.turnId,
+                item: { type: "reasoning", text: delta.reasoning },
+            });
+        }
+        if (delta.content) {
+            turn.roundText += delta.content;
+            this.emit({
+                type: "timeline",
+                provider: this.provider,
+                turnId: turn.turnId,
+                item: {
+                    type: "assistant_message",
+                    text: delta.content,
+                    messageId: turn.assistantMessageId,
+                },
+            });
+        }
+        for (const toolCallDelta of delta.toolCalls) {
+            const existing = turn.pendingToolCalls.get(toolCallDelta.index) ?? {
+                id: "",
+                name: "",
+                argumentsJson: "",
+            };
+            turn.pendingToolCalls.set(toolCallDelta.index, {
+                id: toolCallDelta.id ?? (existing.id || `call_${toolCallDelta.index}`),
+                name: existing.name || (toolCallDelta.name ?? ""),
+                argumentsJson: existing.argumentsJson + (toolCallDelta.argumentsChunk ?? ""),
+            });
+        }
+        if (delta.finishReason) {
+            turn.finishReason = delta.finishReason;
+        }
+        if (delta.usage) {
+            turn.usage = delta.usage;
+            this.emitStreamUsageUpdated(turn);
+        }
+    }
+    /**
+     * Emit a usage_updated event so the agent manager updates agent.lastUsage
+     * and pushes the context usage to the client immediately, rather than
+     * waiting for turn_completed at the end of the entire tool loop.
+     *
+     * resolveContextWindowMaxTokens() is async (it may probe the endpoint) and
+     * this runs on the hot streaming path, so only the already-cached value is
+     * included. The event is always emitted regardless — the client and agent
+     * manager handle partial usage snapshots correctly.
+     */
+    emitStreamUsageUpdated(turn) {
+        if (!turn.usage || typeof turn.usage.inputTokens !== "number") {
+            return;
+        }
+        const usage = {
+            ...turn.usage,
+            contextWindowUsedTokens: turn.usage.inputTokens + (turn.usage.outputTokens ?? 0),
+        };
+        if (this.contextWindowMaxTokens !== null) {
+            usage.contextWindowMaxTokens = this.contextWindowMaxTokens;
+        }
+        this.emit({
+            type: "usage_updated",
+            provider: this.provider,
+            usage,
+            turnId: turn.turnId,
+        });
+    }
+    /**
+     * A turn can end (interrupt or failure) between an assistant message's
+     * tool_calls and their tool results — e.g. the user interrupts during call
+     * #1 of 3. Strict OpenAI-compatible servers reject the next request over
+     * such a conversation with a 400, so append synthetic results for the
+     * unanswered calls. Resume gets the equivalent repair from
+     * sanitizeRestoredMessages; this covers the live conversation.
+     */
+    repairDanglingToolCalls() {
+        // Only the trailing round can dangle: earlier rounds pushed all their
+        // results before the loop moved on.
+        for (let index = this.messages.length - 1; index >= 0; index -= 1) {
+            const message = this.messages[index];
+            if (message.role === "user") {
+                return;
+            }
+            if (message.role !== "assistant" || !message.tool_calls) {
+                continue;
+            }
+            const answered = new Set(this.messages
+                .slice(index + 1)
+                .flatMap((candidate) => (candidate.role === "tool" ? [candidate.tool_call_id] : [])));
+            for (const call of message.tool_calls) {
+                if (!answered.has(call.id)) {
+                    this.messages.push({
+                        role: "tool",
+                        content: "[Tool call was interrupted before it completed]",
+                        tool_call_id: call.id,
+                    });
+                }
+            }
+            return;
+        }
+    }
+    settleTurnFailure(turn, error) {
+        if (this.activeTurn !== turn) {
+            return;
+        }
+        this.activeTurn = null;
+        this.failPendingPermissions();
+        this.repairDanglingToolCalls();
+        if (turn.abort.signal.aborted) {
+            this.emit({
+                type: "turn_canceled",
+                provider: this.provider,
+                reason: "Interrupted",
+                turnId: turn.turnId,
+            });
+            if (turn.roundText || turn.roundReasoning) {
+                if (turn.roundText) {
+                    turn.finalTextParts.push(turn.roundText);
+                }
+                this.messages.push({
+                    role: "assistant",
+                    content: turn.roundText,
+                    ...(turn.roundReasoning ? { reasoning: turn.roundReasoning } : {}),
+                });
+            }
+            turn.resolve({
+                sessionId: this.id,
+                finalText: turn.finalTextParts.join("\n\n"),
+                timeline: [],
+                canceled: true,
+            });
+            return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger?.warn({ err: error, provider: this.provider }, "OpenAI-compatible turn failed");
+        this.emit({
+            type: "timeline",
+            provider: this.provider,
+            turnId: turn.turnId,
+            item: { type: "error", message },
+        });
+        this.emit({
+            type: "turn_failed",
+            provider: this.provider,
+            error: message,
+            turnId: turn.turnId,
+        });
+        turn.reject(error instanceof Error ? error : new Error(message));
+    }
+    failPendingPermissions() {
+        // Map iterators tolerate deleting the current entry mid-iteration.
+        for (const [requestId, pending] of this.pendingPermissions) {
+            this.pendingPermissions.delete(requestId);
+            pending.resolve({ behavior: "deny", message: "Turn ended", interrupt: false });
+        }
+    }
+    async resolveModel(endpoint) {
+        if (this.modelId) {
+            return this.modelId;
+        }
+        let response;
+        try {
+            response = await fetch(`${endpoint.baseUrl}/models`, {
+                headers: buildHeaders(endpoint),
+                signal: AbortSignal.timeout(DEFAULT_CATALOG_TIMEOUT_MS),
+            });
+        }
+        catch (error) {
+            throw unreachableError(this.label, endpoint, error);
+        }
+        const modelIds = response.ok ? parseModelList(await response.json()) : [];
+        const first = modelIds[0];
+        if (!first) {
+            throw new Error(`${this.label} has no models loaded. Load a model in the server, then try again.`);
+        }
+        this.modelId = first;
+        return first;
+    }
+    /**
+     * Best-effort context window discovery, cached per model. Checks the
+     * standard /v1/models listing for extended context-length fields first,
+     * then LM Studio's native /api/v0/models listing (same host, /v1 stripped),
+     * which reports the loaded instance's actual window. Servers that expose
+     * neither leave the meter without a max — never an error.
+     */
+    async resolveContextWindowMaxTokens() {
+        const model = this.modelId;
+        if (!model) {
+            return null;
+        }
+        if (this.contextWindowProbedModel === model) {
+            return this.contextWindowMaxTokens;
+        }
+        let endpoint;
+        try {
+            endpoint = resolveEndpoint(this.env, this.label);
+        }
+        catch {
+            return null;
+        }
+        const candidateUrls = [
+            `${endpoint.baseUrl}/models`,
+            `${endpoint.baseUrl.replace(/\/v1$/u, "")}/api/v0/models`,
+        ];
+        let resolved = null;
+        for (const url of candidateUrls) {
+            try {
+                const response = await fetch(url, {
+                    headers: buildHeaders(endpoint),
+                    signal: AbortSignal.timeout(DEFAULT_CATALOG_TIMEOUT_MS),
+                });
+                if (!response.ok)
+                    continue;
+                const match = parseModelContextLengths(await response.json()).get(model);
+                if (typeof match === "number") {
+                    resolved = match;
+                    break;
+                }
+            }
+            catch {
+                // Discovery is optional; unreachable probe endpoints are expected.
+            }
+        }
+        this.contextWindowMaxTokens = resolved;
+        this.contextWindowProbedModel = model;
+        return resolved;
+    }
+    /**
+     * Promote the raw per-request token counts into AgentUsage. The final
+     * round's prompt already contains the full conversation, so prompt +
+     * completion tokens is the context content size as the server measured it.
+     */
+    async buildTurnUsage(turn) {
+        if (!turn.usage) {
+            return undefined;
+        }
+        const usage = { ...turn.usage };
+        if (typeof turn.usage.inputTokens === "number") {
+            const usedTokens = turn.usage.inputTokens + (turn.usage.outputTokens ?? 0);
+            usage.contextWindowUsedTokens = usedTokens;
+            this.lastContextTokens = usedTokens;
+        }
+        const maxTokens = await this.resolveContextWindowMaxTokens();
+        if (maxTokens !== null) {
+            usage.contextWindowMaxTokens = maxTokens;
+        }
+        return usage;
+    }
+    /**
+     * Context makeup for the client's popup. The daemon owns this provider's
+     * entire prompt (system message, tool schemas, conversation), so the split
+     * is computed locally: char-based estimates per category, scaled so the
+     * counted total matches the server-measured context size when one exists.
+     */
+    async getContextUsage() {
+        const maxTokens = await this.resolveContextWindowMaxTokens();
+        if (maxTokens === null) {
+            return null;
+        }
+        const systemMessage = this.messages.find((message) => message.role === "system");
+        const conversation = this.messages.filter((message) => message.role !== "system");
+        const toolsPayload = [
+            ...buildOpenAIToolsPayload(this.availableToolSpecs()),
+            ...this.buildOttoToolPayload(),
+            ...this.buildMcpToolPayload(),
+        ];
+        let categories = [
+            {
+                name: "Messages",
+                tokens: conversation.reduce((sum, message) => sum + estimateTokens(JSON.stringify(message)), 0),
+            },
+            { name: "Tools", tokens: estimateTokens(JSON.stringify(toolsPayload)) },
+            { name: "System prompt", tokens: estimateTokens(systemMessage?.content ?? "") },
+        ];
+        let totalTokens = categories.reduce((sum, category) => sum + category.tokens, 0);
+        if (this.lastContextTokens !== null && totalTokens > 0) {
+            const scale = this.lastContextTokens / totalTokens;
+            categories = categories.map((category) => ({
+                ...category,
+                tokens: Math.round(category.tokens * scale),
+            }));
+            totalTokens = this.lastContextTokens;
+        }
+        return {
+            categories: categories.filter((category) => category.tokens > 0),
+            totalTokens,
+            maxTokens,
+        };
+    }
+    subscribe(callback) {
+        this.listeners.add(callback);
+        return () => {
+            this.listeners.delete(callback);
+        };
+    }
+    async *streamHistory() {
+        for (const event of this.eventHistory) {
+            yield event;
+        }
+    }
+    async getRuntimeInfo() {
+        return {
+            provider: this.provider,
+            sessionId: this.id,
+            model: this.modelId,
+            modeId: this.modeId,
+        };
+    }
+    async getAvailableModes() {
+        return OPENAI_COMPAT_MODES;
+    }
+    async getCurrentMode() {
+        return this.modeId;
+    }
+    async setMode(modeId) {
+        if (!VALID_MODE_IDS.has(modeId)) {
+            throw new Error(`Unknown mode: ${modeId}`);
+        }
+        this.modeId = modeId;
+        this.emit({
+            type: "mode_changed",
+            provider: this.provider,
+            currentModeId: modeId,
+            availableModes: OPENAI_COMPAT_MODES,
+        });
+    }
+    getPendingPermissions() {
+        return [...this.pendingPermissions.values()].map((pending) => pending.request);
+    }
+    async respondToPermission(requestId, response) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+            return undefined;
+        }
+        this.pendingPermissions.delete(requestId);
+        this.emit({
+            type: "permission_resolved",
+            provider: this.provider,
+            requestId,
+            resolution: response,
+            ...(this.activeTurn ? { turnId: this.activeTurn.turnId } : {}),
+        });
+        pending.resolve(response);
+        return undefined;
+    }
+    describePersistence() {
+        return {
+            provider: this.provider,
+            sessionId: this.id,
+            metadata: {
+                model: this.modelId,
+                modeId: this.modeId,
+                messages: this.messages,
+            },
+        };
+    }
+    async setModel(modelId) {
+        this.modelId = modelId;
+    }
+    /**
+     * Rewind the daemon-owned conversation to just before the given user
+     * message. The full conversation persists (no message cap), so any
+     * previous user message is a valid rewind target — the not-found error
+     * below only fires for a truly unknown messageId.
+     */
+    async revertConversation(input) {
+        if (this.activeTurn) {
+            throw new Error(`${this.label} cannot rewind while a turn is running`);
+        }
+        const index = this.messages.findIndex((message) => message.role === "user" && message.messageId === input.messageId);
+        if (index === -1) {
+            throw new Error("Message not found in this session's conversation — it may predate rewind support or was trimmed from persisted history.");
+        }
+        const retained = sanitizeRestoredMessages(this.messages.slice(0, index));
+        this.messages.length = 0;
+        this.messages.push(...retained);
+        this.rebuildEventHistory();
+        this.lastContextTokens = null;
+    }
+    async interrupt() {
+        const turn = this.activeTurn;
+        if (!turn) {
+            return;
+        }
+        turn.abort.abort();
+        // A turn parked on a permission prompt has no in-flight fetch to abort —
+        // deny the prompt so the loop unwinds and settles as canceled.
+        this.failPendingPermissions();
+    }
+    async close() {
+        await this.interrupt();
+        await this.mcpManager?.close();
+        this.listeners.clear();
+    }
+    /**
+     * Retain what streamHistory replays: user messages, assistant messages
+     * (coalesced per messageId so streamed deltas don't accumulate one event
+     * each), reasoning (coalesced per contiguous block), and tool calls
+     * (coalesced per callId so a call's running → completed/failed/canceled
+     * transitions collapse to its latest status instead of replaying every
+     * intermediate state). Usage and permission events aren't part of the
+     * displayed transcript and are dropped. Copies are stored so coalescing
+     * never mutates an event a listener already received.
+     */
+    retainForHistory(event) {
+        if (event.type !== "timeline") {
+            return;
+        }
+        const item = event.item;
+        if (item.type === "user_message") {
+            this.eventHistory.push({ ...event, item: { ...item } });
+            return;
+        }
+        if (item.type === "tool_call") {
+            const existingIdx = this.eventHistory.findIndex((candidate) => candidate.type === "timeline" &&
+                candidate.item.type === "tool_call" &&
+                candidate.item.callId === item.callId);
+            const copy = { ...event, item: { ...item } };
+            if (existingIdx >= 0) {
+                this.eventHistory[existingIdx] = copy;
+            }
+            else {
+                this.eventHistory.push(copy);
+            }
+            return;
+        }
+        if (item.type === "reasoning") {
+            // Reasoning deltas stream contiguously within a round, so appending to
+            // a trailing reasoning event coalesces one block per round; assistant
+            // text or a tool call in between starts the next block naturally.
+            const last = this.eventHistory[this.eventHistory.length - 1];
+            if (last?.type === "timeline" && last.item.type === "reasoning") {
+                last.item.text += item.text;
+                return;
+            }
+            this.eventHistory.push({ ...event, item: { ...item } });
+            return;
+        }
+        if (item.type !== "assistant_message") {
+            return;
+        }
+        const last = this.eventHistory[this.eventHistory.length - 1];
+        if (last?.type === "timeline" &&
+            last.item.type === "assistant_message" &&
+            last.item.messageId === item.messageId) {
+            last.item.text += item.text;
+            return;
+        }
+        this.eventHistory.push({ ...event, item: { ...item } });
+    }
+    emit(event) {
+        this.retainForHistory(event);
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                this.logger?.warn({ err: error }, "OpenAI-compatible listener failed");
+            }
+        }
+    }
+}
+//# sourceMappingURL=openai-compat-agent.js.map