@juspay/neurolink 9.30.0 → 9.31.1

package/dist/client/context/toolOutputLimits.js

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

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

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