@depup/ai 6.0.116-depup.0

package/src/model/resolve-model.ts

@@ -0,0 +1,159 @@
+import { gateway } from '@ai-sdk/gateway';
+import {
+  EmbeddingModelV3,
+  Experimental_VideoModelV3,
+  ImageModelV3,
+  LanguageModelV3,
+  ProviderV3,
+  SpeechModelV3,
+  TranscriptionModelV3,
+} from '@ai-sdk/provider';
+import { UnsupportedModelVersionError } from '../error';
+import { EmbeddingModel } from '../types/embedding-model';
+import { LanguageModel } from '../types/language-model';
+import { SpeechModel } from '../types/speech-model';
+import { TranscriptionModel } from '../types/transcription-model';
+import { asEmbeddingModelV3 } from './as-embedding-model-v3';
+import { asImageModelV3 } from './as-image-model-v3';
+import { asLanguageModelV3 } from './as-language-model-v3';
+import { asSpeechModelV3 } from './as-speech-model-v3';
+import { asTranscriptionModelV3 } from './as-transcription-model-v3';
+import { ImageModel } from '../types/image-model';
+import { VideoModel } from '../types/video-model';
+
+export function resolveLanguageModel(model: LanguageModel): LanguageModelV3 {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+
+    return asLanguageModelV3(model);
+  }
+
+  return getGlobalProvider().languageModel(model);
+}
+
+export function resolveEmbeddingModel(model: EmbeddingModel): EmbeddingModelV3 {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+
+    return asEmbeddingModelV3(model);
+  }
+
+  return getGlobalProvider().embeddingModel(model);
+}
+
+export function resolveTranscriptionModel(
+  model: TranscriptionModel,
+): TranscriptionModelV3 | undefined {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+    return asTranscriptionModelV3(model);
+  }
+
+  return getGlobalProvider().transcriptionModel?.(model);
+}
+
+export function resolveSpeechModel(
+  model: SpeechModel,
+): SpeechModelV3 | undefined {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+    return asSpeechModelV3(model);
+  }
+
+  return getGlobalProvider().speechModel?.(model);
+}
+
+export function resolveImageModel(model: ImageModel): ImageModelV3 {
+  if (typeof model !== 'string') {
+    if (
+      model.specificationVersion !== 'v3' &&
+      model.specificationVersion !== 'v2'
+    ) {
+      const unsupportedModel: any = model;
+      throw new UnsupportedModelVersionError({
+        version: unsupportedModel.specificationVersion,
+        provider: unsupportedModel.provider,
+        modelId: unsupportedModel.modelId,
+      });
+    }
+
+    return asImageModelV3(model);
+  }
+
+  return getGlobalProvider().imageModel(model);
+}
+
+export function resolveVideoModel(
+  model: VideoModel,
+): Experimental_VideoModelV3 {
+  if (typeof model === 'string') {
+    const provider = getGlobalProvider();
+    // TODO AI SDK v7
+    // @ts-expect-error - videoModel support is experimental
+    const videoModel = provider.videoModel;
+
+    if (!videoModel) {
+      throw new Error(
+        'The default provider does not support video models. ' +
+          'Please use a Experimental_VideoModelV3 object from a provider (e.g., vertex.video("model-id")).',
+      );
+    }
+
+    return videoModel(model);
+  }
+
+  if (model.specificationVersion !== 'v3') {
+    const unsupportedModel: any = model;
+    throw new UnsupportedModelVersionError({
+      version: unsupportedModel.specificationVersion,
+      provider: unsupportedModel.provider,
+      modelId: unsupportedModel.modelId,
+    });
+  }
+
+  return model;
+}
+
+function getGlobalProvider(): ProviderV3 {
+  return globalThis.AI_SDK_DEFAULT_PROVIDER ?? gateway;
+}

package/src/prompt/call-settings.ts

@@ -0,0 +1,148 @@
+/**
+ * Timeout configuration for API calls. Can be specified as:
+ * - A number representing milliseconds
+ * - An object with `totalMs` property for the total timeout in milliseconds
+ * - An object with `stepMs` property for the timeout of each step in milliseconds
+ * - An object with `chunkMs` property for the timeout between stream chunks (streaming only)
+ */
+export type TimeoutConfiguration =
+  | number
+  | { totalMs?: number; stepMs?: number; chunkMs?: number };
+
+/**
+ * Extracts the total timeout value in milliseconds from a TimeoutConfiguration.
+ *
+ * @param timeout - The timeout configuration.
+ * @returns The total timeout in milliseconds, or undefined if no timeout is configured.
+ */
+export function getTotalTimeoutMs(
+  timeout: TimeoutConfiguration | undefined,
+): number | undefined {
+  if (timeout == null) {
+    return undefined;
+  }
+  if (typeof timeout === 'number') {
+    return timeout;
+  }
+  return timeout.totalMs;
+}
+
+/**
+ * Extracts the step timeout value in milliseconds from a TimeoutConfiguration.
+ *
+ * @param timeout - The timeout configuration.
+ * @returns The step timeout in milliseconds, or undefined if no step timeout is configured.
+ */
+export function getStepTimeoutMs(
+  timeout: TimeoutConfiguration | undefined,
+): number | undefined {
+  if (timeout == null || typeof timeout === 'number') {
+    return undefined;
+  }
+  return timeout.stepMs;
+}
+
+/**
+ * Extracts the chunk timeout value in milliseconds from a TimeoutConfiguration.
+ * This timeout is for streaming only - it aborts if no new chunk is received within the specified duration.
+ *
+ * @param timeout - The timeout configuration.
+ * @returns The chunk timeout in milliseconds, or undefined if no chunk timeout is configured.
+ */
+export function getChunkTimeoutMs(
+  timeout: TimeoutConfiguration | undefined,
+): number | undefined {
+  if (timeout == null || typeof timeout === 'number') {
+    return undefined;
+  }
+  return timeout.chunkMs;
+}
+
+export type CallSettings = {
+  /**
+   * Maximum number of tokens to generate.
+   */
+  maxOutputTokens?: number;
+
+  /**
+   * Temperature setting. The range depends on the provider and model.
+   *
+   * It is recommended to set either `temperature` or `topP`, but not both.
+   */
+  temperature?: number;
+
+  /**
+   * Nucleus sampling. This is a number between 0 and 1.
+   *
+   * E.g. 0.1 would mean that only tokens with the top 10% probability mass
+   * are considered.
+   *
+   * It is recommended to set either `temperature` or `topP`, but not both.
+   */
+  topP?: number;
+
+  /**
+   * Only sample from the top K options for each subsequent token.
+   *
+   * Used to remove "long tail" low probability responses.
+   * Recommended for advanced use cases only. You usually only need to use temperature.
+   */
+  topK?: number;
+
+  /**
+   * Presence penalty setting. It affects the likelihood of the model to
+   * repeat information that is already in the prompt.
+   *
+   * The presence penalty is a number between -1 (increase repetition)
+   * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+   */
+  presencePenalty?: number;
+
+  /**
+   * Frequency penalty setting. It affects the likelihood of the model
+   * to repeatedly use the same words or phrases.
+   *
+   * The frequency penalty is a number between -1 (increase repetition)
+   * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+   */
+  frequencyPenalty?: number;
+
+  /**
+   * Stop sequences.
+   * If set, the model will stop generating text when one of the stop sequences is generated.
+   * Providers may have limits on the number of stop sequences.
+   */
+  stopSequences?: string[];
+
+  /**
+   * The seed (integer) to use for random sampling. If set and supported
+   * by the model, calls will generate deterministic results.
+   */
+  seed?: number;
+
+  /**
+   * Maximum number of retries. Set to 0 to disable retries.
+   *
+   * @default 2
+   */
+  maxRetries?: number;
+
+  /**
+   * Abort signal.
+   */
+  abortSignal?: AbortSignal;
+
+  /**
+   * Timeout in milliseconds. The call will be aborted if it takes longer
+   * than the specified timeout. Can be used alongside abortSignal.
+   *
+   * Can be specified as a number (milliseconds) or as an object with `totalMs`.
+   */
+  timeout?: TimeoutConfiguration;
+
+  /**
+   * Additional HTTP headers to be sent with the request.
+   * Only applicable for HTTP-based providers.
+   */
+  headers?: Record<string, string | undefined>;
+};

package/src/prompt/content-part.ts

@@ -0,0 +1,215 @@
+import {
+  FilePart,
+  ImagePart,
+  ProviderOptions,
+  ReasoningPart,
+  TextPart,
+  ToolApprovalRequest,
+  ToolApprovalResponse,
+  ToolResultOutput,
+  ToolResultPart,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { jsonValueSchema } from '../types/json-value';
+import { providerMetadataSchema } from '../types/provider-metadata';
+import { dataContentSchema } from './data-content';
+
+/**
+ * @internal
+ */
+export const textPartSchema: z.ZodType<TextPart> = z.object({
+  type: z.literal('text'),
+  text: z.string(),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * @internal
+ */
+export const imagePartSchema: z.ZodType<ImagePart> = z.object({
+  type: z.literal('image'),
+  image: z.union([dataContentSchema, z.instanceof(URL)]),
+  mediaType: z.string().optional(),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * @internal
+ */
+export const filePartSchema: z.ZodType<FilePart> = z.object({
+  type: z.literal('file'),
+  data: z.union([dataContentSchema, z.instanceof(URL)]),
+  filename: z.string().optional(),
+  mediaType: z.string(),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * @internal
+ */
+export const reasoningPartSchema: z.ZodType<ReasoningPart> = z.object({
+  type: z.literal('reasoning'),
+  text: z.string(),
+  providerOptions: providerMetadataSchema.optional(),
+});
+
+/**
+ * Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
+ */
+export interface ToolCallPart {
+  type: 'tool-call';
+
+  /**
+   * 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: string;
+
+  /**
+   * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+   */
+  input: unknown;
+
+  /**
+   * 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;
+}
+
+/**
+ * @internal
+ */
+export const toolCallPartSchema: z.ZodType<ToolCallPart> = z.object({
+  type: z.literal('tool-call'),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  input: z.unknown(),
+  providerOptions: providerMetadataSchema.optional(),
+  providerExecuted: z.boolean().optional(),
+}) as z.ZodType<ToolCallPart>; // necessary bc input is optional on Zod type
+
+/**
+ * @internal
+ */
+export const outputSchema: z.ZodType<ToolResultOutput> = z.discriminatedUnion(
+  'type',
+  [
+    z.object({
+      type: z.literal('text'),
+      value: z.string(),
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('json'),
+      value: jsonValueSchema,
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('execution-denied'),
+      reason: z.string().optional(),
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('error-text'),
+      value: z.string(),
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('error-json'),
+      value: jsonValueSchema,
+      providerOptions: providerMetadataSchema.optional(),
+    }),
+    z.object({
+      type: z.literal('content'),
+      value: z.array(
+        z.union([
+          z.object({
+            type: z.literal('text'),
+            text: z.string(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('media'),
+            data: z.string(),
+            mediaType: z.string(),
+          }),
+          z.object({
+            type: z.literal('file-data'),
+            data: z.string(),
+            mediaType: z.string(),
+            filename: z.string().optional(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('file-url'),
+            url: z.string(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('file-id'),
+            fileId: z.union([z.string(), z.record(z.string(), z.string())]),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('image-data'),
+            data: z.string(),
+            mediaType: z.string(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('image-url'),
+            url: z.string(),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('image-file-id'),
+            fileId: z.union([z.string(), z.record(z.string(), z.string())]),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+          z.object({
+            type: z.literal('custom'),
+            providerOptions: providerMetadataSchema.optional(),
+          }),
+        ]),
+      ),
+    }),
+  ],
+);
+
+/**
+ * @internal
+ */
+export const toolResultPartSchema: z.ZodType<ToolResultPart> = z.object({
+  type: z.literal('tool-result'),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  output: outputSchema,
+  providerOptions: providerMetadataSchema.optional(),
+}) as z.ZodType<ToolResultPart>; // necessary bc result is optional on Zod type
+
+/**
+ * @internal
+ */
+export const toolApprovalRequestSchema: z.ZodType<ToolApprovalRequest> =
+  z.object({
+    type: z.literal('tool-approval-request'),
+    approvalId: z.string(),
+    toolCallId: z.string(),
+  });
+
+/**
+ * @internal
+ */
+export const toolApprovalResponseSchema: z.ZodType<ToolApprovalResponse> =
+  z.object({
+    type: z.literal('tool-approval-response'),
+    approvalId: z.string(),
+    approved: z.boolean(),
+    reason: z.string().optional(),
+  });