@ai-sdk/perplexity 5.0.2 → 5.0.4

package/dist/index.js

@@ -1,1390 +1,1126 @@
-// src/perplexity-provider.ts
-import {
-  NoSuchModelError
-} from "@ai-sdk/provider";
-import {
-  generateId,
-  loadApiKey,
-  withoutTrailingSlash,
-  withUserAgentSuffix
-} from "@ai-sdk/provider-utils";
-
-// src/perplexity-embedding-model.ts
-import {
-  TooManyEmbeddingValuesForCallError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders as combineHeaders2,
-  convertBase64ToUint8Array,
-  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
-  createJsonResponseHandler as createJsonResponseHandler2,
-  parseProviderOptions as parseProviderOptions2,
-  postJsonToApi as postJsonToApi2,
-  serializeModelOptions as serializeModelOptions2,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2
-} from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
-
-// src/perplexity-embedding-model-options.ts
+import { APICallError, NoSuchModelError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertBase64ToUint8Array, convertUint8ArrayToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createNullLanguageModelUsage, generateId, getTopLevelMediaType, isCustomReasoning, loadApiKey, parseProviderOptions, postJsonToApi, resolveFullMediaType, serializeModelOptions, withUserAgentSuffix, withoutTrailingSlash } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
-var perplexityEmbeddingModelOptions = z.object({
-  /**
-   * The number of dimensions the resulting output embeddings should have
-   * (Matryoshka truncation). Ranges from 128 up to the model's full size
-   * (1024 for 0.6b models, 2560 for 4b models).
-   */
-  dimensions: z.number().int().positive().optional(),
-  /**
-   * The quantized encoding format returned by the API. Perplexity does not
-   * return floating point embeddings; values are decoded to numbers:
-   * - `base64_int8` (default): signed int8 values, compare via cosine similarity.
-   * - `base64_binary`: packed bits per byte (0-255), compare via Hamming distance.
-   */
-  encodingFormat: z.enum(["base64_int8", "base64_binary"]).optional()
+//#region src/perplexity-embedding-model-options.ts
+const perplexityEmbeddingModelOptions = z.object({
+	/**
+	* The number of dimensions the resulting output embeddings should have
+	* (Matryoshka truncation). Ranges from 128 up to the model's full size
+	* (1024 for 0.6b models, 2560 for 4b models).
+	*/
+	dimensions: z.number().int().positive().optional(),
+	/**
+	* The quantized encoding format returned by the API. Perplexity does not
+	* return floating point embeddings; values are decoded to numbers:
+	* - `base64_int8` (default): signed int8 values, compare via cosine similarity.
+	* - `base64_binary`: packed bits per byte (0-255), compare via Hamming distance.
+	*/
+	encodingFormat: z.enum(["base64_int8", "base64_binary"]).optional()
 });
-
-// src/perplexity-language-model.ts
-import {
-  APICallError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders,
-  createEventSourceResponseHandler,
-  createJsonErrorResponseHandler,
-  createJsonResponseHandler,
-  createLanguageModelResponseMetadata,
-  isCustomReasoning,
-  parseProviderOptions,
-  postJsonToApi,
-  serializeModelOptions,
-  WORKFLOW_DESERIALIZE,
-  WORKFLOW_SERIALIZE
-} from "@ai-sdk/provider-utils";
-
-// src/convert-perplexity-usage.ts
-import { createNullLanguageModelUsage } from "@ai-sdk/provider-utils";
+//#endregion
+//#region src/convert-perplexity-usage.ts
 function convertPerplexityUsage(usage) {
-  if (usage == null) {
-    return createNullLanguageModelUsage();
-  }
-  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: inputTokens,
-      noCache: Math.max(0, inputTokens - cacheReadTokens - cacheWriteTokens),
-      cacheRead: cacheReadTokens,
-      cacheWrite: cacheWriteTokens
-    },
-    outputTokens: {
-      total: outputTokens,
-      text: Math.max(0, outputTokens - reasoningTokens),
-      reasoning: reasoningTokens
-    },
-    raw: usage
-  };
+	if (usage == null) return createNullLanguageModelUsage();
+	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: inputTokens,
+			noCache: Math.max(0, inputTokens - cacheReadTokens - cacheWriteTokens),
+			cacheRead: cacheReadTokens,
+			cacheWrite: cacheWriteTokens
+		},
+		outputTokens: {
+			total: outputTokens,
+			text: Math.max(0, outputTokens - reasoningTokens),
+			reasoning: reasoningTokens
+		},
+		raw: usage
+	};
 }
-
-// src/convert-to-perplexity-input.ts
-import {
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-import {
-  convertUint8ArrayToBase64,
-  getTopLevelMediaType,
-  resolveFullMediaType
-} from "@ai-sdk/provider-utils";
+//#endregion
+//#region src/convert-to-perplexity-input.ts
 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}`);
-    }
-  }
+	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: throw new Error(`Unsupported tool output: ${output}`);
+	}
 }
 function getThoughtSignature(providerOptions) {
-  const thoughtSignature = providerOptions?.perplexity?.thoughtSignature;
-  return typeof thoughtSignature === "string" ? thoughtSignature : void 0;
+	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": {
-        input.push({ type: "message", role: "system", content });
-        break;
-      }
-      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 ${part.mediaType}`
-                  });
-                }
-                switch (part.data.type) {
-                  case "url":
-                    return {
-                      type: "input_image",
-                      image_url: part.data.url.toString()
-                    };
-                  case "data":
-                    return {
-                      type: "input_image",
-                      image_url: `data:${resolveFullMediaType({ part })};base64,${typeof part.data.data === "string" ? part.data.data : convertUint8ArrayToBase64(part.data.data)}`
-                    };
-                  case "reference":
-                    throw new UnsupportedFunctionalityError({
-                      functionality: "file parts with provider references"
-                    });
-                  case "text":
-                    throw new UnsupportedFunctionalityError({
-                      functionality: "text file parts"
-                    });
-                }
-              }
-            }
-          }
-        );
-        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": {
-        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;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-      }
-    }
-  }
-  return { input, warnings };
+	const input = [];
+	const warnings = [];
+	for (const { role, content } of prompt) switch (role) {
+		case "system":
+			input.push({
+				type: "message",
+				role: "system",
+				content
+			});
+			break;
+		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 ${part.mediaType}` });
+						switch (part.data.type) {
+							case "url": return {
+								type: "input_image",
+								image_url: part.data.url.toString()
+							};
+							case "data": return {
+								type: "input_image",
+								image_url: `data:${resolveFullMediaType({ part })};base64,${typeof part.data.data === "string" ? part.data.data : convertUint8ArrayToBase64(part.data.data)}`
+							};
+							case "reference": throw new UnsupportedFunctionalityError({ functionality: "file parts with provider references" });
+							case "text": throw new UnsupportedFunctionalityError({ functionality: "text file parts" });
+						}
+				}
+			});
+			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: throw new Error(`Unsupported assistant part: ${part}`);
+			}
+			break;
+		}
+		case "tool":
+			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: throw new Error(`Unsupported role: ${role}`);
+	}
+	return {
+		input,
+		warnings
+	};
 }
-
-// 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";
-  }
+//#endregion
+//#region 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";
+		default: return hasFunctionCall ? "tool-calls" : "other";
+	}
 }
-
-// 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()
+//#endregion
+//#region src/perplexity-agent-api.ts
+const perplexitySearchResultSchema = z.looseObject({
+	id: z.number().optional(),
+	title: z.string(),
+	url: z.string(),
+	snippet: z.string().optional(),
+	date: z.string().nullish(),
+	last_updated: z.string().nullish(),
+	source: z.string().optional()
 });
-var perplexityFetchedContentSchema = z2.looseObject({
-  title: z2.string(),
-  url: z2.string(),
-  snippet: z2.string().optional()
+const perplexityFetchedContentSchema = z.looseObject({
+	title: z.string(),
+	url: z.string(),
+	snippet: z.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()
+const perplexityContentPartSchema = z.looseObject({
+	type: z.string(),
+	text: z.string().optional(),
+	annotations: z.array(z.looseObject({
+		type: z.string().optional(),
+		url: z.string().optional(),
+		title: z.string().optional()
+	})).nullish()
 });
-var handledOutputTypes = [
-  "message",
-  "search_results",
-  "fetch_url_results",
-  "function_call"
+const 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" }))
+const perplexityOutputItemSchema = z.union([
+	z.looseObject({
+		type: z.literal("message"),
+		id: z.string().nullish(),
+		content: z.array(perplexityContentPartSchema).nullish()
+	}),
+	z.looseObject({
+		type: z.literal("search_results"),
+		results: z.array(perplexitySearchResultSchema).nullish()
+	}),
+	z.looseObject({
+		type: z.literal("fetch_url_results"),
+		contents: z.array(perplexityFetchedContentSchema).nullish()
+	}),
+	z.looseObject({
+		type: z.literal("function_call"),
+		id: z.string().nullish(),
+		call_id: z.string().nullish(),
+		name: z.string().nullish(),
+		arguments: z.string().nullish(),
+		thought_signature: z.string().nullish()
+	}),
+	z.object({ type: z.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()
+const perplexityCostSchema = z.looseObject({
+	currency: z.string().optional(),
+	input_cost: z.number().optional(),
+	output_cost: z.number().optional(),
+	total_cost: z.number().optional(),
+	cache_creation_cost: z.number().nullish(),
+	cache_read_cost: z.number().nullish(),
+	tool_calls_cost: z.number().nullish()
 });
-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()
+const perplexityUsageSchema = z.looseObject({
+	input_tokens: z.number(),
+	output_tokens: z.number(),
+	total_tokens: z.number(),
+	input_tokens_details: z.looseObject({
+		cached_tokens: z.number().optional(),
+		cache_creation_input_tokens: z.number().optional(),
+		cache_read_input_tokens: z.number().optional()
+	}).nullish(),
+	output_tokens_details: z.looseObject({ reasoning_tokens: z.number().optional() }).nullish(),
+	tool_calls_details: z.record(z.string(), z.looseObject({ invocation: z.number().optional() })).nullish(),
+	cost: perplexityCostSchema.nullish()
 });
-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()
+const perplexityAgentResponseSchema = z.looseObject({
+	id: z.string(),
+	created_at: z.number(),
+	model: z.string(),
+	object: z.literal("response"),
+	output: z.array(perplexityOutputItemSchema),
+	status: z.string(),
+	incomplete_details: z.looseObject({ reason: z.string() }).nullish(),
+	error: z.looseObject({
+		code: z.string().optional(),
+		message: z.string(),
+		type: z.string().optional()
+	}).nullish(),
+	usage: perplexityUsageSchema.nullish()
 });
-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()
+const perplexityAgentChunkSchema = z.looseObject({
+	type: z.string(),
+	sequence_number: z.number().nullish(),
+	response: perplexityAgentResponseSchema.nullish(),
+	item: perplexityOutputItemSchema.nullish(),
+	output_index: z.number().nullish(),
+	item_id: z.string().nullish(),
+	content_index: z.number().nullish(),
+	delta: z.string().nullish(),
+	text: z.string().nullish(),
+	thought: z.string().nullish(),
+	queries: z.array(z.string()).nullish(),
+	urls: z.array(z.string()).nullish(),
+	results: z.array(perplexitySearchResultSchema).nullish(),
+	contents: z.array(perplexityFetchedContentSchema).nullish(),
+	error: z.looseObject({
+		code: z.string().nullish(),
+		message: z.string(),
+		type: z.string().nullish()
+	}).nullish()
 });
-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()
+const perplexityErrorSchema = z.looseObject({
+	error: z.union([z.string(), z.looseObject({
+		code: z.union([z.string(), z.number()]).optional(),
+		message: z.string().nullish(),
+		type: z.string().nullish()
+	})]).optional(),
+	detail: z.union([z.string(), z.array(z.looseObject({ msg: z.string() }))]).optional(),
+	message: z.string().optional()
 });
 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";
+	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()
+//#endregion
+//#region src/perplexity-language-model-options.ts
+const userLocationSchema = z.looseObject({
+	latitude: z.number().optional(),
+	longitude: z.number().optional(),
+	country: z.string().optional(),
+	city: z.string().optional(),
+	region: z.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()
+const webSearchFiltersSchema = z.looseObject({
+	search_domain_filter: z.array(z.string()).optional(),
+	search_recency_filter: z.enum([
+		"hour",
+		"day",
+		"week",
+		"month",
+		"year"
+	]).optional(),
+	search_after_date_filter: z.string().optional(),
+	search_before_date_filter: z.string().optional(),
+	last_updated_after_filter: z.string().optional(),
+	last_updated_before_filter: z.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()
+const webSearchToolSchema = z.looseObject({
+	type: z.literal("web_search"),
+	filters: webSearchFiltersSchema.optional(),
+	max_results: z.number().int().positive().optional(),
+	max_tokens: z.number().optional(),
+	max_tokens_per_page: z.number().optional(),
+	search_context_size: z.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()
-  })
+const nativeToolSchema = z.union([
+	webSearchToolSchema,
+	z.looseObject({
+		type: z.literal("fetch_url"),
+		max_urls: z.number().optional()
+	}),
+	z.looseObject({ type: z.literal("people_search") }),
+	z.looseObject({ type: z.literal("finance_search") }),
+	z.looseObject({ type: z.literal("sandbox") }),
+	z.looseObject({
+		type: z.literal("mcp"),
+		server_label: z.string(),
+		server_url: z.string(),
+		allowed_tools: z.array(z.string()).optional(),
+		authorization: z.string().optional(),
+		defer_loading: z.boolean().optional(),
+		headers: z.record(z.string(), z.string()).optional()
+	}),
+	z.looseObject({
+		type: z.literal("connector"),
+		id: z.string(),
+		server_label: z.string(),
+		server_description: z.string().optional(),
+		allowed_tools: z.array(z.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()
+const perplexityLanguageModelOptions = z.looseObject({
+	/** Top-level Agent API instructions. */
+	instructions: z.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: z.array(nativeToolSchema).optional(),
+	/** A fallback model list for Agent API routing. */
+	models: z.array(z.string()).optional(),
+	/** Maximum number of agentic steps. */
+	max_steps: z.number().int().positive().optional(),
+	/** Maximum number of native tool calls. */
+	max_tool_calls: z.number().int().nonnegative().optional(),
+	/** Continue a conversation from an earlier Agent API response. */
+	previous_response_id: z.string().optional(),
+	/**
+	* Whether the response can be retrieved later. Setting this to false does
+	* not disable persistence or prevent previous_response_id continuations.
+	*/
+	store: z.boolean().optional(),
+	/** Preferred response language as an ISO 639-1 language code. */
+	language_preference: z.string().optional(),
+	/** Agent API reasoning configuration. */
+	reasoning: z.looseObject({ effort: z.enum([
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	]).optional() }).optional(),
+	/** Agent API skill configuration. */
+	skills: z.array(z.union([z.looseObject({
+		type: z.literal("builtin"),
+		name: z.enum([
+			"office",
+			"office/docx",
+			"office/pdf",
+			"office/pptx",
+			"office/xlsx"
+		])
+	}), z.looseObject({
+		type: z.literal("inline"),
+		name: z.string(),
+		description: z.string(),
+		instructions: z.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 };
+//#endregion
+//#region 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"
+//#endregion
+//#region src/perplexity-language-model.ts
+const presetIds = /* @__PURE__ */ new Set([
+	"fast",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
 ]);
 function getModelSelection(modelId) {
-  if (presetIds.has(modelId)) {
-    return { preset: modelId };
-  }
-  return { model: 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
-  });
+	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 }
-          ]
-        )
-      )
-    }
-  };
+	const cost = usage?.cost;
+	return { perplexity: {
+		usage: {
+			citationTokens: null,
+			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
+		},
+		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 createSource(result, generateId) {
+	return {
+		type: "source",
+		sourceType: "url",
+		id: result.id == null ? generateId() : 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";
+	return typeof source.providerMetadata?.perplexity?.resultId === "number";
 }
 function getSearchResults(item) {
-  return item.type === "search_results" ? item.results ?? [] : [];
+	return item.type === "search_results" ? item.results ?? [] : [];
 }
 function getFetchedSources(item) {
-  return item.type === "fetch_url_results" ? item.contents ?? [] : [];
+	return item.type === "fetch_url_results" ? item.contents ?? [] : [];
 }
-var PerplexityLanguageModel = class _PerplexityLanguageModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    this.provider = "perplexity";
-    this.supportedUrls = {
-      "image/*": [/^https?:\/\/.*$/]
-    };
-    this.modelId = modelId;
-    this.config = config;
-  }
-  static [WORKFLOW_SERIALIZE](model) {
-    return serializeModelOptions({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE](options) {
-    return new _PerplexityLanguageModel(options.modelId, options.config);
-  }
-  async getArgs({
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    topK,
-    frequencyPenalty,
-    presencePenalty,
-    stopSequences,
-    reasoning,
-    responseFormat,
-    seed,
-    providerOptions,
-    tools,
-    toolChoice
-  }) {
-    const warnings = [];
-    const perplexityOptions = await parseProviderOptions({
-      provider: "perplexity",
-      providerOptions,
-      schema: perplexityLanguageModelOptions
-    }) ?? {};
-    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" });
-    }
-    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: "JSON response format without a schema"
-      });
-    }
-    return { args: body, warnings };
-  }
-  async doGenerate(options) {
-    const { args: body, warnings } = await this.getArgs(options);
-    const url = `${this.config.baseURL}/v1/agent`;
-    const {
-      responseHeaders,
-      value: response,
-      rawValue: rawResponse
-    } = await postJsonToApi({
-      url,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body,
-      failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: perplexityErrorSchema,
-        errorToMessage: perplexityErrorToMessage
-      }),
-      successfulResponseHandler: createJsonResponseHandler(
-        perplexityAgentResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    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
-      });
-    }
-    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: "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({
-          status: response.status,
-          incompleteReason: response.incomplete_details?.reason,
-          hasFunctionCall
-        }),
-        raw: finishReason
-      },
-      usage: convertPerplexityUsage(response.usage),
-      request: { body },
-      response: {
-        ...getResponseMetadata(response),
-        headers: responseHeaders,
-        body: rawResponse
-      },
-      warnings,
-      providerMetadata: getProviderMetadata(response.usage)
-    };
-  }
-  async doStream(options) {
-    const { args, warnings } = await this.getArgs(options);
-    const body = { ...args, stream: true };
-    const { responseHeaders, value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/v1/agent`,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body,
-      failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: perplexityErrorSchema,
-        errorToMessage: perplexityErrorToMessage
-      }),
-      successfulResponseHandler: createEventSourceResponseHandler(
-        perplexityAgentChunkSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    let finishReason = {
-      unified: "other",
-      raw: void 0
-    };
-    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({
-          start(controller) {
-            controller.enqueue({ type: "stream-start", warnings });
-          },
-          transform(chunk, controller) {
-            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;
-            const getTextId = (itemId, outputIndex, contentIndex = 0) => {
-              const id = itemId ?? String(outputIndex ?? "text");
-              return contentIndex == null || 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: "tool-input-start",
-                id: item.call_id,
-                toolName: item.name
-              });
-              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: generateId2(),
-                  url: result.url,
-                  title: result.title,
-                  providerMetadata: {
-                    perplexity: { snippet: result.snippet ?? null }
-                  }
-                });
-              }
-            };
-            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;
-              }
-            }
-          },
-          flush(controller) {
-            for (const source of pendingSourcesByUrl.values()) {
-              controller.enqueue(source);
-            }
-            if (activeReasoningId != null) {
-              controller.enqueue({
-                type: "reasoning-end",
-                id: activeReasoningId
-              });
-            }
-            for (const [id, state] of textStates) {
-              if (!state.ended) {
-                controller.enqueue({ type: "text-end", id });
-              }
-            }
-            controller.enqueue({
-              type: "finish",
-              finishReason,
-              usage: convertPerplexityUsage(usage),
-              providerMetadata: getProviderMetadata(usage)
-            });
-          }
-        })
-      ),
-      request: { body },
-      response: { headers: responseHeaders }
-    };
-  }
+var PerplexityLanguageModel = class PerplexityLanguageModel {
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new PerplexityLanguageModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.provider = "perplexity";
+		this.supportedUrls = { "image/*": [/^https?:\/\/.*$/] };
+		this.modelId = modelId;
+		this.config = config;
+	}
+	async getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, stopSequences, reasoning, responseFormat, seed, providerOptions, tools, toolChoice }) {
+		const warnings = [];
+		const perplexityOptions = await parseProviderOptions({
+			provider: "perplexity",
+			providerOptions,
+			schema: perplexityLanguageModelOptions
+		}) ?? {};
+		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"
+		});
+		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: "JSON response format without a schema"
+		});
+		return {
+			args: body,
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		const { args: body, warnings } = await this.getArgs(options);
+		const url = `${this.config.baseURL}/v1/agent`;
+		const { responseHeaders, value: response, rawValue: rawResponse } = await postJsonToApi({
+			url,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body,
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: perplexityErrorSchema,
+				errorToMessage: perplexityErrorToMessage
+			}),
+			successfulResponseHandler: createJsonResponseHandler(perplexityAgentResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		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
+		});
+		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: "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({
+					status: response.status,
+					incompleteReason: response.incomplete_details?.reason,
+					hasFunctionCall
+				}),
+				raw: finishReason
+			},
+			usage: convertPerplexityUsage(response.usage),
+			request: { body },
+			response: {
+				...getResponseMetadata(response),
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			warnings,
+			providerMetadata: getProviderMetadata(response.usage)
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = await this.getArgs(options);
+		const body = {
+			...args,
+			stream: true
+		};
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: `${this.config.baseURL}/v1/agent`,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body,
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: perplexityErrorSchema,
+				errorToMessage: perplexityErrorToMessage
+			}),
+			successfulResponseHandler: createEventSourceResponseHandler(perplexityAgentChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		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 generateId = this.config.generateId;
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					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;
+					const getTextId = (itemId, outputIndex, contentIndex = 0) => {
+						const id = itemId ?? String(outputIndex ?? "text");
+						return contentIndex == null || 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: "tool-input-start",
+							id: item.call_id,
+							toolName: item.name
+						});
+						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: generateId(),
+								url: annotation.url,
+								title: annotation.title
+							});
+						}
+						for (const result of getSearchResults(item)) emitSource(createSource(result, generateId));
+						for (const result of getFetchedSources(item)) emitSource({
+							type: "source",
+							sourceType: "url",
+							id: generateId(),
+							url: result.url,
+							title: result.title,
+							providerMetadata: { perplexity: { snippet: result.snippet ?? null } }
+						});
+					};
+					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 ?? generateId()}`;
+							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, generateId));
+							break;
+						case "response.reasoning.fetch_url_results":
+							emitReasoningThought(value.thought);
+							for (const result of value.contents ?? []) emitSource({
+								type: "source",
+								sourceType: "url",
+								id: generateId(),
+								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 ?? /* @__PURE__ */ new Error("Perplexity response failed")
+							});
+					}
+				},
+				flush(controller) {
+					for (const source of pendingSourcesByUrl.values()) controller.enqueue(source);
+					if (activeReasoningId != null) controller.enqueue({
+						type: "reasoning-end",
+						id: activeReasoningId
+					});
+					for (const [id, state] of textStates) if (!state.ended) controller.enqueue({
+						type: "text-end",
+						id
+					});
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage: convertPerplexityUsage(usage),
+						providerMetadata: getProviderMetadata(usage)
+					});
+				}
+			})),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
 };
-
-// src/perplexity-embedding-model.ts
-var PerplexityEmbeddingModel = class _PerplexityEmbeddingModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    // https://docs.perplexity.ai/docs/embeddings/standard-embeddings
-    this.maxEmbeddingsPerCall = 512;
-    this.supportsParallelCalls = true;
-    this.modelId = modelId;
-    this.config = config;
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  static [WORKFLOW_SERIALIZE2](model) {
-    return serializeModelOptions2({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE2](options) {
-    return new _PerplexityEmbeddingModel(options.modelId, options.config);
-  }
-  async doEmbed({
-    values,
-    abortSignal,
-    headers,
-    providerOptions
-  }) {
-    if (values.length > this.maxEmbeddingsPerCall) {
-      throw new TooManyEmbeddingValuesForCallError({
-        provider: this.provider,
-        modelId: this.modelId,
-        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
-        values
-      });
-    }
-    const perplexityOptions = await parseProviderOptions2({
-      provider: "perplexity",
-      providerOptions,
-      schema: perplexityEmbeddingModelOptions
-    }) ?? {};
-    const encodingFormat = perplexityOptions.encodingFormat ?? "base64_int8";
-    const {
-      responseHeaders,
-      value: response,
-      rawValue
-    } = await postJsonToApi2({
-      url: `${this.config.baseURL}/v1/embeddings`,
-      headers: combineHeaders2(this.config.headers(), headers),
-      body: {
-        model: this.modelId,
-        input: values,
-        dimensions: perplexityOptions.dimensions,
-        encoding_format: encodingFormat
-      },
-      failedResponseHandler: createJsonErrorResponseHandler2({
-        errorSchema: perplexityErrorSchema,
-        errorToMessage: perplexityErrorToMessage
-      }),
-      successfulResponseHandler: createJsonResponseHandler2(
-        perplexityEmbeddingResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
-    });
-    const cost = response.usage?.cost;
-    return {
-      embeddings: response.data.map(
-        (item) => decodeEmbedding(item.embedding, encodingFormat)
-      ),
-      usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
-      providerMetadata: cost ? {
-        perplexity: {
-          cost: {
-            inputCost: cost.input_cost ?? null,
-            totalCost: cost.total_cost ?? null,
-            currency: cost.currency ?? null
-          }
-        }
-      } : void 0,
-      response: { headers: responseHeaders, body: rawValue },
-      warnings: []
-    };
-  }
+//#endregion
+//#region src/perplexity-embedding-model.ts
+var PerplexityEmbeddingModel = class PerplexityEmbeddingModel {
+	get provider() {
+		return this.config.provider;
+	}
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new PerplexityEmbeddingModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.maxEmbeddingsPerCall = 512;
+		this.supportsParallelCalls = true;
+		this.modelId = modelId;
+		this.config = config;
+	}
+	async doEmbed({ values, abortSignal, headers, providerOptions }) {
+		if (values.length > this.maxEmbeddingsPerCall) throw new TooManyEmbeddingValuesForCallError({
+			provider: this.provider,
+			modelId: this.modelId,
+			maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+			values
+		});
+		const perplexityOptions = await parseProviderOptions({
+			provider: "perplexity",
+			providerOptions,
+			schema: perplexityEmbeddingModelOptions
+		}) ?? {};
+		const encodingFormat = perplexityOptions.encodingFormat ?? "base64_int8";
+		const { responseHeaders, value: response, rawValue } = await postJsonToApi({
+			url: `${this.config.baseURL}/v1/embeddings`,
+			headers: combineHeaders(this.config.headers(), headers),
+			body: {
+				model: this.modelId,
+				input: values,
+				dimensions: perplexityOptions.dimensions,
+				encoding_format: encodingFormat
+			},
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: perplexityErrorSchema,
+				errorToMessage: perplexityErrorToMessage
+			}),
+			successfulResponseHandler: createJsonResponseHandler(perplexityEmbeddingResponseSchema),
+			abortSignal,
+			fetch: this.config.fetch
+		});
+		const cost = response.usage?.cost;
+		return {
+			embeddings: response.data.map((item) => decodeEmbedding(item.embedding, encodingFormat)),
+			usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
+			providerMetadata: cost ? { perplexity: { cost: {
+				inputCost: cost.input_cost ?? null,
+				totalCost: cost.total_cost ?? null,
+				currency: cost.currency ?? null
+			} } } : void 0,
+			response: {
+				headers: responseHeaders,
+				body: rawValue
+			},
+			warnings: []
+		};
+	}
 };
+/**
+* Decodes a base64-encoded Perplexity embedding into a numeric vector.
+* For `base64_int8` the bytes are reinterpreted as signed int8 values;
+* for `base64_binary` the raw unsigned bytes (packed bits) are returned.
+*/
 function decodeEmbedding(base64, encodingFormat) {
-  const bytes = convertBase64ToUint8Array(base64);
-  if (encodingFormat === "base64_int8") {
-    const int8 = new Int8Array(
-      bytes.buffer,
-      bytes.byteOffset,
-      bytes.byteLength
-    );
-    return Array.from(int8);
-  }
-  return Array.from(bytes);
+	const bytes = convertBase64ToUint8Array(base64);
+	if (encodingFormat === "base64_int8") {
+		const int8 = new Int8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+		return Array.from(int8);
+	}
+	return Array.from(bytes);
 }
-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()
+const perplexityEmbeddingResponseSchema = z.object({
+	data: z.array(z.object({ embedding: z.string() })),
+	usage: z.object({
+		prompt_tokens: z.number(),
+		cost: z.object({
+			input_cost: z.number().nullish(),
+			total_cost: z.number().nullish(),
+			currency: z.string().nullish()
+		}).nullish()
+	}).nullish()
 });
-
-// src/version.ts
-var VERSION = true ? "5.0.2" : "0.0.0-test";
-
-// src/perplexity-provider.ts
+//#endregion
+//#region src/version.ts
+const VERSION = "5.0.4";
+//#endregion
+//#region src/perplexity-provider.ts
 function createPerplexity(options = {}) {
-  const getHeaders = () => withUserAgentSuffix(
-    {
-      Authorization: `Bearer ${loadApiKey({
-        apiKey: options.apiKey,
-        environmentVariableName: "PERPLEXITY_API_KEY",
-        description: "Perplexity"
-      })}`,
-      ...options.headers
-    },
-    `ai-sdk/perplexity/${VERSION}`
-  );
-  const baseURL = withoutTrailingSlash(
-    options.baseURL ?? "https://api.perplexity.ai"
-  );
-  const createLanguageModel = (modelId) => {
-    return new PerplexityLanguageModel(modelId, {
-      baseURL,
-      headers: getHeaders,
-      generateId,
-      fetch: options.fetch
-    });
-  };
-  const createEmbeddingModel = (modelId) => new PerplexityEmbeddingModel(modelId, {
-    provider: "perplexity.embedding",
-    baseURL,
-    headers: getHeaders,
-    fetch: options.fetch
-  });
-  const provider = (modelId) => createLanguageModel(modelId);
-  provider.specificationVersion = "v4";
-  provider.languageModel = createLanguageModel;
-  provider.embedding = createEmbeddingModel;
-  provider.embeddingModel = createEmbeddingModel;
-  provider.textEmbeddingModel = createEmbeddingModel;
-  provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
-  };
-  return provider;
+	const getHeaders = () => withUserAgentSuffix({
+		Authorization: `Bearer ${loadApiKey({
+			apiKey: options.apiKey,
+			environmentVariableName: "PERPLEXITY_API_KEY",
+			description: "Perplexity"
+		})}`,
+		"X-Pplx-Integration": "vercel-ai-sdk",
+		...options.headers
+	}, `ai-sdk-perplexity/${VERSION}`);
+	const baseURL = withoutTrailingSlash(options.baseURL ?? "https://api.perplexity.ai");
+	const createLanguageModel = (modelId) => {
+		return new PerplexityLanguageModel(modelId, {
+			baseURL,
+			headers: getHeaders,
+			generateId,
+			fetch: options.fetch
+		});
+	};
+	const createEmbeddingModel = (modelId) => new PerplexityEmbeddingModel(modelId, {
+		provider: "perplexity.embedding",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const provider = (modelId) => createLanguageModel(modelId);
+	provider.specificationVersion = "v4";
+	provider.languageModel = createLanguageModel;
+	provider.embedding = createEmbeddingModel;
+	provider.embeddingModel = createEmbeddingModel;
+	provider.textEmbeddingModel = createEmbeddingModel;
+	provider.imageModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "imageModel"
+		});
+	};
+	return provider;
 }
-var perplexity = createPerplexity();
-export {
-  VERSION,
-  createPerplexity,
-  perplexity
-};
+const perplexity = createPerplexity();
+//#endregion
+export { VERSION, createPerplexity, perplexity };
+
 //# sourceMappingURL=index.js.map