genai-lite 0.13.1 → 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");
 /**
@@ -247,7 +248,7 @@ class AnthropicClientAdapter {
             const so = request.settings.structuredOutput;
             // Anthropic requires additionalProperties: false on all object schemas
             const processedSchema = so.strict !== false
-                ? this.addAdditionalPropertiesFalse(so.schema)
+                ? (0, schemaUtils_1.applyStrictSchemaConstraints)({ ...so.schema })
                 : { ...so.schema };
             messageParams.output_config = {
                 format: {
@@ -344,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
      *
@@ -490,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 = {
@@ -522,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,
@@ -551,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/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.1",
+  "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",