@depup/ai 6.0.116-depup.0

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;

package/src/generate-text/prune-messages.ts

@@ -0,0 +1,167 @@
+import {
+  AssistantModelMessage,
+  ModelMessage,
+  ToolModelMessage,
+} from '@ai-sdk/provider-utils';
+
+/**
+ * Prunes model messages from a list of model messages.
+ *
+ * @param messages - The list of model messages to prune.
+ * @param reasoning - How to remove reasoning content from assistant messages. Default is `'none'`.
+ * @param toolCalls - How to prune tool call/results/approval content. Default is `[]`.
+ * @param emptyMessages - Whether to keep or remove messages whose content is empty after pruning. Default is `'remove'`.
+ *
+ * @returns The pruned list of model messages.
+ */
+export function pruneMessages({
+  messages,
+  reasoning = 'none',
+  toolCalls = [],
+  emptyMessages = 'remove',
+}: {
+  messages: ModelMessage[];
+  reasoning?: 'all' | 'before-last-message' | 'none';
+  toolCalls?:
+    | 'all'
+    | 'before-last-message'
+    | `before-last-${number}-messages`
+    | 'none'
+    | Array<{
+        type: 'all' | 'before-last-message' | `before-last-${number}-messages`;
+        tools?: string[];
+      }>;
+  emptyMessages?: 'keep' | 'remove';
+}): ModelMessage[] {
+  // filter reasoning parts:
+  if (reasoning === 'all' || reasoning === 'before-last-message') {
+    messages = messages.map((message, messageIndex) => {
+      if (
+        message.role !== 'assistant' ||
+        typeof message.content === 'string' ||
+        (reasoning === 'before-last-message' &&
+          messageIndex === messages.length - 1)
+      ) {
+        return message;
+      }
+
+      return {
+        ...message,
+        content: message.content.filter(part => part.type !== 'reasoning'),
+      };
+    });
+  }
+
+  // filter tool calls, results, errors, and approvals:
+  if (toolCalls === 'none') {
+    toolCalls = [];
+  } else if (toolCalls === 'all') {
+    toolCalls = [{ type: 'all' }];
+  } else if (toolCalls === 'before-last-message') {
+    toolCalls = [{ type: 'before-last-message' }];
+  } else if (typeof toolCalls === 'string') {
+    toolCalls = [{ type: toolCalls }];
+  }
+
+  for (const toolCall of toolCalls) {
+    // determine how many trailing messages to keep:
+    const keepLastMessagesCount =
+      toolCall.type === 'all'
+        ? undefined
+        : toolCall.type === 'before-last-message'
+          ? 1
+          : Number(
+              toolCall.type
+                .slice('before-last-'.length)
+                .slice(0, -'-messages'.length),
+            );
+
+    // scan kept messages to identify tool calls and approvals that need to be kept:
+    const keptToolCallIds: Set<string> = new Set();
+    const keptApprovalIds: Set<string> = new Set();
+
+    if (keepLastMessagesCount != null) {
+      for (const message of messages.slice(-keepLastMessagesCount)) {
+        if (
+          (message.role === 'assistant' || message.role === 'tool') &&
+          typeof message.content !== 'string'
+        ) {
+          for (const part of message.content) {
+            if (part.type === 'tool-call' || part.type === 'tool-result') {
+              keptToolCallIds.add(part.toolCallId);
+            } else if (
+              part.type === 'tool-approval-request' ||
+              part.type === 'tool-approval-response'
+            ) {
+              keptApprovalIds.add(part.approvalId);
+            }
+          }
+        }
+      }
+    }
+
+    messages = messages.map((message, messageIndex) => {
+      if (
+        (message.role !== 'assistant' && message.role !== 'tool') ||
+        typeof message.content === 'string' ||
+        (keepLastMessagesCount &&
+          messageIndex >= messages.length - keepLastMessagesCount)
+      ) {
+        return message;
+      }
+
+      const toolCallIdToToolName: Record<string, string> = {};
+      const approvalIdToToolName: Record<string, string> = {};
+
+      return {
+        ...message,
+        content: message.content.filter(part => {
+          // keep non-tool parts:
+          if (
+            part.type !== 'tool-call' &&
+            part.type !== 'tool-result' &&
+            part.type !== 'tool-approval-request' &&
+            part.type !== 'tool-approval-response'
+          ) {
+            return true;
+          }
+
+          // track tool calls and approvals:
+          if (part.type === 'tool-call') {
+            toolCallIdToToolName[part.toolCallId] = part.toolName;
+          } else if (part.type === 'tool-approval-request') {
+            approvalIdToToolName[part.approvalId] =
+              toolCallIdToToolName[part.toolCallId];
+          }
+
+          // keep parts that are associated with a tool call or approval that needs to be kept:
+          if (
+            ((part.type === 'tool-call' || part.type === 'tool-result') &&
+              keptToolCallIds.has(part.toolCallId)) ||
+            ((part.type === 'tool-approval-request' ||
+              part.type === 'tool-approval-response') &&
+              keptApprovalIds.has(part.approvalId))
+          ) {
+            return true;
+          }
+
+          // keep parts that are not associated with a tool that should be removed:
+          return (
+            toolCall.tools != null &&
+            !toolCall.tools.includes(
+              part.type === 'tool-call' || part.type === 'tool-result'
+                ? part.toolName
+                : approvalIdToToolName[part.approvalId],
+            )
+          );
+        }),
+      } as AssistantModelMessage | ToolModelMessage;
+    });
+  }
+
+  if (emptyMessages === 'remove') {
+    messages = messages.filter(message => message.content.length > 0);
+  }
+
+  return messages;
+}

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

@@ -0,0 +1,20 @@
+import { ProviderMetadata } from '../types/provider-metadata';
+
+/**
+ * Reasoning output of a text generation. It contains a reasoning.
+ */
+export interface ReasoningOutput {
+  type: 'reasoning';
+
+  /**
+   * The reasoning text.
+   */
+  text: string;
+
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerMetadata?: ProviderMetadata;
+}

package/src/generate-text/reasoning.ts

@@ -0,0 +1,8 @@
+import { ReasoningPart } from '@ai-sdk/provider-utils';
+
+export function asReasoningText(
+  reasoningParts: Array<ReasoningPart>,
+): string | undefined {
+  const reasoningText = reasoningParts.map(part => part.text).join('');
+  return reasoningText.length > 0 ? reasoningText : undefined;
+}

package/src/generate-text/response-message.ts

@@ -0,0 +1,10 @@
+import {
+  AssistantModelMessage,
+  ToolModelMessage,
+} from '@ai-sdk/provider-utils';
+
+/**
+ * A message that was generated during the generation process.
+ * It can be either an assistant message or a tool message.
+ */
+export type ResponseMessage = AssistantModelMessage | ToolModelMessage;