@contextableai/clawg-ui 0.2.3 → 0.2.4

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.2.4 (2026-02-06)
+
+### Changed
+- Separate tool call events and text message events into distinct AG-UI runs — when text follows a tool call, the tool run is finished and a new run (with a unique runId) is started for the text messages
+
 ## 0.2.3 (2026-02-06)
 
 ### Fixed

package/index.ts

@@ -13,6 +13,7 @@ import {
   popToolCallId,
   isClientTool,
   setClientToolCalled,
+  setToolFiredInRun,
 } from "./src/tool-store.js";
 
 const plugin = {
@@ -50,6 +51,7 @@ const plugin = {
         toolCallId,
         toolCallName: event.toolName,
       });
+      setToolFiredInRun(sk);
       if (event.params && Object.keys(event.params).length > 0) {
         console.log(`[clawg-ui] before_tool_call: emitting TOOL_CALL_ARGS, params=${JSON.stringify(event.params)}`);
         writer({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextableai/clawg-ui",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "AG-UI protocol channel plugin for OpenClaw — connect CopilotKit and AG-UI clients to your OpenClaw gateway",
   "type": "module",
   "license": "MIT",

package/src/http-handler.ts

@@ -12,6 +12,8 @@ import {
   wasClientToolCalled,
   clearClientToolCalled,
   clearClientToolNames,
+  wasToolFiredInRun,
+  clearToolFiredInRun,
 } from "./tool-store.js";
 import { aguiChannelPlugin } from "./channel.js";
 
@@ -384,6 +386,31 @@ export function createAguiHttpHandler(api: OpenClawPluginApi) {
       }
     };
 
+    // If a tool call was emitted in the current run, finish that run and start
+    // a fresh one for text messages. This keeps tool events and text events in
+    // separate runs per the AG-UI protocol.
+    const splitRunIfToolFired = () => {
+      if (!wasToolFiredInRun(sessionKey)) {
+        return;
+      }
+      // End the tool run
+      writeEvent({
+        type: EventType.RUN_FINISHED,
+        threadId,
+        runId: currentRunId,
+      });
+      // Start a new run for text messages
+      currentRunId = `clawg-ui-run-${randomUUID()}`;
+      currentMessageId = `msg-${randomUUID()}`;
+      messageStarted = false;
+      clearToolFiredInRun(sessionKey);
+      writeEvent({
+        type: EventType.RUN_STARTED,
+        threadId,
+        runId: currentRunId,
+      });
+    };
+
     // Handle client disconnect
     req.on("close", () => {
       closed = true;
@@ -475,6 +502,8 @@ export function createAguiHttpHandler(api: OpenClawPluginApi) {
           return false;
         }
 
+        splitRunIfToolFired();
+
         if (!messageStarted) {
           messageStarted = true;
           writeEvent({
@@ -501,6 +530,8 @@ export function createAguiHttpHandler(api: OpenClawPluginApi) {
         const text = wasClientToolCalled(sessionKey) ? "" : payload.text?.trim();
 
         if (text) {
+          splitRunIfToolFired();
+
           if (!messageStarted) {
             messageStarted = true;
             writeEvent({
@@ -586,6 +617,7 @@ export function createAguiHttpHandler(api: OpenClawPluginApi) {
       clearWriter(sessionKey);
       clearClientToolCalled(sessionKey);
       clearClientToolNames(sessionKey);
+      clearToolFiredInRun(sessionKey);
     }
   };
 }

package/src/tool-store.ts

@@ -108,6 +108,26 @@ export function clearClientToolNames(sessionKey: string): void {
   clientToolNames.delete(sessionKey);
 }
 
+// --- Tool-fired-in-run flag ---
+// Tracks whether any tool call (server or client) was emitted in the current
+// run. When a text message is about to be emitted and this flag is set, the
+// http-handler splits into a new run so tool events and text events live in
+// separate runs (per AG-UI protocol best practice).
+
+const toolFiredInRunFlags = new Map<string, boolean>();
+
+export function setToolFiredInRun(sessionKey: string): void {
+  toolFiredInRunFlags.set(sessionKey, true);
+}
+
+export function wasToolFiredInRun(sessionKey: string): boolean {
+  return toolFiredInRunFlags.get(sessionKey) ?? false;
+}
+
+export function clearToolFiredInRun(sessionKey: string): void {
+  toolFiredInRunFlags.delete(sessionKey);
+}
+
 // --- Client-tool-called flag ---
 // Set when a client tool is invoked during a run so the dispatcher can
 // suppress text output and end the run after the tool call events.