@parallelworks/ui 0.18.0 → 0.19.0

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/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,81 @@
+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
+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/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/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/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,334 @@
+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
+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/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/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[];
+}>;

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

@@ -0,0 +1,40 @@
+import type { ChatModel, TokenUsage, ToolCall, ToolCallDelta, UnreachableSession } from '../../types.js';
+export interface CompletionMessage {
+    role: string;
+    content?: unknown;
+    name?: string;
+    reasoning_content?: string;
+    responses_output?: unknown[] | null;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[] | null;
+    attachment_ids?: string[] | null | undefined;
+}
+export interface CompletionRequest {
+    model: string;
+    messages: CompletionMessage[];
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export interface CompletionChunkChoice {
+    delta?: {
+        content?: unknown;
+        reasoning_content?: string;
+        tool_calls?: ToolCallDelta[] | null;
+    };
+    finish_reason?: string | null;
+    index?: number;
+}
+export interface CompletionChunk {
+    id: string;
+    model: string;
+    object?: string;
+    created?: number;
+    messageId?: string;
+    choices?: CompletionChunkChoice[] | null;
+    usage?: TokenUsage;
+}
+export interface ModelsWireResponse {
+    object: string;
+    data: ChatModel[] | null;
+    unreachable_sessions?: UnreachableSession[] | null;
+}