@juspay/neurolink 9.42.0 → 9.43.0

package/dist/lib/tasks/taskManager.js

@@ -158,7 +158,28 @@ export class TaskManager {
             await backend.schedule(task, (t) => this.onTaskTick(t));
         }
         catch (err) {
-            await store.delete(task.id);
+            this.callbacks.delete(task.id);
+            try {
+                await store.delete(task.id);
+            }
+            catch (cleanupError) {
+                // Deletion failed — task remains persisted as active. Attempt to mark it
+                // failed so it reaches a terminal state and operators can identify it.
+                logger.error("[TaskManager] Failed to clean up task after schedule error — task may remain persisted as active", {
+                    taskId: task.id,
+                    scheduleError: String(err),
+                    cleanupError: String(cleanupError),
+                });
+                try {
+                    await store.update(task.id, { status: "failed" });
+                }
+                catch (terminalError) {
+                    logger.error("[TaskManager] Failed to force task to terminal state — manual cleanup required", {
+                        taskId: task.id,
+                        error: String(terminalError),
+                    });
+                }
+            }
             throw err;
         }
         this.emit("task:created", task);
@@ -209,6 +230,7 @@ export class TaskManager {
                 taskUpdates[field] = updates[field];
             }
         }
+        const shouldClearHistory = updates.mode !== undefined && updates.mode !== "continuation";
         // Special-case: mode changes require sessionId handling
         if (updates.mode !== undefined) {
             if (updates.mode === "continuation" && !existing.sessionId) {
@@ -216,14 +238,39 @@ export class TaskManager {
             }
             else if (updates.mode !== "continuation") {
                 taskUpdates.sessionId = undefined;
-                await store.clearHistory(taskId);
             }
         }
         const updated = await store.update(taskId, taskUpdates);
         // Re-schedule if schedule changed and task is active
         if (updates.schedule && updated.status === "active") {
+            const attemptedSchedule = updated.schedule;
             await backend.cancel(taskId);
-            await backend.schedule(updated, (t) => this.onTaskTick(t));
+            try {
+                await backend.schedule(updated, (t) => this.onTaskTick(t));
+            }
+            catch (error) {
+                await this.restoreScheduledTask(existing, "update schedule rollback");
+                await this.rollbackTaskUpdate(taskId, existing, error);
+                throw TaskError.create("SCHEDULE_FAILED", `Failed to update schedule for task ${taskId}`, {
+                    cause: error instanceof Error ? error : undefined,
+                    details: {
+                        taskId,
+                        previousSchedule: existing.schedule,
+                        attemptedSchedule,
+                    },
+                });
+            }
+        }
+        if (shouldClearHistory) {
+            try {
+                await store.clearHistory(taskId);
+            }
+            catch (error) {
+                logger.warn("[TaskManager] Failed to clear task history after mode update", {
+                    taskId,
+                    error: String(error),
+                });
+            }
         }
         return updated;
     }
@@ -248,7 +295,14 @@ export class TaskManager {
             throw TaskError.create("INVALID_TASK_STATUS", `Cannot pause task with status: ${task.status}`);
         }
         await backend.pause(taskId);
-        const updated = await store.update(taskId, { status: "paused" });
+        let updated;
+        try {
+            updated = await store.update(taskId, { status: "paused" });
+        }
+        catch (error) {
+            await this.restoreScheduledTask(task, "pause rollback");
+            throw error;
+        }
         this.emit("task:paused", updated);
         return updated;
     }
@@ -264,7 +318,16 @@ export class TaskManager {
             throw TaskError.create("INVALID_TASK_STATUS", `Cannot resume task with status: ${task.status}`);
         }
         const updated = await store.update(taskId, { status: "active" });
-        await backend.schedule(updated, (t) => this.onTaskTick(t));
+        try {
+            await backend.schedule(updated, (t) => this.onTaskTick(t));
+        }
+        catch (error) {
+            await this.rollbackTaskUpdate(taskId, task, error);
+            throw TaskError.create("SCHEDULE_FAILED", `Failed to resume task ${taskId}`, {
+                cause: error instanceof Error ? error : undefined,
+                details: { taskId, schedule: task.schedule },
+            });
+        }
         this.emit("task:resumed", updated);
         return updated;
     }
@@ -301,6 +364,38 @@ export class TaskManager {
         return this.backend.isHealthy();
     }
     // ── Internal ──────────────────────────────────────────
+    async restoreScheduledTask(task, reason) {
+        if (task.status !== "active") {
+            return;
+        }
+        try {
+            await this.getBackend().schedule(task, (t) => this.onTaskTick(t));
+            logger.warn("[TaskManager] Restored task schedule after rollback", {
+                taskId: task.id,
+                reason,
+            });
+        }
+        catch (restoreError) {
+            logger.error("[TaskManager] Failed to restore task schedule during rollback", {
+                taskId: task.id,
+                reason,
+                error: String(restoreError),
+            });
+        }
+    }
+    async rollbackTaskUpdate(taskId, previousTask, error) {
+        try {
+            return await this.getStore().update(taskId, previousTask);
+        }
+        catch (rollbackError) {
+            logger.error("[TaskManager] Failed to roll back task update — store and in-memory state may be diverged; manual reconciliation required", {
+                taskId,
+                originalError: String(error),
+                rollbackError: String(rollbackError),
+            });
+            throw rollbackError;
+        }
+    }
     /**
      * Called by the backend on each scheduled tick.
      * Executes the task, updates state, fires callbacks/events.

package/dist/lib/telemetry/telemetryService.js

@@ -54,13 +54,17 @@ export class TelemetryService {
             if (!provider) {
                 return false;
             }
-            const delegateName = provider._delegate?.constructor?.name || "";
-            if (delegateName && delegateName !== "NoopTracerProvider") {
+            const providerName = provider.constructor?.name || "";
+            if (providerName &&
+                providerName !== "ProxyTracerProvider" &&
+                providerName !== "NoopTracerProvider") {
                 return true;
             }
-            const providerName = provider.constructor?.name || "";
-            return (providerName !== "ProxyTracerProvider" &&
-                providerName !== "NoopTracerProvider");
+            const delegate = typeof provider.getDelegate === "function"
+                ? provider.getDelegate()
+                : provider._delegate;
+            const delegateName = delegate?.constructor?.name || "";
+            return Boolean(delegateName && delegateName !== "NoopTracerProvider");
         }
         catch (error) {
             logger.warn("[Telemetry] Failed checking for external TracerProvider", {

package/dist/lib/types/cli.d.ts

@@ -798,6 +798,10 @@ export type ProxyState = {
     host: string;
     strategy: string;
     startTime: string;
+    ready?: boolean;
+    readyAt?: string;
+    healthPath?: string;
+    statusPath?: string;
     envFile?: string;
     /** Fallback chain from proxy config (persisted at start time) */
     fallbackChain?: FallbackInfo[];

package/dist/lib/types/proxyTypes.d.ts

@@ -13,6 +13,8 @@
  * - src/lib/proxy/accountQuota.ts (quota type)
  * - src/lib/server/routes/claudeProxyRoutes.ts (runtime state, deps)
  */
+import type { Span } from "@opentelemetry/api";
+import type { ProxyTracer } from "../proxy/proxyTracer.js";
 /**
  * Type describing the ModelRouter contract.
  * Defined here to avoid a circular dependency between types and implementation.
@@ -242,7 +244,7 @@ export type ParsedClaudeRequest = {
     /** Tools translated to AI SDK-compatible shape for provider fallback. */
     tools: Record<string, {
         description?: string;
-        inputSchema?: unknown;
+        inputSchema: unknown;
         execute?: (...args: unknown[]) => unknown;
     }>;
     /**
@@ -361,6 +363,14 @@ export type TlsFingerprintOptions = {
     /** Whether the stub should log a warning that it is a no-op. */
     warnOnUse?: boolean;
 };
+/**
+ * Proxy operating mode:
+ * - "full"        — managed accounts, retry, rotation, polyfill (default)
+ * - "passthrough" — no polyfill/retry/rotation, but body is still parsed and re-serialized
+ * - "transparent" — zero-mutation byte relay: raw body forwarded as-is, minimal header filtering,
+ *                   SSE interceptor for cache metrics only (bytes pass through unmodified)
+ */
+export type ProxyMode = "full" | "passthrough" | "transparent";
 export type RouteResult = {
     provider: string | null;
     model: string;
@@ -453,6 +463,121 @@ export type RequestAttemptLogEntry = {
     /** OTel span ID for correlation with distributed traces */
     spanId?: string;
 };
+export type ProxyBodyCaptureInput = {
+    phase: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    bodySize?: number;
+    contentType?: string;
+    responseStatus?: number;
+    durationMs?: number;
+    account?: string;
+    accountType?: string;
+    attempt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type ProxyBodyCaptureLogger = (capture: ProxyBodyCaptureInput) => void;
+export type ClaudeFinalRequestLogger = (status: number, accountLabel: string, accountType: string, errorType?: string, errorMessage?: string, extra?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+}) => void;
+export type ClaudeLoggedErrorBuilder = (status: number, message: string, errorType?: string, extra?: {
+    account?: string;
+    accountType?: string;
+    attempt?: number;
+}) => ClaudeErrorResponse;
+export type ClaudeRequestRuntimeContext = {
+    tracer?: ProxyTracer;
+    requestStartTime: number;
+    logProxyBody: ProxyBodyCaptureLogger;
+    logFinalRequest: ClaudeFinalRequestLogger;
+    buildLoggedClaudeError: ClaudeLoggedErrorBuilder;
+};
+export type AnthropicAttemptLogger = (status: number, errorType?: string, errorMessage?: string, extra?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+}) => void;
+export type AnthropicLoopState = {
+    lastError: unknown;
+    sawRateLimit: boolean;
+    sawNetworkError: boolean;
+    sawTransientFailure: boolean;
+    invalidRequestFailure: {
+        status: number;
+        body: string;
+        contentType?: string;
+    } | null;
+    authFailureMessage: string | null;
+    attemptNumber: number;
+};
+export type AnthropicUpstreamBody = {
+    bodyStr: string;
+    sessionId?: string;
+};
+export type AnthropicUpstreamBodyBuilder = (token: string) => AnthropicUpstreamBody;
+export type LoadedClaudeAccountContext = {
+    accounts: ProxyPassthroughAccount[];
+    enabledAccounts: ProxyPassthroughAccount[];
+    orderedAccounts: ProxyPassthroughAccount[];
+    bodyStr: string;
+    requestStart: number;
+    toolCount: number;
+    url: string;
+    clientHeaders: Record<string, string | undefined>;
+    isClaudeClientRequest: boolean;
+};
+export type AnthropicSuccessResult = {
+    retryNextAccount: true;
+} | {
+    response: Response | unknown;
+};
+export type AnthropicAuthRetryResult = {
+    response?: Response | unknown;
+    continueLoop: boolean;
+    lastError: unknown;
+    authFailureMessage: string | null;
+    sawRateLimit: boolean;
+    sawTransientFailure: boolean;
+    sawNetworkError: boolean;
+    upstreamSpan?: Span;
+};
+export type AnthropicNonOkResult = {
+    response?: Response | unknown;
+    continueLoop: boolean;
+    retrySameAccount?: boolean;
+    lastError: unknown;
+    authFailureMessage: string | null;
+    sawTransientFailure: boolean;
+    invalidRequestFailure: {
+        status: number;
+        body: string;
+        contentType?: string;
+    } | null;
+    upstreamSpan?: Span;
+};
+export type PreparedAnthropicAccountAttempt = {
+    continueLoop: boolean;
+    lastError: unknown;
+    authFailureMessage: string | null;
+    headers?: Record<string, string>;
+    buildUpstreamBody?: AnthropicUpstreamBodyBuilder;
+    finalBodyStr?: string;
+    fetchStartMs?: number;
+    upstreamSpan?: Span;
+};
+export type AnthropicUpstreamFetchResult = {
+    continueLoop: boolean;
+    retrySameAccount?: boolean;
+    response?: Response;
+    lastError: unknown;
+    sawRateLimit: boolean;
+    sawNetworkError: boolean;
+    upstreamSpan?: Span;
+};
 export type AccountStats = {
     label: string;
     type: string;
@@ -516,6 +641,10 @@ export type RuntimeAccountState = {
     backoffLevel: number;
     consecutiveRefreshFailures: number;
     permanentlyDisabled: boolean;
+    requestClassCooldowns?: Record<string, number>;
+    modelTierCooldowns?: Record<string, number>;
+    requestClassBackoffLevels?: Record<string, number>;
+    modelTierBackoffLevels?: Record<string, number>;
     lastToken?: string;
     lastRefreshToken?: string;
 };
@@ -566,3 +695,84 @@ export type CachedSession = {
     userId: string;
     expiresAt: number;
 };
+/** Model tier classification for proxy routing decisions. */
+export type ClaudeProxyModelTier = "opus" | "sonnet" | "haiku" | "other";
+/** Request class for proxy routing policy. */
+export type ClaudeProxyRequestClass = "multimodal" | "high-tool-count-non-stream-structured" | "strong-tool-fidelity" | "streaming-conversational" | "standard";
+/** Full classification profile for a proxy request. */
+export type ClaudeProxyRequestProfile = {
+    requestedModel: string;
+    modelTier: ClaudeProxyModelTier;
+    primaryClass: ClaudeProxyRequestClass;
+    classes: ClaudeProxyRequestClass[];
+    stream: boolean;
+    toolCount: number;
+    hasImages: boolean;
+    hasThinking: boolean;
+    hasToolHistory: boolean;
+    requiresToolUse: boolean;
+    requiresSpecificTool: boolean;
+    requiresStrongToolFidelity: boolean;
+    isHighToolCountNonStream: boolean;
+    isStreamingConversational: boolean;
+    isMultimodal: boolean;
+};
+/** Outcome of evaluating a single fallback candidate. */
+export type FallbackEligibilityDecision = {
+    provider?: string;
+    model?: string;
+    eligible: boolean;
+    reason: string;
+};
+/** A single provider attempt in the proxy translation plan. */
+export type ProxyTranslationAttempt = {
+    provider?: string;
+    model?: string;
+    label: string;
+};
+/** Ordered plan of provider attempts and skipped candidates. */
+export type ProxyTranslationPlan = {
+    profile: ClaudeProxyRequestProfile;
+    attempts: ProxyTranslationAttempt[];
+    skipped: FallbackEligibilityDecision[];
+};
+/** Discriminated union describing why a cooldown is active. */
+export type CooldownScope = {
+    scope: "request_class";
+    key: string;
+    until: number;
+} | {
+    scope: "model_tier";
+    key: string;
+    until: number;
+} | {
+    scope: "generic";
+    key: "generic";
+    until: number;
+};
+/** An account skipped during partitioning, with the cooldown that caused it. */
+export type CooldownSkippedAccount<T> = {
+    account: T;
+    cooldown: CooldownScope;
+};
+/** Mutable readiness state tracked by the proxy process. */
+export type ProxyReadinessState = {
+    startTimeMs: number;
+    acceptingConnections: boolean;
+    ready: boolean;
+    readyAtMs?: number;
+};
+/** Structured response returned by the proxy /health endpoint. */
+export type ProxyHealthResponse = {
+    status: "ok" | "starting";
+    ready: boolean;
+    acceptingConnections: boolean;
+    strategy: string;
+    passthrough: boolean;
+    version: string;
+    startedAt: string;
+    readyAt: string | null;
+    uptime: number;
+    healthPath: "/health";
+    statusPath: "/status";
+};

package/dist/lib/types/tools.d.ts

@@ -294,6 +294,8 @@ export type ToolExecutionContext = {
 export type ToolExecutionEvent = {
     type: "tool:start" | "tool:end";
     tool: string;
+    /** Compatibility alias for older consumers that expect `toolName`. */
+    toolName?: string;
     input?: unknown;
     result?: unknown;
     error?: string;
@@ -301,6 +303,22 @@ export type ToolExecutionEvent = {
     duration?: number;
     executionId: string;
 };
+/**
+ * Payload emitted for tool:start and tool:end events.
+ * Always includes both `tool` and `toolName` for backward compatibility.
+ */
+export type ToolEventPayload = {
+    tool: string;
+    toolName: string;
+    input?: unknown;
+    result?: unknown;
+    error?: string;
+    success?: boolean;
+    responseTime?: number;
+    timestamp?: number;
+    duration?: number;
+    executionId?: string;
+};
 /**
  * Tool execution summary for completed executions
  */

package/dist/lib/utils/providerHealth.d.ts

@@ -30,6 +30,7 @@ export declare class ProviderHealthChecker {
      * Check connectivity to provider endpoints
      */
     private static checkConnectivity;
+    private static getConnectivityHeaders;
     /**
      * Check model availability (if possible without making API calls)
      */

package/dist/lib/utils/providerHealth.js

@@ -72,7 +72,7 @@ export class ProviderHealthChecker {
         };
         try {
             // 1. Check environment configuration
-            await this.checkEnvironmentConfiguration(providerName, healthStatus);
+            await this.checkEnvironmentConfiguration(providerName, healthStatus, timeout);
             // 2. Check API key validity (basic format validation)
             await this.checkApiKeyValidity(providerName, healthStatus);
             // 3. Optional: Connectivity test
@@ -129,7 +129,7 @@ export class ProviderHealthChecker {
     /**
      * Check environment configuration for a provider
      */
-    static async checkEnvironmentConfiguration(providerName, healthStatus) {
+    static async checkEnvironmentConfiguration(providerName, healthStatus, timeout) {
         const requiredEnvVars = this.getRequiredEnvironmentVariables(providerName);
         logger.debug(`[ProviderHealthChecker] Checking environment configuration for ${providerName}`, {
             requiredEnvVars,
@@ -160,7 +160,7 @@ export class ProviderHealthChecker {
             healthStatus.recommendations.push(`Set the following environment variables: ${missingVars.join(", ")}`);
         }
         // Provider-specific configuration checks
-        await this.checkProviderSpecificConfig(providerName, healthStatus);
+        await this.checkProviderSpecificConfig(providerName, healthStatus, timeout);
     }
     /**
      * Check API key validity (format validation)
@@ -261,30 +261,34 @@ export class ProviderHealthChecker {
             healthStatus.warning = "No connectivity test available for this provider";
             return;
         }
+        const headers = {
+            "User-Agent": "NeuroLink-HealthCheck/1.0",
+            ...this.getConnectivityHeaders(providerName),
+        };
         try {
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), timeout);
-            const proxyFetch = createProxyFetch();
-            let response = await proxyFetch(endpoint, {
-                method: "HEAD",
-                signal: controller.signal,
-                headers: {
-                    "User-Agent": "NeuroLink-HealthCheck/1.0",
-                },
-            });
-            // Fallback to GET if HEAD returns 405 (Method Not Allowed) for restrictive gateways
-            if (response.status === 405) {
-                response = await proxyFetch(endpoint, {
-                    method: "GET",
+            try {
+                const proxyFetch = createProxyFetch();
+                let response = await proxyFetch(endpoint, {
+                    method: "HEAD",
                     signal: controller.signal,
-                    headers: {
-                        "User-Agent": "NeuroLink-HealthCheck/1.0",
-                    },
+                    headers,
                 });
+                // Fallback to GET if HEAD returns 405 (Method Not Allowed) for restrictive gateways
+                if (response.status === 405) {
+                    response = await proxyFetch(endpoint, {
+                        method: "GET",
+                        signal: controller.signal,
+                        headers,
+                    });
+                }
+                if (!response.ok) {
+                    healthStatus.configurationIssues.push(`Connectivity test failed: HTTP ${response.status}`);
+                }
             }
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                healthStatus.configurationIssues.push(`Connectivity test failed: HTTP ${response.status}`);
+            finally {
+                clearTimeout(timeoutId);
             }
         }
         catch (error) {
@@ -320,6 +324,14 @@ export class ProviderHealthChecker {
             }
         }
     }
+    static getConnectivityHeaders(providerName) {
+        if (providerName === AIProviderName.LITELLM) {
+            return {
+                Authorization: `Bearer ${process.env.LITELLM_API_KEY || "sk-anything"}`,
+            };
+        }
+        return {};
+    }
     /**
      * Check model availability (if possible without making API calls)
      */
@@ -455,7 +467,7 @@ export class ProviderHealthChecker {
     /**
      * Provider-specific configuration checks
      */
-    static async checkProviderSpecificConfig(providerName, healthStatus) {
+    static async checkProviderSpecificConfig(providerName, healthStatus, timeout) {
         switch (providerName) {
             case AIProviderName.VERTEX:
                 await this.checkVertexAIConfig(healthStatus);
@@ -467,10 +479,10 @@ export class ProviderHealthChecker {
                 await this.checkAzureConfig(healthStatus);
                 break;
             case AIProviderName.LITELLM:
-                await this.checkLiteLLMConfig(healthStatus);
+                await this.checkLiteLLMConfig(healthStatus, timeout);
                 break;
             case AIProviderName.OLLAMA:
-                await this.checkOllamaConfig(healthStatus);
+                await this.checkOllamaConfig(healthStatus, timeout);
                 break;
         }
     }
@@ -722,9 +734,12 @@ export class ProviderHealthChecker {
             .filter((model) => typeof model === "string");
     }
     static hasRequestedModel(availableModels, requestedModel) {
-        return availableModels.some((model) => model === requestedModel ||
-            model.startsWith(`${requestedModel}:`) ||
-            requestedModel.startsWith(`${model}:`));
+        const normalizedRequestedModel = requestedModel.trim();
+        const requiresExactMatch = /@/.test(normalizedRequestedModel);
+        return availableModels.some((model) => model === normalizedRequestedModel ||
+            (!requiresExactMatch &&
+                (model.startsWith(`${normalizedRequestedModel}:`) ||
+                    model.startsWith(`${normalizedRequestedModel}@`))));
     }
     static async getOllamaAvailableModels(timeout = 2000) {
         const payload = (await this.fetchJsonWithTimeout(this.getOllamaTagsUrl(), {
@@ -789,7 +804,7 @@ export class ProviderHealthChecker {
             };
         }
     }
-    static async checkLiteLLMConfig(healthStatus) {
+    static async checkLiteLLMConfig(healthStatus, timeout = this.DEFAULT_TIMEOUT) {
         const liteLLMBase = this.getLiteLLMBaseUrl();
         if (!liteLLMBase.startsWith("http")) {
             healthStatus.isConfigured = false;
@@ -799,7 +814,7 @@ export class ProviderHealthChecker {
         }
         const availability = await this.checkLiteLLMAvailability({
             model: this.getConfiguredLiteLLMModel(),
-            timeout: 2000,
+            timeout,
         });
         if (!availability.available) {
             healthStatus.isConfigured = false;
@@ -812,7 +827,7 @@ export class ProviderHealthChecker {
     /**
      * Check Ollama configuration
      */
-    static async checkOllamaConfig(healthStatus) {
+    static async checkOllamaConfig(healthStatus, timeout = this.DEFAULT_TIMEOUT) {
         const ollamaBase = this.getOllamaBaseUrl();
         if (!ollamaBase.startsWith("http")) {
             healthStatus.isConfigured = false;
@@ -822,7 +837,7 @@ export class ProviderHealthChecker {
         }
         const availability = await this.checkOllamaAvailability({
             model: this.getConfiguredOllamaModel(),
-            timeout: 2000,
+            timeout,
         });
         if (!availability.available) {
             healthStatus.isConfigured = false;