@stabgan/openrouter-mcp-multimodal 4.5.3 → 4.6.1

package/dist/index.js

@@ -7,6 +7,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { ToolHandlers } from './tool-handlers.js';
 import { logger } from './logger.js';
 import { SERVER_VERSION } from './version.js';
+import { SERVER_ICON } from './tool-icons.js';
 const DEFAULT_MODEL = 'nvidia/nemotron-nano-12b-v2-vl:free';
 // Exit on fatal errors to prevent silent zombie processes (issue #5).
 // We log an explicit whitelist of fields rather than the raw error object
@@ -37,7 +38,14 @@ if (!apiKey) {
     process.exit(1);
 }
 const defaultModel = process.env.OPENROUTER_DEFAULT_MODEL || process.env.DEFAULT_MODEL || DEFAULT_MODEL;
-const server = new Server({ name: 'openrouter-multimodal-server', version: SERVER_VERSION }, { capabilities: { tools: {} } });
+const server = new Server({
+    name: 'openrouter-multimodal-server',
+    version: SERVER_VERSION,
+    title: 'OpenRouter MCP Multimodal',
+    description: 'MCP server for OpenRouter — chat with 300+ LLMs, analyze/generate images, audio, and video.',
+    websiteUrl: 'https://github.com/stabgan/openrouter-mcp-multimodal',
+    icons: SERVER_ICON,
+}, { capabilities: { tools: {} } });
 server.onerror = (error) => logFatal('mcpError', error);
 new ToolHandlers(server, apiKey, defaultModel);
 process.on('SIGINT', async () => {

package/dist/openrouter-api.d.ts

@@ -31,6 +31,24 @@ export declare class OpenRouterAPIClient {
         buffer: Buffer;
         contentType: string | null;
     }>;
+    /**
+     * POST /images — dedicated image generation endpoint.
+     * Returns structured response with base64 image data.
+     */
+    generateImage(body: Record<string, unknown>, headers?: Record<string, string>): Promise<ImageGenerationResponse>;
+    /**
+     * POST /audio/speech — dedicated text-to-speech endpoint.
+     * Returns raw audio bytes.
+     */
+    generateSpeech(body: Record<string, unknown>, headers?: Record<string, string>): Promise<{
+        buffer: Buffer;
+        contentType: string;
+    }>;
+    /**
+     * POST /audio/transcriptions — dedicated speech-to-text endpoint.
+     * Accepts base64-encoded audio and returns transcription text.
+     */
+    transcribeAudio(body: Record<string, unknown>, headers?: Record<string, string>): Promise<TranscriptionResponse>;
     /** POST /rerank — re-order documents by relevance to a query. */
     rerank(params: {
         model: string;
@@ -45,6 +63,33 @@ export interface VideoJobEnvelope {
     polling_url?: string;
     [key: string]: unknown;
 }
+export interface ImageGenerationResponse {
+    data?: Array<{
+        b64_json?: string;
+        url?: string;
+        revised_prompt?: string;
+    }>;
+    usage?: {
+        cost?: number;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface TranscriptionResponse {
+    text?: string;
+    segments?: Array<{
+        start: number;
+        end: number;
+        text: string;
+    }>;
+    language?: string;
+    duration?: number;
+    usage?: {
+        cost?: number;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
 export interface RerankResultItem {
     index: number;
     relevance_score?: number;

package/dist/openrouter-api.js

@@ -151,6 +151,56 @@ export class OpenRouterAPIClient {
         }
         return { buffer: Buffer.concat(chunks), contentType: res.headers.get('content-type') };
     }
+    /**
+     * POST /images — dedicated image generation endpoint.
+     * Returns structured response with base64 image data.
+     */
+    async generateImage(body, headers) {
+        const res = await fetchWithRetry(`${BASE_URL}/images`, {
+            method: 'POST',
+            headers: this.authHeaders({ 'Content-Type': 'application/json', ...headers }),
+            body: JSON.stringify(body),
+        }, { retries: 2, timeoutMs: 120_000 });
+        if (!res.ok) {
+            const detail = await safeReadText(res);
+            throw new Error(`POST /images failed: HTTP ${res.status}${detail ? ` — ${detail}` : ''}`);
+        }
+        return (await res.json());
+    }
+    /**
+     * POST /audio/speech — dedicated text-to-speech endpoint.
+     * Returns raw audio bytes.
+     */
+    async generateSpeech(body, headers) {
+        const res = await fetchWithRetry(`${BASE_URL}/audio/speech`, {
+            method: 'POST',
+            headers: this.authHeaders({ 'Content-Type': 'application/json', ...headers }),
+            body: JSON.stringify(body),
+        }, { retries: 2, timeoutMs: 60_000 });
+        if (!res.ok) {
+            const detail = await safeReadText(res);
+            throw new Error(`POST /audio/speech failed: HTTP ${res.status}${detail ? ` — ${detail}` : ''}`);
+        }
+        const contentType = res.headers.get('content-type') || 'audio/mpeg';
+        const buf = Buffer.from(await res.arrayBuffer());
+        return { buffer: buf, contentType };
+    }
+    /**
+     * POST /audio/transcriptions — dedicated speech-to-text endpoint.
+     * Accepts base64-encoded audio and returns transcription text.
+     */
+    async transcribeAudio(body, headers) {
+        const res = await fetchWithRetry(`${BASE_URL}/audio/transcriptions`, {
+            method: 'POST',
+            headers: this.authHeaders({ 'Content-Type': 'application/json', ...headers }),
+            body: JSON.stringify(body),
+        }, { retries: 2, timeoutMs: 60_000 });
+        if (!res.ok) {
+            const detail = await safeReadText(res);
+            throw new Error(`POST /audio/transcriptions failed: HTTP ${res.status}${detail ? ` — ${detail}` : ''}`);
+        }
+        return (await res.json());
+    }
     /** POST /rerank — re-order documents by relevance to a query. */
     async rerank(params) {
         const body = {

package/dist/tool-descriptions.d.ts

@@ -14,6 +14,6 @@ export interface ToolDescriptionParts {
 export declare function buildToolDescription(parts: ToolDescriptionParts): string;
 /** Required sections every tool description must contain (regression-tested). */
 export declare const REQUIRED_DESCRIPTION_SECTIONS: readonly ["Use when:", "Do NOT use when:", "Good examples:", "Bad examples:", "Fails when:", "Works with:"];
-export declare const TOOL_NAMES: readonly ["chat_completion", "analyze_image", "analyze_audio", "analyze_video", "search_models", "get_model_info", "validate_model", "generate_image", "generate_audio", "generate_video", "generate_video_from_image", "get_video_status", "rerank_documents", "health_check"];
+export declare const TOOL_NAMES: readonly ["chat_completion", "start_chat_completion", "get_chat_completion_status", "analyze_image", "analyze_audio", "analyze_video", "search_models", "get_model_info", "validate_model", "generate_image", "generate_image_dedicated", "generate_audio", "text_to_speech", "speech_to_text", "generate_video", "generate_video_from_image", "get_video_status", "rerank_documents", "health_check"];
 export type ToolName = (typeof TOOL_NAMES)[number];
 export declare const TOOL_DESCRIPTIONS: Record<ToolName, string>;

package/dist/tool-descriptions.js

@@ -25,6 +25,8 @@ export const REQUIRED_DESCRIPTION_SECTIONS = [
 ];
 export const TOOL_NAMES = [
     'chat_completion',
+    'start_chat_completion',
+    'get_chat_completion_status',
     'analyze_image',
     'analyze_audio',
     'analyze_video',
@@ -32,7 +34,10 @@ export const TOOL_NAMES = [
     'get_model_info',
     'validate_model',
     'generate_image',
+    'generate_image_dedicated',
     'generate_audio',
+    'text_to_speech',
+    'speech_to_text',
     'generate_video',
     'generate_video_from_image',
     'get_video_status',
@@ -42,8 +47,8 @@ export const TOOL_NAMES = [
 export const TOOL_DESCRIPTIONS = {
     chat_completion: buildToolDescription({
         summary: 'Send messages to an OpenRouter chat model and get a text reply. Supports provider routing, ' +
-            'model suffixes (`:nitro` fastest, `:floor` cheapest, `:exacto` tool accuracy), reasoning ' +
-            'tokens, web search (`online: true`), and response caching.',
+            'model suffixes (`:nitro` fastest, `:floor` cheapest, `:free` zero-cost, `:online` web search, ' +
+            '`:exacto` tool accuracy), reasoning tokens, web search (`online: true`), and response caching.',
         useWhen: [
             'You need text generation, Q&A, summarization, or multi-turn dialogue',
             'You want web-grounded answers (`online: true`)',
@@ -72,6 +77,57 @@ export const TOOL_DESCRIPTIONS = {
         ],
         worksWith: ['validate_model', 'search_models'],
     }),
+    start_chat_completion: buildToolDescription({
+        summary: 'Start a chat completion as an async background job. Returns a job_id immediately without waiting ' +
+            'for the model to respond. Use `get_chat_completion_status` to poll for results. Designed for ' +
+            'reasoning models or any request that may exceed MCP timeout limits (~60s).',
+        useWhen: [
+            'Using a reasoning model that may take >60 seconds (DeepSeek R1, Claude Opus, etc.)',
+            'Connected through a remote MCP bridge with short timeouts',
+            'You want to fire-and-forget a completion and check back later',
+        ],
+        notWhen: [
+            'Fast models that respond within seconds → use chat_completion directly',
+            'You need streaming output → use chat_completion',
+            'Messages array is empty',
+        ],
+        goodExamples: [
+            '`{ "messages": [{ "role": "user", "content": "Prove the Riemann hypothesis" }], "model": "deepseek/r1" }`',
+            '`{ "messages": [...], "include_reasoning": true }` for long chain-of-thought',
+        ],
+        badExamples: [
+            '`{ "messages": [] }` → INVALID_INPUT',
+            'Using this for simple "hello world" prompts (unnecessary overhead)',
+        ],
+        failsWhen: [
+            'INVALID_INPUT: empty messages array',
+            'Job may fail in background if model errors or credits exhausted',
+        ],
+        worksWith: ['get_chat_completion_status', 'chat_completion'],
+    }),
+    get_chat_completion_status: buildToolDescription({
+        summary: 'Check the status of an async chat completion job started with `start_chat_completion`. ' +
+            'Returns the full response when completed, or current status (running/failed) otherwise.',
+        useWhen: [
+            'You previously called start_chat_completion and need to check if it finished',
+            'Polling for a long-running reasoning model result',
+        ],
+        notWhen: [
+            "You haven't started a job yet → use start_chat_completion first",
+            'You want to start a new completion',
+        ],
+        goodExamples: ['`{ "job_id": "chat_20260806_001" }`'],
+        badExamples: [
+            '`{ "job_id": "" }` → INVALID_INPUT',
+            '`{ "job_id": "nonexistent" }` → job not found',
+        ],
+        failsWhen: [
+            'INVALID_INPUT: empty job_id',
+            'JOB_FAILED: the background completion encountered an error',
+            'Job not found: invalid job_id or job from a previous session',
+        ],
+        worksWith: ['start_chat_completion', 'chat_completion'],
+    }),
     analyze_image: buildToolDescription({
         summary: 'Analyze one image with a vision model. Accepts a sandboxed local path, https URL, or base64 data URL. ' +
             'Output is model-generated and tagged `_meta.content_is_untrusted: true`.',
@@ -263,6 +319,38 @@ export const TOOL_DESCRIPTIONS = {
         ],
         worksWith: ['analyze_image', 'generate_video_from_image'],
     }),
+    generate_image_dedicated: buildToolDescription({
+        summary: "Generate images via OpenRouter's dedicated Image API (POST /api/v1/images). Supports " +
+            'normalized resolution tiers, quality levels, output format selection, and reference images. ' +
+            'New image models are added exclusively to this endpoint. Default model: google/gemini-2.5-flash-image.',
+        useWhen: [
+            'You need image generation with fine control over resolution, quality, and format',
+            'You want to use newer image models only available on the dedicated API',
+            'You need image-to-image with `input_references`',
+        ],
+        notWhen: [
+            'You want to analyze an existing image → analyze_image',
+            'You want video → generate_video or generate_video_from_image',
+            'Prompt is empty or only whitespace',
+        ],
+        goodExamples: [
+            '`{ "prompt": "A watercolor fox", "resolution": "2K", "quality": "high" }`',
+            '`{ "prompt": "Product shot", "input_references": ["product.jpg"], "aspect_ratio": "16:9" }`',
+            '`{ "prompt": "Logo", "output_format": "svg", "save_path": "out/logo.svg" }`',
+        ],
+        badExamples: [
+            '`{ "prompt": "" }` → INVALID_INPUT',
+            '`{ "resolution": "8K" }` → not in allowed enum',
+            '`{ "quality": "ultra" }` → not in allowed enum',
+        ],
+        failsWhen: [
+            'INVALID_INPUT: empty prompt, invalid resolution/quality/output_format',
+            'UNSAFE_PATH: save_path or input_references escaped sandbox',
+            "UPSTREAM_REFUSED: content policy, model doesn't support requested options",
+            'MODEL_NOT_FOUND: invalid model slug',
+        ],
+        worksWith: ['analyze_image', 'generate_video_from_image'],
+    }),
     generate_audio: buildToolDescription({
         summary: 'Generate speech or music from a text prompt. Output format is auto-detected; file extension auto-corrected on save.',
         useWhen: [
@@ -285,6 +373,66 @@ export const TOOL_DESCRIPTIONS = {
         ],
         worksWith: ['analyze_audio'],
     }),
+    text_to_speech: buildToolDescription({
+        summary: "Convert text to speech via OpenRouter's dedicated TTS endpoint (POST /api/v1/audio/speech). " +
+            'Faster and cheaper than chat completions for pure TTS. Models: OpenAI GPT-4o Mini TTS, Google Gemini Flash TTS, Mistral Voxtral.',
+        useWhen: [
+            'You need text-to-speech with specific voice control',
+            'You want fast, dedicated TTS without chat overhead',
+            'You need a specific audio format (mp3, opus, wav, etc.)',
+        ],
+        notWhen: [
+            'You want to generate music or sound effects → generate_audio',
+            'You want to transcribe audio → speech_to_text or analyze_audio',
+            'Input text is empty',
+        ],
+        goodExamples: [
+            '`{ "input": "Hello, welcome to our app!" }`',
+            '`{ "input": "...", "voice": "nova", "response_format": "mp3", "save_path": "out/welcome.mp3" }`',
+            '`{ "input": "...", "instructions": "speak slowly and clearly", "speed": 0.8 }`',
+        ],
+        badExamples: [
+            '`{ "input": "" }` → INVALID_INPUT',
+            '`{ "prompt": "text" }` → wrong key; use `input`',
+            '`{ "response_format": "mp4" }` → not a valid audio format',
+        ],
+        failsWhen: [
+            'INVALID_INPUT: empty input, invalid response_format',
+            'UNSAFE_PATH: save_path escaped sandbox',
+            'UPSTREAM_REFUSED: content policy or credits',
+        ],
+        worksWith: ['speech_to_text', 'analyze_audio'],
+    }),
+    speech_to_text: buildToolDescription({
+        summary: "Transcribe audio via OpenRouter's dedicated STT endpoint (POST /api/v1/audio/transcriptions). " +
+            'Faster and cheaper than chat completions for pure transcription. Models: Whisper-1, GPT-4o Transcribe, Voxtral.',
+        useWhen: [
+            'You need fast transcription of audio files',
+            'You want pure speech-to-text without analysis or Q&A',
+            'You need structured output (SRT, VTT, verbose JSON)',
+        ],
+        notWhen: [
+            'You want to ask questions about audio → analyze_audio',
+            'You want music analysis or sound identification → analyze_audio',
+            'You want TTS → text_to_speech or generate_audio',
+        ],
+        goodExamples: [
+            '`{ "audio_path": "recording.mp3" }`',
+            '`{ "audio_path": "meeting.wav", "language": "en", "response_format": "srt" }`',
+            '`{ "audio_path": "https://example.com/audio.mp3", "model": "openai/gpt-4o-transcribe" }`',
+        ],
+        badExamples: [
+            '`{ "audio_path": "" }` → INVALID_INPUT',
+            '`{ "path": "audio.mp3" }` → wrong key; use `audio_path`',
+            '`{ "audio_path": "/etc/shadow" }` → UNSAFE_PATH',
+        ],
+        failsWhen: [
+            'INVALID_INPUT: empty audio_path, invalid response_format, unreadable file',
+            'UNSAFE_PATH: audio_path escaped sandbox',
+            'UPSTREAM_REFUSED: unsupported format or credits exhausted',
+        ],
+        worksWith: ['text_to_speech', 'analyze_audio'],
+    }),
     generate_video: buildToolDescription({
         summary: 'Generate video from a text prompt (optional first/last frame or reference images). Submits an async job, ' +
             'polls until `max_wait_ms`, downloads on completion. Emits MCP progress when client sends `progressToken`. ' +

package/dist/tool-handlers/async-chat.d.ts

@@ -0,0 +1,51 @@
+import OpenAI from 'openai';
+import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions.js';
+import { type ProviderRoutingOptions } from './provider-routing.js';
+import { type CacheOptions } from './cache.js';
+export interface StartChatCompletionRequest extends CacheOptions {
+    messages: ChatCompletionMessageParam[];
+    model?: string;
+    temperature?: number;
+    max_tokens?: number;
+    provider?: ProviderRoutingOptions;
+    include_reasoning?: boolean;
+    online?: boolean;
+    web_max_results?: number;
+}
+export interface GetChatCompletionStatusRequest {
+    job_id: string;
+}
+export type AsyncJobStatus = 'queued' | 'running' | 'completed' | 'failed';
+export declare function handleStartChatCompletion(request: {
+    params: {
+        arguments: StartChatCompletionRequest;
+    };
+}, openai: OpenAI, defaultModel?: string): Promise<import("../errors.js").ToolErrorResult | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    _meta: {
+        server_version: string;
+        job_id: string;
+        status: "running";
+        model: string;
+    };
+}>;
+export declare function handleGetChatCompletionStatus(request: {
+    params: {
+        arguments: GetChatCompletionStatusRequest;
+    };
+}): Promise<import("../errors.js").ToolErrorResult | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    _meta: {
+        server_version: string;
+        job_id: string;
+        status: "queued" | "completed" | "running";
+        model: string;
+        created_at: string;
+    };
+}>;

package/dist/tool-handlers/async-chat.js

@@ -0,0 +1,216 @@
+/**
+ * Async chat completions — resumable workflow for long-running requests.
+ *
+ * Problem: Remote MCP bridges (Cowork, etc.) kill tool calls after ~60s.
+ * Reasoning models can take much longer. Unlike video, `chat_completion`
+ * currently has no background job mechanism.
+ *
+ * Solution: Two tools that mirror the video pattern:
+ *  - `start_chat_completion` — fires off the request in the background,
+ *    returns a `job_id` immediately.
+ *  - `get_chat_completion_status` — returns queued/running/completed/failed,
+ *    with the final response on completion.
+ *
+ * Job state is held in memory (survives within a single MCP session).
+ * Optionally persisted to OPENROUTER_OUTPUT_DIR/openrouter-jobs/ for
+ * crash recovery.
+ */
+import { promises as fs } from 'fs';
+import path from 'node:path';
+import { ErrorCode, toolError } from '../errors.js';
+import { SERVER_VERSION } from '../version.js';
+import { logger } from '../logger.js';
+import { extractCompletionText, buildCompletionMeta } from './completion-utils.js';
+import { readProviderDefaults, mergeProviderOptions, buildProviderBody, resolveMaxTokens, } from './provider-routing.js';
+import { buildCacheHeaders } from './cache.js';
+// ─── Job Store ───────────────────────────────────────────────────────────────
+const jobs = new Map();
+let jobCounter = 0;
+function generateJobId() {
+    jobCounter += 1;
+    const ts = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+    return `chat_${ts}_${String(jobCounter).padStart(3, '0')}`;
+}
+function getJobsDir() {
+    const outputDir = process.env.OPENROUTER_OUTPUT_DIR;
+    if (!outputDir)
+        return null;
+    return path.join(outputDir, 'openrouter-jobs');
+}
+async function persistJob(job) {
+    const dir = getJobsDir();
+    if (!dir)
+        return;
+    try {
+        const jobDir = path.join(dir, job.id);
+        await fs.mkdir(jobDir, { recursive: true });
+        await fs.writeFile(path.join(jobDir, 'status.json'), JSON.stringify(job, null, 2));
+        if (job.status === 'completed' && job.result?.text) {
+            await fs.writeFile(path.join(jobDir, 'response.md'), job.result.text);
+        }
+    }
+    catch (err) {
+        logger.warn('async_chat.persist_error', {
+            job_id: job.id,
+            err: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+// ─── Handlers ────────────────────────────────────────────────────────────────
+const DEFAULT_MODEL = 'nvidia/nemotron-nano-12b-v2-vl:free';
+function readIncludeReasoningDefault() {
+    const raw = (process.env.OPENROUTER_INCLUDE_REASONING ?? '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes';
+}
+export async function handleStartChatCompletion(request, openai, defaultModel) {
+    const args = request.params.arguments ?? { messages: [] };
+    const { messages, model, temperature, max_tokens, provider, include_reasoning, online, web_max_results, cache, cache_ttl, cache_clear, } = args;
+    if (!messages?.length) {
+        return toolError(ErrorCode.INVALID_INPUT, 'Messages array cannot be empty.');
+    }
+    const effectiveModel = model || defaultModel || DEFAULT_MODEL;
+    const jobId = generateJobId();
+    // Create the job immediately
+    const job = {
+        id: jobId,
+        status: 'running',
+        createdAt: new Date().toISOString(),
+        model: effectiveModel,
+    };
+    jobs.set(jobId, job);
+    logger.audit('async_chat.start', {
+        job_id: jobId,
+        model: effectiveModel,
+        message_count: messages.length,
+    });
+    // Fire and forget — the completion runs in the background
+    runCompletionInBackground(job, openai, {
+        messages,
+        model: effectiveModel,
+        temperature,
+        max_tokens,
+        provider,
+        include_reasoning,
+        online,
+        web_max_results,
+        cache,
+        cache_ttl,
+        cache_clear,
+    });
+    // Return immediately with the job ID
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Chat completion job started. Use get_chat_completion_status with job_id="${jobId}" to check results.`,
+            },
+        ],
+        _meta: {
+            server_version: SERVER_VERSION,
+            job_id: jobId,
+            status: 'running',
+            model: effectiveModel,
+        },
+    };
+}
+async function runCompletionInBackground(job, openai, opts) {
+    const providerOptions = mergeProviderOptions(readProviderDefaults(), opts.provider);
+    const providerBody = buildProviderBody(providerOptions);
+    const effectiveMaxTokens = resolveMaxTokens(opts.max_tokens);
+    const wantsReasoning = opts.include_reasoning ?? readIncludeReasoningDefault();
+    const body = {
+        model: opts.model,
+        messages: opts.messages,
+        temperature: opts.temperature ?? 1,
+    };
+    if (typeof effectiveMaxTokens === 'number')
+        body.max_tokens = effectiveMaxTokens;
+    if (providerBody)
+        body.provider = providerBody;
+    if (wantsReasoning)
+        body.include_reasoning = true;
+    if (opts.online) {
+        const plugin = { id: 'web' };
+        if (typeof opts.web_max_results === 'number' && opts.web_max_results > 0) {
+            plugin.max_results = opts.web_max_results;
+        }
+        body.plugins = [plugin];
+    }
+    const headers = buildCacheHeaders({
+        cache: opts.cache,
+        cache_ttl: opts.cache_ttl,
+        cache_clear: opts.cache_clear,
+    });
+    const requestOpts = Object.keys(headers).length > 0 ? { headers } : undefined;
+    try {
+        const completion = (await openai.chat.completions.create(body, requestOpts));
+        const extracted = extractCompletionText(completion);
+        if (!extracted.text) {
+            job.status = 'failed';
+            job.error = 'Model returned no textual content.';
+        }
+        else {
+            job.status = 'completed';
+            job.result = {
+                text: extracted.text,
+                meta: buildCompletionMeta(extracted, {
+                    includeReasoning: wantsReasoning,
+                    extra: { server_version: SERVER_VERSION },
+                }),
+            };
+        }
+    }
+    catch (err) {
+        job.status = 'failed';
+        job.error = err instanceof Error ? err.message : String(err);
+        logger.warn('async_chat.failed', { job_id: job.id, error: job.error });
+    }
+    await persistJob(job);
+}
+export async function handleGetChatCompletionStatus(request) {
+    const args = request.params.arguments ?? {};
+    const jobId = args.job_id?.trim();
+    if (!jobId) {
+        return toolError(ErrorCode.INVALID_INPUT, 'job_id is required.');
+    }
+    const job = jobs.get(jobId);
+    if (!job) {
+        return toolError(ErrorCode.INVALID_INPUT, `No job found with id "${jobId}". Jobs are stored in memory for the current session only.`);
+    }
+    if (job.status === 'completed' && job.result) {
+        return {
+            content: [{ type: 'text', text: job.result.text }],
+            _meta: {
+                server_version: SERVER_VERSION,
+                job_id: jobId,
+                status: 'completed',
+                model: job.model,
+                created_at: job.createdAt,
+                ...job.result.meta,
+            },
+        };
+    }
+    if (job.status === 'failed') {
+        return toolError(ErrorCode.JOB_FAILED, job.error || 'Job failed.', {
+            job_id: jobId,
+            model: job.model,
+            created_at: job.createdAt,
+        });
+    }
+    // Still running
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Job ${jobId} is still ${job.status}. Try again in a few seconds.`,
+            },
+        ],
+        _meta: {
+            server_version: SERVER_VERSION,
+            job_id: jobId,
+            status: job.status,
+            model: job.model,
+            created_at: job.createdAt,
+        },
+    };
+}

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

@@ -0,0 +1,32 @@
+import type { OpenRouterAPIClient } from '../openrouter-api.js';
+import { type CacheOptions } from './cache.js';
+export interface GenerateImageDedicatedRequest extends CacheOptions {
+    prompt: string;
+    model?: string;
+    resolution?: string;
+    aspect_ratio?: string;
+    quality?: string;
+    output_format?: string;
+    n?: number;
+    input_references?: string[];
+    save_path?: string;
+    provider?: Record<string, unknown>;
+}
+export declare function handleGenerateImageDedicated(request: {
+    params: {
+        arguments: GenerateImageDedicatedRequest;
+    };
+}, apiClient: OpenRouterAPIClient): Promise<import("../errors.js").ToolErrorResult | {
+    content: ({
+        type: "text";
+        text: string;
+        mimeType?: undefined;
+        data?: undefined;
+    } | {
+        type: "image";
+        mimeType: string;
+        data: string;
+        text?: undefined;
+    })[];
+    _meta: Record<string, unknown>;
+}>;