@juspay/neurolink 12.11.2 → 12.12.0

package/dist/types/tools.d.ts

@@ -9,8 +9,8 @@ import type { ValidationError } from "../utils/parameterValidation.js";
 import type { MCPToolAnnotations } from "./mcp.js";
 import type { Logger } from "./utilities.js";
 import type { HITLExecutionState } from "./hitl.js";
-import type { Tool } from "ai";
-export type { Tool, ToolSet, ToolChoice, ToolCallOptions, ToolExecuteFunction, ToolApprovalRequest, ToolApprovalResponse, InferToolInput, InferToolOutput, Schema, FlexibleSchema, InferSchema, } from "ai";
+import type { Tool } from "./aiCompat.js";
+export type { Tool, ToolSet, ToolChoice, ToolExecuteFunction, ToolApprovalRequest, ToolApprovalResponse, InferToolInput, InferToolOutput, Schema, FlexibleSchema, InferSchema, } from "./aiCompat.js";
 /**
  * Commonly used Zod schema type aliases for cleaner type declarations
  */
@@ -87,6 +87,12 @@ export type ToolInfo = {
     /** Per-tool timeout in milliseconds, set at registration time */
     timeoutMs?: number;
     maxRetries?: number;
+    /**
+     * Ceiling on the WHOLE execution — every attempt plus the delays between
+     * them. Declared explicitly rather than left to the index signature below,
+     * which would type it `unknown` and silently defeat the default.
+     */
+    totalTimeoutMs?: number;
     [key: string]: unknown;
 };
 /**
@@ -103,6 +109,13 @@ export type ToolImplementation = {
     /** Per-tool timeout in milliseconds, set at registration time */
     timeoutMs?: number;
     maxRetries?: number;
+    /**
+     * Ceiling on the WHOLE execution — every attempt plus the delays between
+     * them — in milliseconds. `timeoutMs` bounds one attempt; without this, a
+     * tool that reliably hangs burns `timeoutMs * (maxRetries + 1)`.
+     * Defaults to exactly that product, so behaviour is unchanged unless set.
+     */
+    totalTimeoutMs?: number;
 };
 /**
  * Tool execution options for enhanced control
@@ -130,6 +143,13 @@ export type ToolExecutionOptions = {
      */
     timeoutMs?: number;
     maxRetries?: number;
+    /**
+     * Ceiling on the WHOLE execution — every attempt plus the delays between
+     * them. `timeout` bounds one attempt. Defaults to
+     * `timeout * (maxRetries + 1)`, which is what the retry loop already spent,
+     * so supplying nothing changes nothing.
+     */
+    totalTimeoutMs?: number;
 };
 /**
  * Options for tool registration via registerTool()
@@ -153,6 +173,9 @@ export type ToolRegistrationOptions = {
      *  When omitted, the SDK's global default (2 retries) is used.
      *  Set to 0 to disable retries for this tool. */
     maxRetries?: number;
+    /** Ceiling on the whole execution across every attempt and the delays
+     *  between them. When omitted, `timeout * (maxRetries + 1)` is used. */
+    totalTimeoutMs?: number;
     /**
      * Whether this tool's result may be served from the tool-result cache
      * (default true).

package/dist/utils/errorHandling.d.ts

@@ -108,9 +108,26 @@ export declare class ErrorFactory {
      */
     static toolExecutionFailed(toolName: string, originalError: Error, serverId?: string): NeuroLinkError;
     /**
-     * Create a tool timeout error
-     */
-    static toolTimeout(toolName: string, timeoutMs: number, serverId?: string): NeuroLinkError;
+     * Create a tool timeout error.
+     *
+     * `timeoutMs` is the bound that was actually exceeded. Pass `budget` when
+     * the timeout happened inside a retry loop, so the error can say which
+     * number it is reporting: a reader who sees `timeoutMs: 120000` next to an
+     * `executionTime` of 483005 will otherwise conclude the timeout was never
+     * enforced, when in fact four attempts of 120s each were.
+     *
+     * `budget.exhausted` marks the case where the whole-execution ceiling ran
+     * out rather than a single attempt overrunning; that error is NOT retriable,
+     * because there is no budget left to retry into.
+     */
+    static toolTimeout(toolName: string, timeoutMs: number, serverId?: string, budget?: {
+        attempt?: number;
+        maxAttempts?: number;
+        attemptTimeoutMs?: number;
+        totalTimeoutMs?: number;
+        elapsedMs?: number;
+        exhausted?: boolean;
+    }): NeuroLinkError;
     /**
      * Create a parameter validation error
      */

package/dist/utils/errorHandling.js

@@ -164,16 +164,33 @@ export class ErrorFactory {
         });
     }
     /**
-     * Create a tool timeout error
+     * Create a tool timeout error.
+     *
+     * `timeoutMs` is the bound that was actually exceeded. Pass `budget` when
+     * the timeout happened inside a retry loop, so the error can say which
+     * number it is reporting: a reader who sees `timeoutMs: 120000` next to an
+     * `executionTime` of 483005 will otherwise conclude the timeout was never
+     * enforced, when in fact four attempts of 120s each were.
+     *
+     * `budget.exhausted` marks the case where the whole-execution ceiling ran
+     * out rather than a single attempt overrunning; that error is NOT retriable,
+     * because there is no budget left to retry into.
      */
-    static toolTimeout(toolName, timeoutMs, serverId) {
+    static toolTimeout(toolName, timeoutMs, serverId, budget) {
+        const scope = budget?.exhausted
+            ? `exhausted its ${budget.totalTimeoutMs}ms total budget`
+            : budget?.maxAttempts && budget.maxAttempts > 1
+                ? `timed out after ${timeoutMs}ms on attempt ${budget.attempt ?? 1} of ${budget.maxAttempts}`
+                : `timed out after ${timeoutMs}ms`;
         return new NeuroLinkError({
             code: ERROR_CODES.TOOL_TIMEOUT,
-            message: `Tool '${toolName}' timed out after ${timeoutMs}ms`,
+            message: `Tool '${toolName}' ${scope}`,
             category: ErrorCategory.TIMEOUT,
             severity: ErrorSeverity.HIGH,
-            retriable: true,
-            context: { timeoutMs },
+            // A single attempt timing out is worth another try; an exhausted total
+            // budget is not — retrying it can only overshoot the caller's ceiling.
+            retriable: budget?.exhausted !== true,
+            context: { timeoutMs, ...(budget ?? {}) },
             toolName,
             serverId,
         });

package/dist/utils/generationErrors.d.ts

@@ -1,10 +1,82 @@
 /**
  * Error classes surfaced by the generation pipeline.
  *
- * Used with `.isInstance(e)` checks and instanceof guards in retry,
- * tool-call repair, and stream handling. Today these resolve through the
- * upstream generation library; this file is the only internal source so the
- * implementation can be replaced without touching call sites.
+ * These used to be re-exported from the `ai` package. They are now declared
+ * here, because every path that threw them upstream is gone: generation is
+ * native end to end, and the only one this repo still constructs is
+ * NoOutputGeneratedError.
+ *
+ * The marker symbols are deliberately identical to the upstream ones
+ * (`Symbol.for("vercel.ai.error.<name>")`). `isInstance` is a marker check, not
+ * an `instanceof`, precisely so it survives across duplicate module copies —
+ * and keeping the same symbol means an error raised by any remaining upstream
+ * code is still recognised by these classes, and vice versa. Switching to a
+ * private symbol would have silently broken that recognition at exactly the
+ * points that matter: retry classification and the no-output sentinel.
+ */
+/** Base for the generation errors; stamps the upstream-compatible marker. */
+declare class GenerationError extends Error {
+    readonly cause?: unknown;
+    constructor(markerName: string, message: string, cause?: unknown);
+}
+export declare class NoOutputGeneratedError extends GenerationError {
+    constructor(options?: {
+        message?: string;
+        cause?: unknown;
+    });
+    static isInstance(error: unknown): error is NoOutputGeneratedError;
+}
+export declare class NoObjectGeneratedError extends GenerationError {
+    readonly text?: string;
+    readonly finishReason?: string;
+    constructor(options?: {
+        message?: string;
+        cause?: unknown;
+        text?: string;
+        finishReason?: string;
+    });
+    static isInstance(error: unknown): error is NoObjectGeneratedError;
+}
+export declare class NoSuchToolError extends GenerationError {
+    readonly toolName?: string;
+    constructor(options?: {
+        message?: string;
+        toolName?: string;
+    });
+    static isInstance(error: unknown): error is NoSuchToolError;
+}
+export declare class InvalidToolInputError extends GenerationError {
+    readonly toolName?: string;
+    constructor(options?: {
+        message?: string;
+        toolName?: string;
+        cause?: unknown;
+    });
+    static isInstance(error: unknown): error is InvalidToolInputError;
+}
+/**
+ * Transport-level failure. This repo only ever CATCHES and classifies these —
+ * `providerRetry` and the error classifier duck-type `.statusCode` — so the
+ * class exists to keep those `isInstance` checks working for errors raised by
+ * the provider clients, which stamp the same marker.
  */
-export { NoOutputGeneratedError, NoObjectGeneratedError, NoSuchToolError, InvalidToolInputError, } from "ai";
-export { APICallError } from "@ai-sdk/provider";
+export declare class APICallError extends GenerationError {
+    readonly url?: string;
+    readonly statusCode?: number;
+    readonly responseBody?: string;
+    readonly responseHeaders?: Record<string, string>;
+    readonly isRetryable: boolean;
+    readonly requestBodyValues?: unknown;
+    constructor(options?: {
+        message?: string;
+        url?: string;
+        statusCode?: number;
+        responseBody?: string;
+        responseHeaders?: Record<string, string>;
+        isRetryable?: boolean;
+        requestBodyValues?: unknown;
+        cause?: unknown;
+    });
+    static isInstance(error: unknown): error is APICallError;
+}
+export {};

package/dist/utils/generationErrors.js

@@ -1,10 +1,118 @@
 /**
  * Error classes surfaced by the generation pipeline.
  *
- * Used with `.isInstance(e)` checks and instanceof guards in retry,
- * tool-call repair, and stream handling. Today these resolve through the
- * upstream generation library; this file is the only internal source so the
- * implementation can be replaced without touching call sites.
+ * These used to be re-exported from the `ai` package. They are now declared
+ * here, because every path that threw them upstream is gone: generation is
+ * native end to end, and the only one this repo still constructs is
+ * NoOutputGeneratedError.
+ *
+ * The marker symbols are deliberately identical to the upstream ones
+ * (`Symbol.for("vercel.ai.error.<name>")`). `isInstance` is a marker check, not
+ * an `instanceof`, precisely so it survives across duplicate module copies —
+ * and keeping the same symbol means an error raised by any remaining upstream
+ * code is still recognised by these classes, and vice versa. Switching to a
+ * private symbol would have silently broken that recognition at exactly the
+ * points that matter: retry classification and the no-output sentinel.
+ */
+const markerSymbolFor = (name) => Symbol.for(`vercel.ai.error.${name}`);
+const hasMarker = (error, name) => {
+    const marker = markerSymbolFor(name);
+    return (error !== null &&
+        typeof error === "object" &&
+        marker in error &&
+        error[marker] === true);
+};
+/** Base for the generation errors; stamps the upstream-compatible marker. */
+class GenerationError extends Error {
+    cause;
+    constructor(markerName, message, cause) {
+        super(message);
+        this.name = markerName;
+        if (cause !== undefined) {
+            this.cause = cause;
+        }
+        Object.defineProperty(this, markerSymbolFor(markerName), {
+            value: true,
+            enumerable: false,
+            writable: false,
+        });
+    }
+}
+export class NoOutputGeneratedError extends GenerationError {
+    constructor(options = {}) {
+        super("AI_NoOutputGeneratedError", options.message ?? "No output generated.", options.cause);
+    }
+    static isInstance(error) {
+        return hasMarker(error, "AI_NoOutputGeneratedError");
+    }
+}
+export class NoObjectGeneratedError extends GenerationError {
+    text;
+    finishReason;
+    constructor(options = {}) {
+        super("AI_NoObjectGeneratedError", options.message ?? "No object generated.", options.cause);
+        this.text = options.text;
+        this.finishReason = options.finishReason;
+    }
+    static isInstance(error) {
+        return hasMarker(error, "AI_NoObjectGeneratedError");
+    }
+}
+export class NoSuchToolError extends GenerationError {
+    toolName;
+    constructor(options = {}) {
+        super("AI_NoSuchToolError", options.message ??
+            `Model tried to call unavailable tool '${options.toolName ?? "unknown"}'.`);
+        this.toolName = options.toolName;
+    }
+    static isInstance(error) {
+        return hasMarker(error, "AI_NoSuchToolError");
+    }
+}
+export class InvalidToolInputError extends GenerationError {
+    toolName;
+    constructor(options = {}) {
+        super("AI_InvalidToolInputError", options.message ??
+            `Invalid input for tool '${options.toolName ?? "unknown"}'.`, options.cause);
+        this.toolName = options.toolName;
+    }
+    static isInstance(error) {
+        return hasMarker(error, "AI_InvalidToolInputError");
+    }
+}
+/**
+ * Transport-level failure. This repo only ever CATCHES and classifies these —
+ * `providerRetry` and the error classifier duck-type `.statusCode` — so the
+ * class exists to keep those `isInstance` checks working for errors raised by
+ * the provider clients, which stamp the same marker.
  */
-export { NoOutputGeneratedError, NoObjectGeneratedError, NoSuchToolError, InvalidToolInputError, } from "ai";
-export { APICallError } from "@ai-sdk/provider";
+export class APICallError extends GenerationError {
+    url;
+    statusCode;
+    responseBody;
+    responseHeaders;
+    isRetryable;
+    requestBodyValues;
+    constructor(options = {}) {
+        super("AI_APICallError", options.message ?? "API call error.", options.cause);
+        this.url = options.url;
+        this.statusCode = options.statusCode;
+        this.responseBody = options.responseBody;
+        this.responseHeaders = options.responseHeaders;
+        // Upstream derives this from the status code when the caller does not say,
+        // and `providerRetry` reads it as a plain boolean — leaving it undefined
+        // would make every classified APICallError non-retryable by accident.
+        this.isRetryable =
+            options.isRetryable ??
+                (options.statusCode !== null &&
+                    options.statusCode !== undefined &&
+                    (options.statusCode === 408 ||
+                        options.statusCode === 409 ||
+                        options.statusCode === 429 ||
+                        options.statusCode >= 500));
+        this.requestBodyValues = options.requestBodyValues;
+    }
+    static isInstance(error) {
+        return hasMarker(error, "AI_APICallError");
+    }
+}

package/dist/utils/mcpDefaults.d.ts

@@ -37,7 +37,7 @@ export declare function createMCPServerInfo(options: {
  * Create MCPServerInfo for custom tool registration
  * Specialized version with smart defaults for registerTool usage
  */
-export declare function createCustomToolServerInfo(toolName: string, tool: MCPExecutableTool, timeoutMs?: number, maxRetries?: number): MCPServerInfo;
+export declare function createCustomToolServerInfo(toolName: string, tool: MCPExecutableTool, timeoutMs?: number, maxRetries?: number, totalTimeoutMs?: number): MCPServerInfo;
 /**
  * Create MCPServerInfo for external servers
  * Specialized version with smart defaults for external server usage

package/dist/utils/mcpDefaults.js

@@ -93,7 +93,7 @@ export function createMCPServerInfo(options) {
  * Create MCPServerInfo for custom tool registration
  * Specialized version with smart defaults for registerTool usage
  */
-export function createCustomToolServerInfo(toolName, tool, timeoutMs, maxRetries) {
+export function createCustomToolServerInfo(toolName, tool, timeoutMs, maxRetries, totalTimeoutMs) {
     const serverInfo = createMCPServerInfo({
         id: `custom-tool-${toolName}`,
         name: toolName,
@@ -112,6 +112,9 @@ export function createCustomToolServerInfo(toolName, tool, timeoutMs, maxRetries
         if (maxRetries !== undefined) {
             serverInfo.metadata.toolMaxRetries = maxRetries;
         }
+        if (totalTimeoutMs !== undefined) {
+            serverInfo.metadata.toolTotalTimeoutMs = totalTimeoutMs;
+        }
     }
     return serverInfo;
 }

package/dist/utils/nativeSingleShot.d.ts

@@ -0,0 +1,3 @@
+/** One no-tool turn against a provider's delegating model, without ai's loop. */
+import type { SingleShotRequest, SingleShotResult } from "../types/index.js";
+export declare function generateOnceNative(model: unknown, request: SingleShotRequest): Promise<SingleShotResult>;

package/dist/utils/nativeSingleShot.js

@@ -0,0 +1,83 @@
+const hasDoGenerate = (value) => typeof value === "object" &&
+    value !== null &&
+    typeof value.doGenerate === "function";
+/**
+ * v3 reports `inputTokens` / `outputTokens` as objects carrying a `total`,
+ * while `SingleShotResult` — and `extractTokenUsage` downstream — accept only
+ * numbers. Passing the nested shape straight through recorded 0/0/0 for every
+ * caller of this helper, which is the whole of the video-frame formatting
+ * path's usage accounting.
+ */
+const readCount = (value) => {
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "object" &&
+        value !== null &&
+        typeof value.total === "number") {
+        return value.total;
+    }
+    return undefined;
+};
+const normalizeUsage = (usage) => {
+    if (typeof usage !== "object" || usage === null) {
+        return undefined;
+    }
+    const shaped = usage;
+    const input = readCount(shaped.inputTokens);
+    const output = readCount(shaped.outputTokens);
+    if (input === undefined && output === undefined) {
+        return undefined;
+    }
+    return {
+        inputTokens: input ?? 0,
+        outputTokens: output ?? 0,
+        totalTokens: (input ?? 0) + (output ?? 0),
+    };
+};
+const textFromContent = (content) => Array.isArray(content)
+    ? content
+        .filter((part) => typeof part === "object" &&
+        part !== null &&
+        part.type === "text" &&
+        typeof part.text === "string")
+        .map((part) => part.text)
+        .join("")
+    : typeof content === "string"
+        ? content
+        : "";
+export async function generateOnceNative(model, request) {
+    if (!hasDoGenerate(model)) {
+        throw new Error("generateOnceNative: model handle exposes no doGenerate()");
+    }
+    const prompt = [];
+    if (request.system) {
+        prompt.push({ role: "system", content: request.system });
+    }
+    prompt.push({
+        role: "user",
+        content: [{ type: "text", text: request.prompt }],
+    });
+    const raw = await model.doGenerate({
+        prompt,
+        ...(request.maxOutputTokens
+            ? { maxOutputTokens: request.maxOutputTokens }
+            : {}),
+        ...(request.temperature !== undefined
+            ? { temperature: request.temperature }
+            : {}),
+        ...(request.abortSignal ? { abortSignal: request.abortSignal } : {}),
+    });
+    const shaped = raw;
+    return {
+        text: typeof shaped.text === "string"
+            ? shaped.text
+            : textFromContent(shaped.content),
+        ...(normalizeUsage(shaped.usage)
+            ? { usage: normalizeUsage(shaped.usage) }
+            : {}),
+        ...(typeof shaped.finishReason === "string"
+            ? { finishReason: shaped.finishReason }
+            : {}),
+    };
+}

package/dist/utils/tool.d.ts

@@ -1,8 +1,33 @@
 /**
- * Tool definition helpers + structured-output spec.
+ * Tool and schema primitives.
  *
- * Today these resolve through the upstream generation library; this file is
- * the only internal source for them so the implementation can be replaced
- * without touching call sites.
+ * These were re-exported from the `ai` package. They are implemented here now,
+ * against the local type algebra in `types/aiCompat.ts`. The function and the
+ * type had to move together: replacing `tool()` alone leaves it producing an
+ * upstream `Tool` that no longer matches the local one, which is how the first
+ * attempt failed.
+ *
+ * Upstream behaviour, reproduced exactly:
+ *   - `tool()` is identity. It exists for inference, not for runtime.
+ *   - `jsonSchema()` wraps a raw JSON Schema in the duck-typed shape the rest of
+ *     this repo reads — `convertZodToJsonSchema` looks for the `jsonSchema`
+ *     property, not for the brand — and still stamps
+ *     `Symbol.for("vercel.ai.schema")` so anything that does check it keeps
+ *     working.
+ *   - `stepCountIs(n)` returns `({steps}) => steps.length === n`.
  */
-export { tool, jsonSchema, Output, stepCountIs } from "ai";
+import type { JSONSchema7, Schema, Tool } from "../types/index.js";
+export declare function tool<INPUT, OUTPUT>(definition: Tool<INPUT, OUTPUT>): Tool<INPUT, OUTPUT>;
+export declare function tool<INPUT>(definition: Tool<INPUT, never>): Tool<INPUT, never>;
+export declare function jsonSchema<OBJECT = unknown>(schema: JSONSchema7 | (() => JSONSchema7), options?: {
+    validate?: (value: unknown) => {
+        success: true;
+        value: OBJECT;
+    } | {
+        success: false;
+        error: unknown;
+    };
+}): Schema<OBJECT>;
+export declare const stepCountIs: (stepCount: number) => ({ steps }: {
+    steps: unknown[];
+}) => boolean;

package/dist/utils/tool.js

@@ -1,8 +1,46 @@
 /**
- * Tool definition helpers + structured-output spec.
+ * Tool and schema primitives.
  *
- * Today these resolve through the upstream generation library; this file is
- * the only internal source for them so the implementation can be replaced
- * without touching call sites.
+ * These were re-exported from the `ai` package. They are implemented here now,
+ * against the local type algebra in `types/aiCompat.ts`. The function and the
+ * type had to move together: replacing `tool()` alone leaves it producing an
+ * upstream `Tool` that no longer matches the local one, which is how the first
+ * attempt failed.
+ *
+ * Upstream behaviour, reproduced exactly:
+ *   - `tool()` is identity. It exists for inference, not for runtime.
+ *   - `jsonSchema()` wraps a raw JSON Schema in the duck-typed shape the rest of
+ *     this repo reads — `convertZodToJsonSchema` looks for the `jsonSchema`
+ *     property, not for the brand — and still stamps
+ *     `Symbol.for("vercel.ai.schema")` so anything that does check it keeps
+ *     working.
+ *   - `stepCountIs(n)` returns `({steps}) => steps.length === n`.
  */
-export { tool, jsonSchema, Output, stepCountIs } from "ai";
+const SCHEMA_MARKER = Symbol.for("vercel.ai.schema");
+/* eslint-disable no-redeclare, @typescript-eslint/no-explicit-any --
+   TypeScript overload implementation signature. It must be assignable from
+   both exported overloads above, which only `any` expresses; the exported
+   signatures themselves stay precise. */
+export function tool(definition) {
+    return definition;
+}
+/* eslint-enable no-redeclare, @typescript-eslint/no-explicit-any */
+export function jsonSchema(schema, options = {}) {
+    let resolved = schema;
+    const wrapper = {
+        [SCHEMA_MARKER]: true,
+        _type: undefined,
+        get jsonSchema() {
+            if (typeof resolved === "function") {
+                resolved = resolved();
+            }
+            return resolved;
+        },
+        ...(options.validate ? { validate: options.validate } : {}),
+    };
+    return wrapper;
+}
+export const stepCountIs = (stepCount) => ({ steps }) => steps.length === stepCount;
+// `Output` still comes from the upstream package: its only consumer is the
+// GenerationHandler path that the native provider loops made unreachable, and
+// that whole path is removed in a following change rather than kept alive here.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.11.2",
+  "version": "12.12.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -110,6 +110,7 @@
     "test:matrix:cli": "pnpm exec tsx test/continuous-test-suite-provider-matrix-cli.ts",
     "test:mcp:spans": "pnpm exec tsx test/continuous-test-suite-mcp-spans.ts",
     "test:mcp:infra": "pnpm exec tsx test/continuous-test-suite-mcp-infra.ts",
+    "test:vendor-recovery": "pnpm exec tsx test/continuous-test-suite-native-vendor-recovery.ts",
     "test:providers-mocked": "pnpm exec tsx test/continuous-test-suite-providers-mocked.ts",
     "scaffold:provider": "pnpm exec tsx tools/scaffold-provider.ts",
     "verify:provider-onboarding": "pnpm exec tsx tools/verify-provider-onboarding.ts",
@@ -360,10 +361,6 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.50",
-    "@ai-sdk/mistral": "^3.0.21",
-    "@ai-sdk/openai": "^3.0.37",
-    "@ai-sdk/provider": "^3.0.8",
     "@anthropic-ai/sdk": "^0.102.0",
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@aws-sdk/types": "^3.862.0",
@@ -381,8 +378,8 @@
     "@opentelemetry/sdk-metrics": "^2.6.1",
     "@opentelemetry/sdk-trace-base": "^2.6.0",
     "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@types/json-schema": "^7.0.15",
     "adm-zip": "^0.6.0",
-    "ai": "^6.0.134",
     "chalk": "^5.6.2",
     "chardet": "2.1.1",
     "croner": "^9.1.0",

package/dist/utils/generation.d.ts

@@ -1,8 +0,0 @@
-/**
- * Generation, streaming, embedding, and middleware-composition primitives.
- *
- * Today these resolve through the upstream generation library; this file is
- * the only internal source so the implementation can be replaced without
- * touching call sites.
- */
-export { generateText, streamText, generateObject, streamObject, embed, embedMany, wrapLanguageModel, experimental_transcribe, } from "ai";

package/dist/utils/generation.js

@@ -1,8 +0,0 @@
-/**
- * Generation, streaming, embedding, and middleware-composition primitives.
- *
- * Today these resolve through the upstream generation library; this file is
- * the only internal source so the implementation can be replaced without
- * touching call sites.
- */
-export { generateText, streamText, generateObject, streamObject, embed, embedMany, wrapLanguageModel, experimental_transcribe, } from "ai";