@juspay/neurolink 9.30.0 → 9.31.0

package/dist/client/utils/schemaConversion.js

@@ -0,0 +1,255 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { jsonSchemaToZod } from "json-schema-to-zod";
+import { z } from "zod";
+import { logger } from "./logger.js";
+/**
+ * Inline a JSON Schema by recursively resolving all $ref references.
+ * zodToJsonSchema with 'name' option produces schemas with $ref pointing to definitions.
+ * Some SDKs (like @google/genai) expect flat schemas without $ref.
+ *
+ * This function handles:
+ * - Top-level $ref resolution
+ * - Nested $ref within properties, items, additionalProperties
+ * - $ref within allOf, anyOf, oneOf arrays
+ * - Circular reference detection to prevent infinite loops
+ */
+export function inlineJsonSchema(schema, definitions, visited = new Set()) {
+    // Use definitions from schema if not provided
+    const defs = definitions ||
+        schema.definitions;
+    // Handle $ref at current level
+    if (typeof schema.$ref === "string" &&
+        schema.$ref.startsWith("#/definitions/")) {
+        const defName = schema.$ref.replace("#/definitions/", "");
+        // Prevent circular reference infinite loops
+        if (visited.has(defName)) {
+            logger.debug(`[SCHEMA-INLINE] Circular reference detected for: ${defName}`);
+            // Return a simple object placeholder for circular refs
+            return { type: "object" };
+        }
+        if (defs && defs[defName]) {
+            visited.add(defName);
+            // Recursively inline the resolved definition
+            const resolved = inlineJsonSchema({ ...defs[defName] }, defs, visited);
+            visited.delete(defName);
+            return resolved;
+        }
+    }
+    // Create result without $ref and definitions
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        // Skip $ref and definitions keys
+        if (key === "$ref" || key === "definitions") {
+            continue;
+        }
+        // Recursively process nested schemas
+        if (key === "properties" && value && typeof value === "object") {
+            const properties = {};
+            for (const [propName, propSchema] of Object.entries(value)) {
+                if (propSchema && typeof propSchema === "object") {
+                    properties[propName] = inlineJsonSchema(propSchema, defs, visited);
+                }
+                else {
+                    properties[propName] = propSchema;
+                }
+            }
+            result[key] = properties;
+        }
+        else if (key === "items" && value && typeof value === "object") {
+            // Handle array items schema
+            if (Array.isArray(value)) {
+                result[key] = value.map((item) => item && typeof item === "object"
+                    ? inlineJsonSchema(item, defs, visited)
+                    : item);
+            }
+            else {
+                result[key] = inlineJsonSchema(value, defs, visited);
+            }
+        }
+        else if (key === "additionalProperties" &&
+            value &&
+            typeof value === "object") {
+            result[key] = inlineJsonSchema(value, defs, visited);
+        }
+        else if ((key === "allOf" || key === "anyOf" || key === "oneOf") &&
+            Array.isArray(value)) {
+            // Handle composition schemas
+            result[key] = value.map((item) => item && typeof item === "object"
+                ? inlineJsonSchema(item, defs, visited)
+                : item);
+        }
+        else if (key === "not" && value && typeof value === "object") {
+            result[key] = inlineJsonSchema(value, defs, visited);
+        }
+        else if ((key === "if" || key === "then" || key === "else") &&
+            value &&
+            typeof value === "object") {
+            result[key] = inlineJsonSchema(value, defs, visited);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Convert Zod schema to JSON Schema format for provider APIs.
+ *
+ * Handles three input types:
+ * 1. Zod schemas (have `_def.typeName`) — converted via zod-to-json-schema
+ * 2. AI SDK `jsonSchema()` wrappers (have `.jsonSchema` property) — extracted directly
+ * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) — returned as-is
+ */
+export function convertZodToJsonSchema(zodSchema) {
+    const schema = zodSchema;
+    if (!schema || typeof schema !== "object") {
+        return { type: "object", properties: {} };
+    }
+    // AI SDK jsonSchema() wrapper — extract the inner JSON Schema directly
+    if ("jsonSchema" in schema &&
+        schema.jsonSchema !== null &&
+        typeof schema.jsonSchema === "object") {
+        const extracted = schema.jsonSchema;
+        return ensureTypeField(extracted);
+    }
+    // Plain JSON Schema object (from external MCP tools) — no Zod internals
+    if (!isZodSchema(schema)) {
+        return ensureTypeField(schema);
+    }
+    // Actual Zod schema — convert via zod-to-json-schema
+    try {
+        // Zod 4→3 boundary: zodToJsonSchema types reference Zod 3's ZodSchema via zod/v3.
+        // Runtime compatible — cast through unknown at this third-party boundary only.
+        const zodV3Schema = zodSchema;
+        const jsonSchema = zodToJsonSchema(zodV3Schema, {
+            name: "ToolParameters",
+            target: "jsonSchema7",
+            errorMessages: true,
+        });
+        // zodToJsonSchema with 'name' produces { $ref: "#/definitions/ToolParameters", definitions: {...} }
+        // Inline the $ref to produce a flat schema before passing to ensureTypeField
+        const inlined = inlineJsonSchema(jsonSchema);
+        return ensureTypeField(inlined);
+    }
+    catch (error) {
+        logger.warn("Failed to convert Zod schema to JSON Schema", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return { type: "object", properties: {} };
+    }
+}
+/**
+ * Ensure a JSON Schema object has a `type` field (required by Vertex/Gemini).
+ */
+function ensureTypeField(schema) {
+    if (!schema.type) {
+        // Schemas using composition keywords (anyOf/oneOf/allOf) deliberately omit type
+        if (schema.anyOf || schema.oneOf || schema.allOf) {
+            return schema;
+        }
+        const hadProperties = !!schema.properties;
+        const result = {
+            ...schema,
+            type: "object",
+        };
+        if (!result.properties) {
+            result.properties = {};
+        }
+        logger.debug("[SCHEMA-TYPE-FIX] Added missing type field to JSON Schema", {
+            fixedType: "object",
+            addedProperties: !hadProperties,
+        });
+        return result;
+    }
+    return schema;
+}
+/**
+ * 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();
+    }
+}

package/dist/client/utils/taskClassificationUtils.js

@@ -0,0 +1,149 @@
+/**
+ * Task Classification Utility Functions
+ * Helper functions for analyzing prompts and calculating scores
+ */
+import { FAST_PATTERNS, REASONING_PATTERNS, FAST_KEYWORDS, REASONING_KEYWORDS, SCORING_WEIGHTS, CLASSIFICATION_THRESHOLDS, DOMAIN_PATTERNS, } from "../config/taskClassificationConfig.js";
+/**
+ * Analyze prompt length and apply scoring bonuses
+ */
+export function analyzeLengthFactors(prompt, reasons) {
+    let fastScore = 0;
+    let reasoningScore = 0;
+    if (prompt.length < CLASSIFICATION_THRESHOLDS.SHORT_PROMPT_LENGTH) {
+        fastScore += SCORING_WEIGHTS.SHORT_PROMPT_BONUS;
+        reasons.push("short prompt");
+    }
+    else if (prompt.length > CLASSIFICATION_THRESHOLDS.LONG_PROMPT_LENGTH) {
+        reasoningScore += SCORING_WEIGHTS.LONG_PROMPT_BONUS;
+        reasons.push("detailed prompt");
+    }
+    return { fastScore, reasoningScore };
+}
+/**
+ * Check prompt against fast task patterns
+ */
+export function checkFastPatterns(normalizedPrompt, reasons) {
+    for (const pattern of FAST_PATTERNS) {
+        if (pattern.test(normalizedPrompt)) {
+            reasons.push("fast pattern match");
+            return SCORING_WEIGHTS.PATTERN_MATCH_SCORE;
+        }
+    }
+    return 0;
+}
+/**
+ * Check prompt against reasoning task patterns
+ */
+export function checkReasoningPatterns(normalizedPrompt, reasons) {
+    for (const pattern of REASONING_PATTERNS) {
+        if (pattern.test(normalizedPrompt)) {
+            reasons.push("reasoning pattern match");
+            return SCORING_WEIGHTS.PATTERN_MATCH_SCORE;
+        }
+    }
+    return 0;
+}
+/**
+ * Analyze keyword matches in the prompt
+ */
+export function analyzeKeywords(normalizedPrompt, reasons) {
+    const fastKeywordMatches = FAST_KEYWORDS.filter((keyword) => normalizedPrompt.includes(keyword)).length;
+    const reasoningKeywordMatches = REASONING_KEYWORDS.filter((keyword) => normalizedPrompt.includes(keyword)).length;
+    const fastScore = fastKeywordMatches * SCORING_WEIGHTS.KEYWORD_MATCH_SCORE;
+    const reasoningScore = reasoningKeywordMatches * SCORING_WEIGHTS.KEYWORD_MATCH_SCORE;
+    if (fastKeywordMatches > 0) {
+        reasons.push(`${fastKeywordMatches} fast keywords`);
+    }
+    if (reasoningKeywordMatches > 0) {
+        reasons.push(`${reasoningKeywordMatches} reasoning keywords`);
+    }
+    return { fastScore, reasoningScore };
+}
+/**
+ * Analyze question complexity
+ */
+export function analyzeQuestionComplexity(prompt, reasons) {
+    const questionMarks = (prompt.match(/\?/g) || []).length;
+    if (questionMarks > 1) {
+        reasons.push("multiple questions");
+        return SCORING_WEIGHTS.MULTIPLE_QUESTIONS_BONUS;
+    }
+    return 0;
+}
+/**
+ * Analyze prompt structure and punctuation
+ */
+export function analyzePromptStructure(prompt, reasons) {
+    const sentences = prompt.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+    if (sentences.length > 3) {
+        reasons.push("multi-sentence structure");
+        return SCORING_WEIGHTS.MULTI_SENTENCE_BONUS;
+    }
+    return 0;
+}
+/**
+ * Analyze domain-specific indicators
+ */
+export function analyzeDomainIndicators(normalizedPrompt, prompt, reasons) {
+    let fastScore = 0;
+    let reasoningScore = 0;
+    // Check for technical domain
+    if (DOMAIN_PATTERNS.TECHNICAL.test(normalizedPrompt)) {
+        reasoningScore += SCORING_WEIGHTS.TECHNICAL_DOMAIN_BONUS;
+        reasons.push("technical domain");
+    }
+    // Check for simple definition requests
+    if (DOMAIN_PATTERNS.SIMPLE_DEFINITION.test(normalizedPrompt) &&
+        prompt.length < CLASSIFICATION_THRESHOLDS.SIMPLE_DEFINITION_LENGTH) {
+        fastScore += SCORING_WEIGHTS.SIMPLE_DEFINITION_BONUS;
+        reasons.push("simple definition request");
+    }
+    return { fastScore, reasoningScore };
+}
+/**
+ * Calculate final confidence score
+ */
+export function calculateConfidence(fastScore, reasoningScore) {
+    const totalScore = fastScore + reasoningScore;
+    if (totalScore === 0) {
+        return CLASSIFICATION_THRESHOLDS.DEFAULT_CONFIDENCE;
+    }
+    const rawConfidence = Math.max(fastScore, reasoningScore) / totalScore;
+    return Math.max(CLASSIFICATION_THRESHOLDS.MIN_CONFIDENCE, Math.min(CLASSIFICATION_THRESHOLDS.MAX_CONFIDENCE, rawConfidence));
+}
+/**
+ * Determine task type based on scores
+ */
+export function determineTaskType(fastScore, reasoningScore) {
+    return fastScore >= reasoningScore ? "fast" : "reasoning";
+}
+/**
+ * Comprehensive prompt analysis
+ * Runs all analysis functions and returns combined scores
+ */
+export function analyzePrompt(prompt) {
+    const normalizedPrompt = prompt.toLowerCase().trim();
+    const reasons = [];
+    let fastScore = 0;
+    let reasoningScore = 0;
+    // 1. Length analysis
+    const lengthScores = analyzeLengthFactors(prompt, reasons);
+    fastScore += lengthScores.fastScore;
+    reasoningScore += lengthScores.reasoningScore;
+    // 2. Pattern matching
+    fastScore += checkFastPatterns(normalizedPrompt, reasons);
+    reasoningScore += checkReasoningPatterns(normalizedPrompt, reasons);
+    // 3. Keyword analysis
+    const keywordScores = analyzeKeywords(normalizedPrompt, reasons);
+    fastScore += keywordScores.fastScore;
+    reasoningScore += keywordScores.reasoningScore;
+    // 4. Question complexity
+    reasoningScore += analyzeQuestionComplexity(prompt, reasons);
+    // 5. Structure analysis
+    reasoningScore += analyzePromptStructure(prompt, reasons);
+    // 6. Domain analysis
+    const domainScores = analyzeDomainIndicators(normalizedPrompt, prompt, reasons);
+    fastScore += domainScores.fastScore;
+    reasoningScore += domainScores.reasoningScore;
+    return { fastScore, reasoningScore, reasons };
+}

package/dist/client/utils/taskClassifier.js

@@ -0,0 +1,94 @@
+/**
+ * Binary Task Classifier for NeuroLink Orchestration
+ * Classifies tasks as either 'fast' (quick responses) or 'reasoning' (complex analysis)
+ */
+import { logger } from "./logger.js";
+import { CLASSIFICATION_THRESHOLDS } from "../config/taskClassificationConfig.js";
+import { analyzePrompt, calculateConfidence, determineTaskType, } from "./taskClassificationUtils.js";
+import { redactForClassification } from "./promptRedaction.js";
+/**
+ * Binary Task Classifier
+ * Determines if a task requires fast response or deeper reasoning
+ */
+export class BinaryTaskClassifier {
+    /**
+     * Classify a prompt as either fast or reasoning task
+     */
+    static classify(prompt) {
+        const startTime = Date.now();
+        // Analyze the prompt using utility functions
+        const scores = analyzePrompt(prompt);
+        const { fastScore, reasoningScore, reasons } = scores;
+        // Determine final classification
+        const totalScore = fastScore + reasoningScore;
+        let type;
+        let confidence;
+        if (totalScore === 0) {
+            // Default to fast for ambiguous cases
+            type = "fast";
+            confidence = CLASSIFICATION_THRESHOLDS.DEFAULT_CONFIDENCE;
+            reasons.push("default fallback");
+        }
+        else {
+            type = determineTaskType(fastScore, reasoningScore);
+            confidence = calculateConfidence(fastScore, reasoningScore);
+        }
+        const classification = {
+            type,
+            confidence,
+            reasoning: reasons.join(", "),
+        };
+        const classificationTime = Date.now() - startTime;
+        logger.debug("Task classified", {
+            prompt: redactForClassification(prompt),
+            classification: type,
+            confidence: confidence.toFixed(2),
+            fastScore,
+            reasoningScore,
+            reasons: reasons.join(", "),
+            classificationTime: `${classificationTime}ms`,
+        });
+        return classification;
+    }
+    /**
+     * Get classification statistics for multiple prompts
+     */
+    static getClassificationStats(prompts) {
+        // Guard against empty array to prevent divide-by-zero
+        if (prompts.length === 0) {
+            const stats = {
+                total: 0,
+                fast: 0,
+                reasoning: 0,
+                averageConfidence: 0,
+            };
+            logger.debug("Classification stats", stats);
+            return stats;
+        }
+        const classifications = prompts.map((prompt) => this.classify(prompt));
+        const stats = {
+            total: classifications.length,
+            fast: classifications.filter((c) => c.type === "fast").length,
+            reasoning: classifications.filter((c) => c.type === "reasoning").length,
+            averageConfidence: classifications.reduce((sum, c) => sum + c.confidence, 0) /
+                classifications.length,
+        };
+        logger.debug("Classification stats", stats);
+        return stats;
+    }
+    /**
+     * Validate classification accuracy (for testing/tuning)
+     */
+    static validateClassification(prompt, expectedType) {
+        const classification = this.classify(prompt);
+        const correct = classification.type === expectedType;
+        logger.debug("Classification validation", {
+            prompt: redactForClassification(prompt),
+            expected: expectedType,
+            actual: classification.type,
+            correct,
+            confidence: classification.confidence,
+        });
+        return { correct, classification };
+    }
+}

package/dist/client/utils/thinkingConfig.js

@@ -0,0 +1,104 @@
+/**
+ * ThinkingConfig utility functions for constructing thinking configuration objects.
+ *
+ * This module provides helper functions to create thinkingConfig objects consistently
+ * across the codebase, reducing duplication in CLI and providers.
+ */
+/**
+ * Default token budget for thinking operations
+ */
+export const DEFAULT_THINKING_BUDGET_TOKENS = 10000;
+/**
+ * Default thinking level for Gemini 3 models
+ */
+export const DEFAULT_THINKING_LEVEL = "high";
+/**
+ * Creates a thinkingConfig object from CLI-style options.
+ *
+ * This helper consolidates the pattern used in CLI command handlers
+ * to convert simple CLI flags into the full thinkingConfig structure.
+ *
+ * @param options - CLI-style options with thinking, thinkingBudget, thinkingLevel
+ * @returns ThinkingConfig object or undefined if thinking is not enabled
+ *
+ * @example
+ * ```typescript
+ * // From CLI options
+ * const config = createThinkingConfig({
+ *   thinking: true,
+ *   thinkingBudget: 15000,
+ *   thinkingLevel: "high"
+ * });
+ * // Returns: { enabled: true, budgetTokens: 15000, thinkingLevel: "high" }
+ * ```
+ */
+export function createThinkingConfig(options) {
+    // Only create config if thinking is explicitly enabled or thinkingLevel is set
+    if (!options.thinking && !options.thinkingLevel) {
+        return undefined;
+    }
+    return {
+        enabled: true,
+        budgetTokens: options.thinkingBudget ?? DEFAULT_THINKING_BUDGET_TOKENS,
+        thinkingLevel: options.thinkingLevel,
+    };
+}
+/**
+ * Creates a thinkingConfig from record-style options (useful for CLI handlers).
+ *
+ * This handles the type casting that's commonly needed when working with
+ * CLI argument records.
+ *
+ * @param options - Record-style options from CLI argv
+ * @returns ThinkingConfig object or undefined if thinking is not enabled
+ *
+ * @example
+ * ```typescript
+ * const config = createThinkingConfigFromRecord(argv as Record<string, unknown>);
+ * ```
+ */
+export function createThinkingConfigFromRecord(options) {
+    const thinking = options.thinking;
+    const thinkingLevel = options.thinkingLevel;
+    const thinkingBudget = options.thinkingBudget;
+    return createThinkingConfig({
+        thinking,
+        thinkingLevel,
+        thinkingBudget,
+    });
+}
+/**
+ * Creates thinkingConfig for native Gemini SDK (not AI SDK).
+ *
+ * This is used for direct calls to the Gemini SDK where the config
+ * structure is different from the AI SDK providerOptions.
+ *
+ * @param config - The thinkingConfig from options
+ * @returns NativeThinkingConfig object or undefined
+ *
+ * @example
+ * ```typescript
+ * const nativeConfig = createNativeThinkingConfig(options.thinkingConfig);
+ * if (nativeConfig) {
+ *   sdkConfig.thinkingConfig = nativeConfig;
+ * }
+ * ```
+ */
+export function createNativeThinkingConfig(config) {
+    if (!config?.enabled && !config?.thinkingLevel) {
+        return undefined;
+    }
+    return {
+        includeThoughts: true,
+        thinkingLevel: config.thinkingLevel ?? DEFAULT_THINKING_LEVEL,
+    };
+}
+/**
+ * Checks if thinkingConfig should be applied based on options.
+ *
+ * @param config - The thinkingConfig from options
+ * @returns true if thinking should be enabled
+ */
+export function shouldEnableThinking(config) {
+    return Boolean(config?.enabled || config?.thinkingLevel);
+}