@jaypie/llm 1.2.32 → 1.2.34

package/dist/cjs/operate/adapters/OpenRouterAdapter.d.ts

@@ -82,11 +82,26 @@ interface OpenRouterRequest {
     user?: string;
 }
 /**
- * OpenRouter content part types (text only - images/files not supported)
+ * OpenRouter content part types. OpenRouter follows the OpenAI Chat
+ * Completions multimodal schema and forwards `image_url` and `file` parts
+ * to vision/PDF-capable backends. The SDK accepts camelCase fields at the
+ * input boundary (`imageUrl`, `fileData`) and transforms to snake_case on
+ * the wire.
  */
 type OpenRouterContentPart = {
     type: "text";
     text: string;
+} | {
+    type: "image_url";
+    imageUrl: {
+        url: string;
+    };
+} | {
+    type: "file";
+    file: {
+        filename?: string;
+        fileData: string;
+    };
 };
 /**
  * OpenRouterAdapter implements the ProviderAdapter interface for OpenRouter's API.
@@ -101,6 +116,10 @@ export declare class OpenRouterAdapter extends BaseProviderAdapter {
     rememberModelRejectsStructuredOutput(model: string): void;
     clearRuntimeNoStructuredOutputModels(): void;
     private supportsStructuredOutput;
+    private runtimeNoTemperatureModels;
+    rememberModelRejectsTemperature(model: string): void;
+    clearRuntimeNoTemperatureModels(): void;
+    private supportsTemperature;
     buildRequest(request: OperateRequest): OpenRouterRequest;
     formatTools(toolkit: Toolkit, _outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;

package/dist/cjs/operate/retry/createStaleRejectionGuard.d.ts

@@ -0,0 +1,19 @@
+export interface StaleRejectionGuard {
+    /** Install the unhandledRejection listener (idempotent) */
+    install(): void;
+    /** Remove the listener and forget recorded errors */
+    remove(): void;
+    /** Record an error the retry loop has caught and is handling */
+    recordCaught(error: unknown): void;
+}
+/**
+ * Create a guard that suppresses unhandled rejections firing as siblings of
+ * an error the retry loop has already caught. Provider SDKs occasionally
+ * surface a single upstream failure as twin rejections — the retry layer
+ * accepts responsibility for the first; this guard prevents the second from
+ * crashing the host while the retry is in flight.
+ *
+ * The guard also continues to suppress transient socket teardown errors
+ * (e.g. undici `TypeError: terminated`) emitted between attempts.
+ */
+export declare function createStaleRejectionGuard(): StaleRejectionGuard;

package/dist/esm/index.js

@@ -1197,11 +1197,11 @@ const NOT_RETRYABLE_ERROR_NAMES = [
 // Patterns (not exact names) so dated variants and future releases are covered
 // without code changes — Anthropic is trending toward removing temperature on
 // newer Claude models.
-const MODELS_WITHOUT_TEMPERATURE$1 = [
+const MODELS_WITHOUT_TEMPERATURE$2 = [
     /^claude-opus-4-[789]/,
     /^claude-opus-[5-9]/,
 ];
-function isTemperatureDeprecationError$1(error) {
+function isTemperatureDeprecationError$2(error) {
     if (!error || typeof error !== "object")
         return false;
     const err = error;
@@ -1271,7 +1271,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
     supportsTemperature(model) {
         if (this.runtimeNoTemperatureModels.has(model))
             return false;
-        return !MODELS_WITHOUT_TEMPERATURE$1.some((pattern) => pattern.test(model));
+        return !MODELS_WITHOUT_TEMPERATURE$2.some((pattern) => pattern.test(model));
     }
     supportsStructuredOutput(model) {
         return !this.runtimeNoStructuredOutputModels.has(model);
@@ -1449,7 +1449,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 return undefined;
             // If the model rejected `temperature`, cache it and retry without the param
             if (anthropicRequest.temperature !== undefined &&
-                isTemperatureDeprecationError$1(error)) {
+                isTemperatureDeprecationError$2(error)) {
                 this.rememberModelRejectsTemperature(anthropicRequest.model);
                 const retryRequest = { ...anthropicRequest };
                 delete retryRequest.temperature;
@@ -1510,7 +1510,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         }
         catch (error) {
             if (streamRequest.temperature !== undefined &&
-                isTemperatureDeprecationError$1(error)) {
+                isTemperatureDeprecationError$2(error)) {
                 this.rememberModelRejectsTemperature(streamRequest.model);
                 streamRequest = {
                     ...streamRequest,
@@ -2237,14 +2237,24 @@ class GeminiAdapter extends BaseProviderAdapter {
     // Tool Result Handling
     //
     formatToolResult(toolCall, result) {
-        // Gemini expects the response to be the actual result object, not wrapped in "result"
-        // The output from StandardToolResult is JSON-stringified, so we need to parse it
+        // Gemini's `function_response.response` is a protobuf Struct, which only
+        // accepts plain objects. Some models (e.g. gemini-3.1-pro) accept scalar
+        // values silently; gemini-3.1-flash-lite rejects them. Parse the output
+        // and wrap any non-object value (string, number, boolean, array, null)
+        // in `{ result: value }` so every tool result is a valid Struct.
         let responseData;
         try {
-            responseData = JSON.parse(result.output);
+            const parsed = JSON.parse(result.output);
+            if (parsed !== null &&
+                typeof parsed === "object" &&
+                !Array.isArray(parsed)) {
+                responseData = parsed;
+            }
+            else {
+                responseData = { result: parsed };
+            }
         }
         catch {
-            // If parsing fails, wrap the output as a string result
             responseData = { result: result.output };
         }
         return {
@@ -2665,11 +2675,11 @@ const NOT_RETRYABLE_ERROR_TYPES = [
 // Patterns (not exact names) so dated variants and future releases are covered
 // without code changes — OpenAI is removing temperature on newer reasoning
 // models.
-const MODELS_WITHOUT_TEMPERATURE = [
+const MODELS_WITHOUT_TEMPERATURE$1 = [
     /^gpt-5\.5/, // gpt-5.5 series deprecated temperature
     /^o\d/, // o-series reasoning models (o1, o3, o4, ...)
 ];
-function isTemperatureDeprecationError(error) {
+function isTemperatureDeprecationError$1(error) {
     if (!error || typeof error !== "object")
         return false;
     if (!(error instanceof BadRequestError) &&
@@ -2709,7 +2719,7 @@ class OpenAiAdapter extends BaseProviderAdapter {
     supportsTemperature(model) {
         if (this.runtimeNoTemperatureModels.has(model))
             return false;
-        return !MODELS_WITHOUT_TEMPERATURE.some((pattern) => pattern.test(model));
+        return !MODELS_WITHOUT_TEMPERATURE$1.some((pattern) => pattern.test(model));
     }
     //
     // Request Building
@@ -2816,7 +2826,7 @@ class OpenAiAdapter extends BaseProviderAdapter {
                 return undefined;
             // If the model rejected `temperature`, cache it and retry without the param
             if (openaiRequest.temperature !== undefined &&
-                isTemperatureDeprecationError(error)) {
+                isTemperatureDeprecationError$1(error)) {
                 this.rememberModelRejectsTemperature(openaiRequest.model);
                 const retryRequest = { ...openaiRequest };
                 delete retryRequest.temperature;
@@ -3166,10 +3176,31 @@ function isStructuredOutputUnsupportedError(error) {
     const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
     return messages.some((m) => /response_format|json[_ ]schema|structured[_ ]output|require[_ ]parameters/i.test(m));
 }
+// OpenRouter routes that don't accept `temperature`. Patterns match the
+// vendor-prefixed route id (e.g. `openai/gpt-5.5`) so dated variants are
+// covered without code changes.
+const MODELS_WITHOUT_TEMPERATURE = [
+    /^openai\/gpt-5\.5/,
+    /^openai\/o\d/,
+    /^anthropic\/claude-opus-4-[789]/,
+    /^anthropic\/claude-opus-[5-9]/,
+];
+function isTemperatureDeprecationError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    const status = err.status ?? err.statusCode;
+    if (status !== 400)
+        return false;
+    const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
+    return messages.some((m) => m.toLowerCase().includes("temperature"));
+}
 /**
- * Convert standardized content items to OpenRouter format
- * Note: OpenRouter does not support native file/image uploads.
- * Images and files are discarded with a warning.
+ * Convert standardized content items to OpenRouter format. Images become
+ * `image_url` parts and files become `file` parts; both pass through to
+ * OpenRouter which routes to the selected backend. Backends that don't
+ * support the modality 4xx — that's a model-capability mismatch, surfaced
+ * by the call rather than silently dropped here.
  */
 function convertContentToOpenRouter(content) {
     if (typeof content === "string") {
@@ -3177,25 +3208,38 @@ function convertContentToOpenRouter(content) {
     }
     const parts = [];
     for (const item of content) {
-        // Text content - pass through
         if (item.type === LlmMessageType.InputText) {
             parts.push({ type: "text", text: item.text });
             continue;
         }
-        // Image content - warn and discard
         if (item.type === LlmMessageType.InputImage) {
-            log$1.warn("OpenRouter does not support image uploads; image discarded");
+            const url = item.image_url ?? "";
+            if (!url) {
+                log$1.warn("OpenRouter image content missing image_url; image discarded");
+                continue;
+            }
+            parts.push({ type: "image_url", imageUrl: { url } });
             continue;
         }
-        // File/Document content - warn and discard
         if (item.type === LlmMessageType.InputFile) {
-            log$1.warn({ filename: item.filename }, "OpenRouter does not support file uploads; file discarded");
+            const fileData = typeof item.file_data === "string" ? item.file_data : "";
+            if (!fileData) {
+                log$1.warn({ filename: item.filename }, "OpenRouter file content missing file_data; file discarded");
+                continue;
+            }
+            parts.push({
+                type: "file",
+                file: {
+                    filename: item.filename,
+                    fileData,
+                },
+            });
             continue;
         }
         // Unknown type - warn and skip
         log$1.warn({ item }, "Unknown content type for OpenRouter; discarded");
     }
-    // If no text parts remain, return empty string to avoid empty array
+    // If no parts remain, return empty string to avoid empty array
     if (parts.length === 0) {
         return "";
     }
@@ -3249,6 +3293,9 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         // `response_format: json_schema`. When a model is in this set, buildRequest
         // engages the legacy fake-tool path instead of native structured output.
         this.runtimeNoStructuredOutputModels = new Set();
+        // Session-level cache of routes observed to reject `temperature`. Populated
+        // by executeRequest on 400 errors so repeat calls skip the param.
+        this.runtimeNoTemperatureModels = new Set();
     }
     rememberModelRejectsStructuredOutput(model) {
         this.runtimeNoStructuredOutputModels.add(model);
@@ -3259,6 +3306,17 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     supportsStructuredOutput(model) {
         return !this.runtimeNoStructuredOutputModels.has(model);
     }
+    rememberModelRejectsTemperature(model) {
+        this.runtimeNoTemperatureModels.add(model);
+    }
+    clearRuntimeNoTemperatureModels() {
+        this.runtimeNoTemperatureModels.clear();
+    }
+    supportsTemperature(model) {
+        if (this.runtimeNoTemperatureModels.has(model))
+            return false;
+        return !MODELS_WITHOUT_TEMPERATURE.some((pattern) => pattern.test(model));
+    }
     //
     // Request Building
     //
@@ -3328,6 +3386,12 @@ class OpenRouterAdapter extends BaseProviderAdapter {
             openRouterRequest.temperature =
                 request.temperature;
         }
+        // Strip temperature for routes that don't support it (denylist + runtime cache)
+        const requestRecord = openRouterRequest;
+        if (requestRecord.temperature !== undefined &&
+            !this.supportsTemperature(openRouterRequest.model)) {
+            delete requestRecord.temperature;
+        }
         return openRouterRequest;
     }
     formatTools(toolkit, 
@@ -3354,11 +3418,18 @@ class OpenRouterAdapter extends BaseProviderAdapter {
             jsonSchema.type = "object"; // Normalize type
         }
         else {
-            // Convert NaturalSchema to JSON schema through Zod
+            // Convert NaturalSchema to JSON schema through Zod. Re-spread into a
+            // plain object: Zod v4's z.toJSONSchema returns an object that carries
+            // a non-configurable `~standard` Standard-Schema interop marker as a
+            // non-enumerable own property. Anthropic's output_config.format
+            // validation is strict and rejects unknown properties when OpenRouter
+            // forwards the schema, so we drop the marker here. JSON.stringify
+            // already skips it but the OpenRouter SDK enumerates own properties
+            // during serialization.
             const zodSchema = schema instanceof z.ZodType
                 ? schema
                 : naturalZodSchema(schema);
-            jsonSchema = z.toJSONSchema(zodSchema);
+            jsonSchema = { ...z.toJSONSchema(zodSchema) };
         }
         // Remove $schema property (can cause issues with some providers)
         if (jsonSchema.$schema) {
@@ -3386,6 +3457,20 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         catch (error) {
             if (signal?.aborted)
                 return undefined;
+            // If the route rejected `temperature` (e.g., openai/gpt-5.5 forwarding),
+            // cache it and retry without the param.
+            const requestRecord = openRouterRequest;
+            if (requestRecord.temperature !== undefined &&
+                isTemperatureDeprecationError(error)) {
+                this.rememberModelRejectsTemperature(openRouterRequest.model);
+                const retryRequest = { ...openRouterRequest };
+                delete retryRequest.temperature;
+                const response = (await openRouter.chat.send(this.toSdkChatParams(retryRequest), signal ? { signal } : undefined));
+                if (wantsStructuredOutput) {
+                    response.__jaypieStructuredOutput = true;
+                }
+                return response;
+            }
             // If the model rejected `response_format`, cache it and retry with the
             // legacy fake-tool emulation path.
             if (wantsStructuredOutput && isStructuredOutputUnsupportedError(error)) {
@@ -4730,6 +4815,78 @@ class RetryPolicy {
 // Export a default policy instance
 const defaultRetryPolicy = new RetryPolicy();
 
+//
+//
+// Helpers
+//
+/**
+ * Compare an unhandled rejection reason against errors the retry loop has
+ * already caught. Reference equality first, then fall back to message + name
+ * — providers sometimes surface twin rejections as fresh Error instances
+ * rebuilt from the same upstream failure.
+ */
+function matchesCaughtError(reason, caught) {
+    if (caught.has(reason))
+        return true;
+    if (!(reason instanceof Error))
+        return false;
+    for (const handled of caught) {
+        if (handled instanceof Error &&
+            handled.name === reason.name &&
+            handled.message === reason.message) {
+            return true;
+        }
+    }
+    return false;
+}
+//
+//
+// Main
+//
+/**
+ * Create a guard that suppresses unhandled rejections firing as siblings of
+ * an error the retry loop has already caught. Provider SDKs occasionally
+ * surface a single upstream failure as twin rejections — the retry layer
+ * accepts responsibility for the first; this guard prevents the second from
+ * crashing the host while the retry is in flight.
+ *
+ * The guard also continues to suppress transient socket teardown errors
+ * (e.g. undici `TypeError: terminated`) emitted between attempts.
+ */
+function createStaleRejectionGuard() {
+    const log = getLogger$5();
+    const caughtErrors = new Set();
+    let listener;
+    return {
+        install() {
+            if (listener)
+                return;
+            listener = (reason, promise) => {
+                if (isTransientNetworkError(reason)) {
+                    promise?.catch?.(() => { });
+                    log.trace("Suppressed stale socket error during retry");
+                    return;
+                }
+                if (matchesCaughtError(reason, caughtErrors)) {
+                    promise?.catch?.(() => { });
+                    log.trace("Suppressed sibling rejection of already-handled error");
+                }
+            };
+            process.on("unhandledRejection", listener);
+        },
+        remove() {
+            if (listener) {
+                process.removeListener("unhandledRejection", listener);
+                listener = undefined;
+            }
+            caughtErrors.clear();
+        },
+        recordCaught(error) {
+            caughtErrors.add(error);
+        },
+    };
+}
+
 //
 //
 // Main
@@ -4758,27 +4915,11 @@ class RetryExecutor {
     async execute(operation, options) {
         const log = getLogger$5();
         let attempt = 0;
-        // Persistent guard against stale socket errors (TypeError: terminated).
-        // Installed after the first abort and kept alive through subsequent attempts
-        // so that asynchronous undici socket teardown errors that fire between
-        // sleep completion and the next operation's await are caught.
-        let staleGuard;
-        const installGuard = () => {
-            if (staleGuard)
-                return;
-            staleGuard = (reason) => {
-                if (isTransientNetworkError(reason)) {
-                    log.trace("Suppressed stale socket error during retry");
-                }
-            };
-            process.on("unhandledRejection", staleGuard);
-        };
-        const removeGuard = () => {
-            if (staleGuard) {
-                process.removeListener("unhandledRejection", staleGuard);
-                staleGuard = undefined;
-            }
-        };
+        // Guard against stale rejections firing on a subsequent microtask after
+        // the retry layer has already caught the originating error: undici socket
+        // teardown (TypeError: terminated) and twin upstream-SDK rejections
+        // (e.g. issue #336 — OpenRouter SyntaxError siblings).
+        const guard = createStaleRejectionGuard();
         try {
             while (true) {
                 const controller = new AbortController();
@@ -4790,12 +4931,9 @@ class RetryExecutor {
                     return result;
                 }
                 catch (error) {
-                    // Abort the previous request to kill lingering socket callbacks
                     controller.abort("retry");
-                    // Install the guard immediately after abort — stale socket errors
-                    // can fire on any subsequent microtask boundary (during hook calls,
-                    // sleep, or the next operation attempt)
-                    installGuard();
+                    guard.recordCaught(error);
+                    guard.install();
                     // Check if we've exhausted retries
                     if (!this.policy.shouldRetry(attempt)) {
                         log.error(`API call failed after ${this.policy.maxRetries} retries`);
@@ -4841,7 +4979,7 @@ class RetryExecutor {
             }
         }
         finally {
-            removeGuard();
+            guard.remove();
         }
     }
 }
@@ -5451,25 +5589,10 @@ class StreamLoop {
         // Retry loop for connection-level failures
         let attempt = 0;
         let chunksYielded = false;
-        // Persistent guard against stale socket errors (TypeError: terminated).
-        // Installed after the first abort and kept alive through subsequent attempts.
-        let staleGuard;
-        const installGuard = () => {
-            if (staleGuard)
-                return;
-            staleGuard = (reason) => {
-                if (isTransientNetworkError(reason)) {
-                    log.trace("Suppressed stale socket error during retry");
-                }
-            };
-            process.on("unhandledRejection", staleGuard);
-        };
-        const removeGuard = () => {
-            if (staleGuard) {
-                process.removeListener("unhandledRejection", staleGuard);
-                staleGuard = undefined;
-            }
-        };
+        // Guard against stale rejections firing after the stream loop has already
+        // caught the originating error: undici socket teardown and twin
+        // upstream-SDK rejections (issue #336).
+        const guard = createStaleRejectionGuard();
         try {
             while (true) {
                 const controller = new AbortController();
@@ -5510,10 +5633,9 @@ class StreamLoop {
                     break;
                 }
                 catch (error) {
-                    // Abort the previous request to kill lingering socket callbacks
                     controller.abort("retry");
-                    // Install the guard immediately after abort
-                    installGuard();
+                    guard.recordCaught(error);
+                    guard.install();
                     // If chunks were already yielded, we can't transparently retry
                     if (chunksYielded) {
                         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -5546,7 +5668,7 @@ class StreamLoop {
             }
         }
         finally {
-            removeGuard();
+            guard.remove();
         }
         // Execute afterEachModelResponse hook
         await this.hookRunnerInstance.runAfterModelResponse(context.hooks, {