pi2dsh 0.12.2 → 0.12.4

package/dist/client.js

@@ -0,0 +1,525 @@
+window.__ModuleLoader__.load({
+	id: "pi2dsh",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		//#region src/ansi.ts
+		/** The 8 base ANSI colours, in SGR order, as CSS. */
+		const BASE = [
+			"#000000",
+			"#cd3131",
+			"#0dbc79",
+			"#e5e510",
+			"#2472c8",
+			"#bc3fbc",
+			"#11a8cd",
+			"#e5e5e5"
+		];
+		/** Their bright variants (SGR 90-97 / 100-107). */
+		const BRIGHT = [
+			"#666666",
+			"#f14c4c",
+			"#23d18b",
+			"#f5f543",
+			"#3b8eea",
+			"#d670d6",
+			"#29b8db",
+			"#ffffff"
+		];
+		/**
+		* Resolve one xterm-256 index to CSS.
+		* @param index - the palette index (0-255).
+		* @returns a CSS colour.
+		*/
+		function ansi256(index) {
+			if (index < 8) return BASE[index];
+			if (index < 16) return BRIGHT[index - 8];
+			if (index < 232) {
+				const step = (value) => value === 0 ? 0 : value * 40 + 55;
+				const rest = index - 16;
+				return `rgb(${step(Math.floor(rest / 36))}, ${step(Math.floor(rest / 6) % 6)}, ${step(rest % 6)})`;
+			}
+			const grey = (index - 232) * 10 + 8;
+			return `rgb(${grey}, ${grey}, ${grey})`;
+		}
+		const SGR = String.raw`\[([0-9;]*)m`;
+		/**
+		* Split text into styled runs.
+		*
+		* Unrecognised escapes are dropped rather than printed — a code this does not
+		* model is still not something a reader should see as text. Text with no
+		* escapes comes back as a single unstyled run, so callers need no special case.
+		* @param text - possibly carrying SGR escapes.
+		* @returns the runs, in order; empty only for empty input.
+		*/
+		function parseAnsi(text) {
+			const pattern = new RegExp(SGR, "gu");
+			const runs = [];
+			let style = {};
+			let at = 0;
+			const push = (piece) => {
+				if (piece.length > 0) runs.push({
+					text: piece,
+					style: { ...style }
+				});
+			};
+			for (let match = pattern.exec(text); match !== null; match = pattern.exec(text)) {
+				push(text.slice(at, match.index));
+				at = match.index + match[0].length;
+				const codes = (match[1] ?? "").split(";").filter((part) => part !== "").map(Number);
+				if (codes.length === 0) style = {};
+				for (let index = 0; index < codes.length; index += 1) {
+					const code = codes[index];
+					if (code === 0) style = {};
+					else if (code === 1) style.fontWeight = "bold";
+					else if (code === 2) style.opacity = "0.7";
+					else if (code === 3) style.fontStyle = "italic";
+					else if (code === 4) style.textDecoration = "underline";
+					else if (code === 39) delete style.color;
+					else if (code === 49) delete style.backgroundColor;
+					else if (code >= 30 && code <= 37) style.color = BASE[code - 30];
+					else if (code >= 90 && code <= 97) style.color = BRIGHT[code - 90];
+					else if (code >= 40 && code <= 47) style.backgroundColor = BASE[code - 40];
+					else if (code >= 100 && code <= 107) style.backgroundColor = BRIGHT[code - 100];
+					else if (code === 38 || code === 48) {
+						const property = code === 38 ? "color" : "backgroundColor";
+						const kind = codes[index + 1];
+						if (kind === 5 && codes.length > index + 2) {
+							style[property] = ansi256(codes[index + 2]);
+							index += 2;
+						} else if (kind === 2 && codes.length > index + 4) {
+							style[property] = `rgb(${codes[index + 2]}, ${codes[index + 3]}, ${codes[index + 4]})`;
+							index += 4;
+						}
+					}
+				}
+			}
+			push(text.slice(at));
+			return runs;
+		}
+		/**
+		* Whether text carries any SGR escape.
+		* @param text - the text to check.
+		* @returns true when at least one escape is present.
+		*/
+		function hasAnsi(text) {
+			return new RegExp(SGR, "u").test(text);
+		}
+		//#endregion
+		//#region src/client.ts
+		/** Services this half needs before it can take a seat. */
+		const inject = ["slots", "inputTriggers"];
+		const POLL_MS = 1e3;
+		const EMPTY = {
+			threads: [],
+			surfaces: [],
+			entries: []
+		};
+		/**
+		* One poller per session, shared by every seat this package takes.
+		*
+		* Four components read the same payload; four independent timers would be four
+		* requests a second for one answer.
+		*/
+		const subscribers = /* @__PURE__ */ new Map();
+		const latest = /* @__PURE__ */ new Map();
+		const timers = /* @__PURE__ */ new Map();
+		/**
+		* Subscribe to one session's browser state.
+		* @param session - session id to poll for.
+		* @param notify - called with each payload, and immediately with the last one.
+		* @returns an unsubscribe function that stops the timer with the last reader.
+		*/
+		function watch(session, notify) {
+			const readers = subscribers.get(session) ?? /* @__PURE__ */ new Set();
+			readers.add(notify);
+			subscribers.set(session, readers);
+			const cached = latest.get(session);
+			if (cached !== void 0) notify(cached);
+			if (!timers.has(session)) {
+				const poll = async () => {
+					try {
+						const response = await fetch(`/pi2dsh/browser-state?session=${encodeURIComponent(session)}`);
+						if (!response.ok) return;
+						const payload = await response.json();
+						const state = {
+							threads: Array.isArray(payload.threads) ? payload.threads : [],
+							surfaces: Array.isArray(payload.surfaces) ? payload.surfaces : [],
+							entries: Array.isArray(payload.entries) ? payload.entries : [],
+							...payload.draft === void 0 ? {} : { draft: payload.draft }
+						};
+						latest.set(session, state);
+						for (const reader of subscribers.get(session) ?? []) reader(state);
+					} catch {}
+				};
+				poll();
+				timers.set(session, window.setInterval(() => {
+					poll();
+				}, POLL_MS));
+			}
+			return () => {
+				const live = subscribers.get(session);
+				if (live === void 0) return;
+				live.delete(notify);
+				if (live.size > 0) return;
+				subscribers.delete(session);
+				const timer = timers.get(session);
+				if (timer !== void 0) window.clearInterval(timer);
+				timers.delete(session);
+				latest.delete(session);
+			};
+		}
+		/**
+		* React binding for {@link watch}.
+		* @param session - session id, or undefined while none is selected.
+		* @returns the latest payload for that session.
+		*/
+		function useBrowserState(session) {
+			const [state, setState] = (0, react.useState)(EMPTY);
+			(0, react.useEffect)(() => {
+				if (session === void 0 || session === "") {
+					setState(EMPTY);
+					return;
+				}
+				return watch(session, setState);
+			}, [session]);
+			return state;
+		}
+		/** The working keys Pi's setWorkingVisible gates: hidden while hidden. */
+		const WORKING_KEYS = [
+			"workingMessage",
+			"workingIndicator",
+			"hiddenThinkingLabel"
+		];
+		/** Every value packages have set for one simple surface, in package order. */
+		function valuesFor(surfaces, key) {
+			const out = [];
+			for (const surface of surfaces) {
+				if (WORKING_KEYS.includes(key) && !surface.workingVisible) continue;
+				const text = surface.values[key];
+				if (text !== void 0) out.push({
+					owner: surface.package ?? "pi",
+					text
+				});
+			}
+			return out;
+		}
+		/** Every status entry, package by package, then key, in registration order. */
+		function statusesFor(surfaces) {
+			const out = [];
+			for (const surface of surfaces) for (const [key, text] of Object.entries(surface.statuses)) out.push({
+				owner: surface.package ?? "pi",
+				key,
+				text
+			});
+			return out;
+		}
+		/** Every widget, package by package, then key, in registration order. */
+		function widgetsFor(surfaces) {
+			const out = [];
+			for (const surface of surfaces) for (const [key, text] of Object.entries(surface.widgets)) out.push({
+				owner: surface.package ?? "pi",
+				key,
+				text
+			});
+			return out;
+		}
+		const styles = {
+			panel: {
+				position: "fixed",
+				right: "20px",
+				bottom: "108px",
+				zIndex: 40,
+				width: "340px",
+				maxHeight: "48vh",
+				display: "flex",
+				flexDirection: "column",
+				pointerEvents: "auto",
+				overflow: "hidden",
+				borderRadius: "12px",
+				border: "1px solid rgba(120,120,130,0.28)",
+				background: "var(--dsh-color-bg-elevated, rgba(24,24,27,0.96))",
+				color: "var(--dsh-color-text, #fafafa)",
+				boxShadow: "0 12px 32px rgba(0,0,0,0.32)",
+				font: "400 13px/1.55 system-ui, -apple-system, sans-serif"
+			},
+			header: {
+				display: "flex",
+				alignItems: "center",
+				justifyContent: "space-between",
+				gap: "8px",
+				padding: "10px 12px",
+				borderBottom: "1px solid rgba(120,120,130,0.22)",
+				fontWeight: 500,
+				fontSize: "12px",
+				letterSpacing: "0.01em"
+			},
+			badge: {
+				opacity: .6,
+				fontWeight: 400
+			},
+			body: {
+				padding: "10px 12px",
+				overflowY: "auto",
+				display: "flex",
+				flexDirection: "column",
+				gap: "10px"
+			},
+			role: {
+				fontSize: "11px",
+				textTransform: "uppercase",
+				letterSpacing: "0.06em",
+				opacity: .55
+			},
+			text: {
+				whiteSpace: "pre-wrap",
+				wordBreak: "break-word"
+			},
+			close: {
+				cursor: "pointer",
+				opacity: .55,
+				background: "none",
+				border: "none",
+				color: "inherit",
+				font: "inherit"
+			},
+			pillStack: {
+				position: "fixed",
+				right: "20px",
+				bottom: "20px",
+				zIndex: 39,
+				display: "flex",
+				flexDirection: "column",
+				alignItems: "flex-end",
+				gap: "6px",
+				pointerEvents: "none"
+			},
+			pill: {
+				pointerEvents: "auto",
+				padding: "5px 10px",
+				borderRadius: "999px",
+				background: "var(--dsh-color-bg-elevated, rgba(24,24,27,0.92))",
+				color: "var(--dsh-color-text, #fafafa)",
+				border: "1px solid rgba(120,120,130,0.28)",
+				font: "500 11px/1.4 system-ui, sans-serif",
+				whiteSpace: "pre-wrap"
+			},
+			inline: {
+				font: "400 12px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace",
+				whiteSpace: "pre-wrap",
+				opacity: .85
+			},
+			strip: {
+				display: "flex",
+				flexDirection: "column",
+				gap: "4px",
+				padding: "4px 2px"
+			}
+		};
+		/**
+		* The frame-wide seat: the side-conversation panel, plus whatever packages
+		* pinned frame-wide — transient title and Pi's status entries, as pills.
+		* @param props - the global standard kit every root slot component receives.
+		*/
+		function OverlaySurfaces({ useSessions }) {
+			const { threads, surfaces } = useBrowserState(useSessions((state) => state.current));
+			const [dismissed, setDismissed] = (0, react.useState)([]);
+			const shown = threads.filter((thread) => !dismissed.includes(thread.id));
+			const pills = [...valuesFor(surfaces, "title").map((entry) => ({
+				...entry,
+				key: "title"
+			})), ...statusesFor(surfaces)];
+			if (shown.length === 0 && pills.length === 0) return null;
+			return (0, react.createElement)("div", null, pills.length === 0 ? null : (0, react.createElement)("div", {
+				style: styles.pillStack,
+				"data-pi2dsh": "pills"
+			}, ...pills.map((pill, index) => (0, react.createElement)("div", {
+				key: `${pill.owner}-${pill.key}-${index}`,
+				style: styles.pill,
+				title: pill.owner
+			}, ansiText(pill.text)))), shown.length === 0 ? null : (0, react.createElement)("div", {
+				"data-pi2dsh": "side-panel",
+				style: styles.panel
+			}, ...shown.map((thread) => (0, react.createElement)("div", {
+				key: thread.id,
+				style: { display: "contents" }
+			}, (0, react.createElement)("div", { style: styles.header }, (0, react.createElement)("span", null, thread.label), (0, react.createElement)("span", { style: styles.badge }, thread.running ? "running" : `${thread.messages.length} msg`), (0, react.createElement)("button", {
+				style: styles.close,
+				title: "Hide",
+				onClick: () => setDismissed((list) => [...list, thread.id])
+			}, "×")), (0, react.createElement)("div", { style: styles.body }, ...thread.messages.map((message, index) => (0, react.createElement)("div", { key: index }, (0, react.createElement)("div", { style: styles.role }, message.role), (0, react.createElement)("div", { style: styles.text }, message.text))))))));
+		}
+		/**
+		* One session-scoped seat rendering a set of surfaces as text.
+		* @param marker - the data-pi2dsh value, so an e2e run can address the seat.
+		* @param valueKeys - which simple value surfaces this seat shows.
+		* @param opts - whether the seat also shows widgets (keyed string arrays).
+		* @returns a slot component.
+		*/
+		/**
+		* Render text that may carry ANSI colour into styled spans.
+		*
+		* Parsing lives in ./ansi.js so it can be tested without a DOM; this half
+		* only turns runs into elements. Text with no escapes returns as a plain
+		* string, so the common case adds no wrappers.
+		* @param text - the seat text, possibly with SGR escapes.
+		* @returns react children.
+		*/
+		function ansiText(text) {
+			if (!hasAnsi(text)) return text;
+			return parseAnsi(text).map((run, index) => Object.keys(run.style).length === 0 ? run.text : (0, react.createElement)("span", {
+				key: `ansi-${index}`,
+				style: run.style
+			}, run.text));
+		}
+		function textSeat(marker, valueKeys, opts = {}) {
+			return function TextSeat({ sessionId }) {
+				const { surfaces } = useBrowserState(sessionId);
+				const entries = [...valueKeys.flatMap((key) => valuesFor(surfaces, key)), ...opts.widgets === true ? widgetsFor(surfaces) : []];
+				if (entries.length === 0) return null;
+				return (0, react.createElement)("div", {
+					"data-pi2dsh": marker,
+					style: styles.strip
+				}, ...entries.map((entry, index) => (0, react.createElement)("div", {
+					key: `${entry.owner}-${index}`,
+					style: styles.inline,
+					title: entry.owner
+				}, ansiText(entry.text))));
+			};
+		}
+		/**
+		* Custom entries a package appended and renders itself.
+		*
+		* They live in pi2dsh's sidecar, not DSH's durable log — the host has no
+		* channel for event types declared outside the harness — so the host's own
+		* conversation view cannot show them. This seat is where a package's own
+		* entries become visible, drawn by the package's registered renderer.
+		* @param props - the session standard kit.
+		* @returns the entry strip, or null when the package appended none.
+		*/
+		function EntryStrip({ sessionId }) {
+			const { entries } = useBrowserState(sessionId);
+			if (entries.length === 0) return null;
+			return (0, react.createElement)("div", {
+				"data-pi2dsh": "entries",
+				style: styles.strip
+			}, ...entries.map((entry) => (0, react.createElement)("div", {
+				key: entry.id,
+				style: styles.inline,
+				title: `${entry.package ?? "pi"} · ${entry.customType}`
+			}, ansiText(entry.text))));
+		}
+		/**
+		* The composer half of Pi's editor calls.
+		*
+		* `inputActions` is part of the session standard kit — every session-scoped
+		* slot component receives it — so a package's `setEditorText`/`pasteToEditor`
+		* reaches the real composer instead of a buffer nobody reads. The traffic is
+		* two-way on purpose: the live draft is reported back so a package's
+		* `getEditorText` reads what the user actually has, not only its own last
+		* write.
+		* @param props - the session standard kit (state hook plus input actions).
+		* @returns nothing rendered; this seat exists for the effects.
+		*/
+		function ComposerBridge({ sessionId, useInput, inputActions }) {
+			const { draft } = useBrowserState(sessionId);
+			const live = useInput === void 0 ? "" : useInput((state) => state.draft);
+			const [appliedRev, setAppliedRev] = (0, react.useState)(0);
+			(0, react.useEffect)(() => {
+				if (draft === void 0 || inputActions === void 0) return;
+				if (draft.rev <= appliedRev) return;
+				setAppliedRev(draft.rev);
+				inputActions.setDraft(draft.text);
+			}, [
+				draft?.rev,
+				draft?.text,
+				inputActions,
+				appliedRev
+			]);
+			(0, react.useEffect)(() => {
+				if (sessionId === void 0 || sessionId === "") return;
+				fetch("/pi2dsh/editor-draft", {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({
+						session: sessionId,
+						draft: live
+					})
+				}).catch(() => {});
+			}, [sessionId, live]);
+			return null;
+		}
+		/**
+		* Client plugin body: take the seats this package draws into.
+		* @param ctx - client root context.
+		*/
+		function apply(ctx) {
+			ctx.inject(["inputTriggers"], (scope) => {
+				const triggers = scope.inputTriggers;
+				if (triggers === void 0) return;
+				triggers.registerSource({
+					trigger: "@",
+					name: "pi2dsh",
+					order: 50,
+					candidates: async (_session, req) => {
+						try {
+							const response = await fetch(`/pi2dsh/completions?trigger=${encodeURIComponent("@")}&query=${encodeURIComponent(req.query)}`, { signal: req.signal });
+							if (!response.ok) return [];
+							return ((await response.json()).items ?? []).map((item) => ({
+								name: item.value,
+								...item.description === void 0 ? {} : { description: item.description }
+							}));
+						} catch {
+							return [];
+						}
+					},
+					onPick: (pick) => ({ text: pick.candidate.name })
+				});
+			});
+			ctx.inject(["slots"], (scope) => {
+				scope.slots.inject("shell.overlay", () => scope.slots.register({
+					name: "shell.overlay",
+					id: "pi2dsh-overlay",
+					order: 1
+				}, OverlaySurfaces));
+				scope.slots.inject("conversation.session.header.utilities", () => scope.slots.register({
+					name: "conversation.session.header.utilities",
+					id: "pi2dsh-header",
+					order: 1
+				}, textSeat("header", ["header"])));
+				scope.slots.inject("conversation.input.dock", () => scope.slots.register({
+					name: "conversation.input.dock",
+					id: "pi2dsh-dock",
+					order: 1
+				}, textSeat("dock", [], { widgets: true })));
+				scope.slots.inject("conversation.chat.turnTail", () => scope.slots.register({
+					name: "conversation.chat.turnTail",
+					id: "pi2dsh-entries",
+					order: 1,
+					select: () => ({})
+				}, EntryStrip));
+				scope.slots.inject("conversation.input.dock", () => scope.slots.register({
+					name: "conversation.input.dock",
+					id: "pi2dsh-composer-bridge",
+					order: 2
+				}, ComposerBridge));
+				scope.slots.inject("conversation.composer.dock", () => scope.slots.register({
+					name: "conversation.composer.dock",
+					id: "pi2dsh-working",
+					order: 1
+				}, textSeat("working", [
+					"footer",
+					"workingMessage",
+					"workingIndicator",
+					"hiddenThinkingLabel"
+				])));
+			});
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});

package/dist/compat/pi-ai.d.mts

@@ -278,6 +278,9 @@ declare function registerProvider(name: string, provider: unknown): void;
 declare function getProviders(): string[];
 declare function getProvider(name: string): unknown;
 declare function getModel(_provider: string, _id: string): undefined;
+declare const getBuiltinModels: (provider?: string) => unknown[];
+declare const getBuiltinModel: (provider: string, id: string) => undefined;
+declare const getBuiltinProviders: () => string[];
 declare function getModels(_provider?: string): unknown[];
 declare function builtinProviders(): Array<{
   id: string;
@@ -311,6 +314,38 @@ declare function __setPiAiLlmBridge(bridge: PiAiLlmBridge | undefined): void;
 declare function __getPiAiLlmBridge(): PiAiLlmBridge | undefined;
 declare function complete(model: UnknownRecord, context: UnknownRecord, options?: UnknownRecord): Promise<unknown>;
 declare function stream(model: UnknownRecord, context: UnknownRecord, options?: UnknownRecord): unknown;
+/**
+ * Pi's per-protocol transport factories.
+ *
+ * Pi ships one factory per wire protocol (`pi-ai/compat`), and a gateway
+ * package's most common shape is to take the standard one for its protocol and
+ * hand it to `registerProvider`. Without these names such a package throws at
+ * import — `openAICompletionsApi is not a function` — and the whole package
+ * fails to mount, which reads as "the plugin is broken" rather than "the bridge
+ * is missing an export".
+ *
+ * The provider each returns is not a wire client: its stream is the same DSH
+ * llm route `complete()` and `stream()` already run on, so every model call in
+ * this process keeps going through the one directory and the one path. Without
+ * a mounted llm service it fails loud rather than reaching a provider SDK.
+ * @param api - the protocol id this factory serves.
+ * @returns a provider carrying that protocol's id and the routed stream.
+ */
+declare function routedApi(api: string): {
+  api: string;
+  stream: PiAiLlmBridge;
+  streamSimple: PiAiLlmBridge;
+};
+declare const anthropicMessagesApi: () => ReturnType<typeof routedApi>;
+declare const openAICompletionsApi: () => ReturnType<typeof routedApi>;
+declare const openAIResponsesApi: () => ReturnType<typeof routedApi>;
+declare const openAICodexResponsesApi: () => ReturnType<typeof routedApi>;
+declare const azureOpenAIResponsesApi: () => ReturnType<typeof routedApi>;
+declare const googleGenerativeAIApi: () => ReturnType<typeof routedApi>;
+declare const googleVertexApi: () => ReturnType<typeof routedApi>;
+declare const mistralConversationsApi: () => ReturnType<typeof routedApi>;
+declare const bedrockConverseStreamApi: () => ReturnType<typeof routedApi>;
+declare const piMessagesApi: () => ReturnType<typeof routedApi>;
 interface StringEnumOptions<T extends readonly string[]> {
   description?: string;
   default?: T[number];
@@ -322,5 +357,5 @@ declare function StringEnum<T extends readonly string[]>(values: T, options?: St
   default?: T[number];
 };
 //#endregion
-export { type AgentMessage, Api, type AssistantMessage, AssistantMessageEventStream, type ImageContent, type Message, Model, ModelThinkingLevel, ModelsError, type Static, StringEnum, StringEnumOptions, type TSchema, type TextContent, type ThinkingContent, ThinkingLevel, ThinkingLevelMap, type ToolCallContent, type ToolResultMessage, Type, type Usage, type UserMessage, __getPiAiLlmBridge, __setPiAiLlmBridge, anthropicOAuth, builtinProviders, clampThinkingLevel, complete, contentText, createProvider, generatePKCE, getApiProvider, getApiProviders, getModel, getModels, getProvider, getProviders, getSupportedThinkingLevels, githubCopilotOAuth, isContextOverflow, isRecoverableLength, isRetryableAssistantError, kimiCodingOAuth, lazyApi, lazyStream, loadAnthropicOAuth, loadGitHubCopilotOAuth, loadKimiCodingOAuth, loadOpenAICodexOAuth, modelsAreEqual, openaiCodexOAuth, pollOAuthDeviceCodeFlow, registerApiProvider, registerProvider, stream, unregisterApiProviders, uuidv7 };
+export { type AgentMessage, Api, type AssistantMessage, AssistantMessageEventStream, type ImageContent, type Message, Model, ModelThinkingLevel, ModelsError, type Static, StringEnum, StringEnumOptions, type TSchema, type TextContent, type ThinkingContent, ThinkingLevel, ThinkingLevelMap, type ToolCallContent, type ToolResultMessage, Type, type Usage, type UserMessage, __getPiAiLlmBridge, __setPiAiLlmBridge, anthropicMessagesApi, anthropicOAuth, azureOpenAIResponsesApi, bedrockConverseStreamApi, builtinProviders, clampThinkingLevel, complete, contentText, createProvider, generatePKCE, getApiProvider, getApiProviders, getBuiltinModel, getBuiltinModels, getBuiltinProviders, getModel, getModels, getProvider, getProviders, getSupportedThinkingLevels, githubCopilotOAuth, googleGenerativeAIApi, googleVertexApi, isContextOverflow, isRecoverableLength, isRetryableAssistantError, kimiCodingOAuth, lazyApi, lazyStream, loadAnthropicOAuth, loadGitHubCopilotOAuth, loadKimiCodingOAuth, loadOpenAICodexOAuth, mistralConversationsApi, modelsAreEqual, openAICodexResponsesApi, openAICompletionsApi, openAIResponsesApi, openaiCodexOAuth, piMessagesApi, pollOAuthDeviceCodeFlow, registerApiProvider, registerProvider, stream, unregisterApiProviders, uuidv7 };
 //# sourceMappingURL=pi-ai.d.mts.map

package/dist/compat/pi-ai.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pi-ai.d.mts","names":[],"sources":["../../src/compat/vendor/pi-ai-overflow.ts","../../src/compat/vendor/pi-ai-retry.ts","../../src/compat/vendor/pi-uuid.ts","../../src/compat/vendor/pi-ai-provider.ts","../../src/compat/vendor/pi-ai-event-stream.ts","../../src/compat/vendor/pi-ai-lazy.ts","../../src/compat/vendor/pi-oauth-flows/openai-codex.ts","../../src/compat/vendor/pi-oauth-flows/anthropic.ts","../../src/compat/vendor/pi-oauth-flows/github-copilot.ts","../../src/compat/vendor/pi-oauth-flows/kimi-coding.ts","../../src/compat/vendor/pi-oauth-flows/pkce.ts","../../src/compat/vendor/pi-oauth-flows/device-code.ts","../../src/compat/pi-ai.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsIgB,kBAAkB,SAAS,kBAAkB;;;;;;;iBAqC7C,oBAAoB,SAAS,kBAAkB;;;;;;;;;;;;iBCoD/C,0BAA0B,SAAS;;;;iBChNnC;;;cCLH,oBAAoB;EAC7B;EACY,YAAA,WAAM,cAAS;;;;;;;;iBAYf,eAAe;;;;;;;oCAAf;;;;;;;cCtBH;EACT;EACA;EACA;EACA,oBAAkB;EAClB;EACA;EACA;EACY,YAAA,iBAAY;EAOxB,KAAK;EAgBL,IAAI;GAWI,OAAO,kBAAc;EAgB7B,UAAM;;cAIG,oCAAoC;EAAA;;;;;;;;;iBC5BjC,WAAW,YAAO,aAAK;iBAWvB,QAAQ,WAAM;sDAAd;4DAAA;;;;cC2XH;;;;;;;;;;;;;;;;;;;;;;;iBC7OE,eAAe,mBAAW;;;;;;cA+G5B;;;;;;;;;;;;;;;;iBCvBE,mBAAmB,mBAAW;;;;;;;;cAoChC;;;;;;;;;;;;;;;;;;;;iBC7EE,gBAAgB,mBAAW;;;;;;cAa7B;;;;;;;;;;;;;;;;;;;;;;;iBCrOS,gBAAY;;;;;;iBCOZ,wBAAwB,eAAO;;;KCDzC;KACA,6BAA6B;KAC7B,mBAAmB,QAAQ,OAAO;KAClC;UAEK,MAAM,aAAa,MAAM;EACxC;EACA;EACA,MAAM;EACN;EACA;EACA;EACA,mBAAmB;EACnB;EACA;EACA;GACC;;iBAKa,2BAA2B,aAAa,KAAK,OAAO,MAAM,QAAQ;iBASlE,mBAAmB,aAAa,KAC9C,OAAO,MAAM,OACb,OAAO,qBACN;iBAgBa,eAAe,aAAa,KAC1C,GAAG,MAAM,0BACT,GAAG,MAAM;UAMD;EACR;EACA;GACC;;iBAGa,YAAY,2BAA2B,kBAAkB;iBAazD,iBAAiB,cAAc;iBAM/B;iBAIA,YAAY;iBAIZ,SAAS,mBAAmB;iBAI5B,UAAU;iBAmCV,oBAAoB;EAAQ;EAAY;EAAc;EAAa;EAAiB;EAAiB;IAAQ;;;cAYhH,4BAAiC;cACjC,0BAA+B;cAC/B,8BAAmC;cACnC,2BAAgC;UASnC;EACR;EACA,YAAY;EACZ,kBAAkB;;iBAaJ,oBAAoB,UAAU,mBAAmB;iBAWjD,eAAe,cAAc;iBAI7B,mBAAmB;iBAInB,uBAAuB;KAUlC,iBAAiB,OAAO,eAAe,SAAS,eAAe,SAAS;EAC3E,UAAU;GACT,OAAO,kBAAkB;;KAGvB,gBAAgB;iBAIL,mBAAmB,QAAQ;iBAS3B,sBAAsB;iBAWhB,SAAS,OAAO,eAAe,SAAS,eAAe,UAAU,gBAAgB;iBAOvF,OAAO,OAAO,eAAe,SAAS,eAAe,UAAU;UAI9D,kBAAkB;EACjC;EACA,UAAU;;iBAGI,WAAW,6BACzB,QAAQ,GACR,UAAS,kBAAkB;EACxB;EAAgB,MAAM;EAAG;EAAsB,UAAU"}
+{"version":3,"file":"pi-ai.d.mts","names":[],"sources":["../../src/compat/vendor/pi-ai-overflow.ts","../../src/compat/vendor/pi-ai-retry.ts","../../src/compat/vendor/pi-uuid.ts","../../src/compat/vendor/pi-ai-provider.ts","../../src/compat/vendor/pi-ai-event-stream.ts","../../src/compat/vendor/pi-ai-lazy.ts","../../src/compat/vendor/pi-oauth-flows/openai-codex.ts","../../src/compat/vendor/pi-oauth-flows/anthropic.ts","../../src/compat/vendor/pi-oauth-flows/github-copilot.ts","../../src/compat/vendor/pi-oauth-flows/kimi-coding.ts","../../src/compat/vendor/pi-oauth-flows/pkce.ts","../../src/compat/vendor/pi-oauth-flows/device-code.ts","../../src/compat/pi-ai.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsIgB,kBAAkB,SAAS,kBAAkB;;;;;;;iBAqC7C,oBAAoB,SAAS,kBAAkB;;;;;;;;;;;;iBCoD/C,0BAA0B,SAAS;;;;iBChNnC;;;cCLH,oBAAoB;EAC7B;EACY,YAAA,WAAM,cAAS;;;;;;;;iBAYf,eAAe;;;;;;;oCAAf;;;;;;;cCtBH;EACT;EACA;EACA;EACA,oBAAkB;EAClB;EACA;EACA;EACY,YAAA,iBAAY;EAOxB,KAAK;EAgBL,IAAI;GAWI,OAAO,kBAAc;EAgB7B,UAAM;;cAIG,oCAAoC;EAAA;;;;;;;;;iBC5BjC,WAAW,YAAO,aAAK;iBAWvB,QAAQ,WAAM;sDAAd;4DAAA;;;;cC2XH;;;;;;;;;;;;;;;;;;;;;;;iBC7OE,eAAe,mBAAW;;;;;;cA+G5B;;;;;;;;;;;;;;;;iBCvBE,mBAAmB,mBAAW;;;;;;;;cAoChC;;;;;;;;;;;;;;;;;;;;iBC7EE,gBAAgB,mBAAW;;;;;;cAa7B;;;;;;;;;;;;;;;;;;;;;;;iBCrOS,gBAAY;;;;;;iBCOZ,wBAAwB,eAAO;;;KCDzC;KACA,6BAA6B;KAC7B,mBAAmB,QAAQ,OAAO;KAClC;UAEK,MAAM,aAAa,MAAM;EACxC;EACA;EACA,MAAM;EACN;EACA;EACA;EACA,mBAAmB;EACnB;EACA;EACA;GACC;;iBAKa,2BAA2B,aAAa,KAAK,OAAO,MAAM,QAAQ;iBASlE,mBAAmB,aAAa,KAC9C,OAAO,MAAM,OACb,OAAO,qBACN;iBAgBa,eAAe,aAAa,KAC1C,GAAG,MAAM,0BACT,GAAG,MAAM;UAMD;EACR;EACA;GACC;;iBAGa,YAAY,2BAA2B,kBAAkB;iBAazD,iBAAiB,cAAc;iBAM/B;iBAIA,YAAY;iBAIZ,SAAS,mBAAmB;cAQ/B,mBAAoB;cACpB,kBAAmB,kBAAkB;cACrC;iBAEG,UAAU;iBAmCV,oBAAoB;EAAQ;EAAY;EAAc;EAAa;EAAiB;EAAiB;IAAQ;;;cAYhH,4BAAiC;cACjC,0BAA+B;cAC/B,8BAAmC;cACnC,2BAAgC;UASnC;EACR;EACA,YAAY;EACZ,kBAAkB;;iBAaJ,oBAAoB,UAAU,mBAAmB;iBAWjD,eAAe,cAAc;iBAI7B,mBAAmB;iBAInB,uBAAuB;KAUlC,iBAAiB,OAAO,eAAe,SAAS,eAAe,SAAS;EAC3E,UAAU;GACT,OAAO,kBAAkB;;KAGvB,gBAAgB;iBAIL,mBAAmB,QAAQ;iBAS3B,sBAAsB;iBAWhB,SAAS,OAAO,eAAe,SAAS,eAAe,UAAU,gBAAgB;iBAOvF,OAAO,OAAO,eAAe,SAAS,eAAe,UAAU;;;;;;;;;;;;;;;;;;iBAqBtE,UAAU;EAAgB;EAAa,QAAQ;EAAe,cAAc;;cAKxE,4BAA2B,kBAAkB;cAC7C,4BAA2B,kBAAkB;cAC7C,0BAAyB,kBAAkB;cAC3C,+BAA8B,kBAAkB;cAChD,+BAA8B,kBAAkB;cAChD,6BAA4B,kBAAkB;cAC9C,uBAAsB,kBAAkB;cACxC,+BAA8B,kBAAkB;cAChD,gCAA+B,kBAAkB;cACjD,qBAAoB,kBAAkB;UAElC,kBAAkB;EACjC;EACA,UAAU;;iBAGI,WAAW,6BACzB,QAAQ,GACR,UAAS,kBAAkB;EACxB;EAAgB,MAAM;EAAG;EAAsB,UAAU"}

package/dist/compat/pi-ai.mjs

@@ -1,3 +1,3 @@
 
-import { A as pollOAuthDeviceCodeFlow, B as uuidv7, C as stream, D as anthropicOAuth, E as githubCopilotOAuth, F as AssistantMessageEventStream, I as isContextOverflow, L as isRecoverableLength, M as createProvider, N as lazyApi, O as openaiCodexOAuth, P as lazyStream, R as isRetryableAssistantError, S as registerProvider, T as kimiCodingOAuth, _ as loadGitHubCopilotOAuth, a as builtinProviders, b as modelsAreEqual, c as contentText, d as getModel, f as getModels, g as loadAnthropicOAuth, h as getSupportedThinkingLevels, i as __setPiAiLlmBridge, j as ModelsError, k as generatePKCE, l as getApiProvider, m as getProviders, n as Type, o as clampThinkingLevel, p as getProvider, r as __getPiAiLlmBridge, s as complete, t as StringEnum, u as getApiProviders, v as loadKimiCodingOAuth, w as unregisterApiProviders, x as registerApiProvider, y as loadOpenAICodexOAuth } from "../pi-ai-Dyg4zyLZ.mjs";
-export { AssistantMessageEventStream, ModelsError, StringEnum, Type, __getPiAiLlmBridge, __setPiAiLlmBridge, anthropicOAuth, builtinProviders, clampThinkingLevel, complete, contentText, createProvider, generatePKCE, getApiProvider, getApiProviders, getModel, getModels, getProvider, getProviders, getSupportedThinkingLevels, githubCopilotOAuth, isContextOverflow, isRecoverableLength, isRetryableAssistantError, kimiCodingOAuth, lazyApi, lazyStream, loadAnthropicOAuth, loadGitHubCopilotOAuth, loadKimiCodingOAuth, loadOpenAICodexOAuth, modelsAreEqual, openaiCodexOAuth, pollOAuthDeviceCodeFlow, registerApiProvider, registerProvider, stream, unregisterApiProviders, uuidv7 };
+import { $ as uuidv7, A as openAICodexResponsesApi, B as anthropicOAuth, C as googleVertexApi, D as loadOpenAICodexOAuth, E as loadKimiCodingOAuth, F as registerProvider, G as createProvider, H as generatePKCE, I as stream, J as AssistantMessageEventStream, K as lazyApi, L as unregisterApiProviders, M as openAIResponsesApi, N as piMessagesApi, O as mistralConversationsApi, P as registerApiProvider, R as kimiCodingOAuth, S as googleGenerativeAIApi, T as loadGitHubCopilotOAuth, U as pollOAuthDeviceCodeFlow, V as openaiCodexOAuth, W as ModelsError, X as isRecoverableLength, Y as isContextOverflow, Z as isRetryableAssistantError, _ as getModel, a as anthropicMessagesApi, b as getProviders, c as builtinProviders, d as contentText, f as getApiProvider, g as getBuiltinProviders, h as getBuiltinModels, i as __setPiAiLlmBridge, j as openAICompletionsApi, k as modelsAreEqual, l as clampThinkingLevel, m as getBuiltinModel, n as Type, o as azureOpenAIResponsesApi, p as getApiProviders, q as lazyStream, r as __getPiAiLlmBridge, s as bedrockConverseStreamApi, t as StringEnum, u as complete, v as getModels, w as loadAnthropicOAuth, x as getSupportedThinkingLevels, y as getProvider, z as githubCopilotOAuth } from "../pi-ai-BA3V_J0V.mjs";
+export { AssistantMessageEventStream, ModelsError, StringEnum, Type, __getPiAiLlmBridge, __setPiAiLlmBridge, anthropicMessagesApi, anthropicOAuth, azureOpenAIResponsesApi, bedrockConverseStreamApi, builtinProviders, clampThinkingLevel, complete, contentText, createProvider, generatePKCE, getApiProvider, getApiProviders, getBuiltinModel, getBuiltinModels, getBuiltinProviders, getModel, getModels, getProvider, getProviders, getSupportedThinkingLevels, githubCopilotOAuth, googleGenerativeAIApi, googleVertexApi, isContextOverflow, isRecoverableLength, isRetryableAssistantError, kimiCodingOAuth, lazyApi, lazyStream, loadAnthropicOAuth, loadGitHubCopilotOAuth, loadKimiCodingOAuth, loadOpenAICodexOAuth, mistralConversationsApi, modelsAreEqual, openAICodexResponsesApi, openAICompletionsApi, openAIResponsesApi, openaiCodexOAuth, piMessagesApi, pollOAuthDeviceCodeFlow, registerApiProvider, registerProvider, stream, unregisterApiProviders, uuidv7 };