@jaypie/llm 1.2.24 → 1.2.26

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

@@ -14,6 +14,10 @@ import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
 export declare class AnthropicAdapter extends BaseProviderAdapter {
     readonly name: "anthropic";
     readonly defaultModel: "claude-sonnet-4-6";
+    private runtimeNoTemperatureModels;
+    rememberModelRejectsTemperature(model: string): void;
+    clearRuntimeNoTemperatureModels(): void;
+    private supportsTemperature;
     buildRequest(request: OperateRequest): Anthropic.MessageCreateParams;
     formatTools(toolkit: Toolkit, outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;

package/dist/cjs/providers/gemini/types.d.ts

@@ -72,6 +72,7 @@ export interface GeminiGenerateContentConfig {
     };
     responseMimeType?: string;
     responseJsonSchema?: JsonObject;
+    responseSchema?: JsonObject;
     temperature?: number;
     topP?: number;
     topK?: number;

package/dist/cjs/util/index.d.ts

@@ -2,6 +2,7 @@ export * from "./determineModelProvider.js";
 export * from "./extractReasoning.js";
 export * from "./formatOperateInput.js";
 export * from "./formatOperateMessage.js";
+export * from "./jsonSchemaToOpenApi3.js";
 export * from "./logger.js";
 export * from "./maxTurnsFromOptions.js";
 export * from "./naturalZodSchema.js";

package/dist/cjs/util/jsonSchemaToOpenApi3.d.ts

@@ -0,0 +1,10 @@
+import { JsonObject } from "@jaypie/types";
+/**
+ * Converts a JSON Schema (Draft 2020-12) object to the OpenAPI 3.0 schema subset
+ * that Gemini's `responseSchema` accepts. This constrains generation (not just validation)
+ * and avoids the `items`-keyword leakage bug in `responseJsonSchema`.
+ *
+ * Strips: $schema, additionalProperties, $defs, $ref (inlines where possible), const
+ * Preserves: type, properties, required, items, enum, description, nullable
+ */
+export declare function jsonSchemaToOpenApi3(schema: JsonObject): JsonObject;

package/dist/esm/index.js

@@ -552,6 +552,50 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
+/**
+ * Converts a JSON Schema (Draft 2020-12) object to the OpenAPI 3.0 schema subset
+ * that Gemini's `responseSchema` accepts. This constrains generation (not just validation)
+ * and avoids the `items`-keyword leakage bug in `responseJsonSchema`.
+ *
+ * Strips: $schema, additionalProperties, $defs, $ref (inlines where possible), const
+ * Preserves: type, properties, required, items, enum, description, nullable
+ */
+function jsonSchemaToOpenApi3(schema) {
+    if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+        return schema;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        // Strip JSON Schema keywords not in OpenAPI 3.0 subset
+        if (key === "$schema" ||
+            key === "$defs" ||
+            key === "additionalProperties" ||
+            key === "const" ||
+            key === "$ref") {
+            continue;
+        }
+        if (key === "properties" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            const convertedProps = {};
+            for (const [propKey, propValue] of Object.entries(value)) {
+                convertedProps[propKey] = jsonSchemaToOpenApi3(propValue);
+            }
+            result[key] = convertedProps;
+        }
+        else if (key === "items" &&
+            typeof value === "object" &&
+            value !== null) {
+            result[key] = jsonSchemaToOpenApi3(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
 const getLogger$5 = () => log$1.lib({ lib: JAYPIE.LIB.LLM });
 
 // Turn policy constants
@@ -1019,6 +1063,24 @@ const NOT_RETRYABLE_ERROR_NAMES = [
     "NotFoundError",
     "PermissionDeniedError",
 ];
+// Models known not to accept `temperature`.
+// 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 = [
+    /^claude-opus-4-[789]/,
+    /^claude-opus-[5-9]/,
+];
+function isTemperatureDeprecationError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    const name = error?.constructor?.name;
+    if (name !== "BadRequestError" && err.status !== 400)
+        return false;
+    const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
+    return messages.some((m) => m.toLowerCase().includes("temperature"));
+}
 //
 //
 // Main
@@ -1033,6 +1095,20 @@ class AnthropicAdapter extends BaseProviderAdapter {
         super(...arguments);
         this.name = PROVIDER.ANTHROPIC.NAME;
         this.defaultModel = PROVIDER.ANTHROPIC.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.some((pattern) => pattern.test(model));
     }
     //
     // Request Building
@@ -1124,6 +1200,11 @@ class AnthropicAdapter extends BaseProviderAdapter {
         if (request.temperature !== undefined) {
             anthropicRequest.temperature = request.temperature;
         }
+        // Strip temperature for models that don't support it (denylist + runtime cache)
+        if (anthropicRequest.temperature !== undefined &&
+            !this.supportsTemperature(anthropicRequest.model)) {
+            delete anthropicRequest.temperature;
+        }
         return anthropicRequest;
     }
     formatTools(toolkit, outputSchema) {
@@ -1174,22 +1255,48 @@ class AnthropicAdapter extends BaseProviderAdapter {
     //
     async executeRequest(client, request, signal) {
         const anthropic = client;
+        const anthropicRequest = request;
         try {
-            return (await anthropic.messages.create(request, signal ? { signal } : undefined));
+            return (await anthropic.messages.create(anthropicRequest, signal ? { signal } : undefined));
         }
         catch (error) {
             if (signal?.aborted)
                 return undefined;
+            // If the model rejected `temperature`, cache it and retry without the param
+            if (anthropicRequest.temperature !== undefined &&
+                isTemperatureDeprecationError(error)) {
+                this.rememberModelRejectsTemperature(anthropicRequest.model);
+                const retryRequest = { ...anthropicRequest };
+                delete retryRequest.temperature;
+                return (await anthropic.messages.create(retryRequest, signal ? { signal } : undefined));
+            }
             throw error;
         }
     }
     async *executeStreamRequest(client, request, signal) {
         const anthropic = client;
-        const streamRequest = {
+        let streamRequest = {
             ...request,
             stream: true,
         };
-        const stream = await anthropic.messages.create(streamRequest, signal ? { signal } : undefined);
+        let stream;
+        try {
+            stream = await anthropic.messages.create(streamRequest, signal ? { signal } : undefined);
+        }
+        catch (error) {
+            if (streamRequest.temperature !== undefined &&
+                isTemperatureDeprecationError(error)) {
+                this.rememberModelRejectsTemperature(streamRequest.model);
+                streamRequest = {
+                    ...streamRequest,
+                };
+                delete streamRequest.temperature;
+                stream = await anthropic.messages.create(streamRequest, signal ? { signal } : undefined);
+            }
+            else {
+                throw error;
+            }
+        }
         // Track current tool call being built
         let currentToolCall = null;
         // Track usage for final chunk
@@ -1538,11 +1645,21 @@ class GeminiAdapter extends BaseProviderAdapter {
         // Gemini doesn't support combining function calling with responseMimeType: 'application/json'
         // When tools are present, structured output is handled via the structured_output tool
         if (request.format && !(request.tools && request.tools.length > 0)) {
-            geminiRequest.config = {
-                ...geminiRequest.config,
-                responseMimeType: "application/json",
-                responseJsonSchema: request.format,
-            };
+            const useJsonSchema = request.providerOptions?.useJsonSchema === true;
+            if (useJsonSchema) {
+                geminiRequest.config = {
+                    ...geminiRequest.config,
+                    responseMimeType: "application/json",
+                    responseJsonSchema: request.format,
+                };
+            }
+            else {
+                geminiRequest.config = {
+                    ...geminiRequest.config,
+                    responseMimeType: "application/json",
+                    responseSchema: jsonSchemaToOpenApi3(request.format),
+                };
+            }
         }
         // When format is specified with tools, add instruction to use structured_output tool
         if (request.format && request.tools && request.tools.length > 0) {
@@ -1610,11 +1727,7 @@ class GeminiAdapter extends BaseProviderAdapter {
                 : naturalZodSchema(schema);
             jsonSchema = z.toJSONSchema(zodSchema);
         }
-        // Remove $schema property (Gemini doesn't need it)
-        if (jsonSchema.$schema) {
-            delete jsonSchema.$schema;
-        }
-        return jsonSchema;
+        return jsonSchemaToOpenApi3(jsonSchema);
     }
     //
     // API Execution