@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/utils/schemaConversion.js

@@ -1,255 +0,0 @@
-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

@@ -1,149 +0,0 @@
-/**
- * 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

@@ -1,94 +0,0 @@
-/**
- * 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

@@ -1,104 +0,0 @@
-/**
- * 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);
-}