@ai-sdk/perplexity 5.0.14 → 5.0.16

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @ai-sdk/perplexity
 
+## 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
+
+- 60cc252: feat(perplexity): add decisions api support
+- Updated dependencies [60cc252]
+  - @ai-sdk/provider@4.0.30
+  - @ai-sdk/provider-utils@5.0.63
+
 ## 5.0.14
 
 ### Patch Changes

package/README.md

@@ -10,6 +10,7 @@ contains language model support for Perplexity's Agent API, including web search
 - Direct access to supported third-party models through Perplexity
 - Native tools for web search, URL fetching, code execution, finance, MCP, and connectors
 - AI SDK function tools, structured output, reasoning streams, and multi-turn tool calls
+- Native Choice, Score, and Boolean decisions with probability distributions and image input
 
 > **Deploying to Vercel?** With Vercel's AI Gateway you can access Perplexity (and hundreds of models from other providers) — no additional packages, API keys, or extra cost. [Get started with AI Gateway](https://vercel.com/ai-gateway).
 
@@ -58,6 +59,31 @@ Perplexity supports Sonar Chat Completions only until September 27, 2026.
 Remaining on version 4 will not preserve language generation after that date.
 Migrate unsupported Sonar features using the alternatives in the migration notes.
 
+## Decisions
+
+```ts
+import { perplexity } from '@ai-sdk/perplexity';
+import { experimental_decide as decide } from 'ai';
+
+const result = await decide({
+  model: perplexity.decisionModel('pplx-decider-latest'),
+  state: 'I was charged twice.',
+  questions: {
+    team: {
+      type: 'choice',
+      criteria: { billing: 'Payments and refunds', support: 'Other requests' },
+    },
+  },
+});
+
+console.log(result.answers.team.choice);
+console.log(result.answers.team.probabilities);
+```
+
+See [decision model documentation](https://ai-sdk.dev/providers/ai-sdk-providers/perplexity#decision-models)
+for optional instructions, structured criteria, single-level Score rubrics,
+images, limits, and provider metadata.
+
 ## Documentation
 
 Please check out the **[Perplexity provider documentation](https://ai-sdk.dev/providers/ai-sdk-providers/perplexity)** for more information.

package/dist/index.d.ts

@@ -1,6 +1,11 @@
-import { EmbeddingModelV4, LanguageModelV4, ProviderV4 } from "@ai-sdk/provider";
+import { EmbeddingModelV4, Experimental_DecisionModelV4, LanguageModelV4, ProviderV4 } from "@ai-sdk/provider";
 import { FetchFunction } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
+//#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. */
+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<{
@@ -18,6 +23,8 @@ type PerplexityLanguageModelId = PerplexityAgentPreset | 'perplexity/sonar' | (s
 //#endregion
 //#region src/perplexity-provider.d.ts
 interface PerplexityProvider extends ProviderV4 {
+  /** Creates an experimental decision model using the Perplexity Decisions API. */
+  decisionModel(modelId: PerplexityDecisionModelId): Experimental_DecisionModelV4;
   /**
    * Creates a Perplexity Agent API model or preset for text generation.
    */
@@ -171,5 +178,5 @@ type PerplexityLanguageModelOptions = z.infer<typeof perplexityLanguageModelOpti
 //#region src/version.d.ts
 export declare const VERSION: string;
 //#endregion
-export type { PerplexityAgentPreset, PerplexityEmbeddingModelId, PerplexityEmbeddingModelOptions, PerplexityLanguageModelId, PerplexityLanguageModelOptions, PerplexityProvider, PerplexityProviderSettings };
+export type { PerplexityAgentPreset, PerplexityDecisionModelId, PerplexityDecisionModelOptions, PerplexityEmbeddingModelId, PerplexityEmbeddingModelOptions, PerplexityLanguageModelId, PerplexityLanguageModelOptions, PerplexityProvider, PerplexityProviderSettings };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/perplexity-embedding-model-options.ts","../src/perplexity-options.ts","../src/perplexity-provider.ts","../src/perplexity-language-model-options.ts","../src/version.ts"],"mappings":";;;;KAGY;cAKC,iCAA+B,EAAA;;;;;;GAe1C,EAAA,KAAA;KAEU,kCAAkC,EAAE,aACvC;;;KC1BG;KAOA,4BACR;;;UCWa,2BAA2B;;;;GAIzC,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;qBAoDU,YAAU;;;cCjEV,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;;;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"}

package/dist/index.js

@@ -1,5 +1,5 @@
-import { APICallError, NoSuchModelError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
-import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertBase64ToUint8Array, convertUint8ArrayToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createNullLanguageModelUsage, generateId, getTopLevelMediaType, isCustomReasoning, loadApiKey, mapReasoningToProviderEffort, parseProviderOptions, postJsonToApi, resolveFullMediaType, serializeModelOptions, withUserAgentSuffix, withoutTrailingSlash } from "@ai-sdk/provider-utils";
+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 { z } from "zod/v4";
 //#region src/perplexity-embedding-model-options.ts
 const perplexityEmbeddingModelOptions = z.object({
@@ -290,7 +290,7 @@ const perplexityAgentChunkSchema = z.looseObject({
 });
 const perplexityErrorSchema = z.looseObject({
 	error: z.union([z.string(), z.looseObject({
-		code: z.union([z.string(), z.number()]).optional(),
+		code: z.union([z.string(), z.number()]).nullish(),
 		message: z.string().nullish(),
 		type: z.string().nullish()
 	})]).optional(),
@@ -1090,8 +1090,214 @@ const perplexityEmbeddingResponseSchema = z.object({
 	}).nullish()
 });
 //#endregion
+//#region src/convert-to-perplexity-decision-state.ts
+function convertToPerplexityDecisionState(state) {
+	const parts = state.map((part) => {
+		switch (part.type) {
+			case "text": return part.text;
+			case "json": return part.value;
+			case "file": {
+				if (part.data.type !== "data") throw new UnsupportedFunctionalityError({ functionality: `Perplexity decision file input: ${part.data.type}` });
+				const mediaType = isFullMediaType(part.mediaType) ? part.mediaType : detectMediaType({
+					data: part.data.data,
+					topLevelType: "image"
+				});
+				if (![
+					"image/png",
+					"image/jpeg",
+					"image/webp"
+				].includes(mediaType ?? "")) throw new UnsupportedFunctionalityError({ functionality: `Perplexity decision image media type: ${part.mediaType}` });
+				return {
+					type: "image_url",
+					image_url: { url: `data:${mediaType};base64,${typeof part.data.data === "string" ? part.data.data : convertUint8ArrayToBase64(part.data.data)}` }
+				};
+			}
+		}
+	});
+	if (countImages(parts) > 8) throw new InvalidArgumentError({
+		argument: "state",
+		message: "Perplexity Decisions supports at most 8 images in the shared state."
+	});
+	const single = parts[0];
+	return parts.length === 1 && single !== null && (typeof single === "string" || typeof single === "object") ? single : parts;
+}
+function countImages(value) {
+	if (Array.isArray(value)) return value.reduce((count, item) => count + countImages(item), 0);
+	if (value === null || typeof value !== "object") return 0;
+	const object = value;
+	if (object.type === "image_url") {
+		const image = object.image_url;
+		if (image == null || typeof image !== "object" || Array.isArray(image) || typeof image.url !== "string" || !/^data:image\/(png|jpeg|webp);base64,/i.test(image.url)) throw new UnsupportedFunctionalityError({ functionality: "Perplexity decision images require PNG, JPEG, or WebP base64 data URLs" });
+		return 1;
+	}
+	return Object.values(value).reduce((count, item) => count + (item === void 0 ? 0 : countImages(item)), 0);
+}
+//#endregion
+//#region src/perplexity-decision-model.ts
+var DecisionPerplexityModel = class DecisionPerplexityModel {
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v4";
+		this.supportedQuestionTypes = [
+			"choice",
+			"score",
+			"boolean"
+		];
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	static [WORKFLOW_SERIALIZE](model) {
+		return serializeModelOptions({
+			modelId: model.modelId,
+			config: model.config
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new DecisionPerplexityModel(options.modelId, options.config);
+	}
+	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",
+			message: "Perplexity Decisions supports 1 to 128 questions per request."
+		});
+		const nativeQuestions = Object.fromEntries(entries.map(([id, question]) => {
+			if (id.length === 0) throw new InvalidArgumentError({
+				argument: "questions",
+				message: "Perplexity Decisions requires non-empty question names."
+			});
+			switch (question.type) {
+				case "boolean": return [id, {
+					type: "noul",
+					instructions: question.instructions,
+					criteria: question.criteria
+				}];
+				case "choice": {
+					const count = Object.keys(question.criteria).length;
+					if (count === 0 || count > 255) throw new InvalidArgumentError({
+						argument: `questions.${id}.criteria`,
+						message: "Perplexity Choice questions support 1 to 255 options."
+					});
+					return [id, {
+						type: "choice",
+						instructions: question.instructions,
+						criteria: question.criteria
+					}];
+				}
+				case "score":
+					if (question.criteria.length === 0 || question.criteria.length > 10 || question.criteria.some((level) => level === null)) throw new InvalidArgumentError({
+						argument: `questions.${id}.criteria`,
+						message: "Perplexity Score questions require 1 to 10 non-null levels."
+					});
+					return [id, {
+						type: "score",
+						instructions: question.instructions,
+						criteria: question.criteria
+					}];
+				default: throw new Experimental_DecisionUnsupportedQuestionTypeError({
+					questionId: id,
+					questionType: question.type,
+					provider: this.provider,
+					modelId: this.modelId
+				});
+			}
+		}));
+		const { value: response, rawValue, responseHeaders } = await postJsonToApi({
+			url: `${this.config.baseURL}/v1/decisions`,
+			headers: combineHeaders(await resolve(this.config.headers), headers),
+			body: {
+				model: this.modelId,
+				state: convertToPerplexityDecisionState(state),
+				questions: nativeQuestions
+			},
+			abortSignal,
+			fetch: this.config.fetch,
+			failedResponseHandler: createJsonErrorResponseHandler({
+				errorSchema: perplexityErrorSchema,
+				errorToMessage: perplexityErrorToMessage
+			}),
+			successfulResponseHandler: createJsonResponseHandler(perplexityDecisionResponseSchema)
+		});
+		if (Object.keys(response.answers).length !== entries.length || entries.some(([id]) => !Object.prototype.hasOwnProperty.call(response.answers, id))) throw new InvalidResponseDataError({
+			data: rawValue,
+			message: "Perplexity Decisions must return exactly one answer for every question."
+		});
+		return {
+			answers: Object.fromEntries(Object.entries(response.answers).map(([id, answer]) => [id, answer.type === "noul" ? {
+				type: "boolean",
+				probability: answer.noul
+			} : answer.type === "choice" ? {
+				type: "choice",
+				choice: answer.choice,
+				probabilities: answer.probabilities
+			} : {
+				type: "score",
+				score: answer.score,
+				probabilities: answer.probabilities
+			}])),
+			usage: response.usage == null ? void 0 : {
+				inputTokens: response.usage.input_tokens ?? void 0,
+				outputTokens: response.usage.output_tokens ?? void 0
+			},
+			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]] : []))
+			} },
+			response: {
+				id: responseHeaders?.["x-request-id"],
+				modelId: response.model ?? this.modelId,
+				headers: responseHeaders,
+				body: rawValue
+			}
+		};
+	}
+};
+const probability = z.number().min(0).max(1);
+const perplexityDecisionResponseSchema = z.object({
+	model: z.string().nullish(),
+	answers: z.record(z.string(), z.discriminatedUnion("type", [
+		z.object({
+			type: z.literal("noul"),
+			noul: probability
+		}),
+		z.object({
+			type: z.literal("choice"),
+			choice: z.string(),
+			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(),
+			legend: z.record(z.string(), z.json()).nullish()
+		})
+	])),
+	usage: z.object({
+		input_tokens: z.number().nullish(),
+		output_tokens: z.number().nullish()
+	}).nullish()
+});
+//#endregion
 //#region src/version.ts
-const VERSION = "5.0.14";
+const VERSION = "5.0.16";
 //#endregion
 //#region src/perplexity-provider.ts
 function createPerplexity(options = {}) {
@@ -1122,6 +1328,12 @@ function createPerplexity(options = {}) {
 	const provider = (modelId) => createLanguageModel(modelId);
 	provider.specificationVersion = "v4";
 	provider.languageModel = createLanguageModel;
+	provider.decisionModel = (modelId) => new DecisionPerplexityModel(modelId, {
+		provider: "perplexity.decision",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
 	provider.embedding = createEmbeddingModel;
 	provider.embeddingModel = createEmbeddingModel;
 	provider.textEmbeddingModel = createEmbeddingModel;