@ai-sdk/workflow 2.0.57 → 2.0.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "2.0.57",
+  "version": "2.0.59",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -36,9 +36,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.21",
-    "@ai-sdk/provider-utils": "5.0.53",
-    "ai": "7.0.126",
+    "@ai-sdk/provider": "4.0.22",
+    "@ai-sdk/provider-utils": "5.0.54",
+    "ai": "7.0.128",
     "ajv": "^8.20.0"
   },
   "devDependencies": {

package/src/build-model-step-result.ts

@@ -0,0 +1,329 @@
+import type { LanguageModelV4Content } from '@ai-sdk/provider';
+import {
+  convertLanguageModelContent,
+  DefaultStepResult,
+  calculateTokensPerSecond,
+} from 'ai/internal';
+import type { Context } from '@ai-sdk/provider-utils';
+import {
+  DefaultGeneratedFile,
+  type LanguageModelUsage,
+  type ModelMessage,
+  type StepResult,
+  type ToolSet,
+} from 'ai';
+import type {
+  ModelCallRawResult,
+  ModelCallFinish,
+  ParsedToolCall,
+  ProviderExecutedToolResult,
+} from './model-call.js';
+
+export async function buildModelStepResult(
+  raw: ModelCallRawResult,
+  toolCalls: ParsedToolCall[],
+  finish: ModelCallFinish | undefined,
+  providerExecutedToolResults: Map<string, ProviderExecutedToolResult>,
+  opts: {
+    tools?: ToolSet;
+    requestMessages?: ModelMessage[];
+    stepNumber: number;
+    runtimeContext: Context;
+    toolsContext: Record<string, Context | undefined>;
+  },
+): Promise<StepResult<ToolSet, any>> {
+  if (raw.generation != null && finish != null) {
+    const providerContent: LanguageModelV4Content[] = [];
+    for (const part of raw.content) {
+      switch (part.type) {
+        case 'reasoning':
+          if (!('reasoningIndex' in part)) providerContent.push(part);
+          break;
+        case 'tool-call': {
+          const call = toolCalls[part.toolCallIndex];
+          providerContent.push({ ...call, input: '', type: 'tool-call' });
+          break;
+        }
+        case 'provider-tool-result':
+          providerContent.push({
+            ...providerExecutedToolResults.get(part.toolCallId)!,
+            type: 'tool-result',
+          } as Extract<LanguageModelV4Content, { type: 'tool-result' }>);
+          break;
+        case 'file':
+          providerContent.push({
+            ...part,
+            data: { type: 'data', data: part.data },
+          });
+          break;
+        default:
+          providerContent.push(part);
+      }
+    }
+    const content = await convertLanguageModelContent({
+      content: providerContent,
+      toolCalls: toolCalls as StepResult<ToolSet>['toolCalls'],
+      toolOutputs: [],
+      toolApprovalRequests: [],
+      toolApprovalResponses: [],
+      tools: opts.tools,
+    });
+    const duration = raw.generation.responseTimeMs;
+    const rate = (tokens: number | undefined) =>
+      calculateTokensPerSecond({ tokens, durationMs: duration });
+    return new DefaultStepResult({
+      callId: 'workflow-agent',
+      stepNumber: opts.stepNumber,
+      provider: raw.generation.provider,
+      modelId: raw.generation.modelId,
+      runtimeContext: opts.runtimeContext,
+      toolsContext: opts.toolsContext,
+      content,
+      finishReason: finish.finishReason,
+      rawFinishReason: finish.rawFinishReason,
+      usage: finish.usage,
+      warnings: raw.warnings as StepResult<ToolSet>['warnings'],
+      request: { ...raw.generation.request, messages: opts.requestMessages },
+      response: {
+        ...raw.responseMetadata,
+        messages: [],
+      } as StepResult<ToolSet>['response'],
+      providerMetadata:
+        finish.providerMetadata as StepResult<ToolSet>['providerMetadata'],
+      performance: {
+        responseTimeMs: duration,
+        stepTimeMs: duration,
+        toolExecutionMs: {},
+        effectiveOutputTokensPerSecond: rate(finish.usage.outputTokens),
+        effectiveTotalTokensPerSecond: rate(finish.usage.totalTokens),
+        outputTokensPerSecond: undefined,
+        inputTokensPerSecond: undefined,
+        timeToFirstOutputMs: undefined,
+      },
+    });
+  }
+  const {
+    content: rawContent,
+    reasoning: reasoningParts,
+    responseMetadata,
+    warnings,
+  } = raw;
+  const reasoningText = reasoningParts.map(r => r.text).join('') || undefined;
+  const validToolCallsByIndex = new Map(
+    toolCalls.flatMap((tc, index) =>
+      tc.invalid
+        ? []
+        : [
+            [
+              index,
+              {
+                type: 'tool-call' as const,
+                toolCallId: tc.toolCallId,
+                toolName: tc.toolName,
+                input: tc.input,
+                ...(tc.providerExecuted != null
+                  ? { providerExecuted: tc.providerExecuted }
+                  : {}),
+                ...(tc.title != null ? { title: tc.title } : {}),
+                ...(tc.toolMetadata != null
+                  ? { toolMetadata: tc.toolMetadata }
+                  : {}),
+                ...(tc.dynamic ? { dynamic: true as const } : {}),
+                ...(tc.providerExecuted ? { providerExecuted: true } : {}),
+                ...(tc.providerMetadata != null
+                  ? { providerMetadata: tc.providerMetadata }
+                  : {}),
+              },
+            ] as const,
+          ],
+    ),
+  );
+  const validToolCalls = [...validToolCallsByIndex.values()];
+  const content: StepResult<ToolSet, any>['content'] = [];
+  const files: StepResult<ToolSet, any>['files'] = [];
+  const sources: StepResult<ToolSet, any>['sources'] = [];
+  let text = '';
+
+  for (const part of rawContent) {
+    switch (part.type) {
+      case 'text':
+        text += part.text;
+        content.push({
+          type: 'text',
+          text: part.text,
+          ...(part.providerMetadata != null
+            ? { providerMetadata: part.providerMetadata }
+            : {}),
+        });
+        break;
+      case 'reasoning':
+        if ('reasoningIndex' in part) {
+          const reasoningPart = reasoningParts[part.reasoningIndex];
+          if (reasoningPart != null) {
+            content.push({
+              type: 'reasoning',
+              text: reasoningPart.text,
+              ...(reasoningPart.providerMetadata != null
+                ? { providerMetadata: reasoningPart.providerMetadata }
+                : {}),
+            });
+          }
+        }
+        break;
+      case 'file': {
+        const file = new DefaultGeneratedFile({
+          data: part.data,
+          mediaType: part.mediaType,
+          providerMetadata: part.providerMetadata,
+        });
+        files.push(file);
+        content.push({
+          type: 'file',
+          file,
+          ...(part.providerMetadata != null
+            ? { providerMetadata: part.providerMetadata }
+            : {}),
+        });
+        break;
+      }
+      case 'source':
+        sources.push(part);
+        content.push(part);
+        break;
+      case 'tool-approval-request': {
+        const toolCall = validToolCalls.find(
+          call => call.toolCallId === part.toolCallId,
+        );
+        if (toolCall != null)
+          content.push({
+            type: 'tool-approval-request',
+            approvalId: part.approvalId,
+            toolCall: toolCall as StepResult<ToolSet>['toolCalls'][number],
+          });
+        break;
+      }
+      case 'tool-call': {
+        const toolCall = validToolCallsByIndex.get(part.toolCallIndex);
+        if (toolCall != null) {
+          content.push(toolCall);
+        }
+        break;
+      }
+      case 'provider-tool-result': {
+        const result = providerExecutedToolResults.get(part.toolCallId);
+        if (result == null) {
+          break;
+        }
+
+        const toolCall = toolCalls.find(
+          toolCall => toolCall.toolCallId === result.toolCallId,
+        );
+        const common = {
+          toolCallId: result.toolCallId,
+          toolName: result.toolName,
+          input: toolCall?.input,
+          providerExecuted: true as const,
+          ...(result.dynamic === true || toolCall?.dynamic === true
+            ? { dynamic: true as const }
+            : {}),
+          ...(result.providerMetadata != null
+            ? { providerMetadata: result.providerMetadata }
+            : {}),
+          ...(toolCall?.toolMetadata != null
+            ? { toolMetadata: toolCall.toolMetadata }
+            : {}),
+        };
+
+        content.push(
+          result.isError
+            ? {
+                type: 'tool-error',
+                ...common,
+                error: result.result,
+              }
+            : {
+                type: 'tool-result',
+                ...common,
+                output: result.result,
+              },
+        );
+        break;
+      }
+    }
+  }
+
+  const toolResults = content.filter(
+    part => part.type === 'tool-result',
+  ) as StepResult<ToolSet, any>['toolResults'];
+
+  return {
+    callId: 'workflow-agent',
+    stepNumber: opts.stepNumber,
+    model: {
+      provider: responseMetadata?.modelId?.split(':')[0] ?? 'unknown',
+      modelId: responseMetadata?.modelId ?? 'unknown',
+    },
+    functionId: undefined,
+    metadata: undefined,
+    runtimeContext: opts.runtimeContext ?? {},
+    toolsContext: opts.toolsContext ?? {},
+    content,
+    text,
+    reasoning: reasoningParts.map(r => ({
+      type: 'reasoning' as const,
+      text: r.text,
+      ...(r.providerMetadata != null
+        ? { providerMetadata: r.providerMetadata }
+        : {}),
+    })),
+    reasoningText,
+    files,
+    sources,
+    toolCalls: validToolCalls,
+    staticToolCalls: validToolCalls.filter(tc => tc.dynamic !== true),
+    dynamicToolCalls: validToolCalls.filter(tc => tc.dynamic),
+    toolResults,
+    staticToolResults: toolResults.filter(result => result.dynamic !== true),
+    dynamicToolResults: toolResults.filter(result => result.dynamic === true),
+    finishReason: finish?.finishReason ?? 'other',
+    rawFinishReason: finish?.rawFinishReason,
+    usage:
+      finish?.usage ??
+      ({
+        inputTokens: 0,
+        inputTokenDetails: {
+          noCacheTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        },
+        outputTokens: 0,
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+        totalTokens: 0,
+      } as LanguageModelUsage),
+    performance: {
+      effectiveOutputTokensPerSecond: 0,
+      outputTokensPerSecond: undefined,
+      inputTokensPerSecond: undefined,
+      effectiveTotalTokensPerSecond: 0,
+      stepTimeMs: 0,
+      responseTimeMs: 0,
+      toolExecutionMs: {},
+      timeToFirstOutputMs: undefined,
+    },
+    warnings,
+    request: {
+      body: '',
+      messages: [], // TODO implement step request messages
+    },
+    response: {
+      id: responseMetadata?.id ?? 'unknown',
+      timestamp: responseMetadata?.timestamp ?? new Date(),
+      modelId: responseMetadata?.modelId ?? 'unknown',
+      messages: [],
+    },
+    providerMetadata: finish?.providerMetadata ?? {},
+  } as StepResult<ToolSet, any>;
+}

package/src/do-generate-step.ts

@@ -0,0 +1,212 @@
+import type { LanguageModelV4Prompt } from '@ai-sdk/provider';
+import { generateId, convertUint8ArrayToBase64 } from '@ai-sdk/provider-utils';
+import {
+  ToolChoiceViolationError,
+  type LanguageModel,
+  type ModelMessage,
+} from 'ai';
+import {
+  asLanguageModelUsage,
+  parseToolCall,
+  prepareLanguageModelCallOptions,
+  prepareRetries,
+  prepareToolChoice,
+  prepareTools,
+  resolveLanguageModel,
+} from 'ai/internal';
+import type {
+  ModelCallOptions,
+  ModelCallRawContentPart,
+  ModelCallResult,
+  ProviderExecutedToolResult,
+  ToolInputLifecycleEvent,
+} from './model-call.js';
+import {
+  resolveSerializableTools,
+  type SerializableToolDef,
+} from './serializable-schema.js';
+
+/** A single durable provider call; orchestration and callbacks stay in the workflow. */
+export async function doGenerateStep(
+  prompt: LanguageModelV4Prompt,
+  modelInit: LanguageModel,
+  serializedTools: Record<string, SerializableToolDef>,
+  options: ModelCallOptions = {},
+): Promise<ModelCallResult> {
+  'use step';
+
+  try {
+    return await generateModelCall(prompt, modelInit, serializedTools, options);
+  } catch (error) {
+    // Carry failures as data so Workflow does not normalize arbitrary thrown
+    // values (including undefined) before the agent rejects in workflow code.
+    return {
+      toolCalls: [],
+      finish: undefined,
+      raw: { content: [], reasoning: [] },
+      providerExecutedToolResults: new Map(),
+      terminalError: error,
+    };
+  }
+}
+
+async function generateModelCall(
+  prompt: LanguageModelV4Prompt,
+  modelInit: LanguageModel,
+  serializedTools: Record<string, SerializableToolDef>,
+  options: ModelCallOptions,
+): Promise<ModelCallResult> {
+  const remaining =
+    options.timeoutAt == null ? undefined : options.timeoutAt - Date.now();
+  options.abortSignal?.throwIfAborted();
+  if (remaining != null && remaining <= 0) {
+    throw new DOMException('The generation deadline expired.', 'TimeoutError');
+  }
+  const abortSignal =
+    remaining == null
+      ? options.abortSignal
+      : AbortSignal.any([
+          ...(options.abortSignal == null ? [] : [options.abortSignal]),
+          AbortSignal.timeout(remaining),
+        ]);
+  const model = resolveLanguageModel(modelInit);
+  const tools = resolveSerializableTools(serializedTools);
+  const toolChoice = prepareToolChoice({ toolChoice: options.toolChoice });
+  const modelTools = await prepareTools({ tools });
+  const settings = prepareLanguageModelCallOptions(options);
+  const { retry } = prepareRetries({
+    maxRetries: options.maxRetries,
+    abortSignal,
+  });
+  const start = Date.now();
+  const response = await retry(async () => {
+    abortSignal?.throwIfAborted();
+    if (options.timeoutAt != null && options.timeoutAt <= Date.now())
+      throw new DOMException(
+        'The generation deadline expired.',
+        'TimeoutError',
+      );
+    return model.doGenerate({
+      ...settings,
+      prompt: [...prompt],
+      tools: modelTools,
+      toolChoice,
+      responseFormat: options.responseFormat,
+      providerOptions: options.providerOptions,
+      headers: options.headers,
+      abortSignal,
+    });
+  });
+  abortSignal?.throwIfAborted();
+  const responseTimeMs = Date.now() - start;
+  const toolCalls = await Promise.all(
+    response.content
+      .filter(part => part.type === 'tool-call')
+      .map(toolCall =>
+        parseToolCall({
+          toolCall,
+          tools,
+          repairToolCall: options.repairToolCall,
+          instructions:
+            prompt
+              .filter(message => message.role === 'system')
+              .map(message => message.content)
+              .join('\n') || undefined,
+          messages: prompt.filter(
+            message => message.role !== 'system',
+          ) as unknown as ModelMessage[],
+        }),
+      ),
+  );
+  if (
+    (toolChoice.type === 'required' || toolChoice.type === 'tool') &&
+    !toolCalls.some(
+      call =>
+        toolChoice.type === 'required' || call.toolName === toolChoice.toolName,
+    )
+  ) {
+    throw new ToolChoiceViolationError({
+      toolChoice,
+      finishReason: response.finishReason.unified,
+      provider: model.provider,
+      modelId: model.modelId,
+      content: response.content,
+    });
+  }
+  const providerExecutedToolResults = new Map<
+    string,
+    ProviderExecutedToolResult
+  >();
+  const content: ModelCallRawContentPart[] = response.content.map(part => {
+    switch (part.type) {
+      case 'tool-call':
+        return {
+          type: 'tool-call',
+          toolCallIndex: toolCalls.findIndex(
+            call => call.toolCallId === part.toolCallId,
+          ),
+        };
+      case 'tool-result':
+        providerExecutedToolResults.set(part.toolCallId, part);
+        return { type: 'provider-tool-result', toolCallId: part.toolCallId };
+      case 'file':
+        return {
+          type: 'file',
+          data:
+            part.data.type === 'data'
+              ? typeof part.data.data === 'string'
+                ? part.data.data
+                : convertUint8ArrayToBase64(part.data.data)
+              : part.data.url.toString(),
+          mediaType: part.mediaType,
+          providerMetadata: part.providerMetadata,
+        };
+      default:
+        return part;
+    }
+  });
+  const toolInputLifecycleEvents: ToolInputLifecycleEvent[] = toolCalls.flatMap(
+    call => {
+      const tool = serializedTools[call.toolName];
+      if (call.invalid || tool == null) return [];
+      const events: ToolInputLifecycleEvent[] = [];
+      if (tool.hasOnInputStart || tool.hasOnInputAvailable)
+        events.push(['start', call.toolCallId, call.toolName]);
+      if (tool.hasOnInputAvailable) events.push(['available', call.toolCallId]);
+      return events;
+    },
+  );
+  return {
+    toolCalls,
+    finish: {
+      finishReason: response.finishReason.unified,
+      rawFinishReason: response.finishReason.raw,
+      usage: asLanguageModelUsage(response.usage),
+      providerMetadata: response.providerMetadata,
+    },
+    raw: {
+      content,
+      reasoning: [],
+      warnings: response.warnings,
+      responseMetadata: {
+        id: response.response?.id ?? generateId(),
+        timestamp: response.response?.timestamp ?? new Date(),
+        modelId: response.response?.modelId ?? model.modelId,
+        headers: response.response?.headers,
+        ...(options.include?.responseBody
+          ? { body: response.response?.body }
+          : {}),
+      },
+      generation: {
+        provider: model.provider,
+        modelId: model.modelId,
+        responseTimeMs,
+        request: options.include?.requestBody ? response.request : undefined,
+      },
+    },
+    providerExecutedToolResults,
+    toolInputLifecycleEvents,
+  };
+}
+
+doGenerateStep.maxRetries = 0;