@ai-sdk/perplexity 3.0.48 → 3.0.50

package/src/perplexity-embedding-model.ts

@@ -0,0 +1,165 @@
+import {
+  TooManyEmbeddingValuesForCallError,
+  type EmbeddingModelV3,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  parseProviderOptions,
+  postJsonToApi,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import {
+  perplexityEmbeddingModelOptions,
+  type PerplexityEmbeddingModelId,
+} from './perplexity-embedding-model-options';
+import { perplexityErrorSchema } from './perplexity-language-model';
+
+type PerplexityEmbeddingConfig = {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+};
+
+export class PerplexityEmbeddingModel implements EmbeddingModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly modelId: PerplexityEmbeddingModelId;
+  // https://docs.perplexity.ai/docs/embeddings/standard-embeddings
+  readonly maxEmbeddingsPerCall = 512;
+  readonly supportsParallelCalls = true;
+
+  private readonly config: PerplexityEmbeddingConfig;
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    modelId: PerplexityEmbeddingModelId,
+    config: PerplexityEmbeddingConfig,
+  ) {
+    this.modelId = modelId;
+    this.config = config;
+  }
+
+  async doEmbed({
+    values,
+    abortSignal,
+    headers,
+    providerOptions,
+  }: Parameters<EmbeddingModelV3['doEmbed']>[0]): Promise<
+    Awaited<ReturnType<EmbeddingModelV3['doEmbed']>>
+  > {
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values,
+      });
+    }
+
+    const perplexityOptions =
+      (await parseProviderOptions({
+        provider: 'perplexity',
+        providerOptions,
+        schema: perplexityEmbeddingModelOptions,
+      })) ?? {};
+
+    // Perplexity only returns quantized (base64-encoded) embeddings.
+    const encodingFormat = perplexityOptions.encodingFormat ?? 'base64_int8';
+
+    const {
+      responseHeaders,
+      value: response,
+      rawValue,
+    } = await postJsonToApi({
+      url: `${this.config.baseURL}/v1/embeddings`,
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        input: values,
+        dimensions: perplexityOptions.dimensions,
+        encoding_format: encodingFormat,
+      },
+      failedResponseHandler: createJsonErrorResponseHandler({
+        errorSchema: perplexityErrorSchema,
+        errorToMessage: data => data.error.message ?? 'Unknown error',
+      }),
+      successfulResponseHandler: createJsonResponseHandler(
+        perplexityEmbeddingResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    const cost = response.usage?.cost;
+
+    return {
+      embeddings: response.data.map(item =>
+        decodeEmbedding(item.embedding, encodingFormat),
+      ),
+      usage: response.usage
+        ? { tokens: response.usage.prompt_tokens }
+        : undefined,
+      providerMetadata: cost
+        ? {
+            perplexity: {
+              cost: {
+                inputCost: cost.input_cost ?? null,
+                totalCost: cost.total_cost ?? null,
+                currency: cost.currency ?? null,
+              },
+            },
+          }
+        : undefined,
+      response: { headers: responseHeaders, body: rawValue },
+      warnings: [],
+    };
+  }
+}
+
+/**
+ * Decodes a base64-encoded Perplexity embedding into a numeric vector.
+ * For `base64_int8` the bytes are reinterpreted as signed int8 values;
+ * for `base64_binary` the raw unsigned bytes (packed bits) are returned.
+ */
+function decodeEmbedding(
+  base64: string,
+  encodingFormat: 'base64_int8' | 'base64_binary',
+): number[] {
+  const bytes = convertBase64ToUint8Array(base64);
+
+  if (encodingFormat === 'base64_int8') {
+    const int8 = new Int8Array(
+      bytes.buffer,
+      bytes.byteOffset,
+      bytes.byteLength,
+    );
+    return Array.from(int8);
+  }
+
+  return Array.from(bytes);
+}
+
+// minimal version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+const perplexityEmbeddingResponseSchema = z.object({
+  data: z.array(z.object({ embedding: z.string() })),
+  usage: z
+    .object({
+      prompt_tokens: z.number(),
+      cost: z
+        .object({
+          input_cost: z.number().nullish(),
+          total_cost: z.number().nullish(),
+          currency: z.string().nullish(),
+        })
+        .nullish(),
+    })
+    .nullish(),
+});

package/src/perplexity-provider.ts

@@ -1,6 +1,7 @@
 import {
   NoSuchModelError,
   type LanguageModelV3,
+  type EmbeddingModelV3,
   type ProviderV3,
 } from '@ai-sdk/provider';
 import {
@@ -10,6 +11,8 @@ import {
   withUserAgentSuffix,
   type FetchFunction,
 } from '@ai-sdk/provider-utils';
+import { PerplexityEmbeddingModel } from './perplexity-embedding-model';
+import type { PerplexityEmbeddingModelId } from './perplexity-embedding-model-options';
 import { PerplexityLanguageModel } from './perplexity-language-model';
 import type { PerplexityLanguageModelId } from './perplexity-language-model-options';
 import { VERSION } from './version';
@@ -25,10 +28,20 @@ export interface PerplexityProvider extends ProviderV3 {
    */
   languageModel(modelId: PerplexityLanguageModelId): LanguageModelV3;
 
+  /**
+   * Creates a Perplexity model for text embeddings.
+   */
+  embedding(modelId: PerplexityEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * Creates a Perplexity model for text embeddings.
+   */
+  embeddingModel(modelId: PerplexityEmbeddingModelId): EmbeddingModelV3;
+
   /**
    * @deprecated Use `embeddingModel` instead.
    */
-  textEmbeddingModel(modelId: string): never;
+  textEmbeddingModel(modelId: PerplexityEmbeddingModelId): EmbeddingModelV3;
 }
 
 export interface PerplexityProviderSettings {
@@ -70,27 +83,36 @@ export function createPerplexity(
       `ai-sdk/perplexity/${VERSION}`,
     );
 
+  const baseURL = withoutTrailingSlash(
+    options.baseURL ?? 'https://api.perplexity.ai',
+  )!;
+
   const createLanguageModel = (modelId: PerplexityLanguageModelId) => {
     return new PerplexityLanguageModel(modelId, {
-      baseURL: withoutTrailingSlash(
-        options.baseURL ?? 'https://api.perplexity.ai',
-      )!,
+      baseURL,
       headers: getHeaders,
       generateId,
       fetch: options.fetch,
     });
   };
 
+  const createEmbeddingModel = (modelId: PerplexityEmbeddingModelId) =>
+    new PerplexityEmbeddingModel(modelId, {
+      provider: 'perplexity.embedding',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
   const provider = (modelId: PerplexityLanguageModelId) =>
     createLanguageModel(modelId);
 
   provider.specificationVersion = 'v3' as const;
   provider.languageModel = createLanguageModel;
 
-  provider.embeddingModel = (modelId: string) => {
-    throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });
-  };
-  provider.textEmbeddingModel = provider.embeddingModel;
+  provider.embedding = createEmbeddingModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
   provider.imageModel = (modelId: string) => {
     throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
   };