@ai-sdk/perplexity 2.1.0-beta.8 → 2.1.0

package/dist/index.mjs

@@ -10,67 +10,180 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/perplexity-language-model.ts
+import {
+  APICallError
+} from "@ai-sdk/provider";
 import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
+  parseProviderOptions,
   postJsonToApi
 } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
 
-// src/convert-to-perplexity-messages.ts
+// src/convert-perplexity-usage.ts
+function convertPerplexityUsage(usage) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (usage == null) {
+    return {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
+    };
+  }
+  const inputTokens = (_a = usage.input_tokens) != null ? _a : void 0;
+  const outputTokens = (_b = usage.output_tokens) != null ? _b : void 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: (_c = usage.total_tokens) != null ? _c : inputTokens != null && outputTokens != null ? inputTokens + outputTokens : void 0,
+    reasoningTokens: (_e = (_d = usage.output_tokens_details) == null ? void 0 : _d.reasoning_tokens) != null ? _e : void 0,
+    cachedInputTokens: (_i = (_h = (_f = usage.input_tokens_details) == null ? void 0 : _f.cache_read_input_tokens) != null ? _h : (_g = usage.input_tokens_details) == null ? void 0 : _g.cached_tokens) != null ? _i : void 0
+  };
+}
+
+// src/convert-to-perplexity-input.ts
 import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
 import { convertUint8ArrayToBase64 } 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 "content": {
+      if (output.value.some((part) => part.type !== "text")) {
+        throw new UnsupportedFunctionalityError({
+          functionality: "file and custom tool result content"
+        });
+      }
+      return output.value.map((part) => part.type === "text" ? part.text : "").join("");
+    }
+    default: {
+      const _exhaustiveCheck = output;
+      throw new Error(`Unsupported tool output: ${_exhaustiveCheck}`);
+    }
+  }
+}
+function getTopLevelMediaType(mediaType) {
+  const slashIndex = mediaType.indexOf("/");
+  return slashIndex === -1 ? mediaType : mediaType.substring(0, slashIndex);
+}
+function getThoughtSignature(providerOptions) {
+  var _a;
+  const thoughtSignature = (_a = providerOptions == null ? void 0 : providerOptions.perplexity) == null ? void 0 : _a.thoughtSignature;
+  return typeof thoughtSignature === "string" ? thoughtSignature : void 0;
+}
+function convertToPerplexityInput(prompt) {
+  var _a;
+  const input = [];
+  const warnings = [];
   for (const { role, content } of prompt) {
     switch (role) {
       case "system": {
-        messages.push({ role: "system", content });
+        input.push({ type: "message", role: "system", content });
         break;
       }
-      case "user":
-      case "assistant": {
-        const hasImage = content.some(
-          (part) => part.type === "file" && part.mediaType.startsWith("image/")
-        );
-        const messageContent = content.map((part) => {
-          var _a;
-          switch (part.type) {
-            case "text": {
-              return {
-                type: "text",
-                text: part.text
-              };
-            }
-            case "file": {
-              return part.data instanceof URL ? {
-                type: "image_url",
-                image_url: {
-                  url: part.data.toString()
+      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}`
+                  });
                 }
-              } : {
-                type: "image_url",
-                image_url: {
-                  url: `data:${(_a = part.mediaType) != null ? _a : "image/jpeg"};base64,${typeof part.data === "string" ? part.data : convertUint8ArrayToBase64(part.data)}`
+                if (part.data instanceof URL) {
+                  return {
+                    type: "input_image",
+                    image_url: part.data.toString()
+                  };
                 }
-              };
+                const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                return {
+                  type: "input_image",
+                  image_url: `data:${mediaType};base64,${typeof part.data === "string" ? part.data : convertUint8ArrayToBase64(part.data)}`
+                };
+              }
             }
           }
-        }).filter(Boolean);
-        messages.push({
-          role,
-          content: hasImage ? 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((_a = part.input) != null ? _a : {}),
+                thought_signature: getThoughtSignature(part.providerOptions)
+              });
+              break;
+            case "tool-result":
+              input.push({
+                type: "function_call_output",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                output: serializeToolOutput(part.output),
+                thought_signature: getThoughtSignature(part.providerOptions)
+              });
+              break;
+            case "reasoning":
+              warnings.push({
+                type: "other",
+                message: "reasoning content in prompt is not supported"
+              });
+              break;
+            case "file":
+              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) {
+          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;
@@ -78,32 +191,434 @@ 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 "unknown";
+      return hasFunctionCall ? "tool-calls" : "other";
+  }
+}
+
+// src/perplexity-agent-api.ts
+import { z } from "zod/v4";
+var 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 = z.looseObject({
+  title: z.string(),
+  url: z.string(),
+  snippet: z.string().optional()
+});
+var 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"
+];
+var perplexityOutputItemSchema = z.union([
+  z.looseObject({
+    type: z.literal("message"),
+    id: z.string().nullish(),
+    content: z.array(perplexityContentPartSchema).nullish()
+  }),
+  z.looseObject({
+    type: z.literal("search_results"),
+    results: z.array(perplexitySearchResultSchema).nullish()
+  }),
+  z.looseObject({
+    type: z.literal("fetch_url_results"),
+    contents: z.array(perplexityFetchedContentSchema).nullish()
+  }),
+  z.looseObject({
+    type: z.literal("function_call"),
+    id: z.string().nullish(),
+    call_id: z.string().nullish(),
+    name: z.string().nullish(),
+    arguments: z.string().nullish(),
+    thought_signature: z.string().nullish()
+  }),
+  // Native tool traces remain available in raw responses and raw stream chunks.
+  // Their fields (e.g. finance_results.results) have different shapes. Do not
+  // validate them as search results, or let malformed handled items fall back.
+  z.object({
+    type: z.string().refine((type) => !handledOutputTypes.includes(type))
+  }).transform(() => ({ type: "unhandled" }))
+]);
+var 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 = 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 = 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 = 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 = 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) {
+  var _a, _b, _c;
+  if (typeof data.error === "string") {
+    return data.error;
+  }
+  if (data.error != null) {
+    return (_b = (_a = data.error.message) != null ? _a : data.error.type) != null ? _b : "unknown error";
+  }
+  if (typeof data.detail === "string") {
+    return data.detail;
+  }
+  if (Array.isArray(data.detail)) {
+    return data.detail.map((detail) => detail.msg).join(", ");
   }
+  return (_c = data.message) != null ? _c : "unknown error";
+}
+
+// src/perplexity-language-model-options.ts
+import { z as z2 } from "zod/v4";
+var userLocationSchema = z2.looseObject({
+  latitude: z2.number().optional(),
+  longitude: z2.number().optional(),
+  country: z2.string().optional(),
+  city: z2.string().optional(),
+  region: z2.string().optional()
+});
+var webSearchFiltersSchema = z2.looseObject({
+  search_domain_filter: z2.array(z2.string()).optional(),
+  search_recency_filter: z2.enum(["hour", "day", "week", "month", "year"]).optional(),
+  search_after_date_filter: z2.string().optional(),
+  search_before_date_filter: z2.string().optional(),
+  last_updated_after_filter: z2.string().optional(),
+  last_updated_before_filter: z2.string().optional()
+});
+var webSearchToolSchema = z2.looseObject({
+  type: z2.literal("web_search"),
+  filters: webSearchFiltersSchema.optional(),
+  max_results: z2.number().int().positive().optional(),
+  max_tokens: z2.number().optional(),
+  max_tokens_per_page: z2.number().optional(),
+  search_context_size: z2.enum(["low", "medium", "high"]).optional(),
+  user_location: userLocationSchema.optional()
+});
+var nativeToolSchema = z2.union([
+  webSearchToolSchema,
+  z2.looseObject({
+    type: z2.literal("fetch_url"),
+    max_urls: z2.number().optional()
+  }),
+  z2.looseObject({ type: z2.literal("people_search") }),
+  z2.looseObject({ type: z2.literal("finance_search") }),
+  z2.looseObject({ type: z2.literal("sandbox") }),
+  z2.looseObject({
+    type: z2.literal("mcp"),
+    server_label: z2.string(),
+    server_url: z2.string(),
+    allowed_tools: z2.array(z2.string()).optional(),
+    authorization: z2.string().optional(),
+    defer_loading: z2.boolean().optional(),
+    headers: z2.record(z2.string(), z2.string()).optional()
+  }),
+  z2.looseObject({
+    type: z2.literal("connector"),
+    id: z2.string(),
+    server_label: z2.string(),
+    server_description: z2.string().optional(),
+    allowed_tools: z2.array(z2.string()).optional()
+  })
+]);
+var perplexityLanguageModelOptions = z2.looseObject({
+  /** Top-level Agent API instructions. */
+  instructions: z2.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: z2.array(nativeToolSchema).optional(),
+  /** A fallback model list for Agent API routing. */
+  models: z2.array(z2.string()).optional(),
+  /** Maximum number of agentic steps. */
+  max_steps: z2.number().int().positive().optional(),
+  /** Maximum number of native tool calls. */
+  max_tool_calls: z2.number().int().nonnegative().optional(),
+  /** Continue a conversation from an earlier Agent API response. */
+  previous_response_id: z2.string().optional(),
+  /**
+   * Whether the response can be retrieved later. Setting this to false does
+   * not disable persistence or prevent previous_response_id continuations.
+   */
+  store: z2.boolean().optional(),
+  /** Preferred response language as an ISO 639-1 language code. */
+  language_preference: z2.string().optional(),
+  /** Agent API reasoning configuration. */
+  reasoning: z2.looseObject({
+    effort: z2.enum(["minimal", "low", "medium", "high", "xhigh"]).optional()
+  }).optional(),
+  /** Agent API skill configuration. */
+  skills: z2.array(
+    z2.union([
+      z2.looseObject({
+        type: z2.literal("builtin"),
+        name: z2.enum([
+          "office",
+          "office/docx",
+          "office/pdf",
+          "office/pptx",
+          "office/xlsx"
+        ])
+      }),
+      z2.looseObject({
+        type: z2.literal("inline"),
+        name: z2.string(),
+        description: z2.string(),
+        instructions: z2.string()
+      })
+    ])
+  ).optional()
+});
+
+// src/perplexity-prepare-tools.ts
+function preparePerplexityTools({
+  tools,
+  toolChoice
+}) {
+  const preparedTools = [];
+  const warnings = [];
+  for (const tool of tools != null ? tools : []) {
+    if (tool.type === "provider-defined") {
+      warnings.push({ type: "unsupported-tool", tool });
+      continue;
+    }
+    preparedTools.push({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    });
+  }
+  if (toolChoice != null && toolChoice.type !== "auto") {
+    warnings.push({
+      type: "unsupported-setting",
+      setting: "toolChoice",
+      details: "The Perplexity Agent API currently selects tools automatically."
+    });
+  }
+  return { tools: preparedTools, warnings };
 }
 
 // src/perplexity-language-model.ts
+var presetIds = /* @__PURE__ */ new Set([
+  "fast",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+]);
+function getModelSelection(modelId) {
+  if (presetIds.has(modelId)) {
+    return { preset: modelId };
+  }
+  return { model: modelId };
+}
+function getResponseMetadata(response) {
+  var _a, _b;
+  return {
+    id: (_a = response.id) != null ? _a : void 0,
+    modelId: (_b = response.model) != null ? _b : void 0,
+    timestamp: response.created_at != null ? new Date(response.created_at * 1e3) : void 0
+  };
+}
+function getProviderMetadata(usage) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const cost = usage == null ? void 0 : usage.cost;
+  const numSearchQueries = (usage == null ? void 0 : usage.tool_calls_details) ? Object.entries(usage.tool_calls_details).filter(([name]) => name.includes("search")).reduce((total, [, details]) => {
+    var _a2;
+    return total + ((_a2 = details.invocation) != null ? _a2 : 0);
+  }, 0) : null;
+  return {
+    perplexity: {
+      usage: {
+        citationTokens: null,
+        numSearchQueries
+      },
+      images: null,
+      cost: cost == null ? null : {
+        inputTokensCost: (_a = cost.input_cost) != null ? _a : null,
+        outputTokensCost: (_b = cost.output_cost) != null ? _b : null,
+        requestCost: null,
+        totalCost: (_c = cost.total_cost) != null ? _c : null,
+        currency: (_d = cost.currency) != null ? _d : null,
+        cacheCreationCost: (_e = cost.cache_creation_cost) != null ? _e : null,
+        cacheReadCost: (_f = cost.cache_read_cost) != null ? _f : null,
+        toolCallsCost: (_g = cost.tool_calls_cost) != null ? _g : null
+      },
+      toolCalls: (usage == null ? void 0 : usage.tool_calls_details) == null ? null : Object.fromEntries(
+        Object.entries(usage.tool_calls_details).map(
+          ([name, details]) => {
+            var _a2;
+            return [
+              name,
+              { invocation: (_a2 = details.invocation) != null ? _a2 : null }
+            ];
+          }
+        )
+      )
+    }
+  };
+}
+function createSource(result, generateId2) {
+  var _a, _b, _c, _d, _e;
+  return {
+    type: "source",
+    sourceType: "url",
+    id: result.id == null ? generateId2() : String(result.id),
+    url: result.url,
+    title: result.title,
+    providerMetadata: {
+      perplexity: {
+        resultId: (_a = result.id) != null ? _a : null,
+        snippet: (_b = result.snippet) != null ? _b : null,
+        date: (_c = result.date) != null ? _c : null,
+        lastUpdated: (_d = result.last_updated) != null ? _d : null,
+        source: (_e = result.source) != null ? _e : null
+      }
+    }
+  };
+}
+function hasSearchResultId(source) {
+  var _a, _b;
+  return typeof ((_b = (_a = source.providerMetadata) == null ? void 0 : _a.perplexity) == null ? void 0 : _b.resultId) === "number";
+}
+function getSearchResults(item) {
+  var _a;
+  return item.type === "search_results" ? (_a = item.results) != null ? _a : [] : [];
+}
+function getFetchedSources(item) {
+  var _a;
+  return item.type === "fetch_url_results" ? (_a = item.contents) != null ? _a : [] : [];
+}
 var PerplexityLanguageModel = class {
   constructor(modelId, config) {
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v2";
     this.provider = "perplexity";
     this.supportedUrls = {
-      // No URLs are supported.
+      "image/*": [/^https?:\/\/.*$/]
     };
     this.modelId = modelId;
     this.config = config;
   }
-  getArgs({
+  async getArgs({
     prompt,
     maxOutputTokens,
     temperature,
@@ -114,97 +629,181 @@ var PerplexityLanguageModel = class {
     stopSequences,
     responseFormat,
     seed,
-    providerOptions
+    providerOptions,
+    tools,
+    toolChoice
   }) {
-    var _a;
+    var _a, _b;
     const warnings = [];
+    const perplexityOptions = (_a = await parseProviderOptions({
+      provider: "perplexity",
+      providerOptions,
+      schema: perplexityLanguageModelOptions
+    })) != null ? _a : {};
     if (topK != null) {
+      warnings.push({ type: "unsupported-setting", setting: "topK" });
+    }
+    if (frequencyPenalty != null) {
       warnings.push({
         type: "unsupported-setting",
-        setting: "topK"
+        setting: "frequencyPenalty"
       });
     }
-    if (stopSequences != null) {
+    if (presencePenalty != null) {
       warnings.push({
         type: "unsupported-setting",
-        setting: "stopSequences"
+        setting: "presencePenalty"
       });
     }
+    if (stopSequences != null) {
+      warnings.push({ type: "unsupported-setting", setting: "stopSequences" });
+    }
     if (seed != null) {
+      warnings.push({ type: "unsupported-setting", setting: "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 != null ? nativeTools : [],
+      ...functionTools
+    ];
+    const body = {
+      ...agentOptions,
+      ...modelSelection,
+      input,
+      max_output_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null ? {
+        type: "json_schema",
+        json_schema: {
+          name: (_b = responseFormat.name) != null ? _b : "response",
+          description: responseFormat.description,
+          schema: responseFormat.schema,
+          strict: true
+        }
+      } : void 0,
+      tools: agentTools.length > 0 ? agentTools : void 0
+    };
+    if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema == null) {
       warnings.push({
         type: "unsupported-setting",
-        setting: "seed"
+        setting: "responseFormat",
+        details: "JSON response format without a schema is not supported."
       });
     }
-    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
-        ...(_a = providerOptions == null ? void 0 : providerOptions.perplexity) != null ? _a : {},
-        // messages:
-        messages: convertToPerplexityMessages(prompt)
-      },
-      warnings
-    };
+    return { args: body, warnings };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-    const { args: body, warnings } = this.getArgs(options);
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const { args: body, warnings } = await this.getArgs(options);
+    const url = `${this.config.baseURL}/v1/agent`;
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
     } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      url,
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: perplexityErrorSchema,
-        errorToMessage
+        errorToMessage: perplexityErrorToMessage
       }),
       successfulResponseHandler: createJsonResponseHandler(
-        perplexityResponseSchema
+        perplexityAgentResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const choice = response.choices[0];
-    const content = [];
-    const text = choice.message.content;
-    if (text.length > 0) {
-      content.push({ type: "text", text });
+    if (response.error != null || response.status === "failed") {
+      throw new APICallError({
+        message: (_d = (_c = response.error) == null ? void 0 : _c.message) != null ? _d : "Perplexity response failed",
+        url,
+        requestBodyValues: body,
+        statusCode: 400,
+        responseHeaders,
+        responseBody: rawResponse,
+        isRetryable: false
+      });
     }
-    if (response.citations != null) {
-      for (const url of response.citations) {
+    const content = [];
+    const sourceIndexesByUrl = /* @__PURE__ */ new Map();
+    let hasFunctionCall = false;
+    const addSource = (source) => {
+      const existingIndex = sourceIndexesByUrl.get(source.url);
+      if (existingIndex == null) {
+        sourceIndexesByUrl.set(source.url, content.length);
+        content.push(source);
+      } else if (hasSearchResultId(source) && !hasSearchResultId(content[existingIndex])) {
+        content[existingIndex] = source;
+      }
+    };
+    for (const item of response.output) {
+      if (item.type === "message") {
+        for (const part of (_e = item.content) != null ? _e : []) {
+          if (part.type === "output_text" && part.text != null) {
+            content.push({ type: "text", text: part.text });
+          }
+          for (const annotation of (_f = part.annotations) != null ? _f : []) {
+            if (annotation.url != null) {
+              addSource({
+                type: "source",
+                sourceType: "url",
+                id: this.config.generateId(),
+                url: annotation.url,
+                title: annotation.title
+              });
+            }
+          }
+        }
+      } else if (item.type === "search_results") {
+        for (const result of getSearchResults(item)) {
+          addSource(createSource(result, this.config.generateId));
+        }
+      } else if (item.type === "fetch_url_results") {
+        for (const result of getFetchedSources(item)) {
+          addSource({
+            type: "source",
+            sourceType: "url",
+            id: this.config.generateId(),
+            url: result.url,
+            title: result.title,
+            providerMetadata: {
+              perplexity: { snippet: (_g = result.snippet) != null ? _g : null }
+            }
+          });
+        }
+      } else if (item.type === "function_call" && item.call_id != null && item.name != null && item.arguments != null) {
+        hasFunctionCall = true;
         content.push({
-          type: "source",
-          sourceType: "url",
-          id: this.config.generateId(),
-          url
+          type: "tool-call",
+          toolCallId: item.call_id,
+          toolName: item.name,
+          input: item.arguments,
+          providerMetadata: {
+            perplexity: {
+              itemId: (_h = item.id) != null ? _h : null,
+              ...item.thought_signature != null && {
+                thoughtSignature: item.thought_signature
+              }
+            }
+          }
         });
       }
     }
     return {
       content,
-      finishReason: mapPerplexityFinishReason(choice.finish_reason),
-      usage: {
-        inputTokens: (_a = response.usage) == null ? void 0 : _a.prompt_tokens,
-        outputTokens: (_b = response.usage) == null ? void 0 : _b.completion_tokens,
-        totalTokens: (_d = (_c = response.usage) == null ? void 0 : _c.total_tokens) != null ? _d : void 0
-      },
+      finishReason: mapPerplexityFinishReason({
+        status: response.status,
+        incompleteReason: (_i = response.incomplete_details) == null ? void 0 : _i.reason,
+        hasFunctionCall
+      }),
+      usage: convertPerplexityUsage(response.usage),
       request: { body },
       response: {
         ...getResponseMetadata(response),
@@ -212,57 +811,37 @@ var PerplexityLanguageModel = class {
         body: rawResponse
       },
       warnings,
-      providerMetadata: {
-        perplexity: {
-          images: (_f = (_e = response.images) == null ? void 0 : _e.map((image) => ({
-            imageUrl: image.image_url,
-            originUrl: image.origin_url,
-            height: image.height,
-            width: image.width
-          }))) != null ? _f : null,
-          usage: {
-            citationTokens: (_h = (_g = response.usage) == null ? void 0 : _g.citation_tokens) != null ? _h : null,
-            numSearchQueries: (_j = (_i = response.usage) == null ? void 0 : _i.num_search_queries) != null ? _j : null
-          }
-        }
-      }
+      providerMetadata: getProviderMetadata(response.usage)
     };
   }
   async doStream(options) {
-    const { args, warnings } = this.getArgs(options);
+    var _a, _b;
+    const { args, warnings } = await this.getArgs(options);
     const body = { ...args, stream: true };
     const { responseHeaders, value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: combineHeaders(this.config.headers(), options.headers),
+      url: `${this.config.baseURL}/v1/agent`,
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: perplexityErrorSchema,
-        errorToMessage
+        errorToMessage: perplexityErrorToMessage
       }),
       successfulResponseHandler: createEventSourceResponseHandler(
-        perplexityChunkSchema
+        perplexityAgentChunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     let finishReason = "unknown";
-    const usage = {
-      inputTokens: void 0,
-      outputTokens: void 0,
-      totalTokens: void 0
-    };
-    const providerMetadata = {
-      perplexity: {
-        usage: {
-          citationTokens: null,
-          numSearchQueries: 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({
@@ -270,76 +849,304 @@ var PerplexityLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c;
+            var _a2, _b2, _c, _d, _e, _f, _g;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
             if (!chunk.success) {
+              finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
               return;
             }
             const value = chunk.value;
-            if (isFirstChunk) {
+            const getTextId = (itemId, outputIndex, contentIndex = 0) => {
+              const id = itemId != null ? itemId : String(outputIndex != null ? outputIndex : "text");
+              return contentIndex == null || contentIndex === 0 ? id : `${id}:${contentIndex}`;
+            };
+            const emitTextDelta = (id, delta) => {
+              let state = textStates.get(id);
+              if (state == null ? void 0 : state.ended) {
+                return;
+              }
+              if (state == null) {
+                state = { text: "", ended: false };
+                textStates.set(id, state);
+                controller.enqueue({ type: "text-start", id });
+              }
+              state.text += delta;
+              controller.enqueue({ type: "text-delta", id, delta });
+            };
+            const finishText = (id, text) => {
+              var _a3;
+              const state = textStates.get(id);
+              if (state == null ? void 0 : state.ended) {
+                return;
+              }
+              const emittedText = (_a3 = state == null ? void 0 : state.text) != null ? _a3 : "";
+              if (text != null && text.startsWith(emittedText) && text.length > emittedText.length) {
+                emitTextDelta(id, text.slice(emittedText.length));
+              }
+              const finalState = textStates.get(id);
+              if (finalState != null) {
+                finalState.ended = true;
+                controller.enqueue({ type: "text-end", id });
+              }
+            };
+            const finishOutputText = (item, outputIndex) => {
+              var _a3;
+              if (item.type === "message") {
+                for (const [contentIndex, part] of ((_a3 = item.content) != null ? _a3 : []).entries()) {
+                  if (part.type === "output_text") {
+                    finishText(
+                      getTextId(item.id, outputIndex, contentIndex),
+                      part.text
+                    );
+                  }
+                }
+              }
+            };
+            const emitSource = (source) => {
+              if (emittedSourceUrls.has(source.url)) {
+                return;
+              }
+              if (hasSearchResultId(source)) {
+                pendingSourcesByUrl.delete(source.url);
+                emittedSourceUrls.add(source.url);
+                controller.enqueue(source);
+              } else if (!pendingSourcesByUrl.has(source.url)) {
+                pendingSourcesByUrl.set(source.url, source);
+              }
+            };
+            const emitReasoningThought = (thought) => {
+              if (activeReasoningId != null && thought != null) {
+                controller.enqueue({
+                  type: "reasoning-delta",
+                  id: activeReasoningId,
+                  delta: thought
+                });
+              }
+            };
+            const emitFunctionCall = (item) => {
+              var _a3;
+              if (item.type !== "function_call" || item.call_id == null || item.name == null || item.arguments == null || seenFunctionCalls.has(item.call_id)) {
+                return;
+              }
+              seenFunctionCalls.add(item.call_id);
+              hasFunctionCall = true;
               controller.enqueue({
-                type: "response-metadata",
-                ...getResponseMetadata(value)
+                type: "tool-input-start",
+                id: item.call_id,
+                toolName: item.name
               });
-              (_a = value.citations) == null ? void 0 : _a.forEach((url) => {
-                controller.enqueue({
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: item.call_id,
+                delta: item.arguments
+              });
+              controller.enqueue({ type: "tool-input-end", id: item.call_id });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: item.call_id,
+                toolName: item.name,
+                input: item.arguments,
+                providerMetadata: {
+                  perplexity: {
+                    itemId: (_a3 = item.id) != null ? _a3 : null,
+                    ...item.thought_signature != null && {
+                      thoughtSignature: item.thought_signature
+                    }
+                  }
+                }
+              });
+            };
+            const emitOutputSources = (item) => {
+              var _a3, _b3, _c2;
+              if (item.type === "message") {
+                for (const part of (_a3 = item.content) != null ? _a3 : []) {
+                  for (const annotation of (_b3 = part.annotations) != null ? _b3 : []) {
+                    if (annotation.url != null) {
+                      emitSource({
+                        type: "source",
+                        sourceType: "url",
+                        id: generateId2(),
+                        url: annotation.url,
+                        title: annotation.title
+                      });
+                    }
+                  }
+                }
+              }
+              for (const result of getSearchResults(item)) {
+                emitSource(createSource(result, generateId2));
+              }
+              for (const result of getFetchedSources(item)) {
+                emitSource({
                   type: "source",
                   sourceType: "url",
-                  id: self.config.generateId(),
-                  url
+                  id: generateId2(),
+                  url: result.url,
+                  title: result.title,
+                  providerMetadata: {
+                    perplexity: { snippet: (_c2 = result.snippet) != null ? _c2 : null }
+                  }
                 });
-              });
-              isFirstChunk = false;
-            }
-            if (value.usage != null) {
-              usage.inputTokens = value.usage.prompt_tokens;
-              usage.outputTokens = value.usage.completion_tokens;
-              providerMetadata.perplexity.usage = {
-                citationTokens: (_b = value.usage.citation_tokens) != null ? _b : null,
-                numSearchQueries: (_c = value.usage.num_search_queries) != null ? _c : 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 = mapPerplexityFinishReason(choice.finish_reason);
+              }
+            };
+            switch (value.type) {
+              case "response.created":
+              case "response.in_progress": {
+                if (!hasResponseMetadata && value.response != null) {
+                  controller.enqueue({
+                    type: "response-metadata",
+                    ...getResponseMetadata(value.response)
+                  });
+                  hasResponseMetadata = true;
+                }
+                break;
+              }
+              case "response.output_text.delta": {
+                if (value.delta != null) {
+                  emitTextDelta(
+                    getTextId(
+                      value.item_id,
+                      value.output_index,
+                      value.content_index
+                    ),
+                    value.delta
+                  );
+                }
+                break;
+              }
+              case "response.output_text.done": {
+                finishText(
+                  getTextId(
+                    value.item_id,
+                    value.output_index,
+                    value.content_index
+                  ),
+                  value.text
+                );
+                break;
+              }
+              case "response.reasoning.started": {
+                if (activeReasoningId != null) {
+                  controller.enqueue({
+                    type: "reasoning-end",
+                    id: activeReasoningId
+                  });
+                }
+                activeReasoningId = `reasoning-${(_a2 = value.sequence_number) != null ? _a2 : generateId2()}`;
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: activeReasoningId
+                });
+                emitReasoningThought(value.thought);
+                break;
+              }
+              case "response.reasoning.search_queries":
+              case "response.reasoning.fetch_url_queries": {
+                emitReasoningThought(value.thought);
+                break;
+              }
+              case "response.reasoning.search_results": {
+                emitReasoningThought(value.thought);
+                for (const result of (_b2 = value.results) != null ? _b2 : []) {
+                  emitSource(createSource(result, generateId2));
+                }
+                break;
+              }
+              case "response.reasoning.fetch_url_results": {
+                emitReasoningThought(value.thought);
+                for (const result of (_c = value.contents) != null ? _c : []) {
+                  emitSource({
+                    type: "source",
+                    sourceType: "url",
+                    id: generateId2(),
+                    url: result.url,
+                    title: result.title,
+                    providerMetadata: {
+                      perplexity: { snippet: (_d = result.snippet) != null ? _d : null }
+                    }
+                  });
+                }
+                break;
+              }
+              case "response.reasoning.stopped": {
+                emitReasoningThought(value.thought);
+                if (activeReasoningId != null) {
+                  controller.enqueue({
+                    type: "reasoning-end",
+                    id: activeReasoningId
+                  });
+                  activeReasoningId = void 0;
+                }
+                break;
+              }
+              case "response.output_item.done": {
+                if (value.item != null) {
+                  finishOutputText(value.item, value.output_index);
+                  emitOutputSources(value.item);
+                  emitFunctionCall(value.item);
+                }
+                break;
+              }
+              case "response.completed":
+              case "response.incomplete": {
+                if (value.response != null) {
+                  if (!hasResponseMetadata) {
+                    controller.enqueue({
+                      type: "response-metadata",
+                      ...getResponseMetadata(value.response)
+                    });
+                    hasResponseMetadata = true;
+                  }
+                  for (const [
+                    outputIndex,
+                    item
+                  ] of value.response.output.entries()) {
+                    finishOutputText(item, outputIndex);
+                    emitOutputSources(item);
+                    emitFunctionCall(item);
+                  }
+                  usage = (_e = value.response.usage) != null ? _e : void 0;
+                  finishReason = mapPerplexityFinishReason({
+                    status: value.response.status,
+                    incompleteReason: (_f = value.response.incomplete_details) == null ? void 0 : _f.reason,
+                    hasFunctionCall
+                  });
+                }
+                break;
+              }
+              case "response.failed": {
+                finishReason = "error";
+                controller.enqueue({
+                  type: "error",
+                  error: (_g = value.error) != null ? _g : 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,
-              providerMetadata
+              usage: convertPerplexityUsage(usage),
+              providerMetadata: getProviderMetadata(usage)
             });
           }
         })
@@ -349,78 +1156,9 @@ var PerplexityLanguageModel = class {
     };
   }
 };
-function getResponseMetadata({
-  id,
-  model,
-  created
-}) {
-  return {
-    id,
-    modelId: model,
-    timestamp: new Date(created * 1e3)
-  };
-}
-var perplexityUsageSchema = z.object({
-  prompt_tokens: z.number(),
-  completion_tokens: z.number(),
-  total_tokens: z.number().nullish(),
-  citation_tokens: z.number().nullish(),
-  num_search_queries: z.number().nullish()
-});
-var perplexityImageSchema = z.object({
-  image_url: z.string(),
-  origin_url: z.string(),
-  height: z.number(),
-  width: z.number()
-});
-var perplexityResponseSchema = z.object({
-  id: z.string(),
-  created: z.number(),
-  model: z.string(),
-  choices: z.array(
-    z.object({
-      message: z.object({
-        role: z.literal("assistant"),
-        content: z.string()
-      }),
-      finish_reason: z.string().nullish()
-    })
-  ),
-  citations: z.array(z.string()).nullish(),
-  images: z.array(perplexityImageSchema).nullish(),
-  usage: perplexityUsageSchema.nullish()
-});
-var perplexityChunkSchema = z.object({
-  id: z.string(),
-  created: z.number(),
-  model: z.string(),
-  choices: z.array(
-    z.object({
-      delta: z.object({
-        role: z.literal("assistant"),
-        content: z.string()
-      }),
-      finish_reason: z.string().nullish()
-    })
-  ),
-  citations: z.array(z.string()).nullish(),
-  images: z.array(perplexityImageSchema).nullish(),
-  usage: perplexityUsageSchema.nullish()
-});
-var perplexityErrorSchema = z.object({
-  error: z.object({
-    code: z.number(),
-    message: z.string().nullish(),
-    type: z.string().nullish()
-  })
-});
-var errorToMessage = (data) => {
-  var _a, _b;
-  return (_b = (_a = data.error.message) != null ? _a : data.error.type) != null ? _b : "unknown error";
-};
 
 // src/version.ts
-var VERSION = true ? "2.1.0-beta.8" : "0.0.0-test";
+var VERSION = true ? "2.1.0" : "0.0.0-test";
 
 // src/perplexity-provider.ts
 function createPerplexity(options = {}) {