@juspay/neurolink 9.65.1 → 9.66.0

package/dist/server/routes/openaiProxyRoutes.js

@@ -0,0 +1,336 @@
+/**
+ * OpenAI-Compatible Proxy Routes
+ *
+ * Exposes OpenAI Chat Completions-compatible /v1/chat/completions endpoint.
+ * ALL requests are routed through ctx.neurolink.stream() — no direct
+ * HTTP calls to any upstream provider.
+ *
+ * This is a thin wrapper that parses OpenAI format requests and delegates
+ * to the shared proxy translation engine.
+ *
+ * An optional ModelRouter can remap incoming model names to different
+ * provider/model pairs (e.g. "gpt-4o" -> vertex/gemini-2.5-pro).
+ */
+import { buildOpenAIError, convertClaudeToOpenAIResponse, convertOpenAIToClaudeRequest, createClaudeToOpenAIStreamTransform, parseOpenAIRequest, } from "../../proxy/openaiFormat.js";
+import { ProxyTracer } from "../../proxy/proxyTracer.js";
+import { buildModelsListResponse, handleTranslatedJsonRequest, handleTranslatedStreamRequest, } from "../../proxy/proxyTranslationEngine.js";
+import { logRequest } from "../../proxy/requestLogger.js";
+import { buildProxyTranslationPlan } from "../../proxy/routingPolicy.js";
+import { withTimeout } from "../../utils/async/withTimeout.js";
+import { sanitizeForLog } from "../../utils/logSanitize.js";
+import { logger } from "../../utils/logger.js";
+// Maximum time the internal loopback fetch is allowed to take before we
+// give up — keeps a stuck inner /v1/messages handler from hanging the outer
+// /v1/chat/completions request indefinitely.
+const LOOPBACK_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes — long enough for slow Claude streams
+// Default loopback port — matches the CLI proxy default. Overridden via
+// `createOpenAIProxyRoutes`'s third argument when the actual listener port is
+// known (e.g. when started from the CLI handler).
+const DEFAULT_LOOPBACK_PORT = 55669;
+/**
+ * Build an OpenAI-shaped error as a typed Response with the intended status.
+ *
+ * Without the explicit Response wrapper, the CLI proxy runtime maps plain
+ * objects to HTTP 200, so error returns would silently arrive as 200s with
+ * an error payload. Wrapping in Response forces the runtime to honor the
+ * status code we computed.
+ */
+function buildOpenAIErrorResponse(status, message) {
+    return new Response(JSON.stringify(buildOpenAIError(status, message)), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+// ---------------------------------------------------------------------------
+// Adapt ParsedOpenAIRequest to the shape buildProxyTranslationPlan expects
+// ---------------------------------------------------------------------------
+/**
+ * buildProxyTranslationPlan's classifier expects ParsedClaudeRequest.
+ * The shapes are nearly identical; we just fill in the extra fields it inspects
+ * (thinkingConfig, topK) with safe defaults.
+ */
+function adaptForTranslationPlan(parsed) {
+    return {
+        model: parsed.model,
+        maxTokens: parsed.maxTokens ?? 4096,
+        temperature: parsed.temperature,
+        topP: parsed.topP,
+        systemPrompt: typeof parsed.systemPrompt === "string" ? parsed.systemPrompt : undefined,
+        stream: parsed.stream,
+        prompt: parsed.prompt,
+        images: parsed.images,
+        conversationMessages: parsed.conversationMessages,
+        tools: parsed.tools,
+        toolChoice: parsed.toolChoice,
+        toolChoiceName: parsed.toolChoiceName,
+        stopSequences: parsed.stopSequences,
+    };
+}
+// ---------------------------------------------------------------------------
+// OpenAI -> Anthropic loopback bridge
+// ---------------------------------------------------------------------------
+/**
+ * Forward an OpenAI-format request targeting a Claude model through the
+ * proxy's own /v1/messages endpoint via a loopback fetch().
+ *
+ * This reuses the full Claude passthrough path (OAuth account rotation, retry,
+ * SSE interception, etc.) and only adds format conversion at the edges.
+ *
+ * The loopback target is ALWAYS `127.0.0.1:<loopbackPort>` (never derived
+ * from the client-controlled `Host` header — that would be an SSRF vector).
+ * `loopbackPort` is provided at route-build time from the listener's actual
+ * port via `createOpenAIProxyRoutes(modelRouter, basePath, loopbackPort)`.
+ */
+async function handleOpenAIToAnthropicBridge(args) {
+    const { ctx, body, targetModel, requestStartTime, loopbackPort } = args;
+    const stream = body.stream === true;
+    const toolCount = body.tools?.length ?? 0;
+    const writeLifecycle = (responseStatus, extra = {}) => logRequest({
+        timestamp: new Date().toISOString(),
+        requestId: ctx.requestId,
+        method: ctx.method,
+        path: ctx.path,
+        model: body.model,
+        stream,
+        toolCount,
+        account: "",
+        accountType: "openai-bridge",
+        responseStatus,
+        responseTimeMs: Date.now() - requestStartTime,
+        ...extra,
+    });
+    // Convert to Claude format and remap the model to the router's choice.
+    const claudeBody = convertOpenAIToClaudeRequest(body);
+    claudeBody.model = targetModel;
+    // SECURITY: Never derive the loopback target from the client-controlled
+    // `Host` header. The bridge always fetches from 127.0.0.1 on the listener's
+    // configured port — anything else would be an SSRF vector.
+    const internalUrl = `http://127.0.0.1:${loopbackPort}/v1/messages`;
+    // Forward a minimal set of headers. The proxy's own /v1/messages handler
+    // will attach OAuth credentials from its account pool.
+    const forwardHeaders = {
+        "content-type": "application/json",
+        accept: stream ? "text/event-stream" : "application/json",
+    };
+    for (const [k, v] of Object.entries(ctx.headers)) {
+        if (typeof v !== "string") {
+            continue;
+        }
+        const lower = k.toLowerCase();
+        if (lower.startsWith("anthropic-") || lower === "x-api-key") {
+            forwardHeaders[lower] = v;
+        }
+    }
+    // Bound the self-call with a timeout so a stuck inner handler can't hang
+    // the outer /v1/chat/completions request indefinitely.
+    const upstream = await withTimeout(fetch(internalUrl, {
+        method: "POST",
+        headers: forwardHeaders,
+        body: JSON.stringify({ ...claudeBody, stream }),
+    }), LOOPBACK_TIMEOUT_MS, `Anthropic loopback timed out after ${LOOPBACK_TIMEOUT_MS}ms`);
+    if (!upstream.ok) {
+        const errText = await upstream.text().catch(() => "");
+        const safeErrText = sanitizeForLog(errText);
+        logger.always(`[proxy:openai] anthropic loopback error ${upstream.status}: ${safeErrText}`);
+        await writeLifecycle(upstream.status, {
+            errorType: "loopback_upstream_error",
+            errorMessage: safeErrText,
+        });
+        return buildOpenAIErrorResponse(upstream.status, safeErrText || `Anthropic loopback failed with status ${upstream.status}`);
+    }
+    if (stream) {
+        if (!upstream.body) {
+            await writeLifecycle(502, {
+                errorType: "loopback_empty_stream",
+                errorMessage: "Anthropic loopback returned empty stream body",
+            });
+            return buildOpenAIErrorResponse(502, "Anthropic loopback returned empty stream body");
+        }
+        // Streaming success: log now since the response body is consumed by the
+        // client. Token counts are not visible at this layer (the inner /v1/messages
+        // handler accounts them), so we omit them here.
+        await writeLifecycle(200);
+        const transformed = upstream.body.pipeThrough(createClaudeToOpenAIStreamTransform(body.model));
+        return new Response(transformed, {
+            status: 200,
+            headers: {
+                "content-type": "text/event-stream",
+                "cache-control": "no-cache",
+                connection: "keep-alive",
+            },
+        });
+    }
+    const claudeJson = (await upstream.json());
+    await writeLifecycle(200, {
+        inputTokens: claudeJson.usage?.input_tokens,
+        outputTokens: claudeJson.usage?.output_tokens,
+        cacheCreationTokens: claudeJson.usage?.cache_creation_input_tokens,
+        cacheReadTokens: claudeJson.usage?.cache_read_input_tokens,
+    });
+    return convertClaudeToOpenAIResponse(claudeJson, body.model);
+}
+// ---------------------------------------------------------------------------
+// Route factory
+// ---------------------------------------------------------------------------
+/**
+ * Create OpenAI-compatible proxy routes.
+ *
+ * Every request flows through ctx.neurolink.stream() — no direct HTTP calls
+ * to any upstream provider.
+ *
+ * @param modelRouter   - Optional model router for remapping model names.
+ * @param basePath      - Base path prefix (default: "").
+ * @param loopbackPort  - Listener port used by the Anthropic loopback bridge.
+ *                        Defaults to the CLI proxy default (55669). MUST be the
+ *                        actual listener port — never derived from request
+ *                        headers — to avoid SSRF.
+ * @returns RouteGroup with OpenAI-compatible endpoints.
+ */
+export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort = DEFAULT_LOOPBACK_PORT) {
+    return {
+        prefix: `${basePath}/v1`,
+        routes: [
+            // =================================================================
+            // POST /v1/chat/completions — Main chat completions endpoint
+            // =================================================================
+            {
+                method: "POST",
+                path: `${basePath}/v1/chat/completions`,
+                description: "OpenAI-compatible chat completions (translation mode)",
+                handler: async (ctx) => {
+                    const requestStartTime = Date.now();
+                    const body = ctx.body;
+                    // --- Validation ---
+                    if (!body || !body.model || !body.messages?.length) {
+                        return buildOpenAIErrorResponse(400, "Request must include 'model' and 'messages' fields");
+                    }
+                    // --- Resolve target provider/model ---
+                    const route = modelRouter
+                        ? modelRouter.resolve(body.model)
+                        : { provider: null, model: body.model };
+                    const targetProvider = route.provider ?? undefined;
+                    const targetModel = route.model ?? body.model;
+                    logger.debug(`[proxy:openai] ${body.model} → ${targetProvider ?? "auto"}/${targetModel}`);
+                    // --- Anthropic loopback bridge ---
+                    // When the resolved target is Anthropic, the proxy has no
+                    // ANTHROPIC_API_KEY (it uses OAuth passthrough). Instead of trying
+                    // to stream through the SDK, forward the request to our own
+                    // /v1/messages endpoint via loopback so it goes through the full
+                    // Claude passthrough path (OAuth, retry, rotation, SSE intercept).
+                    if (route.provider === "anthropic") {
+                        try {
+                            return await handleOpenAIToAnthropicBridge({
+                                ctx,
+                                body,
+                                targetModel,
+                                requestStartTime,
+                                loopbackPort,
+                            });
+                        }
+                        catch (err) {
+                            // Internal exception text (.message + any stack-trace remnants)
+                            // is kept ONLY in server-side logs + tracer. The client receives
+                            // a fixed generic message so internal paths/frames don't leak
+                            // back through the response body. (CodeQL: information exposure
+                            // through a stack trace.)
+                            const rawMessage = err instanceof Error ? err.message : String(err);
+                            const internalDetail = sanitizeForLog(rawMessage);
+                            logger.always(`[proxy:openai] anthropic loopback failed: ${internalDetail}`);
+                            await logRequest({
+                                timestamp: new Date().toISOString(),
+                                requestId: ctx.requestId,
+                                method: ctx.method,
+                                path: ctx.path,
+                                model: body.model,
+                                stream: body.stream === true,
+                                toolCount: body.tools?.length ?? 0,
+                                account: "",
+                                accountType: "openai-bridge",
+                                responseStatus: 502,
+                                responseTimeMs: Date.now() - requestStartTime,
+                                errorType: "loopback_exception",
+                                errorMessage: internalDetail,
+                            });
+                            return buildOpenAIErrorResponse(502, "Anthropic loopback failed");
+                        }
+                    }
+                    // --- Parse request ---
+                    const parsed = parseOpenAIRequest(body);
+                    // --- Build translation plan ---
+                    const adapted = adaptForTranslationPlan(parsed);
+                    const plan = buildProxyTranslationPlan({
+                        provider: targetProvider ?? "auto",
+                        model: targetModel,
+                    }, modelRouter?.getFallbackChain() ?? [], body.model, 
+                    // The classifier only reads fields present on both types.
+                    adapted);
+                    const attempts = plan.attempts;
+                    // --- Optional tracing ---
+                    let tracer;
+                    try {
+                        tracer = ProxyTracer.startRequest({
+                            requestId: ctx.requestId,
+                            method: ctx.method,
+                            path: ctx.path,
+                            model: body.model,
+                            stream: body.stream === true,
+                            toolCount: Object.keys(parsed.tools).length,
+                            clientApp: "openai-compat",
+                            userAgent: ctx.headers["user-agent"] ?? "",
+                        }, ctx.headers);
+                        tracer.setMode("full");
+                    }
+                    catch {
+                        // Tracing is best-effort; continue without it.
+                    }
+                    // --- Dispatch via shared translation engine ---
+                    try {
+                        if (body.stream) {
+                            return handleTranslatedStreamRequest({
+                                ctx,
+                                format: "openai",
+                                requestModel: body.model,
+                                parsed,
+                                attempts,
+                                tracer,
+                                requestStartTime,
+                            });
+                        }
+                        return await handleTranslatedJsonRequest({
+                            ctx,
+                            format: "openai",
+                            requestModel: body.model,
+                            parsed,
+                            attempts,
+                            tracer,
+                            requestStartTime,
+                        });
+                    }
+                    catch (err) {
+                        // Internal exception text is kept ONLY in server-side logs +
+                        // tracer. The client receives a fixed generic message so internal
+                        // paths/frames don't leak back through the response body.
+                        // (CodeQL: information exposure through a stack trace.)
+                        const rawMessage = err instanceof Error ? err.message : String(err);
+                        const internalDetail = sanitizeForLog(rawMessage);
+                        logger.always(`[proxy:openai] request failed: ${internalDetail}`);
+                        tracer?.setError("generation_error", internalDetail);
+                        tracer?.end(500, Date.now() - requestStartTime);
+                        return buildOpenAIErrorResponse(500, "Internal proxy error");
+                    }
+                },
+            },
+            // =================================================================
+            // GET /v1/models — List available models (OpenAI list format)
+            // =================================================================
+            {
+                method: "GET",
+                path: `${basePath}/v1/models`,
+                description: "List available models in OpenAI format",
+                handler: async () => {
+                    return buildModelsListResponse(modelRouter);
+                },
+            },
+        ],
+    };
+}

package/dist/tasks/tools/taskTools.d.ts

@@ -1,14 +1,5 @@
-/**
- * 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 type { TaskManager } from "../taskManager.js";
-import type { TaskSchedule } from "../../types/index.js";
+import type { Tool } from "../../types/index.js";
 /**
  * Create task management tools bound to a TaskManager instance.
  *
@@ -26,110 +17,4 @@ import type { TaskSchedule } from "../../types/index.js";
  * // tools.createTask, tools.listTasks, tools.getTaskRuns, etc.
  * ```
  */
-export declare function createTaskTools(manager: TaskManager): {
-    createTask: import("ai").Tool<{
-        name: string;
-        prompt: string;
-        schedule: {
-            type: "once" | "cron" | "interval";
-            expression?: string | undefined;
-            timezone?: string | undefined;
-            every?: number | undefined;
-            at?: string | undefined;
-        };
-        mode?: "isolated" | "continuation" | undefined;
-    }, {
-        success: boolean;
-        taskId: string;
-        name: string;
-        status: import("../../index.js").TaskStatus;
-        mode: import("../../index.js").TaskExecutionMode;
-        nextRunAt: string | undefined;
-        schedule: TaskSchedule;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        taskId?: undefined;
-        name?: undefined;
-        status?: undefined;
-        mode?: undefined;
-        nextRunAt?: undefined;
-        schedule?: undefined;
-    }>;
-    listTasks: import("ai").Tool<{
-        status?: "failed" | "pending" | "completed" | "cancelled" | "active" | "paused" | undefined;
-    }, {
-        success: boolean;
-        count: number;
-        tasks: {
-            taskId: string;
-            name: string;
-            status: import("../../index.js").TaskStatus;
-            mode: import("../../index.js").TaskExecutionMode;
-            schedule: TaskSchedule;
-            runCount: number;
-            lastRunAt: string | undefined;
-            nextRunAt: string | undefined;
-        }[];
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        count?: undefined;
-        tasks?: undefined;
-    }>;
-    getTaskRuns: import("ai").Tool<{
-        taskId: string;
-        limit?: number | undefined;
-    }, {
-        success: boolean;
-        taskId: string;
-        count: number;
-        runs: {
-            runId: string;
-            status: "error" | "success";
-            output: string | undefined;
-            durationMs: number;
-            timestamp: string;
-            error: string | undefined;
-        }[];
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        taskId?: undefined;
-        count?: undefined;
-        runs?: undefined;
-    }>;
-    deleteTask: import("ai").Tool<{
-        taskId: string;
-    }, {
-        success: boolean;
-        error: string;
-        deletedTask?: undefined;
-        taskId?: undefined;
-    } | {
-        success: boolean;
-        deletedTask: string;
-        taskId: string;
-        error?: undefined;
-    }>;
-    runTaskNow: import("ai").Tool<{
-        taskId: string;
-    }, {
-        success: boolean;
-        runId: string;
-        status: "error" | "success";
-        output: string | undefined;
-        durationMs: number;
-        error: string | undefined;
-    } | {
-        success: boolean;
-        error: string;
-        runId?: undefined;
-        status?: undefined;
-        output?: undefined;
-        durationMs?: undefined;
-    }>;
-};
+export declare function createTaskTools(manager: TaskManager): Record<string, Tool>;

package/dist/tasks/tools/taskTools.js

@@ -1,16 +1,7 @@
-/**
- * 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";
+import { tool } from "../../utils/tool.js";
 /**
  * Parse a schedule object from tool input.
  * Accepts: { type: "cron", expression } | { type: "interval", every } | { type: "once", at }

package/dist/types/aliases.d.ts

@@ -3,9 +3,9 @@
  * Centralizes commonly used complex types to improve readability and maintainability
  */
 import type { ZodTypeAny } from "zod";
-import type { Schema } from "ai";
 import type { JsonValue, Result, AsyncFunction } from "./common.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import type { Schema } from "./tools.js";
 /**
  * Type alias for complex Zod schema type to improve readability
  * Used across providers and validation systems

package/dist/types/conversation.d.ts

@@ -34,6 +34,7 @@
  */
 import type { HippocampusMemory, HippocampusStorageConfig } from "./memory.js";
 import type { ObservabilityConfig } from "./observability.js";
+export type { ModelMessage, SystemModelMessage, UserModelMessage, AssistantModelMessage, ToolModelMessage, TextPart, ImagePart, FilePart, ToolCallPart, ToolResultPart, AssistantContent, UserContent, ToolContent, DataContent, } from "ai";
 /**
  * Legacy public alias for the Hippocampus storage configuration.
  * The structural definition lives in `./memory.ts`; this re-export keeps

package/dist/types/evaluation.d.ts

@@ -1,13 +1,9 @@
-/**
- * Evaluation type definitions for NeuroLink
- * Provider performance tracking, evaluation configurations, and provider optimization types
- */
-import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
 import type { TokenUsage } from "./analytics.js";
 import type { GenerateResult } from "./generate.js";
 import type { ToolExecution } from "./tools.js";
 import type { JsonObject } from "./common.js";
 import type { AggregatedScores, EvaluationTraceContext, PipelineConfig, ReportConfig, ReportFormat, ScoreResult, ScorerInput } from "./scorer.js";
+import type { LanguageModelV3CallOptions } from "./middleware.js";
 /**
  * Evaluation provider type as specified in core module refactoring
  */

package/dist/types/evaluation.js

@@ -1,5 +1 @@
-/**
- * Evaluation type definitions for NeuroLink
- * Provider performance tracking, evaluation configurations, and provider optimization types
- */
 export {};

package/dist/types/generate.d.ts

@@ -1,4 +1,3 @@
-import type { Schema, Tool, ToolChoice, StepResult, LanguageModel } from "ai";
 import type { AIProviderName } from "../constants/enums.js";
 import type { RAGConfig } from "./rag.js";
 import type { AnalyticsData, TokenUsage } from "./analytics.js";
@@ -17,6 +16,8 @@ import type { StandardRecord, ValidationSchema, ZodUnknownSchema } from "./alias
 import type { NeurolinkCredentials } from "./providers.js";
 import type { FileWithMetadata } from "./file.js";
 import type { WorkflowConfig } from "./workflow.js";
+import type { Schema, Tool, ToolChoice } from "./tools.js";
+import type { StepResult, LanguageModel } from "./providers.js";
 /**
  * Generate function options type - Primary method for content generation
  * Supports multimodal content while maintaining backward compatibility
@@ -467,17 +468,6 @@ export type GenerateOptions = {
      * callers can correlate generation traces back to their own request lifecycle.
      */
     requestId?: string;
-    /**
-     * File reference registry for on-demand file processing.
-     *
-     * When set, files above the "tiny" size tier (>10KB) will be registered
-     * as lightweight references instead of being fully loaded into the prompt.
-     * The LLM can then access file content on-demand via file tools
-     * (list_attached_files, read_file_section, search_in_file).
-     *
-     * @internal Set by NeuroLink SDK — not typically used directly by consumers.
-     */
-    fileRegistry?: unknown;
     /** Per-call middleware configuration. */
     middleware?: MiddlewareFactoryOptions;
     /** Callback invoked when generation completes successfully. */
@@ -988,16 +978,6 @@ export type TextGenerationOptions = {
         includeHeaders?: boolean;
     };
     enableSummarization?: boolean;
-    /**
-     * File reference registry for on-demand file processing (internal).
-     *
-     * When set, files above the "tiny" size tier (>10KB) will be registered
-     * as lightweight references instead of being fully loaded into the prompt.
-     * The LLM can then access file content on-demand via file tools.
-     *
-     * @internal Set by NeuroLink SDK — not typically used directly by consumers.
-     */
-    fileRegistry?: unknown;
     /**
      * Skip injecting tool schemas into the system prompt.
      * When true, tools are ONLY passed natively via the provider's `tools` parameter,

package/dist/types/guardrails.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageModel } from "ai";
+import type { LanguageModel } from "./providers.js";
 /**
  * Result from precall evaluation of user input
  */

package/dist/types/middleware.d.ts

@@ -1,7 +1,12 @@
-import type { LanguageModelMiddleware } from "ai";
 import type { JsonValue } from "../types/common.js";
 import type { EvaluationData, GetPromptFunction } from "./evaluation.js";
 import type { AuthenticatedUser, RouteDefinition, ServerContext } from "./server.js";
+import type { LanguageModelMiddleware as BaseLanguageModelMiddleware } from "ai";
+export type { LanguageModelMiddleware } from "ai";
+export type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3Message, LanguageModelV3StreamPart, LanguageModelV3ToolCall, LanguageModelV3ToolChoice, LanguageModelV3Source, LanguageModelV3Middleware, JSONSchema7, } from "@ai-sdk/provider";
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+export type LanguageModelV3GenerateResult = Awaited<ReturnType<LanguageModelV3["doGenerate"]>>;
+export type LanguageModelV3StreamResult = Awaited<ReturnType<LanguageModelV3["doStream"]>>;
 /**
  * Metadata type for NeuroLink middleware
  * Provides additional information about middleware without affecting execution
@@ -24,7 +29,7 @@ export type NeuroLinkMiddlewareMetadata = {
  * NeuroLink middleware with metadata
  * Combines standard AI SDK middleware with NeuroLink-specific metadata
  */
-export type NeuroLinkMiddleware = LanguageModelMiddleware & {
+export type NeuroLinkMiddleware = BaseLanguageModelMiddleware & {
     /** Middleware metadata */
     readonly metadata: NeuroLinkMiddlewareMetadata;
 };
@@ -192,7 +197,7 @@ export type MiddlewareRegistryEntry = {
 /**
  * Middleware factory function type
  */
-export type MiddlewareFactory = (config: Record<string, unknown>) => LanguageModelMiddleware;
+export type MiddlewareFactory = (config: Record<string, unknown>) => BaseLanguageModelMiddleware;
 /**
  * Middleware validation result
  */

package/dist/types/providers.d.ts

@@ -4,12 +4,13 @@
 import type { UnknownRecord, JsonValue, StreamingCapability } from "./common.js";
 import type { ProviderError } from "./errors.js";
 import { AIProviderName, AnthropicModels, BedrockModels, DeepSeekModels, GoogleAIModels, LlamaCppModels, LMStudioModels, NvidiaNimModels, OpenAIModels, VertexModels } from "../constants/enums.js";
-import type { Tool } from "ai";
 import type { ValidationSchema } from "./aliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
 import type { StreamOptions, StreamResult } from "./stream.js";
 import type { ExternalMCPToolInfo } from "./externalMcp.js";
 import type { ClaudeSubscriptionTier, AnthropicAuthMethod, AnthropicAuthConfig, SubscriptionInfo, OAuthToken } from "./subscription.js";
+import type { Tool } from "./tools.js";
+export type { LanguageModel, EmbeddingModel, ImageModel, GenerateTextResult, StepResult, ToolCallRepairFunction, PrepareStepFunction, PrepareStepResult, FinishReason, LanguageModelUsage, LanguageModelRequestMetadata, LanguageModelResponseMetadata, } from "ai";
 export type { ClaudeSubscriptionTier, AnthropicAuthMethod, AnthropicAuthConfig, SubscriptionInfo, } from "./subscription.js";
 /**
  * Generic AI SDK model interface