@ai-sdk/perplexity 3.0.63 → 3.1.1

package/dist/index.mjs

@@ -15,13 +15,13 @@ import {
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders2,
-  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  convertBase64ToUint8Array,
   createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
   createJsonResponseHandler as createJsonResponseHandler2,
-  parseProviderOptions,
+  parseProviderOptions as parseProviderOptions2,
   postJsonToApi as postJsonToApi2
 } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 
 // src/perplexity-embedding-model-options.ts
 import { z } from "zod/v4";
@@ -42,18 +42,21 @@ var perplexityEmbeddingModelOptions = z.object({
 });
 
 // src/perplexity-language-model.ts
+import {
+  APICallError
+} from "@ai-sdk/provider";
 import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
+  parseProviderOptions,
   postJsonToApi
 } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod/v4";
 
 // src/convert-perplexity-usage.ts
 function convertPerplexityUsage(usage) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   if (usage == null) {
     return {
       inputTokens: {
@@ -70,106 +73,176 @@ function convertPerplexityUsage(usage) {
       raw: void 0
     };
   }
-  const promptTokens = (_a = usage.prompt_tokens) != null ? _a : 0;
-  const completionTokens = (_b = usage.completion_tokens) != null ? _b : 0;
-  const reasoningTokens = (_c = usage.reasoning_tokens) != null ? _c : 0;
+  const inputTokens = (_a = usage.input_tokens) != null ? _a : 0;
+  const outputTokens = (_b = usage.output_tokens) != null ? _b : 0;
+  const cacheReadTokens = (_f = (_e = (_c = usage.input_tokens_details) == null ? void 0 : _c.cache_read_input_tokens) != null ? _e : (_d = usage.input_tokens_details) == null ? void 0 : _d.cached_tokens) != null ? _f : 0;
+  const cacheWriteTokens = (_h = (_g = usage.input_tokens_details) == null ? void 0 : _g.cache_creation_input_tokens) != null ? _h : 0;
+  const reasoningTokens = (_j = (_i = usage.output_tokens_details) == null ? void 0 : _i.reasoning_tokens) != null ? _j : 0;
   return {
     inputTokens: {
-      total: promptTokens,
-      noCache: promptTokens,
-      cacheRead: void 0,
-      cacheWrite: void 0
+      total: inputTokens,
+      noCache: Math.max(0, inputTokens - cacheReadTokens - cacheWriteTokens),
+      cacheRead: cacheReadTokens,
+      cacheWrite: cacheWriteTokens
     },
     outputTokens: {
-      // Perplexity reports reasoning tokens separately from completion tokens.
-      total: completionTokens + reasoningTokens,
-      text: completionTokens,
+      total: outputTokens,
+      text: Math.max(0, outputTokens - reasoningTokens),
       reasoning: reasoningTokens
     },
     raw: usage
   };
 }
 
-// src/convert-to-perplexity-messages.ts
+// src/convert-to-perplexity-input.ts
 import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
-import {
-  convertBase64ToUint8Array,
-  convertUint8ArrayToBase64
-} from "@ai-sdk/provider-utils";
-function convertToPerplexityMessages(prompt) {
-  const messages = [];
+import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
+function serializeToolOutput(output) {
+  var _a;
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "json":
+    case "error-json":
+      return JSON.stringify(output.value);
+    case "execution-denied":
+      return (_a = output.reason) != null ? _a : "Tool call execution denied.";
+    case "content": {
+      if (output.value.some((part) => part.type !== "text")) {
+        throw new UnsupportedFunctionalityError({
+          functionality: "file and custom tool result content"
+        });
+      }
+      return output.value.map((part) => part.type === "text" ? part.text : "").join("");
+    }
+    default: {
+      const _exhaustiveCheck = output;
+      throw new Error(`Unsupported tool output: ${_exhaustiveCheck}`);
+    }
+  }
+}
+function getTopLevelMediaType(mediaType) {
+  const slashIndex = mediaType.indexOf("/");
+  return slashIndex === -1 ? mediaType : mediaType.substring(0, slashIndex);
+}
+function getThoughtSignature(providerOptions) {
+  var _a;
+  const thoughtSignature = (_a = providerOptions == null ? void 0 : providerOptions.perplexity) == null ? void 0 : _a.thoughtSignature;
+  return typeof thoughtSignature === "string" ? thoughtSignature : void 0;
+}
+function convertToPerplexityInput(prompt) {
+  var _a;
+  const input = [];
+  const warnings = [];
   for (const { role, content } of prompt) {
     switch (role) {
       case "system": {
-        messages.push({ role: "system", content });
+        input.push({ type: "message", role: "system", content });
         break;
       }
-      case "user":
-      case "assistant": {
-        const hasMultipartContent = content.some(
-          (part) => part.type === "file" && part.mediaType.startsWith("image/") || part.type === "file" && getTopLevelMediaType(part.mediaType) === "application"
-        );
-        const messageContent = content.map((part, index) => {
-          var _a;
-          switch (part.type) {
-            case "text": {
-              return {
-                type: "text",
-                text: part.text
-              };
-            }
-            case "file": {
-              if (getTopLevelMediaType(part.mediaType) === "application") {
-                const fullMediaType = resolveApplicationMediaType(part);
-                if (fullMediaType !== "application/pdf") {
+      case "user": {
+        const convertedContent = content.map(
+          (part) => {
+            switch (part.type) {
+              case "text":
+                return { type: "input_text", text: part.text };
+              case "file": {
+                if (getTopLevelMediaType(part.mediaType) !== "image") {
                   throw new UnsupportedFunctionalityError({
-                    functionality: `file part media type ${fullMediaType}`
+                    functionality: `file part media type ${part.mediaType}`
                   });
                 }
-                return part.data instanceof URL ? {
-                  type: "file_url",
-                  file_url: {
-                    url: part.data.toString()
-                  },
-                  file_name: part.filename
-                } : {
-                  type: "file_url",
-                  file_url: {
-                    url: typeof part.data === "string" ? part.data : convertUint8ArrayToBase64(part.data)
-                  },
-                  file_name: part.filename || `document-${index}.pdf`
-                };
-              } else if (part.mediaType.startsWith("image/")) {
-                return part.data instanceof URL ? {
-                  type: "image_url",
-                  image_url: {
-                    url: part.data.toString()
-                  }
-                } : {
-                  type: "image_url",
-                  image_url: {
-                    url: `data:${(_a = part.mediaType) != null ? _a : "image/jpeg"};base64,${typeof part.data === "string" ? part.data : convertUint8ArrayToBase64(part.data)}`
-                  }
+                if (part.data instanceof URL) {
+                  return {
+                    type: "input_image",
+                    image_url: part.data.toString()
+                  };
+                }
+                const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                return {
+                  type: "input_image",
+                  image_url: `data:${mediaType};base64,${typeof part.data === "string" ? part.data : convertUint8ArrayToBase64(part.data)}`
                 };
               }
+            }
+          }
+        );
+        const isTextOnly = convertedContent.every(
+          (part) => part.type === "input_text"
+        );
+        input.push({
+          type: "message",
+          role: "user",
+          content: isTextOnly ? convertedContent.map((part) => part.type === "input_text" ? part.text : "").join("") : convertedContent
+        });
+        break;
+      }
+      case "assistant": {
+        const text = content.filter((part) => part.type === "text").map((part) => part.text).join("");
+        if (text.length > 0) {
+          input.push({ type: "message", role: "assistant", content: text });
+        }
+        for (const part of content) {
+          switch (part.type) {
+            case "text":
+              break;
+            case "tool-call":
+              input.push({
+                type: "function_call",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: JSON.stringify((_a = part.input) != null ? _a : {}),
+                thought_signature: getThoughtSignature(part.providerOptions)
+              });
+              break;
+            case "tool-result":
+              input.push({
+                type: "function_call_output",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                output: serializeToolOutput(part.output),
+                thought_signature: getThoughtSignature(part.providerOptions)
+              });
+              break;
+            case "reasoning":
+              warnings.push({
+                type: "unsupported",
+                feature: "reasoning content in prompt"
+              });
+              break;
+            case "file":
               throw new UnsupportedFunctionalityError({
-                functionality: `file part media type ${part.mediaType}`
+                functionality: `assistant ${part.type} parts`
               });
+            default: {
+              const _exhaustiveCheck = part;
+              throw new Error(
+                `Unsupported assistant part: ${_exhaustiveCheck}`
+              );
             }
           }
-        }).filter(Boolean);
-        messages.push({
-          role,
-          content: hasMultipartContent ? messageContent : messageContent.filter((part) => part.type === "text").map((part) => part.text).join("")
-        });
+        }
         break;
       }
       case "tool": {
-        throw new UnsupportedFunctionalityError({
-          functionality: "Tool messages"
-        });
+        for (const part of content) {
+          if (part.type === "tool-approval-response") {
+            throw new UnsupportedFunctionalityError({
+              functionality: "tool approval responses"
+            });
+          }
+          input.push({
+            type: "function_call_output",
+            call_id: part.toolCallId,
+            name: part.toolName,
+            output: serializeToolOutput(part.output),
+            thought_signature: getThoughtSignature(part.providerOptions)
+          });
+        }
+        break;
       }
       default: {
         const _exhaustiveCheck = role;
@@ -177,64 +250,438 @@ function convertToPerplexityMessages(prompt) {
       }
     }
   }
-  return messages;
-}
-function getTopLevelMediaType(mediaType) {
-  const slashIndex = mediaType.indexOf("/");
-  return slashIndex === -1 ? mediaType : mediaType.substring(0, slashIndex);
+  return { input, warnings };
 }
-function isFullMediaType(mediaType) {
-  const slashIndex = mediaType.indexOf("/");
-  if (slashIndex === -1) {
-    return false;
+
+// src/map-perplexity-finish-reason.ts
+function mapPerplexityFinishReason({
+  status,
+  incompleteReason,
+  hasFunctionCall
+}) {
+  switch (incompleteReason) {
+    case "max_output_tokens":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+  }
+  switch (status) {
+    case "completed":
+      return hasFunctionCall ? "tool-calls" : "stop";
+    case "requires_action":
+      return "tool-calls";
+    case "failed":
+      return "error";
+    case "cancelled":
+    case "queued":
+    case "in_progress":
+    default:
+      return hasFunctionCall ? "tool-calls" : "other";
   }
-  const subtype = mediaType.substring(slashIndex + 1);
-  return subtype.length > 0 && subtype !== "*";
 }
-function resolveApplicationMediaType(part) {
-  if (isFullMediaType(part.mediaType)) {
-    return part.mediaType;
+
+// src/perplexity-agent-api.ts
+import { z as z2 } from "zod/v4";
+var perplexitySearchResultSchema = z2.looseObject({
+  id: z2.number().optional(),
+  title: z2.string(),
+  url: z2.string(),
+  snippet: z2.string().optional(),
+  date: z2.string().nullish(),
+  last_updated: z2.string().nullish(),
+  source: z2.string().optional()
+});
+var perplexityFetchedContentSchema = z2.looseObject({
+  title: z2.string(),
+  url: z2.string(),
+  snippet: z2.string().optional()
+});
+var perplexityContentPartSchema = z2.looseObject({
+  type: z2.string(),
+  text: z2.string().optional(),
+  annotations: z2.array(
+    z2.looseObject({
+      type: z2.string().optional(),
+      url: z2.string().optional(),
+      title: z2.string().optional()
+    })
+  ).nullish()
+});
+var handledOutputTypes = [
+  "message",
+  "search_results",
+  "fetch_url_results",
+  "function_call"
+];
+var perplexityOutputItemSchema = z2.union([
+  z2.looseObject({
+    type: z2.literal("message"),
+    id: z2.string().nullish(),
+    content: z2.array(perplexityContentPartSchema).nullish()
+  }),
+  z2.looseObject({
+    type: z2.literal("search_results"),
+    results: z2.array(perplexitySearchResultSchema).nullish()
+  }),
+  z2.looseObject({
+    type: z2.literal("fetch_url_results"),
+    contents: z2.array(perplexityFetchedContentSchema).nullish()
+  }),
+  z2.looseObject({
+    type: z2.literal("function_call"),
+    id: z2.string().nullish(),
+    call_id: z2.string().nullish(),
+    name: z2.string().nullish(),
+    arguments: z2.string().nullish(),
+    thought_signature: z2.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.
+  z2.object({
+    type: z2.string().refine((type) => !handledOutputTypes.includes(type))
+  }).transform(() => ({ type: "unhandled" }))
+]);
+var perplexityCostSchema = z2.looseObject({
+  currency: z2.string().optional(),
+  input_cost: z2.number().optional(),
+  output_cost: z2.number().optional(),
+  total_cost: z2.number().optional(),
+  cache_creation_cost: z2.number().nullish(),
+  cache_read_cost: z2.number().nullish(),
+  tool_calls_cost: z2.number().nullish()
+});
+var perplexityUsageSchema = z2.looseObject({
+  input_tokens: z2.number(),
+  output_tokens: z2.number(),
+  total_tokens: z2.number(),
+  input_tokens_details: z2.looseObject({
+    cached_tokens: z2.number().optional(),
+    cache_creation_input_tokens: z2.number().optional(),
+    cache_read_input_tokens: z2.number().optional()
+  }).nullish(),
+  output_tokens_details: z2.looseObject({
+    reasoning_tokens: z2.number().optional()
+  }).nullish(),
+  tool_calls_details: z2.record(
+    z2.string(),
+    z2.looseObject({
+      invocation: z2.number().optional()
+    })
+  ).nullish(),
+  cost: perplexityCostSchema.nullish()
+});
+var perplexityAgentResponseSchema = z2.looseObject({
+  id: z2.string(),
+  created_at: z2.number(),
+  model: z2.string(),
+  object: z2.literal("response"),
+  output: z2.array(perplexityOutputItemSchema),
+  status: z2.string(),
+  incomplete_details: z2.looseObject({
+    reason: z2.string()
+  }).nullish(),
+  error: z2.looseObject({
+    code: z2.string().optional(),
+    message: z2.string(),
+    type: z2.string().optional()
+  }).nullish(),
+  usage: perplexityUsageSchema.nullish()
+});
+var perplexityAgentChunkSchema = z2.looseObject({
+  type: z2.string(),
+  sequence_number: z2.number().nullish(),
+  response: perplexityAgentResponseSchema.nullish(),
+  item: perplexityOutputItemSchema.nullish(),
+  output_index: z2.number().nullish(),
+  item_id: z2.string().nullish(),
+  content_index: z2.number().nullish(),
+  delta: z2.string().nullish(),
+  text: z2.string().nullish(),
+  thought: z2.string().nullish(),
+  queries: z2.array(z2.string()).nullish(),
+  urls: z2.array(z2.string()).nullish(),
+  results: z2.array(perplexitySearchResultSchema).nullish(),
+  contents: z2.array(perplexityFetchedContentSchema).nullish(),
+  error: z2.looseObject({
+    code: z2.string().nullish(),
+    message: z2.string(),
+    type: z2.string().nullish()
+  }).nullish()
+});
+var perplexityErrorSchema = z2.looseObject({
+  error: z2.union([
+    z2.string(),
+    z2.looseObject({
+      code: z2.union([z2.string(), z2.number()]).optional(),
+      message: z2.string().nullish(),
+      type: z2.string().nullish()
+    })
+  ]).optional(),
+  detail: z2.union([
+    z2.string(),
+    z2.array(
+      z2.looseObject({
+        msg: z2.string()
+      })
+    )
+  ]).optional(),
+  message: z2.string().optional()
+});
+function perplexityErrorToMessage(data) {
+  var _a, _b, _c;
+  if (typeof data.error === "string") {
+    return data.error;
   }
-  if (part.data instanceof URL) {
-    throw new UnsupportedFunctionalityError({
-      functionality: `file of media type "${part.mediaType}" must specify subtype since it is not passed as inline bytes`
-    });
+  if (data.error != null) {
+    return (_b = (_a = data.error.message) != null ? _a : data.error.type) != null ? _b : "unknown error";
   }
-  if (isPdfData(part.data)) {
-    return "application/pdf";
+  if (typeof data.detail === "string") {
+    return data.detail;
   }
-  throw new UnsupportedFunctionalityError({
-    functionality: `file of media type "${part.mediaType}" must specify subtype since it could not be auto-detected`
-  });
-}
-function isPdfData(data) {
-  const bytes = typeof data === "string" ? convertBase64ToUint8Array(data.substring(0, Math.min(data.length, 8))) : data;
-  return bytes.length >= 4 && bytes[0] === 37 && bytes[1] === 80 && bytes[2] === 68 && bytes[3] === 70;
+  if (Array.isArray(data.detail)) {
+    return data.detail.map((detail) => detail.msg).join(", ");
+  }
+  return (_c = data.message) != null ? _c : "unknown error";
 }
 
-// src/map-perplexity-finish-reason.ts
-function mapPerplexityFinishReason(finishReason) {
-  switch (finishReason) {
-    case "stop":
-    case "length":
-      return finishReason;
-    default:
-      return "other";
+// src/perplexity-language-model-options.ts
+import { z as z3 } from "zod/v4";
+var userLocationSchema = z3.looseObject({
+  latitude: z3.number().optional(),
+  longitude: z3.number().optional(),
+  country: z3.string().optional(),
+  city: z3.string().optional(),
+  region: z3.string().optional()
+});
+var webSearchFiltersSchema = z3.looseObject({
+  search_domain_filter: z3.array(z3.string()).optional(),
+  search_recency_filter: z3.enum(["hour", "day", "week", "month", "year"]).optional(),
+  search_after_date_filter: z3.string().optional(),
+  search_before_date_filter: z3.string().optional(),
+  last_updated_after_filter: z3.string().optional(),
+  last_updated_before_filter: z3.string().optional()
+});
+var webSearchToolSchema = z3.looseObject({
+  type: z3.literal("web_search"),
+  filters: webSearchFiltersSchema.optional(),
+  max_results: z3.number().int().positive().optional(),
+  max_tokens: z3.number().optional(),
+  max_tokens_per_page: z3.number().optional(),
+  search_context_size: z3.enum(["low", "medium", "high"]).optional(),
+  user_location: userLocationSchema.optional()
+});
+var nativeToolSchema = z3.union([
+  webSearchToolSchema,
+  z3.looseObject({
+    type: z3.literal("fetch_url"),
+    max_urls: z3.number().optional()
+  }),
+  z3.looseObject({ type: z3.literal("people_search") }),
+  z3.looseObject({ type: z3.literal("finance_search") }),
+  z3.looseObject({ type: z3.literal("sandbox") }),
+  z3.looseObject({
+    type: z3.literal("mcp"),
+    server_label: z3.string(),
+    server_url: z3.string(),
+    allowed_tools: z3.array(z3.string()).optional(),
+    authorization: z3.string().optional(),
+    defer_loading: z3.boolean().optional(),
+    headers: z3.record(z3.string(), z3.string()).optional()
+  }),
+  z3.looseObject({
+    type: z3.literal("connector"),
+    id: z3.string(),
+    server_label: z3.string(),
+    server_description: z3.string().optional(),
+    allowed_tools: z3.array(z3.string()).optional()
+  })
+]);
+var perplexityLanguageModelOptions = z3.looseObject({
+  /** Top-level Agent API instructions. */
+  instructions: z3.string().optional(),
+  /**
+   * Native Agent API tools. AI SDK function tools can also be supplied through
+   * the top-level `tools` option on `generateText` and `streamText`.
+   */
+  tools: z3.array(nativeToolSchema).optional(),
+  /** A fallback model list for Agent API routing. */
+  models: z3.array(z3.string()).optional(),
+  /** Maximum number of agentic steps. */
+  max_steps: z3.number().int().positive().optional(),
+  /** Maximum number of native tool calls. */
+  max_tool_calls: z3.number().int().nonnegative().optional(),
+  /** Continue a conversation from an earlier Agent API response. */
+  previous_response_id: z3.string().optional(),
+  /**
+   * Whether the response can be retrieved later. Setting this to false does
+   * not disable persistence or prevent previous_response_id continuations.
+   */
+  store: z3.boolean().optional(),
+  /** Preferred response language as an ISO 639-1 language code. */
+  language_preference: z3.string().optional(),
+  /** Agent API reasoning configuration. */
+  reasoning: z3.looseObject({
+    effort: z3.enum(["minimal", "low", "medium", "high", "xhigh"]).optional()
+  }).optional(),
+  /** Agent API skill configuration. */
+  skills: z3.array(
+    z3.union([
+      z3.looseObject({
+        type: z3.literal("builtin"),
+        name: z3.enum([
+          "office",
+          "office/docx",
+          "office/pdf",
+          "office/pptx",
+          "office/xlsx"
+        ])
+      }),
+      z3.looseObject({
+        type: z3.literal("inline"),
+        name: z3.string(),
+        description: z3.string(),
+        instructions: z3.string()
+      })
+    ])
+  ).optional()
+});
+
+// src/perplexity-prepare-tools.ts
+function preparePerplexityTools({
+  tools,
+  toolChoice
+}) {
+  const preparedTools = [];
+  const warnings = [];
+  for (const tool of tools != null ? tools : []) {
+    if (tool.type === "provider") {
+      warnings.push({
+        type: "unsupported",
+        feature: `provider-defined tool ${tool.name}`
+      });
+      continue;
+    }
+    preparedTools.push({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema,
+      strict: tool.strict
+    });
   }
+  if (toolChoice != null && toolChoice.type !== "auto") {
+    warnings.push({
+      type: "unsupported",
+      feature: "toolChoice",
+      details: "The Perplexity Agent API currently selects tools automatically."
+    });
+  }
+  return { tools: preparedTools, warnings };
 }
 
 // src/perplexity-language-model.ts
+var presetIds = /* @__PURE__ */ new Set([
+  "fast",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+]);
+function getModelSelection(modelId) {
+  if (presetIds.has(modelId)) {
+    return { preset: modelId };
+  }
+  return { model: modelId };
+}
+function getResponseMetadata(response) {
+  var _a, _b;
+  return {
+    id: (_a = response.id) != null ? _a : void 0,
+    modelId: (_b = response.model) != null ? _b : void 0,
+    timestamp: response.created_at != null ? new Date(response.created_at * 1e3) : void 0
+  };
+}
+function getProviderMetadata(usage) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const cost = usage == null ? void 0 : usage.cost;
+  const numSearchQueries = (usage == null ? void 0 : usage.tool_calls_details) ? Object.entries(usage.tool_calls_details).filter(([name]) => name.includes("search")).reduce((total, [, details]) => {
+    var _a2;
+    return total + ((_a2 = details.invocation) != null ? _a2 : 0);
+  }, 0) : null;
+  return {
+    perplexity: {
+      usage: {
+        citationTokens: null,
+        numSearchQueries
+      },
+      images: null,
+      cost: cost == null ? null : {
+        inputTokensCost: (_a = cost.input_cost) != null ? _a : null,
+        outputTokensCost: (_b = cost.output_cost) != null ? _b : null,
+        requestCost: null,
+        totalCost: (_c = cost.total_cost) != null ? _c : null,
+        currency: (_d = cost.currency) != null ? _d : null,
+        cacheCreationCost: (_e = cost.cache_creation_cost) != null ? _e : null,
+        cacheReadCost: (_f = cost.cache_read_cost) != null ? _f : null,
+        toolCallsCost: (_g = cost.tool_calls_cost) != null ? _g : null
+      },
+      toolCalls: (usage == null ? void 0 : usage.tool_calls_details) == null ? null : Object.fromEntries(
+        Object.entries(usage.tool_calls_details).map(
+          ([name, details]) => {
+            var _a2;
+            return [
+              name,
+              { invocation: (_a2 = details.invocation) != null ? _a2 : null }
+            ];
+          }
+        )
+      )
+    }
+  };
+}
+function createSource(result, generateId2) {
+  var _a, _b, _c, _d, _e;
+  return {
+    type: "source",
+    sourceType: "url",
+    id: result.id == null ? generateId2() : String(result.id),
+    url: result.url,
+    title: result.title,
+    providerMetadata: {
+      perplexity: {
+        resultId: (_a = result.id) != null ? _a : null,
+        snippet: (_b = result.snippet) != null ? _b : null,
+        date: (_c = result.date) != null ? _c : null,
+        lastUpdated: (_d = result.last_updated) != null ? _d : null,
+        source: (_e = result.source) != null ? _e : null
+      }
+    }
+  };
+}
+function hasSearchResultId(source) {
+  var _a, _b;
+  return typeof ((_b = (_a = source.providerMetadata) == null ? void 0 : _a.perplexity) == null ? void 0 : _b.resultId) === "number";
+}
+function getSearchResults(item) {
+  var _a;
+  return item.type === "search_results" ? (_a = item.results) != null ? _a : [] : [];
+}
+function getFetchedSources(item) {
+  var _a;
+  return item.type === "fetch_url_results" ? (_a = item.contents) != null ? _a : [] : [];
+}
 var PerplexityLanguageModel = class {
   constructor(modelId, config) {
     this.specificationVersion = "v3";
     this.provider = "perplexity";
     this.supportedUrls = {
-      // No URLs are supported.
+      "image/*": [/^https?:\/\/.*$/]
     };
     this.modelId = modelId;
     this.config = config;
   }
-  getArgs({
+  async getArgs({
     prompt,
     maxOutputTokens,
     temperature,
@@ -245,84 +692,176 @@ var PerplexityLanguageModel = class {
     stopSequences,
     responseFormat,
     seed,
-    providerOptions
+    providerOptions,
+    tools,
+    toolChoice
   }) {
+    var _a, _b;
     const warnings = [];
+    const perplexityOptions = (_a = await parseProviderOptions({
+      provider: "perplexity",
+      providerOptions,
+      schema: perplexityLanguageModelOptions
+    })) != null ? _a : {};
     if (topK != null) {
       warnings.push({ type: "unsupported", feature: "topK" });
     }
+    if (frequencyPenalty != null) {
+      warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
+    }
+    if (presencePenalty != null) {
+      warnings.push({ type: "unsupported", feature: "presencePenalty" });
+    }
     if (stopSequences != null) {
       warnings.push({ type: "unsupported", feature: "stopSequences" });
     }
     if (seed != null) {
       warnings.push({ type: "unsupported", feature: "seed" });
     }
-    return {
-      args: {
-        // model id:
-        model: this.modelId,
-        // standardized settings:
-        frequency_penalty: frequencyPenalty,
-        max_tokens: maxOutputTokens,
-        presence_penalty: presencePenalty,
-        temperature,
-        top_k: topK,
-        top_p: topP,
-        // response format:
-        response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? {
-          type: "json_schema",
-          json_schema: { schema: responseFormat.schema }
-        } : void 0,
-        // provider extensions
-        ...providerOptions == null ? void 0 : providerOptions.perplexity,
-        // messages:
-        messages: convertToPerplexityMessages(prompt)
-      },
-      warnings
+    const { tools: nativeTools, ...agentOptions } = perplexityOptions;
+    const modelSelection = getModelSelection(this.modelId);
+    const { input, warnings: inputWarnings } = convertToPerplexityInput(prompt);
+    warnings.push(...inputWarnings);
+    const { tools: functionTools, warnings: toolWarnings } = preparePerplexityTools({ tools, toolChoice });
+    warnings.push(...toolWarnings);
+    const agentTools = [
+      ...nativeTools != null ? nativeTools : [],
+      ...functionTools
+    ];
+    const body = {
+      ...agentOptions,
+      ...modelSelection,
+      input,
+      max_output_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null ? {
+        type: "json_schema",
+        json_schema: {
+          name: (_b = responseFormat.name) != null ? _b : "response",
+          description: responseFormat.description,
+          schema: responseFormat.schema,
+          strict: true
+        }
+      } : void 0,
+      tools: agentTools.length > 0 ? agentTools : void 0
     };
+    if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema == null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "JSON response format without a schema"
+      });
+    }
+    return { args: body, warnings };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-    const { args: body, warnings } = this.getArgs(options);
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    const { args: body, warnings } = await this.getArgs(options);
+    const url = `${this.config.baseURL}/v1/agent`;
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
     } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      url,
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: perplexityErrorSchema,
-        errorToMessage
+        errorToMessage: perplexityErrorToMessage
       }),
       successfulResponseHandler: createJsonResponseHandler(
-        perplexityResponseSchema
+        perplexityAgentResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const choice = response.choices[0];
-    const content = [];
-    const text = choice.message.content;
-    if (text.length > 0) {
-      content.push({ type: "text", text });
+    if (response.error != null || response.status === "failed") {
+      throw new APICallError({
+        message: (_d = (_c = response.error) == null ? void 0 : _c.message) != null ? _d : "Perplexity response failed",
+        url,
+        requestBodyValues: body,
+        statusCode: 400,
+        responseHeaders,
+        responseBody: rawResponse,
+        isRetryable: false
+      });
     }
-    if (response.citations != null) {
-      for (const url of response.citations) {
+    const content = [];
+    const sourceIndexesByUrl = /* @__PURE__ */ new Map();
+    let hasFunctionCall = false;
+    const addSource = (source) => {
+      const existingIndex = sourceIndexesByUrl.get(source.url);
+      if (existingIndex == null) {
+        sourceIndexesByUrl.set(source.url, content.length);
+        content.push(source);
+      } else if (hasSearchResultId(source) && !hasSearchResultId(content[existingIndex])) {
+        content[existingIndex] = source;
+      }
+    };
+    for (const item of response.output) {
+      if (item.type === "message") {
+        for (const part of (_e = item.content) != null ? _e : []) {
+          if (part.type === "output_text" && part.text != null) {
+            content.push({ type: "text", text: part.text });
+          }
+          for (const annotation of (_f = part.annotations) != null ? _f : []) {
+            if (annotation.url != null) {
+              addSource({
+                type: "source",
+                sourceType: "url",
+                id: this.config.generateId(),
+                url: annotation.url,
+                title: annotation.title
+              });
+            }
+          }
+        }
+      } else if (item.type === "search_results") {
+        for (const result of getSearchResults(item)) {
+          addSource(createSource(result, this.config.generateId));
+        }
+      } else if (item.type === "fetch_url_results") {
+        for (const result of getFetchedSources(item)) {
+          addSource({
+            type: "source",
+            sourceType: "url",
+            id: this.config.generateId(),
+            url: result.url,
+            title: result.title,
+            providerMetadata: {
+              perplexity: { snippet: (_g = result.snippet) != null ? _g : null }
+            }
+          });
+        }
+      } else if (item.type === "function_call" && item.call_id != null && item.name != null && item.arguments != null) {
+        hasFunctionCall = true;
         content.push({
-          type: "source",
-          sourceType: "url",
-          id: this.config.generateId(),
-          url
+          type: "tool-call",
+          toolCallId: item.call_id,
+          toolName: item.name,
+          input: item.arguments,
+          providerMetadata: {
+            perplexity: {
+              itemId: (_h = item.id) != null ? _h : null,
+              ...item.thought_signature != null && {
+                thoughtSignature: item.thought_signature
+              }
+            }
+          }
         });
       }
     }
+    const finishReason = (_j = (_i = response.incomplete_details) == null ? void 0 : _i.reason) != null ? _j : response.status;
     return {
       content,
       finishReason: {
-        unified: mapPerplexityFinishReason(choice.finish_reason),
-        raw: (_a = choice.finish_reason) != null ? _a : void 0
+        unified: mapPerplexityFinishReason({
+          status: response.status,
+          incompleteReason: (_k = response.incomplete_details) == null ? void 0 : _k.reason,
+          hasFunctionCall
+        }),
+        raw: finishReason
       },
       usage: convertPerplexityUsage(response.usage),
       request: { body },
@@ -332,41 +871,23 @@ var PerplexityLanguageModel = class {
         body: rawResponse
       },
       warnings,
-      providerMetadata: {
-        perplexity: {
-          images: (_c = (_b = response.images) == null ? void 0 : _b.map((image) => ({
-            imageUrl: image.image_url,
-            originUrl: image.origin_url,
-            height: image.height,
-            width: image.width
-          }))) != null ? _c : null,
-          usage: {
-            citationTokens: (_e = (_d = response.usage) == null ? void 0 : _d.citation_tokens) != null ? _e : null,
-            numSearchQueries: (_g = (_f = response.usage) == null ? void 0 : _f.num_search_queries) != null ? _g : null
-          },
-          cost: ((_h = response.usage) == null ? void 0 : _h.cost) ? {
-            inputTokensCost: (_i = response.usage.cost.input_tokens_cost) != null ? _i : null,
-            outputTokensCost: (_j = response.usage.cost.output_tokens_cost) != null ? _j : null,
-            requestCost: (_k = response.usage.cost.request_cost) != null ? _k : null,
-            totalCost: (_l = response.usage.cost.total_cost) != null ? _l : null
-          } : null
-        }
-      }
+      providerMetadata: getProviderMetadata(response.usage)
     };
   }
   async doStream(options) {
-    const { args, warnings } = this.getArgs(options);
+    var _a, _b;
+    const { args, warnings } = await this.getArgs(options);
     const body = { ...args, stream: true };
     const { responseHeaders, value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      url: `${this.config.baseURL}/v1/agent`,
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: perplexityErrorSchema,
-        errorToMessage
+        errorToMessage: perplexityErrorToMessage
       }),
       successfulResponseHandler: createEventSourceResponseHandler(
-        perplexityChunkSchema
+        perplexityAgentChunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
@@ -375,20 +896,15 @@ var PerplexityLanguageModel = class {
       unified: "other",
       raw: void 0
     };
-    let usage = void 0;
-    const providerMetadata = {
-      perplexity: {
-        usage: {
-          citationTokens: null,
-          numSearchQueries: null
-        },
-        cost: null,
-        images: null
-      }
-    };
-    let isFirstChunk = true;
-    let isActive = false;
-    const self = this;
+    let usage;
+    let hasFunctionCall = false;
+    let hasResponseMetadata = false;
+    let activeReasoningId;
+    const textStates = /* @__PURE__ */ new Map();
+    const emittedSourceUrls = /* @__PURE__ */ new Set();
+    const pendingSourcesByUrl = /* @__PURE__ */ new Map();
+    const seenFunctionCalls = /* @__PURE__ */ new Set();
+    const generateId2 = this.config.generateId;
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -396,84 +912,308 @@ var PerplexityLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g;
+            var _a2, _b2, _c, _d, _e, _f, _g, _h, _i;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
             if (!chunk.success) {
+              finishReason = { unified: "error", raw: void 0 };
               controller.enqueue({ type: "error", error: chunk.error });
               return;
             }
             const value = chunk.value;
-            if (isFirstChunk) {
+            const getTextId = (itemId, outputIndex, contentIndex = 0) => {
+              const id = itemId != null ? itemId : String(outputIndex != null ? outputIndex : "text");
+              return contentIndex == null || contentIndex === 0 ? id : `${id}:${contentIndex}`;
+            };
+            const emitTextDelta = (id, delta) => {
+              let state = textStates.get(id);
+              if (state == null ? void 0 : state.ended) {
+                return;
+              }
+              if (state == null) {
+                state = { text: "", ended: false };
+                textStates.set(id, state);
+                controller.enqueue({ type: "text-start", id });
+              }
+              state.text += delta;
+              controller.enqueue({ type: "text-delta", id, delta });
+            };
+            const finishText = (id, text) => {
+              var _a3;
+              const state = textStates.get(id);
+              if (state == null ? void 0 : state.ended) {
+                return;
+              }
+              const emittedText = (_a3 = state == null ? void 0 : state.text) != null ? _a3 : "";
+              if (text != null && text.startsWith(emittedText) && text.length > emittedText.length) {
+                emitTextDelta(id, text.slice(emittedText.length));
+              }
+              const finalState = textStates.get(id);
+              if (finalState != null) {
+                finalState.ended = true;
+                controller.enqueue({ type: "text-end", id });
+              }
+            };
+            const finishOutputText = (item, outputIndex) => {
+              var _a3;
+              if (item.type === "message") {
+                for (const [contentIndex, part] of ((_a3 = item.content) != null ? _a3 : []).entries()) {
+                  if (part.type === "output_text") {
+                    finishText(
+                      getTextId(item.id, outputIndex, contentIndex),
+                      part.text
+                    );
+                  }
+                }
+              }
+            };
+            const emitSource = (source) => {
+              if (emittedSourceUrls.has(source.url)) {
+                return;
+              }
+              if (hasSearchResultId(source)) {
+                pendingSourcesByUrl.delete(source.url);
+                emittedSourceUrls.add(source.url);
+                controller.enqueue(source);
+              } else if (!pendingSourcesByUrl.has(source.url)) {
+                pendingSourcesByUrl.set(source.url, source);
+              }
+            };
+            const emitReasoningThought = (thought) => {
+              if (activeReasoningId != null && thought != null) {
+                controller.enqueue({
+                  type: "reasoning-delta",
+                  id: activeReasoningId,
+                  delta: thought
+                });
+              }
+            };
+            const emitFunctionCall = (item) => {
+              var _a3;
+              if (item.type !== "function_call" || item.call_id == null || item.name == null || item.arguments == null || seenFunctionCalls.has(item.call_id)) {
+                return;
+              }
+              seenFunctionCalls.add(item.call_id);
+              hasFunctionCall = true;
               controller.enqueue({
-                type: "response-metadata",
-                ...getResponseMetadata(value)
+                type: "tool-input-start",
+                id: item.call_id,
+                toolName: item.name
               });
-              (_a = value.citations) == null ? void 0 : _a.forEach((url) => {
-                controller.enqueue({
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: item.call_id,
+                delta: item.arguments
+              });
+              controller.enqueue({ type: "tool-input-end", id: item.call_id });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: item.call_id,
+                toolName: item.name,
+                input: item.arguments,
+                providerMetadata: {
+                  perplexity: {
+                    itemId: (_a3 = item.id) != null ? _a3 : null,
+                    ...item.thought_signature != null && {
+                      thoughtSignature: item.thought_signature
+                    }
+                  }
+                }
+              });
+            };
+            const emitOutputSources = (item) => {
+              var _a3, _b3, _c2;
+              if (item.type === "message") {
+                for (const part of (_a3 = item.content) != null ? _a3 : []) {
+                  for (const annotation of (_b3 = part.annotations) != null ? _b3 : []) {
+                    if (annotation.url != null) {
+                      emitSource({
+                        type: "source",
+                        sourceType: "url",
+                        id: generateId2(),
+                        url: annotation.url,
+                        title: annotation.title
+                      });
+                    }
+                  }
+                }
+              }
+              for (const result of getSearchResults(item)) {
+                emitSource(createSource(result, generateId2));
+              }
+              for (const result of getFetchedSources(item)) {
+                emitSource({
                   type: "source",
                   sourceType: "url",
-                  id: self.config.generateId(),
-                  url
+                  id: generateId2(),
+                  url: result.url,
+                  title: result.title,
+                  providerMetadata: {
+                    perplexity: { snippet: (_c2 = result.snippet) != null ? _c2 : null }
+                  }
                 });
-              });
-              isFirstChunk = false;
-            }
-            if (value.usage != null) {
-              usage = value.usage;
-              providerMetadata.perplexity.usage = {
-                citationTokens: (_b = value.usage.citation_tokens) != null ? _b : null,
-                numSearchQueries: (_c = value.usage.num_search_queries) != null ? _c : null
-              };
-              providerMetadata.perplexity.cost = value.usage.cost ? {
-                inputTokensCost: (_d = value.usage.cost.input_tokens_cost) != null ? _d : null,
-                outputTokensCost: (_e = value.usage.cost.output_tokens_cost) != null ? _e : null,
-                requestCost: (_f = value.usage.cost.request_cost) != null ? _f : null,
-                totalCost: (_g = value.usage.cost.total_cost) != null ? _g : null
-              } : null;
-            }
-            if (value.images != null) {
-              providerMetadata.perplexity.images = value.images.map((image) => ({
-                imageUrl: image.image_url,
-                originUrl: image.origin_url,
-                height: image.height,
-                width: image.width
-              }));
-            }
-            const choice = value.choices[0];
-            if ((choice == null ? void 0 : choice.finish_reason) != null) {
-              finishReason = {
-                unified: mapPerplexityFinishReason(choice.finish_reason),
-                raw: choice.finish_reason
-              };
+              }
+            };
+            switch (value.type) {
+              case "response.created":
+              case "response.in_progress": {
+                if (!hasResponseMetadata && value.response != null) {
+                  controller.enqueue({
+                    type: "response-metadata",
+                    ...getResponseMetadata(value.response)
+                  });
+                  hasResponseMetadata = true;
+                }
+                break;
+              }
+              case "response.output_text.delta": {
+                if (value.delta != null) {
+                  emitTextDelta(
+                    getTextId(
+                      value.item_id,
+                      value.output_index,
+                      value.content_index
+                    ),
+                    value.delta
+                  );
+                }
+                break;
+              }
+              case "response.output_text.done": {
+                finishText(
+                  getTextId(
+                    value.item_id,
+                    value.output_index,
+                    value.content_index
+                  ),
+                  value.text
+                );
+                break;
+              }
+              case "response.reasoning.started": {
+                if (activeReasoningId != null) {
+                  controller.enqueue({
+                    type: "reasoning-end",
+                    id: activeReasoningId
+                  });
+                }
+                activeReasoningId = `reasoning-${(_a2 = value.sequence_number) != null ? _a2 : generateId2()}`;
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: activeReasoningId
+                });
+                emitReasoningThought(value.thought);
+                break;
+              }
+              case "response.reasoning.search_queries":
+              case "response.reasoning.fetch_url_queries": {
+                emitReasoningThought(value.thought);
+                break;
+              }
+              case "response.reasoning.search_results": {
+                emitReasoningThought(value.thought);
+                for (const result of (_b2 = value.results) != null ? _b2 : []) {
+                  emitSource(createSource(result, generateId2));
+                }
+                break;
+              }
+              case "response.reasoning.fetch_url_results": {
+                emitReasoningThought(value.thought);
+                for (const result of (_c = value.contents) != null ? _c : []) {
+                  emitSource({
+                    type: "source",
+                    sourceType: "url",
+                    id: generateId2(),
+                    url: result.url,
+                    title: result.title,
+                    providerMetadata: {
+                      perplexity: { snippet: (_d = result.snippet) != null ? _d : null }
+                    }
+                  });
+                }
+                break;
+              }
+              case "response.reasoning.stopped": {
+                emitReasoningThought(value.thought);
+                if (activeReasoningId != null) {
+                  controller.enqueue({
+                    type: "reasoning-end",
+                    id: activeReasoningId
+                  });
+                  activeReasoningId = void 0;
+                }
+                break;
+              }
+              case "response.output_item.done": {
+                if (value.item != null) {
+                  finishOutputText(value.item, value.output_index);
+                  emitOutputSources(value.item);
+                  emitFunctionCall(value.item);
+                }
+                break;
+              }
+              case "response.completed":
+              case "response.incomplete": {
+                if (value.response != null) {
+                  if (!hasResponseMetadata) {
+                    controller.enqueue({
+                      type: "response-metadata",
+                      ...getResponseMetadata(value.response)
+                    });
+                    hasResponseMetadata = true;
+                  }
+                  for (const [
+                    outputIndex,
+                    item
+                  ] of value.response.output.entries()) {
+                    finishOutputText(item, outputIndex);
+                    emitOutputSources(item);
+                    emitFunctionCall(item);
+                  }
+                  usage = (_e = value.response.usage) != null ? _e : void 0;
+                  const rawFinishReason = (_g = (_f = value.response.incomplete_details) == null ? void 0 : _f.reason) != null ? _g : value.response.status;
+                  finishReason = {
+                    unified: mapPerplexityFinishReason({
+                      status: value.response.status,
+                      incompleteReason: (_h = value.response.incomplete_details) == null ? void 0 : _h.reason,
+                      hasFunctionCall
+                    }),
+                    raw: rawFinishReason
+                  };
+                }
+                break;
+              }
+              case "response.failed": {
+                finishReason = { unified: "error", raw: "failed" };
+                controller.enqueue({
+                  type: "error",
+                  error: (_i = value.error) != null ? _i : new Error("Perplexity response failed")
+                });
+                break;
+              }
             }
-            if ((choice == null ? void 0 : choice.delta) == null) {
-              return;
+          },
+          flush(controller) {
+            for (const source of pendingSourcesByUrl.values()) {
+              controller.enqueue(source);
             }
-            const delta = choice.delta;
-            const textContent = delta.content;
-            if (textContent != null) {
-              if (!isActive) {
-                controller.enqueue({ type: "text-start", id: "0" });
-                isActive = true;
-              }
+            if (activeReasoningId != null) {
               controller.enqueue({
-                type: "text-delta",
-                id: "0",
-                delta: textContent
+                type: "reasoning-end",
+                id: activeReasoningId
               });
             }
-          },
-          flush(controller) {
-            if (isActive) {
-              controller.enqueue({ type: "text-end", id: "0" });
+            for (const [id, state] of textStates) {
+              if (!state.ended) {
+                controller.enqueue({ type: "text-end", id });
+              }
             }
             controller.enqueue({
               type: "finish",
               finishReason,
               usage: convertPerplexityUsage(usage),
-              providerMetadata
+              providerMetadata: getProviderMetadata(usage)
             });
           }
         })
@@ -483,87 +1223,6 @@ var PerplexityLanguageModel = class {
     };
   }
 };
-function getResponseMetadata({
-  id,
-  model,
-  created
-}) {
-  return {
-    id,
-    modelId: model,
-    timestamp: new Date(created * 1e3)
-  };
-}
-var perplexityCostSchema = z2.object({
-  input_tokens_cost: z2.number().nullish(),
-  output_tokens_cost: z2.number().nullish(),
-  reasoning_tokens_cost: z2.number().nullish(),
-  request_cost: z2.number().nullish(),
-  citation_tokens_cost: z2.number().nullish(),
-  search_queries_cost: z2.number().nullish(),
-  total_cost: z2.number().nullish()
-}).catchall(z2.json());
-var perplexityUsageSchema = z2.object({
-  prompt_tokens: z2.number(),
-  completion_tokens: z2.number(),
-  total_tokens: z2.number().nullish(),
-  search_context_size: z2.enum(["low", "medium", "high"]).nullish(),
-  citation_tokens: z2.number().nullish(),
-  num_search_queries: z2.number().nullish(),
-  reasoning_tokens: z2.number().nullish(),
-  cost: perplexityCostSchema.nullish()
-}).catchall(z2.json());
-var perplexityImageSchema = z2.object({
-  image_url: z2.string(),
-  origin_url: z2.string(),
-  height: z2.number(),
-  width: z2.number()
-});
-var perplexityResponseSchema = z2.object({
-  id: z2.string(),
-  created: z2.number(),
-  model: z2.string(),
-  choices: z2.array(
-    z2.object({
-      message: z2.object({
-        role: z2.literal("assistant"),
-        content: z2.string()
-      }),
-      finish_reason: z2.string().nullish()
-    })
-  ),
-  citations: z2.array(z2.string()).nullish(),
-  images: z2.array(perplexityImageSchema).nullish(),
-  usage: perplexityUsageSchema.nullish()
-});
-var perplexityChunkSchema = z2.object({
-  id: z2.string(),
-  created: z2.number(),
-  model: z2.string(),
-  choices: z2.array(
-    z2.object({
-      delta: z2.object({
-        role: z2.literal("assistant").optional(),
-        content: z2.string().nullish()
-      }),
-      finish_reason: z2.string().nullish()
-    })
-  ),
-  citations: z2.array(z2.string()).nullish(),
-  images: z2.array(perplexityImageSchema).nullish(),
-  usage: perplexityUsageSchema.nullish()
-});
-var perplexityErrorSchema = z2.object({
-  error: z2.object({
-    code: z2.number(),
-    message: z2.string().nullish(),
-    type: z2.string().nullish()
-  })
-});
-var errorToMessage = (data) => {
-  var _a, _b;
-  return (_b = (_a = data.error.message) != null ? _a : data.error.type) != null ? _b : "unknown error";
-};
 
 // src/perplexity-embedding-model.ts
 var PerplexityEmbeddingModel = class {
@@ -593,7 +1252,7 @@ var PerplexityEmbeddingModel = class {
         values
       });
     }
-    const perplexityOptions = (_a = await parseProviderOptions({
+    const perplexityOptions = (_a = await parseProviderOptions2({
       provider: "perplexity",
       providerOptions,
       schema: perplexityEmbeddingModelOptions
@@ -614,10 +1273,7 @@ var PerplexityEmbeddingModel = class {
       },
       failedResponseHandler: createJsonErrorResponseHandler2({
         errorSchema: perplexityErrorSchema,
-        errorToMessage: (data) => {
-          var _a2;
-          return (_a2 = data.error.message) != null ? _a2 : "Unknown error";
-        }
+        errorToMessage: perplexityErrorToMessage
       }),
       successfulResponseHandler: createJsonResponseHandler2(
         perplexityEmbeddingResponseSchema
@@ -646,7 +1302,7 @@ var PerplexityEmbeddingModel = class {
   }
 };
 function decodeEmbedding(base64, encodingFormat) {
-  const bytes = convertBase64ToUint8Array2(base64);
+  const bytes = convertBase64ToUint8Array(base64);
   if (encodingFormat === "base64_int8") {
     const int8 = new Int8Array(
       bytes.buffer,
@@ -657,20 +1313,20 @@ function decodeEmbedding(base64, encodingFormat) {
   }
   return Array.from(bytes);
 }
-var perplexityEmbeddingResponseSchema = z3.object({
-  data: z3.array(z3.object({ embedding: z3.string() })),
-  usage: z3.object({
-    prompt_tokens: z3.number(),
-    cost: z3.object({
-      input_cost: z3.number().nullish(),
-      total_cost: z3.number().nullish(),
-      currency: z3.string().nullish()
+var perplexityEmbeddingResponseSchema = z4.object({
+  data: z4.array(z4.object({ embedding: z4.string() })),
+  usage: z4.object({
+    prompt_tokens: z4.number(),
+    cost: z4.object({
+      input_cost: z4.number().nullish(),
+      total_cost: z4.number().nullish(),
+      currency: z4.string().nullish()
     }).nullish()
   }).nullish()
 });
 
 // src/version.ts
-var VERSION = true ? "3.0.63" : "0.0.0-test";
+var VERSION = true ? "3.1.1" : "0.0.0-test";
 
 // src/perplexity-provider.ts
 function createPerplexity(options = {}) {