ai 6.0.32 → 6.0.34

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

@@ -0,0 +1,188 @@
+import { LanguageModelV3ToolCall } from '@ai-sdk/provider';
+import {
+  asSchema,
+  ModelMessage,
+  safeParseJSON,
+  safeValidateTypes,
+  SystemModelMessage,
+} from '@ai-sdk/provider-utils';
+import { InvalidToolInputError } from '../error/invalid-tool-input-error';
+import { NoSuchToolError } from '../error/no-such-tool-error';
+import { ToolCallRepairError } from '../error/tool-call-repair-error';
+import { DynamicToolCall, TypedToolCall } from './tool-call';
+import { ToolCallRepairFunction } from './tool-call-repair-function';
+import { ToolSet } from './tool-set';
+
+export async function parseToolCall<TOOLS extends ToolSet>({
+  toolCall,
+  tools,
+  repairToolCall,
+  system,
+  messages,
+}: {
+  toolCall: LanguageModelV3ToolCall;
+  tools: TOOLS | undefined;
+  repairToolCall: ToolCallRepairFunction<TOOLS> | undefined;
+  system: string | SystemModelMessage | Array<SystemModelMessage> | undefined;
+  messages: ModelMessage[];
+}): Promise<TypedToolCall<TOOLS>> {
+  try {
+    if (tools == null) {
+      // provider-executed dynamic tools are not part of our list of tools:
+      if (toolCall.providerExecuted && toolCall.dynamic) {
+        return await parseProviderExecutedDynamicToolCall(toolCall);
+      }
+
+      throw new NoSuchToolError({ toolName: toolCall.toolName });
+    }
+
+    try {
+      return await doParseToolCall({ toolCall, tools });
+    } catch (error) {
+      if (
+        repairToolCall == null ||
+        !(
+          NoSuchToolError.isInstance(error) ||
+          InvalidToolInputError.isInstance(error)
+        )
+      ) {
+        throw error;
+      }
+
+      let repairedToolCall: LanguageModelV3ToolCall | null = null;
+
+      try {
+        repairedToolCall = await repairToolCall({
+          toolCall,
+          tools,
+          inputSchema: async ({ toolName }) => {
+            const { inputSchema } = tools[toolName];
+            return await asSchema(inputSchema).jsonSchema;
+          },
+          system,
+          messages,
+          error,
+        });
+      } catch (repairError) {
+        throw new ToolCallRepairError({
+          cause: repairError,
+          originalError: error,
+        });
+      }
+
+      // no repaired tool call returned
+      if (repairedToolCall == null) {
+        throw error;
+      }
+
+      return await doParseToolCall({ toolCall: repairedToolCall, tools });
+    }
+  } catch (error) {
+    // use parsed input when possible
+    const parsedInput = await safeParseJSON({ text: toolCall.input });
+    const input = parsedInput.success ? parsedInput.value : toolCall.input;
+
+    // TODO AI SDK 6: special invalid tool call parts
+    return {
+      type: 'tool-call',
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      input,
+      dynamic: true,
+      invalid: true,
+      error,
+      title: tools?.[toolCall.toolName]?.title,
+      providerExecuted: toolCall.providerExecuted,
+      providerMetadata: toolCall.providerMetadata,
+    };
+  }
+}
+
+async function parseProviderExecutedDynamicToolCall(
+  toolCall: LanguageModelV3ToolCall,
+): Promise<DynamicToolCall> {
+  const parseResult =
+    toolCall.input.trim() === ''
+      ? { success: true as const, value: {} }
+      : await safeParseJSON({ text: toolCall.input });
+
+  if (parseResult.success === false) {
+    throw new InvalidToolInputError({
+      toolName: toolCall.toolName,
+      toolInput: toolCall.input,
+      cause: parseResult.error,
+    });
+  }
+
+  return {
+    type: 'tool-call',
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: parseResult.value,
+    providerExecuted: true,
+    dynamic: true,
+    providerMetadata: toolCall.providerMetadata,
+  };
+}
+
+async function doParseToolCall<TOOLS extends ToolSet>({
+  toolCall,
+  tools,
+}: {
+  toolCall: LanguageModelV3ToolCall;
+  tools: TOOLS;
+}): Promise<TypedToolCall<TOOLS>> {
+  const toolName = toolCall.toolName as keyof TOOLS & string;
+
+  const tool = tools[toolName];
+
+  if (tool == null) {
+    // provider-executed dynamic tools are not part of our list of tools:
+    if (toolCall.providerExecuted && toolCall.dynamic) {
+      return await parseProviderExecutedDynamicToolCall(toolCall);
+    }
+
+    throw new NoSuchToolError({
+      toolName: toolCall.toolName,
+      availableTools: Object.keys(tools),
+    });
+  }
+
+  const schema = asSchema(tool.inputSchema);
+
+  // when the tool call has no arguments, we try passing an empty object to the schema
+  // (many LLMs generate empty strings for tool calls with no arguments)
+  const parseResult =
+    toolCall.input.trim() === ''
+      ? await safeValidateTypes({ value: {}, schema })
+      : await safeParseJSON({ text: toolCall.input, schema });
+
+  if (parseResult.success === false) {
+    throw new InvalidToolInputError({
+      toolName,
+      toolInput: toolCall.input,
+      cause: parseResult.error,
+    });
+  }
+
+  return tool.type === 'dynamic'
+    ? {
+        type: 'tool-call',
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        input: parseResult.value,
+        providerExecuted: toolCall.providerExecuted,
+        providerMetadata: toolCall.providerMetadata,
+        dynamic: true,
+        title: tool.title,
+      }
+    : {
+        type: 'tool-call',
+        toolCallId: toolCall.toolCallId,
+        toolName,
+        input: parseResult.value,
+        providerExecuted: toolCall.providerExecuted,
+        providerMetadata: toolCall.providerMetadata,
+        title: tool.title,
+      };
+}

package/src/generate-text/prepare-step.ts

@@ -0,0 +1,103 @@
+import {
+  ModelMessage,
+  ProviderOptions,
+  SystemModelMessage,
+  Tool,
+} from '@ai-sdk/provider-utils';
+import { LanguageModel, ToolChoice } from '../types/language-model';
+import { StepResult } from './step-result';
+
+/**
+ * Function that you can use to provide different settings for a step.
+ *
+ * @param options - The options for the step.
+ * @param options.steps - The steps that have been executed so far.
+ * @param options.stepNumber - The number of the step that is being executed.
+ * @param options.model - The model that is being used.
+ * @param options.messages - The messages that will be sent to the model for the current step.
+ * @param options.experimental_context - The context passed via the experimental_context setting (experimental).
+ *
+ * @returns An object that contains the settings for the step.
+ * If you return undefined (or for undefined settings), the settings from the outer level will be used.
+ */
+export type PrepareStepFunction<
+  TOOLS extends Record<string, Tool> = Record<string, Tool>,
+> = (options: {
+  /**
+   * The steps that have been executed so far.
+   */
+  steps: Array<StepResult<NoInfer<TOOLS>>>;
+
+  /**
+   * The number of the step that is being executed.
+   */
+  stepNumber: number;
+
+  /**
+   * The model instance that is being used for this step.
+   */
+  model: LanguageModel;
+
+  /**
+   * The messages that will be sent to the model for the current step.
+   */
+  messages: Array<ModelMessage>;
+
+  /**
+   * The context passed via the experimental_context setting (experimental).
+   */
+  experimental_context: unknown;
+}) => PromiseLike<PrepareStepResult<TOOLS>> | PrepareStepResult<TOOLS>;
+
+/**
+ * The result type returned by a {@link PrepareStepFunction},
+ * allowing per-step overrides of model, tools, or messages.
+ */
+export type PrepareStepResult<
+  TOOLS extends Record<string, Tool> = Record<string, Tool>,
+> =
+  | {
+      /**
+       * Optionally override which LanguageModel instance is used for this step.
+       */
+      model?: LanguageModel;
+
+      /**
+       * Optionally set which tool the model must call, or provide tool call configuration
+       * for this step.
+       */
+      toolChoice?: ToolChoice<NoInfer<TOOLS>>;
+
+      /**
+       * If provided, only these tools are enabled/available for this step.
+       */
+      activeTools?: Array<keyof NoInfer<TOOLS>>;
+
+      /**
+       * Optionally override the system message(s) sent to the model for this step.
+       */
+      system?: string | SystemModelMessage | Array<SystemModelMessage>;
+
+      /**
+       * Optionally override the full set of messages sent to the model
+       * for this step.
+       */
+      messages?: Array<ModelMessage>;
+
+      /**
+       * Context that is passed into tool execution. Experimental.
+       *
+       * Changing the context will affect the context in this step
+       * and all subsequent steps.
+       */
+      experimental_context?: unknown;
+
+      /**
+       * Additional provider-specific options for this step.
+       *
+       * Can be used to pass provider-specific configuration such as
+       * container IDs for Anthropic's code execution.
+       */
+      providerOptions?: ProviderOptions;
+    }
+  | undefined;