openmausbot 0.1.96 → 0.1.98

package/dist-server/server/drivers/device-auth.js

@@ -0,0 +1,342 @@
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { stripVTControlCharacters } from "node:util";
+import { deviceSignInPrompt } from "../../shared/device-sign-in.js";
+import { killCliTree, spawnCli } from "../procs.js";
+const MAX_OUTPUT = 16_384;
+// Two configured instances can use the same on-disk login. Only the auth
+// operation is exclusive: normal turns are not blocked by this lock.
+const authenticatingHomes = new Set();
+/** The real path of a credential home, so two spellings of one home share
+ * one sign-in lock. A missing tail keeps its name under its real parent. */
+export function canonicalPath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        const parent = dirname(path);
+        return parent === path ? path : join(canonicalPath(parent), basename(path));
+    }
+}
+/** A fixed login command, not a remotely accessible terminal. CLI output
+ * stays in bounded private memory; only a device page and code are exposed. */
+export class DeviceAuthController {
+    flow = null;
+    command = null;
+    disposed = false;
+    spec;
+    options;
+    constructor(spec, options) {
+        this.spec = spec;
+        this.options = options;
+    }
+    /** The credential home the lock is held on, for this environment. */
+    home(env, action) {
+        const { homeEnv, homeDir, product } = this.spec;
+        const home = env.HOME || env.USERPROFILE || homedir();
+        const named = env[homeEnv];
+        if (!isAbsolute(home) || (named && !isAbsolute(named))) {
+            throw new Error(`Use an absolute HOME and ${homeEnv} path for this server's ${product} provider before ${action}.`);
+        }
+        return { home, homeKey: canonicalPath(resolve(named || join(home, homeDir))) };
+    }
+    async start() {
+        const { product, account, status } = this.spec;
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing in.");
+        if (this.flow?.status.phase === "waiting") {
+            if (this.flow.ready)
+                return { ...this.flow.status, phase: "waiting" };
+            throw new Error(`A ${account} sign-in is already starting. Please wait for the code.`);
+        }
+        await this.flow?.stopping;
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing in.");
+        const env = this.options.environment();
+        const { home, homeKey } = this.home(env, "signing in");
+        if (authenticatingHomes.has(homeKey)) {
+            throw new Error(`A ${account} sign-in is already running for this server account. Finish or cancel it before starting another.`);
+        }
+        authenticatingHomes.add(homeKey);
+        return new Promise((resolveStart, reject) => {
+            const flow = {
+                status: {
+                    phase: "waiting", flowId: randomUUID(), authorizationUrl: null,
+                    expiresAt: new Date(Date.now() + (this.options.lifetimeMs ?? 15 * 60_000)).toISOString(),
+                },
+                child: null, ready: false, resolve: resolveStart, reject, homeKey,
+                startupTimer: setTimeout(() => this.finish(flow, "failed", `${product} did not provide a sign-in code in time. Check the server connection and update ${product}, then try again.`), this.options.startupTimeoutMs ?? 30_000),
+                expiryTimer: setTimeout(() => this.finish(flow, "expired", `The ${account} sign-in code expired. Start sign-in again.`), this.options.lifetimeMs ?? 15 * 60_000),
+            };
+            flow.startupTimer.unref();
+            flow.expiryTimer.unref();
+            this.flow = flow;
+            const login = () => this.run(flow, [...this.spec.loginArgs], env, home, (loginCode, loginOutput) => {
+                if (loginCode !== 0 || !flow.ready) {
+                    this.finish(flow, "failed", this.spec.failure(loginOutput));
+                    return;
+                }
+                // A successful command is not enough: confirm the sign-in the way
+                // this client's bots will find it, with the same executable and
+                // environment.
+                flow.startupTimer = setTimeout(() => this.finish(flow, "failed", `${product} finished sign-in but could not confirm the account. Refresh Settings and try again.`), this.options.startupTimeoutMs ?? 30_000);
+                flow.startupTimer.unref();
+                this.confirm(flow, env, home, (signedIn) => this.finish(flow, signedIn ? "succeeded" : "failed", `${product} finished sign-in but did not confirm a ${account} account. Refresh Settings and try again.`));
+            }, true);
+            // Never overwrite a working login just because Connect was clicked twice.
+            if (!status) {
+                login();
+                return;
+            }
+            this.run(flow, [...status.args], env, home, (code, output) => {
+                const state = status.read(code, output);
+                if (state === "signed-in")
+                    this.finish(flow, "succeeded");
+                else if (state === "other")
+                    this.finish(flow, "failed", `${product} already has a different sign-in method on this server. Ask the server administrator to review it before changing accounts.`);
+                else if (state === "signed-out")
+                    login();
+                else
+                    this.finish(flow, "failed", `${product} could not confirm the existing sign-in on this server. Update ${product} and check its login status before trying again.`);
+            });
+        });
+    }
+    async get(flowId) {
+        if (!flowId || this.flow?.status.flowId !== flowId)
+            throw new Error("This sign-in is no longer available. Start sign-in again.");
+        return { ...this.flow.status };
+    }
+    async cancel() {
+        if (this.flow?.status.phase === "waiting")
+            this.finish(this.flow, "cancelled", `${this.spec.account} sign-in cancelled.`);
+        await this.flow?.stopping;
+        if (this.flow?.terminationFailed)
+            throw new Error(this.flow.status.message);
+        if (this.command && !await this.stopChild(this.command)) {
+            throw new Error(`${this.spec.product} could not be stopped on this server. Ask the server administrator to stop the account command before trying again.`);
+        }
+    }
+    async dispose() {
+        this.disposed = true;
+        await this.cancel();
+        this.flow = null;
+    }
+    /** Remove the sign-in the CLI stores for this server account so a
+     * different account can connect. A sign-in in progress is never pulled
+     * away underneath the browser completing it. */
+    async signOut() {
+        const { product, account, status, logoutArgs } = this.spec;
+        if (!status || !logoutArgs)
+            throw new Error(`Signing out of ${account} is not available from here.`);
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing out.");
+        if (this.flow?.status.phase === "waiting")
+            throw new Error(`Finish or cancel the ${account} sign-in in progress before signing out.`);
+        await this.flow?.stopping;
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing out.");
+        const env = this.options.environment();
+        const { home, homeKey } = this.home(env, "signing out");
+        if (authenticatingHomes.has(homeKey)) {
+            throw new Error(`A ${account} sign-in is running for this server account. Finish or cancel it before signing out.`);
+        }
+        authenticatingHomes.add(homeKey);
+        try {
+            const before = await this.exec([...status.args], env, home);
+            const state = status.read(before.code, before.output);
+            if (state === "signed-out")
+                return;
+            if (state !== "signed-in") {
+                throw new Error(`${product} did not confirm a ${account} sign-in. Other authentication methods will not be removed; ask the server administrator to check the account.`);
+            }
+            const logout = await this.exec([...logoutArgs], env, home);
+            if (logout.code !== 0)
+                throw new Error(`${product} could not remove the sign-in on this server. Check the server's ${product} installation and try again.`);
+            // The command's own report is not enough: confirm with the same status
+            // check that decides whether bots may run on this account.
+            const after = await this.exec([...status.args], env, home);
+            if (status.read(after.code, after.output) !== "signed-out") {
+                throw new Error(`${product} still reports a sign-in on this server. Update ${product} and check its login status before trying again.`);
+            }
+        }
+        finally {
+            // If the OS cannot stop a command, it may still change credentials.
+            // Keep the home reserved until that exact child actually exits.
+            const child = this.command;
+            if (child && child.exitCode === null && child.signalCode === null) {
+                child.once("close", () => authenticatingHomes.delete(homeKey));
+            }
+            else
+                authenticatingHomes.delete(homeKey);
+        }
+    }
+    /** After a login command succeeded: the status command when the CLI has
+     * one, else the stored sign-in a turn checks for. */
+    confirm(flow, env, home, done) {
+        const status = this.spec.status;
+        if (status) {
+            this.run(flow, [...status.args], env, home, (code, output) => done(status.read(code, output) === "signed-in"));
+            return;
+        }
+        let signedIn = false;
+        try {
+            signedIn = this.spec.signedIn?.(env) === true;
+        }
+        catch { /* unreadable: not signed in */ }
+        done(signedIn);
+    }
+    startFailure(error) {
+        const { product, install } = this.spec;
+        return error.code === "ENOENT"
+            ? `${product} is not installed on this server. ${install}`
+            : `${product} could not start on this server. Check the configured CLI path and its executable permissions.`;
+    }
+    /** One bounded, non-interactive command. Its output stays here; callers
+     * see an exit code and a status-line match, never the text. */
+    exec(args, env, cwd) {
+        const { product } = this.spec;
+        return new Promise((resolveExec, rejectExec) => {
+            if (this.disposed) {
+                rejectExec(new Error("This provider was removed. Refresh Settings before signing out."));
+                return;
+            }
+            let child;
+            try {
+                child = spawnCli(this.options.cli, args, { env: { ...env, NO_COLOR: "1" }, cwd, stdio: ["pipe", "pipe", "pipe"] });
+            }
+            catch {
+                rejectExec(new Error(`${product} could not start on this server. Install or update the configured ${product} CLI, then try again.`));
+                return;
+            }
+            this.command = child;
+            child.stdin.end();
+            let output = "";
+            const receive = (chunk) => {
+                if (output.length < MAX_OUTPUT)
+                    output += chunk.toString("utf8").slice(0, MAX_OUTPUT - output.length);
+            };
+            child.stdout.on("data", receive);
+            child.stderr.on("data", receive);
+            // A hung CLI must not hold the credential-home lock forever.
+            const timer = setTimeout(() => {
+                void this.stopChild(child).catch(() => false).then((stopped) => {
+                    if (!stopped)
+                        rejectExec(new Error(`${product} could not be stopped on this server. Ask the server administrator to stop the account command before trying again.`));
+                });
+            }, this.options.startupTimeoutMs ?? 30_000);
+            timer.unref();
+            child.once("error", (error) => {
+                clearTimeout(timer);
+                rejectExec(new Error(this.startFailure(error)));
+            });
+            child.once("close", (code) => {
+                clearTimeout(timer);
+                if (this.command === child)
+                    this.command = null;
+                resolveExec({ code, output: stripVTControlCharacters(output) });
+            });
+        });
+    }
+    run(flow, args, env, cwd, done, parsePrompt = false) {
+        const { product, provider } = this.spec;
+        if (flow.status.phase !== "waiting")
+            return;
+        let child;
+        try {
+            child = spawnCli(this.options.cli, args, { env: { ...env, NO_COLOR: "1" }, cwd, stdio: ["pipe", "pipe", "pipe"] });
+        }
+        catch {
+            this.finish(flow, "failed", `${product} could not start on this server. Install or update the configured ${product} CLI, then try again.`);
+            return;
+        }
+        flow.child = child;
+        child.stdin.end();
+        let output = "";
+        const receive = (chunk) => {
+            if (flow.status.phase !== "waiting")
+                return;
+            if (output.length + chunk.length > MAX_OUTPUT) {
+                this.finish(flow, "failed", `${product} returned an unexpected sign-in response. Update the server's ${product} CLI and try again.`);
+                return;
+            }
+            output += chunk.toString("utf8");
+            const prompt = parsePrompt && !flow.ready ? deviceSignInPrompt(provider, stripVTControlCharacters(output)) : null;
+            if (prompt) {
+                flow.status = { ...flow.status, ...prompt };
+                flow.ready = true;
+                clearTimeout(flow.startupTimer);
+                flow.resolve({ ...flow.status, phase: "waiting" });
+            }
+        };
+        child.stdout.on("data", receive);
+        child.stderr.on("data", receive);
+        child.once("error", (error) => this.finish(flow, "failed", this.startFailure(error)));
+        child.once("close", (code) => {
+            if (flow.child === child)
+                flow.child = null;
+            if (flow.status.phase === "waiting")
+                done(code, stripVTControlCharacters(output));
+            output = "";
+        });
+    }
+    finish(flow, phase, message) {
+        const { product, account } = this.spec;
+        if (flow.status.phase !== "waiting")
+            return;
+        clearTimeout(flow.startupTimer);
+        clearTimeout(flow.expiryTimer);
+        flow.status = {
+            phase, flowId: flow.status.flowId, authorizationUrl: null, expiresAt: null,
+            ...(phase !== "succeeded" && message ? { message } : {}),
+        };
+        if (!flow.ready) {
+            if (phase === "succeeded")
+                flow.resolve({ ...flow.status, phase });
+            else
+                flow.reject(new Error(message ?? `${account} sign-in did not finish.`));
+        }
+        flow.stopping = this.stopChild(flow.child).catch(() => false).then((stopped) => {
+            const release = () => authenticatingHomes.delete(flow.homeKey);
+            if (stopped) {
+                release();
+                return;
+            }
+            flow.terminationFailed = true;
+            flow.status = { ...flow.status, phase: "failed", message: `${product} could not be stopped on this server. Ask the server administrator to stop the login process before trying again.` };
+            // Retain the credential-home lock until the OS actually reports exit.
+            const child = flow.child;
+            if (!child || child.exitCode !== null || child.signalCode !== null)
+                release();
+            else
+                child.once("close", release);
+        });
+        if (phase === "succeeded")
+            void this.options.onAuthenticated?.().catch(() => { });
+    }
+    async stopChild(child) {
+        if (!child || await killCliTree(child, this.options.terminateTimeoutMs ?? 1500))
+            return true;
+        // A broken CLI may ignore SIGTERM. Do not leave a stale device flow able
+        // to write credentials after the user cancelled it.
+        if (process.platform !== "win32" && child.pid) {
+            try {
+                process.kill(-child.pid, "SIGKILL");
+            }
+            catch {
+                child.kill("SIGKILL");
+            }
+        }
+        else
+            child.kill("SIGKILL");
+        await new Promise((resolveStop) => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                return resolveStop();
+            const timer = setTimeout(resolveStop, 1500);
+            timer.unref();
+            child.once("close", () => { clearTimeout(timer); resolveStop(); });
+        });
+        return child.exitCode !== null || child.signalCode !== null;
+    }
+}

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

@@ -10,6 +10,8 @@ import { createChatToolApproval } from "./chat-tool-approval.js";
 import { ChatProtocolError, ChatReasoningDetails, ChatToolCalls, object } from "./openai-chat-protocol.js";
 import { appendNative } from "./native.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
+import { classifyContinuable, writeTurnHandoff } from "../turn-continuation.js";
+import { KEY_REJECTED_REASON, keyRejected, noteKeyAccepted, noteKeyRejected, rejectsKey } from "../key-rejections.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) {
@@ -87,6 +89,53 @@ function rejectsReasoningReplay(status, body) {
     return typeof message === "string" && /\breasoning_content\b/.test(message) &&
         /\b(?:unsupported|not supported|unknown|unrecognized|unexpected|not permitted|not allowed)\b/i.test(message);
 }
+/** Groq checks each generated tool call against the request and fails the
+ *  completion with `tool_use_failed` when the call is invalid: most often a
+ *  tool it was not offered (gpt-oss inventing a "json" tool to answer in
+ *  JSON), sometimes arguments that miss the schema. `refusal` is the
+ *  provider's whole error object, `failed_generation` included. */
+class RejectedToolCallError extends ChatProtocolError {
+    refusal;
+    constructor(message, refusal) {
+        super(message);
+        this.refusal = refusal;
+    }
+}
+const toolCallRefusal = (error) => {
+    const body = object(error);
+    return body?.code === "tool_use_failed" ? body : undefined;
+};
+function refusedToolCall(status, body) {
+    if (status !== 400)
+        return undefined;
+    try {
+        return toolCallRefusal(object(JSON.parse(body))?.error);
+    }
+    catch {
+        return undefined;
+    }
+}
+function completionError(json, label) {
+    const message = providerError(json);
+    if (!message)
+        return null;
+    const text = `provider returned a ${label}: ${message.slice(0, 200)}`;
+    const refusal = toolCallRefusal(json.error);
+    return refusal ? new RejectedToolCallError(text, refusal) : new ChatProtocolError(text);
+}
+/** What a failed turn says once the provider refused every attempt: what
+ *  happened, the next step, then the provider's words. The refused call ran
+ *  nothing, but tool calls from earlier steps of the turn did, and a Retry
+ *  of the whole request would repeat them. */
+function refusedToolCallFailure(error, earlierSteps) {
+    const words = typeof error.refusal.message === "string" ? error.refusal.message : error.message;
+    const tool = /attempted to call tool '([^']+)'/.exec(words)?.[1];
+    const what = tool ? `tried to use a tool it was not given ("${tool}")` : "made a tool call the provider rejected";
+    const next = earlierSteps
+        ? "The steps before it already ran, so ask only for what's left."
+        : "Nothing ran. Retry; if it keeps happening, rephrase the request or choose another model.";
+    return `The model ${what}. ${next} Provider: ${words.slice(0, 200)}`;
+}
 /** Shared runtime for the three providers that speak OpenAI chat completions. */
 export function createOpenAIChatRuntime(options) {
     const { input } = options;
@@ -134,14 +183,20 @@ export function createOpenAIChatRuntime(options) {
             });
             if (!response.ok) {
                 const body = await response.text().catch(() => "");
+                if (rejectsKey(response.status, body))
+                    noteKeyRejected(options.apiUrl, options.apiKey);
                 const message = `${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`;
                 if (rejectsToolsParameter(response.status, body))
                     throw new UnsupportedChatToolsError(message);
+                const refusal = refusedToolCall(response.status, body);
+                if (refusal)
+                    throw new RejectedToolCallError(message, refusal);
                 if (messages.some((entry) => entry.reasoning_content !== undefined) && rejectsReasoningReplay(response.status, body)) {
                     throw new UnsupportedReasoningReplayError(message);
                 }
                 throw new Error(message);
             }
+            noteKeyAccepted(options.apiUrl, options.apiKey);
             if (!stream || response.headers.get("content-type")?.includes("application/json")) {
                 const json = await response.json();
                 if (onUsage) {
@@ -155,9 +210,9 @@ export function createOpenAIChatRuntime(options) {
                         costUsd: count(json.usage?.cost),
                     });
                 }
-                const bodyError = providerError(json);
+                const bodyError = completionError(json, "completion error");
                 if (bodyError)
-                    throw new ChatProtocolError(`provider returned a completion error: ${bodyError.slice(0, 200)}`);
+                    throw bodyError;
                 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");
@@ -219,9 +274,9 @@ export function createOpenAIChatRuntime(options) {
                         malformedFrame = true;
                     return false;
                 }
-                const chunkError = providerError(chunk);
+                const chunkError = completionError(chunk, "streaming completion error");
                 if (chunkError)
-                    throw new ChatProtocolError(`provider returned a streaming completion error: ${chunkError.slice(0, 200)}`);
+                    throw chunkError;
                 const choice = chunk.choices?.find((row) => row.index === undefined || row.index === 0);
                 const delta = choice?.delta;
                 if (object(delta))
@@ -271,9 +326,9 @@ export function createOpenAIChatRuntime(options) {
                             catch {
                                 body = undefined;
                             }
-                            const bodyError = body ? providerError(body) : null;
+                            const bodyError = body ? completionError(body, "completion error") : null;
                             if (bodyError)
-                                throw new ChatProtocolError(`provider returned a completion error: ${bodyError.slice(0, 200)}`);
+                                throw bodyError;
                         }
                         throw new ChatProtocolError("Stream ended before completion");
                     }
@@ -411,7 +466,7 @@ export function createOpenAIChatRuntime(options) {
                 if (!parsed.ok)
                     throw new Error(parsed.error);
                 const scope = parsed.scope;
-                tools = await mountChatTools(options.tools === false ? undefined : turn.integrations, abort.signal, options.computerUse, scope);
+                tools = await mountChatTools(options.tools === false ? undefined : turn.integrations, abort.signal, options.computerUse, scope, turn.mcpCallTimeoutMs);
                 const questionAllowed = options.tools !== false && allowsTool(scope, { kind: "native", name: ASK_USER_TOOL });
                 let optionalQuestionOnly = questionAllowed && tools.definitions.length === 0;
                 // The runtime's one built-in tool rides the same list: ask_user is
@@ -436,6 +491,7 @@ export function createOpenAIChatRuntime(options) {
                     let completion;
                     for (;;) {
                         let streamed = false;
+                        let answerStreamed = false;
                         const pending = { assistant_text: "", reasoning_text: "" };
                         const delta = (text, streamKind, flush = false) => {
                             let combined = pending[streamKind] + text;
@@ -464,6 +520,8 @@ export function createOpenAIChatRuntime(options) {
                         try {
                             completion = await complete(messages, model, true, abort.signal, (text, streamKind) => {
                                 streamed = true;
+                                if (streamKind === "assistant_text")
+                                    answerStreamed = true;
                                 delta(text, streamKind);
                             }, tools.definitions);
                             delta("", "assistant_text", true);
@@ -483,6 +541,20 @@ export function createOpenAIChatRuntime(options) {
                                     delete message.reasoning_content;
                                 continue;
                             }
+                            // A refused tool call ran nothing, so the same request goes
+                            // again; the model usually answers properly next time. Not once
+                            // answer text streamed: the phones' live bubble would join it to
+                            // the next attempt's. Streamed thinking stays thinking. Each
+                            // refusal, failed_generation included, goes to the native log.
+                            if (error instanceof RejectedToolCallError) {
+                                native("in", { refused: "tool_use_failed", attempt: attempt + 1, error: error.refusal });
+                                if (!answerStreamed && !abort.signal.aborted && attempt < RETRY_MAX_ATTEMPTS - 1) {
+                                    emit({ ...base(turn.threadId, turnId), type: "turn.retrying", attempt: ++attempt, delayMs: 0, reason: "tool_use_failed" });
+                                    continue;
+                                }
+                                if (!abort.signal.aborted)
+                                    throw new ChatProtocolError(refusedToolCallFailure(error, seenCalls.size > 0));
+                            }
                             // Only our optional question changed a previously plain request.
                             // A structured parameter rejection has executed nothing; never
                             // downgrade mounted tools, streamed output or a handled call.
@@ -526,6 +598,9 @@ export function createOpenAIChatRuntime(options) {
                             continue;
                         }
                         if (toolFailed) {
+                            // A failed or denied tool op ends the turn: the final answer is
+                            // not an execution receipt, and a person's "no" must never be
+                            // answered with a prompt to run the same thing again.
                             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.");
                         }
@@ -680,6 +755,27 @@ export function createOpenAIChatRuntime(options) {
                 if (failure && (!abort.signal.aborted || cleanupFailed)) {
                     emit({ ...base(turn.threadId, turnId), type: "runtime.error", message: failure, terminal: !abort.signal.aborted });
                 }
+                // Automatic continuity: a resumable terminal (budget cap or tool
+                // errors) persists a handoff and raises cap.exhausted so the harness
+                // can start a `Continue:` thread. Interruptions and provider config
+                // errors are excluded by classifyContinuable.
+                if (!ok && !abort.signal.aborted) {
+                    const continuable = classifyContinuable(stopReason, failure);
+                    if (continuable) {
+                        const handoffPath = writeTurnHandoff({
+                            threadId: turn.threadId,
+                            turnId,
+                            model,
+                            usage,
+                            hasUsage,
+                            failure,
+                            toolCalls: seenCalls.size,
+                            messages,
+                        });
+                        if (handoffPath)
+                            emit({ ...base(turn.threadId, turnId), type: "cap.exhausted", handoffPath, reason: continuable });
+                    }
+                }
                 active.delete(turn.threadId);
                 emit({ ...base(turn.threadId, turnId), type: "turn.completed", ok, stopReason, cost: null,
                     ...(hasUsage && (options.includeUsageInCompleted || seenCalls.size) ? { usage } : {}),
@@ -699,9 +795,13 @@ export function createOpenAIChatRuntime(options) {
             return options.models();
         },
         ...(options.refreshModels ? { refreshModels: options.refreshModels } : {}),
-        snapshot: async () => options.apiKey
-            ? { state: "available", authenticated: true, version: null, ...(options.billing ? { billing: options.billing } : {}) }
-            : { state: "unavailable", reason: options.unavailableReason },
+        snapshot: async () => {
+            if (!options.apiKey)
+                return { state: "unavailable", reason: options.unavailableReason };
+            if (keyRejected(options.apiUrl, options.apiKey))
+                return { state: "available", authenticated: false, reason: KEY_REJECTED_REASON, version: null };
+            return { state: "available", authenticated: true, version: null, ...(options.billing ? { billing: options.billing } : {}) };
+        },
         adapter: {
             provider: options.driverKind,
             capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false,