openmausbot 0.1.78 → 0.1.80

package/dist-server/server/drivers/openai-chat-protocol.js

@@ -0,0 +1,92 @@
+export const MAX_CHAT_TOOL_CALLS = 32;
+const MAX_ARGUMENT_CHARS = 256_000;
+export class ChatProtocolError extends Error {
+}
+export function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : undefined;
+}
+/** Opaque provider reasoning blocks must keep their original order/signatures.
+ * OpenRouter streams the sequence as arrays of blocks, not tool-call deltas. */
+export class ChatReasoningDetails {
+    blocks = [];
+    chars = 0;
+    add(value) {
+        if (value === undefined || value === null)
+            return;
+        if (!Array.isArray(value) || value.some((block) => !object(block))) {
+            throw new ChatProtocolError("provider returned invalid reasoning details");
+        }
+        this.chars += JSON.stringify(value).length;
+        if (this.chars > 256_000)
+            throw new ChatProtocolError("provider reasoning details exceeded the size limit");
+        this.blocks.push(...value);
+    }
+}
+/** One accumulator per completion: indexes identify deltas; IDs correlate results. */
+export class ChatToolCalls {
+    calls = new Map();
+    argumentChars = 0;
+    add(value, streaming) {
+        if (value === undefined || value === null)
+            return;
+        if (!Array.isArray(value))
+            throw new ChatProtocolError("provider returned invalid tool_calls");
+        for (const [position, raw] of value.entries()) {
+            const delta = object(raw);
+            const index = streaming ? delta?.index : position;
+            if (!delta || !Number.isInteger(index) || Number(index) < 0 || Number(index) >= MAX_CHAT_TOOL_CALLS) {
+                throw new ChatProtocolError("provider returned an invalid tool-call index");
+            }
+            const call = this.calls.get(Number(index)) ?? { id: "", type: "function", function: { name: "", arguments: "" } };
+            if (delta.type !== undefined && delta.type !== "function")
+                throw new ChatProtocolError("unsupported tool-call type");
+            if (delta.id !== undefined) {
+                if (typeof delta.id !== "string" || !delta.id || delta.id.length > 256 || (call.id && call.id !== delta.id)) {
+                    throw new ChatProtocolError("provider changed or omitted a tool-call ID");
+                }
+                call.id = delta.id;
+            }
+            if (delta.function !== undefined) {
+                const fn = object(delta.function);
+                if (!fn)
+                    throw new ChatProtocolError("provider returned an invalid tool-call function");
+                for (const field of ["name", "arguments"]) {
+                    if (fn[field] === undefined)
+                        continue;
+                    if (typeof fn[field] !== "string")
+                        throw new ChatProtocolError("provider returned invalid tool-call arguments or name");
+                    call.function[field] += fn[field];
+                    if (field === "arguments")
+                        this.argumentChars += fn[field].length;
+                }
+            }
+            if (call.function.name.length > 64 || this.argumentChars > MAX_ARGUMENT_CHARS) {
+                throw new ChatProtocolError("provider tool calls exceeded the size limit");
+            }
+            this.calls.set(Number(index), call);
+        }
+    }
+    finish(reason, malformedFrame) {
+        const calls = [...this.calls.entries()].sort(([a], [b]) => a - b).map(([, call]) => call);
+        if (malformedFrame)
+            throw new ChatProtocolError("provider stream contained a malformed completion frame");
+        if (reason === "function_call")
+            throw new ChatProtocolError("legacy function_call is unsupported; use structured tool_calls");
+        if (reason === "tool_calls" && !calls.length)
+            throw new ChatProtocolError("provider ended for tool calls without a complete call");
+        if (!calls.length)
+            return calls;
+        if (reason !== null && reason !== "tool_calls" && reason !== "stop") {
+            throw new ChatProtocolError("provider tool calls were truncated or malformed");
+        }
+        const ids = new Set();
+        for (const call of calls) {
+            if (!call.id || ids.has(call.id) || !/^[A-Za-z0-9_-]{1,64}$/.test(call.function.name)) {
+                throw new ChatProtocolError("provider returned an incomplete or duplicate tool call");
+            }
+            ids.add(call.id);
+        }
+        return calls;
+    }
+}

package/dist-server/server/drivers/openai-chat.js

@@ -1,6 +1,26 @@
 import { newEventId, newId } from "../contracts.js";
+import { redactSecretsInText } from "../redact.js";
+import { toolDetailPreview } from "../tool-summary.js";
+import { ChatToolSessionError, mountChatTools } from "./chat-mcp-tools.js";
+import { createChatToolApproval } from "./chat-tool-approval.js";
+import { ChatProtocolError, ChatReasoningDetails, ChatToolCalls, MAX_CHAT_TOOL_CALLS, object } from "./openai-chat-protocol.js";
 import { appendNative } from "./native.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
+/** The message of a JSON error body a provider returned with HTTP 200.
+ *  MiniMax reports auth, balance, and parameter failures as `base_resp`. */
+function providerError(json) {
+    if (typeof json.error === "string")
+        return json.error;
+    const error = object(json.error);
+    if (error)
+        return typeof error.message === "string" ? error.message : "unknown error";
+    const code = json.base_resp?.status_code;
+    if (typeof code === "number" && code !== 0) {
+        const msg = typeof json.base_resp?.status_msg === "string" ? json.base_resp.status_msg : "";
+        return `upstream error ${code}${msg ? `: ${msg}` : ""}`;
+    }
+    return null;
+}
 const usageFrom = (usage) => usage
     ? { input: usage.prompt_tokens ?? 0, output: usage.completion_tokens ?? 0 }
     : null;
@@ -21,7 +41,7 @@ export function createOpenAIChatRuntime(options) {
         turnId,
         createdAt: new Date().toISOString(),
     });
-    const complete = async (messages, model, stream, signal, onDelta) => {
+    const complete = async (messages, model, stream, signal, onDelta, tools = []) => {
         // Idle timer that is renewed on every received chunk during streaming
         const timeoutController = new AbortController();
         let idleTimer = null;
@@ -40,22 +60,44 @@ export function createOpenAIChatRuntime(options) {
             const response = await fetch(`${options.apiUrl}/chat/completions`, {
                 method: "POST",
                 headers: { authorization: `Bearer ${options.apiKey}`, "content-type": "application/json" },
-                body: JSON.stringify(options.requestBody(model, messages, stream)),
+                body: JSON.stringify({
+                    ...options.requestBody(model, messages, stream),
+                    ...(tools.length ? { tools } : {}),
+                }),
                 signal: activeSignal,
             });
             if (!response.ok) {
                 const body = await response.text().catch(() => "");
                 throw new Error(`${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`);
             }
-            if (!stream) {
+            if (!stream || response.headers.get("content-type")?.includes("application/json")) {
                 const json = await response.json();
+                const bodyError = providerError(json);
+                if (bodyError)
+                    throw new ChatProtocolError(`provider returned a completion error: ${bodyError.slice(0, 200)}`);
                 const message = json.choices?.[0]?.message;
+                if (!message || !object(message) || !["content", "reasoning_content", "reasoning", "reasoning_details", "tool_calls", "function_call"].some((key) => key in message)) {
+                    throw new ChatProtocolError("provider returned no completion message");
+                }
+                if (message?.function_call)
+                    throw new ChatProtocolError("legacy function_call is unsupported; use structured tool_calls");
+                const calls = new ChatToolCalls();
+                calls.add(message?.tool_calls, false);
+                const details = new ChatReasoningDetails();
+                details.add(message.reasoning_details);
+                const reasoning = message.reasoning_content ?? message.reasoning;
+                const finishReason = json.choices?.[0]?.finish_reason ?? null;
+                activeSignal.throwIfAborted();
                 return {
                     text: typeof message?.content === "string" ? message.content : "",
-                    reasoning: options.reasoning && typeof message?.reasoning_content === "string"
-                        ? message.reasoning_content
+                    reasoning: options.reasoning && typeof reasoning === "string"
+                        ? reasoning
                         : "",
                     usage: usageFrom(json.usage),
+                    toolCalls: calls.finish(finishReason, false),
+                    finishReason,
+                    protocolReasoning: typeof reasoning === "string" ? reasoning : "",
+                    protocolReasoningDetails: details.blocks,
                 };
             }
             if (!response.body) {
@@ -63,7 +105,13 @@ export function createOpenAIChatRuntime(options) {
             }
             let text = "";
             let reasoning = "";
+            let protocolReasoning = "";
             let usage = null;
+            let finishReason = null;
+            let malformedFrame = false;
+            let sawChoice = false;
+            const calls = new ChatToolCalls();
+            const details = new ChatReasoningDetails();
             const reader = response.body.getReader();
             const decoder = new TextDecoder();
             let buffer = "";
@@ -71,12 +119,29 @@ export function createOpenAIChatRuntime(options) {
                 readLoop: for (;;) {
                     const { done, value } = await reader.read();
                     if (done) {
-                        if (buffer.trim() === "data: [DONE]")
+                        buffer += decoder.decode();
+                        // MiniMax's api.minimax.io/v1 closes the connection after the
+                        // finish_reason chunk and never sends `[DONE]`.
+                        if (buffer.trim() === "data: [DONE]" || finishReason)
                             break;
-                        throw new DOMException("Stream ended before completion", "AbortError");
+                        if (!sawChoice) {
+                            let body;
+                            try {
+                                body = JSON.parse(buffer);
+                            }
+                            catch {
+                                body = undefined;
+                            }
+                            const bodyError = body ? providerError(body) : null;
+                            if (bodyError)
+                                throw new ChatProtocolError(`provider returned a completion error: ${bodyError.slice(0, 200)}`);
+                        }
+                        throw new ChatProtocolError("Stream ended before completion");
                     }
                     resetIdleTimer();
                     buffer += decoder.decode(value, { stream: true });
+                    if (buffer.length > 2_000_000)
+                        throw new ChatProtocolError("provider stream frame exceeded the size limit");
                     let newline;
                     while ((newline = buffer.indexOf("\n")) !== -1) {
                         const line = buffer.slice(0, newline).trim();
@@ -91,11 +156,27 @@ export function createOpenAIChatRuntime(options) {
                             chunk = JSON.parse(data);
                         }
                         catch {
+                            malformedFrame = true;
                             continue;
                         }
-                        const delta = chunk.choices?.[0]?.delta;
-                        const reasoningDelta = options.reasoning && typeof delta?.reasoning_content === "string"
-                            ? delta.reasoning_content
+                        const chunkError = providerError(chunk);
+                        if (chunkError)
+                            throw new ChatProtocolError(`provider returned a streaming completion error: ${chunkError.slice(0, 200)}`);
+                        const choice = chunk.choices?.find((row) => row.index === undefined || row.index === 0);
+                        const delta = choice?.delta;
+                        if (object(delta))
+                            sawChoice = true;
+                        if (delta?.function_call)
+                            throw new ChatProtocolError("legacy function_call is unsupported; use structured tool_calls");
+                        calls.add(delta?.tool_calls, true);
+                        details.add(delta?.reasoning_details);
+                        if (choice?.finish_reason)
+                            finishReason = choice.finish_reason;
+                        const reasoningPart = delta?.reasoning_content ?? delta?.reasoning;
+                        if (typeof reasoningPart === "string")
+                            protocolReasoning += reasoningPart;
+                        const reasoningDelta = options.reasoning && typeof reasoningPart === "string"
+                            ? reasoningPart
                             : "";
                         const contentDelta = typeof delta?.content === "string" ? delta.content : "";
                         if (reasoningDelta) {
@@ -114,7 +195,10 @@ export function createOpenAIChatRuntime(options) {
             finally {
                 await reader.cancel().catch(() => { });
             }
-            return { text, reasoning, usage };
+            activeSignal.throwIfAborted();
+            if (!sawChoice)
+                throw new ChatProtocolError("provider returned no streaming completion choice");
+            return { text, reasoning, usage, toolCalls: calls.finish(finishReason, malformedFrame), finishReason, protocolReasoning, protocolReasoningDetails: details.blocks };
         }
         finally {
             if (idleTimer)
@@ -138,85 +222,233 @@ export function createOpenAIChatRuntime(options) {
         const abort = new AbortController();
         const messages = messagesFor(turn);
         const model = turn.model || options.models().default;
-        active.set(turn.threadId, abort);
-        appendNative(turn.threadId, {
-            dir: "out",
-            source: options.nativeLog.source,
-            msg: options.nativeLog.outgoing(turn, messages, model),
+        const secrets = [options.apiKey];
+        for (const integration of Object.values(turn.integrations ?? {})) {
+            const entries = object(integration);
+            const specs = entries && "command" in entries ? [entries] : Object.values(entries ?? {}).map(object);
+            for (const spec of specs) {
+                for (const [key, value] of Object.entries(object(spec?.env) ?? {})) {
+                    if (/key|token|password|secret|authorization/i.test(key) && typeof value === "string" && value)
+                        secrets.push(value);
+                }
+            }
+        }
+        const safeText = (text) => {
+            let safe = text;
+            for (const secret of secrets)
+                if (secret)
+                    safe = safe.split(secret).join("[redacted]");
+            return redactSecretsInText(safe);
+        };
+        const preview = (value) => toolDetailPreview(JSON.parse(JSON.stringify(value, (_key, part) => typeof part === "string" ? safeText(part) : part)));
+        const native = (dir, msg) => appendNative(turn.threadId, {
+            dir, source: options.nativeLog.source,
+            msg: JSON.parse(JSON.stringify(msg, (_key, part) => typeof part === "string" ? safeText(part) : part)),
+        });
+        const approval = createChatToolApproval({
+            signal: abort.signal,
+            open: (ask) => emit({
+                ...base(turn.threadId, turnId), type: "request.opened", requestType: "permission",
+                requestId: ask.id, tool: ask.tool, summary: ask.summary, allowSession: false,
+            }),
+            resolved: (ask, allowed, source) => emit({
+                ...base(turn.threadId, turnId), type: "request.resolved", requestId: ask.id,
+                behavior: allowed ? "allow" : "deny", source,
+            }),
         });
+        let resolveDone;
+        const done = new Promise((resolve) => { resolveDone = resolve; });
+        active.set(turn.threadId, { abort, turnId, done, approval });
         emit({ ...base(turn.threadId, turnId), type: "turn.started" });
         emit({ ...base(turn.threadId, turnId), type: "session.started", sessionId: null, model });
         void (async () => {
-            let attempt = 0;
-            let streamedText = false;
-            for (;;) {
-                try {
-                    const completion = await complete(messages, model, true, abort.signal, (delta, streamKind) => {
-                        if (streamKind === "assistant_text")
-                            streamedText = true;
-                        emit({ ...base(turn.threadId, turnId), type: "content.delta", streamKind, delta });
-                    });
-                    appendNative(turn.threadId, {
-                        dir: "in",
-                        source: options.nativeLog.source,
-                        msg: options.nativeLog.incoming(completion),
-                    });
-                    const reply = completion.text.trim() ? completion.text : completion.reasoning;
-                    if (reply.trim()) {
-                        emit({ ...base(turn.threadId, turnId), type: "item.completed", itemType: "assistant_text", text: reply });
+            let tools;
+            const usage = { input: 0, output: 0 };
+            let hasUsage = false;
+            let ok = false;
+            let stopReason = null;
+            let failure;
+            let toolFailed = false;
+            const denials = [];
+            const seenCalls = new Set();
+            try {
+                tools = await mountChatTools(options.tools === false ? undefined : turn.integrations, abort.signal);
+                for (let round = 0; round < 16; round++) {
+                    abort.signal.throwIfAborted();
+                    native("out", options.nativeLog.outgoing(turn, messages, model));
+                    let attempt = 0;
+                    let completion;
+                    for (;;) {
+                        let streamed = false;
+                        const pending = { assistant_text: "", reasoning_text: "" };
+                        const delta = (text, streamKind, flush = false) => {
+                            let combined = pending[streamKind] + text;
+                            // Mask complete matches before holding a suffix: otherwise a key
+                            // such as "abab" could be split at its own repeated prefix.
+                            for (const secret of secrets)
+                                if (secret)
+                                    combined = combined.split(secret).join("[redacted]");
+                            let hold = 0;
+                            // A configured credential can straddle chunks. Hold any suffix
+                            // that could be its prefix until the next chunk disambiguates it.
+                            if (!flush)
+                                for (const secret of secrets) {
+                                    for (let length = Math.min(secret.length - 1, combined.length); length > hold; length--) {
+                                        if (combined.endsWith(secret.slice(0, length))) {
+                                            hold = length;
+                                            break;
+                                        }
+                                    }
+                                }
+                            pending[streamKind] = hold ? combined.slice(-hold) : "";
+                            const visible = safeText(hold ? combined.slice(0, -hold) : combined);
+                            if (visible)
+                                emit({ ...base(turn.threadId, turnId), type: "content.delta", streamKind, delta: visible });
+                        };
+                        try {
+                            completion = await complete(messages, model, true, abort.signal, (text, streamKind) => {
+                                streamed = true;
+                                delta(text, streamKind);
+                            }, tools.definitions);
+                            delta("", "assistant_text", true);
+                            delta("", "reasoning_text", true);
+                            break;
+                        }
+                        catch (value) {
+                            const error = asError(value);
+                            const verdict = classifyError(error);
+                            // Once a call has been handled, never replay it through a turn retry.
+                            if (options.retryScale === undefined || abort.signal.aborted || streamed || seenCalls.size ||
+                                error instanceof ChatProtocolError || !verdict.transient || attempt >= RETRY_MAX_ATTEMPTS - 1)
+                                throw error;
+                            const delayMs = computeBackoff(attempt++);
+                            emit({ ...base(turn.threadId, turnId), type: "turn.retrying", attempt, delayMs, reason: verdict.reason });
+                            await interruptibleDelay(delayMs * options.retryScale, abort.signal).promise;
+                            abort.signal.throwIfAborted();
+                        }
                     }
+                    native("in", options.nativeLog.incoming(completion));
                     if (completion.usage) {
-                        emit({ ...base(turn.threadId, turnId), type: "thread.token-usage.updated", ...completion.usage });
+                        usage.input += completion.usage.input;
+                        usage.output += completion.usage.output;
+                        hasUsage = true;
+                        emit({ ...base(turn.threadId, turnId), type: "thread.token-usage.updated", ...usage });
                     }
-                    active.delete(turn.threadId);
-                    const completed = {
-                        ...base(turn.threadId, turnId),
-                        type: "turn.completed",
-                        ok: true,
-                        stopReason: null,
-                        cost: null,
-                    };
-                    emit(options.includeUsageInCompleted && completion.usage
-                        ? { ...completed, usage: completion.usage }
-                        : completed);
-                    return;
-                }
-                catch (value) {
-                    const error = asError(value);
-                    const aborted = error.name === "AbortError";
-                    const verdict = classifyError(error);
-                    if (options.retryScale !== undefined &&
-                        !aborted &&
-                        !streamedText &&
-                        verdict.transient &&
-                        attempt < RETRY_MAX_ATTEMPTS - 1) {
-                        const delayMs = computeBackoff(attempt++);
-                        emit({
-                            ...base(turn.threadId, turnId),
-                            type: "turn.retrying",
-                            attempt,
-                            delayMs,
-                            reason: verdict.reason,
-                        });
-                        const outcome = await interruptibleDelay(delayMs * options.retryScale, abort.signal).promise;
-                        if (outcome === "elapsed" && !abort.signal.aborted)
-                            continue;
-                        active.delete(turn.threadId);
-                        emit({ ...base(turn.threadId, turnId), type: "turn.completed", ok: false, stopReason: "interrupted", cost: null });
-                        return;
+                    // Reasoning on a tool-call round belongs to the protocol, not a final reply.
+                    const reply = completion.text.trim() ? completion.text : completion.toolCalls.length ? "" : completion.reasoning;
+                    if (reply.trim())
+                        emit({ ...base(turn.threadId, turnId), type: "item.completed", itemType: "assistant_text", text: safeText(reply) });
+                    abort.signal.throwIfAborted();
+                    if (!completion.toolCalls.length) {
+                        if (!reply.trim())
+                            throw new ChatProtocolError("provider returned an empty response");
+                        if (completion.finishReason && completion.finishReason !== "stop") {
+                            throw new ChatProtocolError(`provider did not finish the response (${completion.finishReason})`);
+                        }
+                        if (toolFailed) {
+                            stopReason = "tool_error";
+                            throw new ChatProtocolError("One or more tool operations failed or were denied. See the tool results; the final response is not an execution receipt.");
+                        }
+                        ok = true;
+                        break;
+                    }
+                    if (!tools.definitions.length)
+                        throw new ChatProtocolError("provider returned tool calls, but no tools are available for this turn");
+                    // Validate IDs for the entire batch before executing any of its calls.
+                    for (const call of completion.toolCalls) {
+                        if (seenCalls.has(call.id))
+                            throw new ChatProtocolError("provider reused a tool-call ID; refusing to repeat an operation");
+                        seenCalls.add(call.id);
                     }
-                    active.delete(turn.threadId);
-                    if (!aborted)
-                        emit({ ...base(turn.threadId, turnId), type: "runtime.error", message: error.message });
-                    emit({
-                        ...base(turn.threadId, turnId),
-                        type: "turn.completed",
-                        ok: false,
-                        stopReason: aborted ? "interrupted" : "error",
-                        cost: null,
+                    if (seenCalls.size > MAX_CHAT_TOOL_CALLS)
+                        throw new ChatProtocolError("tool-call limit reached");
+                    messages.push({ role: "assistant", content: completion.text || null, tool_calls: completion.toolCalls,
+                        ...(completion.protocolReasoning ? { reasoning_content: completion.protocolReasoning } : {}),
+                        ...(completion.protocolReasoningDetails.length ? { reasoning_details: completion.protocolReasoningDetails } : {}),
                     });
-                    return;
+                    for (const call of completion.toolCalls) {
+                        abort.signal.throwIfAborted();
+                        let result;
+                        let started = false;
+                        let fatal;
+                        try {
+                            let args;
+                            try {
+                                args = JSON.parse(call.function.arguments);
+                            }
+                            catch {
+                                throw new ChatProtocolError("tool arguments are not complete JSON");
+                            }
+                            if (!object(args))
+                                throw new ChatProtocolError("tool arguments must be a JSON object");
+                            tools.validate(call.function.name, args);
+                            const inputPreview = preview(args);
+                            const allowed = await approval.ask(call.function.name, inputPreview ?? "This tool has no arguments.");
+                            abort.signal.throwIfAborted();
+                            emit({ ...base(turn.threadId, turnId), type: "item.started", itemType: "tool", itemId: call.id,
+                                title: call.function.name, ...(inputPreview ? { input: inputPreview } : {}),
+                            });
+                            started = true;
+                            if (allowed) {
+                                result = await tools.execute(call.function.name, args, abort.signal);
+                            }
+                            else {
+                                denials.push(call.function.name);
+                                result = { ok: false, text: "Permission denied or expired; the tool was not executed." };
+                            }
+                        }
+                        catch (error) {
+                            if (error instanceof ChatToolSessionError)
+                                fatal = error;
+                            result = { ok: false, text: abort.signal.aborted
+                                    ? "Tool interrupted; an operation already dispatched may have taken effect. Verify its state before retrying."
+                                    : safeText(asError(error).message).slice(0, 2_000) };
+                        }
+                        if (!started)
+                            emit({ ...base(turn.threadId, turnId), type: "item.started", itemType: "tool", itemId: call.id, title: call.function.name });
+                        const text = safeText(result.text);
+                        const output = preview({ ok: result.ok, result: text });
+                        emit({ ...base(turn.threadId, turnId), type: "item.completed", itemType: "tool", itemId: call.id, ok: result.ok, output });
+                        if (!result.ok)
+                            toolFailed = true;
+                        messages.push({ role: "tool", tool_call_id: call.id, content: JSON.stringify({ ok: result.ok, result: text }) });
+                        abort.signal.throwIfAborted();
+                        if (fatal)
+                            throw fatal;
+                    }
+                }
+                if (!ok)
+                    throw new ChatProtocolError("model-call limit reached before a final response");
+            }
+            catch (value) {
+                stopReason = abort.signal.aborted ? "interrupted" : stopReason ?? "error";
+                failure = safeText(asError(value).message).slice(0, 2_000);
+            }
+            finally {
+                approval.close();
+                let cleanupFailed = false;
+                try {
+                    await tools?.close();
+                }
+                catch {
+                    ok = false;
+                    stopReason = "error";
+                    cleanupFailed = true;
+                    failure = "Tool processes could not be stopped; their execution state is uncertain.";
                 }
+                if (abort.signal.aborted) {
+                    ok = false;
+                    stopReason = "interrupted";
+                }
+                if (failure && (!abort.signal.aborted || cleanupFailed)) {
+                    emit({ ...base(turn.threadId, turnId), type: "runtime.error", message: failure, terminal: !abort.signal.aborted });
+                }
+                active.delete(turn.threadId);
+                emit({ ...base(turn.threadId, turnId), type: "turn.completed", ok, stopReason, cost: null,
+                    ...(hasUsage && (options.includeUsageInCompleted || seenCalls.size) ? { usage } : {}),
+                    ...(denials.length ? { denials } : {}),
+                });
+                resolveDone();
             }
         })();
         return { turnId };
@@ -235,14 +467,22 @@ export function createOpenAIChatRuntime(options) {
             : { state: "unavailable", reason: options.unavailableReason },
         adapter: {
             provider: options.driverKind,
-            capabilities: { sessionModelSwitch: "in-session" },
+            capabilities: { sessionModelSwitch: "in-session", customMcp: options.tools !== false, agentsMcp: options.tools !== false, composioMcp: options.tools !== false },
             sendTurn,
-            interruptTurn: async (threadId) => active.get(threadId)?.abort(),
-            respondToRequest: async () => "unavailable",
+            interruptTurn: async (threadId, turnId) => {
+                const turn = active.get(threadId);
+                if (!turn || (turnId && turn.turnId !== turnId))
+                    return;
+                turn.abort.abort();
+                await turn.done;
+            },
+            respondToRequest: async (threadId, requestId, decision) => active.get(threadId)?.approval.answer(requestId, decision.behavior) ?? "unavailable",
             hasSession: (threadId) => active.has(threadId),
             stopAll: async () => {
-                for (const abort of active.values())
-                    abort.abort();
+                const turns = [...active.values()];
+                for (const turn of turns)
+                    turn.abort.abort();
+                await Promise.all(turns.map((turn) => turn.done));
             },
             onEvent: (listener) => {
                 listeners.add(listener);
@@ -251,12 +491,16 @@ export function createOpenAIChatRuntime(options) {
         },
         generateText: async (prompt) => {
             const model = options.generateModel?.() ?? options.models().default;
-            const { text, reasoning } = await complete([{ role: "user", content: prompt }], model, false);
+            const { text, reasoning, toolCalls } = await complete([{ role: "user", content: prompt }], model, false);
+            if (toolCalls.length)
+                throw new ChatProtocolError("provider returned tool calls to a text-only helper");
             return text.trim() ? text : reasoning;
         },
         dispose: async () => {
-            for (const abort of active.values())
-                abort.abort();
+            const turns = [...active.values()];
+            for (const turn of turns)
+                turn.abort.abort();
+            await Promise.all(turns.map((turn) => turn.done));
             listeners.clear();
         },
     };

package/dist-server/server/drivers/openai-compat.js

@@ -26,8 +26,11 @@ function isOpenRouterUrl(url) {
 }
 function decodeConfig(raw) {
     const config = (raw ?? {});
+    if (config.tools !== undefined && typeof config.tools !== "boolean")
+        throw new Error("tools must be a boolean");
     const envUrl = process.env.OPENAI_COMPAT_URL;
     return {
+        ...(config.tools !== undefined ? { tools: config.tools } : {}),
         url: (typeof config.url === "string" && config.url ? config.url : envUrl || "https://openrouter.ai/api/v1")
             .replace(/\/+$/, ""),
         apiKeyEnv: typeof config.apiKeyEnv === "string" && config.apiKeyEnv
@@ -122,6 +125,7 @@ export const OpenAICompatDriver = {
             driverKind: DRIVER_KIND,
             apiKey,
             apiUrl: config.url,
+            tools: config.tools,
             models: () => catalog,
             refreshModels: fetchModels,
             requestBody: (model, messages, stream) => ({