@effect-uai/perplexity 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Betalyra Sociedade Unipessoal Lda.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/PerplexitySearch.d.mts

@@ -0,0 +1,49 @@
+import { PerplexitySearchContextSize } from "./models.mjs";
+import { Context, Effect, Layer, Redacted } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import * as AiError from "@effect-uai/core/AiError";
+import { CommonSearchRequest, SearchResponse, WebSearch } from "@effect-uai/core/WebSearch";
+
+//#region src/PerplexitySearch.d.ts
+declare namespace PerplexitySearch_d_exports {
+  export { Config, PerplexitySearch, PerplexitySearchRequest, PerplexitySearchService, layer, make };
+}
+/**
+ * Perplexity-typed search request. Widens {@link CommonSearchRequest} with
+ * the provider's own knobs; the common fields map onto Perplexity's wire
+ * filters (see the codec below). There is no `model` - `/search` ranks the
+ * web directly.
+ */
+type PerplexitySearchRequest = CommonSearchRequest & {
+  /** Depth / cost trade-off - see {@link PerplexitySearchContextSize}. */readonly searchContextSize?: PerplexitySearchContextSize; /** Cap on tokens extracted per result page (1..1_000_000). */
+  readonly maxTokensPerPage?: number;
+};
+type PerplexitySearchService = {
+  readonly search: (request: PerplexitySearchRequest) => Effect.Effect<SearchResponse, AiError.AiError>;
+};
+declare const PerplexitySearch_base: Context.ServiceClass<PerplexitySearch, "@betalyra/effect-uai/providers/perplexity/PerplexitySearch", PerplexitySearchService>;
+/**
+ * Provider-typed service tag. Yield this for Perplexity-typed search
+ * (`searchContextSize`, `maxTokensPerPage`); yield the generic `WebSearch`
+ * tag for provider-portable code. Both are registered by {@link layer}.
+ */
+declare class PerplexitySearch extends PerplexitySearch_base {}
+type Config = {
+  readonly apiKey: Redacted.Redacted;
+  readonly baseUrl?: string;
+};
+/**
+ * Build a `PerplexitySearchService` value. For Layer-based setup, prefer
+ * {@link layer}.
+ */
+declare const make: (cfg: Config) => Effect.Effect<PerplexitySearchService, never, HttpClient.HttpClient>;
+/**
+ * Layer registering both the provider-typed `PerplexitySearch` tag and the
+ * generic `WebSearch` tag over one implementation. A `CommonSearchRequest`
+ * is structurally a `PerplexitySearchRequest` with the provider extras
+ * unset, so the generic registration forwards directly.
+ */
+declare const layer: (cfg: Config) => Layer.Layer<PerplexitySearch | WebSearch, never, HttpClient.HttpClient>;
+//#endregion
+export { Config, PerplexitySearch, PerplexitySearchRequest, PerplexitySearchService, layer, make, PerplexitySearch_d_exports as t };
+//# sourceMappingURL=PerplexitySearch.d.mts.map

package/dist/PerplexitySearch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerplexitySearch.d.mts","names":[],"sources":["../src/PerplexitySearch.ts"],"mappings":";;;;;;;;;;;;;;;;KAsBY,uBAAA,GAA0B,mBAAA;mFAE3B,iBAAA,GAAoB,2BAAA;WAEpB,gBAAA;AAAA;AAAA,KAGC,uBAAA;EAAA,SACD,MAAA,GACP,OAAA,EAAS,uBAAA,KACN,MAAA,CAAO,MAAA,CAAO,cAAA,EAAgB,OAAA,CAAQ,OAAA;AAAA;AAAA,cAC5C,qBAAA;;;;;;cAOY,gBAAA,SAAyB,qBAAA;AAAA,KAI1B,MAAA;EAAA,SACD,MAAA,EAAQ,QAAA,CAAS,QAAA;EAAA,SACjB,OAAA;AAAA;;;;;cAkKE,IAAA,GACX,GAAA,EAAK,MAAA,KACJ,MAAA,CAAO,MAAA,CAAO,uBAAA,SAAgC,UAAA,CAAW,UAAA;;;;;;;cAY/C,KAAA,GACX,GAAA,EAAK,MAAA,KACJ,KAAA,CAAM,KAAA,CAAM,gBAAA,GAAmB,SAAA,SAAkB,UAAA,CAAW,UAAA"}

package/dist/PerplexitySearch.mjs

@@ -0,0 +1,146 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { Context, DateTime, Effect, Layer, Option, Schema } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import * as AiError from "@effect-uai/core/AiError";
+import { WebSearch } from "@effect-uai/core/WebSearch";
+//#region src/PerplexitySearch.ts
+var PerplexitySearch_exports = /* @__PURE__ */ __exportAll({
+	PerplexitySearch: () => PerplexitySearch,
+	layer: () => layer,
+	make: () => make
+});
+/**
+* Provider-typed service tag. Yield this for Perplexity-typed search
+* (`searchContextSize`, `maxTokensPerPage`); yield the generic `WebSearch`
+* tag for provider-portable code. Both are registered by {@link layer}.
+*/
+var PerplexitySearch = class extends Context.Service()("@betalyra/effect-uai/providers/perplexity/PerplexitySearch") {};
+/** Perplexity wants dates as `MM/DD/YYYY`, in UTC. */
+const formatMmDdYyyy = (dt) => {
+	const d = DateTime.toDateUtc(dt);
+	return `${String(d.getUTCMonth() + 1).padStart(2, "0")}/${String(d.getUTCDate()).padStart(2, "0")}/${d.getUTCFullYear()}`;
+};
+/**
+* Perplexity has no separate include / exclude fields - it takes one
+* `search_domain_filter` array where an exclusion is a `-` prefix. Lossless
+* shape transform, so done silently (bucket 3).
+*/
+const domainFilter = (include, exclude) => {
+	const all = [...include ?? [], ...(exclude ?? []).map((d) => `-${d}`)];
+	return all.length > 0 ? all : void 0;
+};
+const buildBody = (request) => {
+	const domains = domainFilter(request.includeDomains, request.excludeDomains);
+	return {
+		query: request.query,
+		...request.maxResults !== void 0 && { max_results: request.maxResults },
+		...request.country !== void 0 && { country: request.country },
+		...request.language !== void 0 && { search_language_filter: [request.language] },
+		...domains !== void 0 && { search_domain_filter: domains },
+		...request.recency !== void 0 && { search_recency_filter: request.recency },
+		...request.startDate !== void 0 && { search_after_date_filter: formatMmDdYyyy(request.startDate) },
+		...request.endDate !== void 0 && { search_before_date_filter: formatMmDdYyyy(request.endDate) },
+		...request.searchContextSize !== void 0 && { search_context_size: request.searchContextSize },
+		...request.maxTokensPerPage !== void 0 && { max_tokens_per_page: request.maxTokensPerPage }
+	};
+};
+const WireResult = Schema.Struct({
+	title: Schema.String,
+	url: Schema.String,
+	snippet: Schema.optional(Schema.String),
+	date: Schema.optional(Schema.NullOr(Schema.String)),
+	last_updated: Schema.optional(Schema.NullOr(Schema.String))
+});
+const WireResponse = Schema.Struct({
+	results: Schema.Array(WireResult),
+	id: Schema.optional(Schema.String)
+});
+/** Lenient parse of Perplexity's date strings; unparseable -> omitted. */
+const parseDate = (s) => s == null ? void 0 : Option.getOrUndefined(DateTime.make(s));
+const toResult = (r) => {
+	const publishedDate = parseDate(r.date);
+	return {
+		url: r.url,
+		title: r.title,
+		...r.snippet !== void 0 && { snippet: r.snippet },
+		...publishedDate !== void 0 && { publishedDate },
+		raw: r
+	};
+};
+const toResponse = (wire) => ({
+	results: wire.results.map(toResult),
+	raw: wire
+});
+const transportFailure = (cause) => new AiError.Unavailable({
+	provider: "perplexity",
+	raw: cause
+});
+const httpStatusError = (status, body) => {
+	const provider = "perplexity";
+	const raw = body;
+	if (status === 429) return new AiError.RateLimited({
+		provider,
+		raw
+	});
+	if (status === 408 || status === 504) return new AiError.Timeout({
+		provider,
+		raw
+	});
+	if (status === 401) return new AiError.AuthFailed({
+		provider,
+		subtype: "auth",
+		raw
+	});
+	if (status === 403) return new AiError.AuthFailed({
+		provider,
+		subtype: "permission",
+		raw
+	});
+	if (status === 402) return new AiError.AuthFailed({
+		provider,
+		subtype: "billing",
+		raw
+	});
+	if (status >= 500) return new AiError.Unavailable({
+		provider,
+		status,
+		raw
+	});
+	return new AiError.InvalidRequest({
+		provider,
+		raw
+	});
+};
+const baseUrl = (cfg) => cfg.baseUrl ?? "https://api.perplexity.ai";
+const postSearch = (cfg, body) => Effect.gen(function* () {
+	const client = yield* HttpClient.HttpClient;
+	const httpRequest = HttpClientRequest.post(`${baseUrl(cfg)}/search`).pipe(HttpClientRequest.bearerToken(cfg.apiKey), HttpClientRequest.bodyJsonUnsafe(body));
+	const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure));
+	if (response.status >= 400) {
+		const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""));
+		return yield* httpStatusError(response.status, text);
+	}
+	const json = yield* response.json.pipe(Effect.mapError(transportFailure));
+	return yield* Schema.decodeUnknownEffect(WireResponse)(json).pipe(Effect.mapError(transportFailure));
+});
+const searchImpl = (cfg) => (request) => postSearch(cfg, buildBody(request)).pipe(Effect.map(toResponse));
+/**
+* Build a `PerplexitySearchService` value. For Layer-based setup, prefer
+* {@link layer}.
+*/
+const make = (cfg) => Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({ search: (request) => searchImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)) }));
+/**
+* Layer registering both the provider-typed `PerplexitySearch` tag and the
+* generic `WebSearch` tag over one implementation. A `CommonSearchRequest`
+* is structurally a `PerplexitySearchRequest` with the provider extras
+* unset, so the generic registration forwards directly.
+*/
+const layer = (cfg) => {
+	const typed = Layer.effect(PerplexitySearch, make(cfg));
+	const generic = Layer.effect(WebSearch, Effect.map(make(cfg), (s) => ({ search: (request) => s.search(request) })));
+	return Layer.merge(typed, generic);
+};
+//#endregion
+export { PerplexitySearch, layer, make, PerplexitySearch_exports as t };
+
+//# sourceMappingURL=PerplexitySearch.mjs.map

package/dist/PerplexitySearch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerplexitySearch.mjs","names":[],"sources":["../src/PerplexitySearch.ts"],"sourcesContent":["import { Context, DateTime, Effect, Layer, Option, type Redacted, Schema } from \"effect\"\nimport { HttpClient, HttpClientRequest } from \"effect/unstable/http\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport {\n  type CommonSearchRequest,\n  type SearchResponse,\n  type SearchResult,\n  WebSearch,\n  type WebSearchService,\n} from \"@effect-uai/core/WebSearch\"\nimport type { PerplexitySearchContextSize } from \"./models.js\"\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\n/**\n * Perplexity-typed search request. Widens {@link CommonSearchRequest} with\n * the provider's own knobs; the common fields map onto Perplexity's wire\n * filters (see the codec below). There is no `model` - `/search` ranks the\n * web directly.\n */\nexport type PerplexitySearchRequest = CommonSearchRequest & {\n  /** Depth / cost trade-off - see {@link PerplexitySearchContextSize}. */\n  readonly searchContextSize?: PerplexitySearchContextSize\n  /** Cap on tokens extracted per result page (1..1_000_000). */\n  readonly maxTokensPerPage?: number\n}\n\nexport type PerplexitySearchService = {\n  readonly search: (\n    request: PerplexitySearchRequest,\n  ) => Effect.Effect<SearchResponse, AiError.AiError>\n}\n\n/**\n * Provider-typed service tag. Yield this for Perplexity-typed search\n * (`searchContextSize`, `maxTokensPerPage`); yield the generic `WebSearch`\n * tag for provider-portable code. Both are registered by {@link layer}.\n */\nexport class PerplexitySearch extends Context.Service<PerplexitySearch, PerplexitySearchService>()(\n  \"@betalyra/effect-uai/providers/perplexity/PerplexitySearch\",\n) {}\n\nexport type Config = {\n  readonly apiKey: Redacted.Redacted\n  readonly baseUrl?: string\n}\n\n// ---------------------------------------------------------------------------\n// Codec - request body\n// ---------------------------------------------------------------------------\n\ntype WireBody = {\n  readonly query: string\n  readonly max_results?: number\n  readonly country?: string\n  readonly search_language_filter?: ReadonlyArray<string>\n  readonly search_domain_filter?: ReadonlyArray<string>\n  readonly search_recency_filter?: string\n  readonly search_after_date_filter?: string\n  readonly search_before_date_filter?: string\n  readonly search_context_size?: string\n  readonly max_tokens_per_page?: number\n}\n\n/** Perplexity wants dates as `MM/DD/YYYY`, in UTC. */\nconst formatMmDdYyyy = (dt: DateTime.DateTime): string => {\n  const d = DateTime.toDateUtc(dt)\n  const mm = String(d.getUTCMonth() + 1).padStart(2, \"0\")\n  const dd = String(d.getUTCDate()).padStart(2, \"0\")\n  return `${mm}/${dd}/${d.getUTCFullYear()}`\n}\n\n/**\n * Perplexity has no separate include / exclude fields - it takes one\n * `search_domain_filter` array where an exclusion is a `-` prefix. Lossless\n * shape transform, so done silently (bucket 3).\n */\nconst domainFilter = (\n  include: ReadonlyArray<string> | undefined,\n  exclude: ReadonlyArray<string> | undefined,\n): ReadonlyArray<string> | undefined => {\n  const all = [...(include ?? []), ...(exclude ?? []).map((d) => `-${d}`)]\n  return all.length > 0 ? all : undefined\n}\n\nconst buildBody = (request: PerplexitySearchRequest): WireBody => {\n  const domains = domainFilter(request.includeDomains, request.excludeDomains)\n  return {\n    query: request.query,\n    ...(request.maxResults !== undefined && { max_results: request.maxResults }),\n    ...(request.country !== undefined && { country: request.country }),\n    ...(request.language !== undefined && { search_language_filter: [request.language] }),\n    ...(domains !== undefined && { search_domain_filter: domains }),\n    ...(request.recency !== undefined && { search_recency_filter: request.recency }),\n    ...(request.startDate !== undefined && {\n      search_after_date_filter: formatMmDdYyyy(request.startDate),\n    }),\n    ...(request.endDate !== undefined && {\n      search_before_date_filter: formatMmDdYyyy(request.endDate),\n    }),\n    ...(request.searchContextSize !== undefined && {\n      search_context_size: request.searchContextSize,\n    }),\n    ...(request.maxTokensPerPage !== undefined && {\n      max_tokens_per_page: request.maxTokensPerPage,\n    }),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Codec - response\n// ---------------------------------------------------------------------------\n\nconst WireResult = Schema.Struct({\n  title: Schema.String,\n  url: Schema.String,\n  snippet: Schema.optional(Schema.String),\n  date: Schema.optional(Schema.NullOr(Schema.String)),\n  last_updated: Schema.optional(Schema.NullOr(Schema.String)),\n})\ntype WireResult = typeof WireResult.Type\n\nconst WireResponse = Schema.Struct({\n  results: Schema.Array(WireResult),\n  id: Schema.optional(Schema.String),\n})\ntype WireResponse = typeof WireResponse.Type\n\n/** Lenient parse of Perplexity's date strings; unparseable -> omitted. */\nconst parseDate = (s: string | null | undefined): DateTime.DateTime | undefined =>\n  s == null ? undefined : Option.getOrUndefined(DateTime.make(s))\n\nconst toResult = (r: WireResult): SearchResult => {\n  const publishedDate = parseDate(r.date)\n  return {\n    url: r.url,\n    title: r.title,\n    // Perplexity returns no relevance score, so `score` stays undefined.\n    ...(r.snippet !== undefined && { snippet: r.snippet }),\n    ...(publishedDate !== undefined && { publishedDate }),\n    raw: r,\n  }\n}\n\nconst toResponse = (wire: WireResponse): SearchResponse => ({\n  results: wire.results.map(toResult),\n  raw: wire,\n})\n\n// ---------------------------------------------------------------------------\n// HTTP\n// ---------------------------------------------------------------------------\n\nconst transportFailure = (cause: unknown): AiError.AiError =>\n  new AiError.Unavailable({ provider: \"perplexity\", raw: cause })\n\nconst httpStatusError = (status: number, body: string): AiError.AiError => {\n  const provider = \"perplexity\"\n  const raw = body\n  if (status === 429) return new AiError.RateLimited({ provider, raw })\n  if (status === 408 || status === 504) return new AiError.Timeout({ provider, raw })\n  if (status === 401) return new AiError.AuthFailed({ provider, subtype: \"auth\", raw })\n  if (status === 403) return new AiError.AuthFailed({ provider, subtype: \"permission\", raw })\n  if (status === 402) return new AiError.AuthFailed({ provider, subtype: \"billing\", raw })\n  if (status >= 500) return new AiError.Unavailable({ provider, status, raw })\n  return new AiError.InvalidRequest({ provider, raw })\n}\n\nconst baseUrl = (cfg: Config): string => cfg.baseUrl ?? \"https://api.perplexity.ai\"\n\nconst postSearch = (\n  cfg: Config,\n  body: WireBody,\n): Effect.Effect<WireResponse, AiError.AiError, HttpClient.HttpClient> =>\n  Effect.gen(function* () {\n    const client = yield* HttpClient.HttpClient\n    const httpRequest = HttpClientRequest.post(`${baseUrl(cfg)}/search`).pipe(\n      HttpClientRequest.bearerToken(cfg.apiKey),\n      HttpClientRequest.bodyJsonUnsafe(body),\n    )\n    const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))\n    if (response.status >= 400) {\n      const text = yield* response.text.pipe(Effect.orElseSucceed(() => \"\"))\n      return yield* httpStatusError(response.status, text)\n    }\n    const json = yield* response.json.pipe(Effect.mapError(transportFailure))\n    return yield* Schema.decodeUnknownEffect(WireResponse)(json).pipe(\n      Effect.mapError(transportFailure),\n    )\n  })\n\nconst searchImpl =\n  (cfg: Config) =>\n  (\n    request: PerplexitySearchRequest,\n  ): Effect.Effect<SearchResponse, AiError.AiError, HttpClient.HttpClient> =>\n    postSearch(cfg, buildBody(request)).pipe(Effect.map(toResponse))\n\n// ---------------------------------------------------------------------------\n// Constructors\n// ---------------------------------------------------------------------------\n\n/**\n * Build a `PerplexitySearchService` value. For Layer-based setup, prefer\n * {@link layer}.\n */\nexport const make = (\n  cfg: Config,\n): Effect.Effect<PerplexitySearchService, never, HttpClient.HttpClient> =>\n  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({\n    search: (request) =>\n      searchImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),\n  }))\n\n/**\n * Layer registering both the provider-typed `PerplexitySearch` tag and the\n * generic `WebSearch` tag over one implementation. A `CommonSearchRequest`\n * is structurally a `PerplexitySearchRequest` with the provider extras\n * unset, so the generic registration forwards directly.\n */\nexport const layer = (\n  cfg: Config,\n): Layer.Layer<PerplexitySearch | WebSearch, never, HttpClient.HttpClient> => {\n  const typed = Layer.effect(PerplexitySearch, make(cfg))\n  const generic = Layer.effect(\n    WebSearch,\n    Effect.map(make(cfg), (s): WebSearchService => ({ search: (request) => s.search(request) })),\n  )\n  return Layer.merge(typed, generic)\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAwCA,IAAa,mBAAb,cAAsC,QAAQ,SAAoD,CAChG,6DACD,CAAC;;AAyBF,MAAM,kBAAkB,OAAkC;CACxD,MAAM,IAAI,SAAS,UAAU,GAAG;AAGhC,QAAO,GAFI,OAAO,EAAE,aAAa,GAAG,EAAE,CAAC,SAAS,GAAG,IAEvC,CAAC,GADF,OAAO,EAAE,YAAY,CAAC,CAAC,SAAS,GAAG,IAC5B,CAAC,GAAG,EAAE,gBAAgB;;;;;;;AAQ1C,MAAM,gBACJ,SACA,YACsC;CACtC,MAAM,MAAM,CAAC,GAAI,WAAW,EAAE,EAAG,IAAI,WAAW,EAAE,EAAE,KAAK,MAAM,IAAI,IAAI,CAAC;AACxE,QAAO,IAAI,SAAS,IAAI,MAAM,KAAA;;AAGhC,MAAM,aAAa,YAA+C;CAChE,MAAM,UAAU,aAAa,QAAQ,gBAAgB,QAAQ,eAAe;AAC5E,QAAO;EACL,OAAO,QAAQ;EACf,GAAI,QAAQ,eAAe,KAAA,KAAa,EAAE,aAAa,QAAQ,YAAY;EAC3E,GAAI,QAAQ,YAAY,KAAA,KAAa,EAAE,SAAS,QAAQ,SAAS;EACjE,GAAI,QAAQ,aAAa,KAAA,KAAa,EAAE,wBAAwB,CAAC,QAAQ,SAAS,EAAE;EACpF,GAAI,YAAY,KAAA,KAAa,EAAE,sBAAsB,SAAS;EAC9D,GAAI,QAAQ,YAAY,KAAA,KAAa,EAAE,uBAAuB,QAAQ,SAAS;EAC/E,GAAI,QAAQ,cAAc,KAAA,KAAa,EACrC,0BAA0B,eAAe,QAAQ,UAAU,EAC5D;EACD,GAAI,QAAQ,YAAY,KAAA,KAAa,EACnC,2BAA2B,eAAe,QAAQ,QAAQ,EAC3D;EACD,GAAI,QAAQ,sBAAsB,KAAA,KAAa,EAC7C,qBAAqB,QAAQ,mBAC9B;EACD,GAAI,QAAQ,qBAAqB,KAAA,KAAa,EAC5C,qBAAqB,QAAQ,kBAC9B;EACF;;AAOH,MAAM,aAAa,OAAO,OAAO;CAC/B,OAAO,OAAO;CACd,KAAK,OAAO;CACZ,SAAS,OAAO,SAAS,OAAO,OAAO;CACvC,MAAM,OAAO,SAAS,OAAO,OAAO,OAAO,OAAO,CAAC;CACnD,cAAc,OAAO,SAAS,OAAO,OAAO,OAAO,OAAO,CAAC;CAC5D,CAAC;AAGF,MAAM,eAAe,OAAO,OAAO;CACjC,SAAS,OAAO,MAAM,WAAW;CACjC,IAAI,OAAO,SAAS,OAAO,OAAO;CACnC,CAAC;;AAIF,MAAM,aAAa,MACjB,KAAK,OAAO,KAAA,IAAY,OAAO,eAAe,SAAS,KAAK,EAAE,CAAC;AAEjE,MAAM,YAAY,MAAgC;CAChD,MAAM,gBAAgB,UAAU,EAAE,KAAK;AACvC,QAAO;EACL,KAAK,EAAE;EACP,OAAO,EAAE;EAET,GAAI,EAAE,YAAY,KAAA,KAAa,EAAE,SAAS,EAAE,SAAS;EACrD,GAAI,kBAAkB,KAAA,KAAa,EAAE,eAAe;EACpD,KAAK;EACN;;AAGH,MAAM,cAAc,UAAwC;CAC1D,SAAS,KAAK,QAAQ,IAAI,SAAS;CACnC,KAAK;CACN;AAMD,MAAM,oBAAoB,UACxB,IAAI,QAAQ,YAAY;CAAE,UAAU;CAAc,KAAK;CAAO,CAAC;AAEjE,MAAM,mBAAmB,QAAgB,SAAkC;CACzE,MAAM,WAAW;CACjB,MAAM,MAAM;AACZ,KAAI,WAAW,IAAK,QAAO,IAAI,QAAQ,YAAY;EAAE;EAAU;EAAK,CAAC;AACrE,KAAI,WAAW,OAAO,WAAW,IAAK,QAAO,IAAI,QAAQ,QAAQ;EAAE;EAAU;EAAK,CAAC;AACnF,KAAI,WAAW,IAAK,QAAO,IAAI,QAAQ,WAAW;EAAE;EAAU,SAAS;EAAQ;EAAK,CAAC;AACrF,KAAI,WAAW,IAAK,QAAO,IAAI,QAAQ,WAAW;EAAE;EAAU,SAAS;EAAc;EAAK,CAAC;AAC3F,KAAI,WAAW,IAAK,QAAO,IAAI,QAAQ,WAAW;EAAE;EAAU,SAAS;EAAW;EAAK,CAAC;AACxF,KAAI,UAAU,IAAK,QAAO,IAAI,QAAQ,YAAY;EAAE;EAAU;EAAQ;EAAK,CAAC;AAC5E,QAAO,IAAI,QAAQ,eAAe;EAAE;EAAU;EAAK,CAAC;;AAGtD,MAAM,WAAW,QAAwB,IAAI,WAAW;AAExD,MAAM,cACJ,KACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,WAAW;CACjC,MAAM,cAAc,kBAAkB,KAAK,GAAG,QAAQ,IAAI,CAAC,SAAS,CAAC,KACnE,kBAAkB,YAAY,IAAI,OAAO,EACzC,kBAAkB,eAAe,KAAK,CACvC;CACD,MAAM,WAAW,OAAO,OAAO,QAAQ,YAAY,CAAC,KAAK,OAAO,SAAS,iBAAiB,CAAC;AAC3F,KAAI,SAAS,UAAU,KAAK;EAC1B,MAAM,OAAO,OAAO,SAAS,KAAK,KAAK,OAAO,oBAAoB,GAAG,CAAC;AACtE,SAAO,OAAO,gBAAgB,SAAS,QAAQ,KAAK;;CAEtD,MAAM,OAAO,OAAO,SAAS,KAAK,KAAK,OAAO,SAAS,iBAAiB,CAAC;AACzE,QAAO,OAAO,OAAO,oBAAoB,aAAa,CAAC,KAAK,CAAC,KAC3D,OAAO,SAAS,iBAAiB,CAClC;EACD;AAEJ,MAAM,cACH,SAEC,YAEA,WAAW,KAAK,UAAU,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,WAAW,CAAC;;;;;AAUpE,MAAa,QACX,QAEA,OAAO,IAAI,WAAW,WAAW,UAAU,GAAG,YAAY,EACxD,SAAS,YACP,WAAW,IAAI,CAAC,QAAQ,CAAC,KAAK,OAAO,eAAe,WAAW,YAAY,OAAO,CAAC,EACtF,EAAE;;;;;;;AAQL,MAAa,SACX,QAC4E;CAC5E,MAAM,QAAQ,MAAM,OAAO,kBAAkB,KAAK,IAAI,CAAC;CACvD,MAAM,UAAU,MAAM,OACpB,WACA,OAAO,IAAI,KAAK,IAAI,GAAG,OAAyB,EAAE,SAAS,YAAY,EAAE,OAAO,QAAQ,EAAE,EAAE,CAC7F;AACD,QAAO,MAAM,MAAM,OAAO,QAAQ"}

package/dist/chunk-CfYAbeIz.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { PerplexitySearchContextSize } from "./models.mjs";
+import { t as PerplexitySearch_d_exports } from "./PerplexitySearch.mjs";
+export { PerplexitySearch_d_exports as PerplexitySearch, PerplexitySearchContextSize };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { t as PerplexitySearch_exports } from "./PerplexitySearch.mjs";
+import "./models.mjs";
+export { PerplexitySearch_exports as PerplexitySearch };

package/dist/models.d.mts

@@ -0,0 +1,17 @@
+//#region src/models.d.ts
+/**
+ * Perplexity's Search API takes no model identifier - unlike chat
+ * completions, `/search` ranks the web directly. The one mode knob is the
+ * search-context size, which trades latency / cost for depth.
+ *
+ * - `low` — fastest, fewest pages fetched.
+ * - `medium` — balanced.
+ * - `high` — most thorough (Perplexity's default).
+ *
+ * It is a provider-specific knob, so it lives on `PerplexitySearchRequest`
+ * rather than the cross-provider `CommonSearchRequest`.
+ */
+type PerplexitySearchContextSize = "low" | "medium" | "high";
+//#endregion
+export { PerplexitySearchContextSize };
+//# sourceMappingURL=models.d.mts.map

package/dist/models.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;AAYA;;;;;;;;;;;KAAY,2BAAA"}

package/dist/models.mjs

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@effect-uai/perplexity",
+  "version": "0.7.0",
+  "description": "Perplexity provider for @effect-uai/core (web search).",
+  "keywords": [
+    "ai",
+    "effect",
+    "perplexity",
+    "search",
+    "web-search"
+  ],
+  "homepage": "https://github.com/betalyra/effect-uai/tree/main/packages/providers/perplexity",
+  "bugs": {
+    "url": "https://github.com/betalyra/effect-uai/issues"
+  },
+  "license": "MIT",
+  "author": "Betalyra",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/betalyra/effect-uai",
+    "directory": "packages/providers/perplexity"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./PerplexitySearch": {
+      "types": "./dist/PerplexitySearch.d.mts",
+      "import": "./dist/PerplexitySearch.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "effect": "4.0.0-beta.57",
+    "typescript": "^6.0.3",
+    "@effect-uai/core": "0.7.0"
+  },
+  "peerDependencies": {
+    "@effect-uai/core": ">=0.2.0 <1",
+    "effect": "4.0.0-beta.57"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/PerplexitySearch.ts

@@ -0,0 +1,232 @@
+import { Context, DateTime, Effect, Layer, Option, type Redacted, Schema } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import * as AiError from "@effect-uai/core/AiError"
+import {
+  type CommonSearchRequest,
+  type SearchResponse,
+  type SearchResult,
+  WebSearch,
+  type WebSearchService,
+} from "@effect-uai/core/WebSearch"
+import type { PerplexitySearchContextSize } from "./models.js"
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/**
+ * Perplexity-typed search request. Widens {@link CommonSearchRequest} with
+ * the provider's own knobs; the common fields map onto Perplexity's wire
+ * filters (see the codec below). There is no `model` - `/search` ranks the
+ * web directly.
+ */
+export type PerplexitySearchRequest = CommonSearchRequest & {
+  /** Depth / cost trade-off - see {@link PerplexitySearchContextSize}. */
+  readonly searchContextSize?: PerplexitySearchContextSize
+  /** Cap on tokens extracted per result page (1..1_000_000). */
+  readonly maxTokensPerPage?: number
+}
+
+export type PerplexitySearchService = {
+  readonly search: (
+    request: PerplexitySearchRequest,
+  ) => Effect.Effect<SearchResponse, AiError.AiError>
+}
+
+/**
+ * Provider-typed service tag. Yield this for Perplexity-typed search
+ * (`searchContextSize`, `maxTokensPerPage`); yield the generic `WebSearch`
+ * tag for provider-portable code. Both are registered by {@link layer}.
+ */
+export class PerplexitySearch extends Context.Service<PerplexitySearch, PerplexitySearchService>()(
+  "@betalyra/effect-uai/providers/perplexity/PerplexitySearch",
+) {}
+
+export type Config = {
+  readonly apiKey: Redacted.Redacted
+  readonly baseUrl?: string
+}
+
+// ---------------------------------------------------------------------------
+// Codec - request body
+// ---------------------------------------------------------------------------
+
+type WireBody = {
+  readonly query: string
+  readonly max_results?: number
+  readonly country?: string
+  readonly search_language_filter?: ReadonlyArray<string>
+  readonly search_domain_filter?: ReadonlyArray<string>
+  readonly search_recency_filter?: string
+  readonly search_after_date_filter?: string
+  readonly search_before_date_filter?: string
+  readonly search_context_size?: string
+  readonly max_tokens_per_page?: number
+}
+
+/** Perplexity wants dates as `MM/DD/YYYY`, in UTC. */
+const formatMmDdYyyy = (dt: DateTime.DateTime): string => {
+  const d = DateTime.toDateUtc(dt)
+  const mm = String(d.getUTCMonth() + 1).padStart(2, "0")
+  const dd = String(d.getUTCDate()).padStart(2, "0")
+  return `${mm}/${dd}/${d.getUTCFullYear()}`
+}
+
+/**
+ * Perplexity has no separate include / exclude fields - it takes one
+ * `search_domain_filter` array where an exclusion is a `-` prefix. Lossless
+ * shape transform, so done silently (bucket 3).
+ */
+const domainFilter = (
+  include: ReadonlyArray<string> | undefined,
+  exclude: ReadonlyArray<string> | undefined,
+): ReadonlyArray<string> | undefined => {
+  const all = [...(include ?? []), ...(exclude ?? []).map((d) => `-${d}`)]
+  return all.length > 0 ? all : undefined
+}
+
+const buildBody = (request: PerplexitySearchRequest): WireBody => {
+  const domains = domainFilter(request.includeDomains, request.excludeDomains)
+  return {
+    query: request.query,
+    ...(request.maxResults !== undefined && { max_results: request.maxResults }),
+    ...(request.country !== undefined && { country: request.country }),
+    ...(request.language !== undefined && { search_language_filter: [request.language] }),
+    ...(domains !== undefined && { search_domain_filter: domains }),
+    ...(request.recency !== undefined && { search_recency_filter: request.recency }),
+    ...(request.startDate !== undefined && {
+      search_after_date_filter: formatMmDdYyyy(request.startDate),
+    }),
+    ...(request.endDate !== undefined && {
+      search_before_date_filter: formatMmDdYyyy(request.endDate),
+    }),
+    ...(request.searchContextSize !== undefined && {
+      search_context_size: request.searchContextSize,
+    }),
+    ...(request.maxTokensPerPage !== undefined && {
+      max_tokens_per_page: request.maxTokensPerPage,
+    }),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Codec - response
+// ---------------------------------------------------------------------------
+
+const WireResult = Schema.Struct({
+  title: Schema.String,
+  url: Schema.String,
+  snippet: Schema.optional(Schema.String),
+  date: Schema.optional(Schema.NullOr(Schema.String)),
+  last_updated: Schema.optional(Schema.NullOr(Schema.String)),
+})
+type WireResult = typeof WireResult.Type
+
+const WireResponse = Schema.Struct({
+  results: Schema.Array(WireResult),
+  id: Schema.optional(Schema.String),
+})
+type WireResponse = typeof WireResponse.Type
+
+/** Lenient parse of Perplexity's date strings; unparseable -> omitted. */
+const parseDate = (s: string | null | undefined): DateTime.DateTime | undefined =>
+  s == null ? undefined : Option.getOrUndefined(DateTime.make(s))
+
+const toResult = (r: WireResult): SearchResult => {
+  const publishedDate = parseDate(r.date)
+  return {
+    url: r.url,
+    title: r.title,
+    // Perplexity returns no relevance score, so `score` stays undefined.
+    ...(r.snippet !== undefined && { snippet: r.snippet }),
+    ...(publishedDate !== undefined && { publishedDate }),
+    raw: r,
+  }
+}
+
+const toResponse = (wire: WireResponse): SearchResponse => ({
+  results: wire.results.map(toResult),
+  raw: wire,
+})
+
+// ---------------------------------------------------------------------------
+// HTTP
+// ---------------------------------------------------------------------------
+
+const transportFailure = (cause: unknown): AiError.AiError =>
+  new AiError.Unavailable({ provider: "perplexity", raw: cause })
+
+const httpStatusError = (status: number, body: string): AiError.AiError => {
+  const provider = "perplexity"
+  const raw = body
+  if (status === 429) return new AiError.RateLimited({ provider, raw })
+  if (status === 408 || status === 504) return new AiError.Timeout({ provider, raw })
+  if (status === 401) return new AiError.AuthFailed({ provider, subtype: "auth", raw })
+  if (status === 403) return new AiError.AuthFailed({ provider, subtype: "permission", raw })
+  if (status === 402) return new AiError.AuthFailed({ provider, subtype: "billing", raw })
+  if (status >= 500) return new AiError.Unavailable({ provider, status, raw })
+  return new AiError.InvalidRequest({ provider, raw })
+}
+
+const baseUrl = (cfg: Config): string => cfg.baseUrl ?? "https://api.perplexity.ai"
+
+const postSearch = (
+  cfg: Config,
+  body: WireBody,
+): Effect.Effect<WireResponse, AiError.AiError, HttpClient.HttpClient> =>
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient
+    const httpRequest = HttpClientRequest.post(`${baseUrl(cfg)}/search`).pipe(
+      HttpClientRequest.bearerToken(cfg.apiKey),
+      HttpClientRequest.bodyJsonUnsafe(body),
+    )
+    const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
+    if (response.status >= 400) {
+      const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
+      return yield* httpStatusError(response.status, text)
+    }
+    const json = yield* response.json.pipe(Effect.mapError(transportFailure))
+    return yield* Schema.decodeUnknownEffect(WireResponse)(json).pipe(
+      Effect.mapError(transportFailure),
+    )
+  })
+
+const searchImpl =
+  (cfg: Config) =>
+  (
+    request: PerplexitySearchRequest,
+  ): Effect.Effect<SearchResponse, AiError.AiError, HttpClient.HttpClient> =>
+    postSearch(cfg, buildBody(request)).pipe(Effect.map(toResponse))
+
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a `PerplexitySearchService` value. For Layer-based setup, prefer
+ * {@link layer}.
+ */
+export const make = (
+  cfg: Config,
+): Effect.Effect<PerplexitySearchService, never, HttpClient.HttpClient> =>
+  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+    search: (request) =>
+      searchImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+  }))
+
+/**
+ * Layer registering both the provider-typed `PerplexitySearch` tag and the
+ * generic `WebSearch` tag over one implementation. A `CommonSearchRequest`
+ * is structurally a `PerplexitySearchRequest` with the provider extras
+ * unset, so the generic registration forwards directly.
+ */
+export const layer = (
+  cfg: Config,
+): Layer.Layer<PerplexitySearch | WebSearch, never, HttpClient.HttpClient> => {
+  const typed = Layer.effect(PerplexitySearch, make(cfg))
+  const generic = Layer.effect(
+    WebSearch,
+    Effect.map(make(cfg), (s): WebSearchService => ({ search: (request) => s.search(request) })),
+  )
+  return Layer.merge(typed, generic)
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * as PerplexitySearch from "./PerplexitySearch.js"
+export * from "./models.js"

package/src/models.ts

@@ -0,0 +1,13 @@
+/**
+ * Perplexity's Search API takes no model identifier - unlike chat
+ * completions, `/search` ranks the web directly. The one mode knob is the
+ * search-context size, which trades latency / cost for depth.
+ *
+ * - `low` — fastest, fewest pages fetched.
+ * - `medium` — balanced.
+ * - `high` — most thorough (Perplexity's default).
+ *
+ * It is a provider-specific knob, so it lives on `PerplexitySearchRequest`
+ * rather than the cross-provider `CommonSearchRequest`.
+ */
+export type PerplexitySearchContextSize = "low" | "medium" | "high"