@ai-sdk/perplexity 5.0.15 → 5.0.17

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @ai-sdk/perplexity
 
+## 5.0.17
+
+### Patch Changes
+
+- 4b4c125: Defer construction of provider validation schemas until first use to reduce package import time.
+- Updated dependencies [b089ce8]
+- Updated dependencies [39a776b]
+  - @ai-sdk/provider-utils@5.0.65
+
+## 5.0.16
+
+### Patch Changes
+
+- 0c2a9de: Add `maxOutputTokens` and `reasoning` to experimental decision calls and forward them to language-model-backed decisions. Language-model adapters keep reasoning disabled when omitted. Native decision providers warn when either setting is unsupported.
+- Updated dependencies [0c2a9de]
+- Updated dependencies [200c47f]
+  - @ai-sdk/provider@4.0.31
+  - @ai-sdk/provider-utils@5.0.64
+
 ## 5.0.15
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { EmbeddingModelV4, Experimental_DecisionModelV4, LanguageModelV4, ProviderV4 } from "@ai-sdk/provider";
-import { FetchFunction } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
+import { FetchFunction, InferSchema } from "@ai-sdk/provider-utils";
 //#region src/perplexity-decision-model-options.d.ts
 type PerplexityDecisionModelId = 'pplx-decider-v1.2' | 'pplx-decider-flash-v1.2' | 'pplx-decider-latest' | 'pplx-decider-flash-latest' | 'perplexity/pplx-decider-latest' | 'perplexity/pplx-decider-flash-latest' | 'pplx-decider-v1.1-27b' | 'pplx-decider-v1-27b' | (string & {});
 /** Perplexity decision models do not support provider-specific options. */
@@ -8,14 +7,11 @@ type PerplexityDecisionModelOptions = Record<string, never>;
 //#endregion
 //#region src/perplexity-embedding-model-options.d.ts
 type PerplexityEmbeddingModelId = 'pplx-embed-v1-0.6b' | 'pplx-embed-v1-4b' | (string & {});
-declare const perplexityEmbeddingModelOptions: z.ZodObject<{
-  dimensions: z.ZodOptional<z.ZodNumber>;
-  encodingFormat: z.ZodOptional<z.ZodEnum<{
-    base64_int8: "base64_int8";
-    base64_binary: "base64_binary";
-  }>>;
-}, z.core.$strip>;
-type PerplexityEmbeddingModelOptions = z.infer<typeof perplexityEmbeddingModelOptions>;
+declare const perplexityEmbeddingModelOptions: import("@ai-sdk/provider-utils").LazySchema<{
+  dimensions?: number | undefined;
+  encodingFormat?: "base64_int8" | "base64_binary" | undefined;
+}>;
+type PerplexityEmbeddingModelOptions = InferSchema<typeof perplexityEmbeddingModelOptions>;
 //#endregion
 //#region src/perplexity-options.d.ts
 type PerplexityAgentPreset = 'fast' | 'low' | 'medium' | 'high' | 'xhigh';
@@ -69,111 +65,86 @@ export declare function createPerplexity(options?: PerplexityProviderSettings):
 export declare const perplexity: PerplexityProvider;
 //#endregion
 //#region src/perplexity-language-model-options.d.ts
-declare const perplexityLanguageModelOptions: z.ZodObject<{
-  /** Top-level Agent API instructions. */
-  instructions: z.ZodOptional<z.ZodString>;
-  /**
-   * Native Agent API tools. AI SDK function tools can also be supplied through
-   * the top-level `tools` option on `generateText` and `streamText`.
-   */
-  tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-    type: z.ZodLiteral<"web_search">;
-    filters: z.ZodOptional<z.ZodObject<{
-      search_domain_filter: z.ZodOptional<z.ZodArray<z.ZodString>>;
-      search_recency_filter: z.ZodOptional<z.ZodEnum<{
-        hour: "hour";
-        day: "day";
-        week: "week";
-        month: "month";
-        year: "year";
-      }>>;
-      search_after_date_filter: z.ZodOptional<z.ZodString>;
-      search_before_date_filter: z.ZodOptional<z.ZodString>;
-      last_updated_after_filter: z.ZodOptional<z.ZodString>;
-      last_updated_before_filter: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    max_results: z.ZodOptional<z.ZodNumber>;
-    max_tokens: z.ZodOptional<z.ZodNumber>;
-    max_tokens_per_page: z.ZodOptional<z.ZodNumber>;
-    search_context_size: z.ZodOptional<z.ZodEnum<{
-      low: "low";
-      medium: "medium";
-      high: "high";
-    }>>;
-    user_location: z.ZodOptional<z.ZodObject<{
-      latitude: z.ZodOptional<z.ZodNumber>;
-      longitude: z.ZodOptional<z.ZodNumber>;
-      country: z.ZodOptional<z.ZodString>;
-      city: z.ZodOptional<z.ZodString>;
-      region: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-  }, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"fetch_url">;
-    max_urls: z.ZodOptional<z.ZodNumber>;
-  }, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"people_search">;
-  }, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"finance_search">;
-  }, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"sandbox">;
-  }, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"mcp">;
-    server_label: z.ZodString;
-    server_url: z.ZodString;
-    allowed_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    authorization: z.ZodOptional<z.ZodString>;
-    defer_loading: z.ZodOptional<z.ZodBoolean>;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  }, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"connector">;
-    id: z.ZodString;
-    server_label: z.ZodString;
-    server_description: z.ZodOptional<z.ZodString>;
-    allowed_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  }, z.core.$loose>]>>>;
-  /** A fallback model list for Agent API routing. */
-  models: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  /** Maximum number of agentic steps. */
-  max_steps: z.ZodOptional<z.ZodNumber>;
-  /** Maximum number of native tool calls. */
-  max_tool_calls: z.ZodOptional<z.ZodNumber>;
-  /** Continue a conversation from an earlier Agent API response. */
-  previous_response_id: z.ZodOptional<z.ZodString>;
-  /**
-   * Whether the response can be retrieved later. Setting this to false does
-   * not disable persistence or prevent previous_response_id continuations.
-   */
-  store: z.ZodOptional<z.ZodBoolean>;
-  /** Preferred response language as an ISO 639-1 language code. */
-  language_preference: z.ZodOptional<z.ZodString>;
-  /** Agent API reasoning configuration. */
-  reasoning: z.ZodOptional<z.ZodObject<{
-    effort: z.ZodOptional<z.ZodEnum<{
-      low: "low";
-      medium: "medium";
-      high: "high";
-      minimal: "minimal";
-      xhigh: "xhigh";
-    }>>;
-  }, z.core.$loose>>;
-  /** Agent API skill configuration. */
-  skills: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-    type: z.ZodLiteral<"builtin">;
-    name: z.ZodEnum<{
-      office: "office";
-      "office/docx": "office/docx";
-      "office/pdf": "office/pdf";
-      "office/pptx": "office/pptx";
-      "office/xlsx": "office/xlsx";
-    }>;
-  }, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"inline">;
-    name: z.ZodString;
-    description: z.ZodString;
-    instructions: z.ZodString;
-  }, z.core.$loose>]>>>;
-}, z.core.$loose>;
-type PerplexityLanguageModelOptions = z.infer<typeof perplexityLanguageModelOptions>;
+declare const perplexityLanguageModelOptions: import("@ai-sdk/provider-utils").LazySchema<{
+  [x: string]: unknown;
+  instructions?: string | undefined;
+  tools?: ({
+    [x: string]: unknown;
+    type: "web_search";
+    filters?: {
+      [x: string]: unknown;
+      search_domain_filter?: string[] | undefined;
+      search_recency_filter?: "hour" | "day" | "week" | "month" | "year" | undefined;
+      search_after_date_filter?: string | undefined;
+      search_before_date_filter?: string | undefined;
+      last_updated_after_filter?: string | undefined;
+      last_updated_before_filter?: string | undefined;
+    } | undefined;
+    max_results?: number | undefined;
+    max_tokens?: number | undefined;
+    max_tokens_per_page?: number | undefined;
+    search_context_size?: "low" | "medium" | "high" | undefined;
+    user_location?: {
+      [x: string]: unknown;
+      latitude?: number | undefined;
+      longitude?: number | undefined;
+      country?: string | undefined;
+      city?: string | undefined;
+      region?: string | undefined;
+    } | undefined;
+  } | {
+    [x: string]: unknown;
+    type: "fetch_url";
+    max_urls?: number | undefined;
+  } | {
+    [x: string]: unknown;
+    type: "people_search";
+  } | {
+    [x: string]: unknown;
+    type: "finance_search";
+  } | {
+    [x: string]: unknown;
+    type: "sandbox";
+  } | {
+    [x: string]: unknown;
+    type: "mcp";
+    server_label: string;
+    server_url: string;
+    allowed_tools?: string[] | undefined;
+    authorization?: string | undefined;
+    defer_loading?: boolean | undefined;
+    headers?: Record<string, string> | undefined;
+  } | {
+    [x: string]: unknown;
+    type: "connector";
+    id: string;
+    server_label: string;
+    server_description?: string | undefined;
+    allowed_tools?: string[] | undefined;
+  })[] | undefined;
+  models?: string[] | undefined;
+  max_steps?: number | undefined;
+  max_tool_calls?: number | undefined;
+  previous_response_id?: string | undefined;
+  store?: boolean | undefined;
+  language_preference?: string | undefined;
+  reasoning?: {
+    [x: string]: unknown;
+    effort?: "low" | "medium" | "high" | "minimal" | "xhigh" | undefined;
+  } | undefined;
+  skills?: ({
+    [x: string]: unknown;
+    type: "builtin";
+    name: "office" | "office/docx" | "office/pdf" | "office/pptx" | "office/xlsx";
+  } | {
+    [x: string]: unknown;
+    type: "inline";
+    name: string;
+    description: string;
+    instructions: string;
+  })[] | undefined;
+}>;
+type PerplexityLanguageModelOptions = InferSchema<typeof perplexityLanguageModelOptions>;
 //#endregion
 //#region src/version.d.ts
 export declare const VERSION: string;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["DecisionModelV4"],"sources":["../src/perplexity-decision-model-options.ts","../src/perplexity-embedding-model-options.ts","../src/perplexity-options.ts","../src/perplexity-provider.ts","../src/perplexity-language-model-options.ts","../src/version.ts"],"mappings":";;;;KAAY;;KAYA,iCAAiC;;;KCTjC;cAKC,iCAA+B,EAAA;;;;;;GAe1C,EAAA,KAAA;KAEU,kCAAkC,EAAE,aACvC;;;KC1BG;KAOA,4BACR;;;UCca,2BAA2B;;EAE1C,cAAc,SAAS,4BAA4BA;;;;GAKlD,SAAS,4BAA4B;;;;EAKtC,cAAc,SAAS,4BAA4B;;;;EAKnD,UAAU,SAAS,6BAA6B;;;;EAKhD,eAAe,SAAS,6BAA6B;;;;EAKrD,mBAAmB,SAAS,6BAA6B;;UAG1C;;;;EAIf;;;;EAKA;;;;EAKA,UAAU;;;;;EAMV,QAAQ;;wBAGM,iBACd,UAAS,6BACR;qBA2DU,YAAU;;;cC9EV,gCAA8B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DzC,EAAA,KAAA;KAEU,iCAAiC,EAAE,aACtC;;;qBCxHI"}
+{"version":3,"file":"index.d.ts","names":["DecisionModelV4"],"sources":["../src/perplexity-decision-model-options.ts","../src/perplexity-embedding-model-options.ts","../src/perplexity-options.ts","../src/perplexity-provider.ts","../src/perplexity-language-model-options.ts","../src/version.ts"],"mappings":";;;KAAY;;KAYA,iCAAiC;;;KCJjC;cAKC,kEAA+B;;;;KAqBhC,kCAAkC,mBACrC;;;KCnCG;KAOA,4BACR;;;UCca,2BAA2B;;EAE1C,cAAc,SAAS,4BAA4BA;;;;GAKlD,SAAS,4BAA4B;;;;EAKtC,cAAc,SAAS,4BAA4B;;;;EAKnD,UAAU,SAAS,6BAA6B;;;;EAKhD,eAAe,SAAS,6BAA6B;;;;EAKrD,mBAAmB,SAAS,6BAA6B;;UAG1C;;;;EAIf;;;;EAKA;;;;EAKA,UAAU;;;;;EAMV,QAAQ;;wBAGM,iBACd,UAAS,6BACR;qBA2DU,YAAU;;;cCrEV,iEAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqED,iCAAiC,mBACpC;;;qBCvII"}

package/dist/index.js

@@ -1,8 +1,8 @@
 import { APICallError, Experimental_DecisionUnsupportedQuestionTypeError, InvalidArgumentError, InvalidResponseDataError, NoSuchModelError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
-import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertBase64ToUint8Array, convertUint8ArrayToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createNullLanguageModelUsage, detectMediaType, generateId, getTopLevelMediaType, isCustomReasoning, isFullMediaType, loadApiKey, mapReasoningToProviderEffort, parseProviderOptions, postJsonToApi, resolve, resolveFullMediaType, serializeModelOptions, withUserAgentSuffix, withoutTrailingSlash } from "@ai-sdk/provider-utils";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertBase64ToUint8Array, convertUint8ArrayToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createNullLanguageModelUsage, detectMediaType, generateId, getTopLevelMediaType, isCustomReasoning, isFullMediaType, lazySchema, loadApiKey, mapReasoningToProviderEffort, parseProviderOptions, postJsonToApi, resolve, resolveFullMediaType, serializeModelOptions, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
 //#region src/perplexity-embedding-model-options.ts
-const perplexityEmbeddingModelOptions = z.object({
+const perplexityEmbeddingModelOptions = lazySchema(() => zodSchema(z.object({
 	/**
 	* The number of dimensions the resulting output embeddings should have
 	* (Matryoshka truncation). Ranges from 128 up to the model's full size
@@ -16,7 +16,7 @@ const perplexityEmbeddingModelOptions = z.object({
 	* - `base64_binary`: packed bits per byte (0-255), compare via Hamming distance.
 	*/
 	encodingFormat: z.enum(["base64_int8", "base64_binary"]).optional()
-});
+})));
 //#endregion
 //#region src/convert-perplexity-usage.ts
 function convertPerplexityUsage(usage) {
@@ -177,7 +177,7 @@ function mapPerplexityFinishReason({ status, incompleteReason, hasFunctionCall }
 }
 //#endregion
 //#region src/perplexity-agent-api.ts
-const perplexitySearchResultSchema = z.looseObject({
+const perplexitySearchResultSchema = () => z.looseObject({
 	id: z.number().optional(),
 	title: z.string(),
 	url: z.string(),
@@ -186,12 +186,12 @@ const perplexitySearchResultSchema = z.looseObject({
 	last_updated: z.string().nullish(),
 	source: z.string().optional()
 });
-const perplexityFetchedContentSchema = z.looseObject({
+const perplexityFetchedContentSchema = () => z.looseObject({
 	title: z.string(),
 	url: z.string(),
 	snippet: z.string().optional()
 });
-const perplexityContentPartSchema = z.looseObject({
+const perplexityContentPartSchema = () => z.looseObject({
 	type: z.string(),
 	text: z.string().optional(),
 	annotations: z.array(z.looseObject({
@@ -206,19 +206,19 @@ const handledOutputTypes = [
 	"fetch_url_results",
 	"function_call"
 ];
-const perplexityOutputItemSchema = z.union([
+const perplexityOutputItemSchema = () => z.union([
 	z.looseObject({
 		type: z.literal("message"),
 		id: z.string().nullish(),
-		content: z.array(perplexityContentPartSchema).nullish()
+		content: z.array(perplexityContentPartSchema()).nullish()
 	}),
 	z.looseObject({
 		type: z.literal("search_results"),
-		results: z.array(perplexitySearchResultSchema).nullish()
+		results: z.array(perplexitySearchResultSchema()).nullish()
 	}),
 	z.looseObject({
 		type: z.literal("fetch_url_results"),
-		contents: z.array(perplexityFetchedContentSchema).nullish()
+		contents: z.array(perplexityFetchedContentSchema()).nullish()
 	}),
 	z.looseObject({
 		type: z.literal("function_call"),
@@ -230,7 +230,7 @@ const perplexityOutputItemSchema = z.union([
 	}),
 	z.object({ type: z.string().refine((type) => !handledOutputTypes.includes(type)) }).transform(() => ({ type: "unhandled" }))
 ]);
-const perplexityCostSchema = z.looseObject({
+const perplexityCostSchema = () => z.looseObject({
 	currency: z.string().optional(),
 	input_cost: z.number().optional(),
 	output_cost: z.number().optional(),
@@ -239,7 +239,7 @@ const perplexityCostSchema = z.looseObject({
 	cache_read_cost: z.number().nullish(),
 	tool_calls_cost: z.number().nullish()
 });
-const perplexityUsageSchema = z.looseObject({
+const perplexityUsageSchema = () => z.looseObject({
 	input_tokens: z.number(),
 	output_tokens: z.number(),
 	total_tokens: z.number(),
@@ -250,14 +250,14 @@ const perplexityUsageSchema = z.looseObject({
 	}).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()
+	cost: perplexityCostSchema().nullish()
 });
-const perplexityAgentResponseSchema = z.looseObject({
+const perplexityAgentResponseSchema = () => z.looseObject({
 	id: z.string(),
 	created_at: z.number(),
 	model: z.string(),
 	object: z.literal("response"),
-	output: z.array(perplexityOutputItemSchema),
+	output: z.array(perplexityOutputItemSchema()),
 	status: z.string(),
 	incomplete_details: z.looseObject({ reason: z.string() }).nullish(),
 	error: z.looseObject({
@@ -265,13 +265,14 @@ const perplexityAgentResponseSchema = z.looseObject({
 		message: z.string(),
 		type: z.string().optional()
 	}).nullish(),
-	usage: perplexityUsageSchema.nullish()
+	usage: perplexityUsageSchema().nullish()
 });
-const perplexityAgentChunkSchema = z.looseObject({
+const perplexityAgentResponseSchemaValidator = lazySchema(() => zodSchema(perplexityAgentResponseSchema()));
+const perplexityAgentChunkSchema = lazySchema(() => zodSchema(z.looseObject({
 	type: z.string(),
 	sequence_number: z.number().nullish(),
-	response: perplexityAgentResponseSchema.nullish(),
-	item: perplexityOutputItemSchema.nullish(),
+	response: perplexityAgentResponseSchema().nullish(),
+	item: perplexityOutputItemSchema().nullish(),
 	output_index: z.number().nullish(),
 	item_id: z.string().nullish(),
 	content_index: z.number().nullish(),
@@ -280,15 +281,15 @@ const perplexityAgentChunkSchema = z.looseObject({
 	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(),
+	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()
-});
-const perplexityErrorSchema = z.looseObject({
+})));
+const perplexityErrorSchema = lazySchema(() => zodSchema(z.looseObject({
 	error: z.union([z.string(), z.looseObject({
 		code: z.union([z.string(), z.number()]).nullish(),
 		message: z.string().nullish(),
@@ -296,7 +297,7 @@ const perplexityErrorSchema = z.looseObject({
 	})]).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";
@@ -306,14 +307,14 @@ function perplexityErrorToMessage(data) {
 }
 //#endregion
 //#region src/perplexity-language-model-options.ts
-const userLocationSchema = z.looseObject({
+const userLocationSchema = () => z.looseObject({
 	latitude: z.number().optional(),
 	longitude: z.number().optional(),
 	country: z.string().optional(),
 	city: z.string().optional(),
 	region: z.string().optional()
 });
-const webSearchFiltersSchema = z.looseObject({
+const webSearchFiltersSchema = () => z.looseObject({
 	search_domain_filter: z.array(z.string()).optional(),
 	search_recency_filter: z.enum([
 		"hour",
@@ -327,9 +328,9 @@ const webSearchFiltersSchema = z.looseObject({
 	last_updated_after_filter: z.string().optional(),
 	last_updated_before_filter: z.string().optional()
 });
-const webSearchToolSchema = z.looseObject({
+const webSearchToolSchema = () => z.looseObject({
 	type: z.literal("web_search"),
-	filters: webSearchFiltersSchema.optional(),
+	filters: webSearchFiltersSchema().optional(),
 	max_results: z.number().int().positive().optional(),
 	max_tokens: z.number().optional(),
 	max_tokens_per_page: z.number().optional(),
@@ -338,10 +339,10 @@ const webSearchToolSchema = z.looseObject({
 		"medium",
 		"high"
 	]).optional(),
-	user_location: userLocationSchema.optional()
+	user_location: userLocationSchema().optional()
 });
-const nativeToolSchema = z.union([
-	webSearchToolSchema,
+const nativeToolSchema = () => z.union([
+	webSearchToolSchema(),
 	z.looseObject({
 		type: z.literal("fetch_url"),
 		max_urls: z.number().optional()
@@ -366,14 +367,14 @@ const nativeToolSchema = z.union([
 		allowed_tools: z.array(z.string()).optional()
 	})
 ]);
-const perplexityLanguageModelOptions = z.looseObject({
+const perplexityLanguageModelOptions = lazySchema(() => zodSchema(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(),
+	tools: z.array(nativeToolSchema()).optional(),
 	/** A fallback model list for Agent API routing. */
 	models: z.array(z.string()).optional(),
 	/** Maximum number of agentic steps. */
@@ -413,7 +414,7 @@ const perplexityLanguageModelOptions = z.looseObject({
 		description: z.string(),
 		instructions: z.string()
 	})])).optional()
-});
+})));
 //#endregion
 //#region src/perplexity-prepare-tools.ts
 function preparePerplexityTools({ tools, toolChoice }) {
@@ -626,7 +627,7 @@ var PerplexityLanguageModel = class PerplexityLanguageModel {
 				errorSchema: perplexityErrorSchema,
 				errorToMessage: perplexityErrorToMessage
 			}),
-			successfulResponseHandler: createJsonResponseHandler(perplexityAgentResponseSchema),
+			successfulResponseHandler: createJsonResponseHandler(perplexityAgentResponseSchemaValidator),
 			abortSignal: options.abortSignal,
 			fetch: this.config.fetch
 		});
@@ -1078,7 +1079,7 @@ function decodeEmbedding(base64, encodingFormat) {
 	}
 	return Array.from(bytes);
 }
-const perplexityEmbeddingResponseSchema = z.object({
+const perplexityEmbeddingResponseSchema = lazySchema(() => zodSchema(z.object({
 	data: z.array(z.object({ embedding: z.string() })),
 	usage: z.object({
 		prompt_tokens: z.number(),
@@ -1088,7 +1089,7 @@ const perplexityEmbeddingResponseSchema = z.object({
 			currency: z.string().nullish()
 		}).nullish()
 	}).nullish()
-});
+})));
 //#endregion
 //#region src/convert-to-perplexity-decision-state.ts
 function convertToPerplexityDecisionState(state) {
@@ -1157,7 +1158,7 @@ var DecisionPerplexityModel = class DecisionPerplexityModel {
 	static [WORKFLOW_DESERIALIZE](options) {
 		return new DecisionPerplexityModel(options.modelId, options.config);
 	}
-	async doDecide({ state, questions, headers, abortSignal, providerOptions }) {
+	async doDecide({ state, questions, maxOutputTokens, reasoning, headers, abortSignal, providerOptions }) {
 		const entries = Object.entries(questions);
 		if (entries.length === 0 || entries.length > 128) throw new InvalidArgumentError({
 			argument: "questions",
@@ -1241,10 +1242,20 @@ var DecisionPerplexityModel = class DecisionPerplexityModel {
 				inputTokens: response.usage.input_tokens ?? void 0,
 				outputTokens: response.usage.output_tokens ?? void 0
 			},
-			warnings: Object.keys(providerOptions?.perplexity ?? {}).map((option) => ({
-				type: "unsupported",
-				feature: `providerOptions.perplexity.${option}`
-			})),
+			warnings: [
+				...maxOutputTokens != null ? [{
+					type: "unsupported",
+					feature: "maxOutputTokens"
+				}] : [],
+				...reasoning != null ? [{
+					type: "unsupported",
+					feature: "reasoning"
+				}] : [],
+				...Object.keys(providerOptions?.perplexity ?? {}).map((option) => ({
+					type: "unsupported",
+					feature: `providerOptions.perplexity.${option}`
+				}))
+			],
 			providerMetadata: { perplexity: {
 				confidence: Object.fromEntries(Object.entries(response.answers).flatMap(([id, answer]) => answer.type !== "noul" && answer.confidence != null ? [[id, answer.confidence]] : [])),
 				legend: Object.fromEntries(Object.entries(response.answers).flatMap(([id, answer]) => answer.type === "score" && answer.legend != null ? [[id, answer.legend]] : []))
@@ -1258,25 +1269,25 @@ var DecisionPerplexityModel = class DecisionPerplexityModel {
 		};
 	}
 };
-const probability = z.number().min(0).max(1);
-const perplexityDecisionResponseSchema = z.object({
+const probability = () => z.number().min(0).max(1);
+const perplexityDecisionResponseSchema = lazySchema(() => zodSchema(z.object({
 	model: z.string().nullish(),
 	answers: z.record(z.string(), z.discriminatedUnion("type", [
 		z.object({
 			type: z.literal("noul"),
-			noul: probability
+			noul: probability()
 		}),
 		z.object({
 			type: z.literal("choice"),
 			choice: z.string(),
-			probabilities: z.record(z.string(), probability),
-			confidence: probability.nullish()
+			probabilities: z.record(z.string(), probability()),
+			confidence: probability().nullish()
 		}),
 		z.object({
 			type: z.literal("score"),
 			score: z.number(),
-			probabilities: z.record(z.string(), probability),
-			confidence: probability.nullish(),
+			probabilities: z.record(z.string(), probability()),
+			confidence: probability().nullish(),
 			legend: z.record(z.string(), z.json()).nullish()
 		})
 	])),
@@ -1284,10 +1295,10 @@ const perplexityDecisionResponseSchema = z.object({
 		input_tokens: z.number().nullish(),
 		output_tokens: z.number().nullish()
 	}).nullish()
-});
+})));
 //#endregion
 //#region src/version.ts
-const VERSION = "5.0.15";
+const VERSION = "5.0.17";
 //#endregion
 //#region src/perplexity-provider.ts
 function createPerplexity(options = {}) {