genai-lite 0.13.0 → 0.14.0

package/dist/llm/clients/AnthropicClientAdapter.d.ts

@@ -53,14 +53,6 @@ export declare class AnthropicClientAdapter implements ILLMClientAdapter {
     private mapAnthropicUsage;
     private mergeAnthropicUsage;
     private createSyntheticMessage;
-    /**
-     * Recursively adds additionalProperties: false to all object schemas
-     * Required by Anthropic's strict mode for structured outputs
-     *
-     * @param schema - The JSON schema to process
-     * @returns A new schema with additionalProperties: false on all objects
-     */
-    private addAdditionalPropertiesFalse;
     /**
      * Formats messages for Anthropic API with proper system message handling
      *

package/dist/llm/clients/AnthropicClientAdapter.js

@@ -9,6 +9,7 @@ exports.AnthropicClientAdapter = void 0;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const types_1 = require("./types");
 const errorUtils_1 = require("../../shared/adapters/errorUtils");
+const schemaUtils_1 = require("../../shared/adapters/schemaUtils");
 const systemMessageUtils_1 = require("../../shared/adapters/systemMessageUtils");
 const defaultLogger_1 = require("../../logging/defaultLogger");
 /**
@@ -54,26 +55,15 @@ class AnthropicClientAdapter {
                 hasStopSequences: !!messageParams.stop_sequences,
                 useStructuredOutput,
             });
-            // Make the API call - use beta endpoint for structured output
-            let completion;
-            if (useStructuredOutput) {
-                // For structured output, we need to use the beta messages endpoint with proper headers
-                completion = await anthropic.messages.create(messageParams, {
-                    headers: {
-                        'anthropic-beta': 'structured-outputs-2025-11-13',
-                    },
-                    ...requestTransportOptions,
-                });
-            }
-            else {
-                completion =
-                    Object.keys(requestTransportOptions).length > 0
-                        ? await anthropic.messages.create(messageParams, requestTransportOptions)
-                        : await anthropic.messages.create(messageParams);
-            }
+            // Structured and unstructured requests take the same endpoint - structured
+            // output is GA, so there is no beta header or beta endpoint involved.
+            const completion = Object.keys(requestTransportOptions).length > 0
+                ? await anthropic.messages.create(messageParams, requestTransportOptions)
+                : await anthropic.messages.create(messageParams);
             this.logger.info(`Anthropic API call successful, response ID: ${completion.id}`);
-            // Convert to standardized response format
-            // Cast to any to handle beta response type differences
+            // Convert to standardized response format. `create` is typed against the
+            // streaming/non-streaming param union; we never set `stream`, so this is
+            // always a Message.
             return this.createSuccessResponse(completion, request);
         }
         catch (error) {
@@ -94,17 +84,12 @@ class AnthropicClientAdapter {
         let started = false;
         try {
             const { anthropic, messageParams, requestTransportOptions, useStructuredOutput, } = this.prepareMessageRequest(request, apiKey, options);
-            this.logger.info(`Making Anthropic streaming API call for model: ${request.modelId}`);
-            const streamOptions = useStructuredOutput
-                ? {
-                    headers: {
-                        "anthropic-beta": "structured-outputs-2025-11-13",
-                    },
-                    ...requestTransportOptions,
-                }
-                : requestTransportOptions;
-            const stream = Object.keys(streamOptions).length > 0
-                ? anthropic.messages.stream(messageParams, streamOptions)
+            this.logger.info(`Making Anthropic streaming API call for model: ${request.modelId}`, {
+                useStructuredOutput,
+            });
+            // No beta header for structured output - output_config.format is GA.
+            const stream = Object.keys(requestTransportOptions).length > 0
+                ? anthropic.messages.stream(messageParams, requestTransportOptions)
                 : anthropic.messages.stream(messageParams);
             for await (const event of stream) {
                 sawEvent = true;
@@ -254,20 +239,22 @@ class AnthropicClientAdapter {
                 stop_sequences: request.settings.stopSequences,
             }),
         };
-        // Handle structured output configuration for Anthropic
-        // Note: Structured output requires the beta API endpoint
+        // Handle structured output configuration for Anthropic.
+        // Structured outputs are generally available: the stable request field is
+        // output_config.format, with no beta header. The format object carries only
+        // `type` and `schema` - the generic StructuredOutputSettings `name` and
+        // `strict` fields exist for other providers and are not serialized here.
         if (useStructuredOutput) {
             const so = request.settings.structuredOutput;
             // Anthropic requires additionalProperties: false on all object schemas
             const processedSchema = so.strict !== false
-                ? this.addAdditionalPropertiesFalse(so.schema)
-                : so.schema;
-            // Anthropic's format: output_format.schema is the schema directly
-            messageParams.output_format = {
-                type: 'json_schema',
-                name: so.name,
-                schema: processedSchema,
-                strict: so.strict !== false,
+                ? (0, schemaUtils_1.applyStrictSchemaConstraints)({ ...so.schema })
+                : { ...so.schema };
+            messageParams.output_config = {
+                format: {
+                    type: "json_schema",
+                    schema: processedSchema,
+                },
             };
         }
         // Handle reasoning/thinking configuration for Claude models
@@ -358,35 +345,6 @@ class AnthropicClientAdapter {
             usage: accumulator.usage,
         };
     }
-    /**
-     * Recursively adds additionalProperties: false to all object schemas
-     * Required by Anthropic's strict mode for structured outputs
-     *
-     * @param schema - The JSON schema to process
-     * @returns A new schema with additionalProperties: false on all objects
-     */
-    addAdditionalPropertiesFalse(schema) {
-        if (!schema || typeof schema !== 'object') {
-            return schema;
-        }
-        const processed = { ...schema };
-        // If this is an object type, add additionalProperties: false
-        if (processed.type === 'object') {
-            processed.additionalProperties = false;
-            // Process nested properties
-            if (processed.properties) {
-                processed.properties = {};
-                for (const [key, value] of Object.entries(schema.properties)) {
-                    processed.properties[key] = this.addAdditionalPropertiesFalse(value);
-                }
-            }
-        }
-        // Process array items
-        if (processed.items) {
-            processed.items = this.addAdditionalPropertiesFalse(schema.items);
-        }
-        return processed;
-    }
     /**
      * Formats messages for Anthropic API with proper system message handling
      *
@@ -504,24 +462,15 @@ class AnthropicClientAdapter {
         if (textBlocks.length === 0) {
             throw new Error("Invalid completion structure from Anthropic API");
         }
-        // Extract thinking/reasoning content if available
-        let reasoning;
-        let reasoning_details;
-        // Check for thinking content in the response
-        if (completion.thinking_content) {
-            reasoning = completion.thinking_content;
-        }
+        // Extract reasoning from thinking content blocks. This is the only place
+        // Anthropic exposes it: `Message` has no `thinking_content` or
+        // `reasoning_details` field (the latter is an OpenRouter concept, handled in
+        // OpenRouterClientAdapter), so branches reading those could never fire.
         const thinkingContent = completion.content
             .filter((block) => block.type === "thinking" && typeof block.thinking === "string")
             .map((block) => block.thinking)
             .join("");
-        if (!reasoning && thinkingContent) {
-            reasoning = thinkingContent;
-        }
-        // Check for reasoning details that need to be preserved
-        if (completion.reasoning_details) {
-            reasoning_details = completion.reasoning_details;
-        }
+        const reasoning = thinkingContent || undefined;
         // Map Anthropic's stop reason to our standard format
         const finishReason = this.mapAnthropicStopReason(completion.stop_reason);
         const choice = {
@@ -536,10 +485,6 @@ class AnthropicClientAdapter {
         if (reasoning && request.settings.reasoning && !request.settings.reasoning.exclude) {
             choice.reasoning = reasoning;
         }
-        // Always include reasoning_details if present (for tool use continuation)
-        if (reasoning_details) {
-            choice.reasoning_details = reasoning_details;
-        }
         return {
             id: completion.id,
             provider: request.providerId,
@@ -565,12 +510,22 @@ class AnthropicClientAdapter {
     mapAnthropicStopReason(anthropicReason) {
         if (!anthropicReason)
             return null;
+        // Anthropic's StopReason union is exactly:
+        //   end_turn | max_tokens | stop_sequence | tool_use | pause_turn | refusal
+        // Note there is no `content_filter` - that is OpenAI's vocabulary. A model
+        // that declines on policy grounds reports `refusal`, which we normalize to
+        // `content_filter` so callers can detect a blocked completion with the same
+        // check they already use for OpenAI and Gemini.
         const reasonMap = {
             end_turn: "stop",
             max_tokens: "length",
             stop_sequence: "stop",
-            content_filter: "content_filter",
             tool_use: "tool_calls",
+            refusal: "content_filter",
+            // Anthropic-specific: a long-running turn was paused and the caller is
+            // expected to continue it. No equivalent in the normalized vocabulary, so
+            // it maps to "other" deliberately rather than by falling through.
+            pause_turn: "other",
         };
         return reasonMap[anthropicReason] || "other";
     }

package/dist/llm/clients/OpenAIClientAdapter.d.ts

@@ -52,14 +52,6 @@ export declare class OpenAIClientAdapter implements ILLMClientAdapter {
     private createTransportOptions;
     private getStreamChoiceState;
     private createSyntheticCompletion;
-    /**
-     * Recursively adds additionalProperties: false to all object schemas
-     * Required by OpenAI's strict mode for structured outputs
-     *
-     * @param schema - The JSON schema to process
-     * @returns A new schema with additionalProperties: false on all objects
-     */
-    private addAdditionalPropertiesFalse;
     /**
      * Formats messages for OpenAI API
      *

package/dist/llm/clients/OpenAIClientAdapter.js

@@ -10,6 +10,7 @@ const openai_1 = __importDefault(require("openai"));
 const types_1 = require("./types");
 const errorUtils_1 = require("../../shared/adapters/errorUtils");
 const logprobsUtils_1 = require("../../shared/adapters/logprobsUtils");
+const schemaUtils_1 = require("../../shared/adapters/schemaUtils");
 const systemMessageUtils_1 = require("../../shared/adapters/systemMessageUtils");
 const defaultLogger_1 = require("../../logging/defaultLogger");
 /**
@@ -231,8 +232,10 @@ class OpenAIClientAdapter {
         }
         if (request.settings.structuredOutput?.schema && request.settings.structuredOutput.enabled !== false) {
             const so = request.settings.structuredOutput;
+            // OpenAI strict mode additionally requires `required` to list every
+            // property of each object schema.
             const processedSchema = so.strict !== false
-                ? this.addAdditionalPropertiesFalse(so.schema)
+                ? (0, schemaUtils_1.applyStrictSchemaConstraints)({ ...so.schema }, { requireAllProperties: true })
                 : so.schema;
             completionParams.response_format = {
                 type: 'json_schema',
@@ -288,38 +291,6 @@ class OpenAIClientAdapter {
             ...(usage && { usage }),
         };
     }
-    /**
-     * Recursively adds additionalProperties: false to all object schemas
-     * Required by OpenAI's strict mode for structured outputs
-     *
-     * @param schema - The JSON schema to process
-     * @returns A new schema with additionalProperties: false on all objects
-     */
-    addAdditionalPropertiesFalse(schema) {
-        if (!schema || typeof schema !== 'object') {
-            return schema;
-        }
-        const processed = { ...schema };
-        // If this is an object type, add additionalProperties: false and ensure required includes all properties
-        if (processed.type === 'object') {
-            processed.additionalProperties = false;
-            // Process nested properties
-            if (processed.properties) {
-                const propertyKeys = Object.keys(schema.properties);
-                processed.properties = {};
-                for (const [key, value] of Object.entries(schema.properties)) {
-                    processed.properties[key] = this.addAdditionalPropertiesFalse(value);
-                }
-                // OpenAI strict mode requires 'required' to include ALL properties
-                processed.required = propertyKeys;
-            }
-        }
-        // Process array items
-        if (processed.items) {
-            processed.items = this.addAdditionalPropertiesFalse(schema.items);
-        }
-        return processed;
-    }
     /**
      * Formats messages for OpenAI API
      *

package/dist/llm/config.js

@@ -873,6 +873,10 @@ exports.SUPPORTED_MODELS = [
             outputType: 'summary',
             requiresStreamingAbove: 21333,
         },
+        structuredOutput: {
+            supported: true,
+            strictMode: true,
+        },
     },
     {
         id: "claude-sonnet-4-5-20250929",
@@ -897,6 +901,10 @@ exports.SUPPORTED_MODELS = [
             outputType: 'summary',
             requiresStreamingAbove: 21333,
         },
+        structuredOutput: {
+            supported: true,
+            strictMode: true,
+        },
     },
     {
         id: "claude-haiku-4-5-20251001",
@@ -921,8 +929,14 @@ exports.SUPPORTED_MODELS = [
             outputType: 'summary',
             requiresStreamingAbove: 21333,
         },
+        structuredOutput: {
+            supported: true,
+            strictMode: true,
+        },
     },
     // Anthropic Models - Claude 4 Series
+    // Note: Anthropic's structured outputs are generally available for Claude 4.5
+    // and later models only, so the entries below declare it unsupported.
     {
         id: "claude-sonnet-4-20250514",
         name: "Claude Sonnet 4",
@@ -946,6 +960,10 @@ exports.SUPPORTED_MODELS = [
             outputType: 'summary',
             requiresStreamingAbove: 21333,
         },
+        structuredOutput: {
+            supported: false,
+            notes: "Anthropic structured outputs require Claude 4.5 or later",
+        },
     },
     {
         id: "claude-opus-4-20250514",
@@ -970,6 +988,10 @@ exports.SUPPORTED_MODELS = [
             outputType: 'summary',
             requiresStreamingAbove: 21333,
         },
+        structuredOutput: {
+            supported: false,
+            notes: "Anthropic structured outputs require Claude 4.5 or later",
+        },
     },
     {
         id: "claude-3-7-sonnet-20250219",
@@ -994,6 +1016,10 @@ exports.SUPPORTED_MODELS = [
             outputType: 'full',
             requiresStreamingAbove: 21333,
         },
+        structuredOutput: {
+            supported: false,
+            notes: "Anthropic structured outputs require Claude 4.5 or later",
+        },
     },
     {
         id: "claude-3-5-sonnet-20241022",
@@ -1008,6 +1034,10 @@ exports.SUPPORTED_MODELS = [
         supportsPromptCache: true,
         cacheWritesPrice: 3.75,
         cacheReadsPrice: 0.3,
+        structuredOutput: {
+            supported: false,
+            notes: "Anthropic structured outputs require Claude 4.5 or later",
+        },
     },
     {
         id: "claude-3-5-haiku-20241022",
@@ -1022,6 +1052,10 @@ exports.SUPPORTED_MODELS = [
         supportsPromptCache: true,
         cacheWritesPrice: 1.0,
         cacheReadsPrice: 0.08,
+        structuredOutput: {
+            supported: false,
+            notes: "Anthropic structured outputs require Claude 4.5 or later",
+        },
     },
     // Google Gemini Models - Gemini 3 Series (Preview)
     {

package/dist/shared/adapters/schemaUtils.d.ts

@@ -0,0 +1,32 @@
+export interface StrictSchemaOptions {
+    /**
+     * When true, every object schema's `required` is rewritten to list all of its
+     * properties. OpenAI's strict mode demands this; Anthropic's does not.
+     *
+     * @default false
+     */
+    requireAllProperties?: boolean;
+}
+/**
+ * Returns a deep copy of `schema` with `additionalProperties: false` set on every
+ * object schema, as required by OpenAI's and Anthropic's strict structured-output
+ * modes.
+ *
+ * The input is never mutated.
+ *
+ * Traversal covers `properties`, `items` (single or tuple form), `prefixItems`,
+ * `$defs`, `definitions`, `anyOf`, `oneOf`, `allOf`, and `not`. Note that `$ref`
+ * pointers are **not** resolved — they are left as-is, and the schemas they point
+ * at are constrained where they are *defined* (typically under `$defs`), which is
+ * what the providers validate. Both providers reject genuinely recursive schemas
+ * anyway, so resolving refs would buy nothing.
+ *
+ * Cyclic *JavaScript* object graphs (a schema object reachable from itself) are
+ * handled: each input node is copied at most once and revisits reuse that copy,
+ * so the walk terminates and shared subschemas stay shared.
+ *
+ * @param schema - The JSON schema to process
+ * @param options - Provider-specific strictness tweaks
+ * @returns A new schema with strict-mode constraints applied
+ */
+export declare function applyStrictSchemaConstraints<T>(schema: T, options?: StrictSchemaOptions): T;

package/dist/shared/adapters/schemaUtils.js

@@ -0,0 +1,87 @@
+"use strict";
+// AI Summary: Shared JSON Schema preparation for providers whose strict
+// structured-output mode requires additionalProperties: false on every object
+// schema. Traverses properties, items (incl. tuple form), $defs/definitions,
+// anyOf/oneOf/allOf, prefixItems and not, and is safe against cyclic input.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyStrictSchemaConstraints = applyStrictSchemaConstraints;
+/** Keywords whose value is a map of name -> subschema. */
+const SUBSCHEMA_MAPS = ["properties", "$defs", "definitions"];
+/** Keywords whose value is an array of subschemas. */
+const SUBSCHEMA_ARRAYS = ["anyOf", "oneOf", "allOf", "prefixItems"];
+/**
+ * Returns a deep copy of `schema` with `additionalProperties: false` set on every
+ * object schema, as required by OpenAI's and Anthropic's strict structured-output
+ * modes.
+ *
+ * The input is never mutated.
+ *
+ * Traversal covers `properties`, `items` (single or tuple form), `prefixItems`,
+ * `$defs`, `definitions`, `anyOf`, `oneOf`, `allOf`, and `not`. Note that `$ref`
+ * pointers are **not** resolved — they are left as-is, and the schemas they point
+ * at are constrained where they are *defined* (typically under `$defs`), which is
+ * what the providers validate. Both providers reject genuinely recursive schemas
+ * anyway, so resolving refs would buy nothing.
+ *
+ * Cyclic *JavaScript* object graphs (a schema object reachable from itself) are
+ * handled: each input node is copied at most once and revisits reuse that copy,
+ * so the walk terminates and shared subschemas stay shared.
+ *
+ * @param schema - The JSON schema to process
+ * @param options - Provider-specific strictness tweaks
+ * @returns A new schema with strict-mode constraints applied
+ */
+function applyStrictSchemaConstraints(schema, options = {}) {
+    return walk(schema, options, new Map());
+}
+function walk(node, options, seen) {
+    if (!node || typeof node !== "object") {
+        return node;
+    }
+    const cached = seen.get(node);
+    if (cached !== undefined) {
+        return cached;
+    }
+    if (Array.isArray(node)) {
+        const copy = [];
+        seen.set(node, copy);
+        for (const entry of node) {
+            copy.push(walk(entry, options, seen));
+        }
+        return copy;
+    }
+    const source = node;
+    const processed = { ...source };
+    // Registered before recursing so a cycle resolves to this same object.
+    seen.set(node, processed);
+    if (source.type === "object") {
+        processed.additionalProperties = false;
+        const properties = source.properties;
+        if (options.requireAllProperties && properties && typeof properties === "object") {
+            processed.required = Object.keys(properties);
+        }
+    }
+    for (const key of SUBSCHEMA_MAPS) {
+        const value = source[key];
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            const out = {};
+            for (const [name, subschema] of Object.entries(value)) {
+                out[name] = walk(subschema, options, seen);
+            }
+            processed[key] = out;
+        }
+    }
+    for (const key of SUBSCHEMA_ARRAYS) {
+        const value = source[key];
+        if (Array.isArray(value)) {
+            processed[key] = value.map((subschema) => walk(subschema, options, seen));
+        }
+    }
+    if (source.items !== undefined) {
+        processed.items = walk(source.items, options, seen);
+    }
+    if (source.not !== undefined) {
+        processed.not = walk(source.not, options, seen);
+    }
+    return processed;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genai-lite",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "A lightweight, portable toolkit for interacting with various Generative AI APIs.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",