@juspay/neurolink 9.40.0 → 9.42.0

package/dist/lib/tasks/tools/taskTools.js

@@ -0,0 +1,274 @@
+/**
+ * Built-in agent tools for TaskManager.
+ *
+ * These tools allow the AI to self-schedule, manage, and inspect tasks
+ * during conversations. Created per-instance via `createTaskTools()` factory,
+ * following the same pattern as `createFileTools()` in files/fileTools.ts.
+ *
+ * @module tasks/tools/taskTools
+ */
+import { tool } from "ai";
+import { z } from "zod";
+import { logger } from "../../utils/logger.js";
+import { TaskError } from "../errors.js";
+/**
+ * Parse a schedule object from tool input.
+ * Accepts: { type: "cron", expression } | { type: "interval", every } | { type: "once", at }
+ */
+function parseSchedule(input) {
+    const type = input.type;
+    if (type === "cron") {
+        if (!input.expression || typeof input.expression !== "string") {
+            throw TaskError.create("SCHEDULE_FAILED", "Cron schedule requires an 'expression' field");
+        }
+        return {
+            type: "cron",
+            expression: input.expression,
+            ...(input.timezone ? { timezone: input.timezone } : {}),
+        };
+    }
+    if (type === "interval") {
+        if (typeof input.every !== "number" ||
+            !isFinite(input.every) ||
+            input.every <= 0) {
+            throw TaskError.create("SCHEDULE_FAILED", "Interval schedule requires a positive 'every' field (milliseconds)");
+        }
+        return { type: "interval", every: input.every };
+    }
+    if (type === "once") {
+        if (!input.at) {
+            throw TaskError.create("SCHEDULE_FAILED", "Once schedule requires an 'at' field (ISO 8601 date string)");
+        }
+        return { type: "once", at: input.at };
+    }
+    throw TaskError.create("SCHEDULE_FAILED", `Invalid schedule type: "${type}". Must be "cron", "interval", or "once".`);
+}
+/**
+ * Create task management tools bound to a TaskManager instance.
+ *
+ * These tools follow the same factory pattern as `createFileTools()` in
+ * `src/lib/files/fileTools.ts`. The `manager` is captured via closure,
+ * eliminating the need for module-level singleton state.
+ *
+ * @param manager - The TaskManager instance to bind to
+ * @returns Record of tool name to tool definition
+ *
+ * @example
+ * ```typescript
+ * const manager = new TaskManager(neurolink, config);
+ * const tools = createTaskTools(manager);
+ * // tools.createTask, tools.listTasks, tools.getTaskRuns, etc.
+ * ```
+ */
+export function createTaskTools(manager) {
+    return {
+        createTask: tool({
+            description: 'Schedule a recurring or one-shot task that runs a prompt on a schedule. Use schedule type "cron" for calendar-based (e.g. "0 9 * * *"), "interval" for fixed frequency (every N milliseconds), or "once" for a single future execution.',
+            inputSchema: z.object({
+                name: z.string().describe("Human-readable task name"),
+                prompt: z.string().describe("The prompt to execute on each run"),
+                schedule: z
+                    .object({
+                    type: z.enum(["cron", "interval", "once"]),
+                    expression: z
+                        .string()
+                        .optional()
+                        .describe('Cron expression (for type "cron"), e.g. "0 9 * * *"'),
+                    timezone: z
+                        .string()
+                        .optional()
+                        .describe('IANA timezone for cron, e.g. "America/New_York"'),
+                    every: z
+                        .number()
+                        .optional()
+                        .describe('Interval in milliseconds (for type "interval")'),
+                    at: z
+                        .string()
+                        .optional()
+                        .describe('ISO 8601 timestamp (for type "once")'),
+                })
+                    .describe("When to run the task"),
+                mode: z
+                    .enum(["isolated", "continuation"])
+                    .optional()
+                    .describe('Execution mode. "isolated" = fresh context per run (default). "continuation" = preserves conversation history across runs.'),
+            }),
+            execute: async ({ name, prompt, schedule, mode }) => {
+                try {
+                    const parsedSchedule = parseSchedule(schedule);
+                    const task = await manager.create({
+                        name,
+                        prompt,
+                        schedule: parsedSchedule,
+                        mode: mode,
+                    });
+                    return {
+                        success: true,
+                        taskId: task.id,
+                        name: task.name,
+                        status: task.status,
+                        mode: task.mode,
+                        nextRunAt: task.nextRunAt,
+                        schedule: task.schedule,
+                    };
+                }
+                catch (error) {
+                    logger.error("[taskTools] createTask failed", {
+                        error: String(error),
+                    });
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            },
+        }),
+        listTasks: tool({
+            description: "List all scheduled tasks and their current status.",
+            inputSchema: z.object({
+                status: z
+                    .enum([
+                    "active",
+                    "paused",
+                    "completed",
+                    "failed",
+                    "cancelled",
+                    "pending",
+                ])
+                    .optional()
+                    .describe("Filter by task status"),
+            }),
+            execute: async ({ status }) => {
+                try {
+                    const tasks = await manager.list(status
+                        ? {
+                            status: status,
+                        }
+                        : undefined);
+                    return {
+                        success: true,
+                        count: tasks.length,
+                        tasks: tasks.map((t) => ({
+                            taskId: t.id,
+                            name: t.name,
+                            status: t.status,
+                            mode: t.mode,
+                            schedule: t.schedule,
+                            runCount: t.runCount,
+                            lastRunAt: t.lastRunAt,
+                            nextRunAt: t.nextRunAt,
+                        })),
+                    };
+                }
+                catch (error) {
+                    logger.error("[taskTools] listTasks failed", {
+                        error: String(error),
+                    });
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            },
+        }),
+        getTaskRuns: tool({
+            description: "Get the run history of a scheduled task, showing recent executions and their results.",
+            inputSchema: z.object({
+                taskId: z.string().describe("The task ID"),
+                limit: z
+                    .number()
+                    .optional()
+                    .describe("Max results to return (default: 10)"),
+            }),
+            execute: async ({ taskId, limit }) => {
+                try {
+                    const runs = await manager.runs(taskId, { limit: limit ?? 10 });
+                    return {
+                        success: true,
+                        taskId,
+                        count: runs.length,
+                        runs: runs.map((r) => ({
+                            runId: r.runId,
+                            status: r.status,
+                            output: r.output
+                                ? r.output.length > 500
+                                    ? r.output.slice(0, 500) + "..."
+                                    : r.output
+                                : undefined,
+                            durationMs: r.durationMs,
+                            timestamp: r.timestamp,
+                            error: r.error,
+                        })),
+                    };
+                }
+                catch (error) {
+                    logger.error("[taskTools] getTaskRuns failed", {
+                        error: String(error),
+                    });
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            },
+        }),
+        deleteTask: tool({
+            description: "Cancel and permanently remove a scheduled task.",
+            inputSchema: z.object({
+                taskId: z.string().describe("The task ID to delete"),
+            }),
+            execute: async ({ taskId }) => {
+                try {
+                    const task = await manager.get(taskId);
+                    if (!task) {
+                        return { success: false, error: `Task not found: ${taskId}` };
+                    }
+                    await manager.delete(taskId);
+                    return { success: true, deletedTask: task.name, taskId };
+                }
+                catch (error) {
+                    logger.error("[taskTools] deleteTask failed", {
+                        error: String(error),
+                    });
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            },
+        }),
+        runTaskNow: tool({
+            description: "Immediately execute a scheduled task outside of its normal schedule. Returns the run result.",
+            inputSchema: z.object({
+                taskId: z.string().describe("The task ID to run"),
+            }),
+            execute: async ({ taskId }) => {
+                try {
+                    const result = await manager.run(taskId);
+                    return {
+                        success: true,
+                        runId: result.runId,
+                        status: result.status,
+                        output: result.output
+                            ? result.output.length > 1000
+                                ? result.output.slice(0, 1000) + "..."
+                                : result.output
+                            : undefined,
+                        durationMs: result.durationMs,
+                        error: result.error,
+                    };
+                }
+                catch (error) {
+                    logger.error("[taskTools] runTaskNow failed", {
+                        error: String(error),
+                    });
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            },
+        }),
+    };
+}
+//# sourceMappingURL=taskTools.js.map

package/dist/lib/telemetry/index.d.ts

@@ -4,7 +4,8 @@ export { withSpan, withClientSpan, type SpanOptions } from "./withSpan.js";
 export { ATTR } from "./attributes.js";
 /**
  * Initialize telemetry for NeuroLink
- * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true
+ * Reuses an existing global TracerProvider when one is already registered,
+ * otherwise bootstraps Neurolink telemetry when an exporter endpoint is configured.
  */
 export declare function initializeTelemetry(): Promise<import("./telemetryService.js").TelemetryService>;
 /**

package/dist/lib/telemetry/index.js

@@ -6,7 +6,8 @@ export { ATTR } from "./attributes.js";
 import { logger } from "../utils/logger.js";
 /**
  * Initialize telemetry for NeuroLink
- * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true
+ * Reuses an existing global TracerProvider when one is already registered,
+ * otherwise bootstraps Neurolink telemetry when an exporter endpoint is configured.
  */
 export async function initializeTelemetry() {
     const { TelemetryService } = await import("./telemetryService.js");

package/dist/lib/telemetry/telemetryService.d.ts

@@ -11,6 +11,7 @@ export declare class TelemetryService {
     private tracerProvider?;
     private enabled;
     private initialized;
+    private usingExternalTracerProvider;
     private meter?;
     private tracer?;
     private aiRequestCounter?;
@@ -29,6 +30,8 @@ export declare class TelemetryService {
     private constructor();
     static getInstance(): TelemetryService;
     private isTelemetryEnabled;
+    private hasExternalTracerProvider;
+    private adoptExternalTracerProvider;
     private initializeTelemetry;
     private initializeMetrics;
     initialize(): Promise<void>;

package/dist/lib/telemetry/telemetryService.js

@@ -9,6 +9,7 @@ export class TelemetryService {
     tracerProvider;
     enabled = false;
     initialized = false;
+    usingExternalTracerProvider = false;
     meter;
     tracer;
     // Optional Metrics (only created when enabled)
@@ -43,11 +44,48 @@ export class TelemetryService {
         return TelemetryService.instance;
     }
     isTelemetryEnabled() {
-        return (process.env.NEUROLINK_TELEMETRY_ENABLED === "true" ||
+        return (this.hasExternalTracerProvider() ||
+            process.env.NEUROLINK_TELEMETRY_ENABLED === "true" ||
             process.env.OTEL_EXPORTER_OTLP_ENDPOINT !== undefined);
     }
+    hasExternalTracerProvider() {
+        try {
+            const provider = trace.getTracerProvider();
+            if (!provider) {
+                return false;
+            }
+            const delegateName = provider._delegate?.constructor?.name || "";
+            if (delegateName && delegateName !== "NoopTracerProvider") {
+                return true;
+            }
+            const providerName = provider.constructor?.name || "";
+            return (providerName !== "ProxyTracerProvider" &&
+                providerName !== "NoopTracerProvider");
+        }
+        catch (error) {
+            logger.warn("[Telemetry] Failed checking for external TracerProvider", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    adoptExternalTracerProvider(reason) {
+        this.usingExternalTracerProvider = true;
+        this.tracerProvider = undefined;
+        this.meter = metrics.getMeter("neurolink-ai");
+        this.tracer = trace.getTracer("neurolink-ai");
+        this.initializeMetrics();
+        logger.debug("[Telemetry] Reusing externally managed TracerProvider", {
+            reason,
+            endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+        });
+    }
     initializeTelemetry() {
         try {
+            if (this.hasExternalTracerProvider()) {
+                this.adoptExternalTracerProvider("global tracer provider already registered");
+                return;
+            }
             const resource = resourceFromAttributes({
                 [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
                 [ATTR_SERVICE_VERSION]: process.env.OTEL_SERVICE_VERSION || "3.0.1",
@@ -61,13 +99,23 @@ export class TelemetryService {
                 resource,
                 spanProcessors: [new BatchSpanProcessor(exporter)],
             });
-            trace.setGlobalTracerProvider(this.tracerProvider);
             this.meter = metrics.getMeter("neurolink-ai");
-            this.tracer = trace.getTracer("neurolink-ai");
+            this.tracer = this.tracerProvider.getTracer("neurolink-ai");
             this.initializeMetrics();
-            logger.debug("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
+            logger.debug("[Telemetry] Initialized local telemetry exporter", {
+                endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+                globalTracerProviderOwnedBy: "observability/instrumentation",
+            });
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isDuplicateRegistration = errorMessage.includes("duplicate registration") ||
+                errorMessage.includes("already registered") ||
+                errorMessage.includes("already set");
+            if (isDuplicateRegistration && this.hasExternalTracerProvider()) {
+                this.adoptExternalTracerProvider("duplicate global tracer registration detected");
+                return;
+            }
             logger.error("[Telemetry] Failed to initialize:", error);
             this.enabled = false;
         }
@@ -105,6 +153,16 @@ export class TelemetryService {
         if (!this.enabled) {
             return;
         }
+        if (this.usingExternalTracerProvider) {
+            this.initialized = true;
+            logger.debug("[Telemetry] External TracerProvider already initialized by host");
+            return;
+        }
+        if (!this.tracerProvider) {
+            this.initialized = true;
+            logger.debug("[Telemetry] Tracer provider already prepared during constructor");
+            return;
+        }
         try {
             // Register AsyncLocalStorage context manager for proper parent-child
             // span relationships across async boundaries (required for startActiveSpan)
@@ -308,7 +366,9 @@ export class TelemetryService {
     }
     // Cleanup
     async shutdown() {
-        if (this.enabled && this.tracerProvider) {
+        if (this.enabled &&
+            this.tracerProvider &&
+            !this.usingExternalTracerProvider) {
             try {
                 await this.tracerProvider.shutdown();
                 this.initialized = false;

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

@@ -763,6 +763,8 @@ export type ProxyStartArgs = {
     quiet?: boolean;
     debug?: boolean;
     config?: string;
+    envFile?: string;
+    passthrough?: boolean;
 };
 /** Arguments accepted by `neurolink proxy status` */
 export type ProxyStatusArgs = {
@@ -779,6 +781,11 @@ export type ProxyGuardArgs = {
     pollIntervalMs?: number;
     quiet?: boolean;
 };
+/** Arguments accepted by `neurolink proxy telemetry <subcommand>` */
+export type ProxyTelemetryArgs = {
+    action?: "setup" | "start" | "stop" | "status" | "logs" | "import-dashboard";
+    quiet?: boolean;
+};
 /** A fallback chain entry (serialisable subset of FallbackEntry) */
 export type FallbackInfo = {
     provider: string;
@@ -791,12 +798,15 @@ export type ProxyState = {
     host: string;
     strategy: string;
     startTime: string;
+    envFile?: string;
     /** Fallback chain from proxy config (persisted at start time) */
     fallbackChain?: FallbackInfo[];
     /** Optional fail-open guard PID that reverts Claude settings if proxy dies */
     guardPid?: number;
     /** How the proxy was launched — "launchd" if installed as service, "manual" otherwise */
     managedBy?: "launchd" | "manual";
+    /** Whether the proxy is running in transparent passthrough mode */
+    passthrough?: boolean;
 };
 /** Stored credentials for an authenticated provider. */
 export type StoredCredentials = {

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

@@ -3,6 +3,7 @@
  * Centralized configuration type definitions following the established architecture pattern
  */
 import { MCPToolRegistry } from "../mcp/toolRegistry.js";
+import type { TaskManagerConfig } from "./taskTypes.js";
 import type { HITLConfig } from "../types/hitlTypes.js";
 import type { ConversationMemoryConfig } from "./conversation.js";
 import type { ObservabilityConfig } from "./observability.js";
@@ -36,6 +37,8 @@ export type NeurolinkConstructorConfig = {
     mcp?: MCPEnhancementsConfig;
     /** Authentication provider configuration */
     auth?: NeuroLinkAuthConfig;
+    /** TaskManager configuration (scheduled and self-running tasks) */
+    tasks?: TaskManagerConfig;
 };
 /**
  * Configuration for MCP enhancement modules wired into generate()/stream() paths.

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

@@ -315,10 +315,23 @@ export type GenerateOptions = {
     context?: StandardRecord;
     evaluationDomain?: string;
     toolUsageContext?: string;
+    /**
+     * @deprecated Use `conversationMessages` instead. This field uses a simple `{role, content}` shape
+     * that is not consumed by `buildMessagesArray()` — messages passed here will NOT reach the AI model
+     * as proper conversation turns. `conversationMessages` uses the full `ChatMessage` type and is
+     * correctly wired through the entire generate pipeline.
+     */
     conversationHistory?: Array<{
         role: string;
         content: string;
     }>;
+    /**
+     * Previous conversation as a ChatMessage array.
+     * Messages are injected as proper multi-turn conversation history before the current prompt,
+     * so the AI model sees them as real prior exchanges (not text dumped into the prompt).
+     * Used by task continuation mode and available to external callers.
+     */
+    conversationMessages?: ChatMessage[];
     factoryConfig?: {
         domainType?: string;
         domainConfig?: StandardRecord;

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

@@ -46,3 +46,4 @@ export type { ClientConfig, RequestOptions as ClientRequestOptions, RetryConfig
 export type { TokenRefresher } from "./subscriptionTypes.js";
 export * from "./proxyTypes.js";
 export type { AuthProviderType, AuthProviderConfig, MastraAuthProvider, BetterAuthConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, CustomAuthConfig, BaseAuthProviderConfig, AuthUser, AuthSession, TokenType, TokenValidationResult as AuthTokenValidationResult, TokenClaims, JWK, JWKS, TokenRefreshResult, TokenValidationConfig, TokenExtractionConfig, SessionValidationResult, SessionStorage, AuthorizationResult, AuthRequestContext, AuthenticatedContext, TokenExtractionStrategy, SessionConfig, SessionStorageType, RBACConfig, PermissionDefinition, AuthCacheConfig, AuthMiddlewareOptions, AuthMiddlewareConfig, RBACMiddlewareConfig, AuthErrorCode, AuthErrorInfo, AuthErrorInfo as AuthErrorType, AuthEventType, AuthEventData, AuthEventHandler, AuthProviderFactoryFn, AuthProviderRegistration, AuthHealthCheck, AuthProviderHealthCheck, AuthEvents, AuthProviderMetadata, AuthProviderHealthStatus, AuthTokenValidator, AuthUserAuthorizer, AuthSessionManager, AuthRequestHandler, AuthUserManager, AuthLifecycle, } from "./authTypes.js";
+export type { Task, TaskDefinition, TaskSchedule, TaskScheduleType, CronSchedule, IntervalSchedule, OnceSchedule, TaskExecutionMode, TaskStatus, TaskRunResult, TaskRunError, TaskStore, TaskBackend, TaskBackendName, TaskManagerConfig, TaskRetentionConfig, ConversationEntry as TaskConversationEntry, } from "./taskTypes.js";

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

@@ -239,10 +239,11 @@ export type ParsedClaudeRequest = {
         role: string;
         content: string;
     }>;
-    /** Tools in NeuroLink-compatible shape (name -> { description, parameters }). */
+    /** Tools translated to AI SDK-compatible shape for provider fallback. */
     tools: Record<string, {
-        description: string;
-        parameters: Record<string, unknown>;
+        description?: string;
+        inputSchema?: unknown;
+        execute?: (...args: unknown[]) => unknown;
     }>;
     /**
      * Tool choice mapping from Claude format.
@@ -421,21 +422,52 @@ export type RequestLogEntry = {
     errorMessage?: string;
     inputTokens?: number;
     outputTokens?: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+    /** OTel trace ID for correlation with distributed traces */
+    traceId?: string;
+    /** OTel span ID for correlation with distributed traces */
+    spanId?: string;
+};
+export type RequestAttemptLogEntry = {
+    timestamp: string;
+    requestId: string;
+    attempt: number;
+    method: string;
+    path: string;
+    model: string;
+    stream: boolean;
+    toolCount: number;
+    account: string;
+    accountType: string;
+    responseStatus: number;
+    responseTimeMs: number;
+    errorType?: string;
+    errorMessage?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+    /** OTel trace ID for correlation with distributed traces */
+    traceId?: string;
+    /** OTel span ID for correlation with distributed traces */
+    spanId?: string;
 };
 export type AccountStats = {
     label: string;
     type: string;
-    requestCount: number;
+    attemptCount: number;
     successCount: number;
     errorCount: number;
     rateLimitCount: number;
-    lastRequestAt: number;
+    lastAttemptAt: number;
     lastErrorAt?: number;
     currentBackoffLevel: number;
     coolingUntil?: number;
 };
 export type ProxyStats = {
     startedAt: number;
+    totalAttempts: number;
     totalRequests: number;
     totalSuccess: number;
     totalErrors: number;

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

@@ -1,16 +1,16 @@
-import type { Tool } from "ai";
+import type { LanguageModel, StepResult, Tool, ToolChoice } from "ai";
 import type { AIProviderName } from "../constants/enums.js";
 import type { EvaluationData } from "../index.js";
 import type { RAGConfig } from "../rag/types.js";
 import type { AnalyticsData, ToolExecutionEvent, ToolExecutionSummary } from "../types/index.js";
-import type { MiddlewareFactoryOptions, OnFinishCallback, OnErrorCallback, OnChunkCallback } from "../types/middlewareTypes.js";
+import type { MiddlewareFactoryOptions, OnChunkCallback, OnErrorCallback, OnFinishCallback } from "../types/middlewareTypes.js";
 import type { TokenUsage } from "./analytics.js";
 import type { JsonValue, UnknownRecord } from "./common.js";
 import type { Content, ImageWithAltText } from "./content.js";
 import type { ChatMessage } from "./conversation.js";
+import type { AdditionalMemoryUser } from "./generateTypes.js";
 import type { AIModelProviderConfig } from "./providers.js";
 import type { TTSChunk, TTSOptions } from "./ttsTypes.js";
-import type { AdditionalMemoryUser } from "./generateTypes.js";
 import type { StandardRecord, ValidationSchema } from "./typeAliases.js";
 /**
  * Progress tracking and metadata for streaming operations
@@ -326,12 +326,34 @@ export type StreamOptions = {
     abortSignal?: AbortSignal;
     disableTools?: boolean;
     maxSteps?: number;
+    /**
+     * Tool choice configuration for streaming generation.
+     * Mirrors generate() so translated/fallback requests can preserve forced tool use.
+     */
+    toolChoice?: ToolChoice<Record<string, Tool>>;
+    /**
+     * Optional callback that runs before each stream step in a multi-step generation.
+     */
+    prepareStep?: (options: {
+        steps: StepResult<Record<string, Tool>>[];
+        stepNumber: number;
+        maxSteps: number;
+        model: LanguageModel;
+    }) => PromiseLike<{
+        toolChoice?: ToolChoice<Record<string, Tool>>;
+        activeTools?: Record<string, Tool>;
+    } | undefined>;
     /** Include only these tools by name (whitelist). If set, only matching tools are available. */
     toolFilter?: string[];
     /** Exclude these tools by name (blacklist). Applied after toolFilter. */
     excludeTools?: string[];
     /** Disable tool result caching for this request (overrides global mcp.cache.enabled) */
     disableToolCache?: boolean;
+    /**
+     * Disable NeuroLink's internal provider fallback for this request.
+     * Used by the Claude proxy so the proxy itself can own fallback order.
+     */
+    disableInternalFallback?: boolean;
     /**
      * Skip injecting tool schemas into the system prompt.
      * When true, tools are ONLY passed natively via the provider's `tools` parameter,