@steipete/oracle 0.9.0 → 0.11.0

package/dist/src/mcp/tools/sessions.js

@@ -1,21 +1,24 @@
-import { z } from 'zod';
-import { sessionStore } from '../../sessionStore.js';
-import { sessionsInputSchema } from '../types.js';
+import { z } from "zod";
+import { sessionStore } from "../../sessionStore.js";
+import { sessionsInputSchema } from "../types.js";
 const sessionsInputShape = {
     id: z
         .string()
         .optional()
-        .describe('Session id or slug. If set, returns a single session (use detail:true to include metadata/request).'),
-    hours: z.number().optional().describe('Look back this many hours when listing sessions (default: 24).'),
-    limit: z.number().optional().describe('Maximum sessions to return when listing (default: 100).'),
+        .describe("Session id or slug. If set, returns a single session (use detail:true to include metadata/request)."),
+    hours: z
+        .number()
+        .optional()
+        .describe("Look back this many hours when listing sessions (default: 24)."),
+    limit: z.number().optional().describe("Maximum sessions to return when listing (default: 100)."),
     includeAll: z
         .boolean()
         .optional()
-        .describe('Include sessions outside the time window when listing (mirrors `oracle status --all`).'),
+        .describe("Include sessions outside the time window when listing (mirrors `oracle status --all`)."),
     detail: z
         .boolean()
         .optional()
-        .describe('When id is set, include session metadata + stored request + full log text.'),
+        .describe("When id is set, include session metadata + stored request + full log text."),
 };
 const sessionsOutputShape = {
     entries: z
@@ -38,14 +41,14 @@ const sessionsOutputShape = {
         .optional(),
 };
 export function registerSessionsTool(server) {
-    server.registerTool('sessions', {
-        title: 'List or fetch oracle sessions',
-        description: 'Inspect Oracle session history stored under `ORACLE_HOME_DIR` (shared with the CLI). List recent sessions or fetch one by id/slug (optionally including metadata + request + log).',
+    server.registerTool("sessions", {
+        title: "List or fetch oracle sessions",
+        description: "Inspect Oracle session history stored under `ORACLE_HOME_DIR` (shared with the CLI). List recent sessions or fetch one by id/slug (optionally including metadata + request + log).",
         inputSchema: sessionsInputShape,
         outputSchema: sessionsOutputShape,
     }, async (input) => {
-        const textContent = (text) => [{ type: 'text', text }];
-        const { id, hours = 24, limit = 100, includeAll = false, detail = false } = sessionsInputSchema.parse(input);
+        const textContent = (text) => [{ type: "text", text }];
+        const { id, hours = 24, limit = 100, includeAll = false, detail = false, } = sessionsInputSchema.parse(input);
         if (id) {
             if (!detail) {
                 const metadata = await sessionStore.readSession(id);
@@ -53,7 +56,7 @@ export function registerSessionsTool(server) {
                     throw new Error(`Session "${id}" not found.`);
                 }
                 return {
-                    content: textContent(`${metadata.createdAt} | ${metadata.status} | ${metadata.model ?? 'n/a'} | ${metadata.id}`),
+                    content: textContent(`${metadata.createdAt} | ${metadata.status} | ${metadata.model ?? "n/a"} | ${metadata.id}`),
                     structuredContent: {
                         entries: [
                             {
@@ -81,12 +84,18 @@ export function registerSessionsTool(server) {
             };
         }
         const metas = await sessionStore.listSessions();
-        const { entries, truncated, total } = sessionStore.filterSessions(metas, { hours, includeAll, limit });
+        const { entries, truncated, total } = sessionStore.filterSessions(metas, {
+            hours,
+            includeAll,
+            limit,
+        });
         return {
             content: [
                 {
-                    type: 'text',
-                    text: entries.map((entry) => `${entry.createdAt} | ${entry.status} | ${entry.model ?? 'n/a'} | ${entry.id}`).join('\n'),
+                    type: "text",
+                    text: entries
+                        .map((entry) => `${entry.createdAt} | ${entry.status} | ${entry.model ?? "n/a"} | ${entry.id}`)
+                        .join("\n"),
                 },
             ],
             structuredContent: {

package/dist/src/mcp/types.js

@@ -1,15 +1,22 @@
-import { z } from 'zod';
+import { z } from "zod";
+export const CONSULT_PRESETS = ["chatgpt-pro-heavy"];
 export const consultInputSchema = z.object({
-    prompt: z.string().min(1, 'Prompt is required.'),
+    preset: z.enum(CONSULT_PRESETS).optional(),
+    prompt: z.string().min(1, "Prompt is required."),
     files: z.array(z.string()).default([]),
     model: z.string().optional(),
     models: z.array(z.string()).optional(),
-    engine: z.enum(['api', 'browser']).optional(),
+    engine: z.enum(["api", "browser"]).optional(),
     browserModelLabel: z.string().optional(),
-    browserAttachments: z.enum(['auto', 'never', 'always']).optional(),
+    browserAttachments: z.enum(["auto", "never", "always"]).optional(),
     browserBundleFiles: z.boolean().optional(),
-    browserThinkingTime: z.enum(['light', 'standard', 'extended', 'heavy']).optional(),
+    browserThinkingTime: z.enum(["light", "standard", "extended", "heavy"]).optional(),
+    browserModelStrategy: z.enum(["select", "current", "ignore"]).optional(),
+    browserResearchMode: z.enum(["deep"]).optional(),
+    browserArchive: z.enum(["auto", "always", "never"]).optional(),
+    browserFollowUps: z.array(z.string()).optional(),
     browserKeepBrowser: z.boolean().optional(),
+    dryRun: z.boolean().optional(),
     search: z.boolean().optional(),
     slug: z.string().optional(),
 });

package/dist/src/mcp/utils.js

@@ -1,25 +1,38 @@
-import { resolveRunOptionsFromConfig } from '../cli/runOptions.js';
-import { Launcher } from 'chrome-launcher';
-export function mapConsultToRunOptions({ prompt, files, model, models, engine, search, browserAttachments, browserBundleFiles, userConfig, env = process.env, }) {
+import { resolveRunOptionsFromConfig } from "../cli/runOptions.js";
+import { Launcher } from "chrome-launcher";
+export function mapConsultToRunOptions({ prompt, files, model, models, engine, search, browserAttachments, browserBundleFiles, browserFollowUps, userConfig, env = process.env, }) {
     // Normalize CLI-style inputs through the shared resolver so config/env defaults apply,
     // then overlay MCP-only overrides such as explicit search toggles.
     const mergedModels = Array.isArray(models) && models.length > 0
         ? [model, ...models].filter((entry) => Boolean(entry?.trim()))
         : models;
-    const result = resolveRunOptionsFromConfig({ prompt, files, model, models: mergedModels, engine, userConfig, env });
-    if (typeof search === 'boolean') {
+    const result = resolveRunOptionsFromConfig({
+        prompt,
+        files,
+        model,
+        models: mergedModels,
+        engine,
+        userConfig,
+        env,
+    });
+    if (typeof search === "boolean") {
         result.runOptions.search = search;
     }
     if (browserAttachments) {
         result.runOptions.browserAttachments = browserAttachments;
     }
-    if (typeof browserBundleFiles === 'boolean') {
+    if (typeof browserBundleFiles === "boolean") {
         result.runOptions.browserBundleFiles = browserBundleFiles;
     }
+    if (Array.isArray(browserFollowUps)) {
+        result.runOptions.browserFollowUps = browserFollowUps
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
     return result;
 }
 export function ensureBrowserAvailable(engine, options) {
-    if (engine !== 'browser') {
+    if (engine !== "browser") {
         return null;
     }
     const remoteHost = options?.remoteHost?.trim() || process.env.ORACLE_REMOTE_HOST?.trim();
@@ -31,7 +44,7 @@ export function ensureBrowserAvailable(engine, options) {
     }
     const found = Launcher.getFirstInstallation();
     if (!found) {
-        return 'Browser engine unavailable: no Chrome installation found and CHROME_PATH is unset.';
+        return "Browser engine unavailable: no Chrome installation found and CHROME_PATH is unset.";
     }
     return null;
 }

package/dist/src/oracle/background.js

@@ -1,8 +1,8 @@
-import { APIConnectionError, APIConnectionTimeoutError } from 'openai';
-import chalk from 'chalk';
-import { formatElapsed } from './format.js';
-import { startHeartbeat } from '../heartbeat.js';
-import { OracleResponseError, OracleTransportError, describeTransportError, toTransportError, } from './errors.js';
+import { APIConnectionError, APIConnectionTimeoutError } from "openai";
+import chalk from "chalk";
+import { formatElapsed } from "./format.js";
+import { startHeartbeat } from "../heartbeat.js";
+import { OracleResponseError, OracleTransportError, describeTransportError, toTransportError, } from "./errors.js";
 const BACKGROUND_POLL_INTERVAL_MS = 5000;
 const BACKGROUND_RETRY_BASE_MS = 3000;
 const BACKGROUND_RETRY_MAX_MS = 15000;
@@ -18,10 +18,10 @@ export async function executeBackgroundResponse(params) {
         throw transportError;
     }
     if (!initialResponse || !initialResponse.id) {
-        throw new OracleResponseError('API did not return a response ID for the background run.', initialResponse);
+        throw new OracleResponseError("API did not return a response ID for the background run.", initialResponse);
     }
     const responseId = initialResponse.id;
-    log(chalk.dim(`API scheduled background response ${responseId} (status=${initialResponse.status ?? 'unknown'}). Monitoring up to ${Math.round(maxWaitMs / 60000)} minutes for completion...`));
+    log(chalk.dim(`API scheduled background response ${responseId} (status=${initialResponse.status ?? "unknown"}). Monitoring up to ${Math.round(maxWaitMs / 60000)} minutes for completion...`));
     let heartbeatActive = false;
     let stopHeartbeat = null;
     const stopHeartbeatNow = () => {
@@ -66,29 +66,29 @@ async function pollBackgroundResponse(params) {
     let lastStatus = response.status;
     // biome-ignore lint/nursery/noUnnecessaryConditions: intentional polling loop.
     while (true) {
-        const status = response.status ?? 'completed';
+        const status = response.status ?? "completed";
         // firstCycle toggles immediately; keep for clarity in logs.
         if (firstCycle) {
             firstCycle = false;
             log(chalk.dim(`API background response status=${status}. We'll keep retrying automatically.`));
         }
-        else if (status !== lastStatus && status !== 'completed') {
+        else if (status !== lastStatus && status !== "completed") {
             log(chalk.dim(`API background response status=${status}.`));
         }
         lastStatus = status;
-        if (status === 'completed') {
+        if (status === "completed") {
             return response;
         }
-        if (status !== 'in_progress' && status !== 'queued') {
+        if (status !== "in_progress" && status !== "queued") {
             const detail = response.error?.message || response.incomplete_details?.reason || status;
             throw new OracleResponseError(`Response did not complete: ${detail}`, response);
         }
         if (now() - startMark >= maxWaitMs) {
-            throw new OracleTransportError('client-timeout', 'Timed out waiting for API background response to finish.');
+            throw new OracleTransportError("client-timeout", "Timed out waiting for API background response to finish.");
         }
         await wait(BACKGROUND_POLL_INTERVAL_MS);
         if (now() - startMark >= maxWaitMs) {
-            throw new OracleTransportError('client-timeout', 'Timed out waiting for API background response to finish.');
+            throw new OracleTransportError("client-timeout", "Timed out waiting for API background response to finish.");
         }
         const { response: nextResponse, reconnected } = await retrieveBackgroundResponseWithRetry({
             client,
@@ -100,7 +100,7 @@ async function pollBackgroundResponse(params) {
             log,
         });
         if (reconnected) {
-            const nextStatus = nextResponse.status ?? 'in_progress';
+            const nextStatus = nextResponse.status ?? "in_progress";
             log(chalk.dim(`Reconnected to API background response (status=${nextStatus}). API is still working...`));
         }
         response = nextResponse;
@@ -125,7 +125,7 @@ async function retrieveBackgroundResponseWithRetry(params) {
             log(chalk.yellow(`${describeTransportError(transportError, maxWaitMs)} Retrying in ${formatElapsed(delay)}...`));
             await wait(delay);
             if (now() - startMark >= maxWaitMs) {
-                throw new OracleTransportError('client-timeout', 'Timed out waiting for API background response to finish.');
+                throw new OracleTransportError("client-timeout", "Timed out waiting for API background response to finish.");
             }
         }
     }

package/dist/src/oracle/claude.js

@@ -1,11 +1,11 @@
-const DEFAULT_CLAUDE_ENDPOINT = 'https://api.anthropic.com/v1/messages';
-const ANTHROPIC_VERSION = '2023-06-01';
+const DEFAULT_CLAUDE_ENDPOINT = "https://api.anthropic.com/v1/messages";
+const ANTHROPIC_VERSION = "2023-06-01";
 function extractPrompt(body) {
     const first = body.input?.[0]?.content?.[0];
-    if (first && first.type === 'input_text') {
-        return first.text ?? '';
+    if (first && first.type === "input_text") {
+        return first.text ?? "";
     }
-    return '';
+    return "";
 }
 async function callClaude({ apiKey, model, prompt, endpoint, stream = false, }) {
     const url = endpoint?.trim() || DEFAULT_CLAUDE_ENDPOINT;
@@ -14,34 +14,45 @@ async function callClaude({ apiKey, model, prompt, endpoint, stream = false, })
         max_tokens: 2048,
         messages: [
             {
-                role: 'user',
+                role: "user",
                 content: prompt,
             },
         ],
         stream,
     };
     return fetch(url, {
-        method: 'POST',
+        method: "POST",
         headers: {
-            'content-type': 'application/json',
-            'x-api-key': apiKey,
-            'anthropic-version': ANTHROPIC_VERSION,
+            "content-type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": ANTHROPIC_VERSION,
         },
         body: JSON.stringify(payload),
     });
 }
 async function parseClaudeResponse(raw) {
-    const json = (await raw.json());
+    const body = await raw.text();
+    if (!body.trim()) {
+        throw new Error(`Claude request failed (${raw.status} ${raw.statusText || "unknown status"}): empty response`);
+    }
+    let json;
+    try {
+        json = JSON.parse(body);
+    }
+    catch (error) {
+        const snippet = body.slice(0, 160).replace(/\s+/g, " ").trim();
+        throw new Error(`Claude request failed (${raw.status} ${raw.statusText || "unknown status"}): invalid JSON response${snippet ? `: ${snippet}` : ""}`, { cause: error });
+    }
     if (json.error) {
-        throw new Error(json.error.message || 'Claude request failed');
+        throw new Error(json.error.message || "Claude request failed");
     }
-    const textParts = json.content?.map((part) => part.text ?? '').filter(Boolean) ?? [];
-    const outputText = textParts.join('');
+    const textParts = json.content?.map((part) => part.text ?? "").filter(Boolean) ?? [];
+    const outputText = textParts.join("");
     return {
         id: json.id ?? `claude-${Date.now()}`,
-        status: 'completed',
+        status: "completed",
         output_text: [outputText],
-        output: [{ type: 'text', text: outputText }],
+        output: [{ type: "text", text: outputText }],
         usage: {
             input_tokens: json.usage?.input_tokens ?? 0,
             output_tokens: json.usage?.output_tokens ?? 0,
@@ -53,11 +64,17 @@ export function createClaudeClient(apiKey, modelName, resolvedModelId, baseUrl)
     const modelId = resolveClaudeModelId(resolvedModelId ?? modelName);
     const stream = async (body) => {
         const prompt = extractPrompt(body);
-        const resp = await callClaude({ apiKey, model: modelId, prompt, stream: false, endpoint: baseUrl });
+        const resp = await callClaude({
+            apiKey,
+            model: modelId,
+            prompt,
+            stream: false,
+            endpoint: baseUrl,
+        });
         const parsed = await parseClaudeResponse(resp);
         const iterator = async function* () {
             if (parsed.output_text?.[0]) {
-                yield { type: 'response.output_text.delta', delta: parsed.output_text[0] };
+                yield { type: "response.output_text.delta", delta: parsed.output_text[0] };
             }
             return;
         };
@@ -68,13 +85,19 @@ export function createClaudeClient(apiKey, modelName, resolvedModelId, baseUrl)
     };
     const create = async (body) => {
         const prompt = extractPrompt(body);
-        const resp = await callClaude({ apiKey, model: modelId, prompt, stream: false, endpoint: baseUrl });
+        const resp = await callClaude({
+            apiKey,
+            model: modelId,
+            prompt,
+            stream: false,
+            endpoint: baseUrl,
+        });
         return parseClaudeResponse(resp);
     };
     const retrieve = async (id) => ({
         id,
-        status: 'error',
-        error: { message: 'Retrieve by ID not supported for Claude API yet.' },
+        status: "error",
+        error: { message: "Retrieve by ID not supported for Claude API yet." },
     });
     return {
         responses: {
@@ -85,11 +108,16 @@ export function createClaudeClient(apiKey, modelName, resolvedModelId, baseUrl)
     };
 }
 export function resolveClaudeModelId(modelName) {
-    if (modelName === 'claude-4.5-sonnet' || modelName === 'claude-sonnet-4-5-20241022') {
-        return 'claude-sonnet-4-5';
+    if (modelName === "claude-4.6-sonnet" || modelName === "claude-sonnet-4-6") {
+        return "claude-sonnet-4-6";
+    }
+    if (modelName === "claude-4.5-sonnet" ||
+        modelName === "claude-sonnet-4-5" ||
+        modelName === "claude-sonnet-4-5-20250929") {
+        return "claude-sonnet-4-5";
     }
-    if (modelName === 'claude-4.1-opus' || modelName === 'claude-opus-4-1-20240808') {
-        return 'claude-opus-4-1';
+    if (modelName === "claude-4.1-opus" || modelName === "claude-opus-4-1-20240808") {
+        return "claude-opus-4-1";
     }
     return modelName;
 }

package/dist/src/oracle/client.js

@@ -1,19 +1,19 @@
-import OpenAI from 'openai';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-import { createGeminiClient } from './gemini.js';
-import { createClaudeClient } from './claude.js';
-import { isOpenRouterBaseUrl } from './modelResolver.js';
+import OpenAI from "openai";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { createGeminiClient } from "./gemini.js";
+import { createClaudeClient } from "./claude.js";
+import { isOpenRouterBaseUrl } from "./modelResolver.js";
 /**
  * Known native API base URLs that should still use their dedicated SDKs.
  * Any other custom base URL is treated as an OpenAI-compatible proxy and
  * all models are routed through the chat/completions adapter.
  */
 const NATIVE_API_HOSTS = [
-    'api.openai.com',
-    'api.anthropic.com',
-    'generativelanguage.googleapis.com',
-    'api.x.ai',
+    "api.openai.com",
+    "api.anthropic.com",
+    "generativelanguage.googleapis.com",
+    "api.x.ai",
 ];
 export function isCustomBaseUrl(baseUrl) {
     if (!baseUrl)
@@ -27,7 +27,7 @@ export function isCustomBaseUrl(baseUrl) {
     }
 }
 export function buildAzureResponsesBaseUrl(endpoint) {
-    return `${endpoint.replace(/\/+$/, '')}/openai/v1`;
+    return `${endpoint.replace(/\/+$/, "")}/openai/v1`;
 }
 export function createDefaultClientFactory() {
     const customFactory = loadCustomClientFactory();
@@ -40,17 +40,21 @@ export function createDefaultClientFactory() {
         // route ALL models through the OpenAI chat/completions adapter instead of native SDKs
         // which would reject the proxy's API key.
         if (!openRouter && !customProxy) {
-            if (options?.model?.startsWith('gemini')) {
+            if (options?.model?.startsWith("gemini")) {
                 // Gemini client uses its own SDK; allow passing the already-resolved id for transparency/logging.
                 return createGeminiClient(key, options.model, options.resolvedModelId);
             }
-            if (options?.model?.startsWith('claude')) {
+            if (options?.model?.startsWith("claude")) {
                 return createClaudeClient(key, options.model, options.resolvedModelId, options.baseUrl);
             }
         }
         let instance;
-        const defaultHeaders = openRouter ? buildOpenRouterHeaders() : undefined;
-        const httpTimeoutMs = typeof options?.httpTimeoutMs === 'number' && Number.isFinite(options.httpTimeoutMs) && options.httpTimeoutMs > 0
+        const defaultHeaders = openRouter
+            ? buildOpenRouterHeaders()
+            : undefined;
+        const httpTimeoutMs = typeof options?.httpTimeoutMs === "number" &&
+            Number.isFinite(options.httpTimeoutMs) &&
+            options.httpTimeoutMs > 0
             ? options.httpTimeoutMs
             : 20 * 60 * 1000;
         if (options?.azure?.endpoint) {
@@ -82,13 +86,15 @@ export function createDefaultClientFactory() {
 }
 function buildOpenRouterHeaders() {
     const headers = {};
-    const referer = process.env.OPENROUTER_REFERER ?? process.env.OPENROUTER_HTTP_REFERER ?? 'https://github.com/steipete/oracle';
-    const title = process.env.OPENROUTER_TITLE ?? 'Oracle CLI';
+    const referer = process.env.OPENROUTER_REFERER ??
+        process.env.OPENROUTER_HTTP_REFERER ??
+        "https://github.com/steipete/oracle";
+    const title = process.env.OPENROUTER_TITLE ?? "Oracle CLI";
     if (referer) {
-        headers['HTTP-Referer'] = referer;
+        headers["HTTP-Referer"] = referer;
     }
     if (title) {
-        headers['X-Title'] = title;
+        headers["X-Title"] = title;
     }
     return headers;
 }
@@ -97,19 +103,19 @@ function loadCustomClientFactory() {
     if (!override) {
         return null;
     }
-    if (override === 'INLINE_TEST_FACTORY') {
+    if (override === "INLINE_TEST_FACTORY") {
         return () => ({
             responses: {
-                create: async () => ({ id: 'inline-test', status: 'completed' }),
+                create: async () => ({ id: "inline-test", status: "completed" }),
                 stream: async () => ({
                     [Symbol.asyncIterator]: () => ({
                         async next() {
                             return { done: true, value: undefined };
                         },
                     }),
-                    finalResponse: async () => ({ id: 'inline-test', status: 'completed' }),
+                    finalResponse: async () => ({ id: "inline-test", status: "completed" }),
                 }),
-                retrieve: async (id) => ({ id, status: 'completed' }),
+                retrieve: async (id) => ({ id, status: "completed" }),
             },
         });
     }
@@ -117,14 +123,14 @@ function loadCustomClientFactory() {
         const require = createRequire(import.meta.url);
         const resolved = path.isAbsolute(override) ? override : path.resolve(process.cwd(), override);
         const moduleExports = require(resolved);
-        const factory = typeof moduleExports === 'function'
+        const factory = typeof moduleExports === "function"
             ? moduleExports
-            : typeof moduleExports?.default === 'function'
+            : typeof moduleExports?.default === "function"
                 ? moduleExports.default
-                : typeof moduleExports?.createClientFactory === 'function'
+                : typeof moduleExports?.createClientFactory === "function"
                     ? moduleExports.createClientFactory
                     : null;
-        if (typeof factory === 'function') {
+        if (typeof factory === "function") {
             return factory;
         }
         console.warn(`Custom client factory at ${resolved} did not export a function.`);
@@ -140,14 +146,17 @@ function buildOpenRouterCompletionClient(instance) {
     const adaptRequest = (body) => {
         const messages = [];
         if (body.instructions) {
-            messages.push({ role: 'system', content: body.instructions });
+            messages.push({ role: "system", content: body.instructions });
         }
         for (const entry of body.input) {
             const textParts = entry.content
-                .map((c) => (c.type === 'input_text' ? c.text : ''))
+                .map((c) => (c.type === "input_text" ? c.text : ""))
                 .filter((t) => t)
-                .join('\n\n');
-            messages.push({ role: entry.role ?? 'user', content: textParts });
+                .join("\n\n");
+            messages.push({
+                role: entry.role ?? "user",
+                content: textParts,
+            });
         }
         const base = {
             model: body.model,
@@ -159,7 +168,7 @@ function buildOpenRouterCompletionClient(instance) {
         return { streaming, nonStreaming };
     };
     const adaptResponse = (response) => {
-        const text = response.choices?.[0]?.message?.content ?? '';
+        const text = response.choices?.[0]?.message?.content ?? "";
         const usage = {
             input_tokens: response.usage?.prompt_tokens ?? 0,
             output_tokens: response.usage?.completion_tokens ?? 0,
@@ -167,9 +176,9 @@ function buildOpenRouterCompletionClient(instance) {
         };
         return {
             id: response.id ?? `openrouter-${Date.now()}`,
-            status: 'completed',
+            status: "completed",
             output_text: [text],
-            output: [{ type: 'text', text }],
+            output: [{ type: "text", text }],
             usage,
         };
     };
@@ -177,15 +186,15 @@ function buildOpenRouterCompletionClient(instance) {
         const { streaming } = adaptRequest(body);
         let finalUsage;
         let finalId;
-        let aggregated = '';
+        let aggregated = "";
         async function* iterator() {
             const completion = await instance.chat.completions.create(streaming);
             for await (const chunk of completion) {
                 finalId = chunk.id ?? finalId;
-                const delta = chunk.choices?.[0]?.delta?.content ?? '';
+                const delta = chunk.choices?.[0]?.delta?.content ?? "";
                 if (delta) {
                     aggregated += delta;
-                    yield { type: 'chunk', delta };
+                    yield { type: "chunk", delta };
                 }
                 if (chunk.usage) {
                     finalUsage = chunk.usage;
@@ -200,11 +209,11 @@ function buildOpenRouterCompletionClient(instance) {
             async finalResponse() {
                 return adaptResponse({
                     id: finalId ?? `openrouter-${Date.now()}`,
-                    choices: [{ message: { role: 'assistant', content: aggregated } }],
+                    choices: [{ message: { role: "assistant", content: aggregated } }],
                     usage: finalUsage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
                     created: Math.floor(Date.now() / 1000),
-                    model: '',
-                    object: 'chat.completion',
+                    model: "",
+                    object: "chat.completion",
                 });
             },
         };
@@ -219,7 +228,7 @@ function buildOpenRouterCompletionClient(instance) {
             stream,
             create,
             retrieve: async () => {
-                throw new Error('retrieve is not supported for OpenRouter chat/completions fallback.');
+                throw new Error("retrieve is not supported for OpenRouter chat/completions fallback.");
             },
         },
     };