@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/context/toolOutputLimits.js

@@ -1,95 +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;
-/**
- * True when `generateToolOutputPreview` would actually shrink this output.
- *
- * Callers gate on this before paying for a preview. It exists so the gate and
- * the generator can never disagree: the budget is expressed in BYTES, and
- * testing it against `String.length` (UTF-16 code units) under-reports every
- * multibyte payload — CJK or emoji tool output would be judged small enough to
- * leave alone while the generator would have truncated it. Line count matters
- * for the same reason: a short-but-tall output exceeds `maxLines` alone.
- */
-export function exceedsToolOutputPreviewBudget(output, options) {
-    const maxBytes = options?.maxBytes ?? DEFAULT_MAX_PREVIEW_BYTES;
-    const maxLines = options?.maxLines ?? DEFAULT_MAX_PREVIEW_LINES;
-    return (Buffer.byteLength(output, "utf-8") > maxBytes ||
-        output.split("\n").length > maxLines);
-}
-/**
- * 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,
-    };
-}
-//# sourceMappingURL=toolOutputLimits.js.map

package/dist/lib/context/toolPairRepair.d.ts

@@ -1,43 +0,0 @@
-/**
- * Tool Use/Result Pair Repair
- *
- * After compaction (or a pointer-based history slice) the message array can
- * contain a `tool_call` whose `tool_result` was dropped, or a `tool_result`
- * whose `tool_call` was dropped. Providers reject both, so orphans are filled
- * with synthetic placeholders.
- *
- * Pairing is BATCH- and ID-aware, not adjacency-based. A single agent step
- * with parallel tool calls is persisted as every `tool_call` followed by every
- * `tool_result` (see flushPendingToolData), so `tool_call` is routinely
- * followed by another `tool_call` in perfectly healthy history. Matching on
- * adjacency treats that as an orphan and injects a bogus "result unavailable"
- * over a result that is present a few entries later.
- *
- * Two modes, chosen per batch:
- *   - ID mode      — `toolCallId` present: pair by id, order-independent.
- *   - legacy mode  — sessions written before `toolCallId` existed: pair
- *                    positionally WITHIN the batch (call[i] ↔ result[i]).
- */
-import type { ChatMessage, RepairResult } from "../types/index.js";
-/**
- * Move a summarize/keep split so it never falls INSIDE a tool batch.
- *
- * `splitIndex` means "messages[0..splitIndex) get summarized" — so the summary
- * pointer lands on messages[splitIndex - 1]. Landing mid-batch leaves the
- * recent window starting on an orphaned `tool_result`, which providers reject.
- *
- * Preferred direction is BACKWARD (summarize less, keep the whole batch in the
- * recent window) since that never loses detail. When the batch starts at index
- * 0 there is nothing left to summarize, so the split moves forward past the
- * batch instead — the caller's "at least one message summarized" invariant
- * wins over keeping the batch recent.
- */
-export declare function snapSplitToBatchBoundary(messages: ChatMessage[], splitIndex: number): number;
-/**
- * Repair orphaned tool_call/tool_result pairs in a message array.
- *
- * Guarantees on return: every `tool_call` is followed (within its batch) by
- * exactly one `tool_result`, and no `tool_result` precedes its `tool_call`.
- * A healthy batch — including a parallel one — is returned untouched.
- */
-export declare function repairToolPairs(messages: ChatMessage[]): RepairResult;

package/dist/lib/context/toolPairRepair.js

@@ -1,242 +0,0 @@
-/**
- * Tool Use/Result Pair Repair
- *
- * After compaction (or a pointer-based history slice) the message array can
- * contain a `tool_call` whose `tool_result` was dropped, or a `tool_result`
- * whose `tool_call` was dropped. Providers reject both, so orphans are filled
- * with synthetic placeholders.
- *
- * Pairing is BATCH- and ID-aware, not adjacency-based. A single agent step
- * with parallel tool calls is persisted as every `tool_call` followed by every
- * `tool_result` (see flushPendingToolData), so `tool_call` is routinely
- * followed by another `tool_call` in perfectly healthy history. Matching on
- * adjacency treats that as an orphan and injects a bogus "result unavailable"
- * over a result that is present a few entries later.
- *
- * Two modes, chosen per batch:
- *   - ID mode      — `toolCallId` present: pair by id, order-independent.
- *   - legacy mode  — sessions written before `toolCallId` existed: pair
- *                    positionally WITHIN the batch (call[i] ↔ result[i]).
- */
-import { randomUUID } from "crypto";
-const MISSING_RESULT_CONTENT = "[Tool result unavailable - conversation was compacted]";
-/**
- * Collect the tool batch starting at `start` (which must index a tool-role
- * message). Consumes the maximal run of calls followed by the maximal run of
- * results. A leading run of results with no calls (head-cut orphan) yields a
- * batch with an empty `calls` array.
- */
-function collectBatch(messages, start) {
-    let i = start;
-    const calls = [];
-    const results = [];
-    while (i < messages.length && messages[i].role === "tool_call") {
-        calls.push(messages[i]);
-        i++;
-    }
-    while (i < messages.length && messages[i].role === "tool_result") {
-        results.push(messages[i]);
-        i++;
-    }
-    return { calls, results, endIndex: i };
-}
-/** Synthetic `tool_result` standing in for a call whose result was dropped. */
-function syntheticResult(call) {
-    return {
-        id: `repair-result-${randomUUID()}`,
-        role: "tool_result",
-        content: MISSING_RESULT_CONTENT,
-        tool: call.tool,
-        ...(call.toolCallId ? { toolCallId: call.toolCallId } : {}),
-        timestamp: call.timestamp,
-        metadata: { truncated: true },
-    };
-}
-/** Synthetic `tool_call` standing in for a result whose call was dropped. */
-function syntheticCall(result) {
-    return {
-        id: `repair-call-${randomUUID()}`,
-        role: "tool_call",
-        content: `[Tool call for ${result.tool || "unknown"} - conversation was compacted]`,
-        tool: result.tool,
-        ...(result.toolCallId ? { toolCallId: result.toolCallId } : {}),
-        timestamp: result.timestamp,
-        metadata: { truncated: true },
-    };
-}
-/**
- * Repair one batch, emitting calls then results with every call matched to
- * exactly one result. Returns the rebuilt run plus how many placeholders of
- * each kind were needed.
- */
-function repairBatch(batch) {
-    const { calls, results } = batch;
-    // ID mode requires ids on BOTH sides; a partially-migrated batch (some
-    // entries written before toolCallId existed) falls back to legacy pairing
-    // rather than treating the id-less half as universally orphaned.
-    const useIds = calls.length > 0 &&
-        results.length > 0 &&
-        calls.every((m) => !!m.toolCallId) &&
-        results.every((m) => !!m.toolCallId);
-    const outCalls = [...calls];
-    const outResults = [];
-    let orphanedCallsFixed = 0;
-    let orphanedResultsFixed = 0;
-    let changed = false;
-    if (useIds) {
-        // Duplicate ids (a retry that re-emitted a result) keep the FIRST result;
-        // later duplicates are dropped so a call never gains a second result.
-        const resultById = new Map();
-        for (const result of results) {
-            const key = result.toolCallId;
-            if (!resultById.has(key)) {
-                resultById.set(key, result);
-            }
-            else {
-                changed = true;
-            }
-        }
-        for (const call of calls) {
-            const key = call.toolCallId;
-            const match = resultById.get(key);
-            if (match) {
-                outResults.push(match);
-                resultById.delete(key);
-            }
-            else {
-                outResults.push(syntheticResult(call));
-                orphanedCallsFixed++;
-            }
-        }
-        // Results with no surviving call — the compactor cut the head of the batch.
-        for (const leftover of resultById.values()) {
-            outCalls.push(syntheticCall(leftover));
-            outResults.push(leftover);
-            orphanedResultsFixed++;
-        }
-    }
-    else {
-        // Legacy positional pairing, scoped to the batch.
-        const paired = Math.min(calls.length, results.length);
-        for (let i = 0; i < paired; i++) {
-            outResults.push(results[i]);
-        }
-        for (let i = paired; i < calls.length; i++) {
-            outResults.push(syntheticResult(calls[i]));
-            orphanedCallsFixed++;
-        }
-        for (let i = paired; i < results.length; i++) {
-            outCalls.push(syntheticCall(results[i]));
-            outResults.push(results[i]);
-            orphanedResultsFixed++;
-        }
-    }
-    return {
-        messages: [...outCalls, ...outResults],
-        orphanedCallsFixed,
-        orphanedResultsFixed,
-        changed,
-    };
-}
-/** True for the two roles that make up a tool batch. */
-function isToolRole(msg) {
-    return msg?.role === "tool_call" || msg?.role === "tool_result";
-}
-/**
- * True when a split at `index` would cut a single batch in half.
- *
- * A batch is calls-then-results, so a `tool_result` FOLLOWED BY a `tool_call`
- * is the boundary BETWEEN two batches — a legal place to split. Treating every
- * adjacent pair of tool messages as "inside a batch" would fuse a whole
- * `call,result,call,result,…` history into one indivisible run, and the walks
- * below would then skip past all of it.
- */
-function cutsBatch(messages, index) {
-    const before = messages[index - 1];
-    const after = messages[index];
-    if (!isToolRole(before) || !isToolRole(after)) {
-        return false;
-    }
-    return !(before?.role === "tool_result" && after?.role === "tool_call");
-}
-/**
- * Move a summarize/keep split so it never falls INSIDE a tool batch.
- *
- * `splitIndex` means "messages[0..splitIndex) get summarized" — so the summary
- * pointer lands on messages[splitIndex - 1]. Landing mid-batch leaves the
- * recent window starting on an orphaned `tool_result`, which providers reject.
- *
- * Preferred direction is BACKWARD (summarize less, keep the whole batch in the
- * recent window) since that never loses detail. When the batch starts at index
- * 0 there is nothing left to summarize, so the split moves forward past the
- * batch instead — the caller's "at least one message summarized" invariant
- * wins over keeping the batch recent.
- */
-export function snapSplitToBatchBoundary(messages, splitIndex) {
-    if (splitIndex <= 0 || splitIndex >= messages.length) {
-        return splitIndex;
-    }
-    if (!cutsBatch(messages, splitIndex)) {
-        return splitIndex;
-    }
-    let start = splitIndex;
-    while (start > 0 && cutsBatch(messages, start)) {
-        start--;
-    }
-    if (start > 0) {
-        return start;
-    }
-    let end = splitIndex;
-    while (end < messages.length && cutsBatch(messages, end)) {
-        end++;
-    }
-    return end;
-}
-/**
- * Repair orphaned tool_call/tool_result pairs in a message array.
- *
- * Guarantees on return: every `tool_call` is followed (within its batch) by
- * exactly one `tool_result`, and no `tool_result` precedes its `tool_call`.
- * A healthy batch — including a parallel one — is returned untouched.
- */
-export function repairToolPairs(messages) {
-    // Fast path: nothing tool-shaped to repair. Keeps the read-path cost at one
-    // linear scan for the overwhelmingly common text-only conversation.
-    const hasToolMessage = messages.some((msg) => msg.role === "tool_call" || msg.role === "tool_result");
-    if (!hasToolMessage) {
-        return {
-            repaired: false,
-            messages,
-            orphanedCallsFixed: 0,
-            orphanedResultsFixed: 0,
-        };
-    }
-    const result = [];
-    let orphanedCallsFixed = 0;
-    let orphanedResultsFixed = 0;
-    let changed = false;
-    let i = 0;
-    while (i < messages.length) {
-        const msg = messages[i];
-        if (msg.role !== "tool_call" && msg.role !== "tool_result") {
-            result.push(msg);
-            i++;
-            continue;
-        }
-        const batch = collectBatch(messages, i);
-        const repaired = repairBatch(batch);
-        result.push(...repaired.messages);
-        orphanedCallsFixed += repaired.orphanedCallsFixed;
-        orphanedResultsFixed += repaired.orphanedResultsFixed;
-        changed = changed || repaired.changed;
-        i = batch.endIndex;
-    }
-    const repaired = orphanedCallsFixed > 0 || orphanedResultsFixed > 0 || changed;
-    return {
-        repaired,
-        messages: repaired ? result : messages,
-        orphanedCallsFixed,
-        orphanedResultsFixed,
-    };
-}
-//# sourceMappingURL=toolPairRepair.js.map

package/dist/lib/core/analytics.d.ts

@@ -1,11 +0,0 @@
-/**
- * NeuroLink Analytics System
- *
- * Provides lightweight analytics tracking for AI provider usage,
- * including tokens, costs, performance metrics, and custom context.
- */
-import type { AnalyticsData } from "../types/index.js";
-/**
- * Create analytics data structure from AI response
- */
-export declare function createAnalytics(provider: string, model: string, result: unknown, responseTime: number, context?: Record<string, unknown>): AnalyticsData;

package/dist/lib/core/analytics.js

@@ -1,117 +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);
-        // Turn-lifecycle telemetry from native agentic loops (Vertex
-        // Gemini/Claude): stopReason / rawFinishReason / stepsUsed ride the
-        // provider result; toolCallCount and elapsedMs derive from it.
-        const turnResult = result;
-        const toolCallCount = Array.isArray(turnResult.toolExecutions)
-            ? turnResult.toolExecutions.length
-            : Array.isArray(turnResult.toolsUsed)
-                ? turnResult.toolsUsed.length
-                : undefined;
-        const analytics = {
-            provider,
-            model,
-            tokenUsage: tokens,
-            cost,
-            requestDuration: responseTime,
-            context: context,
-            timestamp: new Date().toISOString(),
-            ...(typeof turnResult.stepsUsed === "number" && {
-                stepsUsed: turnResult.stepsUsed,
-            }),
-            ...(toolCallCount !== undefined && { toolCallCount }),
-            ...(typeof turnResult.stopReason === "string" && {
-                stopReason: turnResult.stopReason,
-            }),
-            ...(typeof turnResult.responseTime === "number" && {
-                elapsedMs: turnResult.responseTime,
-            }),
-            ...(typeof turnResult.rawFinishReason === "string" && {
-                rawFinishReason: turnResult.rawFinishReason,
-            }),
-        };
-        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).
-        // costInfo has no cache tiers, so cache tokens are billed at the input
-        // rate — the pre-split total a cache-blind provider would report, never $0.
-        const inputCost = ((tokens.input +
-            (tokens.cacheReadTokens ?? 0) +
-            (tokens.cacheCreationTokens ?? 0)) /
-            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;
-    }
-}
-//# sourceMappingURL=analytics.js.map