ai 6.0.33 → 6.0.34

package/src/embed/embed.test.ts

@@ -0,0 +1,298 @@
+import { EmbeddingModelV3 } from '@ai-sdk/provider';
+import assert from 'node:assert';
+import { beforeEach, describe, expect, it, vi, vitest } from 'vitest';
+import * as logWarningsModule from '../logger/log-warnings';
+import { MockEmbeddingModelV3 } from '../test/mock-embedding-model-v3';
+import { MockTracer } from '../test/mock-tracer';
+import { Embedding, EmbeddingModelUsage, Warning } from '../types';
+import { embed } from './embed';
+
+const dummyEmbedding = [0.1, 0.2, 0.3];
+const testValue = 'sunny day at the beach';
+
+vi.mock('../version', () => {
+  return {
+    VERSION: '0.0.0-test',
+  };
+});
+
+describe('result.embedding', () => {
+  it('should generate embedding', async () => {
+    const result = await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: mockEmbed([testValue], [dummyEmbedding]),
+      }),
+      value: testValue,
+    });
+
+    assert.deepStrictEqual(result.embedding, dummyEmbedding);
+  });
+});
+
+describe('result.response', () => {
+  it('should include response in the result', async () => {
+    const result = await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: mockEmbed([testValue], [dummyEmbedding], undefined, {
+          body: { foo: 'bar' },
+          headers: { foo: 'bar' },
+        }),
+      }),
+      value: testValue,
+    });
+
+    expect(result.response?.body).toMatchInlineSnapshot(`
+      {
+        "foo": "bar",
+      }
+    `);
+    expect(result.response?.headers).toMatchInlineSnapshot(`
+      {
+        "foo": "bar",
+      }
+    `);
+  });
+});
+
+describe('result.value', () => {
+  it('should include value in the result', async () => {
+    const result = await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: mockEmbed([testValue], [dummyEmbedding]),
+      }),
+      value: testValue,
+    });
+
+    assert.deepStrictEqual(result.value, testValue);
+  });
+});
+
+describe('result.usage', () => {
+  it('should include usage in the result', async () => {
+    const result = await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: mockEmbed([testValue], [dummyEmbedding], { tokens: 10 }),
+      }),
+      value: testValue,
+    });
+
+    assert.deepStrictEqual(result.usage, { tokens: 10 });
+  });
+});
+
+describe('result.providerMetadata', () => {
+  it('should include provider metadata when returned by the model', async () => {
+    const providerMetadata = {
+      gateway: {
+        routing: {
+          resolvedProvider: 'test-provider',
+        },
+      },
+    };
+
+    const result = await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: mockEmbed(
+          [testValue],
+          [dummyEmbedding],
+          undefined,
+          {
+            headers: {},
+            body: {},
+          },
+          providerMetadata,
+        ),
+      }),
+      value: testValue,
+    });
+
+    expect(result.providerMetadata).toStrictEqual(providerMetadata);
+  });
+});
+
+describe('options.headers', () => {
+  it('should set headers', async () => {
+    const result = await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: async ({ headers }) => {
+          assert.deepStrictEqual(headers, {
+            'custom-request-header': 'request-header-value',
+            'user-agent': 'ai/0.0.0-test',
+          });
+
+          return { embeddings: [dummyEmbedding], warnings: [] };
+        },
+      }),
+      value: testValue,
+      headers: {
+        'custom-request-header': 'request-header-value',
+      },
+    });
+
+    assert.deepStrictEqual(result.embedding, dummyEmbedding);
+  });
+});
+
+describe('options.providerOptions', () => {
+  it('should pass provider options to model', async () => {
+    const result = await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: async ({ providerOptions }) => {
+          expect(providerOptions).toStrictEqual({
+            aProvider: { someKey: 'someValue' },
+          });
+
+          return { embeddings: [[1, 2, 3]], warnings: [] };
+        },
+      }),
+      value: 'test-input',
+      providerOptions: {
+        aProvider: { someKey: 'someValue' },
+      },
+    });
+
+    expect(result.embedding).toStrictEqual([1, 2, 3]);
+  });
+});
+
+describe('result.warnings', () => {
+  it('should include warnings in the result', async () => {
+    const expectedWarnings: Warning[] = [
+      {
+        type: 'other',
+        message: 'Setting is not supported',
+      },
+      {
+        type: 'unsupported',
+        feature: 'dimensions',
+        details: 'Dimensions parameter not supported',
+      },
+    ];
+
+    const result = await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: async () => ({
+          embeddings: [dummyEmbedding],
+          warnings: expectedWarnings,
+        }),
+      }),
+      value: testValue,
+    });
+
+    expect(result.warnings).toStrictEqual(expectedWarnings);
+  });
+});
+
+describe('logWarnings', () => {
+  let logWarningsSpy: ReturnType<typeof vitest.spyOn>;
+
+  beforeEach(() => {
+    logWarningsSpy = vitest.spyOn(logWarningsModule, 'logWarnings');
+  });
+
+  it('should call logWarnings with the correct warnings', async () => {
+    const expectedWarnings: Warning[] = [
+      {
+        type: 'other',
+        message: 'Setting is not supported',
+      },
+      {
+        type: 'unsupported',
+        feature: 'dimensions',
+        details: 'Dimensions parameter not supported',
+      },
+    ];
+
+    await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: async () => ({
+          embeddings: [dummyEmbedding],
+          warnings: expectedWarnings,
+        }),
+      }),
+      value: testValue,
+    });
+
+    expect(logWarningsSpy).toHaveBeenCalledOnce();
+    expect(logWarningsSpy).toHaveBeenCalledWith({
+      warnings: expectedWarnings,
+      provider: 'mock-provider',
+      model: 'mock-model-id',
+    });
+  });
+});
+
+describe('telemetry', () => {
+  let tracer: MockTracer;
+
+  beforeEach(() => {
+    tracer = new MockTracer();
+  });
+
+  it('should not record any telemetry data when not explicitly enabled', async () => {
+    await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: mockEmbed([testValue], [dummyEmbedding]),
+      }),
+      value: testValue,
+      experimental_telemetry: { tracer },
+    });
+
+    expect(tracer.jsonSpans).toMatchSnapshot();
+  });
+
+  it('should record telemetry data when enabled', async () => {
+    await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: mockEmbed([testValue], [dummyEmbedding], { tokens: 10 }),
+      }),
+      value: testValue,
+      experimental_telemetry: {
+        isEnabled: true,
+        functionId: 'test-function-id',
+        metadata: {
+          test1: 'value1',
+          test2: false,
+        },
+        tracer,
+      },
+    });
+
+    expect(tracer.jsonSpans).toMatchSnapshot();
+  });
+
+  it('should not record telemetry inputs / outputs when disabled', async () => {
+    await embed({
+      model: new MockEmbeddingModelV3({
+        doEmbed: mockEmbed([testValue], [dummyEmbedding], { tokens: 10 }),
+      }),
+      value: testValue,
+      experimental_telemetry: {
+        isEnabled: true,
+        recordInputs: false,
+        recordOutputs: false,
+        tracer,
+      },
+    });
+
+    expect(tracer.jsonSpans).toMatchSnapshot();
+  });
+});
+
+function mockEmbed(
+  expectedValues: Array<string>,
+  embeddings: Array<Embedding>,
+  usage?: EmbeddingModelUsage,
+  response: Awaited<ReturnType<EmbeddingModelV3['doEmbed']>>['response'] = {
+    headers: {},
+    body: {},
+  },
+  providerMetadata?: Awaited<
+    ReturnType<EmbeddingModelV3['doEmbed']>
+  >['providerMetadata'],
+): EmbeddingModelV3['doEmbed'] {
+  return async ({ values }) => {
+    assert.deepStrictEqual(expectedValues, values);
+    return { embeddings, usage, response, providerMetadata, warnings: [] };
+  };
+}

package/src/embed/embed.ts

@@ -0,0 +1,211 @@
+import { ProviderOptions, withUserAgentSuffix } from '@ai-sdk/provider-utils';
+import { logWarnings } from '../logger/log-warnings';
+import { resolveEmbeddingModel } from '../model/resolve-model';
+import { assembleOperationName } from '../telemetry/assemble-operation-name';
+import { getBaseTelemetryAttributes } from '../telemetry/get-base-telemetry-attributes';
+import { getTracer } from '../telemetry/get-tracer';
+import { recordSpan } from '../telemetry/record-span';
+import { selectTelemetryAttributes } from '../telemetry/select-telemetry-attributes';
+import { TelemetrySettings } from '../telemetry/telemetry-settings';
+import { EmbeddingModel } from '../types';
+import { prepareRetries } from '../util/prepare-retries';
+import { EmbedResult } from './embed-result';
+import { VERSION } from '../version';
+
+/**
+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.
+
+@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,
+}: {
+  /**
+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;
+}): Promise<EmbedResult> {
+  const model = resolveEmbeddingModel(modelArg);
+
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal,
+  });
+
+  const headersWithUserAgent = withUserAgentSuffix(
+    headers ?? {},
+    `ai/${VERSION}`,
+  );
+
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    model: model,
+    telemetry,
+    headers: headersWithUserAgent,
+    settings: { maxRetries },
+  });
+
+  const tracer = getTracer(telemetry);
+
+  return recordSpan({
+    name: 'ai.embed',
+    attributes: selectTelemetryAttributes({
+      telemetry,
+      attributes: {
+        ...assembleOperationName({ operationId: 'ai.embed', telemetry }),
+        ...baseTelemetryAttributes,
+        'ai.value': { input: () => JSON.stringify(value) },
+      },
+    }),
+    tracer,
+    fn: async span => {
+      const { embedding, usage, warnings, response, providerMetadata } =
+        await retry(() =>
+          // nested spans to align with the embedMany telemetry data:
+          recordSpan({
+            name: 'ai.embed.doEmbed',
+            attributes: selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                ...assembleOperationName({
+                  operationId: 'ai.embed.doEmbed',
+                  telemetry,
+                }),
+                ...baseTelemetryAttributes,
+                // specific settings that only make sense on the outer level:
+                'ai.values': { input: () => [JSON.stringify(value)] },
+              },
+            }),
+            tracer,
+            fn: async doEmbedSpan => {
+              const modelResponse = await model.doEmbed({
+                values: [value],
+                abortSignal,
+                headers: headersWithUserAgent,
+                providerOptions,
+              });
+
+              const embedding = modelResponse.embeddings[0];
+              const usage = modelResponse.usage ?? { tokens: NaN };
+
+              doEmbedSpan.setAttributes(
+                await selectTelemetryAttributes({
+                  telemetry,
+                  attributes: {
+                    'ai.embeddings': {
+                      output: () =>
+                        modelResponse.embeddings.map(embedding =>
+                          JSON.stringify(embedding),
+                        ),
+                    },
+                    'ai.usage.tokens': usage.tokens,
+                  },
+                }),
+              );
+
+              return {
+                embedding,
+                usage,
+                warnings: modelResponse.warnings,
+                providerMetadata: modelResponse.providerMetadata,
+                response: modelResponse.response,
+              };
+            },
+          }),
+        );
+
+      span.setAttributes(
+        await selectTelemetryAttributes({
+          telemetry,
+          attributes: {
+            'ai.embedding': { output: () => JSON.stringify(embedding) },
+            'ai.usage.tokens': usage.tokens,
+          },
+        }),
+      );
+
+      logWarnings({ warnings, provider: model.provider, model: model.modelId });
+
+      return new DefaultEmbedResult({
+        value,
+        embedding,
+        usage,
+        warnings,
+        providerMetadata,
+        response,
+      });
+    },
+  });
+}
+
+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,4 @@
+export * from './embed';
+export * from './embed-many';
+export * from './embed-many-result';
+export * from './embed-result';

package/src/error/index.ts

@@ -0,0 +1,34 @@
+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 { 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 { NoSuchToolError } from './no-such-tool-error';
+export { ToolCallRepairError } from './tool-call-repair-error';
+export { UnsupportedModelVersionError } from './unsupported-model-version-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 { SingleRequestTextStreamPart } from '../generate-text/run-tools-transformation';
+
+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: SingleRequestTextStreamPart<any>;
+
+  constructor({
+    chunk,
+    message,
+  }: {
+    chunk: SingleRequestTextStreamPart<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);
+  }
+}