@ai-sdk/perplexity 4.0.50 → 5.0.0

package/dist/index.js

@@ -45,49 +45,51 @@ var perplexityEmbeddingModelOptions = z.object({
 });
 
 // src/perplexity-language-model.ts
+import {
+  APICallError
+} from "@ai-sdk/provider";
 import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
-  createLanguageModelResponseMetadata as getResponseMetadata,
+  createLanguageModelResponseMetadata,
   isCustomReasoning,
   parseProviderOptions,
   postJsonToApi,
   serializeModelOptions,
-  WORKFLOW_SERIALIZE,
-  WORKFLOW_DESERIALIZE
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE
 } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
 
 // src/convert-perplexity-usage.ts
 import { createNullLanguageModelUsage } from "@ai-sdk/provider-utils";
 function convertPerplexityUsage(usage) {
-  var _a, _b, _c;
   if (usage == null) {
     return createNullLanguageModelUsage();
   }
-  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 = usage.input_tokens ?? 0;
+  const outputTokens = usage.output_tokens ?? 0;
+  const cacheReadTokens = usage.input_tokens_details?.cache_read_input_tokens ?? usage.input_tokens_details?.cached_tokens ?? 0;
+  const cacheWriteTokens = usage.input_tokens_details?.cache_creation_input_tokens ?? 0;
+  const reasoningTokens = usage.output_tokens_details?.reasoning_tokens ?? 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";
@@ -96,95 +98,154 @@ import {
   getTopLevelMediaType,
   resolveFullMediaType
 } from "@ai-sdk/provider-utils";
-function convertToPerplexityMessages(prompt) {
-  const messages = [];
+function serializeToolOutput(output) {
+  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 output.reason ?? "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 getThoughtSignature(providerOptions) {
+  const thoughtSignature = providerOptions?.perplexity?.thoughtSignature;
+  return typeof thoughtSignature === "string" ? thoughtSignature : void 0;
+}
+function convertToPerplexityInput(prompt) {
+  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" && getTopLevelMediaType(part.mediaType) === "image" || part.type === "file" && getTopLevelMediaType(part.mediaType) === "application"
-        );
-        const messageContent = content.map((part, index) => {
-          switch (part.type) {
-            case "text": {
-              return {
-                type: "text",
-                text: part.text
-              };
-            }
-            case "file": {
-              switch (part.data.type) {
-                case "reference": {
+      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 parts with provider references"
-                  });
-                }
-                case "text": {
-                  throw new UnsupportedFunctionalityError({
-                    functionality: "text file parts"
+                    functionality: `file part media type ${part.mediaType}`
                   });
                 }
-                case "url":
-                case "data": {
-                  const topLevelMediaType = getTopLevelMediaType(
-                    part.mediaType
-                  );
-                  if (topLevelMediaType === "application") {
-                    const fullMediaType = resolveFullMediaType({ part });
-                    if (fullMediaType !== "application/pdf") {
-                      throw new UnsupportedFunctionalityError({
-                        functionality: `file part media type ${fullMediaType}`
-                      });
-                    }
-                    return part.data.type === "url" ? {
-                      type: "file_url",
-                      file_url: {
-                        url: part.data.url.toString()
-                      },
-                      file_name: part.filename
-                    } : {
-                      type: "file_url",
-                      file_url: {
-                        url: typeof part.data.data === "string" ? part.data.data : convertUint8ArrayToBase64(part.data.data)
-                      },
-                      file_name: part.filename || `document-${index}.pdf`
+                switch (part.data.type) {
+                  case "url":
+                    return {
+                      type: "input_image",
+                      image_url: part.data.url.toString()
                     };
-                  } else if (topLevelMediaType === "image") {
-                    return part.data.type === "url" ? {
-                      type: "image_url",
-                      image_url: {
-                        url: part.data.url.toString()
-                      }
-                    } : {
-                      type: "image_url",
-                      image_url: {
-                        url: `data:${resolveFullMediaType({ part })};base64,${typeof part.data.data === "string" ? part.data.data : convertUint8ArrayToBase64(part.data.data)}`
-                      }
+                  case "data":
+                    return {
+                      type: "input_image",
+                      image_url: `data:${resolveFullMediaType({ part })};base64,${typeof part.data.data === "string" ? part.data.data : convertUint8ArrayToBase64(part.data.data)}`
                     };
-                  }
-                  throw new UnsupportedFunctionalityError({
-                    functionality: `file part media type ${part.mediaType}`
-                  });
+                  case "reference":
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "file parts with provider references"
+                    });
+                  case "text":
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "text file parts"
+                    });
                 }
               }
             }
           }
-        }).filter(Boolean);
-        messages.push({
-          role,
-          content: hasMultipartContent ? messageContent : messageContent.filter((part) => part.type === "text").map((part) => part.text).join("")
+        );
+        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(part.input ?? {}),
+                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":
+            case "reasoning-file":
+            case "custom":
+              throw new UnsupportedFunctionalityError({
+                functionality: `assistant ${part.type} parts`
+              });
+            default: {
+              const _exhaustiveCheck = part;
+              throw new Error(
+                `Unsupported assistant part: ${_exhaustiveCheck}`
+              );
+            }
+          }
+        }
+        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;
@@ -192,141 +253,420 @@ function convertToPerplexityMessages(prompt) {
       }
     }
   }
-  return messages;
+  return { input, warnings };
 }
 
 // src/map-perplexity-finish-reason.ts
-function mapPerplexityFinishReason(finishReason) {
-  switch (finishReason) {
-    case "stop":
-    case "length":
-      return finishReason;
+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 "other";
+      return hasFunctionCall ? "tool-calls" : "other";
   }
 }
 
-// src/perplexity-language-model-options.ts
+// src/perplexity-agent-api.ts
 import { z as z2 } from "zod/v4";
-var perplexityLanguageModelOptions = z2.looseObject({
-  /**
-   * Filters search results to those published within the specified time window.
-   * Cannot be combined with other date filters.
-   */
-  search_recency_filter: z2.enum(["hour", "day", "week", "month", "year"]).optional(),
-  /**
-   * Restrict web search results to specific domains or URLs.
-   * Prefix a domain with "-" to exclude it.
-   */
-  search_domain_filter: z2.array(z2.string()).optional(),
-  /**
-   * Filter search results by language using ISO 639-1 codes.
-   */
-  search_language_filter: z2.array(z2.string()).optional(),
-  /**
-   * Return search results published after this date.
-   */
-  search_after_date_filter: z2.string().optional(),
-  /**
-   * Return search results published before this date.
-   */
-  search_before_date_filter: z2.string().optional(),
-  /**
-   * Return search results last updated after this date.
-   */
-  last_updated_after_filter: z2.string().optional(),
-  /**
-   * Return search results last updated before this date.
-   */
-  last_updated_before_filter: z2.string().optional(),
-  /**
-   * Source of search results.
-   */
-  search_mode: z2.enum(["web", "academic", "sec"]).optional(),
-  /**
-   * If true, the model decides whether web search is needed.
-   */
-  enable_search_classifier: z2.boolean().optional(),
-  /**
-   * If true, disables web search.
-   */
-  disable_search: z2.boolean().optional(),
-  /**
-   * If true, a list of related questions is included in the response.
-   */
-  return_related_questions: z2.boolean().optional(),
-  /**
-   * If true, image search results are included in the response.
-   */
-  return_images: z2.boolean().optional(),
-  /**
-   * Restrict image results to specific domains.
-   * Prefix a domain with "-" to exclude it.
-   */
-  image_domain_filter: z2.array(z2.string()).optional(),
+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().optional(),
+  response: perplexityAgentResponseSchema.optional(),
+  item: perplexityOutputItemSchema.optional(),
+  output_index: z2.number().optional(),
+  item_id: z2.string().optional(),
+  content_index: z2.number().optional(),
+  delta: z2.string().optional(),
+  text: z2.string().optional(),
+  thought: z2.string().optional(),
+  queries: z2.array(z2.string()).optional(),
+  urls: z2.array(z2.string()).optional(),
+  results: z2.array(perplexitySearchResultSchema).optional(),
+  contents: z2.array(perplexityFetchedContentSchema).optional(),
+  error: z2.looseObject({
+    code: z2.string().optional(),
+    message: z2.string(),
+    type: z2.string().optional()
+  }).optional()
+});
+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) {
+  if (typeof data.error === "string") {
+    return data.error;
+  }
+  if (data.error != null) {
+    return data.error.message ?? data.error.type ?? "unknown error";
+  }
+  if (typeof data.detail === "string") {
+    return data.detail;
+  }
+  if (Array.isArray(data.detail)) {
+    return data.detail.map((detail) => detail.msg).join(", ");
+  }
+  return data.message ?? "unknown error";
+}
+
+// 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(),
   /**
-   * Restrict image results to specific file formats.
+   * Native Agent API tools. AI SDK function tools can also be supplied through
+   * the top-level `tools` option on `generateText` and `streamText`.
    */
-  image_format_filter: z2.array(z2.string()).optional(),
+  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(),
   /**
-   * Additional media response configuration.
+   * Whether the response can be retrieved later. Setting this to false does
+   * not disable persistence or prevent previous_response_id continuations.
    */
-  media_response: z2.looseObject({
-    overrides: z2.looseObject({
-      /**
-       * If true, video results are included in the response.
-       */
-      return_videos: z2.boolean().optional()
-    }).optional()
+  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(),
-  /**
-   * Controls the format of streaming events.
-   */
-  stream_mode: z2.enum(["full", "concise"]).optional(),
-  /**
-   * Controls how much effort the model spends on reasoning.
-   */
-  reasoning_effort: z2.enum(["minimal", "low", "medium", "high"]).optional(),
-  /**
-   * Preferred response language as an ISO 639-1 language code.
-   */
-  language_preference: z2.string().optional(),
-  /**
-   * Additional web search configuration.
-   */
-  web_search_options: z2.looseObject({
-    /**
-     * Controls the size of search context injected into the model.
-     */
-    search_context_size: z2.enum(["low", "medium", "high"]).optional(),
-    /**
-     * Controls whether to use fast search, pro search, or automatic routing.
-     */
-    search_type: z2.enum(["fast", "pro", "auto"]).optional(),
-    /**
-     * User location for search result personalization.
-     */
-    user_location: z2.looseObject({
-      latitude: z2.number().optional(),
-      longitude: z2.number().optional(),
-      country: z2.string().optional(),
-      city: z2.string().optional(),
-      region: z2.string().optional()
-    }).optional(),
-    /**
-     * If true, applies enhanced relevance filtering to image results.
-     */
-    image_results_enhanced_relevance: z2.boolean().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 ?? []) {
+    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) {
+  return createLanguageModelResponseMetadata({
+    id: response.id,
+    model: response.model,
+    created: response.created_at
+  });
+}
+function getProviderMetadata(usage) {
+  const cost = usage?.cost;
+  const numSearchQueries = usage?.tool_calls_details ? Object.entries(usage.tool_calls_details).filter(([name]) => name.includes("search")).reduce((total, [, details]) => total + (details.invocation ?? 0), 0) : null;
+  return {
+    perplexity: {
+      usage: {
+        citationTokens: null,
+        numSearchQueries
+      },
+      images: null,
+      cost: cost == null ? null : {
+        inputTokensCost: cost.input_cost ?? null,
+        outputTokensCost: cost.output_cost ?? null,
+        requestCost: null,
+        totalCost: cost.total_cost ?? null,
+        currency: cost.currency ?? null,
+        cacheCreationCost: cost.cache_creation_cost ?? null,
+        cacheReadCost: cost.cache_read_cost ?? null,
+        toolCallsCost: cost.tool_calls_cost ?? null
+      },
+      toolCalls: usage?.tool_calls_details == null ? null : Object.fromEntries(
+        Object.entries(usage.tool_calls_details).map(
+          ([name, details]) => [
+            name,
+            { invocation: details.invocation ?? null }
+          ]
+        )
+      )
+    }
+  };
+}
+function createSource(result, generateId2) {
+  return {
+    type: "source",
+    sourceType: "url",
+    id: result.id == null ? generateId2() : String(result.id),
+    url: result.url,
+    title: result.title,
+    providerMetadata: {
+      perplexity: {
+        resultId: result.id ?? null,
+        snippet: result.snippet ?? null,
+        date: result.date ?? null,
+        lastUpdated: result.last_updated ?? null,
+        source: result.source ?? null
+      }
+    }
+  };
+}
+function hasSearchResultId(source) {
+  return typeof source.providerMetadata?.perplexity?.resultId === "number";
+}
+function getSearchResults(item) {
+  return item.type === "search_results" ? item.results ?? [] : [];
+}
+function getFetchedSources(item) {
+  return item.type === "fetch_url_results" ? item.contents ?? [] : [];
+}
 var PerplexityLanguageModel = class _PerplexityLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     this.provider = "perplexity";
     this.supportedUrls = {
-      // No URLs are supported.
+      "image/*": [/^https?:\/\/.*$/]
     };
     this.modelId = modelId;
     this.config = config;
@@ -352,97 +692,186 @@ var PerplexityLanguageModel = class _PerplexityLanguageModel {
     reasoning,
     responseFormat,
     seed,
-    providerOptions
+    providerOptions,
+    tools,
+    toolChoice
   }) {
-    var _a;
     const warnings = [];
-    const perplexityOptions = (_a = await parseProviderOptions({
+    const perplexityOptions = 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" });
     }
-    if (isCustomReasoning(reasoning)) {
+    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 ?? [],
+      ...functionTools
+    ];
+    let reasoningConfig = agentOptions.reasoning;
+    if (reasoningConfig == null && isCustomReasoning(reasoning)) {
+      if (reasoning === "none") {
+        warnings.push({
+          type: "unsupported",
+          feature: 'reasoning "none"'
+        });
+      } else {
+        reasoningConfig = { effort: reasoning };
+      }
+    }
+    const body = {
+      ...agentOptions,
+      ...modelSelection,
+      input,
+      max_output_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      reasoning: reasoningConfig,
+      response_format: responseFormat?.type === "json" && responseFormat.schema != null ? {
+        type: "json_schema",
+        json_schema: {
+          name: responseFormat.name ?? "response",
+          description: responseFormat.description,
+          schema: responseFormat.schema,
+          strict: true
+        }
+      } : void 0,
+      tools: agentTools.length > 0 ? agentTools : void 0
+    };
+    if (responseFormat?.type === "json" && responseFormat.schema == null) {
       warnings.push({
         type: "unsupported",
-        feature: "reasoning",
-        details: "This provider does not support reasoning configuration."
+        feature: "JSON response format without a schema"
       });
     }
-    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
-        ...perplexityOptions,
-        // messages:
-        messages: convertToPerplexityMessages(prompt)
-      },
-      warnings
-    };
+    return { args: body, warnings };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
     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((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
+      url,
+      headers: combineHeaders(this.config.headers?.(), 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: response.error?.message ?? "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 item.content ?? []) {
+          if (part.type === "output_text" && part.text != null) {
+            content.push({ type: "text", text: part.text });
+          }
+          for (const annotation of part.annotations ?? []) {
+            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: result.snippet ?? 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: item.id ?? null,
+              ...item.thought_signature != null && {
+                thoughtSignature: item.thought_signature
+              }
+            }
+          }
         });
       }
     }
+    const finishReason = response.incomplete_details?.reason ?? response.status;
     return {
       content,
       finishReason: {
-        unified: mapPerplexityFinishReason(choice.finish_reason),
-        raw: (_c = choice.finish_reason) != null ? _c : void 0
+        unified: mapPerplexityFinishReason({
+          status: response.status,
+          incompleteReason: response.incomplete_details?.reason,
+          hasFunctionCall
+        }),
+        raw: finishReason
       },
       usage: convertPerplexityUsage(response.usage),
       request: { body },
@@ -452,42 +881,22 @@ var PerplexityLanguageModel = class _PerplexityLanguageModel {
         body: rawResponse
       },
       warnings,
-      providerMetadata: {
-        perplexity: {
-          images: (_e = (_d = response.images) == null ? void 0 : _d.map((image) => ({
-            imageUrl: image.image_url,
-            originUrl: image.origin_url,
-            height: image.height,
-            width: image.width
-          }))) != null ? _e : null,
-          usage: {
-            citationTokens: (_g = (_f = response.usage) == null ? void 0 : _f.citation_tokens) != null ? _g : null,
-            numSearchQueries: (_i = (_h = response.usage) == null ? void 0 : _h.num_search_queries) != null ? _i : null
-          },
-          cost: ((_j = response.usage) == null ? void 0 : _j.cost) ? {
-            inputTokensCost: (_k = response.usage.cost.input_tokens_cost) != null ? _k : null,
-            outputTokensCost: (_l = response.usage.cost.output_tokens_cost) != null ? _l : null,
-            requestCost: (_m = response.usage.cost.request_cost) != null ? _m : null,
-            totalCost: (_n = response.usage.cost.total_cost) != null ? _n : null
-          } : null
-        }
-      }
+      providerMetadata: getProviderMetadata(response.usage)
     };
   }
   async doStream(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((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
+      url: `${this.config.baseURL}/v1/agent`,
+      headers: combineHeaders(this.config.headers?.(), options.headers),
       body,
       failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: perplexityErrorSchema,
-        errorToMessage
+        errorToMessage: perplexityErrorToMessage
       }),
       successfulResponseHandler: createEventSourceResponseHandler(
-        perplexityChunkSchema
+        perplexityAgentChunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
@@ -496,20 +905,15 @@ var PerplexityLanguageModel = class _PerplexityLanguageModel {
       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({
@@ -517,84 +921,303 @@ var PerplexityLanguageModel = class _PerplexityLanguageModel {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a2, _b2, _c, _d, _e, _f, _g;
             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 ?? String(outputIndex ?? "text");
+              return contentIndex === 0 ? id : `${id}:${contentIndex}`;
+            };
+            const emitTextDelta = (id, delta) => {
+              let state = textStates.get(id);
+              if (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) => {
+              const state = textStates.get(id);
+              if (state?.ended) {
+                return;
+              }
+              const emittedText = state?.text ?? "";
+              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) => {
+              if (item.type === "message") {
+                for (const [contentIndex, part] of (item.content ?? []).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) => {
+              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
               });
-              (_a2 = value.citations) == null ? void 0 : _a2.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: item.id ?? null,
+                    ...item.thought_signature != null && {
+                      thoughtSignature: item.thought_signature
+                    }
+                  }
+                }
+              });
+            };
+            const emitOutputSources = (item) => {
+              if (item.type === "message") {
+                for (const part of item.content ?? []) {
+                  for (const annotation of part.annotations ?? []) {
+                    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: result.snippet ?? null }
+                  }
                 });
-              });
-              isFirstChunk = false;
-            }
-            if (value.usage != null) {
-              usage = value.usage;
-              providerMetadata.perplexity.usage = {
-                citationTokens: (_b2 = value.usage.citation_tokens) != null ? _b2 : 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-${value.sequence_number ?? 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 value.results ?? []) {
+                  emitSource(createSource(result, generateId2));
+                }
+                break;
+              }
+              case "response.reasoning.fetch_url_results": {
+                emitReasoningThought(value.thought);
+                for (const result of value.contents ?? []) {
+                  emitSource({
+                    type: "source",
+                    sourceType: "url",
+                    id: generateId2(),
+                    url: result.url,
+                    title: result.title,
+                    providerMetadata: {
+                      perplexity: { snippet: result.snippet ?? 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 = value.response.usage ?? void 0;
+                  const rawFinishReason = value.response.incomplete_details?.reason ?? value.response.status;
+                  finishReason = {
+                    unified: mapPerplexityFinishReason({
+                      status: value.response.status,
+                      incompleteReason: value.response.incomplete_details?.reason,
+                      hasFunctionCall
+                    }),
+                    raw: rawFinishReason
+                  };
+                }
+                break;
+              }
+              case "response.failed": {
+                finishReason = { unified: "error", raw: "failed" };
+                controller.enqueue({
+                  type: "error",
+                  error: value.error ?? 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)
             });
           }
         })
@@ -604,76 +1227,6 @@ var PerplexityLanguageModel = class _PerplexityLanguageModel {
     };
   }
 };
-var perplexityCostSchema = z3.object({
-  input_tokens_cost: z3.number().nullish(),
-  output_tokens_cost: z3.number().nullish(),
-  reasoning_tokens_cost: z3.number().nullish(),
-  request_cost: z3.number().nullish(),
-  citation_tokens_cost: z3.number().nullish(),
-  search_queries_cost: z3.number().nullish(),
-  total_cost: z3.number().nullish()
-}).catchall(z3.json());
-var perplexityUsageSchema = z3.object({
-  prompt_tokens: z3.number(),
-  completion_tokens: z3.number(),
-  total_tokens: z3.number().nullish(),
-  search_context_size: z3.enum(["low", "medium", "high"]).nullish(),
-  citation_tokens: z3.number().nullish(),
-  num_search_queries: z3.number().nullish(),
-  reasoning_tokens: z3.number().nullish(),
-  cost: perplexityCostSchema.nullish()
-}).catchall(z3.json());
-var perplexityImageSchema = z3.object({
-  image_url: z3.string(),
-  origin_url: z3.string(),
-  height: z3.number(),
-  width: z3.number()
-});
-var perplexityResponseSchema = z3.object({
-  id: z3.string(),
-  created: z3.number(),
-  model: z3.string(),
-  choices: z3.array(
-    z3.object({
-      message: z3.object({
-        role: z3.literal("assistant"),
-        content: z3.string()
-      }),
-      finish_reason: z3.string().nullish()
-    })
-  ),
-  citations: z3.array(z3.string()).nullish(),
-  images: z3.array(perplexityImageSchema).nullish(),
-  usage: perplexityUsageSchema.nullish()
-});
-var perplexityChunkSchema = z3.object({
-  id: z3.string(),
-  created: z3.number(),
-  model: z3.string(),
-  choices: z3.array(
-    z3.object({
-      delta: z3.object({
-        role: z3.literal("assistant").optional(),
-        content: z3.string().nullish()
-      }),
-      finish_reason: z3.string().nullish()
-    })
-  ),
-  citations: z3.array(z3.string()).nullish(),
-  images: z3.array(perplexityImageSchema).nullish(),
-  usage: perplexityUsageSchema.nullish()
-});
-var perplexityErrorSchema = z3.object({
-  error: z3.object({
-    code: z3.number(),
-    message: z3.string().nullish(),
-    type: z3.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 _PerplexityEmbeddingModel {
@@ -703,7 +1256,6 @@ var PerplexityEmbeddingModel = class _PerplexityEmbeddingModel {
     headers,
     providerOptions
   }) {
-    var _a, _b, _c, _d, _e, _f;
     if (values.length > this.maxEmbeddingsPerCall) {
       throw new TooManyEmbeddingValuesForCallError({
         provider: this.provider,
@@ -712,12 +1264,12 @@ var PerplexityEmbeddingModel = class _PerplexityEmbeddingModel {
         values
       });
     }
-    const perplexityOptions = (_a = await parseProviderOptions2({
+    const perplexityOptions = await parseProviderOptions2({
       provider: "perplexity",
       providerOptions,
       schema: perplexityEmbeddingModelOptions
-    })) != null ? _a : {};
-    const encodingFormat = (_b = perplexityOptions.encodingFormat) != null ? _b : "base64_int8";
+    }) ?? {};
+    const encodingFormat = perplexityOptions.encodingFormat ?? "base64_int8";
     const {
       responseHeaders,
       value: response,
@@ -733,10 +1285,7 @@ var PerplexityEmbeddingModel = class _PerplexityEmbeddingModel {
       },
       failedResponseHandler: createJsonErrorResponseHandler2({
         errorSchema: perplexityErrorSchema,
-        errorToMessage: (data) => {
-          var _a2;
-          return (_a2 = data.error.message) != null ? _a2 : "Unknown error";
-        }
+        errorToMessage: perplexityErrorToMessage
       }),
       successfulResponseHandler: createJsonResponseHandler2(
         perplexityEmbeddingResponseSchema
@@ -744,7 +1293,7 @@ var PerplexityEmbeddingModel = class _PerplexityEmbeddingModel {
       abortSignal,
       fetch: this.config.fetch
     });
-    const cost = (_c = response.usage) == null ? void 0 : _c.cost;
+    const cost = response.usage?.cost;
     return {
       embeddings: response.data.map(
         (item) => decodeEmbedding(item.embedding, encodingFormat)
@@ -753,9 +1302,9 @@ var PerplexityEmbeddingModel = class _PerplexityEmbeddingModel {
       providerMetadata: cost ? {
         perplexity: {
           cost: {
-            inputCost: (_d = cost.input_cost) != null ? _d : null,
-            totalCost: (_e = cost.total_cost) != null ? _e : null,
-            currency: (_f = cost.currency) != null ? _f : null
+            inputCost: cost.input_cost ?? null,
+            totalCost: cost.total_cost ?? null,
+            currency: cost.currency ?? null
           }
         }
       } : void 0,
@@ -789,11 +1338,10 @@ var perplexityEmbeddingResponseSchema = z4.object({
 });
 
 // src/version.ts
-var VERSION = true ? "4.0.50" : "0.0.0-test";
+var VERSION = true ? "5.0.0" : "0.0.0-test";
 
 // src/perplexity-provider.ts
 function createPerplexity(options = {}) {
-  var _a;
   const getHeaders = () => withUserAgentSuffix(
     {
       Authorization: `Bearer ${loadApiKey({
@@ -806,7 +1354,7 @@ function createPerplexity(options = {}) {
     `ai-sdk/perplexity/${VERSION}`
   );
   const baseURL = withoutTrailingSlash(
-    (_a = options.baseURL) != null ? _a : "https://api.perplexity.ai"
+    options.baseURL ?? "https://api.perplexity.ai"
   );
   const createLanguageModel = (modelId) => {
     return new PerplexityLanguageModel(modelId, {