@ai-sdk/perplexity 5.0.16 → 5.0.17

package/src/perplexity-agent-api.ts

@@ -1,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import type { JSONSchema7 } from '@ai-sdk/provider';
 import { z } from 'zod/v4';
 
@@ -11,35 +16,38 @@ export type PerplexityAgentTool =
     }
   | ({ type: string } & Record<string, unknown>);
 
-export const perplexitySearchResultSchema = z.looseObject({
-  id: z.number().optional(),
-  title: z.string(),
-  url: z.string(),
-  snippet: z.string().optional(),
-  date: z.string().nullish(),
-  last_updated: z.string().nullish(),
-  source: z.string().optional(),
-});
+export const perplexitySearchResultSchema = () =>
+  z.looseObject({
+    id: z.number().optional(),
+    title: z.string(),
+    url: z.string(),
+    snippet: z.string().optional(),
+    date: z.string().nullish(),
+    last_updated: z.string().nullish(),
+    source: z.string().optional(),
+  });
 
-const perplexityFetchedContentSchema = z.looseObject({
-  title: z.string(),
-  url: z.string(),
-  snippet: z.string().optional(),
-});
+const perplexityFetchedContentSchema = () =>
+  z.looseObject({
+    title: z.string(),
+    url: z.string(),
+    snippet: z.string().optional(),
+  });
 
-const perplexityContentPartSchema = z.looseObject({
-  type: z.string(),
-  text: z.string().optional(),
-  annotations: z
-    .array(
-      z.looseObject({
-        type: z.string().optional(),
-        url: z.string().optional(),
-        title: z.string().optional(),
-      }),
-    )
-    .nullish(),
-});
+const perplexityContentPartSchema = () =>
+  z.looseObject({
+    type: z.string(),
+    text: z.string().optional(),
+    annotations: z
+      .array(
+        z.looseObject({
+          type: z.string().optional(),
+          url: z.string().optional(),
+          title: z.string().optional(),
+        }),
+      )
+      .nullish(),
+  });
 
 const handledOutputTypes = [
   'message',
@@ -48,146 +56,161 @@ const handledOutputTypes = [
   'function_call',
 ];
 
-export const perplexityOutputItemSchema = z.union([
-  z.looseObject({
-    type: z.literal('message'),
-    id: z.string().nullish(),
-    content: z.array(perplexityContentPartSchema).nullish(),
-  }),
-  z.looseObject({
-    type: z.literal('search_results'),
-    results: z.array(perplexitySearchResultSchema).nullish(),
-  }),
-  z.looseObject({
-    type: z.literal('fetch_url_results'),
-    contents: z.array(perplexityFetchedContentSchema).nullish(),
-  }),
-  z.looseObject({
-    type: z.literal('function_call'),
-    id: z.string().nullish(),
-    call_id: z.string().nullish(),
-    name: z.string().nullish(),
-    arguments: z.string().nullish(),
-    thought_signature: z.string().nullish(),
-  }),
-  // Native tool traces remain available in raw responses and raw stream chunks.
-  // Their fields (e.g. finance_results.results) have different shapes. Do not
-  // validate them as search results, or let malformed handled items fall back.
-  z
-    .object({
-      type: z.string().refine(type => !handledOutputTypes.includes(type)),
-    })
-    .transform(() => ({ type: 'unhandled' as const })),
-]);
+export const perplexityOutputItemSchema = () =>
+  z.union([
+    z.looseObject({
+      type: z.literal('message'),
+      id: z.string().nullish(),
+      content: z.array(perplexityContentPartSchema()).nullish(),
+    }),
+    z.looseObject({
+      type: z.literal('search_results'),
+      results: z.array(perplexitySearchResultSchema()).nullish(),
+    }),
+    z.looseObject({
+      type: z.literal('fetch_url_results'),
+      contents: z.array(perplexityFetchedContentSchema()).nullish(),
+    }),
+    z.looseObject({
+      type: z.literal('function_call'),
+      id: z.string().nullish(),
+      call_id: z.string().nullish(),
+      name: z.string().nullish(),
+      arguments: z.string().nullish(),
+      thought_signature: z.string().nullish(),
+    }),
+    // Native tool traces remain available in raw responses and raw stream chunks.
+    // Their fields (e.g. finance_results.results) have different shapes. Do not
+    // validate them as search results, or let malformed handled items fall back.
+    z
+      .object({
+        type: z.string().refine(type => !handledOutputTypes.includes(type)),
+      })
+      .transform(() => ({ type: 'unhandled' as const })),
+  ]);
 
-const perplexityCostSchema = z.looseObject({
-  currency: z.string().optional(),
-  input_cost: z.number().optional(),
-  output_cost: z.number().optional(),
-  total_cost: z.number().optional(),
-  cache_creation_cost: z.number().nullish(),
-  cache_read_cost: z.number().nullish(),
-  tool_calls_cost: z.number().nullish(),
-});
+const perplexityCostSchema = () =>
+  z.looseObject({
+    currency: z.string().optional(),
+    input_cost: z.number().optional(),
+    output_cost: z.number().optional(),
+    total_cost: z.number().optional(),
+    cache_creation_cost: z.number().nullish(),
+    cache_read_cost: z.number().nullish(),
+    tool_calls_cost: z.number().nullish(),
+  });
 
-export const perplexityUsageSchema = z.looseObject({
-  input_tokens: z.number(),
-  output_tokens: z.number(),
-  total_tokens: z.number(),
-  input_tokens_details: z
-    .looseObject({
-      cached_tokens: z.number().optional(),
-      cache_creation_input_tokens: z.number().optional(),
-      cache_read_input_tokens: z.number().optional(),
-    })
-    .nullish(),
-  output_tokens_details: z
-    .looseObject({
-      reasoning_tokens: z.number().optional(),
-    })
-    .nullish(),
-  tool_calls_details: z
-    .record(
-      z.string(),
-      z.looseObject({
-        invocation: z.number().optional(),
-      }),
-    )
-    .nullish(),
-  cost: perplexityCostSchema.nullish(),
-});
+export const perplexityUsageSchema = () =>
+  z.looseObject({
+    input_tokens: z.number(),
+    output_tokens: z.number(),
+    total_tokens: z.number(),
+    input_tokens_details: z
+      .looseObject({
+        cached_tokens: z.number().optional(),
+        cache_creation_input_tokens: z.number().optional(),
+        cache_read_input_tokens: z.number().optional(),
+      })
+      .nullish(),
+    output_tokens_details: z
+      .looseObject({
+        reasoning_tokens: z.number().optional(),
+      })
+      .nullish(),
+    tool_calls_details: z
+      .record(
+        z.string(),
+        z.looseObject({
+          invocation: z.number().optional(),
+        }),
+      )
+      .nullish(),
+    cost: perplexityCostSchema().nullish(),
+  });
 
-export const perplexityAgentResponseSchema = z.looseObject({
-  id: z.string(),
-  created_at: z.number(),
-  model: z.string(),
-  object: z.literal('response'),
-  output: z.array(perplexityOutputItemSchema),
-  status: z.string(),
-  incomplete_details: z
-    .looseObject({
-      reason: z.string(),
-    })
-    .nullish(),
-  error: z
-    .looseObject({
-      code: z.string().optional(),
-      message: z.string(),
-      type: z.string().optional(),
-    })
-    .nullish(),
-  usage: perplexityUsageSchema.nullish(),
-});
+export const perplexityAgentResponseSchema = () =>
+  z.looseObject({
+    id: z.string(),
+    created_at: z.number(),
+    model: z.string(),
+    object: z.literal('response'),
+    output: z.array(perplexityOutputItemSchema()),
+    status: z.string(),
+    incomplete_details: z
+      .looseObject({
+        reason: z.string(),
+      })
+      .nullish(),
+    error: z
+      .looseObject({
+        code: z.string().optional(),
+        message: z.string(),
+        type: z.string().optional(),
+      })
+      .nullish(),
+    usage: perplexityUsageSchema().nullish(),
+  });
+export const perplexityAgentResponseSchemaValidator = lazySchema(() =>
+  zodSchema(perplexityAgentResponseSchema()),
+);
 
-export const perplexityAgentChunkSchema = z.looseObject({
-  type: z.string(),
-  sequence_number: z.number().nullish(),
-  response: perplexityAgentResponseSchema.nullish(),
-  item: perplexityOutputItemSchema.nullish(),
-  output_index: z.number().nullish(),
-  item_id: z.string().nullish(),
-  content_index: z.number().nullish(),
-  delta: z.string().nullish(),
-  text: z.string().nullish(),
-  thought: z.string().nullish(),
-  queries: z.array(z.string()).nullish(),
-  urls: z.array(z.string()).nullish(),
-  results: z.array(perplexitySearchResultSchema).nullish(),
-  contents: z.array(perplexityFetchedContentSchema).nullish(),
-  error: z
-    .looseObject({
-      code: z.string().nullish(),
-      message: z.string(),
-      type: z.string().nullish(),
-    })
-    .nullish(),
-});
+export const perplexityAgentChunkSchema = lazySchema(() =>
+  zodSchema(
+    z.looseObject({
+      type: z.string(),
+      sequence_number: z.number().nullish(),
+      response: perplexityAgentResponseSchema().nullish(),
+      item: perplexityOutputItemSchema().nullish(),
+      output_index: z.number().nullish(),
+      item_id: z.string().nullish(),
+      content_index: z.number().nullish(),
+      delta: z.string().nullish(),
+      text: z.string().nullish(),
+      thought: z.string().nullish(),
+      queries: z.array(z.string()).nullish(),
+      urls: z.array(z.string()).nullish(),
+      results: z.array(perplexitySearchResultSchema()).nullish(),
+      contents: z.array(perplexityFetchedContentSchema()).nullish(),
+      error: z
+        .looseObject({
+          code: z.string().nullish(),
+          message: z.string(),
+          type: z.string().nullish(),
+        })
+        .nullish(),
+    }),
+  ),
+);
 
-export const perplexityErrorSchema = z.looseObject({
-  error: z
-    .union([
-      z.string(),
-      z.looseObject({
-        code: z.union([z.string(), z.number()]).nullish(),
-        message: z.string().nullish(),
-        type: z.string().nullish(),
-      }),
-    ])
-    .optional(),
-  detail: z
-    .union([
-      z.string(),
-      z.array(
-        z.looseObject({
-          msg: z.string(),
-        }),
-      ),
-    ])
-    .optional(),
-  message: z.string().optional(),
-});
+export const perplexityErrorSchema = lazySchema(() =>
+  zodSchema(
+    z.looseObject({
+      error: z
+        .union([
+          z.string(),
+          z.looseObject({
+            code: z.union([z.string(), z.number()]).nullish(),
+            message: z.string().nullish(),
+            type: z.string().nullish(),
+          }),
+        ])
+        .optional(),
+      detail: z
+        .union([
+          z.string(),
+          z.array(
+            z.looseObject({
+              msg: z.string(),
+            }),
+          ),
+        ])
+        .optional(),
+      message: z.string().optional(),
+    }),
+  ),
+);
 
-export type PerplexityErrorData = z.infer<typeof perplexityErrorSchema>;
+export type PerplexityErrorData = InferSchema<typeof perplexityErrorSchema>;
 
 export function perplexityErrorToMessage(data: PerplexityErrorData): string {
   if (typeof data.error === 'string') {

package/src/perplexity-decision-model.ts

@@ -6,6 +6,8 @@ import {
   type Experimental_DecisionModelV4Answer as DecisionModelV4Answer,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
@@ -251,32 +253,36 @@ export class DecisionPerplexityModel implements DecisionModelV4 {
   }
 }
 
-const probability = z.number().min(0).max(1);
-const perplexityDecisionResponseSchema = z.object({
-  model: z.string().nullish(),
-  answers: z.record(
-    z.string(),
-    z.discriminatedUnion('type', [
-      z.object({ type: z.literal('noul'), noul: probability }),
-      z.object({
-        type: z.literal('choice'),
-        choice: z.string(),
-        probabilities: z.record(z.string(), probability),
-        confidence: probability.nullish(),
-      }),
-      z.object({
-        type: z.literal('score'),
-        score: z.number(),
-        probabilities: z.record(z.string(), probability),
-        confidence: probability.nullish(),
-        legend: z.record(z.string(), z.json()).nullish(),
-      }),
-    ]),
+const probability = () => z.number().min(0).max(1);
+const perplexityDecisionResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      model: z.string().nullish(),
+      answers: z.record(
+        z.string(),
+        z.discriminatedUnion('type', [
+          z.object({ type: z.literal('noul'), noul: probability() }),
+          z.object({
+            type: z.literal('choice'),
+            choice: z.string(),
+            probabilities: z.record(z.string(), probability()),
+            confidence: probability().nullish(),
+          }),
+          z.object({
+            type: z.literal('score'),
+            score: z.number(),
+            probabilities: z.record(z.string(), probability()),
+            confidence: probability().nullish(),
+            legend: z.record(z.string(), z.json()).nullish(),
+          }),
+        ]),
+      ),
+      usage: z
+        .object({
+          input_tokens: z.number().nullish(),
+          output_tokens: z.number().nullish(),
+        })
+        .nullish(),
+    }),
   ),
-  usage: z
-    .object({
-      input_tokens: z.number().nullish(),
-      output_tokens: z.number().nullish(),
-    })
-    .nullish(),
-});
+);

package/src/perplexity-embedding-model-options.ts

@@ -1,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 // https://docs.perplexity.ai/docs/embeddings/quickstart
@@ -6,23 +11,27 @@ export type PerplexityEmbeddingModelId =
   | 'pplx-embed-v1-4b'
   | (string & {});
 
-export const perplexityEmbeddingModelOptions = z.object({
-  /**
-   * The number of dimensions the resulting output embeddings should have
-   * (Matryoshka truncation). Ranges from 128 up to the model's full size
-   * (1024 for 0.6b models, 2560 for 4b models).
-   */
-  dimensions: z.number().int().positive().optional(),
+export const perplexityEmbeddingModelOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * The number of dimensions the resulting output embeddings should have
+       * (Matryoshka truncation). Ranges from 128 up to the model's full size
+       * (1024 for 0.6b models, 2560 for 4b models).
+       */
+      dimensions: z.number().int().positive().optional(),
 
-  /**
-   * The quantized encoding format returned by the API. Perplexity does not
-   * return floating point embeddings; values are decoded to numbers:
-   * - `base64_int8` (default): signed int8 values, compare via cosine similarity.
-   * - `base64_binary`: packed bits per byte (0-255), compare via Hamming distance.
-   */
-  encodingFormat: z.enum(['base64_int8', 'base64_binary']).optional(),
-});
+      /**
+       * The quantized encoding format returned by the API. Perplexity does not
+       * return floating point embeddings; values are decoded to numbers:
+       * - `base64_int8` (default): signed int8 values, compare via cosine similarity.
+       * - `base64_binary`: packed bits per byte (0-255), compare via Hamming distance.
+       */
+      encodingFormat: z.enum(['base64_int8', 'base64_binary']).optional(),
+    }),
+  ),
+);
 
-export type PerplexityEmbeddingModelOptions = z.infer<
+export type PerplexityEmbeddingModelOptions = InferSchema<
   typeof perplexityEmbeddingModelOptions
 >;

package/src/perplexity-embedding-model.ts

@@ -3,6 +3,8 @@ import {
   type EmbeddingModelV4,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   convertBase64ToUint8Array,
   createJsonErrorResponseHandler,
@@ -169,18 +171,22 @@ function decodeEmbedding(
 
 // 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
+const perplexityEmbeddingResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      data: z.array(z.object({ embedding: z.string() })),
+      usage: z
         .object({
-          input_cost: z.number().nullish(),
-          total_cost: z.number().nullish(),
-          currency: z.string().nullish(),
+          prompt_tokens: z.number(),
+          cost: z
+            .object({
+              input_cost: z.number().nullish(),
+              total_cost: z.number().nullish(),
+              currency: z.string().nullish(),
+            })
+            .nullish(),
         })
         .nullish(),
-    })
-    .nullish(),
-});
+    }),
+  ),
+);