@x12i/ai-providers-router 4.6.5 → 4.7.0

package/dist/errors.d.ts

@@ -25,3 +25,10 @@ export declare class ProviderNotInstalledError extends Error {
     packageName: string;
     constructor(providerName: ProviderId | string, packageName: string);
 }
+export declare class ProviderTimeoutError extends Error {
+    provider: ProviderId | string;
+    timeoutMs: number;
+    operation?: string | undefined;
+    code: "ETIMEDOUT";
+    constructor(provider: ProviderId | string, timeoutMs: number, operation?: string | undefined);
+}

package/dist/errors.js

@@ -31,3 +31,14 @@ export class ProviderNotInstalledError extends Error {
         Object.setPrototypeOf(this, ProviderNotInstalledError.prototype);
     }
 }
+export class ProviderTimeoutError extends Error {
+    constructor(provider, timeoutMs, operation) {
+        super(`Provider '${provider}' request timed out after ${timeoutMs}ms`);
+        this.provider = provider;
+        this.timeoutMs = timeoutMs;
+        this.operation = operation;
+        this.code = 'ETIMEDOUT';
+        this.name = 'ProviderTimeoutError';
+        Object.setPrototypeOf(this, ProviderTimeoutError.prototype);
+    }
+}

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { LLMProviderRouter } from './router.js';
 export type { RouterConfig, HealthCheckResult, ProviderId, AIRouterRequest, AIResponse, AIStreamEvent, AIBatchResponse, AIBatchRequestItem, } from './router.js';
 export { createRouter, createRouterFromConfig } from './factory.js';
 export type { CreateRouterConfig } from './factory.js';
-export { ProviderNotFoundError, FallbackExhaustedError, ProviderNotInstalledError } from './errors.js';
+export { ProviderNotFoundError, FallbackExhaustedError, ProviderNotInstalledError, ProviderTimeoutError } from './errors.js';
 export type { RequestInterceptor, ResponseInterceptor } from './interceptors.js';
 export type { UsageTracker, AdapterLoader, ProviderInit } from './types.js';
 export { Logger, getLogger, createLogger } from './logger.js';

package/dist/index.js

@@ -37,6 +37,6 @@ export {
 // Factory functions
 export { createRouter, createRouterFromConfig } from './factory.js';
 // Error classes
-export { ProviderNotFoundError, FallbackExhaustedError, ProviderNotInstalledError } from './errors.js';
+export { ProviderNotFoundError, FallbackExhaustedError, ProviderNotInstalledError, ProviderTimeoutError } from './errors.js';
 // Logger
 export { Logger, getLogger, createLogger } from './logger.js';

package/dist/openrouter-catalog.js

@@ -214,6 +214,11 @@ export class OpenRouterCatalogLoader {
                 return model.openrouterId;
             }
         }
+        // Best-effort fallback: if we have a provider hint and the model is bare,
+        // still prefix it (helps with very new models like `gpt-5.5` before catalog refresh).
+        if (providerHint && !modelName.includes('/')) {
+            return `${providerHint}/${modelName}`;
+        }
         // Last resort: return as-is (might be a direct model name)
         return modelName;
     }

package/dist/providers/OpenRouterProvider.js

@@ -3,17 +3,20 @@
  * This properly implements the ProviderModule interface for OpenRouter
  */
 import { OpenRouter } from '@openrouter/sdk';
+import { ProviderTimeoutError } from '../errors.js';
 /**
  * Create OpenRouter ProviderModule using @openrouter/sdk directly
  */
 export function createOpenRouterProvider(config) {
-    const client = new OpenRouter({
+    const defaultClient = new OpenRouter({
         apiKey: config.apiKey,
         serverURL: config.baseURL || 'https://openrouter.ai/api/v1',
         httpReferer: config.httpReferer,
         xTitle: config.xTitle,
         timeoutMs: config.timeoutMs,
     });
+    // Optional test seam (non-breaking): allow injecting a client override
+    const client = config.client || defaultClient;
     return {
         name: 'openrouter',
         capabilities: {
@@ -31,16 +34,42 @@ export function createOpenRouterProvider(config) {
         },
         async execute(spec) {
             const { operation, args, exec } = spec;
-            // Create AbortController for timeout
-            const controller = new AbortController();
+            const timeoutMs = exec?.timeoutMs;
+            let timedOut = false;
+            // Only create a controller if we need to enforce a timeout or bridge signals.
+            const controller = timeoutMs ? new AbortController() : null;
             let timeoutId = null;
-            if (exec?.timeoutMs) {
+            if (timeoutMs && controller) {
                 timeoutId = setTimeout(() => {
-                    controller.abort();
-                }, exec.timeoutMs);
+                    timedOut = true;
+                    try {
+                        controller.abort();
+                    }
+                    catch {
+                        // Defensive: abort() should not be able to crash the process.
+                    }
+                }, timeoutMs);
             }
-            // Use exec.signal if provided, otherwise use our timeout controller
-            const signal = exec?.signal || controller.signal;
+            // If caller provided a signal, bridge it into our controller (if we have one).
+            // Otherwise, just use the caller signal directly.
+            let bridgedAbortListener = null;
+            if (exec?.signal && controller) {
+                bridgedAbortListener = () => {
+                    try {
+                        controller.abort();
+                    }
+                    catch {
+                        // ignore
+                    }
+                };
+                if (exec.signal.aborted) {
+                    bridgedAbortListener();
+                }
+                else {
+                    exec.signal.addEventListener('abort', bridgedAbortListener, { once: true });
+                }
+            }
+            const signal = controller?.signal || exec?.signal;
             try {
                 let rawResponse;
                 if (operation === 'openai.responses.create' || operation === 'openai.chat.completions.create') {
@@ -92,24 +121,54 @@ export function createOpenRouterProvider(config) {
                 };
             }
             catch (error) {
-                if (timeoutId) {
-                    clearTimeout(timeoutId);
+                if (timedOut && typeof timeoutMs === 'number') {
+                    throw new ProviderTimeoutError('openrouter', timeoutMs, operation);
                 }
                 throw error;
             }
+            finally {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (exec?.signal && bridgedAbortListener) {
+                    exec.signal.removeEventListener('abort', bridgedAbortListener);
+                }
+            }
         },
         async *stream(spec) {
             const { operation, args, exec } = spec;
-            // Create AbortController for timeout
-            const controller = new AbortController();
+            const timeoutMs = exec?.timeoutMs;
+            let timedOut = false;
+            const controller = timeoutMs ? new AbortController() : null;
             let timeoutId = null;
-            if (exec?.timeoutMs) {
+            if (timeoutMs && controller) {
                 timeoutId = setTimeout(() => {
-                    controller.abort();
-                }, exec.timeoutMs);
+                    timedOut = true;
+                    try {
+                        controller.abort();
+                    }
+                    catch {
+                        // ignore
+                    }
+                }, timeoutMs);
             }
-            // Use exec.signal if provided, otherwise use our timeout controller
-            const signal = exec?.signal || controller.signal;
+            let bridgedAbortListener = null;
+            if (exec?.signal && controller) {
+                bridgedAbortListener = () => {
+                    try {
+                        controller.abort();
+                    }
+                    catch {
+                        // ignore
+                    }
+                };
+                if (exec.signal.aborted) {
+                    bridgedAbortListener();
+                }
+                else {
+                    exec.signal.addEventListener('abort', bridgedAbortListener, { once: true });
+                }
+            }
+            const signal = controller?.signal || exec?.signal;
             try {
                 if (operation === 'openai.responses.stream' || operation === 'openai.chat.completions.stream') {
                     // Convert args to OpenRouter SDK format
@@ -161,11 +220,18 @@ export function createOpenRouterProvider(config) {
                 }
             }
             catch (error) {
-                if (timeoutId) {
-                    clearTimeout(timeoutId);
+                if (timedOut && typeof timeoutMs === 'number') {
+                    throw new ProviderTimeoutError('openrouter', timeoutMs, operation);
                 }
                 throw error;
             }
+            finally {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (exec?.signal && bridgedAbortListener) {
+                    exec.signal.removeEventListener('abort', bridgedAbortListener);
+                }
+            }
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x12i/ai-providers-router",
-  "version": "4.6.5",
+  "version": "4.7.0",
   "description": "Unified router for all LLM provider implementations",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,7 @@
     "build": "tsc",
     "fix:imports": "node fix-import-extensions.js",
     "prepublishOnly": "rm -rf dist && npm run build && node -e \"import('fs').then(fs => fs.accessSync('dist/index.js'))\"",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "npm run build && node --test .tests/**/*.test.js",
     "test:openai": "ts-node .tests/callOpenAI.ts",
     "test:grok": "ts-node .tests/testOpenRouter.ts",
     "test:catalog": "ts-node .tests/testCatalog.ts",