@juspay/neurolink 9.42.1 → 9.43.0

package/dist/tasks/store/redisTaskStore.js

@@ -183,21 +183,39 @@ export class RedisTaskStore {
         const ttlSeconds = Math.ceil(ttlMs / 1000);
         // Set TTL on associated keys best-effort. A successful task write should not
         // be surfaced as a failure just because the retention metadata could not be updated.
-        client.expire(taskRunsKey(task.id), ttlSeconds).catch((err) => {
-            logger.warn("[TaskStore:Redis] Failed to set TTL on task runs key — task data may outlive retention window", {
-                taskId: task.id,
-                key: taskRunsKey(task.id),
-                ttlSeconds,
-                error: String(err),
-            });
-        });
-        client.expire(taskHistoryKey(task.id), ttlSeconds).catch((err) => {
-            logger.warn("[TaskStore:Redis] Failed to set TTL on task history key — task data may outlive retention window", {
-                taskId: task.id,
-                key: taskHistoryKey(task.id),
-                ttlSeconds,
-                error: String(err),
-            });
-        });
+        void (async () => {
+            const runsKey = taskRunsKey(task.id);
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    await client.expire(runsKey, ttlSeconds);
+                    break;
+                }
+                catch (err) {
+                    if (attempt === 3) {
+                        logger.warn("[TaskStore:Redis] expire failed after 3 attempts on task runs key — task data may outlive retention window", { taskId: task.id, key: runsKey, ttlSeconds, err: String(err) });
+                    }
+                    else {
+                        await new Promise((r) => setTimeout(r, 100 * attempt));
+                    }
+                }
+            }
+        })();
+        void (async () => {
+            const histKey = taskHistoryKey(task.id);
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    await client.expire(histKey, ttlSeconds);
+                    break;
+                }
+                catch (err) {
+                    if (attempt === 3) {
+                        logger.warn("[TaskStore:Redis] expire failed after 3 attempts on task history key — task data may outlive retention window", { taskId: task.id, key: histKey, ttlSeconds, err: String(err) });
+                    }
+                    else {
+                        await new Promise((r) => setTimeout(r, 100 * attempt));
+                    }
+                }
+            }
+        })();
     }
 }

package/dist/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/types/proxyTypes.d.ts

@@ -548,6 +548,7 @@ export type AnthropicAuthRetryResult = {
 export type AnthropicNonOkResult = {
     response?: Response | unknown;
     continueLoop: boolean;
+    retrySameAccount?: boolean;
     lastError: unknown;
     authFailureMessage: string | null;
     sawTransientFailure: boolean;
@@ -570,6 +571,7 @@ export type PreparedAnthropicAccountAttempt = {
 };
 export type AnthropicUpstreamFetchResult = {
     continueLoop: boolean;
+    retrySameAccount?: boolean;
     response?: Response;
     lastError: unknown;
     sawRateLimit: boolean;
@@ -639,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;
 };
@@ -689,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/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/utils/schemaConversion.d.ts

@@ -20,6 +20,7 @@ export declare function inlineJsonSchema(schema: Record<string, unknown>, defini
  * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) — returned as-is
  */
 export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema): object;
+export declare function normalizeJsonSchemaObject(schema: Record<string, unknown> | undefined | null): Record<string, unknown>;
 /**
  * Check if a value is a Zod schema
  */

package/dist/utils/schemaConversion.js

@@ -138,6 +138,9 @@ export function convertZodToJsonSchema(zodSchema) {
         return { type: "object", properties: {} };
     }
 }
+export function normalizeJsonSchemaObject(schema) {
+    return ensureTypeField(inlineJsonSchema(schema ? { ...schema } : { type: "object", properties: {} }));
+}
 /**
  * Ensure a JSON Schema object has a `type` field (required by Vertex/Gemini).
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.42.1",
+  "version": "9.43.0",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {