@jaypie/llm 1.2.31 → 1.2.33

package/dist/cjs/index.cjs

@@ -1199,11 +1199,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 = [
+const MODELS_WITHOUT_TEMPERATURE$2 = [
     /^claude-opus-4-[789]/,
     /^claude-opus-[5-9]/,
 ];
-function isTemperatureDeprecationError(error) {
+function isTemperatureDeprecationError$2(error) {
     if (!error || typeof error !== "object")
         return false;
     const err = error;
@@ -1273,7 +1273,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
     supportsTemperature(model) {
         if (this.runtimeNoTemperatureModels.has(model))
             return false;
-        return !MODELS_WITHOUT_TEMPERATURE.some((pattern) => pattern.test(model));
+        return !MODELS_WITHOUT_TEMPERATURE$2.some((pattern) => pattern.test(model));
     }
     supportsStructuredOutput(model) {
         return !this.runtimeNoStructuredOutputModels.has(model);
@@ -1451,7 +1451,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 return undefined;
             // If the model rejected `temperature`, cache it and retry without the param
             if (anthropicRequest.temperature !== undefined &&
-                isTemperatureDeprecationError(error)) {
+                isTemperatureDeprecationError$2(error)) {
                 this.rememberModelRejectsTemperature(anthropicRequest.model);
                 const retryRequest = { ...anthropicRequest };
                 delete retryRequest.temperature;
@@ -1512,7 +1512,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         }
         catch (error) {
             if (streamRequest.temperature !== undefined &&
-                isTemperatureDeprecationError(error)) {
+                isTemperatureDeprecationError$2(error)) {
                 this.rememberModelRejectsTemperature(streamRequest.model);
                 streamRequest = {
                     ...streamRequest,
@@ -2239,14 +2239,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 {
@@ -2663,6 +2673,27 @@ const NOT_RETRYABLE_ERROR_TYPES = [
     openai.RateLimitError,
     openai.UnprocessableEntityError,
 ];
+// Models known not to accept `temperature`.
+// 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$1 = [
+    /^gpt-5\.5/, // gpt-5.5 series deprecated temperature
+    /^o\d/, // o-series reasoning models (o1, o3, o4, ...)
+];
+function isTemperatureDeprecationError$1(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    if (!(error instanceof openai.BadRequestError) &&
+        error.status !== 400) {
+        return false;
+    }
+    const messages = [
+        error.message,
+        error.error?.message,
+    ].filter((m) => typeof m === "string");
+    return messages.some((m) => m.toLowerCase().includes("temperature"));
+}
 //
 //
 // Main
@@ -2677,6 +2708,20 @@ class OpenAiAdapter extends BaseProviderAdapter {
         super(...arguments);
         this.name = PROVIDER.OPENAI.NAME;
         this.defaultModel = PROVIDER.OPENAI.MODEL.DEFAULT;
+        // Session-level cache of models observed to reject `temperature` at runtime.
+        // Populated by executeRequest on 400 errors so repeat calls skip the param.
+        this.runtimeNoTemperatureModels = new Set();
+    }
+    rememberModelRejectsTemperature(model) {
+        this.runtimeNoTemperatureModels.add(model);
+    }
+    clearRuntimeNoTemperatureModels() {
+        this.runtimeNoTemperatureModels.clear();
+    }
+    supportsTemperature(model) {
+        if (this.runtimeNoTemperatureModels.has(model))
+            return false;
+        return !MODELS_WITHOUT_TEMPERATURE$1.some((pattern) => pattern.test(model));
     }
     //
     // Request Building
@@ -2720,6 +2765,11 @@ class OpenAiAdapter extends BaseProviderAdapter {
         if (request.temperature !== undefined) {
             openaiRequest.temperature = request.temperature;
         }
+        // Strip temperature for models that don't support it (denylist + runtime cache)
+        if (openaiRequest.temperature !== undefined &&
+            !this.supportsTemperature(openaiRequest.model)) {
+            delete openaiRequest.temperature;
+        }
         return openaiRequest;
     }
     formatTools(toolkit, _outputSchema) {
@@ -2769,14 +2819,21 @@ class OpenAiAdapter extends BaseProviderAdapter {
     //
     async executeRequest(client, request, signal) {
         const openai = client;
+        const openaiRequest = request;
         try {
-            return await openai.responses.create(
-            // @ts-expect-error OpenAI SDK types don't match our request format exactly
-            request, signal ? { signal } : undefined);
+            return await openai.responses.create(openaiRequest, signal ? { signal } : undefined);
         }
         catch (error) {
             if (signal?.aborted)
                 return undefined;
+            // If the model rejected `temperature`, cache it and retry without the param
+            if (openaiRequest.temperature !== undefined &&
+                isTemperatureDeprecationError$1(error)) {
+                this.rememberModelRejectsTemperature(openaiRequest.model);
+                const retryRequest = { ...openaiRequest };
+                delete retryRequest.temperature;
+                return await openai.responses.create(retryRequest, signal ? { signal } : undefined);
+            }
             throw error;
         }
     }
@@ -3121,10 +3178,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") {
@@ -3132,25 +3210,38 @@ function convertContentToOpenRouter(content) {
     }
     const parts = [];
     for (const item of content) {
-        // Text content - pass through
         if (item.type === exports.LlmMessageType.InputText) {
             parts.push({ type: "text", text: item.text });
             continue;
         }
-        // Image content - warn and discard
         if (item.type === exports.LlmMessageType.InputImage) {
-            log$1.log.warn("OpenRouter does not support image uploads; image discarded");
+            const url = item.image_url ?? "";
+            if (!url) {
+                log$1.log.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 === exports.LlmMessageType.InputFile) {
-            log$1.log.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.log.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.log.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 "";
     }
@@ -3204,6 +3295,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);
@@ -3214,6 +3308,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
     //
@@ -3283,6 +3388,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, 
@@ -3309,11 +3420,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 v4.z.ZodType
                 ? schema
                 : naturalZodSchema(schema);
-            jsonSchema = v4.z.toJSONSchema(zodSchema);
+            jsonSchema = { ...v4.z.toJSONSchema(zodSchema) };
         }
         // Remove $schema property (can cause issues with some providers)
         if (jsonSchema.$schema) {
@@ -3341,6 +3459,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)) {