@juspay/neurolink 9.54.3 → 9.54.5

package/dist/lib/server/routes/claudeProxyRoutes.js

@@ -20,9 +20,9 @@ import { createRawStreamCapture } from "../../proxy/rawStreamCapture.js";
 import { logBodyCapture, logRequest, logRequestAttempt, logStreamError, } from "../../proxy/requestLogger.js";
 import { createSSEInterceptor } from "../../proxy/sseInterceptor.js";
 import { needsRefresh, persistTokens, refreshToken, } from "../../proxy/tokenRefresh.js";
-import { applyRateLimitCooldown, buildProxyTranslationPlan, clearAccountCooldown, getAccountCooldownUntil, partitionAccountsByCooldown, } from "../../proxy/routingPolicy.js";
+import { buildProxyTranslationPlan, parseRetryAfterMs, } from "../../proxy/routingPolicy.js";
 import { writeJsonSnapshotAtomically } from "../../proxy/snapshotPersistence.js";
-import { recordAttempt, recordAttemptError, recordCooldown, recordFinalError, recordFinalSuccess, } from "../../proxy/usageStats.js";
+import { recordAttempt, recordAttemptError, recordFinalError, recordFinalSuccess, } from "../../proxy/usageStats.js";
 import { logger } from "../../utils/logger.js";
 import { ProviderHealthChecker } from "../../utils/providerHealth.js";
 // ---------------------------------------------------------------------------
@@ -41,7 +41,7 @@ const BLOCKED_UPSTREAM_HEADERS = new Set([
 // Module-level state
 // ---------------------------------------------------------------------------
 /** Fill-first: index of the current primary account. Only advances when
- *  the current account hits a 429 or auth failure that puts it on cooldown. */
+ *  the current account exhausts 429 retries or auth retries fail. */
 let primaryAccountIndex = 0;
 /** Track account count so we can reset primaryAccountIndex when it changes. */
 let lastKnownAccountCount = 0;
@@ -49,9 +49,12 @@ const MAX_AUTH_RETRIES = 5;
 const MAX_CONSECUTIVE_REFRESH_FAILURES = 15;
 const MAX_TRANSIENT_SAME_ACCOUNT_RETRIES = 2;
 const TRANSIENT_SAME_ACCOUNT_RETRY_DELAYS_MS = [250, 1_000];
-/** Decision 8: Cooldowns only for 401 and 429. */
-const AUTH_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes for 401
-const RATE_LIMIT_BACKOFF_CAP_MS = 10 * 60 * 1000; // 10 minute cap for 429
+/** Maximum upstream 429 attempts per account before rotating to the next account.
+ *  Total attempts per account = this + 1 (the initial call plus this many retries). */
+const MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES = 5;
+/** Max time to sleep between 429 retries. Caps large upstream retry-after values
+ *  so we don't hold the client connection open for minutes. */
+const MAX_RATE_LIMIT_RETRY_DELAY_MS = 30_000;
 /** Timeout for upstream requests to Anthropic. Must be generous enough
  *  to cover the full lifecycle of streaming responses, including extended
  *  thinking from Opus models (which can exceed 5 minutes for large contexts). */
@@ -59,10 +62,10 @@ const UPSTREAM_FETCH_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
 const accountRuntimeState = new Map();
 /** Track whether we've run the one-time startup prune. */
 let startupPruneDone = false;
-/** Advance the primary account index when the current primary is put on cooldown.
- *  This is what makes fill-first work: we stick to one account until it's unusable.
- *  Only advances when the account being cooled IS the current primary; otherwise
- *  it's already a fallback and advancing would disrupt the fill-first ordering. */
+/** Advance the primary account index when the current primary is exhausted
+ *  (429 retries exhausted or auth failure). This is what makes fill-first work:
+ *  we stick to one account until it's unusable. Only advances when the exhausted
+ *  account IS the current primary; otherwise it's already a fallback. */
 function advancePrimaryIfCurrent(accountKey, enabledCount, primaryAccountKey) {
     if (enabledCount <= 1) {
         return;
@@ -1089,8 +1092,6 @@ async function loadClaudeProxyAccounts(args) {
                 await tokenStore.markEnabled(key);
                 logger.always(`[proxy] account=${key.split(":")[1] ?? key} re-enabled (credentials changed)`);
                 existingState.permanentlyDisabled = false;
-                existingState.coolingUntil = undefined;
-                existingState.backoffLevel = 0;
                 existingState.consecutiveRefreshFailures = 0;
             }
             else {
@@ -1187,8 +1188,6 @@ async function loadClaudeProxyAccounts(args) {
             if (state.permanentlyDisabled) {
                 logger.always(`[proxy] account=${account.label} credentials changed, re-enabling`);
             }
-            state.coolingUntil = undefined;
-            state.backoffLevel = 0;
             state.consecutiveRefreshFailures = 0;
             state.permanentlyDisabled = false;
         }
@@ -1513,16 +1512,10 @@ function buildClaudeAnthropicFailureResponse(args) {
         tracer?.end(502, Date.now() - requestStartTime);
         return buildLoggedClaudeError(502, msg);
     }
-    const earliestRecovery = orderedAccounts.reduce((min, account) => {
-        const until = getAccountCooldownUntil(getOrCreateRuntimeState(account.key));
-        return until !== null ? Math.min(min, until) : min;
-    }, Infinity);
-    // If no active cooldown remains (expired while retries ran), use 1s
-    // instead of fabricating a long retry-after.
-    const retryAfterSec = Number.isFinite(earliestRecovery)
-        ? Math.max(1, Math.ceil((earliestRecovery - Date.now()) / 1000))
-        : 1;
-    const errorMessage = `All accounts rate-limited. Earliest recovery in ${retryAfterSec}s.`;
+    // All accounts returned 429 after exhausting per-account retries.
+    // Return 1s retry-after — the proxy already waited for each upstream retry-after inline.
+    const retryAfterSec = 1;
+    const errorMessage = `All ${orderedAccounts.length} accounts rate-limited after ${MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES + 1} attempts each (1 initial + ${MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES} retries).`;
     logger.always(`[proxy] all accounts rate-limited, retry in ${retryAfterSec}s`);
     const errorBody = buildClaudeError(429, errorMessage, "overloaded_error");
     tracer?.setError("rate_limit_error", errorMessage);
@@ -1552,7 +1545,6 @@ function buildClaudeAnthropicFailureResponse(args) {
 }
 async function handleAnthropicSuccessfulResponse(args) {
     const { ctx, body, account, accountState, response, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
-    clearAccountCooldown(accountState);
     accountState.consecutiveRefreshFailures = 0;
     logger.always(`[proxy] ← ${response.status} account=${account.label}`);
     const quota = parseQuotaHeaders(response.headers);
@@ -1599,7 +1591,7 @@ async function handleAnthropicSuccessfulResponse(args) {
     });
 }
 async function handleAnthropicStreamingSuccessResponse(args) {
-    const { ctx, body, account, accountState, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
+    const { ctx, body, account, accountState: _accountState, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
     if (!response.body) {
         upstreamSpan?.end();
         tracer?.setError("stream_error", "No response body from upstream");
@@ -1626,8 +1618,6 @@ async function handleAnthropicStreamingSuccessResponse(args) {
     const firstChunk = await reader.read();
     if (firstChunk.done || !firstChunk.value || firstChunk.value.length === 0) {
         reader.cancel();
-        accountState.coolingUntil = Date.now() + 10_000;
-        recordCooldown(account.label, account.type, accountState.coolingUntil, accountState.backoffLevel);
         logger.always(`[proxy] ← empty stream from account=${account.label}, trying next`);
         tracer?.recordRetry(account.label, "empty_stream");
         upstreamSpan?.end();
@@ -2186,8 +2176,6 @@ async function handleAnthropicAuthRetry(args) {
             if (retryResp.ok) {
                 authRetrySucceeded = true;
                 accountState.consecutiveRefreshFailures = 0;
-                accountState.backoffLevel = 0;
-                accountState.coolingUntil = undefined;
                 logger.always(`[proxy] ← 200 account=${account.label} (after ${authRetry + 1} refresh(es))`);
                 const successResponse = await handleAnthropicSuccessfulRetryResponse({
                     ctx,
@@ -2222,18 +2210,7 @@ async function handleAnthropicAuthRetry(args) {
             recordAttemptError(account.label, account.type, retryStatus);
             if (retryStatus === 429) {
                 currentSawRateLimit = true;
-                const retryAfter = retryResp.headers.get("retry-after");
-                const parsedRetryAfter = parseInt(retryAfter ?? "", 10);
-                const cooldownMs = Number.isNaN(parsedRetryAfter)
-                    ? 60_000
-                    : Math.max(1, parsedRetryAfter) * 1000;
-                const cooldown = applyRateLimitCooldown({
-                    state: accountState,
-                    retryAfterMs: cooldownMs,
-                    capMs: RATE_LIMIT_BACKOFF_CAP_MS,
-                });
                 advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
-                recordCooldown(account.label, account.type, Date.now() + cooldown.backoffMs, accountState.backoffLevel);
                 break;
             }
             if (retryStatus === 401 || retryStatus === 402 || retryStatus === 403) {
@@ -2288,20 +2265,15 @@ async function handleAnthropicAuthRetry(args) {
         }
     }
     if (!authRetrySucceeded) {
-        if (!accountState.permanentlyDisabled) {
-            if (!accountState.coolingUntil ||
-                accountState.coolingUntil <= Date.now()) {
-                accountState.coolingUntil = Date.now() + AUTH_COOLDOWN_MS;
-            }
-            recordCooldown(account.label, account.type, accountState.coolingUntil, accountState.backoffLevel);
-        }
+        // No persistent cooldown — just move to next account for this request.
         currentLastError = authRetryError;
-        logger.always(`[proxy] ⚠ account=${account.label} auth retries exhausted, cooldown=5min`);
+        logger.always(`[proxy] ⚠ account=${account.label} auth retries exhausted, rotating to next account`);
         logAttempt(401, "authentication_error", authRetryError);
         tracer?.setError("authentication_error", authRetryError);
         tracer?.recordRetry(account.label, "auth_exhausted");
         currentUpstreamSpan?.end();
         currentUpstreamSpan = undefined;
+        advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
     }
     return {
         continueLoop: true,
@@ -2354,7 +2326,7 @@ function buildAnthropicTerminalErrorResponse(args) {
     }
 }
 async function handleAnthropicNonOkResponse(args) {
-    const { response, account, accountState, tracer, requestStartTime, fetchStartMs, attemptNumber, logAttempt, logProxyBody, logFinalRequest, lastError, authFailureMessage, sawTransientFailure, invalidRequestFailure, maxConsecutiveRefreshFailures, } = args;
+    const { response, account, accountState, enabledAccounts, orderedAccounts, tracer, requestStartTime, fetchStartMs, attemptNumber, logAttempt, logProxyBody, logFinalRequest, lastError, authFailureMessage, sawTransientFailure, invalidRequestFailure, maxConsecutiveRefreshFailures, } = args;
     let currentLastError = lastError;
     let currentAuthFailureMessage = authFailureMessage;
     let currentSawTransientFailure = sawTransientFailure;
@@ -2404,17 +2376,16 @@ async function handleAnthropicNonOkResponse(args) {
         !account.refreshToken) {
         recordAttemptError(account.label, account.type, response.status);
         accountState.consecutiveRefreshFailures += 1;
-        accountState.coolingUntil = Date.now() + AUTH_COOLDOWN_MS;
-        recordCooldown(account.label, account.type, accountState.coolingUntil, accountState.backoffLevel);
         if (accountState.consecutiveRefreshFailures >= maxConsecutiveRefreshFailures) {
             await disableAccountUntilReauth(account, accountState);
         }
         currentAuthFailureMessage = formatReauthMessage(account.label);
-        logger.always(`[proxy] ← ${response.status} account=${account.label} cooldown=5min`);
+        logger.always(`[proxy] ← ${response.status} account=${account.label} (auth failure, no refresh token)`);
         currentLastError = errBody;
         logAttempt(response.status, "authentication_error", summarizeErrorMessage(errBody));
         tracer?.setError("authentication_error", summarizeErrorMessage(errBody));
         tracer?.recordRetry(account.label, "auth_no_refresh");
+        advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
         return {
             continueLoop: true,
             lastError: currentLastError,
@@ -2431,13 +2402,12 @@ async function handleAnthropicNonOkResponse(args) {
         recordAttemptError(account.label, account.type, response.status);
         currentAuthFailureMessage =
             "Authentication failed for Anthropic API key credentials. Update ANTHROPIC_API_KEY or re-login with OAuth.";
-        accountState.coolingUntil = Date.now() + AUTH_COOLDOWN_MS;
-        recordCooldown(account.label, account.type, accountState.coolingUntil, accountState.backoffLevel);
-        logger.always(`[proxy] ← ${response.status} account=${account.label} cooldown=5min`);
+        logger.always(`[proxy] ← ${response.status} account=${account.label} (auth failure, api_key)`);
         currentLastError = errBody;
         logAttempt(response.status, "authentication_error", summarizeErrorMessage(errBody));
         tracer?.setError("authentication_error", summarizeErrorMessage(errBody));
         tracer?.recordRetry(account.label, "auth_api_key");
+        advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
         return {
             continueLoop: true,
             lastError: currentLastError,
@@ -2805,7 +2775,7 @@ async function prepareAnthropicAccountAttempt(args) {
     };
 }
 async function fetchAnthropicAccountResponse(args) {
-    const { url, headers, finalBodyStr, account, accountState, enabledAccounts, orderedAccounts, tracer, logAttempt, currentLastError, currentSawRateLimit, currentSawNetworkError, upstreamSpan, } = args;
+    const { url, headers, finalBodyStr, account, accountState: _accountState2, enabledAccounts: _enabledAccounts, orderedAccounts: _orderedAccounts, tracer, logAttempt, currentLastError, currentSawRateLimit, currentSawNetworkError, upstreamSpan, } = args;
     let lastError = currentLastError;
     let sawRateLimit = currentSawRateLimit;
     let sawNetworkError = currentSawNetworkError;
@@ -2844,36 +2814,18 @@ async function fetchAnthropicAccountResponse(args) {
     }
     if (response.status === 429) {
         sawRateLimit = true;
-        const retryAfter = response.headers.get("retry-after");
-        let cooldownMs = 0;
-        if (retryAfter) {
-            const seconds = parseInt(retryAfter, 10);
-            if (!Number.isNaN(seconds)) {
-                cooldownMs = seconds * 1000;
-            }
-            else {
-                const date = new Date(retryAfter);
-                if (!Number.isNaN(date.getTime())) {
-                    cooldownMs = Math.max(date.getTime() - Date.now(), 1000);
-                }
-            }
-        }
-        const cooldown = applyRateLimitCooldown({
-            state: accountState,
-            retryAfterMs: cooldownMs > 0 ? cooldownMs : undefined,
-            capMs: RATE_LIMIT_BACKOFF_CAP_MS,
-        });
-        advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
+        const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
         recordAttemptError(account.label, account.type, 429);
-        recordCooldown(account.label, account.type, Date.now() + cooldown.backoffMs, accountState.backoffLevel);
         lastError = await response.text();
-        logger.always(`[proxy] ← 429 account=${account.label} backoff-level=${accountState.backoffLevel} cooldown=${Math.round(cooldown.backoffMs / 1000)}s`);
+        logger.always(`[proxy] ← 429 account=${account.label} retry-after=${retryAfterMs}ms (upstream)`);
         logAttempt(429, "rate_limit_error", String(lastError));
         tracer?.setError("rate_limit_error", String(lastError).slice(0, 500));
         tracer?.recordRetry(account.label, "rate_limit");
         currentUpstreamSpan?.end();
         return {
             continueLoop: true,
+            retrySameAccount: true,
+            retryAfterMs,
             lastError,
             sawRateLimit,
             sawNetworkError,
@@ -2914,20 +2866,12 @@ async function handleAnthropicRoutedClaudeRequest(args) {
         attemptNumber: 0,
     };
     const acctSelectionSpan = tracer?.startAccountSelection();
-    const accountPartition = partitionAccountsByCooldown(orderedAccounts, (account) => getOrCreateRuntimeState(account.key));
-    for (const skippedAccount of accountPartition.skipped) {
-        logger.always(`[proxy] skipping account=${skippedAccount.account.label} cooldown remaining=${Math.max(1, Math.ceil((skippedAccount.cooldown.until - Date.now()) / 1000))}s`);
-    }
-    // Only flag rate-limit when ALL accounts are cooling — if some are eligible,
-    // let the actual attempt results determine sawRateLimit via real 429 responses.
-    if (accountPartition.skipped.length > 0 &&
-        accountPartition.eligible.length === 0) {
-        loopState.sawRateLimit = true;
-        loopState.lastError = `All ${accountPartition.skipped.length} accounts are cooling down`;
-    }
-    accountLoop: for (const account of accountPartition.eligible) {
+    // No partition / cooldown gating — every account is always eligible.
+    // Retries are handled inline per-account using upstream retry-after.
+    accountLoop: for (const account of orderedAccounts) {
         const accountState = getOrCreateRuntimeState(account.key);
         let transientSameAccountRetries = 0;
+        let rateLimitSameAccountRetries = 0;
         while (true) {
             loopState.attemptNumber += 1;
             if (tracer && loopState.attemptNumber === 1 && acctSelectionSpan) {
@@ -2991,6 +2935,24 @@ async function handleAnthropicRoutedClaudeRequest(args) {
             loopState.sawRateLimit = fetchResult.sawRateLimit;
             loopState.sawNetworkError = fetchResult.sawNetworkError;
             if (fetchResult.continueLoop || !fetchResult.response) {
+                // 429 with retry-after: wait and retry same account up to 5 times
+                if (fetchResult.retrySameAccount &&
+                    fetchResult.retryAfterMs !== undefined &&
+                    rateLimitSameAccountRetries < MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES) {
+                    rateLimitSameAccountRetries += 1;
+                    const delayMs = Math.min(fetchResult.retryAfterMs || 1_000, MAX_RATE_LIMIT_RETRY_DELAY_MS);
+                    logger.always(`[proxy] retrying same account=${account.label} after upstream 429 (${rateLimitSameAccountRetries}/${MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES}) in ${delayMs}ms`);
+                    await sleep(delayMs);
+                    continue;
+                }
+                // Rate-limit retries exhausted for this account — rotate
+                if (fetchResult.retrySameAccount &&
+                    fetchResult.retryAfterMs !== undefined) {
+                    advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
+                    logger.always(`[proxy] exhausted ${MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES} rate-limit retries for account=${account.label}; rotating`);
+                    continue accountLoop;
+                }
+                // Transient error retry (network errors, 529 overloaded)
                 if (fetchResult.retrySameAccount &&
                     transientSameAccountRetries < MAX_TRANSIENT_SAME_ACCOUNT_RETRIES) {
                     transientSameAccountRetries += 1;
@@ -3052,6 +3014,8 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                     response,
                     account,
                     accountState,
+                    enabledAccounts,
+                    orderedAccounts,
                     tracer,
                     requestStartTime,
                     fetchStartMs: preparedAttempt.fetchStartMs,
@@ -3366,8 +3330,6 @@ function getOrCreateRuntimeState(accountKey) {
         return existing;
     }
     const initial = {
-        coolingUntil: undefined,
-        backoffLevel: 0,
         consecutiveRefreshFailures: 0,
         permanentlyDisabled: false,
     };
@@ -3376,8 +3338,6 @@ function getOrCreateRuntimeState(accountKey) {
 }
 async function disableAccountUntilReauth(account, state) {
     state.permanentlyDisabled = true;
-    state.coolingUntil = undefined;
-    state.backoffLevel = 0;
     // Decision 7 (usage): Persist disabled state to disk so it survives restarts
     try {
         const { tokenStore } = await import("../../auth/tokenStore.js");

package/dist/lib/server/routes/healthRoutes.d.ts

@@ -2,7 +2,7 @@
  * Health Routes
  * Endpoints for health checks and system status
  */
-import type { RouteGroup } from "../types.js";
+import type { RouteGroup } from "../../types/index.js";
 /**
  * Create health check routes
  */

package/dist/lib/server/routes/index.d.ts

@@ -2,7 +2,7 @@
  * Route Builders
  * Pre-built route definitions for common NeuroLink endpoints
  */
-import type { RouteDefinition, RouteGroup } from "../types.js";
+import type { RouteDefinition, RouteGroup } from "../../types/index.js";
 export { createAgentRoutes } from "./agentRoutes.js";
 export { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
 export { createHealthRoutes } from "./healthRoutes.js";
@@ -13,7 +13,7 @@ export { createToolRoutes } from "./toolRoutes.js";
 /**
  * Options for creating routes
  */
-export type CreateRoutesOptions = {
+type CreateRoutesOptions = {
     /** Enable OpenAPI/Swagger documentation endpoints (default: false) */
     enableSwagger?: boolean;
     /**

package/dist/lib/server/routes/mcpRoutes.d.ts

@@ -2,7 +2,7 @@
  * MCP Routes
  * Endpoints for MCP server management
  */
-import type { RouteGroup } from "../types.js";
+import type { RouteGroup } from "../../types/index.js";
 /**
  * Create MCP server management routes
  */

package/dist/lib/server/routes/memoryRoutes.d.ts

@@ -2,7 +2,7 @@
  * Memory Routes
  * Endpoints for conversation memory management
  */
-import type { RouteGroup } from "../types.js";
+import type { RouteGroup } from "../../types/index.js";
 /**
  * Create memory management routes
  * Note: These routes provide a simplified interface to conversation memory.

package/dist/lib/server/routes/openApiRoutes.d.ts

@@ -2,7 +2,7 @@
  * OpenAPI Routes
  * Endpoints for OpenAPI specification and documentation
  */
-import type { RouteDefinition, RouteGroup } from "../types.js";
+import type { RouteDefinition, RouteGroup } from "../../types/index.js";
 /**
  * Create OpenAPI documentation routes
  *

package/dist/lib/server/routes/toolRoutes.d.ts

@@ -2,7 +2,7 @@
  * Tool Routes
  * Endpoints for tool listing, discovery, and execution
  */
-import type { RouteGroup } from "../types.js";
+import type { RouteGroup } from "../../types/index.js";
 /**
  * Create tool routes
  */

package/dist/lib/server/streaming/dataStream.d.ts

@@ -3,106 +3,11 @@
  * Implements a protocol for streaming structured data between server and client
  * Compatible with AI SDK's data stream format
  */
-import type { DataStreamWriter } from "../types.js";
-import type { CloseHandler } from "../../types/index.js";
-/**
- * Data stream event types
- */
-export type DataStreamEventType = "text-start" | "text-delta" | "text-end" | "tool-call" | "tool-result" | "data" | "error" | "finish";
-/**
- * Base data stream event
- */
-export type DataStreamEvent = {
-    type: DataStreamEventType;
-    id?: string;
-    timestamp: number;
-    data: unknown;
-};
-/**
- * Text start event
- */
-export type TextStartEvent = DataStreamEvent & {
-    type: "text-start";
-    data: {
-        id: string;
-    };
-};
-/**
- * Text delta event
- */
-export type TextDeltaEvent = DataStreamEvent & {
-    type: "text-delta";
-    data: {
-        id: string;
-        delta: string;
-    };
-};
-/**
- * Text end event
- */
-export type TextEndEvent = DataStreamEvent & {
-    type: "text-end";
-    data: {
-        id: string;
-    };
-};
-/**
- * Tool call event
- */
-export type ToolCallEvent = DataStreamEvent & {
-    type: "tool-call";
-    data: {
-        id: string;
-        name: string;
-        arguments: Record<string, unknown>;
-    };
-};
-/**
- * Tool result event
- */
-export type ToolResultEvent = DataStreamEvent & {
-    type: "tool-result";
-    data: {
-        id: string;
-        name: string;
-        result: unknown;
-    };
-};
-/**
- * Data event (arbitrary data)
- */
-export type DataEvent = DataStreamEvent & {
-    type: "data";
-    data: unknown;
-};
-/**
- * Error event
- */
-export type ErrorEvent = DataStreamEvent & {
-    type: "error";
-    data: {
-        message: string;
-        code?: string;
-    };
-};
-/**
- * Finish event
- */
-export type FinishEvent = DataStreamEvent & {
-    type: "finish";
-    data: {
-        reason?: string;
-        usage?: {
-            input: number;
-            output: number;
-            total: number;
-        };
-    };
-};
+import type { DataStreamWriter, CloseHandler } from "../../types/index.js";
 /**
  * Configuration for DataStreamWriter
  */
-export type DataStreamWriterConfig = {
+type DataStreamWriterConfig = {
     /** Writer function to send data */
     write: (chunk: string) => void | Promise<void>;
     /** Function to close the stream */
@@ -119,7 +24,7 @@ export declare function createDataStreamWriter(config: DataStreamWriterConfig):
 /**
  * Configuration for DataStreamResponse
  */
-export type DataStreamResponseConfig = {
+type DataStreamResponseConfig = {
     /** Content type header */
     contentType?: "text/event-stream" | "application/x-ndjson";
     /** Initial headers */
@@ -231,7 +136,7 @@ export declare function createNDJSONHeaders(additionalHeaders?: Record<string, s
 /**
  * SSE Event options for formatSSEEvent
  */
-export type SSEEventOptions = {
+type SSEEventOptions = {
     /** Event type (optional) */
     event?: string;
     /** Event data (required) */
@@ -338,3 +243,4 @@ export declare class WebStreamWriter extends BaseDataStreamWriter {
     writeEvent(eventType: string, data: unknown): void;
     protected doClose(): void;
 }
+export {};

package/dist/lib/server/streaming/index.d.ts

@@ -2,4 +2,4 @@
  * Streaming Module
  * Exports for data stream protocol and streaming utilities
  */
-export { type DataStreamEventType, type DataStreamEvent, type TextStartEvent, type TextDeltaEvent, type TextEndEvent, type ToolCallEvent, type ToolResultEvent, type DataEvent, type ErrorEvent, type FinishEvent, type SSEEventOptions, type DataStreamWriterConfig, createDataStreamWriter, type DataStreamResponseConfig, DataStreamResponse, createDataStreamResponse, pipeAsyncIterableToDataStream, createSSEHeaders, createNDJSONHeaders, formatSSEEvent, BaseDataStreamWriter, WebStreamWriter, } from "./dataStream.js";
+export { createDataStreamWriter, DataStreamResponse, createDataStreamResponse, pipeAsyncIterableToDataStream, createSSEHeaders, createNDJSONHeaders, formatSSEEvent, BaseDataStreamWriter, WebStreamWriter, } from "./dataStream.js";

package/dist/lib/server/streaming/index.js

@@ -2,7 +2,12 @@
  * Streaming Module
  * Exports for data stream protocol and streaming utilities
  */
-export { createDataStreamWriter, DataStreamResponse, createDataStreamResponse, 
+export { 
+// Types
+// Writer
+createDataStreamWriter, 
+// Response
+DataStreamResponse, createDataStreamResponse, 
 // Helpers
 pipeAsyncIterableToDataStream, createSSEHeaders, createNDJSONHeaders, 
 // SSE Event Formatting

package/dist/lib/server/utils/redaction.d.ts

@@ -1,11 +1,4 @@
-/**
- * Stream Chunk Redaction Utilities
- * Sanitizes sensitive data from stream chunks before client delivery
- *
- * NOTE: Redaction is DISABLED by default. Enable via config.enabled = true
- */
-import type { DataStreamEvent } from "../streaming/dataStream.js";
-import type { RedactionConfig } from "../types.js";
+import type { RedactionConfig, DataStreamEvent } from "../../types/index.js";
 /**
  * Redact sensitive data from a stream chunk.
  *

package/dist/lib/server/utils/redaction.js

@@ -1,9 +1,3 @@
-/**
- * Stream Chunk Redaction Utilities
- * Sanitizes sensitive data from stream chunks before client delivery
- *
- * NOTE: Redaction is DISABLED by default. Enable via config.enabled = true
- */
 /**
  * Default fields to redact from stream chunks
  */

package/dist/lib/server/utils/validation.d.ts

@@ -3,6 +3,7 @@
  * Provides Zod schemas and validation helpers for server routes
  */
 import { z } from "zod";
+import type { ErrorResponse, ServerValidationResult } from "../../types/index.js";
 /**
  * Agent execute request schema
  */
@@ -98,21 +99,6 @@ export declare const EmbedManyRequestSchema: z.ZodObject<{
     provider: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-/**
- * Standardized error response format
- */
-export type ErrorResponse = {
-    error: {
-        code: string;
-        message: string;
-        details?: unknown;
-    };
-    metadata?: {
-        timestamp: string;
-        requestId?: string;
-    };
-    httpStatus?: number;
-};
 /**
  * Type guard to check if a value is an ErrorResponse
  */
@@ -121,27 +107,15 @@ export declare function isErrorResponse(value: unknown): value is ErrorResponse;
  * Create a standardized error response
  */
 export declare function createErrorResponse(code: string, message: string, details?: unknown, requestId?: string, httpStatus?: number): ErrorResponse;
-/**
- * Validation result type
- */
-export type ValidationResult<T> = {
-    success: true;
-    data: T;
-    error?: undefined;
-} | {
-    success: false;
-    error: ErrorResponse;
-    data?: undefined;
-};
 /**
  * Validate request body against a Zod schema
  */
-export declare function validateRequest<T>(schema: z.ZodSchema<T>, data: unknown, requestId?: string): ValidationResult<T>;
+export declare function validateRequest<T>(schema: z.ZodSchema<T>, data: unknown, requestId?: string): ServerValidationResult<T>;
 /**
  * Validate query parameters against a Zod schema
  */
-export declare function validateQuery<T>(schema: z.ZodSchema<T>, query: Record<string, string>, requestId?: string): ValidationResult<T>;
+export declare function validateQuery<T>(schema: z.ZodSchema<T>, query: Record<string, string>, requestId?: string): ServerValidationResult<T>;
 /**
  * Validate path parameters against a Zod schema
  */
-export declare function validateParams<T>(schema: z.ZodSchema<T>, params: Record<string, string>, requestId?: string): ValidationResult<T>;
+export declare function validateParams<T>(schema: z.ZodSchema<T>, params: Record<string, string>, requestId?: string): ServerValidationResult<T>;

package/dist/lib/server/utils/validation.js

@@ -127,6 +127,9 @@ export const EmbedManyRequestSchema = z.object({
     provider: z.string().optional(),
     model: z.string().optional(),
 });
+// ============================================
+// Error Response Type Guards / Helpers
+// ============================================
 /**
  * Type guard to check if a value is an ErrorResponse
  */