ai 6.0.33 → 6.0.34

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

@@ -0,0 +1,163 @@
+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,
+}: {
+  content: Array<ContentPart<TOOLS>>;
+  tools: TOOLS | undefined;
+}): Promise<Array<AssistantModelMessage | ToolModelMessage>> {
+  const responseMessages: Array<AssistantModelMessage | ToolModelMessage> = [];
+
+  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 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 '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 '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;
+    }
+
+    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, LanguageModelV3ToolCall } 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: LanguageModelV3ToolCall;
+  tools: TOOLS;
+  inputSchema: (options: { toolName: string }) => PromiseLike<JSONSchema7>;
+  error: NoSuchToolError | InvalidToolInputError;
+}) => Promise<LanguageModelV3ToolCall | 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/global.ts

@@ -0,0 +1,24 @@
+import { ProviderV3 } from '@ai-sdk/provider';
+import { LogWarningsFunction } from './logger/log-warnings';
+
+// add AI SDK default provider to the globalThis object
+declare global {
+  /**
+   * The default provider to use for the AI SDK.
+   * String model ids are resolved to the default provider and model id.
+   *
+   * If not set, the default provider is the Vercel AI gateway provider.
+   *
+   * @see https://ai-sdk.dev/docs/ai-sdk-core/provider-management#global-provider-configuration
+   */
+  var AI_SDK_DEFAULT_PROVIDER: ProviderV3 | undefined;
+
+  /**
+   * The warning logger to use for the AI SDK.
+   *
+   * If not set, the default logger is the console.warn function.
+   *
+   * If set to false, no warnings are logged.
+   */
+  var AI_SDK_LOG_WARNINGS: LogWarningsFunction | undefined | false;
+}

package/src/index.ts

@@ -0,0 +1,50 @@
+// re-exports:
+export { createGateway, gateway, type GatewayModelId } from '@ai-sdk/gateway';
+export {
+  asSchema,
+  createIdGenerator,
+  dynamicTool,
+  generateId,
+  jsonSchema,
+  parseJsonEventStream,
+  tool,
+  zodSchema,
+  type FlexibleSchema,
+  type IdGenerator,
+  type InferSchema,
+  type InferToolInput,
+  type InferToolOutput,
+  type Schema,
+  type Tool,
+  type ToolApprovalRequest,
+  type ToolApprovalResponse,
+  type ToolCallOptions,
+  type ToolExecutionOptions,
+  type ToolExecuteFunction,
+} from '@ai-sdk/provider-utils';
+
+// directory exports
+export * from './agent';
+export * from './embed';
+export * from './error';
+export * from './generate-image';
+export * from './generate-object';
+export * from './generate-speech';
+export * from './generate-text';
+export * from './logger';
+export * from './middleware';
+export * from './prompt';
+export * from './registry';
+export * from './rerank';
+export * from './text-stream';
+export * from './transcribe';
+export * from './types';
+export * from './ui';
+export * from './ui-message-stream';
+export * from './util';
+
+// telemetry types:
+export type { TelemetrySettings } from './telemetry/telemetry-settings';
+
+// import globals
+import './global';

package/src/logger/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @deprecated  Use `LogWarningsFunction` instead.
+ */
+export type { LogWarningsFunction as Experimental_LogWarningsFunction } from './log-warnings';
+
+export { type LogWarningsFunction } from './log-warnings';