@fondation-io/ai 7.0.0-beta.45

package/src/embed/embed.ts

@@ -0,0 +1,266 @@
+import {
+  createIdGenerator,
+  ProviderOptions,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { logWarnings } from '../logger/log-warnings';
+import { resolveEmbeddingModel } from '../model/resolve-model';
+import { getGlobalTelemetryIntegration } from '../telemetry/get-global-telemetry-integration';
+import { TelemetrySettings } from '../telemetry/telemetry-settings';
+import { EmbeddingModel } from '../types';
+import { notify } from '../util/notify';
+import { prepareRetries } from '../util/prepare-retries';
+import type { EmbedOnFinishEvent, EmbedOnStartEvent } from './embed-events';
+import { EmbedResult } from './embed-result';
+import { VERSION } from '../version';
+import type { Listener } from '../util/notify';
+
+const originalGenerateCallId = createIdGenerator({
+  prefix: 'call',
+  size: 24,
+});
+
+/**
+ * Embed a value using an embedding model. The type of the value is defined by the embedding model.
+ *
+ * @param model - The embedding model to use.
+ * @param value - The value that should be embedded.
+ *
+ * @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+ * @param abortSignal - An optional abort signal that can be used to cancel the call.
+ * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+ *
+ * @param experimental_telemetry - Optional telemetry configuration (experimental).
+ *
+ * @param providerOptions - 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.
+ *
+ * @returns A result object that contains the embedding, the value, and additional information.
+ */
+export async function embed({
+  model: modelArg,
+  value,
+  providerOptions,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  experimental_telemetry: telemetry,
+  experimental_onStart: onStart,
+  experimental_onFinish: onFinish,
+  _internal: { generateCallId = originalGenerateCallId } = {},
+}: {
+  /**
+   * The embedding model to use.
+   */
+  model: EmbeddingModel;
+
+  /**
+   * The value that should be embedded.
+   */
+  value: string;
+
+  /**
+   * Maximum number of retries per embedding model call. Set to 0 to disable retries.
+   *
+   * @default 2
+   */
+  maxRetries?: number;
+
+  /**
+   * Abort signal.
+   */
+  abortSignal?: AbortSignal;
+
+  /**
+   * Additional headers to include in the request.
+   * Only applicable for HTTP-based providers.
+   */
+  headers?: Record<string, string>;
+
+  /**
+   * 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.
+   */
+  providerOptions?: ProviderOptions;
+
+  /**
+   * Optional telemetry configuration (experimental).
+   */
+  experimental_telemetry?: TelemetrySettings;
+
+  /**
+   * Callback that is called when the embed operation begins,
+   * before the embedding model is called.
+   */
+  experimental_onStart?: Listener<EmbedOnStartEvent>;
+
+  /**
+   * Callback that is called when the embed operation completes,
+   * after the embedding model returns.
+   */
+  experimental_onFinish?: Listener<EmbedOnFinishEvent>;
+
+  /**
+   * Internal. For test use only. May change without notice.
+   */
+  _internal?: {
+    generateCallId?: () => string;
+  };
+}): Promise<EmbedResult> {
+  const model = resolveEmbeddingModel(modelArg);
+
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal,
+  });
+
+  const headersWithUserAgent = withUserAgentSuffix(
+    headers ?? {},
+    `ai/${VERSION}`,
+  );
+
+  const callId = generateCallId();
+
+  const createGlobalTelemetry = getGlobalTelemetryIntegration();
+  const globalTelemetry = createGlobalTelemetry({
+    integrations: telemetry?.integrations,
+  });
+
+  await notify({
+    event: {
+      callId,
+      operationId: 'ai.embed',
+      provider: model.provider,
+      modelId: model.modelId,
+      value,
+      maxRetries,
+      abortSignal,
+      headers: headersWithUserAgent,
+      providerOptions,
+      isEnabled: telemetry?.isEnabled,
+      recordInputs: telemetry?.recordInputs,
+      recordOutputs: telemetry?.recordOutputs,
+      functionId: telemetry?.functionId,
+      metadata: telemetry?.metadata,
+    },
+    callbacks: [onStart, globalTelemetry.onStart],
+  });
+
+  try {
+    const { embedding, usage, warnings, response, providerMetadata } =
+      await retry(async () => {
+        const embedCallId = generateCallId();
+
+        await notify({
+          event: {
+            callId,
+            embedCallId,
+            operationId: 'ai.embed.doEmbed',
+            provider: model.provider,
+            modelId: model.modelId,
+            values: [value],
+            isEnabled: telemetry?.isEnabled,
+            recordInputs: telemetry?.recordInputs,
+            recordOutputs: telemetry?.recordOutputs,
+            functionId: telemetry?.functionId,
+            metadata: telemetry?.metadata,
+          },
+          callbacks: [globalTelemetry.onEmbedStart],
+        });
+
+        const modelResponse = await model.doEmbed({
+          values: [value],
+          abortSignal,
+          headers: headersWithUserAgent,
+          providerOptions,
+        });
+
+        const embedding = modelResponse.embeddings[0];
+        const usage = modelResponse.usage ?? { tokens: NaN };
+
+        await notify({
+          event: {
+            callId,
+            embedCallId,
+            operationId: 'ai.embed.doEmbed',
+            provider: model.provider,
+            modelId: model.modelId,
+            values: [value],
+            embeddings: modelResponse.embeddings,
+            usage,
+          },
+          callbacks: [globalTelemetry.onEmbedFinish],
+        });
+
+        return {
+          embedding,
+          usage,
+          warnings: modelResponse.warnings,
+          providerMetadata: modelResponse.providerMetadata,
+          response: modelResponse.response,
+        };
+      });
+
+    logWarnings({ warnings, provider: model.provider, model: model.modelId });
+
+    await notify({
+      event: {
+        callId,
+        operationId: 'ai.embed',
+        provider: model.provider,
+        modelId: model.modelId,
+        value,
+        embedding,
+        usage,
+        warnings,
+        providerMetadata,
+        response,
+        isEnabled: telemetry?.isEnabled,
+        recordInputs: telemetry?.recordInputs,
+        recordOutputs: telemetry?.recordOutputs,
+        functionId: telemetry?.functionId,
+        metadata: telemetry?.metadata,
+      },
+      callbacks: [onFinish, globalTelemetry.onFinish],
+    });
+
+    return new DefaultEmbedResult({
+      value,
+      embedding,
+      usage,
+      warnings,
+      providerMetadata,
+      response,
+    });
+  } catch (error) {
+    await globalTelemetry.onError?.({ callId, error });
+    throw error;
+  }
+}
+
+class DefaultEmbedResult implements EmbedResult {
+  readonly value: EmbedResult['value'];
+  readonly embedding: EmbedResult['embedding'];
+  readonly usage: EmbedResult['usage'];
+  readonly warnings: EmbedResult['warnings'];
+  readonly providerMetadata: EmbedResult['providerMetadata'];
+  readonly response: EmbedResult['response'];
+
+  constructor(options: {
+    value: EmbedResult['value'];
+    embedding: EmbedResult['embedding'];
+    usage: EmbedResult['usage'];
+    warnings: EmbedResult['warnings'];
+    providerMetadata?: EmbedResult['providerMetadata'];
+    response?: EmbedResult['response'];
+  }) {
+    this.value = options.value;
+    this.embedding = options.embedding;
+    this.usage = options.usage;
+    this.warnings = options.warnings;
+    this.providerMetadata = options.providerMetadata;
+    this.response = options.response;
+  }
+}

package/src/embed/index.ts

@@ -0,0 +1,5 @@
+export * from './embed';
+export * from './embed-events';
+export * from './embed-many';
+export * from './embed-many-result';
+export * from './embed-result';

package/src/error/index.ts

@@ -0,0 +1,37 @@
+export {
+  AISDKError,
+  APICallError,
+  EmptyResponseBodyError,
+  InvalidPromptError,
+  InvalidResponseDataError,
+  JSONParseError,
+  LoadAPIKeyError,
+  LoadSettingError,
+  NoContentGeneratedError,
+  NoSuchModelError,
+  TooManyEmbeddingValuesForCallError,
+  TypeValidationError,
+  UnsupportedFunctionalityError,
+} from '@ai-sdk/provider';
+
+export { InvalidArgumentError } from './invalid-argument-error';
+export { InvalidStreamPartError } from './invalid-stream-part-error';
+export { InvalidToolApprovalError } from './invalid-tool-approval-error';
+export { InvalidToolInputError } from './invalid-tool-input-error';
+export { ToolCallNotFoundForApprovalError } from './tool-call-not-found-for-approval-error';
+export { MissingToolResultsError } from './missing-tool-result-error';
+export { NoImageGeneratedError } from './no-image-generated-error';
+export { NoObjectGeneratedError } from './no-object-generated-error';
+export { NoOutputGeneratedError } from './no-output-generated-error';
+export { NoSpeechGeneratedError } from './no-speech-generated-error';
+export { NoTranscriptGeneratedError } from './no-transcript-generated-error';
+export { NoVideoGeneratedError } from './no-video-generated-error';
+export { NoSuchToolError } from './no-such-tool-error';
+export { ToolCallRepairError } from './tool-call-repair-error';
+export { UnsupportedModelVersionError } from './unsupported-model-version-error';
+export { UIMessageStreamError } from './ui-message-stream-error';
+export { InvalidDataContentError } from '../prompt/invalid-data-content-error';
+export { InvalidMessageRoleError } from '../prompt/invalid-message-role-error';
+export { MessageConversionError } from '../prompt/message-conversion-error';
+export { DownloadError } from '@ai-sdk/provider-utils';
+export { RetryError } from '../util/retry-error';

package/src/error/invalid-argument-error.ts

@@ -0,0 +1,34 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_InvalidArgumentError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class InvalidArgumentError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly parameter: string;
+  readonly value: unknown;
+
+  constructor({
+    parameter,
+    value,
+    message,
+  }: {
+    parameter: string;
+    value: unknown;
+    message: string;
+  }) {
+    super({
+      name,
+      message: `Invalid argument for parameter ${parameter}: ${message}`,
+    });
+
+    this.parameter = parameter;
+    this.value = value;
+  }
+
+  static isInstance(error: unknown): error is InvalidArgumentError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/invalid-stream-part-error.ts

@@ -0,0 +1,28 @@
+import { AISDKError } from '@ai-sdk/provider';
+import { ModelCallStreamPart } from '../generate-text/stream-model-call';
+
+const name = 'AI_InvalidStreamPartError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class InvalidStreamPartError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly chunk: ModelCallStreamPart<any>;
+
+  constructor({
+    chunk,
+    message,
+  }: {
+    chunk: ModelCallStreamPart<any>;
+    message: string;
+  }) {
+    super({ name, message });
+
+    this.chunk = chunk;
+  }
+
+  static isInstance(error: unknown): error is InvalidStreamPartError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/invalid-tool-approval-error.ts

@@ -0,0 +1,26 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_InvalidToolApprovalError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class InvalidToolApprovalError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly approvalId: string;
+
+  constructor({ approvalId }: { approvalId: string }) {
+    super({
+      name,
+      message:
+        `Tool approval response references unknown approvalId: "${approvalId}". ` +
+        `No matching tool-approval-request found in message history.`,
+    });
+
+    this.approvalId = approvalId;
+  }
+
+  static isInstance(error: unknown): error is InvalidToolApprovalError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/invalid-tool-input-error.ts

@@ -0,0 +1,33 @@
+import { AISDKError, getErrorMessage } from '@ai-sdk/provider';
+
+const name = 'AI_InvalidToolInputError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class InvalidToolInputError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly toolName: string;
+  readonly toolInput: string;
+
+  constructor({
+    toolInput,
+    toolName,
+    cause,
+    message = `Invalid input for tool ${toolName}: ${getErrorMessage(cause)}`,
+  }: {
+    message?: string;
+    toolInput: string;
+    toolName: string;
+    cause: unknown;
+  }) {
+    super({ name, message, cause });
+
+    this.toolInput = toolInput;
+    this.toolName = toolName;
+  }
+
+  static isInstance(error: unknown): error is InvalidToolInputError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/missing-tool-result-error.ts

@@ -0,0 +1,28 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_MissingToolResultsError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class MissingToolResultsError extends AISDKError {
+  private readonly [symbol] = true;
+
+  readonly toolCallIds: string[];
+
+  constructor({ toolCallIds }: { toolCallIds: string[] }) {
+    super({
+      name,
+      message: `Tool result${
+        toolCallIds.length > 1 ? 's are' : ' is'
+      } missing for tool call${toolCallIds.length > 1 ? 's' : ''} ${toolCallIds.join(
+        ', ',
+      )}.`,
+    });
+
+    this.toolCallIds = toolCallIds;
+  }
+
+  static isInstance(error: unknown): error is MissingToolResultsError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/no-image-generated-error.ts

@@ -0,0 +1,39 @@
+import { AISDKError } from '@ai-sdk/provider';
+import { ImageModelResponseMetadata } from '../types/image-model-response-metadata';
+
+const name = 'AI_NoImageGeneratedError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Thrown when no image could be generated. This can have multiple causes:
+ *
+ * - The model failed to generate a response.
+ * - The model generated a response that could not be parsed.
+ */
+export class NoImageGeneratedError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  /**
+   * The response metadata for each call.
+   */
+  readonly responses: Array<ImageModelResponseMetadata> | undefined;
+
+  constructor({
+    message = 'No image generated.',
+    cause,
+    responses,
+  }: {
+    message?: string;
+    cause?: Error;
+    responses?: Array<ImageModelResponseMetadata>;
+  }) {
+    super({ name, message, cause });
+
+    this.responses = responses;
+  }
+
+  static isInstance(error: unknown): error is NoImageGeneratedError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/no-object-generated-error.ts

@@ -0,0 +1,70 @@
+import { AISDKError } from '@ai-sdk/provider';
+import { FinishReason } from '../types/language-model';
+import { LanguageModelResponseMetadata } from '../types/language-model-response-metadata';
+import { LanguageModelUsage } from '../types/usage';
+
+const name = 'AI_NoObjectGeneratedError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Thrown when no object could be generated. This can have several causes:
+ *
+ * - The model failed to generate a response.
+ * - The model generated a response that could not be parsed.
+ * - The model generated a response that could not be validated against the schema.
+ *
+ * The error contains the following properties:
+ *
+ * - `text`: The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
+ */
+export class NoObjectGeneratedError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  /**
+   * The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
+   */
+  readonly text: string | undefined;
+
+  /**
+   * The response metadata.
+   */
+  readonly response: LanguageModelResponseMetadata | undefined;
+
+  /**
+   * The usage of the model.
+   */
+  readonly usage: LanguageModelUsage | undefined;
+
+  /**
+   * Reason why the model finished generating a response.
+   */
+  readonly finishReason: FinishReason | undefined;
+
+  constructor({
+    message = 'No object generated.',
+    cause,
+    text,
+    response,
+    usage,
+    finishReason,
+  }: {
+    message?: string;
+    cause?: Error;
+    text?: string;
+    response: LanguageModelResponseMetadata;
+    usage: LanguageModelUsage;
+    finishReason: FinishReason;
+  }) {
+    super({ name, message, cause });
+
+    this.text = text;
+    this.response = response;
+    this.usage = usage;
+    this.finishReason = finishReason;
+  }
+
+  static isInstance(error: unknown): error is NoObjectGeneratedError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/no-output-generated-error.ts

@@ -0,0 +1,26 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_NoOutputGeneratedError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Thrown when no LLM output was generated, e.g. because of errors.
+ */
+export class NoOutputGeneratedError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  constructor({
+    message = 'No output generated.',
+    cause,
+  }: {
+    message?: string;
+    cause?: Error;
+  } = {}) {
+    super({ name, message, cause });
+  }
+
+  static isInstance(error: unknown): error is NoOutputGeneratedError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/no-speech-generated-error.ts

@@ -0,0 +1,28 @@
+import { AISDKError } from '@ai-sdk/provider';
+import { SpeechModelResponseMetadata } from '../types/speech-model-response-metadata';
+
+const name = 'AI_NoSpeechGeneratedError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Error that is thrown when no speech audio was generated.
+ */
+export class NoSpeechGeneratedError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly responses: Array<SpeechModelResponseMetadata>;
+
+  constructor(options: { responses: Array<SpeechModelResponseMetadata> }) {
+    super({
+      name,
+      message: 'No speech audio generated.',
+    });
+
+    this.responses = options.responses;
+  }
+
+  static isInstance(error: unknown): error is NoSpeechGeneratedError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/no-such-tool-error.ts

@@ -0,0 +1,35 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_NoSuchToolError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export class NoSuchToolError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly toolName: string;
+  readonly availableTools: string[] | undefined;
+
+  constructor({
+    toolName,
+    availableTools = undefined,
+    message = `Model tried to call unavailable tool '${toolName}'. ${
+      availableTools === undefined
+        ? 'No tools are available.'
+        : `Available tools: ${availableTools.join(', ')}.`
+    }`,
+  }: {
+    toolName: string;
+    availableTools?: string[] | undefined;
+    message?: string;
+  }) {
+    super({ name, message });
+
+    this.toolName = toolName;
+    this.availableTools = availableTools;
+  }
+
+  static isInstance(error: unknown): error is NoSuchToolError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}

package/src/error/no-transcript-generated-error.ts

@@ -0,0 +1,30 @@
+import { AISDKError } from '@ai-sdk/provider';
+import { TranscriptionModelResponseMetadata } from '../types/transcription-model-response-metadata';
+
+const name = 'AI_NoTranscriptGeneratedError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Error that is thrown when no transcript was generated.
+ */
+export class NoTranscriptGeneratedError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  readonly responses: Array<TranscriptionModelResponseMetadata>;
+
+  constructor(options: {
+    responses: Array<TranscriptionModelResponseMetadata>;
+  }) {
+    super({
+      name,
+      message: 'No transcript generated.',
+    });
+
+    this.responses = options.responses;
+  }
+
+  static isInstance(error: unknown): error is NoTranscriptGeneratedError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}