@parallelworks/ui 0.40.1 → 0.41.0

package/dist/ai/adapter/memoryStore.js

@@ -1,4 +1,5 @@
 import { ChatAdapterError } from "./types.js";
+import { applyPartDelta, finalizeParts } from "../core/parts.js";
 //#region src/ai/adapter/memoryStore.ts
 function newId() {
 	return crypto.randomUUID();
@@ -103,6 +104,7 @@ function createMemoryConversationStore(options) {
 			return async (req, handlers, signal) => {
 				let partialContent = "";
 				let partialReasoning = "";
+				let parts = [];
 				const wrappedHandlers = {
 					...handlers,
 					onContent: (chunk) => {
@@ -112,6 +114,10 @@ function createMemoryConversationStore(options) {
 					onReasoning: (chunk) => {
 						partialReasoning += chunk;
 						handlers.onReasoning?.(chunk);
+					},
+					onPart: (delta) => {
+						parts = applyPartDelta(parts, delta);
+						handlers.onPart?.(delta);
 					}
 				};
 				recordUser(req);
@@ -126,6 +132,7 @@ function createMemoryConversationStore(options) {
 						...result.reasoning ? { reasoning: result.reasoning } : {},
 						...result.responsesOutput.length ? { responsesOutput: result.responsesOutput } : {},
 						...result.toolCalls.length ? { toolCalls: result.toolCalls } : {},
+						...parts.length ? { parts: finalizeParts(parts) } : {},
 						timestamp: (/* @__PURE__ */ new Date()).toISOString()
 					});
 					return {

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

@@ -5,6 +5,7 @@ var CANNED_REPLIES = [
 	"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 TOOL_REPLY = "Two clusters are running: **gpu-a** with 4 nodes, and **cpu-batch**, idle and scaled to zero.";
 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) => {
@@ -30,21 +31,32 @@ function createMockChatAdapter(options) {
 		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"
-				}],
+				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"
+					},
+					{
+						id: "mock:local/canned-tools",
+						object: "model",
+						created: 0,
+						owned_by: "mock",
+						provider: "Mock Provider",
+						tool_calling_mode: "native"
+					}
+				],
 				unreachableSessions: [],
 				providerIssues: []
 			};
@@ -57,8 +69,31 @@ function createMockChatAdapter(options) {
 				reasoning += word;
 				handlers.onReasoning?.(word);
 			}
-			const reply = CANNED_REPLIES[replyIndex % CANNED_REPLIES.length] ?? "";
-			replyIndex++;
+			const usesTools = req.model.includes("tools");
+			if (usesTools) {
+				const id = `call-${crypto.randomUUID()}`;
+				handlers.onPart?.({
+					type: "tool_start",
+					id,
+					name: "list_clusters",
+					args: "{}"
+				});
+				await sleep(900, signal);
+				handlers.onPart?.({
+					type: "tool_end",
+					id,
+					result: JSON.stringify([{
+						name: "gpu-a",
+						status: "on",
+						nodes: 4
+					}, {
+						name: "cpu-batch",
+						status: "on",
+						nodes: 0
+					}])
+				});
+			}
+			const reply = usesTools ? TOOL_REPLY : CANNED_REPLIES[replyIndex++ % CANNED_REPLIES.length] ?? "";
 			await sleep(250, signal);
 			let content = "";
 			for (const word of reply.split(/(?<= )/)) {

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

@@ -27,7 +27,7 @@ function createOpenAICompatibleStream(config) {
 		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);
+		return processSSEStream(reader, handlers.onContent, void 0, void 0, handlers.onReasoning, handlers.onMessageId, useResponses ? parseResponsesSSELine : void 0, handlers.onPart);
 	};
 }
 //#endregion

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

@@ -3,4 +3,4 @@ export { apiErrorMessage, errorMessageFromResponse, statusFallbackMessage, } fro
 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';
+export type { CompletionChunk, CompletionChunkChoice, CompletionMessage, CompletionRequest, ModelsWireResponse, ToolResultChunk, } from './wire.js';

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

@@ -1,10 +1,13 @@
 import type { ToolCall, ToolCallDelta } from '../../types.js';
+import type { PartDelta } from '../types.js';
+import type { ToolResultChunk } from './wire.js';
 export type ParsedSSELine = {
     id?: string | undefined;
     messageId?: string | undefined;
     content?: string | undefined;
     reasoningContent?: string | undefined;
     toolCalls?: ToolCallDelta[] | undefined;
+    toolResult?: ToolResultChunk | undefined;
     finishReason?: string | null | undefined;
     model?: string | undefined;
     error?: string | undefined;
@@ -12,8 +15,11 @@ export type ParsedSSELine = {
 } | 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<{
+/** Process an SSE stream from a ReadableStream reader. With `onPart`, tool
+ *  calls stream as parts; a call the gateway answered with a result is left
+ *  off the returned `toolCalls`, which then hold only calls the caller must
+ *  run. */
+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, onPart?: (delta: PartDelta) => void): Promise<{
     content: string;
     messageId: string;
     toolCalls: ToolCall[];

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

@@ -14,6 +14,7 @@ function parseSSELine(line) {
 			content: choice?.delta?.content,
 			reasoningContent: choice?.delta?.reasoning_content,
 			toolCalls: choice?.delta?.tool_calls ?? void 0,
+			toolResult: chunk.toolResult,
 			finishReason: choice?.finish_reason,
 			model: chunk.model
 		};
@@ -21,8 +22,11 @@ function parseSSELine(line) {
 		return null;
 	}
 }
-/** Process an SSE stream from a ReadableStream reader */
-async function processSSEStream(reader, onContent, onToolCall, onError, onReasoning, onMessageId, parseLine = parseSSELine) {
+/** Process an SSE stream from a ReadableStream reader. With `onPart`, tool
+*  calls stream as parts; a call the gateway answered with a result is left
+*  off the returned `toolCalls`, which then hold only calls the caller must
+*  run. */
+async function processSSEStream(reader, onContent, onToolCall, onError, onReasoning, onMessageId, parseLine = parseSSELine, onPart) {
 	const decoder = new TextDecoder();
 	let assistantContent = "";
 	let assistantReasoning = "";
@@ -31,6 +35,19 @@ async function processSSEStream(reader, onContent, onToolCall, onError, onReason
 	let resolvedModel = null;
 	let responsesOutput = [];
 	const toolCallsMap = /* @__PURE__ */ new Map();
+	const startedToolCalls = /* @__PURE__ */ new Set();
+	const answeredToolCalls = /* @__PURE__ */ new Set();
+	const startToolCall = (index) => {
+		const tc = toolCallsMap.get(index);
+		if (!onPart || !tc?.id || !tc.name || startedToolCalls.has(index)) return;
+		startedToolCalls.add(index);
+		onPart({
+			type: "tool_start",
+			id: tc.id,
+			name: tc.name,
+			args: tc.arguments
+		});
+	};
 	let lineBuffer = "";
 	while (true) {
 		const result = await reader.read();
@@ -64,13 +81,32 @@ async function processSSEStream(reader, onContent, onToolCall, onError, onReason
 					if (tc.index === void 0) continue;
 					const existing = toolCallsMap.get(tc.index);
 					if (existing) {
-						if (tc.function?.arguments) existing.arguments += tc.function.arguments;
+						existing.id ||= tc.id || "";
+						existing.name ||= tc.function?.name || "";
+						if (tc.function?.arguments) {
+							existing.arguments += tc.function.arguments;
+							if (startedToolCalls.has(tc.index)) onPart?.({
+								type: "tool_update",
+								id: existing.id,
+								args: tc.function.arguments
+							});
+						}
 					} else toolCallsMap.set(tc.index, {
 						id: tc.id || "",
 						type: tc.type || "function",
 						name: tc.function?.name || "",
 						arguments: tc.function?.arguments || ""
 					});
+					startToolCall(tc.index);
+				}
+				if (parsed.toolResult) {
+					answeredToolCalls.add(parsed.toolResult.toolCallId);
+					onPart?.({
+						type: "tool_end",
+						id: parsed.toolResult.toolCallId,
+						result: parsed.toolResult.content,
+						...parsed.toolResult.isError ? { isError: true } : {}
+					});
 				}
 			}
 		}
@@ -89,7 +125,7 @@ async function processSSEStream(reader, onContent, onToolCall, onError, onReason
 			if (parsed.finishReason) finishReason = parsed.finishReason;
 		}
 	}
-	const toolCalls = Array.from(toolCallsMap.values()).map((tc) => ({
+	const toolCalls = Array.from(toolCallsMap.values()).filter((tc) => !answeredToolCalls.has(tc.id)).map((tc) => ({
 		id: tc.id,
 		type: tc.type,
 		function: {

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

@@ -30,9 +30,15 @@ export interface CompletionChunk {
     object?: string;
     created?: number;
     messageId?: string;
+    toolResult?: ToolResultChunk;
     choices?: CompletionChunkChoice[] | null;
     usage?: TokenUsage;
 }
+export interface ToolResultChunk {
+    toolCallId: string;
+    content: string;
+    isError?: boolean;
+}
 export interface ModelsWireResponse {
     object: string;
     data: ChatModel[] | null;

package/dist/ai/core/ChatProvider.js

@@ -1,4 +1,4 @@
-import { applyPartDelta, finalizeParts } from "./parts.js";
+import { applyPartDelta, finalizeParts, toolTurnMessages } from "./parts.js";
 import { chatReducer, initialState } from "./chatReducer.js";
 import { ChatConfigProvider, resolveChatConfig } from "./config.js";
 import { providerIssueFor } from "./providerIssues.js";
@@ -392,7 +392,7 @@ function ChatProvider({ adapter, currentUser, navigation, notify, activeConversa
 			});
 		};
 		const apiMessages = [
-			...(isNewConversation ? [] : state.currentConversation?.messages || []).filter((m) => m.content || m.toolCalls?.length).map((m) => {
+			...(isNewConversation ? [] : state.currentConversation?.messages || []).filter((m) => m.content || m.toolCalls?.length || m.parts?.length).flatMap((m) => {
 				const msg = {
 					role: m.role,
 					content: m.content || null
@@ -401,7 +401,7 @@ function ChatProvider({ adapter, currentUser, navigation, notify, activeConversa
 				if (m.role === "assistant" && m.toolCalls?.length) msg.tool_calls = m.toolCalls;
 				if (m.role === "assistant" && m.responsesOutput?.length && m.model === state.selectedProvider) msg.responses_output = m.responsesOutput;
 				if (m.role === "tool" && m.toolCallId) msg.tool_call_id = m.toolCallId;
-				return msg;
+				return m.role === "assistant" ? toolTurnMessages(m.parts, msg) : [msg];
 			}),
 			...precedingApiMessages,
 			{

package/dist/ai/core/parts.d.ts

@@ -1,3 +1,4 @@
+import type { CompletionMessage } from '../adapter/openai/wire.js';
 import type { PartDelta } from '../adapter/types.js';
 import type { MessagePart } from '../types.js';
 /** Fold one streamed PartDelta into a parts timeline. Pure: returns a new
@@ -5,6 +6,10 @@ import type { MessagePart } from '../types.js';
  *  and the provider's local accumulation. Unknown target ids are dropped
  *  rather than invented — an end without a start has nothing to render. */
 export declare function applyPartDelta(parts: MessagePart[], delta: PartDelta): MessagePart[];
+/** The wire history for an assistant turn whose tool calls the gateway ran:
+ *  the calls, each result, then the answer. A turn with no finished tool
+ *  calls comes back as the answer alone. */
+export declare function toolTurnMessages(parts: MessagePart[] | null | undefined, answer: CompletionMessage): CompletionMessage[];
 /** A turn can end (completed or stopped) with tool calls still marked
  *  running — the transport died before their tool_end arrived. A stored
  *  message must not spin forever, so close them out as interrupted. */

package/dist/ai/core/parts.js

@@ -90,6 +90,33 @@ function applyPartDelta(parts, delta) {
 function isStreamedText(part) {
 	return part?.kind === "text" || part?.kind === "reasoning";
 }
+/** The wire history for an assistant turn whose tool calls the gateway ran:
+*  the calls, each result, then the answer. A turn with no finished tool
+*  calls comes back as the answer alone. */
+function toolTurnMessages(parts, answer) {
+	const calls = (parts ?? []).filter((p) => p.kind === "tool_call" && p.status !== "running" && p.result !== void 0);
+	if (calls.length === 0) return [answer];
+	return [
+		{
+			role: "assistant",
+			content: null,
+			tool_calls: calls.map((c) => ({
+				id: c.id,
+				type: "function",
+				function: {
+					name: c.name,
+					arguments: c.args
+				}
+			}))
+		},
+		...calls.map((c) => ({
+			role: "tool",
+			tool_call_id: c.id,
+			content: c.result
+		})),
+		...answer.content ? [answer] : []
+	];
+}
 /** A turn can end (completed or stopped) with tool calls still marked
 *  running — the transport died before their tool_end arrived. A stored
 *  message must not spin forever, so close them out as interrupted. */
@@ -101,4 +128,4 @@ function finalizeParts(parts) {
 	} : p);
 }
 //#endregion
-export { applyPartDelta, finalizeParts };
+export { applyPartDelta, finalizeParts, toolTurnMessages };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parallelworks/ui",
-  "version": "0.40.1",
+  "version": "0.41.0",
   "description": "React UI components: a theme contract, icons, primitives, lists, forms, a job graph, a code editor, a log viewer, a file explorer and an AI chat, each on its own subpath",
   "license": "Apache-2.0",
   "repository": {