@juspay/neurolink 7.37.0 → 7.38.0

package/dist/types/streamTypes.d.ts

@@ -1,12 +1,13 @@
 import type { Tool } from "ai";
 import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
-import type { AIProviderName, ProviderConfig } from "./providers.js";
-import type { AnalyticsData, TokenUsage } from "./analytics.js";
-import type { EvaluationData } from "./evaluation.js";
-import type { UnknownRecord, JsonValue } from "./common.js";
-import type { ChatMessage } from "./conversation.js";
+import type { ProviderConfig } from "./providers.js";
 import type { TextContent, ImageContent } from "./content.js";
-import type { MiddlewareFactoryOptions } from "./middlewareTypes.js";
+import type { AIProviderName, AnalyticsData } from "../core/types.js";
+import type { TokenUsage } from "./analytics.js";
+import type { EvaluationData } from "../index.js";
+import type { UnknownRecord, JsonValue, ToolExecutionEvent, ToolExecutionSummary } from "./common.js";
+import type { MiddlewareFactoryOptions } from "../types/middlewareTypes.js";
+import type { ChatMessage } from "./conversation.js";
 /**
  * Progress tracking and metadata for streaming operations
  */
@@ -187,6 +188,9 @@ export type StreamResult = {
     finishReason?: string;
     toolCalls?: ToolCall[];
     toolResults?: ToolResult[];
+    toolEvents?: AsyncIterable<ToolExecutionEvent>;
+    toolExecutions?: ToolExecutionSummary[];
+    toolsUsed?: string[];
     metadata?: {
         streamId?: string;
         startTime?: number;
@@ -194,6 +198,9 @@ export type StreamResult = {
         estimatedDuration?: number;
         responseTime?: number;
         fallback?: boolean;
+        totalToolExecutions?: number;
+        toolExecutionTime?: number;
+        hasToolErrors?: boolean;
     };
     analytics?: AnalyticsData | Promise<AnalyticsData>;
     evaluation?: EvaluationData | Promise<EvaluationData>;

package/dist/types/typeAliases.d.ts

@@ -2,14 +2,15 @@
  * Comprehensive Type Alias Library
  * Centralizes commonly used complex types to improve readability and maintainability
  */
-import type { ZodType, ZodTypeDef } from "zod";
+import type { ZodTypeAny } from "zod";
 import type { Schema } from "ai";
 import type { JsonValue, JsonObject } from "./common.js";
 /**
  * Type alias for complex Zod schema type to improve readability
  * Used across providers and validation systems
+ * Using ZodTypeAny to prevent infinite type recursion in zod-to-json-schema
  */
-export type ZodUnknownSchema = ZodType<unknown, ZodTypeDef, unknown>;
+export type ZodUnknownSchema = ZodTypeAny;
 /**
  * Union type for schema validation (Zod or AI SDK schema)
  * Commonly used in provider interfaces and validation functions

package/dist/utils/conversationMemory.js

@@ -32,8 +32,10 @@ export async function getConversationMessages(conversationMemory, options) {
         return [];
     }
     try {
+        // Extract userId from context
+        const userId = options.context?.userId;
         // Remove duplicate summarization logic - it should be handled in ConversationMemoryManager
-        const messages = await conversationMemory.buildContextMessages(sessionId);
+        const messages = await conversationMemory.buildContextMessages(sessionId, userId);
         logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
             sessionId,
             messageCount: messages.length,

package/dist/utils/messageBuilder.d.ts

@@ -3,18 +3,26 @@
  * Centralized logic for building message arrays from TextGenerationOptions
  * Enhanced with multimodal support for images
  */
-import type { ChatMessage, MultimodalChatMessage } from "../types/conversation.js";
+import type { MultimodalChatMessage } from "../types/conversation.js";
 import type { TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions } from "../types/streamTypes.js";
 import type { GenerateOptions } from "../types/generateTypes.js";
+/**
+ * Core message type compatible with AI SDK
+ */
+type CoreMessage = {
+    role: "user" | "assistant" | "system";
+    content: string;
+};
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt
  * Supports both TextGenerationOptions and StreamOptions
  */
-export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): ChatMessage[];
+export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): CoreMessage[];
 /**
  * Build multimodal message array with image support
  * Detects when images are present and routes through provider adapter
  */
 export declare function buildMultimodalMessagesArray(options: GenerateOptions, provider: string, model: string): Promise<MultimodalChatMessage[]>;
+export {};

package/dist/utils/messageBuilder.js

@@ -8,6 +8,21 @@ import { ProviderImageAdapter, MultimodalLogger, } from "../adapters/providerIma
 import { logger } from "./logger.js";
 import { request } from "undici";
 import { readFileSync, existsSync } from "fs";
+/**
+ * Convert ChatMessage to CoreMessage for AI SDK compatibility
+ */
+function toCoreMessage(message) {
+    // Only include messages with roles supported by AI SDK
+    if (message.role === "user" ||
+        message.role === "assistant" ||
+        message.role === "system") {
+        return {
+            role: message.role,
+            content: message.content,
+        };
+    }
+    return null; // Filter out tool_call and tool_result messages
+}
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt
@@ -31,8 +46,14 @@ export function buildMessagesArray(options) {
         });
     }
     // Add conversation history if available
+    // Convert ChatMessages to CoreMessages and filter out tool messages
     if (hasConversationHistory && options.conversationMessages) {
-        messages.push(...options.conversationMessages);
+        for (const chatMessage of options.conversationMessages) {
+            const coreMessage = toCoreMessage(chatMessage);
+            if (coreMessage) {
+                messages.push(coreMessage);
+            }
+        }
     }
     // Add current user prompt (required)
     // Handle both TextGenerationOptions (prompt field) and StreamOptions (input.text field)

package/dist/utils/parameterValidation.js

@@ -192,28 +192,9 @@ export function validateMCPTool(tool) {
     if (execError) {
         errors.push(execError);
     }
-    // Additional MCP-specific validation
-    if (mcpTool.execute) {
-        try {
-            // Test execute function with mock data
-            const mockParams = {};
-            const mockContext = {
-                sessionId: "validation-test",
-                userId: "validation-user",
-            };
-            const result = mcpTool.execute(mockParams, mockContext);
-            const returnsPromise = result && typeof result === "object" && "then" in result;
-            if (!returnsPromise) {
-                errors.push(new ValidationError("Execute function must return a Promise", "execute", "NOT_PROMISE", [
-                    "Ensure function returns a Promise<ToolResult>",
-                    "Use async/await pattern",
-                    "Return a result object with success property",
-                ]));
-            }
-        }
-        catch (error) {
-            warnings.push(`Execute function validation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    // Simplified validation - just check if execute is a function
+    if (mcpTool.execute && typeof mcpTool.execute !== "function") {
+        errors.push(new ValidationError("Execute must be a function", "execute", "INVALID_TYPE", ["Provide a function for the execute property"]));
     }
     // Check optional properties
     if (mcpTool.inputSchema && !isNonNullObject(mcpTool.inputSchema)) {
@@ -264,7 +245,7 @@ export function validateTextGenerationOptions(options) {
         errors.push(tempError);
     }
     // Validate maxTokens
-    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 200000);
+    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 128000);
     if (tokensError) {
         errors.push(tokensError);
     }
@@ -316,7 +297,7 @@ export function validateStreamOptions(options) {
         errors.push(tempError);
     }
     // Validate maxTokens
-    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 200000);
+    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 128000);
     if (tokensError) {
         errors.push(tokensError);
     }
@@ -349,7 +330,7 @@ export function validateGenerateOptions(options) {
     if (tempError) {
         errors.push(tempError);
     }
-    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 200000);
+    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 128000);
     if (tokensError) {
         errors.push(tokensError);
     }

package/dist/utils/promptRedaction.js

@@ -16,8 +16,8 @@ const DEFAULT_REDACTION_OPTIONS = {
  */
 export function redactPrompt(prompt, options = {}) {
     const opts = { ...DEFAULT_REDACTION_OPTIONS, ...options };
-    if (!prompt || typeof prompt !== 'string') {
-        return '[INVALID_PROMPT]';
+    if (!prompt || typeof prompt !== "string") {
+        return "[INVALID_PROMPT]";
     }
     const wordCount = prompt.trim().split(/\s+/).length;
     let redacted = prompt.substring(0, opts.maxLength);
@@ -35,8 +35,8 @@ export function redactPrompt(prompt, options = {}) {
  * Create a short safe mask for highly sensitive contexts
  */
 export function createSafeMask(prompt, _maskLength = 20) {
-    if (!prompt || typeof prompt !== 'string') {
-        return '[INVALID_PROMPT]';
+    if (!prompt || typeof prompt !== "string") {
+        return "[INVALID_PROMPT]";
     }
     const wordCount = prompt.trim().split(/\s+/).length;
     const charCount = prompt.length;

package/dist/utils/redis.d.ts

@@ -4,7 +4,7 @@
  */
 import { createClient } from "redis";
 type RedisClient = ReturnType<typeof createClient>;
-import type { ChatMessage, RedisStorageConfig } from "../types/conversation.js";
+import type { RedisStorageConfig, RedisConversationObject } from "../types/conversation.js";
 /**
  * Creates a Redis client with the provided configuration
  */
@@ -12,15 +12,19 @@ export declare function createRedisClient(config: Required<RedisStorageConfig>):
 /**
  * Generates a Redis key for session messages
  */
-export declare function getSessionKey(config: Required<RedisStorageConfig>, sessionId: string): string;
+export declare function getSessionKey(config: Required<RedisStorageConfig>, sessionId: string, userId?: string): string;
 /**
- * Serializes messages for Redis storage
+ * Generates a Redis key for user sessions mapping
  */
-export declare function serializeMessages(messages: ChatMessage[]): string;
+export declare function getUserSessionsKey(config: Required<RedisStorageConfig>, userId: string): string;
 /**
- * Deserializes messages from Redis storage
+ * Serializes conversation object for Redis storage
  */
-export declare function deserializeMessages(data: string | null): ChatMessage[];
+export declare function serializeConversation(conversation: RedisConversationObject): string;
+/**
+ * Deserializes conversation object from Redis storage
+ */
+export declare function deserializeConversation(data: string | null): RedisConversationObject | null;
 /**
  * Checks if Redis client is healthy
  */

package/dist/utils/redis.js

@@ -53,123 +53,120 @@ export async function createRedisClient(config) {
 /**
  * Generates a Redis key for session messages
  */
-export function getSessionKey(config, sessionId) {
-    const key = `${config.keyPrefix}${sessionId}`;
+export function getSessionKey(config, sessionId, userId) {
+    const key = `${config.keyPrefix}${userId || "randomUser"}:${sessionId}`;
     logger.debug("[redisUtils] Generated session key", {
         sessionId,
+        userId,
         keyPrefix: config.keyPrefix,
         fullKey: key,
     });
     return key;
 }
 /**
- * Serializes messages for Redis storage
+ * Generates a Redis key for user sessions mapping
  */
-export function serializeMessages(messages) {
+export function getUserSessionsKey(config, userId) {
+    return `${config.userSessionsKeyPrefix}${userId}`;
+}
+/**
+ * Serializes conversation object for Redis storage
+ */
+export function serializeConversation(conversation) {
     try {
-        logger.debug("[redisUtils] Serializing messages", {
-            messageCount: messages.length,
-            messageTypes: messages.map((m) => m.role),
-            firstMessage: messages.length > 0
-                ? {
-                    role: messages[0].role,
-                    contentLength: messages[0].content.length,
-                    contentPreview: messages[0].content.substring(0, 50),
-                }
-                : null,
-            lastMessage: messages.length > 0
-                ? {
-                    role: messages[messages.length - 1].role,
-                    contentLength: messages[messages.length - 1].content.length,
-                    contentPreview: messages[messages.length - 1].content.substring(0, 50),
-                }
-                : null,
-        });
-        const serialized = JSON.stringify(messages);
-        logger.debug("[redisUtils] Messages serialized successfully", {
-            serializedLength: serialized.length,
-            messageCount: messages.length,
-        });
+        const serialized = JSON.stringify(conversation);
         return serialized;
     }
     catch (error) {
-        logger.error("[redisUtils] Failed to serialize messages", {
+        logger.error("[redisUtils] Failed to serialize conversation", {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : undefined,
-            messageCount: messages.length,
+            sessionId: conversation?.sessionId,
+            userId: conversation?.userId,
         });
         throw error;
     }
 }
 /**
- * Deserializes messages from Redis storage
+ * Deserializes conversation object from Redis storage
  */
-export function deserializeMessages(data) {
+export function deserializeConversation(data) {
     if (!data) {
-        logger.debug("[redisUtils] No data to deserialize, returning empty array");
-        return [];
+        logger.debug("[redisUtils] No conversation data to deserialize, returning null");
+        return null;
     }
     try {
-        logger.debug("[redisUtils] Deserializing messages", {
+        logger.debug("[redisUtils] Deserializing conversation", {
             dataLength: data.length,
             dataPreview: data.substring(0, 100) + (data.length > 100 ? "..." : ""),
         });
         // Parse as unknown first, then validate before casting
         const parsedData = JSON.parse(data);
-        // Check if the parsed data is an array
-        if (!Array.isArray(parsedData)) {
-            logger.warn("[redisUtils] Deserialized data is not an array", {
+        // Check if the parsed data is an object with required properties
+        if (typeof parsedData !== "object" ||
+            parsedData === null ||
+            !("title" in parsedData) ||
+            !("sessionId" in parsedData) ||
+            !("userId" in parsedData) ||
+            !("createdAt" in parsedData) ||
+            !("updatedAt" in parsedData) ||
+            !("messages" in parsedData)) {
+            logger.warn("[redisUtils] Deserialized data is not a valid conversation object", {
                 type: typeof parsedData,
+                hasRequiredFields: parsedData && typeof parsedData === "object"
+                    ? Object.keys(parsedData).join(", ")
+                    : "none",
                 preview: JSON.stringify(parsedData).substring(0, 100),
             });
-            return [];
+            return null;
+        }
+        const conversation = parsedData;
+        // Validate messages is an array
+        if (!Array.isArray(conversation.messages)) {
+            logger.warn("[redisUtils] messages is not an array", {
+                type: typeof conversation.messages,
+            });
+            return null;
         }
-        // Validate each item in the array has the correct ChatMessage structure
-        const isValid = parsedData.every((m) => typeof m === "object" &&
+        // Validate each message in the messages array
+        const isValidHistory = conversation.messages.every((m) => typeof m === "object" &&
             m !== null &&
             "role" in m &&
             "content" in m &&
             typeof m.role === "string" &&
             typeof m.content === "string" &&
-            (m.role === "user" || m.role === "assistant" || m.role === "system"));
-        if (!isValid) {
-            logger.warn("[redisUtils] Deserialized data has unexpected structure", {
-                isArray: true,
-                firstItem: parsedData.length > 0 ? JSON.stringify(parsedData[0]) : null,
+            (m.role === "user" ||
+                m.role === "assistant" ||
+                m.role === "system" ||
+                m.role === "tool_call" ||
+                m.role === "tool_result"));
+        if (!isValidHistory) {
+            logger.warn("[redisUtils] Invalid messages structure", {
+                messageCount: conversation.messages.length,
+                firstMessage: conversation.messages.length > 0
+                    ? JSON.stringify(conversation.messages[0])
+                    : null,
             });
-            return [];
+            return null;
         }
-        // Now that we've validated, we can safely cast
-        const messages = parsedData;
-        logger.debug("[redisUtils] Messages deserialized successfully", {
-            messageCount: messages.length,
-            messageTypes: messages.map((m) => m.role),
-            firstMessage: messages.length > 0
-                ? {
-                    role: messages[0].role,
-                    contentLength: messages[0].content.length,
-                    contentPreview: messages[0].content.substring(0, 50),
-                }
-                : null,
-            lastMessage: messages.length > 0
-                ? {
-                    role: messages[messages.length - 1].role,
-                    contentLength: messages[messages.length - 1].content.length,
-                    contentPreview: messages[messages.length - 1].content.substring(0, 50),
-                }
-                : null,
+        logger.debug("[redisUtils] Conversation deserialized successfully", {
+            sessionId: conversation.sessionId,
+            userId: conversation.userId,
+            title: conversation.title,
+            messageCount: conversation.messages.length,
+            createdAt: conversation.createdAt,
+            updatedAt: conversation.updatedAt,
         });
-        logger.debug("[deserializeMessages] completed");
-        return messages;
+        return conversation;
     }
     catch (error) {
-        logger.error("[redisUtils] Failed to deserialize messages", {
+        logger.error("[redisUtils] Failed to deserialize conversation", {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : undefined,
             dataLength: data.length,
             dataPreview: "[REDACTED]", // Prevent exposure of potentially sensitive data
         });
-        return [];
+        return null;
     }
 }
 /**
@@ -245,12 +242,16 @@ export async function scanKeys(client, pattern, batchSize = 100) {
  * Get normalized Redis configuration with defaults
  */
 export function getNormalizedConfig(config) {
+    const keyPrefix = config.keyPrefix || "neurolink:conversation:";
+    // Intelligent default: derive user sessions prefix from conversation prefix
+    const defaultUserSessionsPrefix = keyPrefix.replace(/conversation:?$/, "user:sessions:");
     return {
         host: config.host || "localhost",
         port: config.port || 6379,
         password: config.password || "",
         db: config.db || 0,
-        keyPrefix: config.keyPrefix || "neurolink:conversation:",
+        keyPrefix,
+        userSessionsKeyPrefix: config.userSessionsKeyPrefix || defaultUserSessionsPrefix,
         ttl: config.ttl || 86400,
         connectionOptions: {
             connectTimeout: 30000,

package/dist/utils/schemaConversion.d.ts

@@ -0,0 +1,14 @@
+import type { ZodUnknownSchema } from "../types/tools.js";
+/**
+ * Convert Zod schema to JSON Schema format for Claude AI
+ */
+export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema): object;
+/**
+ * Check if a value is a Zod schema
+ */
+export declare function isZodSchema(value: unknown): boolean;
+/**
+ * Convert JSON Schema to Zod schema format using official json-schema-to-zod library
+ * This ensures complete preservation of all schema structure and validation rules
+ */
+export declare function convertJsonSchemaToZod(jsonSchema: Record<string, unknown>): ZodUnknownSchema;

package/dist/utils/schemaConversion.js

@@ -0,0 +1,140 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { jsonSchemaToZod } from "json-schema-to-zod";
+import { z } from "zod";
+import { logger } from "./logger.js";
+/**
+ * Convert Zod schema to JSON Schema format for Claude AI
+ */
+export function convertZodToJsonSchema(zodSchema) {
+    try {
+        // Use a type assertion that bypasses the infinite recursion check
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const jsonSchema = zodToJsonSchema(zodSchema, {
+            name: "ToolParameters",
+            target: "jsonSchema7",
+            errorMessages: true,
+        });
+        // CRITICAL FIX: Ensure schema always has a proper type field for Google Vertex AI
+        if (!jsonSchema.type) {
+            // Default to "object" type if not specified, as most tool schemas are objects
+            jsonSchema.type = "object";
+            // If no properties, ensure it's at least an empty object schema
+            if (!jsonSchema.properties) {
+                jsonSchema.properties = {};
+            }
+            logger.info(`[SCHEMA-TYPE-FIX] Added missing type field to JSON Schema`, {
+                originalType: undefined,
+                fixedType: jsonSchema.type,
+                hasProperties: !!jsonSchema.properties,
+                addedEmptyProperties: !jsonSchema.properties,
+            });
+        }
+        logger.debug("Converted Zod schema to JSON Schema", {
+            hasProperties: !!jsonSchema.properties,
+            propertiesCount: Object.keys(jsonSchema.properties || {}).length,
+            schemaType: jsonSchema.type,
+            hasTypeField: !!jsonSchema.type,
+        });
+        return jsonSchema;
+    }
+    catch (error) {
+        logger.warn("Failed to convert Zod schema to JSON Schema", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        // Return a valid empty object schema instead of empty object
+        return {
+            type: "object",
+            properties: {},
+        };
+    }
+}
+/**
+ * Check if a value is a Zod schema
+ */
+export function isZodSchema(value) {
+    return !!(value &&
+        typeof value === "object" &&
+        "_def" in value &&
+        typeof value.parse === "function");
+}
+/**
+ * Convert JSON Schema to Zod schema format using official json-schema-to-zod library
+ * This ensures complete preservation of all schema structure and validation rules
+ */
+export function convertJsonSchemaToZod(jsonSchema) {
+    const startTime = Date.now();
+    try {
+        // Handle empty or invalid schemas
+        if (!jsonSchema || typeof jsonSchema !== "object") {
+            logger.debug("🔍 [SCHEMA-CONVERSION] Invalid or empty JSON schema, using fallback");
+            return z.object({}).passthrough();
+        }
+        // Log detailed input schema for debugging
+        logger.debug("🔍 [SCHEMA-CONVERSION] ===== STARTING OFFICIAL LIBRARY CONVERSION =====");
+        logger.debug("🔍 [SCHEMA-CONVERSION] Input JSON Schema:", {
+            type: jsonSchema.type,
+            hasProperties: !!jsonSchema.properties,
+            propertiesCount: jsonSchema.properties
+                ? Object.keys(jsonSchema.properties).length
+                : 0,
+            requiredCount: Array.isArray(jsonSchema.required)
+                ? jsonSchema.required.length
+                : 0,
+            required: jsonSchema.required,
+            sampleProperties: jsonSchema.properties
+                ? Object.keys(jsonSchema.properties).slice(0, 5)
+                : [],
+        });
+        // Use official library to convert JSON Schema to Zod code
+        const zodCodeResult = jsonSchemaToZod(jsonSchema, {
+            module: "esm",
+            name: "schema",
+        });
+        logger.debug("🔍 [SCHEMA-CONVERSION] Generated Zod code:", {
+            codeLength: zodCodeResult.length,
+            codePreview: zodCodeResult.substring(0, 200) + "...",
+        });
+        // Extract the actual Zod schema expression from the generated code
+        // Generated code looks like: "import { z } from "zod"\n\nexport const schema = z.object({...})\n"
+        const schemaMatch = zodCodeResult.match(/export const schema = (z\..+?)(?:\n|$)/s);
+        if (!schemaMatch) {
+            throw new Error("Could not extract Zod schema from generated code");
+        }
+        const schemaExpression = schemaMatch[1].trim();
+        logger.debug("🔍 [SCHEMA-CONVERSION] Extracted schema expression:", {
+            expression: schemaExpression.substring(0, 300) + "...",
+        });
+        // Use Function constructor instead of eval for better scope control
+        const createZodSchema = new Function("z", `return ${schemaExpression}`);
+        const zodSchema = createZodSchema(z);
+        const conversionTime = Date.now() - startTime;
+        logger.debug("🔍 [SCHEMA-CONVERSION] ===== CONVERSION SUCCESSFUL =====", {
+            inputType: jsonSchema.type,
+            propertiesCount: jsonSchema.properties
+                ? Object.keys(jsonSchema.properties).length
+                : 0,
+            requiredCount: Array.isArray(jsonSchema.required)
+                ? jsonSchema.required.length
+                : 0,
+            conversionSuccess: true,
+            conversionTimeMs: conversionTime,
+            libraryUsed: "json-schema-to-zod-official",
+            zodSchemaType: zodSchema?.constructor?.name || "unknown",
+        });
+        return zodSchema;
+    }
+    catch (error) {
+        const conversionTime = Date.now() - startTime;
+        logger.warn("🚨 [SCHEMA-CONVERSION] Official library conversion failed, using passthrough fallback", {
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.constructor.name : typeof error,
+            inputSchemaType: jsonSchema?.type,
+            inputSchemaKeys: jsonSchema && typeof jsonSchema === "object"
+                ? Object.keys(jsonSchema)
+                : [],
+            conversionTimeMs: conversionTime,
+            libraryUsed: "json-schema-to-zod-official-FAILED",
+        });
+        return z.object({}).passthrough();
+    }
+}