@adaptic/lumic-utils 1.0.25 → 1.0.26

package/dist/{index-Bvc61lYS.js → index-z7Y1nTVX.js}

@@ -1628,8 +1628,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
             () => {
@@ -1663,45 +1672,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
@@ -1712,6 +1741,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.
@@ -9048,6 +9177,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
@@ -9058,43 +9191,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);
@@ -9144,23 +9249,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;
     }
 };
 
@@ -10094,14 +10189,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) {
@@ -23055,11 +23163,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 import('./apollo-client.server-CXLiLmSz.js'));
+        return (await import('./apollo-client.server-DaXmxoBl.js'));
     }
     else {
         // Client-side: load the ESM‑based implementation.
-        return (await import('./apollo-client.client-DLW-p46Y.js'));
+        return (await import('./apollo-client.client-Uv0-ZrFd.js'));
     }
 }
 /**
@@ -81583,4 +81691,4 @@ const lumic = {
 };
 
 export { GraphQLInterfaceType as $, print as A, getNamedType as B, isInputType as C, isRequiredArgument as D, isNamedType as E, GraphQLError as F, GraphQLNonNull as G, isOutputType as H, isRequiredInputField as I, isCompositeType as J, Kind as K, getNullableType as L, getEnterLeaveForKind as M, isNode as N, OperationTypeNode as O, didYouMean as P, naturalCompare as Q, suggestionList as R, specifiedScalarTypes as S, keyMap as T, isType as U, isNullableType as V, visit as W, visitInParallel as X, keyValMap as Y, assertObjectType as Z, GraphQLScalarType as _, isListType as a, validateGoogleSheetsRange as a$, GraphQLUnionType as a0, GraphQLInputObjectType as a1, assertNullableType as a2, assertInterfaceType as a3, mapValue as a4, isSpecifiedScalarType as a5, isPrintableAsBlockString as a6, printBlockString as a7, BREAK as a8, GRAPHQL_MAX_INT as a9, printSourceLocation as aA, resolveObjMapThunk as aB, resolveReadonlyArrayThunk as aC, valueFromASTUntyped as aD, version$4 as aE, versionInfo as aF, getAugmentedNamespace as aG, isDigit$1 as aH, isNameStart as aI, dedentBlockStringLines as aJ, isNameContinue as aK, setLumicLogger as aL, getLumicLogger as aM, sanitizeForLog as aN, sanitizeError as aO, sanitizeAWSAuth as aP, sanitizeObject as aQ, getSecrets as aR, resetSecrets as aS, requireSecret as aT, withRetry as aU, CircuitBreaker as aV, CircuitBreakerState as aW, CircuitBreakerOpenError as aX, DEFAULT_CIRCUIT_BREAKER_CONFIG as aY, validateSlackChannel as aZ, validateS3Key as a_, GRAPHQL_MIN_INT as aa, GraphQLFloat as ab, GraphQLInt as ac, Location as ad, Token as ae, assertAbstractType as af, assertCompositeType as ag, assertEnumType as ah, assertEnumValueName as ai, assertInputObjectType as aj, assertInputType as ak, assertLeafType as al, assertListType as am, assertNamedType as an, assertNonNullType as ao, assertOutputType as ap, assertScalarType as aq, assertType as ar, assertUnionType as as, assertWrappingType as at, formatError as au, getLocation as av, getVisitFn as aw, isWrappingType as ax, printError as ay, printLocation as az, isAbstractType as b, PDFError as b$, LLMCostTracker as b0, getLLMCostTracker as b1, setLLMCostTracker as b2, resetLLMCostTracker as b3, setMetricsCollector as b4, getMetricsCollector as b5, resetMetricsCollector as b6, withMetrics as b7, generateCorrelationId as b8, getCorrelationId as b9, openAIChatCompletionSchema as bA, openAIImageResponseSchema as bB, validateOpenAIChatCompletion as bC, safeValidateOpenAIChatCompletion as bD, perplexityResponseSchema as bE, validatePerplexityResponse as bF, safeValidatePerplexityResponse as bG, googleSheetsValueRangeSchema as bH, validateGoogleSheetsResponse as bI, safeValidateGoogleSheetsResponse as bJ, s3ListObjectsSchema as bK, s3GetObjectSchema as bL, lambdaInvokeResponseSchema as bM, validateS3ListObjects as bN, safeValidateS3ListObjects as bO, validateLambdaResponse as bP, safeValidateLambdaResponse as bQ, createValidator as bR, createSafeValidator as bS, LumicError as bT, SlackError as bU, LLMError as bV, AWSLambdaError as bW, AWSS3Error as bX, GoogleSheetsError as bY, PerplexityError as bZ, JsonParseError as b_, getCorrelationContext as ba, withCorrelationId as bb, getCorrelationHeaders as bc, TokenBucketRateLimiter as bd, RATE_LIMIT_PROFILES as be, getRateLimiter as bf, resetAllRateLimiters as bg, withRateLimit as bh, checkIntegrationHealth as bi, SUPPORTED_MODELS as bj, isValidModel as bk, getModelCapabilities as bl, getModelProvider as bm, MODEL_ALIASES as bn, OPENAI_COMPATIBLE_PROVIDERS as bo, PROVIDER_DEFAULT_MODELS as bp, LLM_DEFAULT_PROVIDER as bq, LLM_MINI_PROVIDER as br, LLM_NORMAL_PROVIDER as bs, LLM_ADVANCED_PROVIDER as bt, LLM_PROVIDER as bu, LLM_MODEL_MINI as bv, LLM_MODEL_NORMAL as bw, LLM_MODEL_ADVANCED as bx, makeAnthropicCall as by, makeOpenAICompatibleCall as bz, isInterfaceType as c, ZipError as c0, SLACK_TIMEOUT_MS as c1, PERPLEXITY_TIMEOUT_MS as c2, GOOGLE_SHEETS_TIMEOUT_MS as c3, LLM_TIMEOUT_MS as c4, AWS_LAMBDA_TIMEOUT_MS as c5, AWS_S3_TIMEOUT_MS as c6, OPENWEATHER_TIMEOUT_MS as c7, GENERIC_FETCH_TIMEOUT_MS as c8, isObjectType as d, assertName as e, devAssert as f, isObjectLike as g, defineArguments as h, isNonNullType as i, argsToArgsConfig as j, GraphQLBoolean as k, lumic as l, GraphQLString as m, instanceOf as n, inspect as o, isInputObjectType as p, isLeafType as q, isEnumType as r, GraphQLID as s, toObjMap as t, invariant as u, GraphQLObjectType as v, GraphQLEnumType as w, GraphQLList as x, isScalarType as y, isUnionType as z };
-//# sourceMappingURL=index-Bvc61lYS.js.map
+//# sourceMappingURL=index-z7Y1nTVX.js.map