@parallelworks/ui 0.19.0 → 0.19.1

package/dist/{chunks/memoryStore-CC91S5LP.js → ai/adapter/memoryStore.js}

@@ -1,4 +1,4 @@
-import { t as ChatAdapterError } from "./types-Yy0NrerF.js";
+import { ChatAdapterError } from "./types.js";
 //#region src/ai/adapter/memoryStore.ts
 function newId() {
 	return crypto.randomUUID();
@@ -149,4 +149,4 @@ function createMemoryConversationStore(options) {
 	};
 }
 //#endregion
-export { createMemoryConversationStore as t };
+export { createMemoryConversationStore };

package/dist/ai/adapter/mock/index.js

@@ -1,81 +1,3 @@
-import { t as createMemoryConversationStore } from "../../../chunks/memoryStore-CC91S5LP.js";
-//#region src/ai/adapter/mock/mockAdapter.ts
-var CANNED_REPLIES = [
-	"Here's a canned reply from the mock adapter. It streams word by word so the typewriter animation, cancel behavior, and background streams all exercise the same code paths as a real backend.\n\n- No network requests are made\n- Conversations persist in localStorage\n- Try cancelling mid-stream: the partial reply is kept",
-	"Everything you see is generated locally. The mock adapter implements the same `ChatAdapter` interface as the OpenAI-compatible adapter and any backend's own, so the UI can't tell the difference.\n\n```ts\nconst adapter = createMockChatAdapter()\n```\n\nMarkdown, `inline code`, and code blocks render through the same pipeline.",
-	"Branching works too: edit one of your earlier messages or hit regenerate on a reply, then use the arrows to flip between branches."
-];
-var THINKING_PREAMBLE = "Thinking about the question, weighing a few canned options, and picking the next reply in the rotation...";
-function sleep(ms, signal) {
-	return new Promise((resolve, reject) => {
-		if (signal?.aborted) {
-			reject(new DOMException("The operation was aborted.", "AbortError"));
-			return;
-		}
-		const onAbort = () => {
-			clearTimeout(timer);
-			reject(new DOMException("The operation was aborted.", "AbortError"));
-		};
-		const timer = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-function createMockChatAdapter(options) {
-	const store = createMemoryConversationStore({ storageKey: options?.storageKey ?? "ai-chat-mock-conversations" });
-	let replyIndex = 0;
-	return {
-		conversations: store.conversations,
-		models: { async list() {
-			return {
-				models: [{
-					id: "mock:local/canned-small",
-					object: "model",
-					created: 0,
-					owned_by: "mock",
-					provider: "Mock Provider",
-					tool_calling_mode: "none"
-				}, {
-					id: "mock:local/canned-thinking",
-					object: "model",
-					created: 0,
-					owned_by: "mock",
-					provider: "Mock Provider",
-					tool_calling_mode: "none"
-				}],
-				unreachableSessions: []
-			};
-		} },
-		streamCompletion: store.recordingStream(async (req, handlers, signal) => {
-			if (signal?.aborted) throw new DOMException("The operation was aborted.", "AbortError");
-			let reasoning = "";
-			if (req.model.includes("thinking")) for (const word of THINKING_PREAMBLE.split(/(?<= )/)) {
-				await sleep(40, signal);
-				reasoning += word;
-				handlers.onReasoning?.(word);
-			}
-			const reply = CANNED_REPLIES[replyIndex % CANNED_REPLIES.length] ?? "";
-			replyIndex++;
-			await sleep(250, signal);
-			let content = "";
-			for (const word of reply.split(/(?<= )/)) {
-				await sleep(25, signal);
-				content += word;
-				handlers.onContent(word);
-			}
-			return {
-				content,
-				messageId: "",
-				toolCalls: [],
-				finishReason: "stop",
-				model: req.model,
-				reasoning,
-				responsesOutput: []
-			};
-		})
-	};
-}
-//#endregion
+import { createMemoryConversationStore } from "../memoryStore.js";
+import { createMockChatAdapter } from "./mockAdapter.js";
 export { createMemoryConversationStore, createMockChatAdapter };

package/dist/ai/adapter/mock/mockAdapter.js

@@ -0,0 +1,81 @@
+import { createMemoryConversationStore } from "../memoryStore.js";
+//#region src/ai/adapter/mock/mockAdapter.ts
+var CANNED_REPLIES = [
+	"Here's a canned reply from the mock adapter. It streams word by word so the typewriter animation, cancel behavior, and background streams all exercise the same code paths as a real backend.\n\n- No network requests are made\n- Conversations persist in localStorage\n- Try cancelling mid-stream: the partial reply is kept",
+	"Everything you see is generated locally. The mock adapter implements the same `ChatAdapter` interface as the OpenAI-compatible adapter and any backend's own, so the UI can't tell the difference.\n\n```ts\nconst adapter = createMockChatAdapter()\n```\n\nMarkdown, `inline code`, and code blocks render through the same pipeline.",
+	"Branching works too: edit one of your earlier messages or hit regenerate on a reply, then use the arrows to flip between branches."
+];
+var THINKING_PREAMBLE = "Thinking about the question, weighing a few canned options, and picking the next reply in the rotation...";
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new DOMException("The operation was aborted.", "AbortError"));
+			return;
+		}
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(new DOMException("The operation was aborted.", "AbortError"));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function createMockChatAdapter(options) {
+	const store = createMemoryConversationStore({ storageKey: options?.storageKey ?? "ai-chat-mock-conversations" });
+	let replyIndex = 0;
+	return {
+		conversations: store.conversations,
+		models: { async list() {
+			return {
+				models: [{
+					id: "mock:local/canned-small",
+					object: "model",
+					created: 0,
+					owned_by: "mock",
+					provider: "Mock Provider",
+					tool_calling_mode: "none"
+				}, {
+					id: "mock:local/canned-thinking",
+					object: "model",
+					created: 0,
+					owned_by: "mock",
+					provider: "Mock Provider",
+					tool_calling_mode: "none"
+				}],
+				unreachableSessions: []
+			};
+		} },
+		streamCompletion: store.recordingStream(async (req, handlers, signal) => {
+			if (signal?.aborted) throw new DOMException("The operation was aborted.", "AbortError");
+			let reasoning = "";
+			if (req.model.includes("thinking")) for (const word of THINKING_PREAMBLE.split(/(?<= )/)) {
+				await sleep(40, signal);
+				reasoning += word;
+				handlers.onReasoning?.(word);
+			}
+			const reply = CANNED_REPLIES[replyIndex % CANNED_REPLIES.length] ?? "";
+			replyIndex++;
+			await sleep(250, signal);
+			let content = "";
+			for (const word of reply.split(/(?<= )/)) {
+				await sleep(25, signal);
+				content += word;
+				handlers.onContent(word);
+			}
+			return {
+				content,
+				messageId: "",
+				toolCalls: [],
+				finishReason: "stop",
+				model: req.model,
+				reasoning,
+				responsesOutput: []
+			};
+		})
+	};
+}
+//#endregion
+export { createMockChatAdapter };

package/dist/ai/adapter/openai/createOpenAIStream.js

@@ -0,0 +1,33 @@
+import { ChatAdapterError } from "../types.js";
+import { errorMessageFromResponse } from "./errors.js";
+import { buildResponsesRequestBody, parseResponsesSSELine } from "./responses.js";
+import { processSSEStream } from "./sse.js";
+//#region src/ai/adapter/openai/createOpenAIStream.ts
+function createOpenAICompatibleStream(config) {
+	return async (req, handlers, signal) => {
+		const useResponses = req.useResponses === true && !!config.responsesUrl;
+		const url = useResponses ? config.responsesUrl : config.completionsUrl;
+		const body = useResponses ? buildResponsesRequestBody(req.model, req.messages) : {
+			model: req.model,
+			messages: req.messages,
+			stream: true
+		};
+		const res = await (config.fetch ?? globalThis.fetch.bind(globalThis))(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "text/event-stream",
+				...config.buildHeaders?.(req)
+			},
+			...config.credentials ? { credentials: config.credentials } : {},
+			body: JSON.stringify(body),
+			...signal ? { signal } : {}
+		});
+		if (!res.ok) throw new ChatAdapterError(await errorMessageFromResponse(res), { status: res.status });
+		const reader = res.body?.getReader();
+		if (!reader) throw new ChatAdapterError("No response body");
+		return processSSEStream(reader, handlers.onContent, void 0, void 0, handlers.onReasoning, handlers.onMessageId, useResponses ? parseResponsesSSELine : void 0);
+	};
+}
+//#endregion
+export { createOpenAICompatibleStream };

package/dist/ai/adapter/openai/errors.js

@@ -0,0 +1,37 @@
+//#region src/ai/adapter/openai/errors.ts
+function apiErrorMessage(errorData, fallback) {
+	if (typeof errorData !== "object" || errorData === null) return fallback;
+	const data = errorData;
+	const candidate = data["message"] ?? data["error"] ?? data["detail"];
+	if (typeof candidate === "string" && candidate.trim()) return candidate;
+	if (candidate && typeof candidate === "object") {
+		const nested = candidate["message"];
+		if (typeof nested === "string" && nested.trim()) return nested;
+		try {
+			return JSON.stringify(candidate);
+		} catch {
+			return fallback;
+		}
+	}
+	return fallback;
+}
+function statusFallbackMessage(status) {
+	if (status === 401) return "Your session has expired. Please refresh the page and try again.";
+	if (status === 403) return "You do not have permission to use this AI provider.";
+	if (status === 404) return "The AI provider or model was not found. Please select a different provider.";
+	if (status === 429) return "Too many requests. Please wait a moment and try again.";
+	if (status >= 500) return "The AI service is temporarily unavailable. Please try again later.";
+	return "Failed to send message";
+}
+async function errorMessageFromResponse(res) {
+	let message = statusFallbackMessage(res.status);
+	try {
+		const contentType = res.headers.get("content-type");
+		const text = await res.text();
+		if (contentType?.includes("application/json") && text) message = apiErrorMessage(JSON.parse(text), message);
+		else if (text && res.status < 500) message = text.substring(0, 200);
+	} catch {}
+	return message;
+}
+//#endregion
+export { apiErrorMessage, errorMessageFromResponse, statusFallbackMessage };

package/dist/ai/adapter/openai/index.js

@@ -1,334 +1,6 @@
-import { t as ChatAdapterError } from "../../../chunks/types-Yy0NrerF.js";
-import { t as createMemoryConversationStore } from "../../../chunks/memoryStore-CC91S5LP.js";
-//#region src/ai/adapter/openai/errors.ts
-function apiErrorMessage(errorData, fallback) {
-	if (typeof errorData !== "object" || errorData === null) return fallback;
-	const data = errorData;
-	const candidate = data["message"] ?? data["error"] ?? data["detail"];
-	if (typeof candidate === "string" && candidate.trim()) return candidate;
-	if (candidate && typeof candidate === "object") {
-		const nested = candidate["message"];
-		if (typeof nested === "string" && nested.trim()) return nested;
-		try {
-			return JSON.stringify(candidate);
-		} catch {
-			return fallback;
-		}
-	}
-	return fallback;
-}
-function statusFallbackMessage(status) {
-	if (status === 401) return "Your session has expired. Please refresh the page and try again.";
-	if (status === 403) return "You do not have permission to use this AI provider.";
-	if (status === 404) return "The AI provider or model was not found. Please select a different provider.";
-	if (status === 429) return "Too many requests. Please wait a moment and try again.";
-	if (status >= 500) return "The AI service is temporarily unavailable. Please try again later.";
-	return "Failed to send message";
-}
-async function errorMessageFromResponse(res) {
-	let message = statusFallbackMessage(res.status);
-	try {
-		const contentType = res.headers.get("content-type");
-		const text = await res.text();
-		if (contentType?.includes("application/json") && text) message = apiErrorMessage(JSON.parse(text), message);
-		else if (text && res.status < 500) message = text.substring(0, 200);
-	} catch {}
-	return message;
-}
-//#endregion
-//#region src/ai/adapter/openai/responses.ts
-function contentString(content) {
-	return typeof content === "string" ? content : "";
-}
-function buildResponsesRequestBody(model, messages) {
-	const input = [];
-	let attachmentIds;
-	for (const m of messages) switch (m.role) {
-		case "system":
-			input.push({
-				type: "message",
-				role: "system",
-				content: contentString(m.content)
-			});
-			break;
-		case "user":
-			if (m.attachment_ids?.length) attachmentIds = m.attachment_ids;
-			input.push({
-				type: "message",
-				role: "user",
-				content: contentString(m.content)
-			});
-			break;
-		case "assistant": {
-			const replayed = Array.isArray(m.responses_output) ? replayableOutput(m.responses_output) : [];
-			if (replayed.length > 0) {
-				for (const item of replayed) input.push(item);
-				break;
-			}
-			const text = contentString(m.content);
-			const toolCalls = m.tool_calls ?? [];
-			if (text || toolCalls.length === 0) input.push({
-				type: "message",
-				role: "assistant",
-				content: text
-			});
-			for (const tc of toolCalls) input.push({
-				type: "function_call",
-				call_id: tc.id ?? "",
-				name: tc.function.name,
-				arguments: tc.function.arguments
-			});
-			break;
-		}
-		case "tool": input.push({
-			type: "function_call_output",
-			call_id: m.tool_call_id ?? "",
-			output: contentString(m.content)
-		});
-	}
-	const body = {
-		model,
-		input,
-		stream: true,
-		store: false,
-		include: ["reasoning.encrypted_content"]
-	};
-	if (attachmentIds?.length) body["attachment_ids"] = attachmentIds;
-	return body;
-}
-var REPLAYABLE_ITEM_TYPES = /* @__PURE__ */ new Set([
-	"reasoning",
-	"message",
-	"function_call"
-]);
-function replayableOutput(output) {
-	if (!output?.length) return [];
-	return output.filter((item) => {
-		if (typeof item !== "object" || item === null) return false;
-		const itemType = item.type;
-		return typeof itemType === "string" && REPLAYABLE_ITEM_TYPES.has(itemType);
-	});
-}
-function parseResponsesSSELine(line) {
-	if (!line.startsWith("data: ")) return null;
-	const data = line.slice(6);
-	if (data === "[DONE]" || data === "\"[DONE]\"") return null;
-	let event;
-	try {
-		event = JSON.parse(data);
-	} catch {
-		return null;
-	}
-	if (event.error) return { error: event.error.message || "Unknown error" };
-	const model = event.response?.model;
-	switch (event.type) {
-		case "pw.message_id": return event.messageId ? { messageId: event.messageId } : null;
-		case "response.output_text.delta":
-		case "response.refusal.delta": return typeof event.delta === "string" ? { content: event.delta } : null;
-		case "response.reasoning_summary_text.delta": return typeof event.delta === "string" ? { reasoningContent: event.delta } : null;
-		case "response.created": return model ? { model } : null;
-		case "response.completed": return {
-			...model && { model },
-			finishReason: "stop",
-			responsesOutput: replayableOutput(event.response?.output)
-		};
-		case "response.incomplete": return {
-			...model && { model },
-			finishReason: "length",
-			responsesOutput: replayableOutput(event.response?.output)
-		};
-		case "response.failed": return { error: event.response?.error?.message || "Response failed" };
-		case "error": return { error: event.message || "Stream error" };
-		default: return null;
-	}
-}
-//#endregion
-//#region src/ai/adapter/openai/sse.ts
-function parseSSELine(line) {
-	if (!line.startsWith("data: ")) return null;
-	const data = line.slice(6);
-	if (data === "[DONE]" || data === "\"[DONE]\"") return null;
-	try {
-		const parsed = JSON.parse(data);
-		if (parsed.error) return { error: parsed.error.message || "Unknown error" };
-		const chunk = parsed;
-		const choice = chunk.choices?.[0];
-		return {
-			id: chunk.id,
-			messageId: chunk.messageId,
-			content: choice?.delta?.content,
-			reasoningContent: choice?.delta?.reasoning_content,
-			toolCalls: choice?.delta?.tool_calls ?? void 0,
-			finishReason: choice?.finish_reason,
-			model: chunk.model
-		};
-	} catch {
-		return null;
-	}
-}
-/** Process an SSE stream from a ReadableStream reader */
-async function processSSEStream(reader, onContent, onToolCall, onError, onReasoning, onMessageId, parseLine = parseSSELine) {
-	const decoder = new TextDecoder();
-	let assistantContent = "";
-	let assistantReasoning = "";
-	let assistantMessageId = "";
-	let finishReason = null;
-	let resolvedModel = null;
-	let responsesOutput = [];
-	const toolCallsMap = /* @__PURE__ */ new Map();
-	let lineBuffer = "";
-	while (true) {
-		const result = await reader.read();
-		if (result.done) break;
-		const chunk = decoder.decode(result.value, { stream: true });
-		const lines = (lineBuffer + chunk).split("\n");
-		lineBuffer = lines.pop() || "";
-		for (const line of lines) {
-			const parsed = parseLine(line);
-			if (parsed) {
-				if (parsed.error) {
-					onError?.(parsed.error);
-					throw new Error(parsed.error);
-				}
-				if (parsed.messageId && !assistantMessageId) {
-					assistantMessageId = parsed.messageId;
-					onMessageId?.(parsed.messageId);
-				} else if (parsed.id && !assistantMessageId) assistantMessageId = parsed.id;
-				if (parsed.model && !resolvedModel) resolvedModel = parsed.model;
-				if (parsed.content) {
-					assistantContent += parsed.content;
-					onContent(parsed.content);
-				}
-				if (parsed.reasoningContent) {
-					assistantReasoning += parsed.reasoningContent;
-					onReasoning?.(parsed.reasoningContent);
-				}
-				if (parsed.finishReason) finishReason = parsed.finishReason;
-				if (parsed.responsesOutput?.length) responsesOutput = parsed.responsesOutput;
-				if (parsed.toolCalls) for (const tc of parsed.toolCalls) {
-					if (tc.index === void 0) continue;
-					const existing = toolCallsMap.get(tc.index);
-					if (existing) {
-						if (tc.function?.arguments) existing.arguments += tc.function.arguments;
-					} else toolCallsMap.set(tc.index, {
-						id: tc.id || "",
-						type: tc.type || "function",
-						name: tc.function?.name || "",
-						arguments: tc.function?.arguments || ""
-					});
-				}
-			}
-		}
-	}
-	if (lineBuffer.trim()) {
-		const parsed = parseLine(lineBuffer);
-		if (parsed) {
-			if (parsed.content) {
-				assistantContent += parsed.content;
-				onContent(parsed.content);
-			}
-			if (parsed.reasoningContent) {
-				assistantReasoning += parsed.reasoningContent;
-				onReasoning?.(parsed.reasoningContent);
-			}
-			if (parsed.finishReason) finishReason = parsed.finishReason;
-		}
-	}
-	const toolCalls = Array.from(toolCallsMap.values()).map((tc) => ({
-		id: tc.id,
-		type: tc.type,
-		function: {
-			name: tc.name,
-			arguments: tc.arguments
-		}
-	}));
-	if (toolCalls.length > 0 && onToolCall) onToolCall(toolCalls);
-	return {
-		content: assistantContent,
-		messageId: assistantMessageId,
-		toolCalls,
-		finishReason,
-		model: resolvedModel,
-		reasoning: assistantReasoning,
-		responsesOutput
-	};
-}
-//#endregion
-//#region src/ai/adapter/openai/createOpenAIStream.ts
-function createOpenAICompatibleStream(config) {
-	return async (req, handlers, signal) => {
-		const useResponses = req.useResponses === true && !!config.responsesUrl;
-		const url = useResponses ? config.responsesUrl : config.completionsUrl;
-		const body = useResponses ? buildResponsesRequestBody(req.model, req.messages) : {
-			model: req.model,
-			messages: req.messages,
-			stream: true
-		};
-		const res = await (config.fetch ?? globalThis.fetch.bind(globalThis))(url, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				Accept: "text/event-stream",
-				...config.buildHeaders?.(req)
-			},
-			...config.credentials ? { credentials: config.credentials } : {},
-			body: JSON.stringify(body),
-			...signal ? { signal } : {}
-		});
-		if (!res.ok) throw new ChatAdapterError(await errorMessageFromResponse(res), { status: res.status });
-		const reader = res.body?.getReader();
-		if (!reader) throw new ChatAdapterError("No response body");
-		return processSSEStream(reader, handlers.onContent, void 0, void 0, handlers.onReasoning, handlers.onMessageId, useResponses ? parseResponsesSSELine : void 0);
-	};
-}
-//#endregion
-//#region src/ai/adapter/openai/openaiAdapter.ts
-function providerLabelFor(baseUrl) {
-	try {
-		return new URL(baseUrl).host;
-	} catch {
-		return "OpenAI compatible";
-	}
-}
-function staticModel(id, provider) {
-	return {
-		id,
-		object: "model",
-		created: 0,
-		owned_by: "openai-compatible",
-		provider,
-		tool_calling_mode: "none"
-	};
-}
-function createOpenAIChatAdapter(options) {
-	const baseUrl = options.baseUrl.replace(/\/$/, "");
-	const doFetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-	const headers = options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {};
-	const store = createMemoryConversationStore({ storageKey: options.storageKey ?? "ai-chat-openai-conversations" });
-	return {
-		conversations: store.conversations,
-		models: { async list() {
-			const providerLabel = providerLabelFor(baseUrl);
-			if (options.models?.length) return {
-				models: options.models.map((id) => staticModel(id, providerLabel)),
-				unreachableSessions: []
-			};
-			const res = await doFetch(`${baseUrl}/models`, { headers });
-			if (!res.ok) throw new ChatAdapterError(await errorMessageFromResponse(res), { status: res.status });
-			return {
-				models: ((await res.json()).data ?? []).map((m) => ({
-					...staticModel(m.id, providerLabel),
-					...m
-				})),
-				unreachableSessions: []
-			};
-		} },
-		streamCompletion: store.recordingStream(createOpenAICompatibleStream({
-			completionsUrl: `${baseUrl}/chat/completions`,
-			buildHeaders: () => headers,
-			...options.fetch ? { fetch: options.fetch } : {}
-		}))
-	};
-}
-//#endregion
+import { apiErrorMessage, errorMessageFromResponse, statusFallbackMessage } from "./errors.js";
+import { buildResponsesRequestBody, parseResponsesSSELine } from "./responses.js";
+import { parseSSELine, processSSEStream } from "./sse.js";
+import { createOpenAICompatibleStream } from "./createOpenAIStream.js";
+import { createOpenAIChatAdapter } from "./openaiAdapter.js";
 export { apiErrorMessage, buildResponsesRequestBody, createOpenAIChatAdapter, createOpenAICompatibleStream, errorMessageFromResponse, parseResponsesSSELine, parseSSELine, processSSEStream, statusFallbackMessage };

package/dist/ai/adapter/openai/openaiAdapter.js

@@ -0,0 +1,54 @@
+import { ChatAdapterError } from "../types.js";
+import { errorMessageFromResponse } from "./errors.js";
+import { createOpenAICompatibleStream } from "./createOpenAIStream.js";
+import { createMemoryConversationStore } from "../memoryStore.js";
+//#region src/ai/adapter/openai/openaiAdapter.ts
+function providerLabelFor(baseUrl) {
+	try {
+		return new URL(baseUrl).host;
+	} catch {
+		return "OpenAI compatible";
+	}
+}
+function staticModel(id, provider) {
+	return {
+		id,
+		object: "model",
+		created: 0,
+		owned_by: "openai-compatible",
+		provider,
+		tool_calling_mode: "none"
+	};
+}
+function createOpenAIChatAdapter(options) {
+	const baseUrl = options.baseUrl.replace(/\/$/, "");
+	const doFetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+	const headers = options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {};
+	const store = createMemoryConversationStore({ storageKey: options.storageKey ?? "ai-chat-openai-conversations" });
+	return {
+		conversations: store.conversations,
+		models: { async list() {
+			const providerLabel = providerLabelFor(baseUrl);
+			if (options.models?.length) return {
+				models: options.models.map((id) => staticModel(id, providerLabel)),
+				unreachableSessions: []
+			};
+			const res = await doFetch(`${baseUrl}/models`, { headers });
+			if (!res.ok) throw new ChatAdapterError(await errorMessageFromResponse(res), { status: res.status });
+			return {
+				models: ((await res.json()).data ?? []).map((m) => ({
+					...staticModel(m.id, providerLabel),
+					...m
+				})),
+				unreachableSessions: []
+			};
+		} },
+		streamCompletion: store.recordingStream(createOpenAICompatibleStream({
+			completionsUrl: `${baseUrl}/chat/completions`,
+			buildHeaders: () => headers,
+			...options.fetch ? { fetch: options.fetch } : {}
+		}))
+	};
+}
+//#endregion
+export { createOpenAIChatAdapter };