Integration with AI SDK

package.json

@@ -39,6 +39,7 @@
     "ava": "pnpm -C packages/test exec ava"
   },
   "dependencies": {
+    "@temporalio/ai-sdk": "workspace:*",
     "@temporalio/client": "workspace:*",
     "@temporalio/cloud": "workspace:*",
     "@temporalio/common": "workspace:*",
@@ -57,9 +58,9 @@
     "temporalio": "file:packages/meta"
   },
   "devDependencies": {
-    "@opentelemetry/api": "^1.7.0",
-    "@opentelemetry/core": "^1.19.0",
-    "@opentelemetry/sdk-node": "^0.46.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^1.25.1",
+    "@opentelemetry/sdk-node": "^0.52.1",
     "@tsconfig/node18": "^18.2.4",
     "@types/fs-extra": "^11.0.4",
     "@types/ms": "^0.7.34",

packages/ai-sdk/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@temporalio/ai-sdk",
+  "version": "1.13.2",
+  "description": "Temporal AI SDK integration package",
+  "main": "lib/index.js",
+  "types": "./lib/index.d.ts",
+  "keywords": [
+    "temporal",
+    "workflow",
+    "ai",
+    "ai-sdk",
+    "llm"
+  ],
+  "author": "Temporal Technologies Inc. <sdk@temporal.io>",
+  "license": "MIT",
+  "dependencies": {
+    "@temporalio/plugin": "workspace:*",
+    "@temporalio/workflow": "workspace:*",
+    "@ungap/structured-clone": "^1.3.0",
+    "headers-polyfill": "^4.0.3",
+    "web-streams-polyfill": "^4.2.0"
+  },
+  "peerDependencies": {
+    "@ai-sdk/provider": "^2.0.0",
+    "@ai-sdk/mcp": "^0.0.8",
+    "ai": "^5.0.91"
+  },
+  "engines": {
+    "node": ">= 18.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/temporalio/sdk-typescript/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/temporalio/sdk-typescript.git",
+    "directory": "packages/ai-sdk"
+  },
+  "homepage": "https://github.com/temporalio/sdk-typescript/tree/main/packages/ai-sdk",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "lib"
+  ]
+}

packages/ai-sdk/src/activities.ts

@@ -0,0 +1,103 @@
+import {
+  LanguageModelV2CallOptions,
+  LanguageModelV2CallWarning,
+  LanguageModelV2Content,
+  LanguageModelV2FinishReason,
+  LanguageModelV2ResponseMetadata,
+  LanguageModelV2Usage,
+  ProviderV2,
+  SharedV2Headers,
+  SharedV2ProviderMetadata,
+} from '@ai-sdk/provider';
+import type { ToolCallOptions } from 'ai';
+import type { McpClientFactory } from './mcp';
+
+export interface InvokeModelArgs {
+  modelId: string;
+  options: LanguageModelV2CallOptions;
+}
+
+export interface InvokeModelResult {
+  content: Array<LanguageModelV2Content>;
+  finishReason: LanguageModelV2FinishReason;
+  usage: LanguageModelV2Usage;
+  providerMetadata?: SharedV2ProviderMetadata;
+  request?: { body?: unknown };
+  response?: LanguageModelV2ResponseMetadata & { headers?: SharedV2Headers; body?: unknown };
+  warnings: Array<LanguageModelV2CallWarning>;
+}
+
+export interface ListToolResult {
+  description?: string;
+  inputSchema: any;
+}
+
+export interface ListToolArgs {
+  clientArgs?: any;
+}
+
+export interface CallToolArgs {
+  clientArgs?: any;
+  name: string;
+  args: any;
+  options: ToolCallOptions;
+}
+
+/**
+ * Creates Temporal activities for AI model invocation using the provided AI SDK provider.
+ * These activities allow workflows to call AI models while maintaining Temporal's
+ * execution guarantees and replay safety.
+ *
+ * @param provider The AI SDK provider to use for model invocations
+ * @param mcpClientFactories A mapping of server names to functions to create mcp clients
+ * @returns An object containing the activity functions
+ *
+ * @experimental The AI SDK integration is an experimental feature; APIs may change without notice.
+ */
+export const createActivities = (provider: ProviderV2, mcpClientFactories?: [string, McpClientFactory][]): object => {
+  let activities = {
+    async invokeModel(args: InvokeModelArgs): Promise<InvokeModelResult> {
+      const model = provider.languageModel(args.modelId);
+      return await model.doGenerate(args.options);
+    },
+  };
+  if (mcpClientFactories !== undefined) {
+    mcpClientFactories.forEach(([name, func]) => {
+      activities = {
+        ...activities,
+        ...activitiesForName(name, func),
+      };
+    });
+  }
+  return activities;
+};
+
+const activitiesForName = (name: string, mcpClientFactory: McpClientFactory): object => {
+  const listToolsActivity = async (args: ListToolArgs): Promise<Record<string, ListToolResult>> => {
+    const mcpClient = await mcpClientFactory(args.clientArgs);
+    const tools = await mcpClient.tools();
+
+    return Object.fromEntries(
+      Object.entries(tools).map(([k, v]) => [
+        k,
+        {
+          description: v.description,
+          inputSchema: v.inputSchema,
+        },
+      ])
+    );
+  };
+  const callToolActivity = async (args: CallToolArgs): Promise<any> => {
+    const mcpClient = await mcpClientFactory(args.clientArgs);
+    const tools = await mcpClient.tools();
+    const tool = tools[args.name];
+    if (tool === undefined) {
+      throw new Error(`Tool ${args.name} not found.`);
+    }
+    return tool.execute(args.args, args.options);
+  };
+  return {
+    [name + '-listTools']: listToolsActivity,
+    [name + '-callTool']: callToolActivity,
+  };
+};

packages/ai-sdk/src/index.ts

@@ -0,0 +1,6 @@
+// eslint-disable-next-line import/no-unassigned-import
+import './load-polyfills';
+
+export * from './mcp';
+export * from './plugin';
+export * from './provider';

packages/ai-sdk/src/load-polyfills.ts

@@ -0,0 +1,18 @@
+import { Headers } from 'headers-polyfill';
+import { inWorkflowContext } from '@temporalio/workflow';
+
+if (inWorkflowContext()) {
+  // Apply Headers polyfill
+  if (typeof globalThis.Headers === 'undefined') {
+    globalThis.Headers = Headers;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-require-imports,import/no-unassigned-import
+  require('web-streams-polyfill/polyfill');
+  // Attach the polyfill as a Global function
+  if (!('structuredClone' in globalThis)) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports,import/no-unassigned-import
+    const structuredClone = require('@ungap/structured-clone');
+    globalThis.structuredClone = structuredClone.default;
+  }
+}

packages/ai-sdk/src/mcp.ts

@@ -0,0 +1,68 @@
+import type { ToolSet } from 'ai';
+import type { experimental_MCPClient as MCPClient } from '@ai-sdk/mcp';
+import * as workflow from '@temporalio/workflow';
+import type { ActivityOptions } from '@temporalio/workflow';
+import type { ListToolResult } from './activities';
+
+export type McpClientFactory = (args: unknown) => Promise<MCPClient>;
+
+/**
+ * Options for the Temporal MCP Client
+ *
+ * @experimental The AI SDK plugin is an experimental feature; APIs may change without notice.
+ */
+export interface TemporalMCPClientOptions {
+  readonly name: string;
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  readonly clientArgs?: any;
+  readonly activityOptions?: ActivityOptions;
+}
+
+/**
+ * A Temporal MCP Client which uses activities to execute list tools and call tools.
+ * This should match by name an MCPClientFactory registered with the AI SDK plugin to function.
+ *
+ * @experimental The AI SDK plugin is an experimental feature; APIs may change without notice.
+ */
+export class TemporalMCPClient {
+  constructor(readonly options: TemporalMCPClientOptions) {}
+
+  async tools(): Promise<ToolSet> {
+    workflow.log.info(`Options: ${this.options.activityOptions}`);
+    const activities = workflow.proxyActivities({ startToCloseTimeout: '10 minutes', ...this.options.activityOptions });
+
+    const listActivity = activities[this.options.name + '-listTools']
+    if (listActivity === undefined) {
+      throw new Error(`List Tools activity could not be found for mcp client ${this.options.name}. Has it been registered in the plugin?`)
+    }
+    const tools: Record<string, ListToolResult> = await listActivity({ clientArgs: this.options.clientArgs });
+    return Object.fromEntries(
+      Object.entries(tools).map(([toolName, toolResult]) => [
+        toolName,
+        {
+          execute: async (args: any, options) => {
+            const activities = workflow
+              .proxyActivities({
+                summary: toolName,
+                startToCloseTimeout: '10 minutes',
+                ...this.options,
+              });
+            const callActivity = activities[this.options.name + '-callTool'];
+            if (callActivity === undefined) {
+              throw new Error(`Call Tool activity could not be found for mcp client ${this.options.name}. Has it been registered in the plugin?`)
+            }
+            return await callActivity({ name: toolName, args, options, clientArgs: this.options.clientArgs });
+          },
+          inputSchema: {
+            ...toolResult.inputSchema,
+            _type: undefined,
+            validate: undefined,
+            [Symbol.for('vercel.ai.schema')]: true,
+            [Symbol.for('vercel.ai.validator')]: true,
+          },
+          type: 'dynamic',
+        },
+      ])
+    );
+  }
+}

packages/ai-sdk/src/plugin.ts

@@ -0,0 +1,29 @@
+import type { ProviderV2 } from '@ai-sdk/provider';
+import { SimplePlugin } from '@temporalio/plugin';
+import { createActivities } from './activities';
+import type { McpClientFactory } from './mcp';
+
+/**
+ * Options for the AI SDK plugin
+ *
+ * @experimental The AI SDK plugin is an experimental feature; APIs may change without notice.
+ */
+export interface AiSdkPluginOptions {
+  modelProvider: ProviderV2;
+  mcpClientFactories?: [string, McpClientFactory][];
+}
+
+/**
+ * A Temporal plugin that integrates AI SDK providers for use in workflows.
+ * This plugin creates activities that allow workflows to invoke AI models.
+ *
+ * @experimental The AI SDK plugin is an experimental feature; APIs may change without notice.
+ */
+export class AiSdkPlugin extends SimplePlugin {
+  constructor(options: AiSdkPluginOptions) {
+    super({
+      name: 'AiSDKPlugin',
+      activities: createActivities(options.modelProvider, options.mcpClientFactories),
+    });
+  }
+}

packages/ai-sdk/src/provider.ts

@@ -0,0 +1,81 @@
+import type {
+  EmbeddingModelV2,
+  ImageModelV2,
+  LanguageModelV2,
+  LanguageModelV2CallOptions,
+  ProviderV2,
+  SharedV2Headers,
+} from '@ai-sdk/provider';
+import * as workflow from '@temporalio/workflow';
+import { ActivityOptions } from '@temporalio/workflow';
+import { InvokeModelResult } from './activities';
+
+/**
+ * A language model implementation that delegates AI model calls to Temporal activities.
+ * This allows workflows to invoke AI models through the Temporal execution model.
+ *
+ * @experimental The AI SDK integration is an experimental feature; APIs may change without notice.
+ */
+export class TemporalLanguageModel implements LanguageModelV2 {
+  readonly specificationVersion = 'v2';
+  readonly provider = 'temporal';
+  readonly supportedUrls = {};
+
+  constructor(
+    readonly modelId: string,
+    readonly options?: ActivityOptions
+  ) {}
+
+  async doGenerate(options: LanguageModelV2CallOptions): Promise<InvokeModelResult> {
+    const activities = workflow.proxyActivities({ startToCloseTimeout: '10 minutes', ...this.options });
+    if (activities.invokeModel === undefined) {
+      throw new Error("Unable to find model activity. Is the plugin registered?")
+    }
+    const result = await activities.invokeModel({modelId: this.modelId, options});
+    if (result === undefined) {
+      throw new Error('Received undefined response from model activity.');
+    }
+    if (result.response !== undefined) {
+      result.response.timestamp = new Date(result.response.timestamp);
+    }
+    return result;
+  }
+
+  doStream(_options: LanguageModelV2CallOptions): PromiseLike<{
+    stream: any;
+    request?: { body?: unknown };
+    response?: { headers?: SharedV2Headers };
+  }> {
+    throw new Error('Streaming not supported.');
+  }
+}
+
+/**
+ * A Temporal-specific provider implementation that creates AI models which execute
+ * through Temporal activities. This provider integrates AI SDK models with Temporal's
+ * execution model to ensure reliable, durable AI model invocations.
+ *
+ * @experimental The AI SDK integration is an experimental feature; APIs may change without notice.
+ */
+export class TemporalProvider implements ProviderV2 {
+  constructor(readonly options?: ActivityOptions) {}
+
+  imageModel(_modelId: string): ImageModelV2 {
+    throw new Error('Not implemented');
+  }
+
+  languageModel(modelId: string): LanguageModelV2 {
+    return new TemporalLanguageModel(modelId, this.options);
+  }
+
+  textEmbeddingModel(_modelId: string): EmbeddingModelV2<string> {
+    throw new Error('Not implemented');
+  }
+}
+
+/**
+ * A singleton instance of TemporalProvider for convenient use in applications.
+ *
+ * @experimental The AI SDK integration is an experimental feature; APIs may change without notice.
+ */
+export const temporalProvider: TemporalProvider = new TemporalProvider();

packages/ai-sdk/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./lib",
+    "rootDir": "./src"
+  },
+  "references": [{ "path": "../plugin" }, { "path": "../workflow" }],
+  "include": ["./src/**/*.ts"]
+}