@adaptic/lumic-utils 1.0.25 → 1.0.26

package/dist/{index-ChygDqeG.js → index-DgFDhFuO.js}

@@ -1648,8 +1648,17 @@ async function parseResponse(content, responseFormat, options = {}) {
                 getLumicLogger().info(`Code block for type ${detectedType} detected and removed. Cleaned content: ${cleanedContent}`);
             }
         }
-        // Multiple JSON parsing strategies
-        // Default pipeline: direct parse -> extract from brackets -> remove leading/trailing text -> fixBrokenJson (string manipulation) -> FAIL
+        // Whether the cleaned content structurally resembles JSON. Used to gate the
+        // lenient fixBrokenJson strategy, which will otherwise coerce arbitrary
+        // prose into a bogus object/array.
+        const inputResemblesJson = cleanedContent.startsWith('{') || cleanedContent.startsWith('[');
+        // Multiple JSON parsing strategies.
+        // Default pipeline: direct parse -> extract from brackets -> remove
+        // leading/trailing text -> GATED fixBrokenJson -> FAIL. fixBrokenJson is
+        // deliberately gated (Strategy 4): its output is accepted only when the
+        // input looked like JSON AND the repaired value round-trips through
+        // JSON.stringify/JSON.parse, so a "successful" repair of non-JSON text is
+        // rejected instead of silently returned as garbage.
         const jsonParsingStrategies = [
             // Strategy 1: Direct parsing
             () => {
@@ -1683,45 +1692,65 @@ async function parseResponse(content, responseFormat, options = {}) {
                     return null;
                 }
             },
-            // Strategy 4: Use fixBrokenJson (string manipulation only, no AI)
+            // Strategy 4: Gated fixBrokenJson (string manipulation only, no AI)
             () => {
-                return fixBrokenJson(cleanedContent);
+                if (!inputResemblesJson) {
+                    return null;
+                }
+                const fixed = fixBrokenJson(cleanedContent);
+                if (fixed === null) {
+                    return null;
+                }
+                try {
+                    // Round-trip guard: ensures the repaired value is genuinely
+                    // JSON-serializable before we trust it.
+                    return JSON.parse(JSON.stringify(fixed));
+                }
+                catch {
+                    return null;
+                }
             },
         ];
         // Try each parsing strategy
         for (const strategy of jsonParsingStrategies) {
-            const result = await strategy();
+            const result = strategy();
             if (result !== null) {
-                return result;
+                return finalizeJsonResult(result, responseFormat);
             }
         }
         // Strategy 5: Use AI fixing (only if explicitly enabled)
         if (enableAiFix) {
             getLumicLogger().warn('Using AI-powered JSON fixing. This adds cost and latency. Consider improving JSON generation instead.');
+            let aiFixedJson = null;
             try {
-                const aiFixedJson = await fixJsonWithAI(cleanedContent);
-                if (aiFixedJson !== null) {
-                    // Validate the AI-fixed JSON by attempting to stringify and re-parse it
-                    // This ensures it's actually valid JSON and not just something that passed fixJsonWithAI
-                    try {
-                        const validated = JSON.parse(JSON.stringify(aiFixedJson));
-                        return validated;
-                    }
-                    catch {
-                        // AI returned something that looks like JSON but isn't valid
-                        // Increment recursion depth and try parsing the AI response
-                        getLumicLogger().warn('AI fixing returned invalid JSON, attempting recursive parse...');
-                        return parseResponse(JSON.stringify(aiFixedJson), responseFormat, {
-                            ...options,
-                            _recursionDepth: recursionDepth + 1,
-                        });
-                    }
-                }
+                aiFixedJson = await fixJsonWithAI(cleanedContent);
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : 'Unknown error';
                 getLumicLogger().error(`AI JSON fixing failed: ${errorMessage}`);
-                // Continue to final error below
+                // Fall through to the final error below.
+            }
+            if (aiFixedJson !== null) {
+                let validated;
+                try {
+                    // Validate the AI-fixed JSON by attempting to stringify and re-parse
+                    // it. This ensures it is actually valid JSON, not just something that
+                    // passed fixJsonWithAI.
+                    validated = JSON.parse(JSON.stringify(aiFixedJson));
+                }
+                catch {
+                    // AI returned something that looks like JSON but isn't valid.
+                    // Increment recursion depth and try parsing the AI response.
+                    getLumicLogger().warn('AI fixing returned invalid JSON, attempting recursive parse...');
+                    return parseResponse(JSON.stringify(aiFixedJson), responseFormat, {
+                        ...options,
+                        _recursionDepth: recursionDepth + 1,
+                    });
+                }
+                // Schema validation (json_schema format) happens here, OUTSIDE the
+                // JSON.parse try/catch, so a schema mismatch propagates as a thrown
+                // JsonParseError rather than being mistaken for invalid JSON.
+                return finalizeJsonResult(validated, responseFormat);
             }
         }
         // If all strategies fail, throw an error
@@ -1732,6 +1761,106 @@ async function parseResponse(content, responseFormat, options = {}) {
         return content;
     }
 }
+/**
+ * Reports the JSON type of a runtime value for schema-validation diagnostics.
+ *
+ * @param value The value whose JSON type should be described.
+ * @returns One of `'null' | 'array' | 'object' | 'string' | 'number' | 'boolean' | 'undefined'`.
+ */
+function jsonTypeOf(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+/**
+ * Extracts a declared primitive `type` string from a property schema, if present.
+ *
+ * @param propertySchema The (untyped) per-property JSON-Schema fragment.
+ * @returns The declared type string, or null when none is declared.
+ */
+function extractSchemaType(propertySchema) {
+    if (typeof propertySchema === 'object' && propertySchema !== null && 'type' in propertySchema) {
+        const declared = propertySchema.type;
+        return typeof declared === 'string' ? declared : null;
+    }
+    return null;
+}
+/**
+ * Checks whether a runtime value satisfies a declared JSON-Schema primitive
+ * type. Unknown/unsupported type keywords are treated permissively (they never
+ * cause a rejection), so this validator only ever rejects clear mismatches.
+ *
+ * @param value The runtime value to check.
+ * @param expectedType The declared JSON-Schema type keyword.
+ * @returns True when the value matches (or the keyword is unsupported).
+ */
+function valueMatchesJsonType(value, expectedType) {
+    switch (expectedType) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number';
+        case 'integer':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        case 'array':
+            return Array.isArray(value);
+        case 'null':
+            return value === null;
+        default:
+            return true;
+    }
+}
+/**
+ * Validates a parsed value against a `json_schema` object schema. Enforces that
+ * the value is a plain object, that every `required` property is present, and
+ * that present properties whose schema declares a primitive `type` match it.
+ *
+ * @param value The parsed value to validate.
+ * @param schema The object schema supplied on the response format.
+ * @throws {JsonParseError} When the value violates the schema.
+ */
+function validateJsonSchema(value, schema) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new JsonParseError(`JSON schema validation failed: expected an object but received ${jsonTypeOf(value)}.`);
+    }
+    const record = value;
+    const missing = (schema.required ?? []).filter((key) => !(key in record));
+    if (missing.length > 0) {
+        throw new JsonParseError(`JSON schema validation failed: missing required properties: ${missing.join(', ')}.`);
+    }
+    for (const [key, propertySchema] of Object.entries(schema.properties)) {
+        if (!(key in record))
+            continue;
+        const expectedType = extractSchemaType(propertySchema);
+        if (expectedType !== null && !valueMatchesJsonType(record[key], expectedType)) {
+            throw new JsonParseError(`JSON schema validation failed: property "${key}" expected type "${expectedType}" but received ${jsonTypeOf(record[key])}.`);
+        }
+    }
+}
+/**
+ * Finalizes a successfully-parsed JSON value. When the caller supplied a
+ * `json_schema` response format, the value is validated against that schema
+ * before being returned so schema violations surface as a thrown
+ * {@link JsonParseError} instead of flowing silently downstream. For plain
+ * `json` formats the value is returned unchanged.
+ *
+ * @param value The parsed value produced by a parsing strategy.
+ * @param responseFormat The originally requested response format.
+ * @returns The value narrowed to `T`.
+ * @throws {JsonParseError} When a supplied json_schema is not satisfied.
+ */
+function finalizeJsonResult(value, responseFormat) {
+    if (typeof responseFormat === 'object' && responseFormat?.type === 'json_schema') {
+        validateJsonSchema(value, responseFormat.schema);
+    }
+    return value;
+}
 
 /**
  * Default timeout values (in milliseconds) for external service calls.
@@ -9068,6 +9197,10 @@ async function createDeepseekCompletion(content, responseFormat, options = {}) {
  * @param responseFormat The format of the response. Defaults to 'json'.
  * @param options Configuration options including model ('deepseek-chat' or 'deepseek-reasoner'), tools, and apiKey.
  * @return A promise that resolves to the response from the Deepseek API.
+ * @throws {Error} If the requested capability (JSON output / tool calling) is
+ *   unsupported by the model, or if the underlying API call fails. This matches
+ *   the OpenAI and Anthropic providers, which surface failures by throwing
+ *   rather than returning a success-shaped response carrying an error payload.
  */
 const makeDeepseekCall = async (content, responseFormat = 'json', options = {}) => {
     // Set default model if not provided
@@ -9078,43 +9211,15 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
         mergedOptions.model = DEFAULT_DEEPSEEK_OPTIONS.defaultModel;
     }
     const modelName = normalizeModelName(mergedOptions.model);
-    // Check if the requested response format is compatible with the model
+    // Check if the requested response format is compatible with the model.
+    // Throw rather than returning a fake-success LLMResponse: a caller that
+    // asked for JSON must not silently receive an { error } payload typed as T.
     if (responseFormat !== 'text' && !supportsJsonOutput(modelName)) {
-        getLumicLogger().warn(`Model ${modelName} does not support JSON output. Will return error in the response.`);
-        return {
-            response: {
-                error: `Model ${modelName} does not support JSON output format.`
-            },
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                reasoning_tokens: 0,
-                provider: 'deepseek',
-                model: modelName,
-                cached_tokens: 0,
-                cost: 0,
-            },
-            tool_calls: undefined,
-        };
+        throw new Error(`Model ${modelName} does not support JSON output format.`);
     }
-    // Check if tools are requested with a model that doesn't support them
+    // Check if tools are requested with a model that doesn't support them.
     if (mergedOptions.tools && mergedOptions.tools.length > 0 && !supportsToolCalling(modelName)) {
-        getLumicLogger().warn(`Model ${modelName} does not support tool calling. Will return error in the response.`);
-        return {
-            response: {
-                error: `Model ${modelName} does not support tool calling.`
-            },
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                reasoning_tokens: 0,
-                provider: 'deepseek',
-                model: modelName,
-                cached_tokens: 0,
-                cost: 0,
-            },
-            tool_calls: undefined,
-        };
+        throw new Error(`Model ${modelName} does not support tool calling.`);
     }
     try {
         const completion = await createDeepseekCompletion(content, responseFormat, mergedOptions);
@@ -9164,23 +9269,13 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
         };
     }
     catch (error) {
-        // If there's an error due to incompatible features, return a structured error
+        // Mirror the OpenAI/Anthropic providers: log with sanitized context and
+        // rethrow so callers observe the failure. Returning a success-shaped
+        // response with an { error } payload here previously let hard failures
+        // (auth, timeout, rate-limit exhaustion, unparseable output) masquerade as
+        // successful completions downstream.
         getLumicLogger().error(`Error in Deepseek API call: ${sanitizeError(error)}`);
-        return {
-            response: {
-                error: sanitizeError(error)
-            },
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                reasoning_tokens: 0,
-                provider: 'deepseek',
-                model: modelName,
-                cached_tokens: 0,
-                cost: 0,
-            },
-            tool_calls: undefined,
-        };
+        throw error;
     }
 };
 
@@ -10114,14 +10209,27 @@ async function downloadFile(s3Client, bucketName, s3Key, localFilePath) {
 async function unzipFile(zipPath, destPath) {
     const zip = new AdmZip(zipPath);
     try {
-        zip.extractAllToAsync(destPath, true);
-        const stats = await getDirectoryStats(destPath);
-        return stats;
+        // extractAllToAsync is fire-and-forget: it returns void and reports
+        // failures through its callback. The previous call neither awaited it nor
+        // observed the callback, so getDirectoryStats raced an in-flight (or
+        // failed) extraction and any extraction error was silently dropped. Wrap
+        // it in a Promise so the extraction is fully awaited and errors surface.
+        await new Promise((resolve, reject) => {
+            zip.extractAllToAsync(destPath, true, false, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        return await getDirectoryStats(destPath);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         getLumicLogger().error(`Error unzipping file: ${errorMessage}`);
-        throw error;
+        throw new ZipError(`Failed to extract archive "${zipPath}" to "${destPath}": ${errorMessage}`, error);
     }
 }
 async function getDirectoryStats(dirPath) {
@@ -23075,11 +23183,11 @@ let poolConfig = DEFAULT_POOL_CONFIG;
 async function loadApolloModules() {
     if (typeof window === "undefined" || process.env.AWS_EXECUTION_ENV) {
         // Server-side (or Lambda): load the CommonJS‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.server-Cx30LaNh.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.server-JYHXy9ib.js'); }));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await Promise.resolve().then(function () { return require('./apollo-client.client-D6jG5B1n.js'); }));
+        return (await Promise.resolve().then(function () { return require('./apollo-client.client-CtjgIfRT.js'); }));
     }
 }
 /**
@@ -81790,4 +81898,4 @@ exports.withCorrelationId = withCorrelationId;
 exports.withMetrics = withMetrics;
 exports.withRateLimit = withRateLimit;
 exports.withRetry = withRetry;
-//# sourceMappingURL=index-ChygDqeG.js.map
+//# sourceMappingURL=index-DgFDhFuO.js.map