@ai-sdk/perplexity 4.0.52 → 5.0.0

package/src/perplexity-language-model.ts

@@ -1,49 +1,183 @@
-import type {
-  LanguageModelV4,
-  LanguageModelV4CallOptions,
-  LanguageModelV4Content,
-  LanguageModelV4FinishReason,
-  LanguageModelV4GenerateResult,
-  LanguageModelV4StreamPart,
-  LanguageModelV4StreamResult,
-  SharedV4Warning,
+import {
+  APICallError,
+  type LanguageModelV4,
+  type LanguageModelV4CallOptions,
+  type LanguageModelV4Content,
+  type LanguageModelV4FinishReason,
+  type LanguageModelV4GenerateResult,
+  type LanguageModelV4StreamPart,
+  type LanguageModelV4StreamResult,
+  type SharedV4ProviderMetadata,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
-  createLanguageModelResponseMetadata as getResponseMetadata,
+  createLanguageModelResponseMetadata,
   isCustomReasoning,
   parseProviderOptions,
   postJsonToApi,
   serializeModelOptions,
-  WORKFLOW_SERIALIZE,
   WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
   type FetchFunction,
   type ParseResult,
 } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
+import type { z } from 'zod/v4';
 import { convertPerplexityUsage } from './convert-perplexity-usage';
-import { convertToPerplexityMessages } from './convert-to-perplexity-messages';
+import { convertToPerplexityInput } from './convert-to-perplexity-input';
 import { mapPerplexityFinishReason } from './map-perplexity-finish-reason';
+import {
+  perplexityAgentChunkSchema,
+  perplexityAgentResponseSchema,
+  perplexityErrorSchema,
+  perplexityErrorToMessage,
+  type PerplexityAgentTool,
+  type perplexityOutputItemSchema,
+  type perplexitySearchResultSchema,
+  type perplexityUsageSchema,
+} from './perplexity-agent-api';
 import { perplexityLanguageModelOptions } from './perplexity-language-model-options';
-import type { PerplexityLanguageModelId } from './perplexity-options';
+import type {
+  PerplexityAgentPreset,
+  PerplexityLanguageModelId,
+} from './perplexity-options';
+import { preparePerplexityTools } from './perplexity-prepare-tools';
 
-type PerplexityChatConfig = {
+type PerplexityAgentConfig = {
   baseURL: string;
   headers?: () => Record<string, string | undefined>;
   generateId: () => string;
   fetch?: FetchFunction;
 };
 
+type PerplexityOutputItem = z.infer<typeof perplexityOutputItemSchema>;
+type PerplexitySearchResult = z.infer<typeof perplexitySearchResultSchema>;
+type PerplexityUsage = z.infer<typeof perplexityUsageSchema>;
+type PerplexityUrlSource = Extract<
+  LanguageModelV4Content,
+  { type: 'source'; sourceType: 'url' }
+>;
+
+const presetIds = new Set<PerplexityAgentPreset>([
+  'fast',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+]);
+
+function getModelSelection(modelId: PerplexityLanguageModelId): {
+  model?: string;
+  preset?: PerplexityAgentPreset;
+} {
+  if (presetIds.has(modelId as PerplexityAgentPreset)) {
+    return { preset: modelId as PerplexityAgentPreset };
+  }
+
+  return { model: modelId };
+}
+
+function getResponseMetadata(response: {
+  id?: string | null;
+  model?: string | null;
+  created_at?: number | null;
+}) {
+  return createLanguageModelResponseMetadata({
+    id: response.id,
+    model: response.model,
+    created: response.created_at,
+  });
+}
+
+function getProviderMetadata(
+  usage: PerplexityUsage | null | undefined,
+): SharedV4ProviderMetadata {
+  const cost = usage?.cost;
+  const numSearchQueries = usage?.tool_calls_details
+    ? Object.entries(usage.tool_calls_details)
+        .filter(([name]) => name.includes('search'))
+        .reduce((total, [, details]) => total + (details.invocation ?? 0), 0)
+    : null;
+
+  return {
+    perplexity: {
+      usage: {
+        citationTokens: null,
+        numSearchQueries,
+      },
+      images: null,
+      cost:
+        cost == null
+          ? null
+          : {
+              inputTokensCost: cost.input_cost ?? null,
+              outputTokensCost: cost.output_cost ?? null,
+              requestCost: null,
+              totalCost: cost.total_cost ?? null,
+              currency: cost.currency ?? null,
+              cacheCreationCost: cost.cache_creation_cost ?? null,
+              cacheReadCost: cost.cache_read_cost ?? null,
+              toolCallsCost: cost.tool_calls_cost ?? null,
+            },
+      toolCalls:
+        usage?.tool_calls_details == null
+          ? null
+          : Object.fromEntries(
+              Object.entries(usage.tool_calls_details).map(
+                ([name, details]) => [
+                  name,
+                  { invocation: details.invocation ?? null },
+                ],
+              ),
+            ),
+    },
+  };
+}
+
+function createSource(
+  result: PerplexitySearchResult,
+  generateId: () => string,
+): PerplexityUrlSource {
+  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: PerplexityUrlSource): boolean {
+  return typeof source.providerMetadata?.perplexity?.resultId === 'number';
+}
+
+function getSearchResults(item: PerplexityOutputItem) {
+  return item.type === 'search_results' ? (item.results ?? []) : [];
+}
+
+function getFetchedSources(item: PerplexityOutputItem) {
+  return item.type === 'fetch_url_results' ? (item.contents ?? []) : [];
+}
+
 export class PerplexityLanguageModel implements LanguageModelV4 {
   readonly specificationVersion = 'v4';
   readonly provider = 'perplexity';
 
   readonly modelId: PerplexityLanguageModelId;
 
-  private readonly config: PerplexityChatConfig;
+  private readonly config: PerplexityAgentConfig;
 
   static [WORKFLOW_SERIALIZE](model: PerplexityLanguageModel) {
     return serializeModelOptions({
@@ -54,21 +188,21 @@ export class PerplexityLanguageModel implements LanguageModelV4 {
 
   static [WORKFLOW_DESERIALIZE](options: {
     modelId: PerplexityLanguageModelId;
-    config: PerplexityChatConfig;
+    config: PerplexityAgentConfig;
   }) {
     return new PerplexityLanguageModel(options.modelId, options.config);
   }
 
   constructor(
     modelId: PerplexityLanguageModelId,
-    config: PerplexityChatConfig,
+    config: PerplexityAgentConfig,
   ) {
     this.modelId = modelId;
     this.config = config;
   }
 
   readonly supportedUrls: Record<string, RegExp[]> = {
-    // No URLs are supported.
+    'image/*': [/^https?:\/\/.*$/],
   };
 
   private async getArgs({
@@ -84,6 +218,8 @@ export class PerplexityLanguageModel implements LanguageModelV4 {
     responseFormat,
     seed,
     providerOptions,
+    tools,
+    toolChoice,
   }: LanguageModelV4CallOptions) {
     const warnings: SharedV4Warning[] = [];
 
@@ -97,53 +233,78 @@ export class PerplexityLanguageModel implements LanguageModelV4 {
     if (topK != null) {
       warnings.push({ type: 'unsupported', feature: 'topK' });
     }
-
+    if (frequencyPenalty != null) {
+      warnings.push({ type: 'unsupported', feature: 'frequencyPenalty' });
+    }
+    if (presencePenalty != null) {
+      warnings.push({ type: 'unsupported', feature: 'presencePenalty' });
+    }
     if (stopSequences != null) {
       warnings.push({ type: 'unsupported', feature: 'stopSequences' });
     }
-
     if (seed != null) {
       warnings.push({ type: 'unsupported', feature: 'seed' });
     }
 
-    if (isCustomReasoning(reasoning)) {
+    const { tools: nativeTools, ...agentOptions } = perplexityOptions;
+
+    const modelSelection = getModelSelection(this.modelId);
+
+    const { input, warnings: inputWarnings } = convertToPerplexityInput(prompt);
+    warnings.push(...inputWarnings);
+
+    const { tools: functionTools, warnings: toolWarnings } =
+      preparePerplexityTools({ tools, toolChoice });
+    warnings.push(...toolWarnings);
+
+    const agentTools = [
+      ...((nativeTools ?? []) as PerplexityAgentTool[]),
+      ...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: Record<string, unknown> = {
+      ...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,
+              },
+            }
+          : undefined,
+      tools: agentTools.length > 0 ? agentTools : undefined,
+    };
+
+    if (responseFormat?.type === 'json' && responseFormat.schema == null) {
       warnings.push({
         type: 'unsupported',
-        feature: 'reasoning',
-        details: 'This provider does not support reasoning configuration.',
+        feature: 'JSON response format without a schema',
       });
     }
 
-    return {
-      args: {
-        // model id:
-        model: this.modelId,
-
-        // standardized settings:
-        frequency_penalty: frequencyPenalty,
-        max_tokens: maxOutputTokens,
-        presence_penalty: presencePenalty,
-        temperature,
-        top_k: topK,
-        top_p: topP,
-
-        // response format:
-        response_format:
-          responseFormat?.type === 'json'
-            ? {
-                type: 'json_schema',
-                json_schema: { schema: responseFormat.schema },
-              }
-            : undefined,
-
-        // provider extensions
-        ...perplexityOptions,
-
-        // messages:
-        messages: convertToPerplexityMessages(prompt),
-      },
-      warnings,
-    };
+    return { args: body, warnings };
   }
 
   async doGenerate(
@@ -151,51 +312,125 @@ export class PerplexityLanguageModel implements LanguageModelV4 {
   ): Promise<LanguageModelV4GenerateResult> {
     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`,
+      url,
       headers: combineHeaders(this.config.headers?.(), options.headers),
       body,
       failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: perplexityErrorSchema,
-        errorToMessage,
+        errorToMessage: perplexityErrorToMessage,
       }),
       successfulResponseHandler: createJsonResponseHandler(
-        perplexityResponseSchema,
+        perplexityAgentResponseSchema,
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
     });
 
-    const choice = response.choices[0];
-    const content: Array<LanguageModelV4Content> = [];
-
-    // text content:
-    const text = choice.message.content;
-    if (text.length > 0) {
-      content.push({ type: 'text', text });
+    if (response.error != null || response.status === 'failed') {
+      throw new APICallError({
+        message: response.error?.message ?? 'Perplexity response failed',
+        url,
+        requestBodyValues: body,
+        statusCode: 400,
+        responseHeaders,
+        responseBody: rawResponse as string,
+        isRetryable: false,
+      });
     }
 
-    // sources:
-    if (response.citations != null) {
-      for (const url of response.citations) {
+    const content: LanguageModelV4Content[] = [];
+    const sourceIndexesByUrl = new Map<string, number>();
+    let hasFunctionCall = false;
+
+    const addSource = (source: PerplexityUrlSource) => {
+      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] as PerplexityUrlSource)
+      ) {
+        content[existingIndex] = source;
+      }
+    };
+
+    for (const item of response.output) {
+      if (item.type === 'message') {
+        for (const part of item.content ?? []) {
+          if (part.type === 'output_text' && part.text != null) {
+            content.push({ type: 'text', text: part.text });
+          }
+          for (const annotation of part.annotations ?? []) {
+            if (annotation.url != null) {
+              addSource({
+                type: 'source',
+                sourceType: 'url',
+                id: this.config.generateId(),
+                url: annotation.url,
+                title: annotation.title,
+              });
+            }
+          }
+        }
+      } else if (item.type === 'search_results') {
+        for (const result of getSearchResults(item)) {
+          addSource(createSource(result, this.config.generateId));
+        }
+      } else if (item.type === 'fetch_url_results') {
+        for (const result of getFetchedSources(item)) {
+          addSource({
+            type: 'source',
+            sourceType: 'url',
+            id: this.config.generateId(),
+            url: result.url,
+            title: result.title,
+            providerMetadata: {
+              perplexity: { snippet: result.snippet ?? null },
+            },
+          });
+        }
+      } else if (
+        item.type === 'function_call' &&
+        item.call_id != null &&
+        item.name != null &&
+        item.arguments != null
+      ) {
+        hasFunctionCall = true;
         content.push({
-          type: 'source',
-          sourceType: 'url',
-          id: this.config.generateId(),
-          url,
+          type: 'tool-call',
+          toolCallId: item.call_id,
+          toolName: item.name,
+          input: item.arguments,
+          providerMetadata: {
+            perplexity: {
+              itemId: item.id ?? null,
+              ...(item.thought_signature != null && {
+                thoughtSignature: item.thought_signature,
+              }),
+            },
+          },
         });
       }
     }
 
+    const finishReason = response.incomplete_details?.reason ?? response.status;
+
     return {
       content,
       finishReason: {
-        unified: mapPerplexityFinishReason(choice.finish_reason),
-        raw: choice.finish_reason ?? undefined,
+        unified: mapPerplexityFinishReason({
+          status: response.status,
+          incompleteReason: response.incomplete_details?.reason,
+          hasFunctionCall,
+        }),
+        raw: finishReason,
       },
       usage: convertPerplexityUsage(response.usage),
       request: { body },
@@ -205,30 +440,7 @@ export class PerplexityLanguageModel implements LanguageModelV4 {
         body: rawResponse,
       },
       warnings,
-      providerMetadata: {
-        perplexity: {
-          images:
-            response.images?.map(image => ({
-              imageUrl: image.image_url,
-              originUrl: image.origin_url,
-              height: image.height,
-              width: image.width,
-            })) ?? null,
-          usage: {
-            citationTokens: response.usage?.citation_tokens ?? null,
-            numSearchQueries: response.usage?.num_search_queries ?? null,
-          },
-          cost: response.usage?.cost
-            ? {
-                inputTokensCost: response.usage.cost.input_tokens_cost ?? null,
-                outputTokensCost:
-                  response.usage.cost.output_tokens_cost ?? null,
-                requestCost: response.usage.cost.request_cost ?? null,
-                totalCost: response.usage.cost.total_cost ?? null,
-              }
-            : null,
-        },
-      },
+      providerMetadata: getProviderMetadata(response.usage),
     };
   }
 
@@ -236,19 +448,18 @@ export class PerplexityLanguageModel implements LanguageModelV4 {
     options: LanguageModelV4CallOptions,
   ): Promise<LanguageModelV4StreamResult> {
     const { args, warnings } = await this.getArgs(options);
-
     const body = { ...args, stream: true };
 
     const { responseHeaders, value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
+      url: `${this.config.baseURL}/v1/agent`,
       headers: combineHeaders(this.config.headers?.(), options.headers),
       body,
       failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: perplexityErrorSchema,
-        errorToMessage,
+        errorToMessage: perplexityErrorToMessage,
       }),
       successfulResponseHandler: createEventSourceResponseHandler(
-        perplexityChunkSchema,
+        perplexityAgentChunkSchema,
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
@@ -258,52 +469,20 @@ export class PerplexityLanguageModel implements LanguageModelV4 {
       unified: 'other',
       raw: undefined,
     };
-    let usage:
-      | {
-          prompt_tokens: number | undefined;
-          completion_tokens: number | undefined;
-          reasoning_tokens?: number | null | undefined;
-        }
-      | undefined = undefined;
-
-    const providerMetadata: {
-      perplexity: {
-        usage: {
-          citationTokens: number | null;
-          numSearchQueries: number | null;
-        };
-        cost: {
-          inputTokensCost: number | null;
-          outputTokensCost: number | null;
-          requestCost: number | null;
-          totalCost: number | null;
-        } | null;
-        images: Array<{
-          imageUrl: string;
-          originUrl: string;
-          height: number;
-          width: number;
-        }> | null;
-      };
-    } = {
-      perplexity: {
-        usage: {
-          citationTokens: null,
-          numSearchQueries: null,
-        },
-        cost: null,
-        images: null,
-      },
-    };
-    let isFirstChunk = true;
-    let isActive = false;
-
-    const self = this;
+    let usage: PerplexityUsage | undefined;
+    let hasFunctionCall = false;
+    let hasResponseMetadata = false;
+    let activeReasoningId: string | undefined;
+    const textStates = new Map<string, { text: string; ended: boolean }>();
+    const emittedSourceUrls = new Set<string>();
+    const pendingSourcesByUrl = new Map<string, PerplexityUrlSource>();
+    const seenFunctionCalls = new Set<string>();
+    const generateId = this.config.generateId;
 
     return {
       stream: response.pipeThrough(
         new TransformStream<
-          ParseResult<z.infer<typeof perplexityChunkSchema>>,
+          ParseResult<z.infer<typeof perplexityAgentChunkSchema>>,
           LanguageModelV4StreamPart
         >({
           start(controller) {
@@ -311,103 +490,354 @@ export class PerplexityLanguageModel implements LanguageModelV4 {
           },
 
           transform(chunk, controller) {
-            // Emit raw chunk if requested (before anything else)
             if (options.includeRawChunks) {
               controller.enqueue({ type: 'raw', rawValue: chunk.rawValue });
             }
 
             if (!chunk.success) {
+              finishReason = { unified: 'error', raw: undefined };
               controller.enqueue({ type: 'error', error: chunk.error });
               return;
             }
 
             const value = chunk.value;
 
-            if (isFirstChunk) {
-              controller.enqueue({
-                type: 'response-metadata',
-                ...getResponseMetadata(value),
-              });
+            const getTextId = (
+              itemId: string | null | undefined,
+              outputIndex: number | undefined,
+              contentIndex = 0,
+            ) => {
+              const id = itemId ?? String(outputIndex ?? 'text');
+              return contentIndex === 0 ? id : `${id}:${contentIndex}`;
+            };
+
+            const emitTextDelta = (id: string, delta: string) => {
+              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: string, text: string | undefined) => {
+              const state = textStates.get(id);
+              if (state?.ended) {
+                return;
+              }
+              // Terminal output can contain text for which no delta arrived,
+              // or the remainder of a partially streamed content part.
+              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: PerplexityOutputItem,
+              outputIndex?: number,
+            ) => {
+              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: PerplexityUrlSource) => {
+              if (emittedSourceUrls.has(source.url)) {
+                return;
+              }
 
-              value.citations?.forEach(url => {
+              if (hasSearchResultId(source)) {
+                pendingSourcesByUrl.delete(source.url);
+                emittedSourceUrls.add(source.url);
+                controller.enqueue(source);
+              } else if (!pendingSourcesByUrl.has(source.url)) {
+                // A later search result can supply the citation ID. Delay
+                // sources without one rather than emitting a duplicate update.
+                pendingSourcesByUrl.set(source.url, source);
+              }
+            };
+
+            const emitReasoningThought = (thought: string | undefined) => {
+              if (activeReasoningId != null && thought != null) {
                 controller.enqueue({
+                  type: 'reasoning-delta',
+                  id: activeReasoningId,
+                  delta: thought,
+                });
+              }
+            };
+
+            const emitFunctionCall = (item: PerplexityOutputItem) => {
+              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: PerplexityOutputItem) => {
+              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: self.config.generateId(),
-                  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;
+              }
 
-              isFirstChunk = false;
-            }
+              case 'response.output_text.delta': {
+                if (value.delta != null) {
+                  emitTextDelta(
+                    getTextId(
+                      value.item_id,
+                      value.output_index,
+                      value.content_index,
+                    ),
+                    value.delta,
+                  );
+                }
+                break;
+              }
 
-            if (value.usage != null) {
-              usage = value.usage;
-
-              providerMetadata.perplexity.usage = {
-                citationTokens: value.usage.citation_tokens ?? null,
-                numSearchQueries: value.usage.num_search_queries ?? null,
-              };
-
-              providerMetadata.perplexity.cost = value.usage.cost
-                ? {
-                    inputTokensCost: value.usage.cost.input_tokens_cost ?? null,
-                    outputTokensCost:
-                      value.usage.cost.output_tokens_cost ?? null,
-                    requestCost: value.usage.cost.request_cost ?? null,
-                    totalCost: value.usage.cost.total_cost ?? null,
-                  }
-                : null;
-            }
+              case 'response.output_text.done': {
+                finishText(
+                  getTextId(
+                    value.item_id,
+                    value.output_index,
+                    value.content_index,
+                  ),
+                  value.text,
+                );
+                break;
+              }
 
-            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,
-              }));
-            }
+              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;
+              }
 
-            const choice = value.choices[0];
-            if (choice?.finish_reason != null) {
-              finishReason = {
-                unified: mapPerplexityFinishReason(choice.finish_reason),
-                raw: choice.finish_reason,
-              };
-            }
+              case 'response.reasoning.search_queries':
+              case 'response.reasoning.fetch_url_queries': {
+                emitReasoningThought(value.thought);
+                break;
+              }
 
-            if (choice?.delta == null) {
-              return;
-            }
+              case 'response.reasoning.search_results': {
+                emitReasoningThought(value.thought);
+                for (const result of value.results ?? []) {
+                  emitSource(createSource(result, generateId));
+                }
+                break;
+              }
 
-            const delta = choice.delta;
-            const textContent = delta.content;
+              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;
+              }
 
-            if (textContent != null) {
-              if (!isActive) {
-                controller.enqueue({ type: 'text-start', id: '0' });
-                isActive = true;
+              case 'response.reasoning.stopped': {
+                emitReasoningThought(value.thought);
+                if (activeReasoningId != null) {
+                  controller.enqueue({
+                    type: 'reasoning-end',
+                    id: activeReasoningId,
+                  });
+                  activeReasoningId = undefined;
+                }
+                break;
               }
 
-              controller.enqueue({
-                type: 'text-delta',
-                id: '0',
-                delta: textContent,
-              });
+              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 ?? undefined;
+                  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) {
-            if (isActive) {
-              controller.enqueue({ type: 'text-end', id: '0' });
+            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,
+              providerMetadata: getProviderMetadata(usage),
             });
           },
         }),
@@ -418,88 +848,8 @@ export class PerplexityLanguageModel implements LanguageModelV4 {
   }
 }
 
-const perplexityCostSchema = z
-  .object({
-    input_tokens_cost: z.number().nullish(),
-    output_tokens_cost: z.number().nullish(),
-    reasoning_tokens_cost: z.number().nullish(),
-    request_cost: z.number().nullish(),
-    citation_tokens_cost: z.number().nullish(),
-    search_queries_cost: z.number().nullish(),
-    total_cost: z.number().nullish(),
-  })
-  .catchall(z.json());
-
-const perplexityUsageSchema = z
-  .object({
-    prompt_tokens: z.number(),
-    completion_tokens: z.number(),
-    total_tokens: z.number().nullish(),
-    search_context_size: z.enum(['low', 'medium', 'high']).nullish(),
-    citation_tokens: z.number().nullish(),
-    num_search_queries: z.number().nullish(),
-    reasoning_tokens: z.number().nullish(),
-    cost: perplexityCostSchema.nullish(),
-  })
-  .catchall(z.json());
-
-export const perplexityImageSchema = z.object({
-  image_url: z.string(),
-  origin_url: z.string(),
-  height: z.number(),
-  width: z.number(),
-});
-
-// limited version of the schema, focussed on what is needed for the implementation
-// this approach limits breakages when the API changes and increases efficiency
-const 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(),
-});
-
-// limited version of the schema, focussed on what is needed for the implementation
-// this approach limits breakages when the API changes and increases efficiency
-const perplexityChunkSchema = z.object({
-  id: z.string(),
-  created: z.number(),
-  model: z.string(),
-  choices: z.array(
-    z.object({
-      delta: z.object({
-        role: z.literal('assistant').optional(),
-        content: z.string().nullish(),
-      }),
-      finish_reason: z.string().nullish(),
-    }),
-  ),
-  citations: z.array(z.string()).nullish(),
-  images: z.array(perplexityImageSchema).nullish(),
-  usage: perplexityUsageSchema.nullish(),
-});
-
-export const perplexityErrorSchema = z.object({
-  error: z.object({
-    code: z.number(),
-    message: z.string().nullish(),
-    type: z.string().nullish(),
-  }),
-});
-
-export type PerplexityErrorData = z.infer<typeof perplexityErrorSchema>;
-
-const errorToMessage = (data: PerplexityErrorData) => {
-  return data.error.message ?? data.error.type ?? 'unknown error';
-};
+export {
+  perplexityErrorSchema,
+  perplexityErrorToMessage,
+} from './perplexity-agent-api';
+export type { PerplexityErrorData } from './perplexity-agent-api';