@fondation-io/ai 7.0.0-beta.45

package/src/generate-text/to-response-messages.ts

@@ -0,0 +1,195 @@
+import {
+  AssistantContent,
+  AssistantModelMessage,
+  ToolContent,
+  ToolModelMessage,
+} from '../prompt';
+import { createToolModelOutput } from '../prompt/create-tool-model-output';
+import { ContentPart } from './content-part';
+import { ToolSet } from './tool-set';
+
+/**
+ * Converts the result of a `generateText` or `streamText` call to a list of response messages.
+ */
+export async function toResponseMessages<TOOLS extends ToolSet>({
+  content: inputContent,
+  tools,
+  fireAndForgetTools,
+}: {
+  content: Array<ContentPart<TOOLS>>;
+  tools: TOOLS | undefined;
+  fireAndForgetTools?: Set<string>;
+}): Promise<Array<AssistantModelMessage | ToolModelMessage>> {
+  const responseMessages: Array<AssistantModelMessage | ToolModelMessage> = [];
+  const fireAndForgetToolNames = fireAndForgetTools ?? new Set<string>();
+
+  const content: AssistantContent = [];
+  for (const part of inputContent) {
+    // Skip sources - they are response-only content that no provider expects back
+    if (part.type === 'source') {
+      continue;
+    }
+
+    // Skip fire-and-forget tool calls — they are executed for side effects
+    // but should not appear in messages sent to the model in subsequent steps
+    if (
+      part.type === 'tool-call' &&
+      fireAndForgetToolNames.has(part.toolName)
+    ) {
+      continue;
+    }
+
+    // Skip non-provider-executed tool results/errors (they go in the tool message)
+    if (
+      (part.type === 'tool-result' || part.type === 'tool-error') &&
+      !part.providerExecuted
+    ) {
+      continue;
+    }
+
+    // Skip empty text
+    if (part.type === 'text' && part.text.length === 0) {
+      continue;
+    }
+
+    switch (part.type) {
+      case 'text':
+        content.push({
+          type: 'text',
+          text: part.text,
+          providerOptions: part.providerMetadata,
+        });
+        break;
+      case 'custom':
+        content.push({
+          type: 'custom',
+          kind: part.kind,
+          providerOptions: part.providerMetadata,
+        });
+        break;
+      case 'reasoning':
+        content.push({
+          type: 'reasoning',
+          text: part.text,
+          providerOptions: part.providerMetadata,
+        });
+        break;
+      case 'file':
+        content.push({
+          type: 'file',
+          data: part.file.base64,
+          mediaType: part.file.mediaType,
+          providerOptions: part.providerMetadata,
+        });
+        break;
+      case 'reasoning-file':
+        content.push({
+          type: 'reasoning-file',
+          data: part.file.base64,
+          mediaType: part.file.mediaType,
+          providerOptions: part.providerMetadata,
+        });
+        break;
+      case 'tool-call':
+        content.push({
+          type: 'tool-call',
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          input: part.input,
+          providerExecuted: part.providerExecuted,
+          providerOptions: part.providerMetadata,
+        });
+        break;
+      case 'tool-result': {
+        const output = await createToolModelOutput({
+          toolCallId: part.toolCallId,
+          input: part.input,
+          tool: tools?.[part.toolName],
+          output: part.output,
+          errorMode: 'none',
+        });
+        content.push({
+          type: 'tool-result',
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          output,
+          providerOptions: part.providerMetadata,
+        });
+        break;
+      }
+      case 'tool-error': {
+        const output = await createToolModelOutput({
+          toolCallId: part.toolCallId,
+          input: part.input,
+          tool: tools?.[part.toolName],
+          output: part.error,
+          errorMode: 'json',
+        });
+        content.push({
+          type: 'tool-result',
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          output,
+          providerOptions: part.providerMetadata,
+        });
+        break;
+      }
+      case 'tool-approval-request':
+        content.push({
+          type: 'tool-approval-request',
+          approvalId: part.approvalId,
+          toolCallId: part.toolCall.toolCallId,
+        });
+        break;
+    }
+  }
+
+  if (content.length > 0) {
+    responseMessages.push({
+      role: 'assistant',
+      content,
+    });
+  }
+
+  const toolResultContent: ToolContent = [];
+  for (const part of inputContent) {
+    if (
+      !(part.type === 'tool-result' || part.type === 'tool-error') ||
+      part.providerExecuted
+    ) {
+      continue;
+    }
+
+    // Skip fire-and-forget tool results — not sent to the model
+    if (fireAndForgetToolNames.has(part.toolName)) {
+      continue;
+    }
+
+    const output = await createToolModelOutput({
+      toolCallId: part.toolCallId,
+      input: part.input,
+      tool: tools?.[part.toolName],
+      output: part.type === 'tool-result' ? part.output : part.error,
+      errorMode: part.type === 'tool-error' ? 'text' : 'none',
+    });
+
+    toolResultContent.push({
+      type: 'tool-result',
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      output,
+      ...(part.providerMetadata != null
+        ? { providerOptions: part.providerMetadata }
+        : {}),
+    });
+  }
+
+  if (toolResultContent.length > 0) {
+    responseMessages.push({
+      role: 'tool',
+      content: toolResultContent,
+    });
+  }
+
+  return responseMessages;
+}

package/src/generate-text/tool-approval-request-output.ts

@@ -0,0 +1,21 @@
+import { TypedToolCall } from './tool-call';
+import { ToolSet } from './tool-set';
+
+/**
+ * Output part that indicates that a tool approval request has been made.
+ *
+ * The tool approval request can be approved or denied in the next tool message.
+ */
+export type ToolApprovalRequestOutput<TOOLS extends ToolSet> = {
+  type: 'tool-approval-request';
+
+  /**
+   * ID of the tool approval request.
+   */
+  approvalId: string;
+
+  /**
+   * Tool call that the approval request is for.
+   */
+  toolCall: TypedToolCall<TOOLS>;
+};

package/src/generate-text/tool-call-repair-function.ts

@@ -0,0 +1,27 @@
+import { JSONSchema7, LanguageModelV4ToolCall } from '@ai-sdk/provider';
+import { InvalidToolInputError } from '../error/invalid-tool-input-error';
+import { NoSuchToolError } from '../error/no-such-tool-error';
+import { ModelMessage, SystemModelMessage } from '../prompt';
+import { ToolSet } from './tool-set';
+
+/**
+ * A function that attempts to repair a tool call that failed to parse.
+ *
+ * It receives the error and the context as arguments and returns the repair
+ * tool call JSON as text.
+ *
+ * @param options.system - The system prompt.
+ * @param options.messages - The messages in the current generation step.
+ * @param options.toolCall - The tool call that failed to parse.
+ * @param options.tools - The tools that are available.
+ * @param options.inputSchema - A function that returns the JSON Schema for a tool.
+ * @param options.error - The error that occurred while parsing the tool call.
+ */
+export type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
+  system: string | SystemModelMessage | Array<SystemModelMessage> | undefined;
+  messages: ModelMessage[];
+  toolCall: LanguageModelV4ToolCall;
+  tools: TOOLS;
+  inputSchema: (options: { toolName: string }) => PromiseLike<JSONSchema7>;
+  error: NoSuchToolError | InvalidToolInputError;
+}) => Promise<LanguageModelV4ToolCall | null>;

package/src/generate-text/tool-call.ts

@@ -0,0 +1,47 @@
+import { Tool } from '@ai-sdk/provider-utils';
+import { ProviderMetadata } from '../types';
+import { ValueOf } from '../util/value-of';
+import { ToolSet } from './tool-set';
+
+type BaseToolCall = {
+  type: 'tool-call';
+  toolCallId: string;
+  providerExecuted?: boolean;
+  providerMetadata?: ProviderMetadata;
+};
+
+export type StaticToolCall<TOOLS extends ToolSet> = ValueOf<{
+  [NAME in keyof TOOLS]: BaseToolCall & {
+    toolName: NAME & string;
+    input: TOOLS[NAME] extends Tool<infer PARAMETERS> ? PARAMETERS : never;
+    dynamic?: false | undefined;
+    invalid?: false | undefined;
+    error?: never;
+    title?: string;
+  };
+}>;
+
+export type DynamicToolCall = BaseToolCall & {
+  toolName: string;
+  input: unknown;
+  dynamic: true;
+  title?: string;
+
+  /**
+   * True if this is caused by an unparsable tool call or
+   * a tool that does not exist.
+   */
+  // Added into DynamicToolCall to avoid breaking changes.
+  // TODO AI SDK 6: separate into a new InvalidToolCall type
+  invalid?: boolean;
+
+  /**
+   * The error that caused the tool call to be invalid.
+   */
+  // TODO AI SDK 6: separate into a new InvalidToolCall type
+  error?: unknown;
+};
+
+export type TypedToolCall<TOOLS extends ToolSet> =
+  | StaticToolCall<TOOLS>
+  | DynamicToolCall;

package/src/generate-text/tool-error.ts

@@ -0,0 +1,34 @@
+import { InferToolInput } from '@ai-sdk/provider-utils';
+import { ProviderMetadata } from '../types';
+import { ValueOf } from '../util/value-of';
+import { ToolSet } from './tool-set';
+
+export type StaticToolError<TOOLS extends ToolSet> = ValueOf<{
+  [NAME in keyof TOOLS]: {
+    type: 'tool-error';
+    toolCallId: string;
+    toolName: NAME & string;
+    input: InferToolInput<TOOLS[NAME]>;
+    error: unknown;
+    providerExecuted?: boolean;
+    providerMetadata?: ProviderMetadata;
+    dynamic?: false | undefined;
+    title?: string;
+  };
+}>;
+
+export type DynamicToolError = {
+  type: 'tool-error';
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  error: unknown;
+  providerExecuted?: boolean;
+  providerMetadata?: ProviderMetadata;
+  dynamic: true;
+  title?: string;
+};
+
+export type TypedToolError<TOOLS extends ToolSet> =
+  | StaticToolError<TOOLS>
+  | DynamicToolError;

package/src/generate-text/tool-output-denied.ts

@@ -0,0 +1,21 @@
+import { ValueOf } from '../util/value-of';
+import { ToolSet } from './tool-set';
+
+/**
+ * Tool output when the tool execution has been denied (for static tools).
+ */
+export type StaticToolOutputDenied<TOOLS extends ToolSet> = ValueOf<{
+  [NAME in keyof TOOLS]: {
+    type: 'tool-output-denied';
+    toolCallId: string;
+    toolName: NAME & string;
+    providerExecuted?: boolean;
+    dynamic?: false | undefined;
+  };
+}>;
+
+/**
+ * Tool output when the tool execution has been denied.
+ */
+export type TypedToolOutputDenied<TOOLS extends ToolSet> =
+  StaticToolOutputDenied<TOOLS>;

package/src/generate-text/tool-output.ts

@@ -0,0 +1,7 @@
+import { TypedToolError } from './tool-error';
+import { TypedToolResult } from './tool-result';
+import { ToolSet } from './tool-set';
+
+export type ToolOutput<TOOLS extends ToolSet> =
+  | TypedToolResult<TOOLS>
+  | TypedToolError<TOOLS>;

package/src/generate-text/tool-result.ts

@@ -0,0 +1,36 @@
+import { InferToolInput, InferToolOutput } from '@ai-sdk/provider-utils';
+import { ProviderMetadata } from '../types';
+import { ValueOf } from '../../src/util/value-of';
+import { ToolSet } from './tool-set';
+
+export type StaticToolResult<TOOLS extends ToolSet> = ValueOf<{
+  [NAME in keyof TOOLS]: {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: NAME & string;
+    input: InferToolInput<TOOLS[NAME]>;
+    output: InferToolOutput<TOOLS[NAME]>;
+    providerExecuted?: boolean;
+    providerMetadata?: ProviderMetadata;
+    dynamic?: false | undefined;
+    preliminary?: boolean;
+    title?: string;
+  };
+}>;
+
+export type DynamicToolResult = {
+  type: 'tool-result';
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  output: unknown;
+  providerExecuted?: boolean;
+  providerMetadata?: ProviderMetadata;
+  dynamic: true;
+  preliminary?: boolean;
+  title?: string;
+};
+
+export type TypedToolResult<TOOLS extends ToolSet> =
+  | StaticToolResult<TOOLS>
+  | DynamicToolResult;

package/src/generate-text/tool-set.ts

@@ -0,0 +1,14 @@
+import { Tool } from '@ai-sdk/provider-utils';
+
+export type ToolSet = Record<
+  string,
+  (Tool<never, never> | Tool<any, any> | Tool<any, never> | Tool<never, any>) &
+    Pick<
+      Tool<any, any>,
+      | 'execute'
+      | 'onInputAvailable'
+      | 'onInputStart'
+      | 'onInputDelta'
+      | 'needsApproval'
+    >
+>;

package/src/generate-video/generate-video-result.ts

@@ -0,0 +1,36 @@
+import { GeneratedFile } from '../generate-text';
+import { VideoModelProviderMetadata } from '../types/video-model';
+import { VideoModelResponseMetadata } from '../types/video-model-response-metadata';
+import { Warning } from '../types/warning';
+
+/**
+ * The result of an `experimental_generateVideo` call.
+ * Contains the generated video and additional information.
+ */
+export interface GenerateVideoResult {
+  /**
+   * The first video that was generated.
+   */
+  readonly video: GeneratedFile;
+
+  /**
+   * All videos that were generated.
+   */
+  readonly videos: Array<GeneratedFile>;
+
+  /**
+   * Warnings for the call, e.g. unsupported settings.
+   */
+  readonly warnings: Array<Warning>;
+
+  /**
+   * Response metadata from the provider.
+   * May contain multiple responses if multiple calls were made.
+   */
+  readonly responses: Array<VideoModelResponseMetadata>;
+
+  /**
+   * Provider-specific metadata passed through from the provider.
+   */
+  readonly providerMetadata: VideoModelProviderMetadata;
+}