@jaypie/llm 1.3.4 → 1.3.6

package/dist/cjs/index.cjs

@@ -101,7 +101,10 @@ const PROVIDER = {
     ANTHROPIC: {
         // https://docs.anthropic.com/en/docs/about-claude/models/overview
         MAX_TOKENS: {
-            DEFAULT: 4096,
+            // Non-streaming ceiling: responses above ~16K output tokens risk HTTP
+            // timeouts; streaming requests resolve to the model maximum instead
+            // (see util/maxOutputTokens.ts)
+            DEFAULT: 16384,
         },
         MODEL: {
             DEFAULT: FIRST_CLASS_PROVIDER.ANTHROPIC.DEFAULT,
@@ -450,14 +453,12 @@ class BaseProviderAdapter {
     /**
      * Default implementation returns false - override for providers with native structured output
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     hasStructuredOutput(_response) {
         return false;
     }
     /**
      * Default implementation returns undefined - override for providers with native structured output
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     extractStructuredOutput(_response) {
         return undefined;
     }
@@ -768,6 +769,119 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
+// Keywords a JSON Schema object node can carry that Natural Schema has no
+// representation for. Anything present here (or any other unrecognized key)
+// is dropped silently and logged, never thrown.
+const LOSSY_OBJECT_KEYWORDS = [
+    "$defs",
+    "$id",
+    "$ref",
+    "$schema",
+    "additionalProperties",
+    "const",
+    "default",
+    "description",
+    "format",
+    "maxLength",
+    "maximum",
+    "minLength",
+    "minimum",
+    "multipleOf",
+    "nullable",
+    "allOf",
+    "anyOf",
+    "oneOf",
+    "pattern",
+];
+const KNOWN_KEYWORDS = new Set([
+    "type",
+    "properties",
+    "required",
+    "items",
+    "enum",
+    ...LOSSY_OBJECT_KEYWORDS,
+]);
+/**
+ * Duck-type check for a bare JSON Schema object node: `{ type: "object", properties: {...} }`.
+ * Does not require the OpenAI-style `{ type: "json_schema", ... }` envelope.
+ */
+function isJsonSchema$1(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const schema = value;
+    return (schema.type === "object" &&
+        typeof schema.properties === "object" &&
+        schema.properties !== null &&
+        !Array.isArray(schema.properties));
+}
+/**
+ * Convert a Natural Schema to JSON Schema. Lossless: Natural Schema is a
+ * strict subset of what JSON Schema can express.
+ */
+function naturalSchemaToJsonSchema(schema) {
+    return v4.z.toJSONSchema(naturalZodSchema(schema));
+}
+function logDroppedKeywords(schema, path) {
+    for (const key of Object.keys(schema)) {
+        if (!KNOWN_KEYWORDS.has(key)) {
+            log$1.debug(`[jsonSchemaToNaturalSchema] Dropping unrecognized keyword "${key}" at "${path}"`);
+        }
+        else if (LOSSY_OBJECT_KEYWORDS.includes(key) &&
+            schema[key] !== undefined) {
+            log$1.debug(`[jsonSchemaToNaturalSchema] Dropping unsupported keyword "${key}" at "${path}"`);
+        }
+    }
+}
+function convertNode(schema, path) {
+    logDroppedKeywords(schema, path);
+    if (Array.isArray(schema.enum)) {
+        return schema.enum;
+    }
+    switch (schema.type) {
+        case "string":
+            return String;
+        case "number":
+        case "integer":
+            return Number;
+        case "boolean":
+            return Boolean;
+        case "array": {
+            const items = schema.items;
+            if (typeof items !== "object" || items === null || Array.isArray(items)) {
+                return Array;
+            }
+            return [convertNode(items, `${path}[]`)];
+        }
+        case "object": {
+            const properties = schema.properties;
+            if (!properties || Object.keys(properties).length === 0) {
+                return Object;
+            }
+            const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+            const result = {};
+            for (const [key, value] of Object.entries(properties)) {
+                if (!required.has(key)) {
+                    log$1.debug(`[jsonSchemaToNaturalSchema] Field "${path}.${key}" is optional; Natural Schema has no optional marker — treating as required`);
+                }
+                result[key] = convertNode(value, `${path}.${key}`);
+            }
+            return result;
+        }
+        default:
+            log$1.debug(`[jsonSchemaToNaturalSchema] Unsupported type "${String(schema.type)}" at "${path}"; defaulting to Object`);
+            return Object;
+    }
+}
+/**
+ * Convert a JSON Schema object node to Natural Schema. Lossy: constraints,
+ * descriptions, defaults, unions, and optionality have no Natural Schema
+ * representation. Dropped keywords are logged at debug level, never thrown.
+ */
+function jsonSchemaToNaturalSchema(schema) {
+    return convertNode(schema, "$");
+}
+
 /**
  * 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)
@@ -812,6 +926,52 @@ function jsonSchemaToOpenApi3(schema) {
 
 const getLogger$6 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 
+//
+//
+// Constants
+//
+// Non-streaming requests above ~16K output tokens risk HTTP timeouts
+// (Anthropic guidance is to stream anything larger), so non-streaming
+// defaults are capped here and only streaming requests resolve to the
+// full model maximum.
+const NON_STREAMING_MAX_TOKENS = PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT;
+// Maximum output tokens by model; first match wins.
+// Providers without low output ceilings (OpenAI, xAI) are intentionally
+// absent — their requests leave the limit unset.
+const MODEL_MAX_OUTPUT_TOKENS = [
+    // Anthropic — https://platform.claude.com/docs/en/about-claude/models/overview
+    { pattern: /^claude-opus-4-(0$|1$|1-|2025)/, tokens: 32000 },
+    { pattern: /^claude-opus-4-5/, tokens: 64000 },
+    { pattern: /^claude-sonnet-4-(0$|5$|5-|2025)/, tokens: 64000 },
+    { pattern: /haiku/, tokens: 64000 },
+    { pattern: /claude|fable|mythos|opus|sonnet/, tokens: 128000 },
+    // Google — https://ai.google.dev/gemini-api/docs/models
+    { pattern: /gemini-(2\.5|3)/, tokens: 65536 },
+    { pattern: /gemini/, tokens: 8192 },
+];
+//
+//
+// Main
+//
+/**
+ * Maximum output tokens the model supports, or undefined when unknown.
+ */
+function maxOutputTokens(model) {
+    const match = MODEL_MAX_OUTPUT_TOKENS.find(({ pattern }) => pattern.test(model));
+    return match?.tokens;
+}
+/**
+ * Default output token limit for a request: the model maximum when
+ * streaming, capped at the non-streaming maximum otherwise. Returns
+ * undefined when the model's maximum is unknown.
+ */
+function resolveMaxOutputTokens(model, { stream = false } = {}) {
+    const max = maxOutputTokens(model);
+    if (max === undefined)
+        return undefined;
+    return stream ? max : Math.min(max, NON_STREAMING_MAX_TOKENS);
+}
+
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
 const MAX_TURNS_DEFAULT_LIMIT = 24;
@@ -1636,11 +1796,13 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 lastMsg.content = lastMsg.content + "\n\n" + request.instructions;
             }
         }
+        const model = (request.model ||
+            this.defaultModel);
         const anthropicRequest = {
-            model: (request.model ||
-                this.defaultModel),
+            model,
             messages,
-            max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
+            max_tokens: resolveMaxOutputTokens(model, { stream: request.stream }) ??
+                PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
             stream: false,
         };
         if (request.system) {
@@ -1703,7 +1865,6 @@ class AnthropicAdapter extends BaseProviderAdapter {
     // outputSchema is part of the interface contract but Anthropic now uses
     // native `output_format` (set in buildRequest), so we no longer inject a
     // synthetic structured-output tool here.
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _outputSchema) {
         return toolkit.tools.map((tool) => ({
             name: tool.name,
@@ -1716,11 +1877,13 @@ class AnthropicAdapter extends BaseProviderAdapter {
     }
     formatOutputSchema(schema) {
         let jsonSchema;
-        // Check if schema is already a JsonObject with type "json_schema"
-        if (typeof schema === "object" &&
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
             schema !== null &&
             !Array.isArray(schema) &&
-            schema.type === "json_schema") {
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
             jsonSchema = structuredClone(schema);
             jsonSchema.type = "object"; // Validator does not recognize "json_schema"
         }
@@ -2382,6 +2545,10 @@ class BedrockAdapter extends BaseProviderAdapter {
         }));
     }
     formatOutputSchema(schema) {
+        // Bare JSON Schema node: `{ type: "object", properties: {...} }`
+        if (isJsonSchema$1(schema)) {
+            return structuredClone(schema);
+        }
         const zodSchema = schema instanceof v4.z.ZodType
             ? schema
             : naturalZodSchema(schema);
@@ -2884,6 +3051,18 @@ class GoogleAdapter extends BaseProviderAdapter {
                     : structuredOutputInstruction,
             };
         }
+        // Default output ceiling: Google's own default (8,192) silently
+        // truncates long generations, so resolve to the model maximum (capped
+        // for non-streaming); providerOptions below override
+        const maxOutputTokens = resolveMaxOutputTokens(geminiRequest.model, {
+            stream: request.stream,
+        });
+        if (maxOutputTokens !== undefined) {
+            geminiRequest.config = {
+                ...geminiRequest.config,
+                maxOutputTokens,
+            };
+        }
         // Add provider-specific options
         if (request.providerOptions) {
             geminiRequest.config = {
@@ -2905,7 +3084,6 @@ class GoogleAdapter extends BaseProviderAdapter {
     // structured output via `responseJsonSchema`/`responseSchema` (or the
     // legacy fake-tool injected in buildRequest as a fallback). We no longer
     // inject a synthetic structured-output tool here.
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _outputSchema) {
         return toolkit.tools.map((tool) => ({
             name: tool.name,
@@ -2918,11 +3096,13 @@ class GoogleAdapter extends BaseProviderAdapter {
     }
     formatOutputSchema(schema) {
         let jsonSchema;
-        // Check if schema is already a JsonObject with type "json_schema"
-        if (typeof schema === "object" &&
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
             schema !== null &&
             !Array.isArray(schema) &&
-            schema.type === "json_schema") {
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
             jsonSchema = structuredClone(schema);
             jsonSchema.type = "object";
         }
@@ -3889,21 +4069,35 @@ class OpenAiAdapter extends BaseProviderAdapter {
             schema.type === "json_schema") {
             return schema;
         }
-        // Convert NaturalSchema to Zod schema if needed
-        const zodSchema = schema instanceof v4.z.ZodType
-            ? schema
-            : naturalZodSchema(schema);
-        const responseFormat = zodResponseFormat(zodSchema, "response");
-        // Re-spread to drop zod v4's non-enumerable `~standard` Standard-Schema
-        // interop marker, then strip `$schema`: OpenAI's strict json_schema subset
-        // does not recognize the draft-2020-12 `$schema` keyword, and shipping it
-        // can leave strict structured-output enforcement silently disabled (the
-        // model then free-forms, omitting required fields and corrupting keys).
-        // Mirrors the OpenRouter adapter's sanitization.
-        const jsonSchema = {
-            ...v4.z.toJSONSchema(zodSchema),
-        };
-        delete jsonSchema.$schema;
+        // Bare JSON Schema node: `{ type: "object", properties: {...} }`
+        // Skip the zod round-trip and use it directly (still needs the
+        // additionalProperties + envelope treatment below).
+        let jsonSchema;
+        let name = "response";
+        let strict = true;
+        if (isJsonSchema$1(schema)) {
+            jsonSchema = { ...structuredClone(schema) };
+            delete jsonSchema.$schema;
+        }
+        else {
+            // Convert NaturalSchema to Zod schema if needed
+            const zodSchema = schema instanceof v4.z.ZodType
+                ? schema
+                : naturalZodSchema(schema);
+            const responseFormat = zodResponseFormat(zodSchema, "response");
+            // Re-spread to drop zod v4's non-enumerable `~standard` Standard-Schema
+            // interop marker, then strip `$schema`: OpenAI's strict json_schema subset
+            // does not recognize the draft-2020-12 `$schema` keyword, and shipping it
+            // can leave strict structured-output enforcement silently disabled (the
+            // model then free-forms, omitting required fields and corrupting keys).
+            // Mirrors the OpenRouter adapter's sanitization.
+            jsonSchema = {
+                ...v4.z.toJSONSchema(zodSchema),
+            };
+            delete jsonSchema.$schema;
+            name = responseFormat.json_schema.name;
+            strict = responseFormat.json_schema.strict;
+        }
         // OpenAI requires additionalProperties to be false on all objects
         const checks = [jsonSchema];
         while (checks.length > 0) {
@@ -3919,10 +4113,10 @@ class OpenAiAdapter extends BaseProviderAdapter {
             checks.shift();
         }
         return {
-            name: responseFormat.json_schema.name,
+            name,
             schema: jsonSchema,
-            strict: responseFormat.json_schema.strict,
-            type: responseFormat.type,
+            strict,
+            type: "json_schema",
         };
     }
     //
@@ -4554,7 +4748,6 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     // native `response_format` (set in buildRequest), so we no longer inject a
     // synthetic structured-output tool here. The legacy fake-tool injection
     // happens in buildRequest only as a runtime fallback.
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _outputSchema) {
         return toolkit.tools.map((tool) => ({
             name: tool.name,
@@ -4564,11 +4757,13 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     }
     formatOutputSchema(schema) {
         let jsonSchema;
-        // Check if schema is already a JsonObject with type "json_schema"
-        if (typeof schema === "object" &&
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
             schema !== null &&
             !Array.isArray(schema) &&
-            schema.type === "json_schema") {
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
             jsonSchema = structuredClone(schema);
             jsonSchema.type = "object"; // Normalize type
         }
@@ -6884,6 +7079,7 @@ class StreamLoop {
                     messages: state.currentInput,
                     model: options.model ?? this.adapter.defaultModel,
                     providerOptions: options.providerOptions,
+                    stream: true,
                     system: options.system,
                     temperature: options.temperature,
                     tools: state.formattedTools,
@@ -6952,6 +7148,7 @@ class StreamLoop {
             messages: state.currentInput,
             model: options.model ?? this.adapter.defaultModel,
             providerOptions: options.providerOptions,
+            stream: true,
             system: options.system,
             temperature: options.temperature,
             tools: state.formattedTools,
@@ -9040,6 +9237,8 @@ exports.isLlmOperateInput = isLlmOperateInput;
 exports.isLlmOperateInputContent = isLlmOperateInputContent;
 exports.isLlmOperateInputFile = isLlmOperateInputFile;
 exports.isLlmOperateInputImage = isLlmOperateInputImage;
+exports.jsonSchemaToNaturalSchema = jsonSchemaToNaturalSchema;
+exports.naturalSchemaToJsonSchema = naturalSchemaToJsonSchema;
 exports.toolkit = toolkit;
 exports.tools = tools;
 //# sourceMappingURL=index.cjs.map