@parallelworks/ui 0.18.0 → 0.19.1

package/README.md

@@ -1,8 +1,24 @@
 # @parallelworks/ui
 
-Shared UI foundation for Parallel Works packages and applications: the unified
-theme contract, the icon barrel, and (in later versions) core primitives such
-as tables, tooltips, loaders, and modals.
+React components built on one theme contract. Each surface is its own subpath,
+so an application ships only what it imports:
+
+| Subpath | Contents |
+| --- | --- |
+| `.` | theme contract, primitives (buttons, inputs, tables, tooltips, modals, dropdowns, settings layouts, page header), `UIProvider` |
+| `./theme` | `deriveTheme`, presets, `applyTheme` |
+| `./icons` | the icon barrel |
+| `./list` | list pages, tables, row menus and list controls |
+| `./form` | `DynamicForm` and its field registry |
+| `./graph` | job dependency graph and tree view |
+| `./editor` | Monaco editor (`monaco-editor` and `monaco-yaml` are optional peers) |
+| `./logviewer` | log viewer with ANSI color and search |
+| `./file-explorer` | object storage explorer over a host-supplied provider |
+| `./ai`, `./ai/openai`, `./ai/mock` | chat interface and adapters |
+| `./theme.css`, `./base.css`, `./fonts.css`, `./styles.css`, `./logviewer.css`, `./ai.css` | stylesheets |
+
+Hosts bind notifications, strings, navigation, data hooks and the workflow
+engine through `UIProvider`.
 
 ## Theme contract
 
@@ -35,9 +51,9 @@ import '@parallelworks/ui/styles.css'
 ```
 
 The prebuilt stylesheet nests all of its rules in the `pw-ui` cascade layer,
-so loading it alongside other Parallel Works package stylesheets (for example
-`@parallelworks/ai-chat/styles.css`, which uses the `pw-ai-chat` layer) is
-order-independent.
+so its precedence does not depend on where it loads. It includes Tailwind's
+preflight reset; a host with its own Tailwind build should use the `@source`
+route instead to avoid a double preflight.
 
 ## Icons
 
@@ -47,3 +63,67 @@ import { AddIcon, LoaderIcon, TrashIcon } from '@parallelworks/ui/icons'
 
 The barrel re-exports a curated, stable set of icon names over `react-icons`
 so applications never depend on a specific icon pack directly.
+
+## Workflow engine
+
+The workflow surfaces (`/form`'s `DynamicForm`, `/graph`'s `DependencyGraph`,
+the editor's workflow completions, and the log viewer's workflow commands) do
+not implement a workflow format themselves. They call a `WorkflowEngine` that
+the host passes once:
+
+```tsx
+import { UIProvider } from '@parallelworks/ui'
+
+<UIProvider engine={engine}>{app}</UIProvider>
+```
+
+The engine converts input definitions into the form's field tree, resolves
+`${{ }}` expressions, and supplies the job graph's dependencies, matrix
+grouping, step labels and log paths. The form and graph throw without one; the
+editor and log viewer fall back to plain behavior.
+
+## AI chat
+
+`@parallelworks/ui/ai` is a chat interface (thread, composer, streaming,
+sidebar, model selector, attachments, sharing, branching) decoupled from any
+backend through a `ChatAdapter`. State lives in `ChatProvider` and is read
+with `useChat`:
+
+```tsx
+import { ChatProvider, ChatLayout, ChatThread } from '@parallelworks/ui/ai'
+import { createMockChatAdapter } from '@parallelworks/ui/ai/mock'
+
+export function Chat() {
+  return (
+    <ChatProvider
+      adapter={createMockChatAdapter()}
+      currentUser={{ id: 'u1', username: 'you', name: 'You' }}
+      navigation={{ toConversation: id => {}, toNewChat: () => {}, toAttachments: () => {} }}
+      notify={{ success: console.log, error: console.error, info: console.log }}
+    >
+      <ChatLayout>
+        <ChatThread />
+      </ChatLayout>
+    </ChatProvider>
+  )
+}
+```
+
+Swap the mock for `createOpenAIChatAdapter({ baseUrl, apiKey })` from
+`@parallelworks/ui/ai/openai`, or implement `ChatAdapter` against your own
+backend. It requires `conversations`, `models` and `streamCompletion`; the
+optional capability groups (`providers`, `attachments`, `sharing`,
+`allocations`) hide their UI when absent. Adapter methods throw
+`ChatAdapterError` with a user-facing `message`. Model entries and wire
+messages keep OpenAI-compatible snake_case field names.
+
+Tailwind v4 consumers add the chat rules (markdown rendering, streaming
+animations) and streamdown's classes next to the theme contract:
+
+```css
+@import 'streamdown/styles.css';
+@import '@parallelworks/ui/ai.css';
+@source '../node_modules/streamdown/dist/*.js';
+```
+
+The prebuilt `@parallelworks/ui/styles.css` already includes both.

package/dist/ai/adapter/memoryStore.d.ts

@@ -0,0 +1,8 @@
+import { type ConversationsAdapter, type StreamCompletion } from './types.js';
+export interface MemoryConversationStore {
+    conversations: ConversationsAdapter;
+    recordingStream(inner: StreamCompletion): StreamCompletion;
+}
+export declare function createMemoryConversationStore(options?: {
+    storageKey?: string;
+}): MemoryConversationStore;

package/dist/ai/adapter/memoryStore.js

@@ -0,0 +1,152 @@
+import { ChatAdapterError } from "./types.js";
+//#region src/ai/adapter/memoryStore.ts
+function newId() {
+	return crypto.randomUUID();
+}
+function createMemoryConversationStore(options) {
+	const storageKey = options?.storageKey;
+	let conversations = [];
+	if (storageKey) try {
+		const raw = globalThis.localStorage?.getItem(storageKey);
+		if (raw) conversations = JSON.parse(raw);
+	} catch {
+		conversations = [];
+	}
+	const persist = () => {
+		if (storageKey) try {
+			globalThis.localStorage?.setItem(storageKey, JSON.stringify(conversations));
+		} catch {}
+	};
+	const find = (id) => {
+		const conversation = conversations.find((c) => c.id === id);
+		if (!conversation) throw new ChatAdapterError("Conversation not found", { status: 404 });
+		return conversation;
+	};
+	const toSummary = (c) => ({
+		id: c.id,
+		...c.title !== null ? { title: c.title } : {},
+		messageCount: c.messages.length,
+		createdAt: c.createdAt,
+		updatedAt: c.updatedAt,
+		isOwner: true,
+		canCollaborate: true
+	});
+	const recordUser = (req) => {
+		const conversation = conversations.find((c) => c.id === req.conversationId);
+		if (!conversation) return;
+		const last = req.messages[req.messages.length - 1];
+		const userContent = typeof last?.content === "string" ? last.content : "";
+		conversation.messages.push({
+			id: req.userMessageId,
+			role: "user",
+			content: userContent,
+			parentId: req.parentMessageId ?? null,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		conversation.activeBranchId = req.userMessageId;
+		conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		persist();
+	};
+	const recordAssistant = (req, assistant) => {
+		const conversation = conversations.find((c) => c.id === req.conversationId);
+		if (!conversation) return;
+		conversation.messages.push({
+			...assistant,
+			role: "assistant"
+		});
+		conversation.activeBranchId = assistant.id;
+		conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		persist();
+	};
+	return {
+		conversations: {
+			async list() {
+				return [...conversations].sort((a, b) => b.createdAt.localeCompare(a.createdAt)).map(toSummary);
+			},
+			async get(id) {
+				const c = find(id);
+				return {
+					id: c.id,
+					title: c.title,
+					messages: [...c.messages],
+					activeBranchId: c.activeBranchId,
+					createdAt: c.createdAt,
+					updatedAt: c.updatedAt,
+					isOwner: true,
+					canCollaborate: true
+				};
+			},
+			async create(title) {
+				const now = (/* @__PURE__ */ new Date()).toISOString();
+				const conversation = {
+					id: newId(),
+					title: title ?? null,
+					createdAt: now,
+					updatedAt: now,
+					activeBranchId: null,
+					messages: []
+				};
+				conversations.push(conversation);
+				persist();
+				return toSummary(conversation);
+			},
+			async rename(id, title) {
+				find(id).title = title;
+				persist();
+			},
+			async remove(id) {
+				conversations = conversations.filter((c) => c.id !== id);
+				persist();
+			}
+		},
+		recordingStream(inner) {
+			return async (req, handlers, signal) => {
+				let partialContent = "";
+				let partialReasoning = "";
+				const wrappedHandlers = {
+					...handlers,
+					onContent: (chunk) => {
+						partialContent += chunk;
+						handlers.onContent(chunk);
+					},
+					onReasoning: (chunk) => {
+						partialReasoning += chunk;
+						handlers.onReasoning?.(chunk);
+					}
+				};
+				recordUser(req);
+				try {
+					const result = await inner(req, wrappedHandlers, signal);
+					const assistantId = result.messageId || newId();
+					recordAssistant(req, {
+						id: assistantId,
+						content: result.content || null,
+						parentId: req.userMessageId,
+						model: result.model ?? req.model,
+						...result.reasoning ? { reasoning: result.reasoning } : {},
+						...result.responsesOutput.length ? { responsesOutput: result.responsesOutput } : {},
+						...result.toolCalls.length ? { toolCalls: result.toolCalls } : {},
+						timestamp: (/* @__PURE__ */ new Date()).toISOString()
+					});
+					return {
+						...result,
+						messageId: assistantId
+					};
+				} catch (error) {
+					if (error instanceof DOMException && error.name === "AbortError" && (partialContent || partialReasoning)) recordAssistant(req, {
+						id: newId(),
+						content: partialContent || null,
+						parentId: req.userMessageId,
+						model: req.model,
+						...partialReasoning ? { reasoning: partialReasoning } : {},
+						stopped: true,
+						timestamp: (/* @__PURE__ */ new Date()).toISOString()
+					});
+					throw error;
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { createMemoryConversationStore };

package/dist/ai/adapter/mock/index.d.ts

@@ -0,0 +1,2 @@
+export { createMemoryConversationStore, type MemoryConversationStore, } from '../memoryStore.js';
+export { createMockChatAdapter } from './mockAdapter.js';

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

@@ -0,0 +1,3 @@
+import { createMemoryConversationStore } from "../memoryStore.js";
+import { createMockChatAdapter } from "./mockAdapter.js";
+export { createMemoryConversationStore, createMockChatAdapter };

package/dist/ai/adapter/mock/mockAdapter.d.ts

@@ -0,0 +1,4 @@
+import type { ChatAdapter } from '../types.js';
+export declare function createMockChatAdapter(options?: {
+    storageKey?: string;
+}): ChatAdapter;

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.d.ts

@@ -0,0 +1,9 @@
+import { type StreamCompletion, type StreamRequest } from '../types.js';
+export interface OpenAIStreamConfig {
+    completionsUrl: string;
+    responsesUrl?: string;
+    buildHeaders?: (req: StreamRequest) => Record<string, string>;
+    credentials?: RequestCredentials;
+    fetch?: typeof globalThis.fetch;
+}
+export declare function createOpenAICompatibleStream(config: OpenAIStreamConfig): StreamCompletion;

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.d.ts

@@ -0,0 +1,3 @@
+export declare function apiErrorMessage(errorData: unknown, fallback: string): string;
+export declare function statusFallbackMessage(status: number): string;
+export declare function errorMessageFromResponse(res: Response): Promise<string>;

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.d.ts

@@ -0,0 +1,6 @@
+export { createOpenAICompatibleStream, type OpenAIStreamConfig, } from './createOpenAIStream.js';
+export { apiErrorMessage, errorMessageFromResponse, statusFallbackMessage, } from './errors.js';
+export { createOpenAIChatAdapter, type OpenAIChatAdapterOptions, } from './openaiAdapter.js';
+export { buildResponsesRequestBody, parseResponsesSSELine, } from './responses.js';
+export { type ParsedSSELine, parseSSELine, processSSEStream, type SSELineParser, } from './sse.js';
+export type { CompletionChunk, CompletionChunkChoice, CompletionMessage, CompletionRequest, ModelsWireResponse, } from './wire.js';

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

@@ -0,0 +1,6 @@
+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.d.ts

@@ -0,0 +1,9 @@
+import { type ChatAdapter } from '../types.js';
+export interface OpenAIChatAdapterOptions {
+    baseUrl: string;
+    apiKey?: string;
+    models?: string[];
+    storageKey?: string;
+    fetch?: typeof globalThis.fetch;
+}
+export declare function createOpenAIChatAdapter(options: OpenAIChatAdapterOptions): ChatAdapter;

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 };

package/dist/ai/adapter/openai/responses.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedSSELine } from './sse.js';
+import type { CompletionMessage } from './wire.js';
+export declare function buildResponsesRequestBody(model: string, messages: CompletionMessage[]): Record<string, unknown>;
+export declare function parseResponsesSSELine(line: string): ParsedSSELine;

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

@@ -0,0 +1,108 @@
+//#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
+export { buildResponsesRequestBody, parseResponsesSSELine };

package/dist/ai/adapter/openai/sse.d.ts

@@ -0,0 +1,24 @@
+import type { ToolCall, ToolCallDelta } from '../../types.js';
+export type ParsedSSELine = {
+    id?: string | undefined;
+    messageId?: string | undefined;
+    content?: string | undefined;
+    reasoningContent?: string | undefined;
+    toolCalls?: ToolCallDelta[] | undefined;
+    finishReason?: string | null | undefined;
+    model?: string | undefined;
+    error?: string | undefined;
+    responsesOutput?: unknown[] | undefined;
+} | null;
+export type SSELineParser = (line: string) => ParsedSSELine;
+export declare function parseSSELine(line: string): ParsedSSELine;
+/** Process an SSE stream from a ReadableStream reader */
+export declare function processSSEStream(reader: ReadableStreamDefaultReader<Uint8Array>, onContent: (content: string) => void, onToolCall?: (toolCalls: ToolCall[]) => void, onError?: (error: string) => void, onReasoning?: (reasoning: string) => void, onMessageId?: (messageId: string) => void, parseLine?: SSELineParser): Promise<{
+    content: string;
+    messageId: string;
+    toolCalls: ToolCall[];
+    finishReason: string | null;
+    model: string | null;
+    reasoning: string;
+    responsesOutput: unknown[];
+}>;