ima2-gen 2.0.6-preview-260629 → 2.0.13

package/node_modules/@ai-sdk/provider-utils/src/types/model-message.ts

@@ -0,0 +1,14 @@
+import { AssistantModelMessage } from './assistant-model-message';
+import { SystemModelMessage } from './system-model-message';
+import { ToolModelMessage } from './tool-model-message';
+import { UserModelMessage } from './user-model-message';
+
+/**
+ * A message that can be used in the `messages` field of a prompt.
+ * It can be a user message, an assistant message, or a tool message.
+ */
+export type ModelMessage =
+  | SystemModelMessage
+  | UserModelMessage
+  | AssistantModelMessage
+  | ToolModelMessage;

package/node_modules/@ai-sdk/provider-utils/src/types/provider-options.ts

@@ -0,0 +1,9 @@
+import { SharedV3ProviderOptions } from '@ai-sdk/provider';
+
+/**
+ * Additional provider-specific options.
+ *
+ * They are passed through to the provider from the AI SDK and enable
+ * provider-specific functionality that can be fully encapsulated in the provider.
+ */
+export type ProviderOptions = SharedV3ProviderOptions;

package/node_modules/@ai-sdk/provider-utils/src/types/system-model-message.ts

@@ -0,0 +1,20 @@
+import { ProviderOptions } from './provider-options';
+
+/**
+ * A system message. It can contain system information.
+ *
+ * Note: using the "system" part of the prompt is strongly preferred
+ * to increase the resilience against prompt injection attacks,
+ * and because not all providers support several system messages.
+ */
+export type SystemModelMessage = {
+  role: 'system';
+  content: 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.
+   */
+  providerOptions?: ProviderOptions;
+};

package/node_modules/@ai-sdk/provider-utils/src/types/tool-approval-request.ts

@@ -0,0 +1,16 @@
+/**
+ * Tool approval request prompt part.
+ */
+export type ToolApprovalRequest = {
+  type: 'tool-approval-request';
+
+  /**
+   * ID of the tool approval.
+   */
+  approvalId: string;
+
+  /**
+   * ID of the tool call that the approval request is for.
+   */
+  toolCallId: string;
+};

package/node_modules/@ai-sdk/provider-utils/src/types/tool-approval-response.ts

@@ -0,0 +1,27 @@
+/**
+ * Tool approval response prompt part.
+ */
+export type ToolApprovalResponse = {
+  type: 'tool-approval-response';
+
+  /**
+   * ID of the tool approval.
+   */
+  approvalId: string;
+
+  /**
+   * Flag indicating whether the approval was granted or denied.
+   */
+  approved: boolean;
+
+  /**
+   * Optional reason for the approval or denial.
+   */
+  reason?: string;
+
+  /**
+   * Flag indicating whether the tool call is provider-executed.
+   * Only provider-executed tool approval responses should be sent to the model.
+   */
+  providerExecuted?: boolean;
+};

package/node_modules/@ai-sdk/provider-utils/src/types/tool-call.ts

@@ -0,0 +1,31 @@
+/**
+ * Typed tool call that is returned by generateText and streamText.
+ * It contains the tool call ID, the tool name, and the tool arguments.
+ */
+export interface ToolCall<NAME extends string, INPUT> {
+  /**
+   * ID of the tool call. This ID is used to match the tool call with the tool result.
+   */
+  toolCallId: string;
+
+  /**
+   * Name of the tool that is being called.
+   */
+  toolName: NAME;
+
+  /**
+   * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+   */
+  input: INPUT;
+
+  /**
+   * Whether the tool call will be executed by the provider.
+   * If this flag is not set or is false, the tool call will be executed by the client.
+   */
+  providerExecuted?: boolean;
+
+  /**
+   * Whether the tool is dynamic.
+   */
+  dynamic?: boolean;
+}

package/node_modules/@ai-sdk/provider-utils/src/types/tool-model-message.ts

@@ -0,0 +1,23 @@
+import { ToolResultPart } from './content-part';
+import { ProviderOptions } from './provider-options';
+import { ToolApprovalResponse } from './tool-approval-response';
+
+/**
+ * A tool message. It contains the result of one or more tool calls.
+ */
+export type ToolModelMessage = {
+  role: 'tool';
+  content: ToolContent;
+
+  /**
+   * 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.
+   */
+  providerOptions?: ProviderOptions;
+};
+
+/**
+ * Content of a tool message. It is an array of tool result parts.
+ */
+export type ToolContent = Array<ToolResultPart | ToolApprovalResponse>;

package/node_modules/@ai-sdk/provider-utils/src/types/tool-result.ts

@@ -0,0 +1,35 @@
+/**
+ * Typed tool result that is returned by `generateText` and `streamText`.
+ * It contains the tool call ID, the tool name, the tool arguments, and the tool result.
+ */
+export interface ToolResult<NAME extends string, INPUT, OUTPUT> {
+  /**
+   * ID of the tool call. This ID is used to match the tool call with the tool result.
+   */
+  toolCallId: string;
+
+  /**
+   * Name of the tool that was called.
+   */
+  toolName: NAME;
+
+  /**
+   * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+   */
+  input: INPUT;
+
+  /**
+   * Result of the tool call. This is the result of the tool's execution.
+   */
+  output: OUTPUT;
+
+  /**
+   * Whether the tool result has been executed by the provider.
+   */
+  providerExecuted?: boolean;
+
+  /**
+   * Whether the tool is dynamic.
+   */
+  dynamic?: boolean;
+}

package/node_modules/@ai-sdk/provider-utils/src/types/tool.ts

@@ -0,0 +1,324 @@
+import { JSONValue } from '@ai-sdk/provider';
+import { FlexibleSchema } from '../schema';
+import { ToolResultOutput } from './content-part';
+import { ModelMessage } from './model-message';
+import { ProviderOptions } from './provider-options';
+
+/**
+ * Additional options that are sent into each tool call.
+ */
+export interface ToolExecutionOptions {
+  /**
+   * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+   */
+  toolCallId: string;
+
+  /**
+   * Messages that were sent to the language model to initiate the response that contained the tool call.
+   * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
+   */
+  messages: ModelMessage[];
+
+  /**
+   * An optional abort signal that indicates that the overall operation should be aborted.
+   */
+  abortSignal?: AbortSignal;
+
+  /**
+   * User-defined context.
+   *
+   * Treat the context object as immutable inside tools.
+   * Mutating the context object can lead to race conditions and unexpected results
+   * when tools are called in parallel.
+   *
+   * If you need to mutate the context, analyze the tool calls and results
+   * in `prepareStep` and update it there.
+   *
+   * Experimental (can break in patch releases).
+   */
+  experimental_context?: unknown;
+}
+
+/**
+ * Function that is called to determine if the tool needs approval before it can be executed.
+ */
+export type ToolNeedsApprovalFunction<INPUT> = (
+  input: INPUT,
+  options: {
+    /**
+     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+     */
+    toolCallId: string;
+
+    /**
+     * Messages that were sent to the language model to initiate the response that contained the tool call.
+     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
+     */
+    messages: ModelMessage[];
+
+    /**
+     * Additional context.
+     *
+     * Experimental (can break in patch releases).
+     */
+    experimental_context?: unknown;
+  },
+) => boolean | PromiseLike<boolean>;
+
+export type ToolExecuteFunction<INPUT, OUTPUT> = (
+  input: INPUT,
+  options: ToolExecutionOptions,
+) => AsyncIterable<OUTPUT> | PromiseLike<OUTPUT> | OUTPUT;
+
+// 0 extends 1 & N checks for any
+// [N] extends [never] checks for never
+type NeverOptional<N, T> = 0 extends 1 & N
+  ? Partial<T>
+  : [N] extends [never]
+    ? Partial<Record<keyof T, undefined>>
+    : T;
+
+type ToolOutputProperties<INPUT, OUTPUT> = NeverOptional<
+  OUTPUT,
+  | {
+      /**
+       * An async function that is called with the arguments from the tool call and produces a result.
+       * If not provided, the tool will not be executed automatically.
+       *
+       * @args is the input of the tool call.
+       * @options.abortSignal is a signal that can be used to abort the tool call.
+       */
+      execute: ToolExecuteFunction<INPUT, OUTPUT>;
+
+      outputSchema?: FlexibleSchema<OUTPUT>;
+    }
+  | {
+      outputSchema: FlexibleSchema<OUTPUT>;
+
+      execute?: never;
+    }
+>;
+
+/**
+ * A tool contains the description and the schema of the input that the tool expects.
+ * This enables the language model to generate the input.
+ *
+ * The tool can also contain an optional execute function for the actual execution function of the tool.
+ */
+export type Tool<
+  INPUT extends JSONValue | unknown | never = any,
+  OUTPUT extends JSONValue | unknown | never = any,
+> = {
+  /**
+   * An optional description of what the tool does.
+   * Will be used by the language model to decide whether to use the tool.
+   * Not used for provider-defined tools.
+   */
+  description?: string;
+
+  /**
+   * An optional title of the tool.
+   */
+  title?: 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.
+   */
+  providerOptions?: ProviderOptions;
+
+  /**
+   * The schema of the input that the tool expects.
+   * The language model will use this to generate the input.
+   * It is also used to validate the output of the language model.
+   *
+   * You can use descriptions on the schema properties to make the input understandable for the language model.
+   */
+  inputSchema: FlexibleSchema<INPUT>;
+
+  /**
+   * An optional list of input examples that show the language
+   * model what the input should look like.
+   */
+  inputExamples?: Array<{ input: NoInfer<INPUT> }>;
+
+  /**
+   * Whether the tool needs approval before it can be executed.
+   */
+  needsApproval?:
+    | boolean
+    | ToolNeedsApprovalFunction<[INPUT] extends [never] ? unknown : INPUT>;
+
+  /**
+   * Strict mode setting for the tool.
+   *
+   * Providers that support strict mode will use this setting to determine
+   * how the input should be generated. Strict mode will always produce
+   * valid inputs, but it might limit what input schemas are supported.
+   */
+  strict?: boolean;
+
+  /**
+   * Optional function that is called when the argument streaming starts.
+   * Only called when the tool is used in a streaming context.
+   */
+  onInputStart?: (options: ToolExecutionOptions) => void | PromiseLike<void>;
+
+  /**
+   * Optional function that is called when an argument streaming delta is available.
+   * Only called when the tool is used in a streaming context.
+   */
+  onInputDelta?: (
+    options: { inputTextDelta: string } & ToolExecutionOptions,
+  ) => void | PromiseLike<void>;
+
+  /**
+   * Optional function that is called when a tool call can be started,
+   * even if the execute function is not provided.
+   */
+  onInputAvailable?: (
+    options: {
+      input: [INPUT] extends [never] ? unknown : INPUT;
+    } & ToolExecutionOptions,
+  ) => void | PromiseLike<void>;
+} & ToolOutputProperties<INPUT, OUTPUT> & {
+    /**
+     * Optional conversion function that maps the tool result to an output that can be used by the language model.
+     *
+     * If not provided, the tool result will be sent as a JSON object.
+     */
+    toModelOutput?: (options: {
+      /**
+       * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+       */
+      toolCallId: string;
+
+      /**
+       * The input of the tool call.
+       */
+      input: [INPUT] extends [never] ? unknown : INPUT;
+
+      /**
+       * The output of the tool call.
+       */
+      output: 0 extends 1 & OUTPUT
+        ? any
+        : [OUTPUT] extends [never]
+          ? any
+          : NoInfer<OUTPUT>;
+    }) => ToolResultOutput | PromiseLike<ToolResultOutput>;
+  } & (
+    | {
+        /**
+         * Tool with user-defined input and output schemas.
+         */
+        type?: undefined | 'function';
+      }
+    | {
+        /**
+         * Tool that is defined at runtime (e.g. an MCP tool).
+         * The types of input and output are not known at development time.
+         */
+        type: 'dynamic';
+      }
+    | {
+        /**
+         * Tool with provider-defined input and output schemas.
+         */
+        type: 'provider';
+
+        /**
+         * The ID of the tool. Must follow the format `<provider-name>.<unique-tool-name>`.
+         */
+        id: `${string}.${string}`;
+
+        /**
+         * The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
+         */
+        args: Record<string, unknown>;
+
+        /**
+         * Whether this provider-executed tool supports deferred results.
+         *
+         * When true, the tool result may not be returned in the same turn as the
+         * tool call (e.g., when using programmatic tool calling where a server tool
+         * triggers a client-executed tool, and the server tool's result is deferred
+         * until the client tool is resolved).
+         *
+         * This flag allows the AI SDK to handle tool results that arrive without
+         * a matching tool call in the current response.
+         *
+         * @default false
+         */
+        supportsDeferredResults?: boolean;
+      }
+  );
+
+/**
+ * Infer the input type of a tool.
+ */
+export type InferToolInput<TOOL extends Tool> =
+  TOOL extends Tool<infer INPUT, any> ? INPUT : never;
+
+/**
+ * Infer the output type of a tool.
+ */
+export type InferToolOutput<TOOL extends Tool> =
+  TOOL extends Tool<any, infer OUTPUT> ? OUTPUT : never;
+
+/**
+ * Helper function for inferring the execute args of a tool.
+ */
+// Note: overload order is important for auto-completion
+export function tool<INPUT, OUTPUT>(
+  tool: Tool<INPUT, OUTPUT>,
+): Tool<INPUT, OUTPUT>;
+export function tool<INPUT>(tool: Tool<INPUT, never>): Tool<INPUT, never>;
+export function tool<OUTPUT>(tool: Tool<never, OUTPUT>): Tool<never, OUTPUT>;
+export function tool(tool: Tool<never, never>): Tool<never, never>;
+export function tool(tool: any): any {
+  return tool;
+}
+
+/**
+ * Defines a dynamic tool.
+ */
+export function dynamicTool(tool: {
+  description?: string;
+  title?: string;
+  providerOptions?: ProviderOptions;
+  inputSchema: FlexibleSchema<unknown>;
+  execute: ToolExecuteFunction<unknown, unknown>;
+
+  /**
+   * Optional conversion function that maps the tool result to an output that can be used by the language model.
+   *
+   * If not provided, the tool result will be sent as a JSON object.
+   */
+  toModelOutput?: (options: {
+    /**
+     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+     */
+    toolCallId: string;
+
+    /**
+     * The input of the tool call.
+     */
+    input: unknown;
+
+    /**
+     * The output of the tool call.
+     */
+    output: unknown;
+  }) => ToolResultOutput | PromiseLike<ToolResultOutput>;
+
+  /**
+   * Whether the tool needs approval before it can be executed.
+   */
+  needsApproval?: boolean | ToolNeedsApprovalFunction<unknown>;
+}): Tool<unknown, unknown> & {
+  type: 'dynamic';
+} {
+  return { ...tool, type: 'dynamic' };
+}

package/node_modules/@ai-sdk/provider-utils/src/types/user-model-message.ts

@@ -0,0 +1,22 @@
+import { FilePart, ImagePart, TextPart } from './content-part';
+import { ProviderOptions } from './provider-options';
+
+/**
+ * A user message. It can contain text or a combination of text and images.
+ */
+export type UserModelMessage = {
+  role: 'user';
+  content: UserContent;
+
+  /**
+   * 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.
+   */
+  providerOptions?: ProviderOptions;
+};
+
+/**
+ * Content of a user message. It can be a string or an array of text and image parts.
+ */
+export type UserContent = string | Array<TextPart | ImagePart | FilePart>;

package/node_modules/@ai-sdk/provider-utils/src/uint8-utils.ts

@@ -0,0 +1,26 @@
+// btoa and atob need to be invoked as a function call, not as a method call.
+// Otherwise CloudFlare will throw a
+// "TypeError: Illegal invocation: function called with incorrect this reference"
+const { btoa, atob } = globalThis;
+
+export function convertBase64ToUint8Array(base64String: string) {
+  const base64Url = base64String.replace(/-/g, '+').replace(/_/g, '/');
+  const latin1string = atob(base64Url);
+  return Uint8Array.from(latin1string, byte => byte.codePointAt(0)!);
+}
+
+export function convertUint8ArrayToBase64(array: Uint8Array): string {
+  let latin1string = '';
+
+  // Note: regular for loop to support older JavaScript versions that
+  // do not support for..of on Uint8Array
+  for (let i = 0; i < array.length; i++) {
+    latin1string += String.fromCodePoint(array[i]);
+  }
+
+  return btoa(latin1string);
+}
+
+export function convertToBase64(value: string | Uint8Array): string {
+  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+}

package/node_modules/@ai-sdk/provider-utils/src/validate-download-url.ts

@@ -0,0 +1,143 @@
+import { DownloadError } from './download-error';
+
+/**
+ * Validates that a URL is safe to download from, blocking private/internal addresses
+ * to prevent SSRF attacks.
+ *
+ * @param url - The URL string to validate.
+ * @throws DownloadError if the URL is unsafe.
+ */
+export function validateDownloadUrl(url: string): void {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new DownloadError({
+      url,
+      message: `Invalid URL: ${url}`,
+    });
+  }
+
+  // Only allow http and https protocols
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new DownloadError({
+      url,
+      message: `URL scheme must be http or https, got ${parsed.protocol}`,
+    });
+  }
+
+  const hostname = parsed.hostname;
+
+  // Block empty hostname
+  if (!hostname) {
+    throw new DownloadError({
+      url,
+      message: `URL must have a hostname`,
+    });
+  }
+
+  // Block localhost and .local domains
+  if (
+    hostname === 'localhost' ||
+    hostname.endsWith('.local') ||
+    hostname.endsWith('.localhost')
+  ) {
+    throw new DownloadError({
+      url,
+      message: `URL with hostname ${hostname} is not allowed`,
+    });
+  }
+
+  // Check for IPv6 addresses (enclosed in brackets in URLs)
+  if (hostname.startsWith('[') && hostname.endsWith(']')) {
+    const ipv6 = hostname.slice(1, -1);
+    if (isPrivateIPv6(ipv6)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IPv6 address ${hostname} is not allowed`,
+      });
+    }
+    return;
+  }
+
+  // Check for IPv4 addresses
+  if (isIPv4(hostname)) {
+    if (isPrivateIPv4(hostname)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IP address ${hostname} is not allowed`,
+      });
+    }
+    return;
+  }
+}
+
+function isIPv4(hostname: string): boolean {
+  const parts = hostname.split('.');
+  if (parts.length !== 4) return false;
+  return parts.every(part => {
+    const num = Number(part);
+    return (
+      Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part
+    );
+  });
+}
+
+function isPrivateIPv4(ip: string): boolean {
+  const parts = ip.split('.').map(Number);
+  const [a, b] = parts;
+
+  // 0.0.0.0/8
+  if (a === 0) return true;
+  // 10.0.0.0/8
+  if (a === 10) return true;
+  // 127.0.0.0/8
+  if (a === 127) return true;
+  // 169.254.0.0/16
+  if (a === 169 && b === 254) return true;
+  // 172.16.0.0/12
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  // 192.168.0.0/16
+  if (a === 192 && b === 168) return true;
+
+  return false;
+}
+
+function isPrivateIPv6(ip: string): boolean {
+  const normalized = ip.toLowerCase();
+
+  // ::1 (loopback)
+  if (normalized === '::1') return true;
+  // :: (unspecified)
+  if (normalized === '::') return true;
+
+  // Check for IPv4-mapped addresses (::ffff:x.x.x.x or ::ffff:HHHH:HHHH)
+  if (normalized.startsWith('::ffff:')) {
+    const mappedPart = normalized.slice(7);
+    // Dotted-decimal form: ::ffff:127.0.0.1
+    if (isIPv4(mappedPart)) {
+      return isPrivateIPv4(mappedPart);
+    }
+    // Hex form: ::ffff:7f00:1 (URL parser normalizes to this)
+    const hexParts = mappedPart.split(':');
+    if (hexParts.length === 2) {
+      const high = parseInt(hexParts[0], 16);
+      const low = parseInt(hexParts[1], 16);
+      if (!isNaN(high) && !isNaN(low)) {
+        const a = (high >> 8) & 0xff;
+        const b = high & 0xff;
+        const c = (low >> 8) & 0xff;
+        const d = low & 0xff;
+        return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+      }
+    }
+  }
+
+  // fc00::/7 (unique local addresses - fc00:: and fd00::)
+  if (normalized.startsWith('fc') || normalized.startsWith('fd')) return true;
+
+  // fe80::/10 (link-local)
+  if (normalized.startsWith('fe80')) return true;
+
+  return false;
+}