thaipass 0.0.0 → 0.1.0

package/dist/index.js

@@ -1,9 +1,1379 @@
-// src/index.ts
-var name = "thaipass";
-var description = "AI SDK provider for AI Pass, using your own session cookie.";
-var src_default = { name, description };
-export {
-  src_default as default,
-  description,
-  name
+import { APICallError, NoSuchModelError } from "@ai-sdk/provider";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { parseJsonEventStream } from "@ai-sdk/provider-utils";
+//#region ../core/src/aipass/models.ts
+/**
+* The chat ids the proxy knew when it was built. The account's catalog on
+* `/loaders/list-models` decides what a chat request may name. This list
+* stands in when the catalog cannot be read, seeds the docs, and feeds the
+* drift warning. A media id needs per-model knowledge the catalog does not
+* carry, so the media lists below stay the gate for their routes.
+*/
+const CHAT_MODELS = [
+	"gpt-5.6-terra",
+	"gpt-5.6-sol",
+	"claude-opus-5@azure",
+	"claude-sonnet-5@default",
+	"gemini-3.1-pro-preview",
+	"gemini-3.7-flash",
+	"gemini-3.1-flash-lite",
+	"glm-5.2",
+	"grok-4.3",
+	"DeepSeek-V3.2",
+	"minimax-m2-maas",
+	"qwen3-next-80b-a3b-instruct-maas",
+	"Kimi-K2.7-Code",
+	"Mistral-Large-3",
+	"Mistral-Medium-3",
+	"Llama-4-Scout-17B-16E-Instruct-1",
+	"Llama-4-Maverick-17B-128E-Instruct-FP8-1",
+	"pathumma-thaillm-8b",
+	"openai-deep-research",
+	"openthai2.0-legal@jts",
+	"sonar",
+	"sonar-reasoning-pro",
+	"sonar-deep-research"
+];
+/**
+* AI Pass has no model category on `/loaders/list-models`; the web UI builds
+* its tabs client-side, so the split lives here. Video is its own list
+* because it is a polled job rather than a stream.
+*/
+const IMAGE_MODELS = [
+	"gpt-image-2",
+	"gemini-3-pro-image",
+	"gemini-2.5-flash-image",
+	"seedream-4.0",
+	"seedream-5.0-lite"
+];
+const VIDEO_MODELS = [
+	"seedance-2.0",
+	"seedance-2.0-fast",
+	"seedance-2.0-mini",
+	"veo-3.1-fast-generate-001"
+];
+const MUSIC_MODELS = ["lyria-3-pro-preview", "lyria-3-clip-preview"];
+const MEDIA_MODELS = [
+	...IMAGE_MODELS,
+	...VIDEO_MODELS,
+	...MUSIC_MODELS
+];
+z.enum(IMAGE_MODELS, { error: "unknown image model, see GET /v1/models" });
+z.enum(VIDEO_MODELS, { error: "unknown video model, see GET /v1/models" });
+z.enum(MUSIC_MODELS, { error: "unknown music model, see GET /v1/models" });
+const KINDS = new Map([
+	...IMAGE_MODELS.map((id) => [id, "image"]),
+	...VIDEO_MODELS.map((id) => [id, "video"]),
+	...MUSIC_MODELS.map((id) => [id, "music"])
+]);
+const kindOf = (modelId) => KINDS.get(modelId) ?? "chat";
+z.string().min(1, { error: "model must not be empty, see GET /v1/models" }).meta({
+	description: "A chat model id from GET /v1/models. Ids are case-sensitive and Claude carries a @provider suffix.",
+	examples: [...CHAT_MODELS]
+});
+const DEFAULT_MODEL = "gemini-3.1-flash-lite";
+const ANY_MODELS = [...CHAT_MODELS, ...MEDIA_MODELS];
+z.enum(ANY_MODELS, { error: "unknown model, see GET /v1/models" });
+const current = {
+	origin: "https://de.aipass.net",
+	userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36"
 };
+const config = current;
+/** Process-wide; the server calls it once at startup, a library consumer when the defaults are wrong. */
+const configure = (changes) => {
+	Object.assign(current, changes);
+};
+//#endregion
+//#region ../core/src/lib/cache.ts
+const ttlCache = (ttlMs) => {
+	const entries = /* @__PURE__ */ new Map();
+	return {
+		get: (key) => {
+			const now = Date.now();
+			for (const [id, entry] of entries) if (entry.expiresAt <= now) entries.delete(id);
+			return entries.get(key)?.value;
+		},
+		set: (key, value) => {
+			entries.set(key, {
+				expiresAt: Date.now() + ttlMs,
+				value
+			});
+		}
+	};
+};
+//#endregion
+//#region ../core/src/aipass/request.ts
+const browserGetHeaders = (cookie, referer) => ({
+	accept: "*/*",
+	"accept-language": "th-TH,th;q=0.9,en;q=0.8",
+	cookie,
+	origin: config.origin,
+	referer,
+	"sec-fetch-dest": "empty",
+	"sec-fetch-mode": "cors",
+	"sec-fetch-site": "same-origin",
+	"user-agent": config.userAgent
+});
+const browserPostHeaders = (cookie, referer, contentType) => ({
+	...browserGetHeaders(cookie, referer),
+	"content-type": contentType
+});
+/** Headers for a JSON action made from inside one conversation's page. */
+const conversationJsonHeaders = (cookie, conversationId) => browserPostHeaders(cookie, `${config.origin}/chat/${conversationId}`, "application/json");
+const loadJson = async (path, schema, cookie, signal) => {
+	let payload;
+	try {
+		const response = await fetch(`${config.origin}${path}`, {
+			headers: browserGetHeaders(cookie, `${config.origin}/chat`),
+			redirect: "manual",
+			signal
+		});
+		if (!response.ok) return null;
+		payload = await response.json();
+	} catch {
+		return null;
+	}
+	const decoded = schema.safeParse(payload);
+	return decoded.success ? decoded.data : null;
+};
+//#endregion
+//#region ../core/src/aipass/catalog.ts
+const CATALOG_PATH = "/loaders/list-models";
+const CACHE_TTL_MS = 3e5;
+const catalogSchema = z.object({ data: z.array(z.object({
+	id: z.string(),
+	isFreeCredit: z.boolean().optional(),
+	ready: z.boolean().optional(),
+	thinkingConfig: z.object({ supportedLevels: z.array(z.string()).optional() }).optional()
+})) });
+const cache = ttlCache(CACHE_TTL_MS);
+const knownChat = new Set(CHAT_MODELS);
+const served = /* @__PURE__ */ new Set([...CHAT_MODELS, ...MEDIA_MODELS]);
+const MEDIA_ROUTES = {
+	image: "/v1/images/generations",
+	music: "/v1/audio/generations",
+	video: "/v1/videos"
+};
+/**
+* Why a chat request may not name the model, or null when it may. The
+* account's catalog decides: an id upstream added after the build passes,
+* and one upstream retired does not. When the catalog cannot be read the
+* built-in list stands in rather than refusing everything.
+*/
+const chatModelProblem = (model, catalog) => {
+	const kind = kindOf(model);
+	if (kind !== "chat") return `${model} makes ${kind}, send it to ${MEDIA_ROUTES[kind]}`;
+	if (catalog) return catalog.has(model) ? null : `unknown model ${model}, the account's catalog does not list it, see GET /v1/models`;
+	return knownChat.has(model) ? null : `unknown model ${model}, see GET /v1/models`;
+};
+const reportDrift = (catalog) => {
+	const unknown = [...catalog.keys()].filter((id) => !served.has(id));
+	if (unknown.length > 0) config.logger?.warn({
+		models: unknown.join(", "),
+		msg: "catalog has unserved models"
+	});
+};
+const load = async (cookie, signal) => {
+	const listed = await loadJson(CATALOG_PATH, catalogSchema, cookie, signal);
+	if (!listed) return null;
+	return new Map(listed.data.map((entry) => [entry.id, {
+		free: entry.isFreeCredit ?? false,
+		ready: entry.ready ?? true,
+		thinking: entry.thinkingConfig?.supportedLevels ?? null
+	}]));
+};
+const fetchCatalog = async (clientId, cookie, signal) => {
+	const cached = cache.get(clientId);
+	if (cached) return cached;
+	const catalog = await load(cookie, signal);
+	if (!catalog) return null;
+	cache.set(clientId, catalog);
+	reportDrift(catalog);
+	return catalog;
+};
+//#endregion
+//#region ../core/src/aipass/refusal.ts
+/**
+* The AI Pass edge answers some requests itself with a 403 before the chat
+* backend runs, scoring what the prompt contains rather than its length. A
+* retry of the same body gets the same verdict, so the proxy reports it as a
+* request error and hands back the edge's own body, since the trigger set is
+* undocumented.
+*/
+const EDGE_REFUSAL_STATUS = 403;
+const EDGE_REFUSAL_HINT = "; the AI Pass edge refused this before the model ran, on what the prompt contains rather than how long it is — resending the same text will be refused again";
+const isEdgeRefusal = (status) => status === EDGE_REFUSAL_STATUS;
+//#endregion
+//#region ../core/src/aipass/upload.ts
+/**
+* Three calls: `initiate` reserves a place and answers with a signed bucket
+* URL, the bytes go there with a plain PUT and no cookie, and `confirm` tells
+* AI Pass the object landed. Only the storage key travels on the message.
+*/
+const INITIATE_PATH = "/actions/upload-file/initiate";
+const CONFIRM_PATH = "/actions/upload-file/confirm";
+/** What the upstream composer accepts. */
+const MAX_ATTACHMENT_BYTES = 20971520;
+const initiateSchema = z.object({
+	error: z.string().optional(),
+	sizeBytes: z.number().optional(),
+	storageKey: z.string(),
+	uploadToken: z.string(),
+	uploadUrl: z.string()
+});
+const confirmSchema = z.object({
+	error: z.string().optional(),
+	storageKey: z.string().optional()
+});
+var UploadError = class extends Error {
+	name = "UploadError";
+};
+const readJson = async (response, schema, step) => {
+	if (!response.ok) {
+		const detail = await response.text().catch(() => "");
+		throw new UploadError(`upload ${step} returned ${response.status}: ${detail.slice(0, 200)}`);
+	}
+	const parsed = schema.safeParse(await response.json().catch(() => null));
+	if (!parsed.success) throw new UploadError(`upload ${step} answered in an unreadable shape`);
+	return parsed.data;
+};
+/** The bucket answers 412 when a retry re-sends bytes that already landed. */
+const PRECONDITION_FAILED = 412;
+const uploadAttachment = async (cookie, conversationId, modelId, attachment, signal) => {
+	const { bytes, filename, mediaType } = attachment;
+	if (bytes.length > 20971520) throw new UploadError(`${filename} is ${bytes.length} bytes, over the ${MAX_ATTACHMENT_BYTES} byte limit`);
+	const initiated = await readJson(await fetch(`${config.origin}${INITIATE_PATH}`, {
+		body: JSON.stringify({
+			contentFilename: filename,
+			contentType: mediaType,
+			conversationId,
+			filename,
+			modelId,
+			sizeBytes: bytes.length
+		}),
+		headers: conversationJsonHeaders(cookie, conversationId),
+		method: "POST",
+		redirect: "manual",
+		signal
+	}), initiateSchema, "initiate");
+	if (initiated.error) throw new UploadError(`upload initiate refused: ${initiated.error}`);
+	const putHeaders = { "content-type": mediaType };
+	if (initiated.sizeBytes !== void 0) {
+		putHeaders["x-goog-content-length-range"] = `${initiated.sizeBytes},${initiated.sizeBytes}`;
+		putHeaders["x-goog-if-generation-match"] = "0";
+	}
+	const put = await fetch(initiated.uploadUrl, {
+		body: new Blob([bytes], { type: mediaType }),
+		headers: new Headers(Object.entries(putHeaders)),
+		method: "PUT",
+		signal
+	});
+	await put.arrayBuffer().catch(() => /* @__PURE__ */ new ArrayBuffer(0));
+	if (!put.ok && put.status !== PRECONDITION_FAILED) throw new UploadError(`upload PUT returned ${put.status}`);
+	const confirmed = await readJson(await fetch(`${config.origin}${CONFIRM_PATH}`, {
+		body: JSON.stringify({ uploadToken: initiated.uploadToken }),
+		headers: conversationJsonHeaders(cookie, conversationId),
+		method: "POST",
+		redirect: "manual",
+		signal
+	}), confirmSchema, "confirm");
+	if (confirmed.error) throw new UploadError(`upload confirm refused: ${confirmed.error}`);
+	return {
+		filename,
+		mediaType,
+		storageKey: confirmed.storageKey ?? initiated.storageKey
+	};
+};
+//#endregion
+//#region ../core/src/aipass/client.ts
+const CONVERSATION_ID_LENGTH = 16;
+const TITLE_PREVIEW_LENGTH = 400;
+const postAction = (cookie, path, referer, fields, signal) => fetch(`${config.origin}${path}`, {
+	body: new URLSearchParams(fields).toString(),
+	headers: browserPostHeaders(cookie, referer, "application/x-www-form-urlencoded;charset=UTF-8"),
+	method: "POST",
+	redirect: "manual",
+	signal
+});
+/** Frees the socket for a response nobody is going to read. */
+const drain = async (response) => {
+	await response.arrayBuffer().catch(() => /* @__PURE__ */ new ArrayBuffer(0));
+	return response.status;
+};
+const createConversation = async (cookie, reqUuid, modelId, text, signal) => {
+	const title = text.slice(0, TITLE_PREVIEW_LENGTH) || "hi";
+	const response = await postAction(cookie, "/chat.data", `${config.origin}/chat`, {
+		clientCreateRequestId: reqUuid,
+		folderId: "",
+		intent: "create-conversation",
+		message: title,
+		modelId
+	}, signal);
+	const conversationId = reqUuid.replaceAll("-", "").slice(0, CONVERSATION_ID_LENGTH);
+	/**
+	* The title carries the head of the prompt, so the edge can refuse the
+	* conversation here before any turn is sent.
+	*/
+	if (isEdgeRefusal(response.status)) return {
+		conversationId,
+		refusal: response
+	};
+	await drain(response);
+	return {
+		conversationId,
+		refusal: null
+	};
+};
+const deleteConversation = async (cookie, conversationId) => {
+	try {
+		const status = await drain(await postAction(cookie, "/actions/update-conversation.data", `${config.origin}/chat/${conversationId}`, {
+			conversationId,
+			intent: "delete"
+		}));
+		if (status >= 400) config.logger?.warn({
+			conversationId,
+			msg: "delete rejected",
+			status
+		});
+	} catch (error) {
+		config.logger?.warn({
+			conversationId,
+			err: String(error),
+			msg: "delete failed"
+		});
+	}
+};
+const sendBody = (modelId, messages, options) => {
+	const body = {
+		messages,
+		modelId
+	};
+	if (options.imageAspectRatio) body.imageAspectRatio = options.imageAspectRatio;
+	if (options.thinkingLevel) body.thinkingLevel = options.thinkingLevel;
+	return body;
+};
+const lastText = (messages) => messages.at(-1)?.parts.find((part) => part.type === "text")?.text ?? "";
+/** The composer puts attachments above the prompt, so files go first. */
+const withFiles = (messages, files) => messages.map((message, index) => index === messages.length - 1 ? {
+	...message,
+	parts: [...files, ...message.parts]
+} : message);
+const sendMessage = async (cookie, modelId, messages, signal, options = {}) => {
+	const { conversationId, refusal } = await createConversation(cookie, crypto.randomUUID(), modelId, lastText(messages), signal);
+	if (refusal) return {
+		conversationId,
+		created: false,
+		response: refusal
+	};
+	const uploaded = await Promise.all((options.attachments ?? []).map(async (attachment) => {
+		const file = await uploadAttachment(cookie, conversationId, modelId, attachment, signal);
+		return {
+			filename: file.filename,
+			mediaType: file.mediaType,
+			storageKey: file.storageKey,
+			type: "file",
+			url: file.storageKey
+		};
+	}));
+	const sent = uploaded.length > 0 ? withFiles(messages, uploaded) : messages;
+	return {
+		conversationId,
+		created: true,
+		response: await fetch(`${config.origin}/actions/send-message/${conversationId}`, {
+			body: JSON.stringify(sendBody(modelId, sent, options)),
+			headers: conversationJsonHeaders(cookie, conversationId),
+			method: "POST",
+			redirect: "manual",
+			signal
+		})
+	};
+};
+//#endregion
+//#region ../core/src/aipass/media.ts
+const INLINE_CAP = {
+	audio: 26214400,
+	file: 10485760,
+	image: 5242880,
+	video: 52428800
+};
+/** Music carries `url`; video carries only `snapshotUrl`, so both are read. */
+const fileEventSchema = z.object({
+	filename: z.string().optional(),
+	mediaType: z.string().optional(),
+	snapshotUrl: z.string().optional(),
+	url: z.string().optional()
+});
+const kindOfMediaType = (mediaType) => {
+	if (mediaType.startsWith("image/")) return "image";
+	if (mediaType.startsWith("video/")) return "video";
+	return mediaType.startsWith("audio/") ? "audio" : "file";
+};
+const EXTENSIONS = {
+	audio: "mp3",
+	file: "bin",
+	image: "png",
+	video: "mp4"
+};
+const nameFor$1 = (kind, mediaType) => {
+	return `${kind}.${mediaType.split("/")[1]?.split(";")[0] ?? EXTENSIONS[kind]}`;
+};
+const toDataUri = (bytes, mediaType) => `data:${mediaType};base64,${Buffer.from(bytes).toString("base64")}`;
+const isAbsolute = (url) => /^https?:\/\//iu.test(url);
+const inlineBase64 = (asset) => asset.href.slice(asset.href.indexOf(",") + 1);
+const renderAsset = (asset) => {
+	const link = asset.kind === "image" ? "!" : "";
+	const note = asset.note ? `\n\n_${asset.note}_` : "";
+	return `\n\n${link}[${asset.filename}](${asset.href})${note}\n\n`;
+};
+/**
+* Only a same-origin asset is fetched; an absolute URL elsewhere is public
+* or needs its own credential, and is not this proxy's to get.
+*/
+const resolveAsset = async (cookie, event, signal) => {
+	const url = event.url ?? event.snapshotUrl;
+	if (!url) return null;
+	const mediaType = event.mediaType ?? "application/octet-stream";
+	const kind = kindOfMediaType(mediaType);
+	const base = {
+		filename: event.filename ?? nameFor$1(kind, mediaType),
+		kind,
+		mediaType
+	};
+	if (url.startsWith("data:")) return {
+		...base,
+		href: url,
+		inline: true
+	};
+	const absolute = new URL(url, config.origin).href;
+	if (isAbsolute(url) && !absolute.startsWith(config.origin)) return {
+		...base,
+		href: absolute,
+		inline: false
+	};
+	const needsLogin = "the file is over the size the proxy will carry inline, so this link needs a logged-in browser";
+	try {
+		const response = await fetch(absolute, {
+			headers: browserGetHeaders(cookie, `${config.origin}/chat`),
+			redirect: "manual",
+			signal
+		});
+		if (!response.ok) return {
+			...base,
+			href: absolute,
+			inline: false,
+			note: `the proxy could not read the file (${response.status}); this link needs a logged-in browser`
+		};
+		const bytes = await response.arrayBuffer();
+		if (bytes.byteLength > INLINE_CAP[kind]) return {
+			...base,
+			href: absolute,
+			inline: false,
+			note: needsLogin
+		};
+		return {
+			...base,
+			href: toDataUri(bytes, mediaType),
+			inline: true
+		};
+	} catch (error) {
+		return {
+			...base,
+			href: absolute,
+			inline: false,
+			note: `the proxy could not read the file (${error}); this link needs a logged-in browser`
+		};
+	}
+};
+//#endregion
+//#region ../core/src/aipass/quotas.ts
+const QUOTA_PATH = "/loaders/get-usage-quota";
+const SETTLE_TIMEOUT_MS = 5e3;
+const amountSchema = z.union([z.string(), z.number()]);
+const quotaResponseSchema = z.object({ creditStatus: z.object({
+	credits: z.object({
+		available: amountSchema,
+		limit: amountSchema,
+		used: amountSchema
+	}),
+	creditsDecimals: z.number().int().min(0).max(18),
+	periodEndsAt: z.string()
+}) });
+const fetchCredits = async (cookie, signal) => {
+	const quota = await loadJson(QUOTA_PATH, quotaResponseSchema, cookie, signal);
+	if (!quota) return null;
+	const { credits, creditsDecimals, periodEndsAt } = quota.creditStatus;
+	const scale = 10 ** creditsDecimals;
+	return {
+		creditsAvailable: Number(credits.available) / scale,
+		creditsLimit: Number(credits.limit) / scale,
+		creditsResetAt: periodEndsAt,
+		creditsUsed: Number(credits.used) / scale
+	};
+};
+z.object({
+	available: z.number(),
+	limit: z.number(),
+	reset_at: z.string(),
+	used: z.number()
+}).extend({ spent: z.number().optional() });
+const toCreditBalance = (credits) => ({
+	available: credits.creditsAvailable,
+	limit: credits.creditsLimit,
+	reset_at: credits.creditsResetAt,
+	used: credits.creditsUsed
+});
+const toCreditUsage = (before, after) => {
+	const latest = after ?? before;
+	if (!latest) return;
+	const balance = toCreditBalance(latest);
+	if (!(before && after)) return balance;
+	return {
+		...balance,
+		spent: Math.max(0, after.creditsUsed - before.creditsUsed)
+	};
+};
+/** The read has its own timeout because the request signal may already be aborted. */
+const settleCredits = async (cookie, before) => {
+	const [start, after] = await Promise.all([before, fetchCredits(cookie, AbortSignal.timeout(SETTLE_TIMEOUT_MS))]);
+	return {
+		after,
+		usage: toCreditUsage(start, after)
+	};
+};
+const CLIENT_ID_LENGTH = 16;
+const clientIdFromCookie = (cookie) => createHash("sha256").update(cookie).digest("hex").slice(0, CLIENT_ID_LENGTH);
+const thinkingLevelSchema = z.enum([
+	"low",
+	"medium",
+	"high",
+	"max"
+]);
+/** The levels to assume for a model whose catalog entry could not be read. */
+const COMMON_LEVELS = [
+	"low",
+	"medium",
+	"high"
+];
+/**
+* An unsupported level is dropped and named, like any other unsupported
+* setting. An unread catalog falls back to the common three so a cold cache
+* does not strip a level the model would have taken.
+*/
+const resolveThinking = (asked, entry) => {
+	if (asked === void 0) return { level: null };
+	const advertised = entry?.thinking;
+	const allowed = advertised && advertised.length > 0 ? advertised : COMMON_LEVELS;
+	if (allowed.includes(asked)) return { level: asked };
+	return {
+		dropped: `the model does not offer thinking level ${asked}, it offers ${allowed.join(", ")}`,
+		level: null
+	};
+};
+//#endregion
+//#region ../core/src/lib/stream.ts
+const guardController = (controller) => {
+	let open = true;
+	const attempt = (action) => {
+		if (!open) return;
+		try {
+			action();
+		} catch {
+			open = false;
+		}
+	};
+	return {
+		abandon: () => {
+			open = false;
+		},
+		close: () => attempt(() => controller.close()),
+		enqueue: (chunk) => attempt(() => controller.enqueue(chunk)),
+		isOpen: () => open
+	};
+};
+//#endregion
+//#region ../core/src/aipass/inline.ts
+/**
+* A remote URL is refused rather than fetched: a deployment that fetches any
+* URL a caller names is a request forger for the network it sits in.
+*/
+const DATA_URI = /^data:(?<mediaType>[^;,]*)(?<base64>;base64)?,/iu;
+var InlineError = class extends Error {
+	name = "InlineError";
+};
+/** atob yields one byte per code unit, so every code point here is below 256. */
+const decodeBase64 = (value) => {
+	const binary = atob(value);
+	const bytes = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.codePointAt(index) ?? 0;
+	return bytes;
+};
+const fromBase64 = (data, mediaType, filename) => {
+	try {
+		return {
+			bytes: decodeBase64(data),
+			filename,
+			mediaType
+		};
+	} catch {
+		throw new InlineError(`${filename} is not readable base64`);
+	}
+};
+const nameFor = (mediaType, index) => {
+	const subtype = mediaType.split("/")[1]?.split(";")[0] ?? "bin";
+	const extension = subtype === "jpeg" ? "jpg" : subtype;
+	return `${mediaType.startsWith("image/") ? "image" : "attachment"}-${index + 1}.${extension}`;
+};
+/** Percent-encoded data URIs are decoded too; small SVG and text files arrive that way. */
+const fromDataUri = (uri, filename, index = 0) => {
+	const match = DATA_URI.exec(uri);
+	if (!match) throw new InlineError("only inline data is accepted; send the file as a data: URI or base64, not as a URL the proxy would have to fetch");
+	const mediaType = match.groups?.mediaType || "application/octet-stream";
+	const payload = uri.slice(match[0].length);
+	const name = filename ?? nameFor(mediaType, index);
+	if (match.groups?.base64) return fromBase64(payload, mediaType, name);
+	return {
+		bytes: new TextEncoder().encode(decodeURIComponent(payload)),
+		filename: name,
+		mediaType
+	};
+};
+//#endregion
+//#region ../core/src/aipass/stream.ts
+const optionalText = z.union([z.string(), z.unknown().transform(() => void 0)]).optional();
+/** Some models put the file's fields at the top level, others under `data`; the outer wins. */
+const fileFrameSchema = fileEventSchema.extend({
+	data: fileEventSchema.optional(),
+	type: z.literal("file")
+});
+const upstreamEventSchema = z.discriminatedUnion("type", [
+	z.object({
+		delta: z.string(),
+		type: z.literal("text-delta")
+	}),
+	z.object({
+		delta: z.string(),
+		type: z.literal("reasoning-delta")
+	}),
+	fileFrameSchema,
+	z.object({
+		finishReason: optionalText,
+		type: z.literal("finish")
+	}),
+	z.object({
+		error: optionalText,
+		errorText: optionalText,
+		type: z.literal("error")
+	})
+]);
+const skippedTypeSchema = z.object({ type: z.string() });
+const parseAipassSSE = async function* parseAipassSSE(body, skips) {
+	const chunks = parseJsonEventStream({
+		schema: upstreamEventSchema,
+		stream: body
+	});
+	for await (const chunk of chunks) {
+		if (!chunk.success) {
+			if (skips) {
+				skips.count += 1;
+				const named = skippedTypeSchema.safeParse(chunk.rawValue);
+				if (named.success) skips.types.add(named.data.type);
+			}
+			continue;
+		}
+		const event = chunk.value;
+		switch (event.type) {
+			case "text-delta":
+				yield {
+					kind: "delta",
+					text: event.delta
+				};
+				break;
+			case "reasoning-delta":
+				yield {
+					kind: "reasoning",
+					text: event.delta
+				};
+				break;
+			case "file": {
+				const { data } = event;
+				yield {
+					file: {
+						filename: event.filename ?? data?.filename,
+						mediaType: event.mediaType ?? data?.mediaType,
+						snapshotUrl: event.snapshotUrl ?? data?.snapshotUrl,
+						url: event.url ?? data?.url
+					},
+					kind: "file"
+				};
+				break;
+			}
+			case "finish":
+				yield {
+					kind: "finish",
+					reason: event.finishReason ?? "stop"
+				};
+				break;
+			default: yield {
+				kind: "error",
+				message: event.errorText ?? event.error ?? "upstream error"
+			};
+		}
+	}
+};
+//#endregion
+//#region ../core/src/tokens.ts
+/**
+* AI Pass reports no token counts. ASCII runs about four characters per
+* token; Thai, other non-Latin scripts and emoji nearer one and a half, so
+* the two are counted apart.
+*/
+const ASCII = /[\u0020-\u007E\s]/gu;
+const ASCII_CHARS_PER_TOKEN = 4;
+const OTHER_CHARS_PER_TOKEN = 1.5;
+const newCharCount = () => ({
+	ascii: 0,
+	other: 0
+});
+const addText = (count, text) => {
+	const ascii = text.match(ASCII)?.length ?? 0;
+	count.ascii += ascii;
+	count.other += text.length - ascii;
+};
+const charTokens = (count) => Math.ceil(count.ascii / ASCII_CHARS_PER_TOKEN + count.other / OTHER_CHARS_PER_TOKEN);
+const estimateTokens = (text) => {
+	const count = newCharCount();
+	addText(count, text);
+	return charTokens(count);
+};
+//#endregion
+//#region ../core/src/lib/id.ts
+/** The first `length` hex characters of a random UUID, for wire-visible ids. */
+const randomHex = (length) => crypto.randomUUID().replaceAll("-", "").slice(0, length);
+//#endregion
+//#region ../core/src/tools.ts
+const toolInputSchema = z.record(z.string(), z.unknown());
+const FENCE_OPEN = "```tool_call\n";
+const FENCE_CLOSE = "\n```";
+const CALL_ID_LENGTH = 24;
+const callBodySchema = z.object({
+	input: toolInputSchema.default({}),
+	name: z.string().min(1)
+});
+const text = (value) => value.length > 0 ? [{
+	text: value,
+	type: "text"
+}] : [];
+const newCallId = () => randomHex(CALL_ID_LENGTH);
+const renderCall = (call) => `${FENCE_OPEN}${JSON.stringify({
+	input: call.input,
+	name: call.name
+})}${FENCE_CLOSE}`;
+const renderTool = (tool) => {
+	const summary = tool.description && tool.description.length > 0 ? `- ${tool.name}: ${tool.description.trim()}` : `- ${tool.name}`;
+	return tool.inputSchema === void 0 ? summary : `${summary}\n  input schema: ${JSON.stringify(tool.inputSchema)}`;
+};
+const renderToolGuide = (tools) => [
+	"You can call tools. To call one, write a block exactly like this, one block per call, then stop and wait for the result, which arrives in the next turn:",
+	`${FENCE_OPEN}{"name": "<tool name>", "input": {<arguments matching the tool's input schema>}}${FENCE_CLOSE}`,
+	`Tools:\n\n${tools.map(renderTool).join("\n")}`
+].join("\n\n");
+const parseCall = (json, names) => {
+	let raw;
+	try {
+		raw = JSON.parse(json);
+	} catch {
+		return;
+	}
+	const parsed = callBodySchema.safeParse(raw);
+	if (!parsed.success || !names.has(parsed.data.name)) return;
+	return {
+		id: newCallId(),
+		input: parsed.data.input,
+		name: parsed.data.name
+	};
+};
+/** How many trailing characters could still turn out to open a fence. */
+const heldLength = (tail) => {
+	const longest = Math.min(tail.length, 12);
+	for (let length = longest; length > 0; length -= 1) if ("```tool_call\n".startsWith(tail.slice(-length))) return length;
+	return 0;
+};
+/**
+* Text is released as soon as it can no longer open a fence. A fence that
+* never closes, or holds no call to an offered tool, is released as text.
+*/
+const splitReply = (tools) => {
+	if (tools.length === 0) return {
+		flush: () => [],
+		push: text
+	};
+	const names = new Set(tools.map((tool) => tool.name));
+	let buffer = "";
+	let inBlock = false;
+	/** Ends the open block; `fence` is what closed it, nothing when the reply ran out first. */
+	const closeBlock = (json, fence) => {
+		inBlock = false;
+		const call = parseCall(json.trim(), names);
+		return call ? [{
+			call,
+			type: "call"
+		}] : text(`${FENCE_OPEN}${json}${fence}`);
+	};
+	const drain = (final) => {
+		const parts = [];
+		for (;;) {
+			if (inBlock) {
+				const end = buffer.indexOf(FENCE_CLOSE);
+				if (end === -1) {
+					if (!final) return parts;
+					const json = buffer;
+					buffer = "";
+					parts.push(...closeBlock(json, ""));
+					return parts;
+				}
+				const json = buffer.slice(0, end);
+				buffer = buffer.slice(end + 4);
+				if (buffer.startsWith("\n")) buffer = buffer.slice(1);
+				parts.push(...closeBlock(json, FENCE_CLOSE));
+				continue;
+			}
+			const start = buffer.indexOf(FENCE_OPEN);
+			if (start === -1) {
+				const hold = final ? 0 : heldLength(buffer);
+				const released = buffer.slice(0, buffer.length - hold);
+				buffer = buffer.slice(buffer.length - hold);
+				parts.push(...text(released));
+				return parts;
+			}
+			parts.push(...text(buffer.slice(0, start)));
+			buffer = buffer.slice(start + 13);
+			inBlock = true;
+		}
+	};
+	return {
+		flush: () => drain(true),
+		push: (chunk) => {
+			buffer += chunk;
+			return drain(false);
+		}
+	};
+};
+//#endregion
+//#region ../core/src/translate.ts
+const filesOf = (conversation) => conversation.turns.flatMap((turn) => turn.files ?? []);
+const toolNames = (turns) => {
+	const names = /* @__PURE__ */ new Map();
+	for (const turn of turns) for (const call of turn.calls ?? []) names.set(call.id, call.name);
+	return names;
+};
+const roleLabel = (turn, names) => {
+	if (turn.role === "assistant") return "Assistant";
+	if (turn.role === "tool") {
+		const name = turn.callId === void 0 ? void 0 : names.get(turn.callId);
+		return name === void 0 ? "Tool" : `Tool (${name})`;
+	}
+	return "User";
+};
+const turnText = (turn) => {
+	return [turn.content.trim(), ...(turn.calls ?? []).map(renderCall)].filter((part) => part.length > 0).join("\n\n");
+};
+const flattenPrompt = ({ tools, turns }) => {
+	const system = turns.filter((turn) => turn.role === "system").map((turn) => turn.content).filter((text) => text.length > 0).join("\n\n");
+	const convo = turns.filter((turn) => turn.role !== "system");
+	if (system.length === 0 && tools.length === 0 && convo.length === 1 && convo[0]?.role === "user" && convo[0].calls === void 0) return convo[0].content;
+	const blocks = [];
+	if (system.length > 0) blocks.push(system.trim());
+	if (tools.length > 0) blocks.push(renderToolGuide(tools));
+	const names = toolNames(convo);
+	const lines = [];
+	for (const turn of convo) {
+		const text = turnText(turn);
+		if (text.length === 0) continue;
+		lines.push(`${roleLabel(turn, names)}: ${text}`);
+	}
+	if (lines.length > 0) blocks.push(lines.join("\n\n"));
+	return blocks.join("\n\n");
+};
+const toAipassMessages = (prompt, modelId) => [{
+	id: crypto.randomUUID(),
+	metadata: { modelId },
+	parts: [{
+		text: prompt,
+		type: "text"
+	}],
+	role: "user"
+}];
+//#endregion
+//#region ../core/src/reply.ts
+/** Only a request that asked for a level reads the catalog; on a cold cache that is a round trip. */
+const prepareTurn = async (conversation, model, thinking, catalog) => {
+	const prompt = flattenPrompt(conversation);
+	const inputTokens = estimateTokens(prompt);
+	let thinkingLevel = null;
+	let thinkingDropped;
+	if (thinking !== void 0) {
+		const entries = await catalog();
+		const resolved = resolveThinking(thinking, entries?.get(model));
+		thinkingLevel = resolved.level;
+		thinkingDropped = resolved.dropped;
+	}
+	const sendOptions = { attachments: filesOf(conversation).map((file, index) => fromDataUri(file.uri, file.filename, index)) };
+	if (thinkingLevel) sendOptions.thinkingLevel = thinkingLevel;
+	return {
+		inputTokens,
+		prompt,
+		sendOptions,
+		thinkingDropped,
+		thinkingLevel
+	};
+};
+const finishReasonOf = (tally) => tally.calls > 0 && tally.finishReason === "stop" ? "tool-calls" : tally.finishReason;
+const replyTokens = (tally) => charTokens(tally.reply);
+/**
+* Text goes through the tool-call splitter, so a fenced call never reaches the
+* caller as text. An upstream error is yielded rather than thrown, since each
+* caller handles one differently.
+*/
+const readReply = (options) => {
+	const { body, cookie, signal, tools } = options;
+	const startedAt = options.startedAt ?? Date.now();
+	const tally = {
+		calls: 0,
+		chars: 0,
+		deltas: 0,
+		files: 0,
+		finishReason: "stop",
+		msToFirstChunk: void 0,
+		reasoningChars: 0,
+		reply: newCharCount(),
+		skips: {
+			count: 0,
+			types: /* @__PURE__ */ new Set()
+		}
+	};
+	const splitter = splitReply(tools);
+	const fromParts = function* fromParts(parts) {
+		for (const part of parts) if (part.type === "text") {
+			tally.chars += part.text.length;
+			addText(tally.reply, part.text);
+			yield {
+				kind: "text",
+				text: part.text
+			};
+		} else {
+			tally.calls += 1;
+			addText(tally.reply, renderCall(part.call));
+			yield {
+				call: part.call,
+				kind: "call"
+			};
+		}
+	};
+	return {
+		events: async function* events() {
+			for await (const event of parseAipassSSE(body, tally.skips)) if (event.kind === "delta") {
+				tally.msToFirstChunk ??= Date.now() - startedAt;
+				tally.deltas += 1;
+				yield* fromParts(splitter.push(event.text));
+			} else if (event.kind === "reasoning") {
+				tally.reasoningChars += event.text.length;
+				yield {
+					kind: "reasoning",
+					text: event.text
+				};
+			} else if (event.kind === "file") {
+				const asset = await resolveAsset(cookie, event.file, signal);
+				if (asset) {
+					tally.files += 1;
+					yield {
+						asset,
+						kind: "file"
+					};
+				}
+			} else if (event.kind === "finish") tally.finishReason = event.reason;
+			else yield {
+				kind: "error",
+				message: event.message
+			};
+			yield* fromParts(splitter.flush());
+		}(),
+		tally
+	};
+};
+//#endregion
+//#region src/prompt.ts
+const resultText = (output) => {
+	switch (output.type) {
+		case "text":
+		case "error-text": return output.value;
+		case "json":
+		case "error-json": return JSON.stringify(output.value);
+		default: return output.value.filter((part) => part.type === "text").map((part) => part.text).join("");
+	}
+};
+/** The SDK types a call's input as unknown; a call whose input is not an object carries none. */
+const inputOf = (part) => {
+	const parsed = toolInputSchema.safeParse(part.input);
+	return parsed.success ? parsed.data : {};
+};
+const droppedWarning = (dropped) => dropped.size > 0 ? [{
+	message: `the provider dropped ${[...dropped].toSorted().join(", ")} parts because AI Pass reads text only`,
+	type: "other"
+}] : [];
+/** Inline bytes become a data URI; a URL is passed through to be refused where every protocol's files decode. */
+const fileUri = (part) => {
+	const { data, mediaType } = part;
+	if (data instanceof URL) return data.href;
+	if (data instanceof Uint8Array) return `data:${mediaType};base64,${Buffer.from(data).toString("base64")}`;
+	return data.startsWith("data:") ? data : `data:${mediaType};base64,${data}`;
+};
+const toTurnFile = (part, index) => ({
+	filename: part.filename ?? nameFor(part.mediaType, index),
+	uri: fileUri(part)
+});
+const convertPrompt = (prompt) => {
+	const turns = [];
+	const dropped = /* @__PURE__ */ new Set();
+	for (const message of prompt) {
+		if (message.role === "system") {
+			turns.push({
+				content: message.content,
+				role: "system"
+			});
+			continue;
+		}
+		if (message.role === "tool") {
+			for (const part of message.content) turns.push({
+				callId: part.toolCallId,
+				content: resultText(part.output),
+				role: "tool"
+			});
+			continue;
+		}
+		const text = [];
+		const calls = [];
+		const files = [];
+		for (const part of message.content) if (part.type === "text" || part.type === "reasoning") text.push(part.text);
+		else if (part.type === "file") files.push(toTurnFile(part, files.length));
+		else if (part.type === "tool-call") calls.push({
+			id: part.toolCallId,
+			input: inputOf(part),
+			name: part.toolName
+		});
+		else dropped.add(part.type);
+		const turn = {
+			content: text.join(""),
+			role: message.role
+		};
+		const withFiles = files.length > 0 ? {
+			...turn,
+			files
+		} : turn;
+		turns.push(calls.length > 0 ? {
+			...withFiles,
+			calls
+		} : withFiles);
+	}
+	return {
+		turns,
+		warnings: droppedWarning(dropped)
+	};
+};
+/** Function tools are offered through the text protocol; provider-defined ones have no upstream to run on. */
+const convertTools = (options) => {
+	const tools = [];
+	const warnings = [];
+	for (const tool of options.tools ?? []) if (tool.type === "function") tools.push({
+		description: tool.description,
+		inputSchema: tool.inputSchema,
+		name: tool.name
+	});
+	else warnings.push({
+		tool,
+		type: "unsupported-tool"
+	});
+	return {
+		tools,
+		warnings
+	};
+};
+//#endregion
+//#region src/model.ts
+const PROVIDER = "aipass";
+const REASONING_ID = "reasoning";
+const DETAIL_LIMIT = 300;
+const estimatedUsage = (inputTokens, outputTokens) => ({
+	inputTokens,
+	outputTokens,
+	totalTokens: inputTokens + outputTokens
+});
+const FINISH_REASONS = /* @__PURE__ */ new Map([
+	["content-filter", "content-filter"],
+	["error", "error"],
+	["length", "length"],
+	["other", "other"],
+	["stop", "stop"],
+	["tool-calls", "tool-calls"],
+	["unknown", "unknown"]
+]);
+const UNSUPPORTED_SETTINGS = [
+	"frequencyPenalty",
+	"maxOutputTokens",
+	"presencePenalty",
+	"responseFormat",
+	"seed",
+	"stopSequences",
+	"temperature",
+	"toolChoice",
+	"topK",
+	"topP"
+];
+const toFinishReason = (reason) => FINISH_REASONS.get(reason) ?? "unknown";
+/** AI Pass takes a level, not a token budget, so the SDK's own reasoning settings do not map. */
+const askedThinking = (options) => {
+	const asked = options.providerOptions?.aipass?.thinkingLevel;
+	const parsed = thinkingLevelSchema.safeParse(asked);
+	return parsed.success ? parsed.data : void 0;
+};
+const settingWarnings = (options) => {
+	const warnings = [];
+	for (const setting of UNSUPPORTED_SETTINGS) if (options[setting] !== void 0) warnings.push({
+		setting,
+		type: "unsupported-setting"
+	});
+	return warnings;
+};
+/** Provider metadata allows no undefined, so `spent` is left out when unknown. */
+const creditMetadata = (usage) => {
+	if (!usage) return;
+	const { spent, ...balance } = usage;
+	return { aipass: { credits: spent === void 0 ? balance : {
+		...balance,
+		spent
+	} } };
+};
+const toolCallPart = (call) => ({
+	input: JSON.stringify(call.input),
+	toolCallId: call.id,
+	toolName: call.name,
+	type: "tool-call"
+});
+const startTurn = async (cookie, modelId, options) => {
+	const prompt = convertPrompt(options.prompt);
+	const offered = convertTools(options);
+	const { tools } = offered;
+	const catalog = fetchCatalog(clientIdFromCookie(cookie), cookie, options.abortSignal);
+	const problem = chatModelProblem(modelId, await catalog);
+	if (problem) throw new NoSuchModelError({
+		message: problem,
+		modelId,
+		modelType: "languageModel"
+	});
+	const credits = fetchCredits(cookie, options.abortSignal);
+	const prepared = await prepareTurn({
+		tools,
+		turns: prompt.turns
+	}, modelId, askedThinking(options), () => catalog);
+	const body = toAipassMessages(prepared.prompt, modelId);
+	const { conversationId, created, response } = await sendMessage(cookie, modelId, body, options.abortSignal, prepared.sendOptions);
+	const contentType = response.headers.get("content-type") ?? "";
+	if (response.ok && response.body && contentType.includes("event-stream")) {
+		const warnings = [
+			...prompt.warnings,
+			...offered.warnings,
+			...settingWarnings(options)
+		];
+		if (prepared.thinkingDropped) warnings.push({
+			message: prepared.thinkingDropped,
+			type: "other"
+		});
+		return {
+			conversationId,
+			credits,
+			inputTokens: prepared.inputTokens,
+			reader: readReply({
+				body: response.body,
+				cookie,
+				signal: options.abortSignal,
+				tools
+			}),
+			warnings
+		};
+	}
+	const detail = response.body ? await response.text().catch(() => "") : "";
+	if (created) await deleteConversation(cookie, conversationId);
+	const hint = isEdgeRefusal(response.status) ? EDGE_REFUSAL_HINT : "";
+	throw new APICallError({
+		message: `AI Pass answered ${response.status} (${contentType || "no content-type"})${hint}`,
+		requestBodyValues: {
+			messages: body,
+			modelId
+		},
+		responseBody: detail.slice(0, DETAIL_LIMIT),
+		statusCode: response.status,
+		url: created ? `${config.origin}/actions/send-message/${conversationId}` : `${config.origin}/chat.data`
+	});
+};
+/** An inline asset becomes the SDK's file part; a link is rendered as text with the reason. */
+const assetPart = (asset) => {
+	if (!asset.inline) return { text: renderAsset(asset) };
+	return {
+		data: inlineBase64(asset),
+		mediaType: asset.mediaType,
+		type: "file"
+	};
+};
+const streamTurn = (cookie, turn) => new ReadableStream({ async start(raw) {
+	const out = guardController(raw);
+	const { reader } = turn;
+	const { tally } = reader;
+	out.enqueue({
+		type: "stream-start",
+		warnings: turn.warnings
+	});
+	let textId;
+	let textBlocks = 0;
+	let reasoningOpen = false;
+	const closeText = () => {
+		if (textId !== void 0) {
+			out.enqueue({
+				id: textId,
+				type: "text-end"
+			});
+			textId = void 0;
+		}
+	};
+	const text = (delta) => {
+		if (textId === void 0) {
+			textId = `text-${textBlocks}`;
+			textBlocks += 1;
+			out.enqueue({
+				id: textId,
+				type: "text-start"
+			});
+		}
+		out.enqueue({
+			delta,
+			id: textId,
+			type: "text-delta"
+		});
+	};
+	try {
+		for await (const event of reader.events) if (event.kind === "text") text(event.text);
+		else if (event.kind === "call") {
+			closeText();
+			out.enqueue(toolCallPart(event.call));
+		} else if (event.kind === "reasoning") {
+			if (!reasoningOpen) {
+				out.enqueue({
+					id: REASONING_ID,
+					type: "reasoning-start"
+				});
+				reasoningOpen = true;
+			}
+			out.enqueue({
+				delta: event.text,
+				id: REASONING_ID,
+				type: "reasoning-delta"
+			});
+		} else if (event.kind === "file") {
+			const part = assetPart(event.asset);
+			if ("type" in part) {
+				closeText();
+				out.enqueue(part);
+			} else text(part.text);
+		} else {
+			tally.finishReason = "error";
+			out.enqueue({
+				error: new Error(event.message),
+				type: "error"
+			});
+		}
+	} catch (error) {
+		tally.finishReason = "error";
+		out.enqueue({
+			error,
+			type: "error"
+		});
+	} finally {
+		if (reasoningOpen) out.enqueue({
+			id: REASONING_ID,
+			type: "reasoning-end"
+		});
+		closeText();
+		const [{ usage }] = await Promise.all([settleCredits(cookie, turn.credits), deleteConversation(cookie, turn.conversationId)]);
+		out.enqueue({
+			finishReason: toFinishReason(finishReasonOf(tally)),
+			providerMetadata: creditMetadata(usage),
+			type: "finish",
+			usage: estimatedUsage(turn.inputTokens, replyTokens(tally))
+		});
+		out.close();
+	}
+} });
+const aipassModel = (cookie, modelId) => ({
+	doGenerate: async (options) => {
+		const turn = await startTurn(cookie, modelId, options);
+		const { reader } = turn;
+		const { tally } = reader;
+		const calls = [];
+		const files = [];
+		let text = "";
+		let reasoning = "";
+		try {
+			for await (const event of reader.events) if (event.kind === "text") text += event.text;
+			else if (event.kind === "call") calls.push(event.call);
+			else if (event.kind === "reasoning") reasoning += event.text;
+			else if (event.kind === "file") {
+				const part = assetPart(event.asset);
+				if ("type" in part) files.push(part);
+				else text += part.text;
+			} else tally.finishReason = "error";
+		} finally {
+			await deleteConversation(cookie, turn.conversationId);
+		}
+		const { usage } = await settleCredits(cookie, turn.credits);
+		const content = [];
+		if (reasoning.length > 0) content.push({
+			text: reasoning,
+			type: "reasoning"
+		});
+		if (text.length > 0) content.push({
+			text,
+			type: "text"
+		});
+		content.push(...files, ...calls.map(toolCallPart));
+		return {
+			content,
+			finishReason: toFinishReason(finishReasonOf(tally)),
+			providerMetadata: creditMetadata(usage),
+			usage: estimatedUsage(turn.inputTokens, replyTokens(tally)),
+			warnings: turn.warnings
+		};
+	},
+	doStream: async (options) => {
+		const turn = await startTurn(cookie, modelId, options);
+		return { stream: streamTurn(cookie, turn) };
+	},
+	modelId,
+	provider: PROVIDER,
+	specificationVersion: "v2",
+	supportedUrls: {}
+});
+//#endregion
+//#region src/index.ts
+const createAipass = (settings) => {
+	if (settings.origin !== void 0) configure({ origin: settings.origin });
+	if (settings.logger !== void 0) configure({ logger: settings.logger });
+	const languageModel = (modelId = DEFAULT_MODEL) => {
+		if (modelId.length === 0 || kindOf(modelId) !== "chat") throw new NoSuchModelError({
+			modelId,
+			modelType: "languageModel"
+		});
+		return aipassModel(settings.cookie, modelId);
+	};
+	return Object.assign(languageModel, { languageModel });
+};
+//#endregion
+export { createAipass };