@x12i/ai-gateway 10.4.4 → 11.0.1

package/dist/message-builder.js

@@ -5,19 +5,38 @@
  */
 import { parseTemplate } from './template-parser.js';
 import { mergeGatewayAndRequestTemplateRenderOptions } from './template-render-merge.js';
-// Type guard
-// AIRequest is distinguished by having primaryObjectType or objectTypes
-// ChatRequest does not have these fields
-function isAIRequest(request) {
-    return 'primaryObjectType' in request || ('objectTypes' in request && Array.isArray(request.objectTypes));
+function hasNonEmptyPrompt(prompt) {
+    return typeof prompt === 'string' && prompt.trim() !== '';
+}
+function getWorkingMemoryInput(workingMemory) {
+    if (workingMemory == null || typeof workingMemory !== 'object')
+        return undefined;
+    return workingMemory.input;
+}
+function hasResolvableInput(workingMemory) {
+    const input = getWorkingMemoryInput(workingMemory);
+    return input !== undefined && input !== null;
+}
+/**
+ * Serializes workingMemory.input when no prompt template is provided.
+ */
+export function formatInputFallback(input) {
+    if (input === undefined || input === null) {
+        return '';
+    }
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (typeof input === 'object') {
+        return JSON.stringify(input, null, 2);
+    }
+    return String(input);
 }
 /**
- * Builds user message (prompt + input)
+ * Builds user message from prompt template or workingMemory.input fallback.
  */
 async function buildUserMessage(request, config, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions) {
     const { logger } = config;
-    const parts = [];
-    // Validate that input field is not provided (removed - use workingMemory.input instead)
     if ('input' in request && request.input !== undefined) {
         const err = new Error(`The 'input' field has been removed. Use workingMemory.input instead for template rendering. Prompt templates should contain {{input}} which will be resolved from workingMemory.input.`);
         err.code = 'INPUT_FIELD_DEPRECATED';
@@ -32,213 +51,127 @@ async function buildUserMessage(request, config, shortTermMemory, experienceMemo
             errorCode: 'INPUT_FIELD_DEPRECATED',
             hasPrompt: !!request.prompt,
             hasWorkingMemory: !!request.workingMemory,
-            hasInputInWorkingMemory: !!request.workingMemory?.input
+            hasInputInWorkingMemory: hasResolvableInput(request.workingMemory)
         });
         throw err;
     }
-    // Determine if we have user content to process (prompt is required for user message)
-    const hasUserContent = isAIRequest(request) && request.prompt;
-    // Input prefix is no longer used - prompt templates handle all formatting
-    // If no prompt is provided, that's an error (prompt is required for user message)
-    if (isAIRequest(request) && !request.prompt) {
-        const err = new Error(`Prompt is required for AI requests. Provide prompt template text. The template should contain variables such as {{input}} resolved from workingMemory.input.`);
-        err.code = 'PROMPT_REQUIRED';
-        err.details = {
-            missingField: 'prompt',
-            hasWorkingMemory: !!request.workingMemory,
-            hasInputInWorkingMemory: !!request.workingMemory?.input
-        };
-        logger.error('Prompt is required for AI requests', {
+    if (hasNonEmptyPrompt(request.prompt)) {
+        if (typeof request.prompt !== 'string') {
+            throw new Error(`Prompt must be a string template, but received: ${typeof request.prompt}`);
+        }
+        logger.info('Parsing prompt template text', {
             jobId: request.identity.jobId,
             agentId: request.agentId,
-            errorCode: 'PROMPT_REQUIRED'
+            promptLength: request.prompt.length,
+            promptPreview: request.prompt.substring(0, 200),
+            hasWorkingMemory: !!request.workingMemory
         });
-        throw err;
-    }
-    // Add prompt if provided (always template text; parsed with memory context)
-    if (request.prompt) {
-        if (typeof request.prompt === 'string') {
-            logger.info('Parsing prompt template text', {
-                jobId: request.identity.jobId,
-                agentId: request.agentId,
-                promptLength: request.prompt.length,
-                promptPreview: request.prompt.substring(0, 200),
-                hasWorkingMemory: !!request.workingMemory
-            });
-            try {
-                if (!request.workingMemory) {
-                    const err = new Error(`workingMemory is required for prompt template rendering but was not provided.`);
-                    err.code = 'WORKING_MEMORY_REQUIRED';
-                    err.details = { requiresVariables: true };
-                    logger.error('workingMemory required for prompt template rendering', {
-                        jobId: request.identity.jobId,
-                        agentId: request.agentId,
-                        errorCode: 'WORKING_MEMORY_REQUIRED'
-                    });
-                    throw err;
-                }
-                const parsedPrompt = await parseTemplate(request.prompt, request.workingMemory, undefined, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
-                if (!parsedPrompt || parsedPrompt.trim() === '') {
-                    const workingMemoryObj = request.workingMemory;
-                    const err = new Error(`Prompt template rendered to empty string. This may indicate missing template variables or empty template content.`);
-                    err.code = 'PROMPT_RENDERED_EMPTY';
-                    err.details = {
-                        promptLength: request.prompt.length,
-                        renderedLength: 0,
-                        hasWorkingMemory: !!request.workingMemory,
-                        workingMemoryKeys: workingMemoryObj ? Object.keys(workingMemoryObj) : []
-                    };
-                    logger.error('Prompt template rendered to empty string', {
-                        jobId: request.identity.jobId,
-                        agentId: request.agentId,
-                        errorCode: 'PROMPT_RENDERED_EMPTY',
-                        hasWorkingMemory: !!request.workingMemory,
-                        workingMemoryKeys: workingMemoryObj ? Object.keys(workingMemoryObj) : []
-                    });
-                    throw err;
-                }
-                logger.info('Prompt text parsed successfully', {
+        try {
+            if (!request.workingMemory) {
+                const err = new Error(`workingMemory is required for prompt template rendering but was not provided.`);
+                err.code = 'WORKING_MEMORY_REQUIRED';
+                err.details = { requiresVariables: true };
+                logger.error('workingMemory required for prompt template rendering', {
                     jobId: request.identity.jobId,
                     agentId: request.agentId,
-                    originalLength: request.prompt.length,
-                    parsedLength: parsedPrompt.length,
-                    parsedPreview: parsedPrompt.substring(0, 200)
+                    errorCode: 'WORKING_MEMORY_REQUIRED'
                 });
-                parts.push(parsedPrompt);
+                throw err;
             }
-            catch (error) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                let errorCode = 'PROMPT_TEMPLATE_ERROR';
-                let errorMessage = `Failed to render prompt template: ${err.message}`;
-                if (err.message.includes('not found') || err.message.includes('does not exist')) {
-                    errorCode = 'PROMPT_NOT_FOUND';
-                    errorMessage = err.message;
-                }
-                else if (err.message.includes('rendered to empty')) {
-                    errorCode = 'PROMPT_RENDERED_EMPTY';
-                    errorMessage = err.message;
-                }
-                else if (err.name === 'TemplateResolutionError') {
-                    errorCode = 'TEMPLATE_RESOLUTION_ERROR';
-                    errorMessage = err.message;
-                }
-                else if (err.message.includes('Template variable') || err.message.includes('missing')) {
-                    errorCode = 'TEMPLATE_VARIABLE_MISSING';
-                    errorMessage = err.message;
-                }
-                logger.error('Failed to render prompt template', {
+            const parsedPrompt = await parseTemplate(request.prompt, request.workingMemory, undefined, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
+            if (!parsedPrompt || parsedPrompt.trim() === '') {
+                const workingMemoryObj = request.workingMemory;
+                const err = new Error(`Prompt template rendered to empty string. This may indicate missing template variables or empty template content.`);
+                err.code = 'PROMPT_RENDERED_EMPTY';
+                err.details = {
+                    promptLength: request.prompt.length,
+                    renderedLength: 0,
+                    hasWorkingMemory: !!request.workingMemory,
+                    workingMemoryKeys: workingMemoryObj ? Object.keys(workingMemoryObj) : []
+                };
+                logger.error('Prompt template rendered to empty string', {
                     jobId: request.identity.jobId,
                     agentId: request.agentId,
-                    errorCode,
-                    error: err.message,
-                    errorName: err.name,
-                    errorStack: err.stack
+                    errorCode: 'PROMPT_RENDERED_EMPTY',
+                    hasWorkingMemory: !!request.workingMemory,
+                    workingMemoryKeys: workingMemoryObj ? Object.keys(workingMemoryObj) : []
                 });
-                const structuredError = new Error(errorMessage);
-                structuredError.code = errorCode;
-                structuredError.details = {
-                    type: 'prompt',
-                    originalError: err.message
-                };
-                throw structuredError;
+                throw err;
             }
+            logger.info('Prompt text parsed successfully', {
+                jobId: request.identity.jobId,
+                agentId: request.agentId,
+                originalLength: request.prompt.length,
+                parsedLength: parsedPrompt.length,
+                parsedPreview: parsedPrompt.substring(0, 200)
+            });
+            return parsedPrompt;
         }
-        else {
-            const err = new Error(`Prompt must be a string template, but received: ${typeof request.prompt}`);
-            logger.error('Prompt provided as non-string - not supported', {
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            let errorCode = 'PROMPT_TEMPLATE_ERROR';
+            let errorMessage = `Failed to render prompt template: ${err.message}`;
+            if (err.message.includes('not found') || err.message.includes('does not exist')) {
+                errorCode = 'PROMPT_NOT_FOUND';
+                errorMessage = err.message;
+            }
+            else if (err.message.includes('rendered to empty')) {
+                errorCode = 'PROMPT_RENDERED_EMPTY';
+                errorMessage = err.message;
+            }
+            else if (err.name === 'TemplateResolutionError') {
+                errorCode = 'TEMPLATE_RESOLUTION_ERROR';
+                errorMessage = err.message;
+            }
+            else if (err.message.includes('Template variable') || err.message.includes('missing')) {
+                errorCode = 'TEMPLATE_VARIABLE_MISSING';
+                errorMessage = err.message;
+            }
+            logger.error('Failed to render prompt template', {
                 jobId: request.identity.jobId,
                 agentId: request.agentId,
-                promptType: typeof request.prompt
+                errorCode,
+                error: err.message,
+                errorName: err.name,
+                errorStack: err.stack
             });
-            throw err;
+            const structuredError = new Error(errorMessage);
+            structuredError.code = errorCode;
+            structuredError.details = {
+                type: 'prompt',
+                originalError: err.message
+            };
+            throw structuredError;
         }
     }
-    // Input field has been removed - all input must come from workingMemory.input
-    // Prompt templates should contain {{input}} which will be resolved from workingMemory.input
-    // No need to add input separately - it's already in the rendered prompt template
-    const userMessage = parts.join('\n\n');
-    // If prompt was provided, we MUST have a non-empty user message
-    if (request.prompt && (!userMessage || userMessage.trim() === '')) {
-        const err = new Error(`Prompt template was provided but resulted in empty user message. The template may have rendered to empty or failed to resolve.`);
-        err.code = 'PROMPT_NO_USER_MESSAGE';
-        err.details = {
-            promptPreview: typeof request.prompt === 'string' ? request.prompt.substring(0, 200) : request.prompt,
-            hasWorkingMemory: !!request.workingMemory,
-            workingMemoryKeys: request.workingMemory ? Object.keys(request.workingMemory) : [],
-            partsLength: parts.length
-        };
-        logger.error('Prompt provided but resulted in empty user message', {
+    if (hasResolvableInput(request.workingMemory)) {
+        const fallback = formatInputFallback(getWorkingMemoryInput(request.workingMemory));
+        if (!fallback.trim()) {
+            const err = new Error(`workingMemory.input is present but empty. Provide a prompt template or non-empty workingMemory.input.`);
+            err.code = 'USER_CONTENT_REQUIRED';
+            throw err;
+        }
+        logger.info('Using workingMemory.input fallback for user message', {
             jobId: request.identity.jobId,
             agentId: request.agentId,
-            prompt: request.prompt,
-            errorCode: 'PROMPT_NO_USER_MESSAGE',
-            partsLength: parts.length,
-            parts: parts.map(p => ({ length: p.length, preview: p.substring(0, 50) }))
+            fallbackLength: fallback.length,
+            fallbackPreview: fallback.substring(0, 200)
         });
-        throw err;
-    }
-    return userMessage;
-}
-/**
- * Checks if instructions already meet the required flex-md compliance level
- * Uses flex-md SDK to validate compliance
- *
- * @param instructionsText - Instructions to check
- * @param complianceLevel - Required compliance level (L0, L1, L2, L3)
- * @returns true if instructions meet the compliance level
- */
-async function hasFlexMdContract(instructionsText, complianceLevel = 'L0') {
-    if (!instructionsText || instructionsText.trim() === '') {
-        return false;
-    }
-    try {
-        // Try to use flex-md SDK to validate compliance
-        const { loadFlexMd } = await import('./flex-md-loader.js');
-        const flexMd = await loadFlexMd();
-        // Check if validateMarkdownAgainstOfs is available
-        if (flexMd.validateMarkdownAgainstOfs && typeof flexMd.validateMarkdownAgainstOfs === 'function') {
-            try {
-                // Try to validate - this might require a spec, so we catch errors
-                const result = flexMd.validateMarkdownAgainstOfs(instructionsText, { strictness: complianceLevel });
-                // If validation passes, instructions meet compliance
-                if (result && result.valid !== false) {
-                    return true;
-                }
-            }
-            catch (e) {
-                // Validation function might need more parameters, fall through to pattern matching
-            }
-        }
-    }
-    catch (error) {
-        // flex-md SDK not available or error - fall through to pattern matching
-    }
-    // Fallback: Pattern-based checking
-    const text = instructionsText.toLowerCase();
-    // Check for key flex-md enforcement phrases
-    const flexMdIndicators = [
-        'markdown',
-        'fenced block',
-        '```markdown',
-        '```json',
-        'reply in markdown',
-        'return your entire answer'
-    ];
-    // Check for enforcement language based on compliance level
-    const enforcementIndicators = [];
-    if (complianceLevel === 'L2' || complianceLevel === 'L3') {
-        // L2/L3 require fenced block container
-        enforcementIndicators.push('fenced block', '```markdown', 'single ```markdown', 'entire answer inside', 'nothing else');
-    }
-    if (complianceLevel === 'L1' || complianceLevel === 'L2' || complianceLevel === 'L3') {
-        // L1+ requires section headings
-        enforcementIndicators.push('section', 'heading', 'include these');
+        return fallback;
     }
-    // Must have at least one flex-md indicator AND appropriate enforcement indicators
-    const hasFlexMd = flexMdIndicators.some(indicator => text.includes(indicator));
-    const hasEnforcement = enforcementIndicators.length === 0 ||
-        enforcementIndicators.some(indicator => text.includes(indicator));
-    return hasFlexMd && hasEnforcement;
+    const err = new Error(`User message requires prompt template text or workingMemory.input. Provide prompt or workingMemory.input.`);
+    err.code = 'USER_CONTENT_REQUIRED';
+    err.details = {
+        hasPrompt: hasNonEmptyPrompt(request.prompt),
+        hasWorkingMemory: !!request.workingMemory,
+        hasInputInWorkingMemory: false
+    };
+    logger.error('No prompt or workingMemory.input for user message', {
+        jobId: request.identity.jobId,
+        agentId: request.agentId,
+        errorCode: 'USER_CONTENT_REQUIRED'
+    });
+    throw err;
 }
 /**
  * Main function to build messages
@@ -247,13 +180,11 @@ export async function buildMessages(request, config, options = {}) {
     const { parsedSnapshot } = options;
     const { logger } = config;
     const messages = [];
-    // Step 1: Instructions as template text (parsed with full memory context)
-    let instructionsText = '';
-    // Extract memory context from options
     const shortTermMemory = options.shortTermMemory;
     const experienceMemory = options.experienceMemory;
     const knowledgeMemory = options.knowledgeMemory;
     const templateRenderOptions = mergeGatewayAndRequestTemplateRenderOptions(config.templateRendering, request);
+    let instructionsText = '';
     if (request.instructions) {
         if (typeof request.instructions === 'string') {
             logger.info('Using instructions as template text', {
@@ -268,16 +199,9 @@ export async function buildMessages(request, config, options = {}) {
             instructionsText = JSON.stringify(request.instructions);
         }
     }
-    // NO SYSTEM CONTEXT FALLBACK - removed default instruction fallback
-    // Instructions must be provided explicitly - no defaults allowed
-    // If instructionsText is empty here, it's a bad request
-    // Step 2: Parse instructions template with full memory context
-    // Rendrix handles token resolution, so we just parse directly
     if (instructionsText) {
-        instructionsText = await parseTemplate(instructionsText, request.workingMemory, undefined, // taskConfig removed - no longer used
-        shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
+        instructionsText = await parseTemplate(instructionsText, request.workingMemory, undefined, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
     }
-    // Instructions must be provided explicitly — no packaged block injection
     if (!instructionsText || instructionsText.trim() === '') {
         const errorMessage = 'No instructions available - cannot proceed without clear instructions. This is a bad request.';
         logger.error(errorMessage, {
@@ -292,11 +216,9 @@ export async function buildMessages(request, config, options = {}) {
         role: 'system',
         content: instructionsText
     });
-    // Store resolved/parsed content for activity (parsed = content after resolution + Rendrix, not the key)
     if (parsedSnapshot) {
         parsedSnapshot.instructions = instructionsText;
     }
-    // Log the final system message for verification
     logger.info('Final system message constructed', {
         jobId: request.identity.jobId,
         agentId: request.agentId,
@@ -305,65 +227,34 @@ export async function buildMessages(request, config, options = {}) {
         hasFencedBlock: instructionsText.includes('```markdown'),
         hasJson: instructionsText.toLowerCase().includes('json'),
         messagePreview: instructionsText.substring(0, 500),
-        fullMessage: instructionsText // Log full message for debugging
+        fullMessage: instructionsText
     });
-    // Step 7: Add context (if provided) with full memory context
-    if (request.context) {
-        const contextText = typeof request.context === 'string' ? request.context : JSON.stringify(request.context);
-        const parsedContext = await parseTemplate(contextText, request.workingMemory, undefined, // taskConfig removed - no longer used
-        shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
-        if (parsedContext && parsedContext.trim() !== '') {
-            messages.push({
-                role: 'assistant',
-                content: parsedContext
-            });
-        }
-    }
-    // Step 8: Build user message with full memory context
     const userMessage = await buildUserMessage(request, config, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions);
-    if (userMessage && userMessage.trim() !== '') {
-        messages.push({
-            role: 'user',
-            content: userMessage
-        });
-        // Store resolved/parsed prompt for activity (parsed = content after resolution + Rendrix, not the key)
-        if (parsedSnapshot) {
-            parsedSnapshot.prompt = userMessage;
-        }
-        // Log the user message for verification
-        logger.info('Final user message constructed', {
+    if (!userMessage || userMessage.trim() === '') {
+        const err = new Error(`User message is required but was empty after prompt render or input fallback.`);
+        err.code = 'USER_CONTENT_REQUIRED';
+        logger.error('User message empty after build', {
             jobId: request.identity.jobId,
             agentId: request.agentId,
-            messageLength: userMessage.length,
-            messagePreview: userMessage.substring(0, 200),
-            fullMessage: userMessage // Log full message for debugging
+            errorCode: 'USER_CONTENT_REQUIRED',
+            hasPrompt: hasNonEmptyPrompt(request.prompt)
         });
+        throw err;
     }
-    else {
-        // If prompt was provided, we MUST have a user message - this is an error
-        if (request.prompt) {
-            const err = new Error(`Prompt template was provided but no user message was created. The template may have rendered to empty or failed to resolve.`);
-            err.code = 'PROMPT_NO_USER_MESSAGE';
-            err.details = {
-                promptPreview: typeof request.prompt === 'string' ? request.prompt.substring(0, 200) : request.prompt,
-                hasWorkingMemory: !!request.workingMemory
-            };
-            logger.error('Prompt provided but no user message created', {
-                jobId: request.identity.jobId,
-                agentId: request.agentId,
-                prompt: request.prompt,
-                errorCode: 'PROMPT_NO_USER_MESSAGE'
-            });
-            throw err;
-        }
-        // If no prompt was provided, it's just a warning (input-only requests are valid)
-        logger.warn('No user message to add', {
-            jobId: request.identity.jobId,
-            agentId: request.agentId,
-            hasPrompt: !!request.prompt
-        });
+    messages.push({
+        role: 'user',
+        content: userMessage
+    });
+    if (parsedSnapshot) {
+        parsedSnapshot.prompt = userMessage;
     }
-    // Log complete message structure
+    logger.info('Final user message constructed', {
+        jobId: request.identity.jobId,
+        agentId: request.agentId,
+        messageLength: userMessage.length,
+        messagePreview: userMessage.substring(0, 200),
+        fullMessage: userMessage
+    });
     logger.info('Complete message structure', {
         jobId: request.identity.jobId,
         agentId: request.agentId,

package/dist/openrouter-runtime-adapter/create-openrouter-runtime-provider.js

@@ -1,6 +1,33 @@
 import { createOpenRouterRuntime, RuntimeConfigError, OpenRouterHttpError, } from '@x12i/openrouter-runtime';
 import { OPENROUTER_RUNTIME_OPERATION } from './map-gateway-request.js';
 import { throwMappedOpenRouterHttpError, throwMappedRuntimeConfigError, throwMappedRuntimeResponseErrors, } from './map-runtime-errors.js';
+function summarizeServerTools(serverTools) {
+    if (!serverTools)
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(serverTools)) {
+        if (Array.isArray(value)) {
+            out[key] = value.map((item) => item.mode).join(',');
+            continue;
+        }
+        if (value && typeof value === 'object' && 'mode' in value && typeof value.mode === 'string') {
+            out[key] = value.mode;
+        }
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+function summarizeCompiledTools(compiled) {
+    const tools = Array.isArray(compiled.body.tools) ? compiled.body.tools : [];
+    const toolTypes = tools
+        .map((tool) => (tool && typeof tool === 'object' && 'type' in tool ? String(tool.type) : undefined))
+        .filter((type) => typeof type === 'string');
+    return {
+        apiMode: compiled.apiMode,
+        toolCount: tools.length,
+        toolTypes,
+        bodyKeys: Object.keys(compiled.body),
+    };
+}
 export function createOpenRouterRuntimeProvider(options) {
     const runtime = options.runtime ??
         createOpenRouterRuntime({
@@ -9,6 +36,22 @@ export function createOpenRouterRuntimeProvider(options) {
                 retry: { enabled: false },
                 onPolicyViolation: 'throw',
             },
+            logger: options.logger
+                ? {
+                    debug: (event, data) => options.logger?.debug(event, data),
+                    info: (event, data) => options.logger?.info(event, data),
+                    warn: (event, data) => options.logger?.warn(event, data),
+                    error: (event, data) => options.logger?.error(event, data),
+                }
+                : undefined,
+            hooks: options.logger
+                ? {
+                    beforeOpenRouterRequest: (compiled) => {
+                        const summary = summarizeCompiledTools(compiled);
+                        options.logger?.debug('OpenRouter runtime compiled request tools', summary);
+                    },
+                }
+                : undefined,
         });
     return {
         name: 'openrouter',
@@ -22,6 +65,17 @@ export function createOpenRouterRuntimeProvider(options) {
                 throw new Error(`Unsupported OpenRouter runtime operation: ${spec.operation}`);
             }
             const runtimeRequest = spec.args;
+            const rawOverrideKeys = runtimeRequest.rawOpenRouterOverrides
+                ? Object.keys(runtimeRequest.rawOpenRouterOverrides)
+                : [];
+            options.logger?.debug('OpenRouter runtime request server tools', {
+                requestId: spec.requestId,
+                model: runtimeRequest.model,
+                apiMode: runtimeRequest.apiMode,
+                serverTools: summarizeServerTools(runtimeRequest.serverTools),
+                rawOverrideKeys,
+                rawOverridesToolsPresent: Object.prototype.hasOwnProperty.call(runtimeRequest.rawOpenRouterOverrides ?? {}, 'tools'),
+            });
             try {
                 const response = await runtime.run(runtimeRequest);
                 if (response.status !== 'completed') {

package/dist/openrouter-runtime-adapter/map-gateway-request.js

@@ -22,14 +22,30 @@ function buildGenerationOverrides(config) {
         overrides.stop = config.stop;
     return overrides;
 }
+function hasActiveServerTools(serverTools) {
+    if (!serverTools)
+        return false;
+    return Object.values(serverTools).some((value) => {
+        if (Array.isArray(value))
+            return value.some((item) => item.mode !== 'disabled');
+        return !!value && value.mode !== 'disabled';
+    });
+}
+function buildRawOpenRouterOverrides(generationOverrides, trustedRaw, serverTools) {
+    const raw = { ...trustedRaw };
+    if (hasActiveServerTools(serverTools)) {
+        delete raw.tools;
+    }
+    const merged = { ...generationOverrides, ...raw };
+    return Object.keys(merged).length ? merged : undefined;
+}
 export function mapGatewayRequestToRuntimeRequest(request, exec) {
     const config = request.config ?? {};
     const openrouter = config.openrouter;
     const generationOverrides = buildGenerationOverrides(config);
     const trustedRaw = openrouter?.rawOverrides ?? {};
-    const rawOpenRouterOverrides = Object.keys(generationOverrides).length || Object.keys(trustedRaw).length
-        ? { ...generationOverrides, ...trustedRaw }
-        : undefined;
+    const serverTools = mapGatewayServerTools(config.serverTools);
+    const rawOpenRouterOverrides = buildRawOpenRouterOverrides(generationOverrides, trustedRaw, serverTools);
     const aiRequestId = (typeof request.aiRequestId === 'string' && request.aiRequestId) ||
         (typeof request.identity?.aiRequestId === 'string' ? request.identity.aiRequestId : undefined);
     return {
@@ -42,7 +58,7 @@ export function mapGatewayRequestToRuntimeRequest(request, exec) {
         reasoning: config.reasoning != null && typeof config.reasoning === 'object'
             ? config.reasoning
             : undefined,
-        serverTools: mapGatewayServerTools(config.serverTools),
+        serverTools,
         execution: exec?.timeoutMs ? { timeoutMs: exec.timeoutMs } : undefined,
         rawOpenRouterOverrides,
         metadata: {

package/dist/openrouter-runtime-adapter/validate-server-tools.js

@@ -73,22 +73,12 @@ export function applyPostRoutingServerToolsPolicy(input) {
         return { serverTools, warnings, forceOpenRouter: false };
     }
     validateApplyPatchConfig(serverTools, openrouter);
-    if (hasRequiredServerTool(serverTools)) {
-        if (!openRouterApiKey) {
-            throw new ProviderConfigError('OPENROUTER_SERVER_TOOL_REQUIRES_KEY', 'Required OpenRouter server tools need OPENROUTER_API_KEY or GatewayConfig.openrouter.apiKey', { codeAliases: ['OPENROUTER_SERVER_TOOL_REQUIRES_OPENROUTER_KEY'] });
-        }
-        if (provider !== 'openrouter') {
-            provider = 'openrouter';
-            return { serverTools, warnings, forceOpenRouter: true };
-        }
-        return { serverTools, warnings, forceOpenRouter: false };
+    if (!openRouterApiKey) {
+        throw new ProviderConfigError('OPENROUTER_SERVER_TOOL_REQUIRES_KEY', 'OpenRouter server tools need OPENROUTER_API_KEY or GatewayConfig.openrouter.apiKey', { codeAliases: ['OPENROUTER_SERVER_TOOL_REQUIRES_OPENROUTER_KEY'] });
     }
     if (provider !== 'openrouter') {
-        warnings.push({
-            code: 'SERVER_TOOLS_IGNORED_FOR_NON_OPENROUTER_PROVIDER',
-            message: 'OpenRouter server tools were requested but the final provider is not openrouter; tools were stripped',
-        });
-        return { serverTools: undefined, warnings, forceOpenRouter: false };
+        provider = 'openrouter';
+        return { serverTools, warnings, forceOpenRouter: true };
     }
     return { serverTools, warnings, forceOpenRouter: false };
 }