@botbotgo/agent-harness 0.0.186 → 0.0.187

package/README.md

@@ -954,7 +954,7 @@ ACP transport notes:
 - `serveAcpStdio(runtime)` exposes newline-delimited JSON-RPC over stdio for local IDE, CLI, or subprocess clients.
 - `serveAcpHttp(runtime)` exposes JSON-RPC over HTTP plus SSE runtime events so remote operator surfaces can connect without importing the runtime in-process.
 - `serveA2aHttp(runtime)` exposes a minimal A2A-compatible HTTP JSON-RPC bridge plus agent card discovery, mapping `message/send`, `tasks/get`, and `tasks/cancel` onto the existing session/request runtime surface.
-- `serveAgUiHttp(runtime)` exposes a minimal AG-UI-compatible HTTP SSE bridge that projects `run + output.delta + final result` onto `RUN_STARTED`, `TEXT_MESSAGE_*`, and `RUN_FINISHED` events for UI clients.
+- `serveAgUiHttp(runtime)` exposes an AG-UI-compatible HTTP SSE bridge that projects runtime lifecycle, text output, upstream thinking, step progress, and tool calls onto `RUN_*`, `TEXT_MESSAGE_*`, `THINKING_TEXT_MESSAGE_*`, `STEP_*`, and `TOOL_CALL_*` events for UI clients.
 - `createRuntimeMcpServer(runtime)` and `serveRuntimeMcpOverStdio(runtime)` expose the persisted runtime control surface itself as MCP tools, including sessions, requests, approvals, artifacts, events, and package export helpers.
 - `listRequestEvents(...)` and `exportRequestPackage(...)` are the request-first inspection helpers.
 - `exportRequestPackage(...)` and `exportSessionPackage(...)` package stable runtime records, transcript, approvals, events, and artifacts for operator tooling without reaching into persistence internals.

package/README.zh.md

@@ -913,7 +913,7 @@ ACP transport 说明：
 - `serveAcpStdio(runtime)` 提供基于 stdio 的 newline-delimited JSON-RPC，适合本地 IDE、CLI 或子进程客户端。
 - `serveAcpHttp(runtime)` 提供基于 HTTP 的 JSON-RPC 与 SSE runtime events，适合远程 operator surface 或独立控制面接入。
 - `serveA2aHttp(runtime)` 提供最小可用的 A2A HTTP JSON-RPC bridge 与 agent card discovery，把 `message/send`、`tasks/get`、`tasks/cancel` 映射到现有 session/request runtime surface。
-- `serveAgUiHttp(runtime)` 提供最小可用的 AG-UI HTTP SSE bridge，把现有 `run + output.delta + final result` 投影成 `RUN_STARTED`、`TEXT_MESSAGE_*` 与 `RUN_FINISHED` 事件，便于 UI 客户端直接接入。
+- `serveAgUiHttp(runtime)` 提供 AG-UI HTTP SSE bridge，把 runtime 生命周期、文本输出、upstream thinking、step 进度与 tool call 投影成 `RUN_*`、`TEXT_MESSAGE_*`、`THINKING_TEXT_MESSAGE_*`、`STEP_*` 与 `TOOL_CALL_*` 事件，便于 UI 客户端直接接入。
 - `createRuntimeMcpServer(runtime)` 与 `serveRuntimeMcpOverStdio(runtime)` 会把持久化 runtime 控制面本身暴露成 MCP tools，包括 sessions、requests、approvals、artifacts、events 与 package export helpers。
 - `listRequestEvents(...)` 与 `exportRequestPackage(...)` 是 request-first 的检查 helper。
 - `exportRequestPackage(...)` 与 `exportSessionPackage(...)` 可把稳定 runtime 记录、transcript、approvals、events 和 artifacts 打包给 operator tooling，而不必直接访问 persistence 内部实现。

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.185";
+export declare const AGENT_HARNESS_VERSION = "0.0.186";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.185";
+export const AGENT_HARNESS_VERSION = "0.0.186";

package/dist/protocol/ag-ui/http.d.ts

@@ -20,6 +20,28 @@ export type AgUiEvent = (AgUiBaseEvent & {
     threadId: string;
     runId: string;
     input?: MessageContent;
+}) | (AgUiBaseEvent & {
+    type: "STEP_STARTED";
+    stepId: string;
+    title: string;
+    category: "llm" | "tool" | "skill" | "memory" | "chain" | "approval";
+}) | (AgUiBaseEvent & {
+    type: "STEP_FINISHED";
+    stepId: string;
+    title: string;
+    category: "llm" | "tool" | "skill" | "memory" | "chain" | "approval";
+    status: "completed" | "failed";
+}) | (AgUiBaseEvent & {
+    type: "THINKING_TEXT_MESSAGE_START";
+    messageId: string;
+    role: "assistant";
+}) | (AgUiBaseEvent & {
+    type: "THINKING_TEXT_MESSAGE_CONTENT";
+    messageId: string;
+    delta: string;
+}) | (AgUiBaseEvent & {
+    type: "THINKING_TEXT_MESSAGE_END";
+    messageId: string;
 }) | (AgUiBaseEvent & {
     type: "TEXT_MESSAGE_START";
     messageId: string;
@@ -31,6 +53,25 @@ export type AgUiEvent = (AgUiBaseEvent & {
 }) | (AgUiBaseEvent & {
     type: "TEXT_MESSAGE_END";
     messageId: string;
+}) | (AgUiBaseEvent & {
+    type: "TOOL_CALL_START";
+    toolCallId: string;
+    toolName: string;
+}) | (AgUiBaseEvent & {
+    type: "TOOL_CALL_ARGS";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+}) | (AgUiBaseEvent & {
+    type: "TOOL_CALL_RESULT";
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError?: boolean;
+}) | (AgUiBaseEvent & {
+    type: "TOOL_CALL_END";
+    toolCallId: string;
+    toolName: string;
 }) | (AgUiBaseEvent & {
     type: "RUN_FINISHED";
     threadId: string;

package/dist/protocol/ag-ui/http.js

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { createPersistentId } from "../../utils/id.js";
+import { createUpstreamTimelineReducer } from "../../upstream-events.js";
 function normalizePath(value, fallback) {
     const source = typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
     return source.startsWith("/") ? source : `/${source}`;
@@ -55,6 +56,63 @@ function toRunStarted(event, input) {
         input,
     };
 }
+function asObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function readUpstreamEventName(event) {
+    return typeof asObject(event)?.event === "string" ? String(asObject(event)?.event) : "";
+}
+function readUpstreamToolName(event) {
+    return typeof asObject(event)?.name === "string" ? String(asObject(event)?.name) : "";
+}
+function readUpstreamRunType(event) {
+    return typeof asObject(event)?.run_type === "string" ? String(asObject(event)?.run_type) : "";
+}
+function isToolStartEvent(event) {
+    const eventName = readUpstreamEventName(event);
+    return eventName === "on_tool_start" || (eventName === "on_chain_start" && readUpstreamRunType(event) === "tool");
+}
+function isToolTerminalEvent(event) {
+    const eventName = readUpstreamEventName(event);
+    return eventName === "on_tool_end"
+        || eventName === "on_tool_error"
+        || ((eventName === "on_chain_end" || eventName === "on_chain_error") && readUpstreamRunType(event) === "tool");
+}
+function readToolArgs(event) {
+    const typed = asObject(event);
+    const data = asObject(typed?.data);
+    if (!data || !("input" in data)) {
+        return undefined;
+    }
+    return data.input;
+}
+function createToolCallState() {
+    const activeToolCallIds = new Map();
+    return {
+        start(toolName) {
+            const toolCallId = `tool-${createPersistentId()}`;
+            const activeIds = activeToolCallIds.get(toolName) ?? [];
+            activeIds.push(toolCallId);
+            activeToolCallIds.set(toolName, activeIds);
+            return toolCallId;
+        },
+        peek(toolName) {
+            const activeIds = activeToolCallIds.get(toolName);
+            return activeIds?.at(-1);
+        },
+        finish(toolName) {
+            const activeIds = activeToolCallIds.get(toolName);
+            if (!activeIds || activeIds.length === 0) {
+                return undefined;
+            }
+            const toolCallId = activeIds.pop();
+            if (!activeIds.length) {
+                activeToolCallIds.delete(toolName);
+            }
+            return toolCallId;
+        },
+    };
+}
 export async function serveAgUiOverHttp(runtime, options = {}) {
     const hostname = options.hostname?.trim() || "127.0.0.1";
     const port = typeof options.port === "number" && Number.isFinite(options.port) ? options.port : 0;
@@ -74,7 +132,11 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
         let runId;
         let threadId;
         let messageId;
+        let thinkingMessageId;
         let textMessageStarted = false;
+        let thinkingMessageStarted = false;
+        const toolCalls = createToolCallState();
+        const upstreamReducer = createUpstreamTimelineReducer();
         const ensureTextStart = async () => {
             if (textMessageStarted) {
                 return;
@@ -88,6 +150,37 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
                 role: "assistant",
             });
         };
+        const ensureThinkingTextStart = async () => {
+            if (thinkingMessageStarted) {
+                return;
+            }
+            thinkingMessageId = thinkingMessageId ?? `thinking-${createPersistentId()}`;
+            thinkingMessageStarted = true;
+            await writeSseEvent(response, {
+                type: "THINKING_TEXT_MESSAGE_START",
+                timestamp: createTimestamp(),
+                messageId: thinkingMessageId,
+                role: "assistant",
+            });
+        };
+        const closeOpenMessages = async () => {
+            if (thinkingMessageStarted) {
+                await writeSseEvent(response, {
+                    type: "THINKING_TEXT_MESSAGE_END",
+                    timestamp: createTimestamp(),
+                    messageId: thinkingMessageId,
+                });
+                thinkingMessageStarted = false;
+            }
+            if (textMessageStarted) {
+                await writeSseEvent(response, {
+                    type: "TEXT_MESSAGE_END",
+                    timestamp: createTimestamp(),
+                    messageId: messageId,
+                });
+                textMessageStarted = false;
+            }
+        };
         try {
             const body = await readRequestBody(request);
             const input = parseRunInput(JSON.parse(body));
@@ -120,6 +213,92 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
                             });
                         }
                     },
+                    onUpstreamEvent: async (event) => {
+                        const eventName = readUpstreamEventName(event);
+                        const toolName = readUpstreamToolName(event);
+                        if (isToolStartEvent(event) && toolName) {
+                            const toolCallId = toolCalls.start(toolName);
+                            await writeSseEvent(response, {
+                                type: "TOOL_CALL_START",
+                                timestamp: createTimestamp(),
+                                toolCallId,
+                                toolName,
+                            });
+                            const args = readToolArgs(event);
+                            if (args !== undefined) {
+                                await writeSseEvent(response, {
+                                    type: "TOOL_CALL_ARGS",
+                                    timestamp: createTimestamp(),
+                                    toolCallId,
+                                    toolName,
+                                    args,
+                                });
+                            }
+                        }
+                        const projections = upstreamReducer.consume(event);
+                        for (const projection of projections) {
+                            if (projection.type === "thinking") {
+                                if (!projection.text) {
+                                    continue;
+                                }
+                                await ensureThinkingTextStart();
+                                await writeSseEvent(response, {
+                                    type: "THINKING_TEXT_MESSAGE_CONTENT",
+                                    timestamp: createTimestamp(),
+                                    messageId: thinkingMessageId,
+                                    delta: projection.text,
+                                });
+                                continue;
+                            }
+                            if (projection.type === "step") {
+                                if (projection.status === "started") {
+                                    await writeSseEvent(response, {
+                                        type: "STEP_STARTED",
+                                        timestamp: createTimestamp(),
+                                        stepId: projection.key,
+                                        title: projection.step,
+                                        category: projection.category,
+                                    });
+                                    continue;
+                                }
+                                await writeSseEvent(response, {
+                                    type: "STEP_FINISHED",
+                                    timestamp: createTimestamp(),
+                                    stepId: projection.key,
+                                    title: projection.step,
+                                    category: projection.category,
+                                    status: projection.status,
+                                });
+                                continue;
+                            }
+                            const toolCallId = toolCalls.peek(projection.toolName) ?? toolCalls.start(projection.toolName);
+                            await writeSseEvent(response, {
+                                type: "TOOL_CALL_RESULT",
+                                timestamp: createTimestamp(),
+                                toolCallId,
+                                toolName: projection.toolName,
+                                result: projection.output,
+                                ...(projection.isError !== undefined ? { isError: projection.isError } : {}),
+                            });
+                        }
+                        if (isToolTerminalEvent(event) && toolName) {
+                            const toolCallId = toolCalls.finish(toolName) ?? `tool-${createPersistentId()}`;
+                            await writeSseEvent(response, {
+                                type: "TOOL_CALL_END",
+                                timestamp: createTimestamp(),
+                                toolCallId,
+                                toolName,
+                            });
+                        }
+                        if (eventName === "on_chat_model_end" && thinkingMessageStarted) {
+                            await writeSseEvent(response, {
+                                type: "THINKING_TEXT_MESSAGE_END",
+                                timestamp: createTimestamp(),
+                                messageId: thinkingMessageId,
+                            });
+                            thinkingMessageStarted = false;
+                        }
+                    },
                 },
             });
             runId = runId ?? result.runId;
@@ -133,13 +312,7 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
                     delta: result.output,
                 });
             }
-            if (textMessageStarted) {
-                await writeSseEvent(response, {
-                    type: "TEXT_MESSAGE_END",
-                    timestamp: createTimestamp(),
-                    messageId: messageId,
-                });
-            }
+            await closeOpenMessages();
             await writeSseEvent(response, {
                 type: "RUN_FINISHED",
                 timestamp: createTimestamp(),
@@ -151,6 +324,7 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
             });
         }
         catch (error) {
+            await closeOpenMessages();
             await writeSseEvent(response, {
                 type: "RUN_ERROR",
                 timestamp: createTimestamp(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.186",
+  "version": "0.0.187",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",