@dbos-inc/vercel-ai 0.1.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DBOS, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,212 @@
+# @dbos-inc/vercel-ai
+
+[DBOS](https://docs.dbos.dev/) durable execution for the [Vercel AI SDK](https://ai-sdk.dev/).
+
+This package makes AI SDK **agents** durable, backed by your Postgres database.
+All you have to do is wrap your model with `durableCalls` and run your generation inside a DBOS workflow.
+Then, this integration automatically checkpoints every action your agents take in Postgres.
+If your process crashes mid-agent, DBOS replays the completed steps from their checkpoints and the agent resumes exactly where it left off.
+
+This package is implemented as standard AI SDK [middleware](https://ai-sdk.dev/docs/ai-sdk-core/middleware), so you keep your provider, your model configuration, and the familiar APIs like `generateText`, `streamText`, and `ToolLoopAgent`.
+Durability is transparent to your agent code.
+
+```ts
+import { DBOS } from '@dbos-inc/dbos-sdk';
+import { generateText, wrapLanguageModel } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { durableCalls } from '@dbos-inc/vercel-ai';
+
+const model = wrapLanguageModel({
+  model: openai('gpt-5'),
+  middleware: durableCalls({ retriesAllowed: true, maxAttempts: 5 }),
+});
+
+const researchAgent = DBOS.registerWorkflow(
+  async (question: string) => {
+    const { text } = await generateText({
+      model,
+      prompt: question,
+      system: 'You are a helpful research assistant.',
+    });
+    return text;
+  },
+  { name: 'researchAgent' },
+);
+
+DBOS.setConfig({ name: 'my-agent', systemDatabaseUrl: process.env.DBOS_SYSTEM_DATABASE_URL });
+await DBOS.launch();
+
+console.log(await researchAgent('Why did the agent cross the road?'));
+```
+
+## Installation
+
+```sh
+npm install @dbos-inc/vercel-ai @dbos-inc/dbos-sdk ai
+```
+
+Requires AI SDK v7+ and a Postgres database for DBOS.
+
+## How it works
+
+When an agent runs inside a DBOS workflow, DBOS makes three things durable:
+
+- **Every model call.** `durableCalls()` is AI SDK middleware that intercepts `doGenerate`/`doStream` and runs each call through [`DBOS.runStep`](https://docs.dbos.dev/typescript/tutorials/step-tutorial). The complete result (content, usage, finish reason, response metadata) is checkpointed in Postgres. On recovery, completed calls replay from their checkpoints without contacting the model provider.
+- **The agent loop.** Because DBOS workflows replay deterministically on recovery and each model call replays from its checkpoint, a multi-step, tool-calling agent resumes from the first unfinished step instead of restarting from the beginning.
+- **Tool calls.** MCP tools (via [`durableMCPTools`](#mcp-tools)) are checkpointed automatically. Your own tools' side effects are durable when you wrap their `execute` in `DBOS.runStep` (see [Tools](#tools)).
+
+Outside a workflow (or inside another step) the wrapped model calls the provider directly with no checkpointing, so the same model works anywhere in your app.
+
+All DBOS step options are accepted and apply per model call:
+
+```ts
+durableCalls({
+  retriesAllowed: true,   // retry failed model calls (default: true)
+  maxAttempts: 5,         // total attempts when retries are allowed (default: 3)
+  intervalSeconds: 1,     // delay before first retry (default: 1)
+  backoffRate: 2,         // exponential backoff multiplier (default: 2)
+  shouldRetry: (error) => true,  // per-error retry predicate (default: skip provider-declared non-retryable errors and aborts)
+  timeoutMS: 60000,       // per-attempt timeout
+  name: 'my-model-call',  // step name (default: "<provider>.<modelId>.<operation>")
+});
+```
+
+Retries are on by default so that a transient provider error is absorbed inside a single durable step.
+The default `shouldRetry` treats errors the provider marks non-retryable (an AI SDK `APICallError`/`GatewayError` with `isRetryable === false`, e.g. a 401 or an invalid-request 400) and aborts/timeouts as terminal, so they fail fast instead of retrying `maxAttempts` times. 
+Pass your own `shouldRetry` to override it, or `retriesAllowed: false` to disable step retries.
+
+Because DBOS owns retries by default, pass `maxRetries: 0` to the AI SDK call so retry behavior is governed in one place; otherwise the two compose multiplicatively and each AI SDK retry is a fresh step.
+
+## Streaming
+
+You can stream durable model responses inside a workflow with `streamText`.
+During streaming, DBOS checkpoints only the final completed output, not individual deltas.
+As a consequence:
+
+- You can safely forward streamed deltas to a UI or terminal, but you should not perform durable steps on them because model responses are not resumable. Instead, run your own durable steps on the complete result (`result.text`) after the stream ends. Tool calls performed by the AI SDK during streaming are already durable because they execute after the model call has been checkpointed.
+- Do not exit a stream before it completes. To stop reading early, either drain the stream (`await result.consumeStream()`) or abort it.
+- To abort early, pass an `abortSignal` to `streamText` and fire it. The output streamed so far becomes the durable result for that model call.
+
+```ts
+import { streamText } from 'ai';
+import { durableCalls } from '@dbos-inc/vercel-ai';
+
+const model = wrapLanguageModel({
+  model: openai('gpt-5'),
+  middleware: durableCalls({ retriesAllowed: true, maxAttempts: 5 }),
+});
+
+const streamingAgent = DBOS.registerWorkflow(async (prompt: string) => {
+  const result = streamText({ model, prompt });
+  for await (const delta of result.textStream) {
+    process.stdout.write(delta);
+  }
+  return await result.text;
+}, { name: 'streamingAgent' });
+```
+
+## Tools
+
+Model calls in a tool-calling loop are each checkpointed individually, so a recovered agent resumes mid-loop.
+You should wrap your tool's `execute` in a DBOS step so it is checkpointed too.
+
+```ts
+import { tool, stepCountIs } from 'ai';
+import { z } from 'zod';
+
+const agent = DBOS.registerWorkflow(async (question: string) => {
+  const result = await generateText({
+    model,
+    prompt: question,
+    tools: {
+      getWeather: tool({
+        description: 'Get the weather for a city',
+        inputSchema: z.object({ city: z.string() }),
+        execute: ({ city }) => DBOS.runStep(() => fetchWeather(city), { name: 'getWeather' }),
+      }),
+    },
+    stopWhen: stepCountIs(10),
+  });
+  return result.text;
+}, { name: 'weatherAgent' });
+```
+
+### MCP tools
+
+`durableMCPTools` wraps an [MCP](https://modelcontextprotocol.io/) client (e.g. from [`@ai-sdk/mcp`](https://www.npmjs.com/package/@ai-sdk/mcp)) so both the tool listing and every tool call run as durable steps.
+Each tool call is checkpointed so recovery replays results instead of re-invoking the tool:
+
+```ts
+import { createMCPClient } from '@ai-sdk/mcp';
+import { durableMCPTools } from '@dbos-inc/vercel-ai';
+
+const agent = DBOS.registerWorkflow(async (question: string) => {
+  const mcpClient = await createMCPClient({ transport: { type: 'http', url: MCP_URL } });
+  const tools = await durableMCPTools(mcpClient);
+  const result = await generateText({ model, prompt: question, tools, stopWhen: stepCountIs(10) });
+  return result.text;
+}, { name: 'mcpAgent' });
+```
+
+To use the client's explicit-schema mode (tool subsetting, typed inputs, output schemas), pass `toolOptions`; it is forwarded to `client.tools()` for both the listing and each tool call:
+
+```ts
+const tools = await durableMCPTools(mcpClient, {
+  toolOptions: { schemas: { 'get-weather': { inputSchema: z.object({ city: z.string() }) } } },
+});
+```
+
+## Concurrency
+
+Run **one durable model call at a time within a single workflow**.
+DBOS requires workflows to be deterministic, but the AI SDK issues concurrent model calls in nondeterministic order.
+To guard against nondeterminism, this integration throws an error if it detects concurrent durable model calls in the same workflow.
+Sequential calls (including a normal tool-calling loop, where each model call completes before the next begins) are unaffected.
+
+To fan out model calls in parallel, give each its own **child workflow**:
+
+```ts
+const summarizeOne = DBOS.registerWorkflow(
+  async (doc: string) => (await generateText({ model, prompt: `Summarize: ${doc}` })).text,
+  { name: 'summarizeOne' },
+);
+
+const summarizeAll = DBOS.registerWorkflow(async (docs: string[]) => {
+  const handles = await Promise.all(
+    docs.map((doc) => DBOS.startWorkflow(summarizeOne)(doc)),
+  );
+  return Promise.all(handles.map((h) => h.getResult()));
+}, { name: 'summarizeAll' });
+```
+
+## Embeddings
+
+`durableEmbeddingCalls` enables durable calls to embedding models:
+
+```ts
+import { embedMany, wrapEmbeddingModel } from 'ai';
+import { durableEmbeddingCalls } from '@dbos-inc/vercel-ai';
+
+const embeddingModel = wrapEmbeddingModel({
+  model: openai.textEmbeddingModel('text-embedding-3-small'),
+  middleware: durableEmbeddingCalls({ retriesAllowed: true }),
+});
+
+const { embeddings } = await embedMany({ model: embeddingModel, values: chunks, maxParallelCalls: 1 });
+```
+
+Pass `maxParallelCalls: 1` when embedding more values than the model's per-call limit. `embedMany` otherwise splits the input into batches and runs them concurrently, which the concurrency guard rejects (their step order would be nondeterministic on replay); `maxParallelCalls: 1` runs the batches sequentially, keeping them durable and replay-safe.
+
+## Images
+
+`durableImageCalls` makes image generation durable:
+
+```ts
+import { generateImage, wrapImageModel } from 'ai';
+import { durableImageCalls } from '@dbos-inc/vercel-ai';
+
+const imageModel = wrapImageModel({ model: openai.imageModel('gpt-image-1'), middleware: durableImageCalls() });
+
+const { images } = await generateImage({ model: imageModel, prompt: 'a durable cat' });
+```
+

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { durableCalls, durableEmbeddingCalls, durableImageCalls } from './middleware';
+export { durableMCPTools, DurableMCPToolsOptions, MCPClientLike } from './mcp';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtF,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.durableMCPTools = exports.durableImageCalls = exports.durableEmbeddingCalls = exports.durableCalls = void 0;
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "durableCalls", { enumerable: true, get: function () { return middleware_1.durableCalls; } });
+Object.defineProperty(exports, "durableEmbeddingCalls", { enumerable: true, get: function () { return middleware_1.durableEmbeddingCalls; } });
+Object.defineProperty(exports, "durableImageCalls", { enumerable: true, get: function () { return middleware_1.durableImageCalls; } });
+var mcp_1 = require("./mcp");
+Object.defineProperty(exports, "durableMCPTools", { enumerable: true, get: function () { return mcp_1.durableMCPTools; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,2CAAsF;AAA7E,0GAAA,YAAY,OAAA;AAAE,mHAAA,qBAAqB,OAAA;AAAE,+GAAA,iBAAiB,OAAA;AAC/D,6BAA+E;AAAtE,sGAAA,eAAe,OAAA"}

package/dist/internal.d.ts

@@ -0,0 +1,6 @@
+import { StepConfig } from '@dbos-inc/dbos-sdk';
+export declare function isInWorkflowFunction(): boolean;
+export declare function assertNotInTransaction(operation: string): void;
+export declare function restoreAISDKErrorIdentity(error: unknown): unknown;
+export declare function withErrorClassification(options: StepConfig): StepConfig;
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEtD,wBAAgB,oBAAoB,IAAI,OAAO,CAG9C;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAI9D;AA2BD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAejE;AAKD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAMvE"}

package/dist/internal.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInWorkflowFunction = isInWorkflowFunction;
+exports.assertNotInTransaction = assertNotInTransaction;
+exports.restoreAISDKErrorIdentity = restoreAISDKErrorIdentity;
+exports.withErrorClassification = withErrorClassification;
+const dbos_sdk_1 = require("@dbos-inc/dbos-sdk");
+function isInWorkflowFunction() {
+    // True only in workflow code proper: not in a step, transaction, or outside DBOS.
+    return dbos_sdk_1.DBOS.isInWorkflow();
+}
+function assertNotInTransaction(operation) {
+    if (dbos_sdk_1.DBOS.isInTransaction()) {
+        throw new Error(`Cannot call ${operation} inside a DBOS transaction; run it in workflow or step code.`);
+    }
+}
+// Aborts/timeouts are deliberate cancellations, never transient; retrying just re-runs an already-cancelled call.
+function isAbortError(error) {
+    const name = error?.name;
+    return name === 'AbortError' || name === 'TimeoutError';
+}
+// AI SDK errors (APICallError, GatewayError) expose an isRetryable flag; treat an explicit false, and any abort, as terminal.
+function isNonRetryable(error) {
+    try {
+        return (isAbortError(error) ||
+            (typeof error === 'object' &&
+                error !== null &&
+                'isRetryable' in error &&
+                error.isRetryable === false));
+    }
+    catch {
+        // A throwing accessor must not replace the step's real error; treat as retryable.
+        return false;
+    }
+}
+// serialize-error drops the Symbol-keyed AI SDK error markers on replay, so isInstance() fails on the revived error.
+// The markers derive from error.name (which survives), so re-attach them; no @ai-sdk/provider/@ai-sdk/gateway import.
+// AISDKError (APICallError, ...) and GatewayError use distinct marker namespaces — ai's retry predicate checks both.
+function restoreAISDKErrorIdentity(error) {
+    // Wrap the whole body: identity restoration must never replace or mask the real error (a frozen/non-extensible
+    // error throws on assignment, a throwing `name` getter throws on read) — on failure, return the error untouched.
+    try {
+        const name = error?.name;
+        if (error === null || typeof error !== 'object' || typeof name !== 'string')
+            return error;
+        const base = name.startsWith('AI_') ? 'vercel.ai.error' : name.startsWith('Gateway') ? 'vercel.ai.gateway.error' : undefined;
+        if (base !== undefined) {
+            error[Symbol.for(base)] = true;
+            error[Symbol.for(`${base}.${name}`)] = true;
+        }
+    }
+    catch {
+        // Fall through and return the error as-is.
+    }
+    return error;
+}
+// Default to DBOS-owned retries so a transient provider error is absorbed inside one step (never checkpointed as an
+// error that replay would re-run); the default shouldRetry skips provider-declared non-retryable errors and aborts.
+// A caller's retriesAllowed/shouldRetry wins, but an explicit `undefined` falls back to the default.
+function withErrorClassification(options) {
+    return {
+        ...options,
+        retriesAllowed: options.retriesAllowed ?? true,
+        shouldRetry: options.shouldRetry ?? ((error) => !isNonRetryable(error)),
+    };
+}
+//# sourceMappingURL=internal.js.map

package/dist/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":";;AAEA,oDAGC;AAED,wDAIC;AA2BD,8DAeC;AAKD,0DAMC;AAhED,iDAAsD;AAEtD,SAAgB,oBAAoB;IAClC,kFAAkF;IAClF,OAAO,eAAI,CAAC,YAAY,EAAE,CAAC;AAC7B,CAAC;AAED,SAAgB,sBAAsB,CAAC,SAAiB;IACtD,IAAI,eAAI,CAAC,eAAe,EAAE,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,eAAe,SAAS,8DAA8D,CAAC,CAAC;IAC1G,CAAC;AACH,CAAC;AAED,kHAAkH;AAClH,SAAS,YAAY,CAAC,KAAc;IAClC,MAAM,IAAI,GAAI,KAAmC,EAAE,IAAI,CAAC;IACxD,OAAO,IAAI,KAAK,YAAY,IAAI,IAAI,KAAK,cAAc,CAAC;AAC1D,CAAC;AAED,8HAA8H;AAC9H,SAAS,cAAc,CAAC,KAAc;IACpC,IAAI,CAAC;QACH,OAAO,CACL,YAAY,CAAC,KAAK,CAAC;YACnB,CAAC,OAAO,KAAK,KAAK,QAAQ;gBACxB,KAAK,KAAK,IAAI;gBACd,aAAa,IAAI,KAAK;gBACrB,KAAmC,CAAC,WAAW,KAAK,KAAK,CAAC,CAC9D,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,kFAAkF;QAClF,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,qHAAqH;AACrH,sHAAsH;AACtH,qHAAqH;AACrH,SAAgB,yBAAyB,CAAC,KAAc;IACtD,+GAA+G;IAC/G,iHAAiH;IACjH,IAAI,CAAC;QACH,MAAM,IAAI,GAAI,KAAmC,EAAE,IAAI,CAAC;QACxD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QAC1F,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,SAAS,CAAC;QAC7H,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACtB,KAAiC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;YAC3D,KAAiC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;QAC3E,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,2CAA2C;IAC7C,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,oHAAoH;AACpH,oHAAoH;AACpH,qGAAqG;AACrG,SAAgB,uBAAuB,CAAC,OAAmB;IACzD,OAAO;QACL,GAAG,OAAO;QACV,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,IAAI;QAC9C,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC,KAAc,EAAE,EAAE,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;KACjF,CAAC;AACJ,CAAC"}

package/dist/mcp.d.ts

@@ -0,0 +1,17 @@
+import { StepConfig } from '@dbos-inc/dbos-sdk';
+import type { ToolSet } from 'ai' with { 'resolution-mode': 'import' };
+export interface MCPClientLike {
+    tools(options?: unknown): Promise<Record<string, unknown>>;
+    close?(): Promise<void>;
+}
+export interface DurableMCPToolsOptions extends StepConfig {
+    /** Forwarded to client.tools() on listing and on each call (e.g. { schemas } for subsetting and output schemas). */
+    toolOptions?: unknown;
+}
+/**
+ * Wraps an MCP client so its tool listing and each tool call run as durable DBOS steps: the tool
+ * list (JSON schemas) is checkpointed so recovery needs no live connection, and each tool call is
+ * checkpointed so a recovered workflow replays results instead of re-invoking the tool.
+ */
+export declare function durableMCPTools(client: MCPClientLike, options?: DurableMCPToolsOptions): Promise<ToolSet>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC,OAAO,iBAAiB,EAAE,QAAQ,EAAE,CAAC;AAKvE,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAaD,MAAM,WAAW,sBAAuB,SAAQ,UAAU;IACxD,oHAAoH;IACpH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAqCD;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,GAAE,sBAA2B,GAAG,OAAO,CAAC,OAAO,CAAC,CAwEnH"}

package/dist/mcp.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.durableMCPTools = durableMCPTools;
+const dbos_sdk_1 = require("@dbos-inc/dbos-sdk");
+const internal_1 = require("./internal");
+function isAsyncIterable(value) {
+    return typeof value?.[Symbol.asyncIterator] === 'function';
+}
+// Mirror of @ai-sdk/mcp's toModelOutput: MCP content becomes model content (text stays text, images become files).
+function mcpToolOutput(output) {
+    const result = output;
+    if (result === null || typeof result !== 'object' || !Array.isArray(result.content)) {
+        return { type: 'json', value: output };
+    }
+    return {
+        type: 'content',
+        value: result.content.map((part) => {
+            if (part.type === 'text' && typeof part.text === 'string') {
+                return { type: 'text', text: part.text };
+            }
+            if (part.type === 'image' && part.data !== undefined && part.mimeType !== undefined) {
+                return { type: 'file', mediaType: part.mimeType, data: { type: 'data', data: part.data } };
+            }
+            return { type: 'text', text: JSON.stringify(part) };
+        }),
+    };
+}
+/**
+ * Wraps an MCP client so its tool listing and each tool call run as durable DBOS steps: the tool
+ * list (JSON schemas) is checkpointed so recovery needs no live connection, and each tool call is
+ * checkpointed so a recovered workflow replays results instead of re-invoking the tool.
+ */
+async function durableMCPTools(client, options = {}) {
+    const { toolOptions, ...stepOptions } = options;
+    const stepConfig = (0, internal_1.withErrorClassification)(stepOptions);
+    const { asSchema, dynamicTool, jsonSchema } = await import('ai');
+    const run = (name, fn, config = stepConfig) => {
+        (0, internal_1.assertNotInTransaction)(name);
+        if (!(0, internal_1.isInWorkflowFunction)())
+            return fn();
+        // Restore the AI SDK error identity a replay revival strips, so the SDK's retry/catch logic behaves the same.
+        return dbos_sdk_1.DBOS.runStep(fn, { ...config, name }).catch((error) => {
+            throw (0, internal_1.restoreAISDKErrorIdentity)(error);
+        });
+    };
+    // Checkpoint the tool list as plain JSON schemas, so replay reconstructs tools without the live client.
+    const listed = await run('mcp.listTools', async () => {
+        const tools = await client.tools(toolOptions);
+        const defs = {};
+        for (const [name, rawTool] of Object.entries(tools)) {
+            const tool = rawTool;
+            defs[name] = {
+                description: typeof tool.description === 'string' ? tool.description : undefined,
+                title: typeof tool.title === 'string' ? tool.title : undefined,
+                metadata: tool.metadata,
+                meta: tool._meta,
+                convertsOutput: typeof tool.toModelOutput === 'function',
+                // Await: a Schema's jsonSchema may be a Promise, which would otherwise checkpoint as {} and yield an empty schema.
+                inputJsonSchema: await asSchema(tool.inputSchema).jsonSchema,
+            };
+        }
+        return defs;
+    });
+    const durable = {};
+    for (const [name, def] of Object.entries(listed)) {
+        const reconstructed = dynamicTool({
+            description: def.description,
+            title: def.title,
+            metadata: def.metadata,
+            inputSchema: jsonSchema(def.inputJsonSchema),
+            // MCP clients convert results via a pure toModelOutput; reapply an equivalent so results reach the model as content, not raw JSON.
+            toModelOutput: def.convertsOutput ? ({ output }) => mcpToolOutput(output) : undefined,
+            // Re-fetch the live tool inside the step (its execute closure can't be checkpointed); replay returns the recorded result.
+            execute: (input, execOptions) => {
+                const signal = execOptions?.abortSignal;
+                // An aborted consumer is done with this call, whatever the failure looks like; a retry would re-run a cancelled side effect.
+                const callConfig = {
+                    ...stepConfig,
+                    shouldRetry: async (error) => !signal?.aborted && (stepConfig.shouldRetry ? await stepConfig.shouldRetry(error) : true),
+                };
+                return run(`mcp.tool.${name}`, async () => {
+                    const tool = (await client.tools(toolOptions))[name];
+                    if (typeof tool?.execute !== 'function')
+                        throw new Error(`MCP tool "${name}" is not executable.`);
+                    const output = await tool.execute(input, execOptions);
+                    // A streaming execute can't checkpoint mid-flight; drain it and record the final value (the last yield).
+                    if (isAsyncIterable(output)) {
+                        let last;
+                        for await (last of output)
+                            ;
+                        return last;
+                    }
+                    return output;
+                }, callConfig);
+            },
+        });
+        // @ai-sdk/mcp spreads the MCP _meta onto the tool object; preserve it for consumers that read it.
+        durable[name] = def.meta === undefined ? reconstructed : Object.assign(reconstructed, { _meta: def.meta });
+    }
+    return durable;
+}
+//# sourceMappingURL=mcp.js.map

package/dist/mcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.js","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":"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"}

package/dist/middleware.d.ts

@@ -0,0 +1,13 @@
+import { StepConfig } from '@dbos-inc/dbos-sdk';
+import type { EmbeddingModelMiddleware, ImageModelMiddleware, LanguageModelMiddleware } from 'ai' with { 'resolution-mode': 'import' };
+/** AI SDK language-model middleware that runs each model call as a durable, checkpointed DBOS step (replayed on recovery); outside a workflow it calls the model directly. */
+export declare function durableCalls(options?: StepConfig): LanguageModelMiddleware;
+/** AI SDK embedding-model middleware that runs each embedding call as a durable DBOS step, like {@link durableCalls}. */
+export declare function durableEmbeddingCalls(options?: StepConfig): EmbeddingModelMiddleware;
+/**
+ * AI SDK image-model middleware that runs each image generation as a durable DBOS step, like {@link durableCalls}.
+ * No concurrency guard: generateImage splits `n > maxImagesPerCall` into batches it dispatches synchronously (no
+ * await before doGenerate), so their step order is deterministic on replay — unlike embedMany's parallel batches.
+ */
+export declare function durableImageCalls(options?: StepConfig): ImageModelMiddleware;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAItD,OAAO,KAAK,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,IAAI,CAAC,OAAO,iBAAiB,EAAE,QAAQ,EAAE,CAAC;AAgDvI,8KAA8K;AAC9K,wBAAgB,YAAY,CAAC,OAAO,GAAE,UAAe,GAAG,uBAAuB,CAsK9E;AAED,yHAAyH;AACzH,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,UAAe,GAAG,wBAAwB,CAsBxF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,UAAe,GAAG,oBAAoB,CAmBhF"}