@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/context/toolOutputLimits.js

@@ -1,78 +0,0 @@
-/**
- * Tool output preview generation.
- * Generates head/tail previews of large tool outputs for context-efficient LLM calls.
- * @module
- */
-/** Default maximum preview size in bytes (50KB) */
-export const DEFAULT_MAX_PREVIEW_BYTES = 50 * 1024;
-/** Default maximum preview lines */
-export const DEFAULT_MAX_PREVIEW_LINES = 2_000;
-/** Default head ratio (25% of preview budget) */
-export const DEFAULT_HEAD_RATIO = 0.25;
-/** Tool name referenced in truncation notices for on-demand full-output access */
-export const RETRIEVE_CONTEXT_TOOL_NAME = "retrieve_context";
-/** Default tail ratio (75% of preview budget) */
-export const DEFAULT_TAIL_RATIO = 0.75;
-/**
- * Generate a head/tail preview of a tool output string.
- * If the output is within limits, returns it unchanged with truncated: false.
- * If over limits, keeps the first 25% and last 75% with an omission notice.
- *
- * Industry pattern: 25/75 head/tail split. Head captures schema/headers/structure,
- * tail captures the most recent and typically most relevant data.
- */
-export function generateToolOutputPreview(output, options) {
-    const maxBytes = options?.maxBytes ?? DEFAULT_MAX_PREVIEW_BYTES;
-    const maxLines = options?.maxLines ?? DEFAULT_MAX_PREVIEW_LINES;
-    const rawHeadRatio = options?.headRatio ?? DEFAULT_HEAD_RATIO;
-    const rawTailRatio = options?.tailRatio ?? DEFAULT_TAIL_RATIO;
-    // Clamp ratios to valid range to avoid negative omittedBytes
-    const headRatio = Math.max(0, Math.min(1, rawHeadRatio));
-    const tailRatio = Math.max(0, Math.min(1, rawTailRatio));
-    const originalSize = Buffer.byteLength(output, "utf-8");
-    const lines = output.split("\n");
-    const exceedsBytes = originalSize > maxBytes;
-    const exceedsLines = lines.length > maxLines;
-    if (!exceedsBytes && !exceedsLines) {
-        return { preview: output, truncated: false, originalSize };
-    }
-    // Line-based split
-    const headLineCount = Math.max(1, Math.floor(maxLines * headRatio));
-    const tailLineCount = Math.max(1, maxLines - headLineCount);
-    let head;
-    let tail;
-    if (exceedsLines) {
-        head = lines.slice(0, headLineCount).join("\n");
-        tail = lines.slice(-tailLineCount).join("\n");
-    }
-    else {
-        head = lines
-            .slice(0, Math.max(1, Math.floor(lines.length * headRatio)))
-            .join("\n");
-        tail = lines
-            .slice(-Math.max(1, Math.ceil(lines.length * tailRatio)))
-            .join("\n");
-    }
-    // Byte-based cap on each portion
-    const headMaxBytes = Math.floor(maxBytes * headRatio);
-    const tailMaxBytes = maxBytes - headMaxBytes;
-    if (Buffer.byteLength(head, "utf-8") > headMaxBytes) {
-        head = Buffer.from(head, "utf-8")
-            .subarray(0, headMaxBytes)
-            .toString("utf-8");
-    }
-    if (Buffer.byteLength(tail, "utf-8") > tailMaxBytes) {
-        const tailBuf = Buffer.from(tail, "utf-8");
-        tail = tailBuf.subarray(tailBuf.length - tailMaxBytes).toString("utf-8");
-    }
-    const omittedBytes = Math.max(0, originalSize -
-        Buffer.byteLength(head, "utf-8") -
-        Buffer.byteLength(tail, "utf-8"));
-    const notice = `\n\n[... ${omittedBytes} bytes omitted. ` +
-        `Use ${RETRIEVE_CONTEXT_TOOL_NAME} tool to access full output ...]\n\n`;
-    return {
-        preview: head + notice + tail,
-        truncated: true,
-        originalSize,
-    };
-}

package/dist/client/context/toolPairRepair.js

@@ -1,66 +0,0 @@
-/**
- * Tool Use/Result Pair Repair
- *
- * After compaction, validates that every tool_use (tool_call) has a
- * corresponding tool_result and vice versa. Inserts synthetic
- * placeholders for orphaned entries.
- */
-import { randomUUID } from "crypto";
-/**
- * Repair orphaned tool_use/tool_result pairs in a message array.
- *
- * Ensures every tool_call has a following tool_result and vice versa.
- */
-export function repairToolPairs(messages) {
-    const result = [];
-    let orphanedCallsFixed = 0;
-    let orphanedResultsFixed = 0;
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        const nextMsg = i + 1 < messages.length ? messages[i + 1] : undefined;
-        if (msg.role === "tool_call") {
-            result.push(msg);
-            // Check if next message is the corresponding tool_result
-            if (!nextMsg || nextMsg.role !== "tool_result") {
-                // Insert synthetic tool_result
-                result.push({
-                    id: `repair-result-${randomUUID()}`,
-                    role: "tool_result",
-                    content: "[Tool result unavailable - conversation was compacted]",
-                    tool: msg.tool,
-                    timestamp: msg.timestamp,
-                    metadata: { truncated: true },
-                });
-                orphanedCallsFixed++;
-            }
-        }
-        else if (msg.role === "tool_result") {
-            // Check if previous message was the corresponding tool_call
-            const prevMsg = result.length > 0 ? result[result.length - 1] : undefined;
-            if (!prevMsg ||
-                (prevMsg.role !== "tool_call" && prevMsg.role !== "tool_result")) {
-                // Insert synthetic tool_call before this result
-                result.push({
-                    id: `repair-call-${randomUUID()}`,
-                    role: "tool_call",
-                    content: `[Tool call for ${msg.tool || "unknown"} - conversation was compacted]`,
-                    tool: msg.tool,
-                    timestamp: msg.timestamp,
-                    metadata: { truncated: true },
-                });
-                orphanedResultsFixed++;
-            }
-            result.push(msg);
-        }
-        else {
-            result.push(msg);
-        }
-    }
-    const repaired = orphanedCallsFixed > 0 || orphanedResultsFixed > 0;
-    return {
-        repaired,
-        messages: repaired ? result : messages,
-        orphanedCallsFixed,
-        orphanedResultsFixed,
-    };
-}

package/dist/client/core/analytics.js

@@ -1,88 +0,0 @@
-/**
- * NeuroLink Analytics System
- *
- * Provides lightweight analytics tracking for AI provider usage,
- * including tokens, costs, performance metrics, and custom context.
- */
-import { logger } from "../utils/logger.js";
-import { modelConfig } from "./modelConfiguration.js";
-import { extractTokenUsage as extractTokenUsageUtil } from "../utils/tokenUtils.js";
-import { calculateCost, hasPricing } from "../utils/pricing.js";
-/**
- * Create analytics data structure from AI response
- */
-export function createAnalytics(provider, model, result, responseTime, context) {
-    const functionTag = "createAnalytics";
-    try {
-        // Extract token usage from different result formats
-        const tokens = extractTokenUsage(result);
-        // Estimate cost based on provider and tokens
-        const cost = estimateCost(provider, model, tokens);
-        const analytics = {
-            provider,
-            model,
-            tokenUsage: tokens,
-            cost,
-            requestDuration: responseTime,
-            context: context,
-            timestamp: new Date().toISOString(),
-        };
-        logger.debug(`[${functionTag}] Analytics created`, {
-            provider,
-            model,
-            tokens: tokens.total,
-            responseTime,
-            cost,
-        });
-        return analytics;
-    }
-    catch (error) {
-        logger.error(`[${functionTag}] Failed to create analytics`, { error });
-        // Return minimal analytics on error
-        return {
-            provider,
-            model,
-            tokenUsage: { input: 0, output: 0, total: 0 },
-            requestDuration: responseTime,
-            context: context,
-            timestamp: new Date().toISOString(),
-        };
-    }
-}
-/**
- * Extract token usage from various AI result formats
- * Delegates to centralized tokenUtils for consistent extraction across providers
- */
-function extractTokenUsage(result) {
-    // Use centralized token extraction utility
-    // The utility handles nested usage objects, multiple provider formats,
-    // cache tokens, reasoning tokens, and cache savings calculation
-    // Cast result to allow extractTokenUsageUtil to handle type normalization
-    return extractTokenUsageUtil(result.usage);
-}
-/**
- * Estimate cost based on provider, model, and token usage.
- * Uses the per-model pricing table first (which includes cache token rates),
- * then falls back to the provider-level configuration system.
- */
-function estimateCost(provider, model, tokens) {
-    try {
-        // Try the per-model pricing table first (includes cache token rates)
-        if (hasPricing(provider, model)) {
-            return calculateCost(provider, model, tokens);
-        }
-        // Fall back to the configuration system for providers/models not in the pricing table
-        const costInfo = modelConfig.getCostInfo(provider.toLowerCase(), model);
-        if (!costInfo) {
-            return undefined;
-        }
-        // Calculate cost using the configuration system (per-1K-token rates)
-        const inputCost = (tokens.input / 1000) * costInfo.input;
-        const outputCost = (tokens.output / 1000) * costInfo.output;
-        return Math.round((inputCost + outputCost) * 1_000_000) / 1_000_000; // Round to 6 decimal places
-    }
-    catch (error) {
-        logger.debug("Cost estimation failed", { provider, model, error });
-        return undefined;
-    }
-}