@ai-sdk/workflow 2.0.19 → 2.0.21

package/src/stream-text-iterator.ts

@@ -6,6 +6,7 @@ import type {
 } from '@ai-sdk/provider';
 import type { Context } from '@ai-sdk/provider-utils';
 import {
+  DefaultGeneratedFile,
   experimental_filterActiveTools as filterActiveTools,
   type ActiveTools,
   type Experimental_SandboxSession as SandboxSession,
@@ -27,7 +28,9 @@ import {
   type ParsedToolCall,
   type ProviderExecutedToolResult,
   type StreamFinish,
+  type ToolInputLifecycleEvent,
 } from './do-stream-step.js';
+import { resolveToolContext } from './resolve-tool-context.js';
 import { serializeToolSet } from './serializable-schema.js';
 import type {
   GenerationSettings,
@@ -337,6 +340,7 @@ export async function* streamTextIterator({
         headers: currentGenerationSettings.headers,
       } as never);
 
+      const stepInputMessages = conversationPrompt as unknown as ModelMessage[];
       const streamStepResult = await doStreamStep(
         conversationPrompt,
         currentModel,
@@ -362,8 +366,22 @@ export async function* streamTextIterator({
         hasTerminalError = true;
       }
 
-      const { toolCalls, finish, raw, providerExecutedToolResults } =
-        streamStepResult;
+      const {
+        toolCalls,
+        finish,
+        raw,
+        providerExecutedToolResults,
+        toolInputLifecycleEvents,
+      } = streamStepResult;
+      await invokeToolInputLifecycleCallbacks({
+        events: toolInputLifecycleEvents ?? [],
+        toolCalls,
+        tools: effectiveTools,
+        messages: stepInputMessages,
+        abortSignal: currentGenerationSettings.abortSignal,
+        toolsContext: currentToolsContext,
+        experimental_sandbox: stepSandbox,
+      });
       // Reconstruct the full StepResult outside the step boundary so the
       // durable event log doesn't carry StepResult's redundant copies (or the
       // per-chunk snapshot the step used to return).
@@ -402,11 +420,16 @@ export async function* streamTextIterator({
       } else if (finishReason === 'tool-calls') {
         lastStepWasToolCalls = true;
 
-        const textContent = step.content.filter(
-          item => item.type === 'text',
-        ) as Array<{ type: 'text'; text: string }>;
+        const assistantContent = getAssistantMessageContent(step);
+        const includedToolCallIds = new Set(
+          assistantContent.flatMap(part =>
+            part.type === 'tool-call' ? [part.toolCallId] : [],
+          ),
+        );
 
-        // Add assistant message with text and tool calls to the conversation
+        // Add assistant message content in provider emission order. Invalid
+        // tool calls are not part of StepResult.content, so retain the previous
+        // behavior of appending them to the prompt.
         // Note: providerMetadata from the tool call is mapped to providerOptions
         // in the prompt format, following the AI SDK convention. This is critical
         // for providers like Gemini that require thoughtSignature to be preserved
@@ -414,24 +437,10 @@ export async function* streamTextIterator({
         conversationPrompt.push({
           role: 'assistant',
           content: [
-            ...textContent,
-            ...toolCalls.map(toolCall => {
-              const sanitizedMetadata = sanitizeProviderMetadataForToolCall(
-                toolCall.providerMetadata,
-              );
-              return {
-                type: 'tool-call' as const,
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                input: toolCall.input,
-                ...(sanitizedMetadata != null
-                  ? {
-                      providerOptions:
-                        sanitizedMetadata as SharedV4ProviderOptions,
-                    }
-                  : {}),
-              };
-            }),
+            ...assistantContent,
+            ...toolCalls
+              .filter(toolCall => !includedToolCallIds.has(toolCall.toolCallId))
+              .map(toAssistantToolCallContent),
           ],
         });
 
@@ -462,15 +471,13 @@ export async function* streamTextIterator({
           }
         }
       } else if (finishReason === 'stop') {
-        // Add assistant message with text content to the conversation
-        const textContent = step.content.filter(
-          item => item.type === 'text',
-        ) as Array<{ type: 'text'; text: string }>;
+        // Add assistant response content to the conversation
+        const assistantContent = getAssistantMessageContent(step);
 
-        if (textContent.length > 0) {
+        if (assistantContent.length > 0) {
           conversationPrompt.push({
             role: 'assistant',
-            content: textContent,
+            content: assistantContent,
           });
         }
 
@@ -535,6 +542,89 @@ export async function* streamTextIterator({
   return conversationPrompt;
 }
 
+async function invokeToolInputLifecycleCallbacks({
+  events,
+  toolCalls,
+  tools,
+  messages,
+  abortSignal,
+  toolsContext,
+  experimental_sandbox,
+}: {
+  events: ToolInputLifecycleEvent[];
+  toolCalls: ParsedToolCall[];
+  tools: ToolSet;
+  messages: ModelMessage[];
+  abortSignal?: AbortSignal;
+  toolsContext: Record<string, Context | undefined>;
+  experimental_sandbox?: SandboxSession;
+}) {
+  const toolNamesByCallId = new Map<string, string>();
+  const toolCallsById = new Map(
+    toolCalls.map(toolCall => [toolCall.toolCallId, toolCall]),
+  );
+  const resolvedContexts = new Map<string, Promise<unknown>>();
+
+  for (const event of events) {
+    const [type, toolCallId, value] = event;
+    if (type === 'start') {
+      toolNamesByCallId.set(toolCallId, value);
+    }
+
+    const toolName =
+      type === 'start' ? value : toolNamesByCallId.get(toolCallId);
+    if (toolName == null) {
+      continue;
+    }
+
+    const tool = tools[toolName];
+    if (tool == null) {
+      continue;
+    }
+
+    let resolvedContext = resolvedContexts.get(toolName);
+    if (resolvedContext == null) {
+      resolvedContext = resolveToolContext({
+        toolName,
+        tool,
+        toolsContext,
+      });
+      resolvedContexts.set(toolName, resolvedContext);
+    }
+
+    const options = {
+      toolCallId,
+      messages,
+      abortSignal,
+      context: await resolvedContext,
+      experimental_sandbox,
+    };
+
+    switch (type) {
+      case 'start':
+        await tool.onInputStart?.(options);
+        break;
+      case 'delta':
+        await tool.onInputDelta?.({
+          ...options,
+          inputTextDelta: value,
+        });
+        break;
+      case 'available': {
+        const toolCall = toolCallsById.get(toolCallId);
+        if (toolCall == null) {
+          break;
+        }
+        await tool.onInputAvailable?.({
+          ...options,
+          input: toolCall.input,
+        });
+        break;
+      }
+    }
+  }
+}
+
 function getModelInfo(model: LanguageModel): {
   provider: string;
   modelId: string;
@@ -554,9 +644,10 @@ function normalizeStepForTelemetry(step: StepResult<any, any>) {
 /**
  * Reconstruct a full `StepResult` from the minimal aggregates returned by
  * `doStreamStep`. Runs outside the step boundary so StepResult's redundant
- * fields (duplicate tool-call lists, `content`, `reasoningText`, the
- * always-empty `*ToolResults` arrays) and the per-chunk snapshot don't cross
- * it. The shape matches what the AI SDK's `streamText` exposes to callers.
+ * fields (duplicate tool-call lists, `text`, `files`, `sources`, and
+ * `reasoningText`) and the per-chunk snapshot don't cross it. Tool-result
+ * arrays are initialized here and populated after execution. The shape matches
+ * what the AI SDK's `streamText` exposes to callers.
  */
 function buildStepResult(
   raw: DoStreamStepRawResult,
@@ -568,18 +659,89 @@ function buildStepResult(
     toolsContext: Record<string, Context | undefined>;
   },
 ): StepResult<ToolSet, any> {
-  const { text, reasoning: reasoningParts, responseMetadata, warnings } = raw;
+  const {
+    content: rawContent,
+    reasoning: reasoningParts,
+    responseMetadata,
+    warnings,
+  } = raw;
   const reasoningText = reasoningParts.map(r => r.text).join('') || undefined;
-
-  const validToolCalls = toolCalls
-    .filter(tc => !tc.invalid)
-    .map(tc => ({
-      type: 'tool-call' as const,
-      toolCallId: tc.toolCallId,
-      toolName: tc.toolName,
-      input: tc.input,
-      ...(tc.dynamic ? { dynamic: true as const } : {}),
-    }));
+  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 '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-call': {
+        const toolCall = validToolCallsByIndex.get(part.toolCallIndex);
+        if (toolCall != null) {
+          content.push(toolCall);
+        }
+        break;
+      }
+    }
+  }
 
   return {
     callId: 'workflow-agent',
@@ -592,20 +754,17 @@ function buildStepResult(
     metadata: undefined,
     runtimeContext: opts.runtimeContext ?? {},
     toolsContext: opts.toolsContext ?? {},
-    content: [
-      ...(text ? [{ type: 'text' as const, text }] : []),
-      ...validToolCalls,
-    ],
+    content,
     text,
     reasoning: reasoningParts.map(r => ({
       type: 'reasoning' as const,
       text: r.text,
     })),
     reasoningText,
-    files: [],
-    sources: [],
+    files,
+    sources,
     toolCalls: validToolCalls,
-    staticToolCalls: [],
+    staticToolCalls: validToolCalls.filter(tc => tc.dynamic !== true),
     dynamicToolCalls: validToolCalls.filter(tc => tc.dynamic),
     toolResults: [],
     staticToolResults: [],
@@ -653,6 +812,69 @@ function buildStepResult(
   } as StepResult<ToolSet, any>;
 }
 
+function getAssistantMessageContent(
+  step: StepResult<any, any>,
+): Extract<LanguageModelV4Prompt[number], { role: 'assistant' }>['content'] {
+  const content: Extract<
+    LanguageModelV4Prompt[number],
+    { role: 'assistant' }
+  >['content'] = [];
+
+  for (const part of step.content) {
+    switch (part.type) {
+      case 'text':
+        if (part.text.length > 0) {
+          content.push({ type: 'text', text: part.text });
+        }
+        break;
+      case 'file':
+        content.push({
+          type: 'file',
+          data: { type: 'data', data: part.file.base64 },
+          mediaType: part.file.mediaType,
+          ...(part.providerMetadata != null
+            ? {
+                providerOptions:
+                  part.providerMetadata as SharedV4ProviderOptions,
+              }
+            : {}),
+        });
+        break;
+      case 'tool-call':
+        content.push(toAssistantToolCallContent(part));
+        break;
+    }
+  }
+
+  return content;
+}
+
+function toAssistantToolCallContent(toolCall: {
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  providerExecuted?: boolean;
+  providerMetadata?: unknown;
+}) {
+  const sanitizedMetadata = sanitizeProviderMetadataForToolCall(
+    toolCall.providerMetadata,
+  );
+  return {
+    type: 'tool-call' as const,
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: toolCall.input,
+    ...(toolCall.providerExecuted != null
+      ? { providerExecuted: toolCall.providerExecuted }
+      : {}),
+    ...(sanitizedMetadata != null
+      ? {
+          providerOptions: sanitizedMetadata as SharedV4ProviderOptions,
+        }
+      : {}),
+  };
+}
+
 /**
  * Strip OpenAI's itemId from providerMetadata (requires reasoning items we don't preserve).
  * Preserves all other provider metadata (e.g., Gemini's thoughtSignature).