@stabgan/openrouter-mcp-multimodal 4.6.1 → 4.7.0

package/dist/tool-handlers/generate-image.d.ts

@@ -14,49 +14,6 @@ export declare function handleGenerateImage(request: {
         arguments: GenerateImageToolRequest;
     };
 }, openai: OpenAI): Promise<import("../errors.js").ToolErrorResult | {
-    content: ({
-        type: "text";
-        text: string;
-        mimeType?: undefined;
-        data?: undefined;
-    } | {
-        type: "image";
-        mimeType: string;
-        data: string;
-        text?: undefined;
-    })[];
-    _meta: {
-        usage: {
-            prompt_tokens: number;
-            completion_tokens: number;
-            total_tokens: number;
-        };
-        server_version: string;
-        save_path: string;
-        mime: string;
-    } | {
-        usage?: undefined;
-        server_version: string;
-        save_path: string;
-        mime: string;
-    };
-} | {
-    content: {
-        type: "image";
-        mimeType: string;
-        data: string;
-    }[];
-    _meta: {
-        usage: {
-            prompt_tokens: number;
-            completion_tokens: number;
-            total_tokens: number;
-        };
-        server_version: string;
-        mime: string;
-    } | {
-        usage?: undefined;
-        server_version: string;
-        mime: string;
-    };
+    content: import("./tool-result-payload.js").BinaryToolContent[];
+    _meta: Record<string, unknown>;
 }>;

package/dist/tool-handlers/generate-image.js

@@ -1,11 +1,13 @@
-import { promises as fs } from 'fs';
-import { resolveSafeOutputPath, UnsafeOutputPathError } from './path-safety.js';
+import { promises as fs } from 'node:fs';
+import { resolveOptionalOutputPath, isToolErrorResult, UnsafeOutputPathError, } from './path-safety.js';
 import { parseBase64DataUrl } from './fetch-utils.js';
 import { buildUserContent } from './generate-image-input.js';
+import { asOpenAIChatBody } from './chat-request.js';
 import { ErrorCode, toolError, toolErrorFrom } from '../errors.js';
 import { SERVER_VERSION } from '../version.js';
 import { logger } from '../logger.js';
 import { classifyUpstreamError } from './openrouter-errors.js';
+import { buildBinaryToolResult } from './tool-result-payload.js';
 const DEFAULT_MODEL = 'google/gemini-2.5-flash-image';
 const VALID_ASPECT_RATIOS = new Set([
     '1:1',
@@ -43,18 +45,10 @@ export async function handleGenerateImage(request, openai) {
     if (image_size !== undefined && !VALID_IMAGE_SIZES.has(image_size)) {
         return invalidEnumError('image_size', image_size, VALID_IMAGE_SIZES);
     }
-    let safePathResolved = null;
-    if (save_path) {
-        try {
-            safePathResolved = await resolveSafeOutputPath(save_path);
-        }
-        catch (err) {
-            if (err instanceof UnsafeOutputPathError) {
-                return toolErrorFrom(ErrorCode.UNSAFE_PATH, err);
-            }
-            return toolErrorFrom(ErrorCode.INTERNAL, err);
-        }
-    }
+    const savePathResult = await resolveOptionalOutputPath(save_path);
+    if (isToolErrorResult(savePathResult))
+        return savePathResult;
+    const safePathResolved = savePathResult.path;
     let content;
     try {
         content = await buildUserContent(prompt, input_images);
@@ -81,7 +75,7 @@ export async function handleGenerateImage(request, openai) {
         body.max_tokens = max_tokens;
     let completion;
     try {
-        completion = (await openai.chat.completions.create(body));
+        completion = (await openai.chat.completions.create(asOpenAIChatBody(body)));
     }
     catch (err) {
         return classifyUpstreamError(err, 'generate_image');
@@ -122,28 +116,13 @@ function buildImageSuccessResult(base64, usage, savePath) {
             },
         }
         : {};
-    if (savePath) {
-        return {
-            content: [
-                { type: 'text', text: `Image saved to: ${savePath}` },
-                { type: 'image', mimeType: base64.mime, data: base64.data },
-            ],
-            _meta: {
-                server_version: SERVER_VERSION,
-                save_path: savePath,
-                mime: base64.mime,
-                ...usageMeta,
-            },
-        };
-    }
-    return {
-        content: [{ type: 'image', mimeType: base64.mime, data: base64.data }],
-        _meta: {
-            server_version: SERVER_VERSION,
-            mime: base64.mime,
-            ...usageMeta,
-        },
-    };
+    const buffer = Buffer.from(base64.data, 'base64');
+    return buildBinaryToolResult({ kind: 'image', buffer, mimeType: base64.mime }, {
+        savedPath: savePath ?? null,
+        inlineOnly: !savePath,
+        summaryText: savePath ? `Image saved to: ${savePath}` : undefined,
+        meta: { server_version: SERVER_VERSION, ...usageMeta },
+    });
 }
 function extractBase64(message) {
     const images = message.images;

package/dist/tool-handlers/generate-video.d.ts

@@ -72,13 +72,7 @@ export declare function handleGetVideoStatus(request: {
         progress: number | undefined;
     };
 }>;
-/**
- * Image-to-video convenience wrapper. Takes a single `image` argument
- * (first frame) and delegates to `handleGenerateVideo` with the broader
- * parameter surface hidden. Based on arxiv 2511.03497's finding that
- * tool-calling success degrades with parameter count — a narrower tool
- * gives the model a cleaner decision path.
- */
+/** Image-to-video wrapper — delegates to `handleGenerateVideo` with a narrower schema. */
 export interface GenerateVideoFromImageRequest {
     image: string;
     prompt: string;

package/dist/tool-handlers/generate-video.js

@@ -3,14 +3,15 @@ import { extname } from 'node:path';
 import { ErrorCode, toolError, toolErrorFrom } from '../errors.js';
 import { SERVER_VERSION } from '../version.js';
 import { logger } from '../logger.js';
-import { resolveSafeOutputPath, resolveSafeInputPath, UnsafeOutputPathError, } from './path-safety.js';
+import { resolveOptionalOutputPath, isToolErrorResult, UnsafeOutputPathError, } from './path-safety.js';
+import { resolveImageBase64 } from './image-source.js';
 import { readEnvInt } from './fetch-utils.js';
 import { classifyUpstreamError } from './openrouter-errors.js';
+import { buildBinaryToolResult } from './tool-result-payload.js';
 const FALLBACK_MODEL = 'google/veo-3.1';
 const DEFAULT_POLL_INTERVAL_MS = 15_000;
 const DEFAULT_MAX_WAIT_MS = 10 * 60_000;
 const MIN_POLL_INTERVAL_MS = 50; // just to avoid a 0ms busy-loop if a caller omits
-const INLINE_RETURN_CEILING_BYTES = 10 * 1024 * 1024;
 /** Models deprecated by OpenAI — removal date: 2026-09-24. */
 const SORA_DEPRECATED_MODELS = new Set([
     'openai/sora-2',
@@ -26,10 +27,7 @@ const SORA_ALTERNATIVES = [
     'bytedance/seedance-2.0-fast (fast turnaround)',
     'alibaba/wan-2.7 (good for artistic styles)',
 ];
-/**
- * Check if the model is a deprecated Sora model and return a warning string,
- * or null if no deprecation applies.
- */
+/** Return a deprecation warning for Sora models, or null. */
 function checkSoraDeprecation(model) {
     const normalized = model.toLowerCase().trim();
     if (!SORA_DEPRECATED_MODELS.has(normalized) && !normalized.startsWith('openai/sora')) {
@@ -39,9 +37,6 @@ function checkSoraDeprecation(model) {
         `Your request will still be attempted, but may fail. Recommended alternatives:\n` +
         SORA_ALTERNATIVES.map((a) => `  • ${a}`).join('\n'));
 }
-function getMaxInlineBytes() {
-    return readEnvInt('OPENROUTER_VIDEO_INLINE_MAX_BYTES', INLINE_RETURN_CEILING_BYTES, 4096);
-}
 function getDefaultPollInterval() {
     return readEnvInt('OPENROUTER_VIDEO_POLL_INTERVAL_MS', DEFAULT_POLL_INTERVAL_MS, MIN_POLL_INTERVAL_MS);
 }
@@ -49,57 +44,19 @@ function getDefaultMaxWait() {
     return readEnvInt('OPENROUTER_VIDEO_MAX_WAIT_MS', DEFAULT_MAX_WAIT_MS, 10_000);
 }
 function getMaxDownloadBytes() {
-    // Generation output can be bigger than the input cap since it's our own
-    // content. Default 256 MB, override via env.
     return readEnvInt('OPENROUTER_VIDEO_GEN_MAX_BYTES', 256 * 1024 * 1024, 1024 * 1024);
 }
-/**
- * Fold a caller-supplied image source (local path, http URL, or data URL)
- * into the `{ url: "data:video|image/...base64,..." }` shape OpenRouter
- * expects inside `frame_images[].image` / `input_references[]`.
- *
- * We reuse `prepareVideoData` for videos but images live in `image-utils`.
- * Since generate_video's references are images, not videos, we do a small
- * image-specific fetch here (data URL pass-through, HTTP via fetch-utils,
- * local via fs). We deliberately do NOT run them through sharp — the model
- * wants the pristine frame.
- */
-async function prepareImageInput(source) {
+async function imageFrameEntry(source, frameType) {
     if (!source)
         return null;
-    if (source.startsWith('data:')) {
-        const match = source.match(/^data:([^;,]+)(?:;[^,]*)*;base64,(.+)$/);
-        if (!match)
-            throw new Error(`Invalid image data URL: ${source.slice(0, 40)}…`);
-        return { mime: match[1], data: match[2] };
-    }
-    if (source.startsWith('http://') || source.startsWith('https://')) {
-        const { fetchHttpResource } = await import('./fetch-utils.js');
-        const { buffer, contentType } = await fetchHttpResource(source, {
-            timeoutMs: 30_000,
-            maxBytes: 25 * 1024 * 1024,
-            maxRedirects: 8,
-        });
-        const mime = (contentType?.split(';')[0]?.trim() || 'image/jpeg').toLowerCase();
-        return { mime, data: buffer.toString('base64') };
-    }
-    // Local file: sandbox via path-safety's resolveSafeInputPath so
-    // generate_video's first_frame_image / last_frame_image /
-    // reference_images fields enforce the same OPENROUTER_INPUT_DIR
-    // / OPENROUTER_OUTPUT_DIR / cwd scope that generate_image's
-    // input_images already uses. Callers can still bypass with
-    // OPENROUTER_ALLOW_UNSAFE_PATHS=1 for legacy scripts.
-    const abs = await resolveSafeInputPath(source);
-    const buf = await fs.readFile(abs);
-    const ext = extname(abs).toLowerCase();
-    const mime = ext === '.png'
-        ? 'image/png'
-        : ext === '.webp'
-            ? 'image/webp'
-            : ext === '.gif'
-                ? 'image/gif'
-                : 'image/jpeg';
-    return { mime, data: buf.toString('base64') };
+    const img = await resolveImageBase64(source);
+    const entry = {
+        type: 'image_url',
+        image_url: { url: `data:${img.mime};base64,${img.data}` },
+    };
+    if (frameType)
+        entry.frame_type = frameType;
+    return { kind: 'frame', entry };
 }
 function buildRequestBody(args, model) {
     const body = { model, prompt: args.prompt };
@@ -118,28 +75,10 @@ function buildRequestBody(args, model) {
 async function attachFrameImages(args, body) {
     const frameTasks = [];
     if (args.first_frame_image) {
-        frameTasks.push(prepareImageInput(args.first_frame_image).then((img) => img
-            ? {
-                kind: 'frame',
-                entry: {
-                    type: 'image_url',
-                    image_url: { url: `data:${img.mime};base64,${img.data}` },
-                    frame_type: 'first_frame',
-                },
-            }
-            : null));
+        frameTasks.push(imageFrameEntry(args.first_frame_image, 'first_frame'));
     }
     if (args.last_frame_image) {
-        frameTasks.push(prepareImageInput(args.last_frame_image).then((img) => img
-            ? {
-                kind: 'frame',
-                entry: {
-                    type: 'image_url',
-                    image_url: { url: `data:${img.mime};base64,${img.data}` },
-                    frame_type: 'last_frame',
-                },
-            }
-            : null));
+        frameTasks.push(imageFrameEntry(args.last_frame_image, 'last_frame'));
     }
     const frameResults = await Promise.all(frameTasks);
     const frameImages = frameResults
@@ -148,10 +87,8 @@ async function attachFrameImages(args, body) {
     if (frameImages.length)
         body.frame_images = frameImages;
     if (args.reference_images?.length) {
-        const refResults = await Promise.all(args.reference_images.map((src) => prepareImageInput(src)));
-        const refs = refResults
-            .filter((img) => img !== null)
-            .map((img) => ({
+        const refResults = await Promise.all(args.reference_images.map((src) => resolveImageBase64(src)));
+        const refs = refResults.map((img) => ({
             type: 'image_url',
             image_url: { url: `data:${img.mime};base64,${img.data}` },
         }));
@@ -231,37 +168,16 @@ async function finalizeCompletedJob(apiClient, status, savePath) {
         await fs.writeFile(finalPath, buffer);
         baseMeta.save_path = finalPath;
         const summaryNote = finalPath !== savePath ? ` (detected ${mime}, saved as ${finalPath})` : '';
-        const content = [
-            { type: 'text', text: `Video saved to: ${finalPath}${summaryNote}` },
-        ];
-        if (buffer.length <= getMaxInlineBytes()) {
-            content.push({
-                type: 'video',
-                mimeType: mime,
-                data: buffer.toString('base64'),
-            });
-        }
-        return { content, _meta: baseMeta };
-    }
-    // No save_path — return inline if small enough, otherwise just the URL.
-    if (buffer.length <= getMaxInlineBytes()) {
-        return {
-            content: [
-                { type: 'text', text: `Video generated (${buffer.length} bytes, ${mime}).` },
-                { type: 'video', mimeType: mime, data: buffer.toString('base64') },
-            ],
-            _meta: baseMeta,
-        };
+        return buildBinaryToolResult({ kind: 'video', buffer, mimeType: mime }, {
+            savedPath: finalPath,
+            summaryText: `Video saved to: ${finalPath}${summaryNote}`,
+            meta: baseMeta,
+        });
     }
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `Video generated (${buffer.length} bytes, ${mime}). Too large to inline; pass save_path to persist. URL: ${url}`,
-            },
-        ],
-        _meta: baseMeta,
-    };
+    return buildBinaryToolResult({ kind: 'video', buffer, mimeType: mime }, {
+        remoteUrl: url,
+        meta: baseMeta,
+    });
 }
 function stripAndReplaceExt(p, newExt) {
     const cur = extname(p);
@@ -274,12 +190,7 @@ export async function handleGenerateVideo(request, apiClient, progress) {
         return toolError(ErrorCode.INVALID_INPUT, 'prompt is required.');
     }
     const model = args.model || process.env.OPENROUTER_DEFAULT_VIDEO_GEN_MODEL || FALLBACK_MODEL;
-    // Sora deprecation warning — OpenAI is removing the Videos API and all
-    // Sora 2 model aliases on September 24, 2026. Warn and suggest alternatives.
     const deprecationWarning = checkSoraDeprecation(model);
-    // Audit entry — video is the most expensive tool we have. Always log
-    // model, resolution, duration, and a safe prompt preview so unintended
-    // spend can be traced.
     logger.audit('generate_video.start', {
         model,
         prompt_preview: args.prompt.slice(0, 80),
@@ -291,25 +202,15 @@ export async function handleGenerateVideo(request, apiClient, progress) {
         reference_images: args.reference_images?.length ?? 0,
         save_path: args.save_path ? 'provided' : 'none',
     });
-    // Fail-fast on unsafe save_path BEFORE spending credits on the job.
-    let safeSavePath = null;
-    if (args.save_path) {
-        try {
-            safeSavePath = await resolveSafeOutputPath(args.save_path);
-        }
-        catch (err) {
-            if (err instanceof UnsafeOutputPathError)
-                return toolErrorFrom(ErrorCode.UNSAFE_PATH, err);
-            return toolErrorFrom(ErrorCode.INTERNAL, err);
-        }
-    }
+    const savePathResult = await resolveOptionalOutputPath(args.save_path);
+    if (isToolErrorResult(savePathResult))
+        return savePathResult;
+    const safeSavePath = savePathResult.path;
     const body = buildRequestBody(args, model);
     try {
         await attachFrameImages(args, body);
     }
     catch (err) {
-        // Sandbox violation → UNSAFE_PATH; all other decode failures stay
-        // as UNSUPPORTED_FORMAT (couldn't read, invalid data URL, etc.).
         if (err instanceof UnsafeOutputPathError) {
             return toolErrorFrom(ErrorCode.UNSAFE_PATH, err, 'Reference/frame image');
         }
@@ -359,7 +260,6 @@ export async function handleGenerateVideo(request, apiClient, progress) {
     }
     try {
         const { content, _meta } = await finalizeCompletedJob(apiClient, outcome.status, safeSavePath);
-        // Prepend deprecation warning if applicable
         if (deprecationWarning) {
             content.unshift({ type: 'text', text: deprecationWarning });
             _meta.deprecated_model = true;
@@ -378,18 +278,10 @@ export async function handleGetVideoStatus(request, apiClient) {
     const id = args.video_id?.trim();
     if (!id)
         return toolError(ErrorCode.INVALID_INPUT, 'video_id is required.');
-    // Pre-resolve save_path so the poll surfaces a fast error before hitting OpenRouter.
-    let safeSavePath = null;
-    if (args.save_path) {
-        try {
-            safeSavePath = await resolveSafeOutputPath(args.save_path);
-        }
-        catch (err) {
-            if (err instanceof UnsafeOutputPathError)
-                return toolErrorFrom(ErrorCode.UNSAFE_PATH, err);
-            return toolErrorFrom(ErrorCode.INTERNAL, err);
-        }
-    }
+    const savePathResult = await resolveOptionalOutputPath(args.save_path);
+    if (isToolErrorResult(savePathResult))
+        return savePathResult;
+    const safeSavePath = savePathResult.path;
     let status;
     try {
         status = await apiClient.pollVideoJob(id);

package/dist/tool-handlers/health-check.d.ts

@@ -1,14 +1,6 @@
 import type { OpenRouterAPIClient } from '../openrouter-api.js';
 import { ModelCache } from '../model-cache.js';
-/**
- * Lightweight liveness probe. Runs the following checks:
- *  - Hit `/models` via the API client (indirectly validates API key +
- *    OpenRouter reachability)
- *  - Read cached model count
- *  - Report server + protocol versions
- *
- * Returns `{ ok, ... }` so ops can use it as a readiness signal.
- */
+/** Liveness probe — validates API key, reachability, and cached model count. */
 export declare function handleHealthCheck(_request: {
     params: {
         arguments: Record<string, unknown>;

package/dist/tool-handlers/health-check.js

@@ -1,14 +1,6 @@
 import { SERVER_VERSION, MCP_PROTOCOL_VERSION } from '../version.js';
 import { buildStructuredResult } from './structured-output.js';
-/**
- * Lightweight liveness probe. Runs the following checks:
- *  - Hit `/models` via the API client (indirectly validates API key +
- *    OpenRouter reachability)
- *  - Read cached model count
- *  - Report server + protocol versions
- *
- * Returns `{ ok, ... }` so ops can use it as a readiness signal.
- */
+/** Liveness probe — validates API key, reachability, and cached model count. */
 export async function handleHealthCheck(_request, apiClient, modelCache) {
     let apiKeyValid = false;
     let errorMessage;
@@ -20,9 +12,6 @@ export async function handleHealthCheck(_request, apiClient, modelCache) {
         errorMessage = err instanceof Error ? err.message : String(err);
     }
     const modelsCached = modelCache.isValid() ? modelCache.size() : 0;
-    // `ok` means the API was reachable and the key was accepted. An empty
-    // catalog counts as success (the API just returned no models) — callers
-    // branch on `models_cached` if they care about the count.
     const ok = apiKeyValid;
     return buildStructuredResult({
         ok,

package/dist/tool-handlers/image-source.d.ts

@@ -0,0 +1,14 @@
+/** Resolve an image reference to a URL (data URL or http(s) passthrough). */
+export declare function resolveImageUrl(ref: string): Promise<string>;
+/** Resolve an image reference to base64 payload + mime (for video frame uploads). */
+export declare function resolveImageBase64(source: string): Promise<{
+    mime: string;
+    data: string;
+}>;
+/** OpenRouter dedicated-image API reference shape. */
+export declare function toOpenRouterImageReference(source: string): Promise<{
+    type: string;
+    image_url: {
+        url: string;
+    };
+}>;

package/dist/tool-handlers/image-source.js

@@ -0,0 +1,23 @@
+import { fetchImageWithMime } from './image-utils.js';
+/** Resolve an image reference to a URL (data URL or http(s) passthrough). */
+export async function resolveImageUrl(ref) {
+    const trimmed = ref.trim();
+    if (!trimmed)
+        throw new Error('empty image reference');
+    if (trimmed.startsWith('data:') || /^https?:\/\//i.test(trimmed))
+        return trimmed;
+    const { buffer, mime } = await fetchImageWithMime(trimmed);
+    return `data:${mime};base64,${buffer.toString('base64')}`;
+}
+/** Resolve an image reference to base64 payload + mime (for video frame uploads). */
+export async function resolveImageBase64(source) {
+    if (!source.trim())
+        throw new Error('empty image source');
+    const { buffer, mime } = await fetchImageWithMime(source);
+    return { mime, data: buffer.toString('base64') };
+}
+/** OpenRouter dedicated-image API reference shape. */
+export async function toOpenRouterImageReference(source) {
+    const url = await resolveImageUrl(source);
+    return { type: 'image_url', image_url: { url } };
+}

package/dist/tool-handlers/image-utils.d.ts

@@ -24,4 +24,9 @@ export declare function optimizeImage(buffer: Buffer): Promise<{
     base64: string;
     mime: string;
 }>;
+/** Load image bytes with a MIME type (respects OPENROUTER_IMAGE_* fetch limits). */
+export declare function fetchImageWithMime(source: string): Promise<{
+    buffer: Buffer;
+    mime: string;
+}>;
 export declare function prepareImageUrl(source: string): Promise<string>;

package/dist/tool-handlers/image-utils.js

@@ -160,6 +160,29 @@ export async function optimizeImage(buffer) {
         };
     }
 }
+/** Load image bytes with a MIME type (respects OPENROUTER_IMAGE_* fetch limits). */
+export async function fetchImageWithMime(source) {
+    if (source.startsWith('data:')) {
+        const parsed = parseBase64DataUrl(source);
+        if (!parsed)
+            throw new Error('Invalid data URL');
+        return { buffer: Buffer.from(parsed.base64, 'base64'), mime: parsed.mediaType };
+    }
+    if (source.startsWith('http://') || source.startsWith('https://')) {
+        const { buffer, contentType } = await fetchHttpResource(source, {
+            timeoutMs: getFetchTimeoutMs(),
+            maxBytes: getMaxDownloadBytes(),
+            maxRedirects: getMaxRedirects(),
+        });
+        const mime = (contentType?.split(';')[0]?.trim() ||
+            sniffImageMime(buffer) ||
+            'image/jpeg').toLowerCase();
+        return { buffer, mime };
+    }
+    const safe = await resolveSafeInputPath(source);
+    const buffer = await fs.readFile(safe);
+    return { buffer, mime: getMimeType(safe) };
+}
 export async function prepareImageUrl(source) {
     if (source.startsWith('data:'))
         return source;

package/dist/tool-handlers/openai-withresponse.d.ts

@@ -1,13 +1,4 @@
-/**
- * Helper for calling `openai.chat.completions.create()` and getting back
- * BOTH the typed body and the raw fetch `Response` (so we can read the
- * X-OpenRouter-Cache-* headers).
- *
- * The real openai SDK returns an `APIPromise` that exposes `.withResponse()`.
- * Vitest tests typically stub `create()` to return a plain `ChatCompletion`
- * object. This helper handles both cases so tests don't need to mock the
- * chainable.
- */
+/** Call `openai.chat.completions.create()` and return body + raw Response headers. */
 import type { ChatCompletion } from 'openai/resources/chat/completions.js';
 export interface ChatCompletionWithHeaders {
     data: ChatCompletion;

package/dist/tool-handlers/openai-withresponse.js

@@ -1,16 +1,9 @@
 export async function awaitCompletionWithHeaders(call) {
-    // Prefer the APIPromise .withResponse() chainable, which returns
-    // `{ data, response }` — but only if the object looks like an
-    // APIPromise. Mocks that return plain objects get unwrapped via a
-    // direct await.
     const maybeChainable = call;
     if (typeof maybeChainable?.withResponse === 'function') {
         const { data, response } = await maybeChainable.withResponse();
         return { data, response };
     }
-    // Fallback: await the value directly. Covers both test mocks
-    // (which return a plain ChatCompletion via vi.fn().mockResolvedValue())
-    // and any exotic SDK shape we don't recognize.
     const data = (await call);
     return { data, response: undefined };
 }

package/dist/tool-handlers/openrouter-errors.d.ts

@@ -1,22 +1,6 @@
 /**
- * Shared mapping from OpenRouter / OpenAI SDK error shapes to our closed
- * `ErrorCode` enum. Every tool handler that calls the OpenAI client routes
- * its `catch` block through `classifyUpstreamError` so error taxonomies
- * don't drift.
+ * Map OpenRouter / OpenAI SDK errors to our closed `ErrorCode` enum.
  */
 import { type ToolErrorResult } from '../errors.js';
-/**
- * Classify a caught error from `openai.*` or a raw `fetch` to the
- * OpenRouter REST API into the closed `ErrorCode` set.
- *
- * Matching strategy:
- *   1. HTTP status first (when available).
- *   2. Message heuristics for common OpenRouter strings (credits, ZDR,
- *      "model does not exist", content policy, etc.).
- *   3. Default to INTERNAL to avoid leaking raw shapes.
- *
- * When the error carries a `Retry-After` header (on 429 / 503) we populate
- * `_meta.retry_after_seconds` so agents can back off intelligently. We
- * also attach canonical `suggestions[]` for common cases.
- */
+/** Classify upstream errors into the closed `ErrorCode` set. */
 export declare function classifyUpstreamError(err: unknown, contextMessage?: string): ToolErrorResult;