@contextableai/clawg-ui 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.2.2 (2026-02-05)
+
+### Fixed
+- Include `messageId` in `TOOL_CALL_RESULT` events as required by AG-UI client v0.0.43 Zod schema
+
+### Added
+- Debug logging throughout tool call flow for easier troubleshooting
+
+## 0.2.1 (2026-02-05)
+
+### Fixed
+- Return HTTP 429 `rate_limit` error when max pending pairing requests (3) is reached, instead of returning an empty pairing code
+
 ## 0.2.0 (2026-02-04)
 
 ### Added
@@ -13,7 +26,7 @@
 
 ### Security
 - Device tokens are HMAC-signed and do not expose the gateway's master secret
-- Pending pairing requests expire after 10 minutes (max 3 per channel)
+- Pending pairing requests expire after 1 hour (max 3 per channel)
 - Each device requires explicit approval by the gateway owner
 
 ## 0.1.1 (2026-02-03)

package/index.ts

@@ -8,6 +8,7 @@ import { createAguiHttpHandler } from "./src/http-handler.js";
 import { clawgUiToolFactory } from "./src/client-tools.js";
 import {
   getWriter,
+  getMessageId,
   pushToolCallId,
   popToolCallId,
   isClientTool,
@@ -32,16 +33,25 @@ const plugin = {
     // For server tools: TOOL_CALL_END is emitted later by tool_result_persist.
     api.on("before_tool_call", (event, ctx) => {
       const sk = ctx.sessionKey;
-      if (!sk) return;
+      console.log(`[clawg-ui] before_tool_call: tool=${event.toolName}, sessionKey=${sk ?? "none"}, hasParams=${!!(event.params && Object.keys(event.params).length > 0)}, params=${JSON.stringify(event.params ?? {})}`);
+      if (!sk) {
+        console.log(`[clawg-ui] before_tool_call: skipping, no sessionKey`);
+        return;
+      }
       const writer = getWriter(sk);
-      if (!writer) return;
+      if (!writer) {
+        console.log(`[clawg-ui] before_tool_call: skipping, no writer for sessionKey=${sk}`);
+        return;
+      }
       const toolCallId = `tool-${randomUUID()}`;
+      console.log(`[clawg-ui] before_tool_call: emitting TOOL_CALL_START, toolCallId=${toolCallId}`);
       writer({
         type: EventType.TOOL_CALL_START,
         toolCallId,
         toolCallName: event.toolName,
       });
       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({
           type: EventType.TOOL_CALL_ARGS,
           toolCallId,
@@ -52,6 +62,7 @@ const plugin = {
       if (isClientTool(sk, event.toolName)) {
         // Client tool: emit TOOL_CALL_END now. The run will finish and the
         // client initiates a new run with the tool result.
+        console.log(`[clawg-ui] before_tool_call: client tool detected, emitting TOOL_CALL_END immediately`);
         writer({
           type: EventType.TOOL_CALL_END,
           toolCallId,
@@ -60,21 +71,30 @@ const plugin = {
       } else {
         // Server tool: push ID so tool_result_persist can emit
         // TOOL_CALL_RESULT + TOOL_CALL_END after execute() completes.
+        console.log(`[clawg-ui] before_tool_call: server tool, pushing toolCallId to stack`);
         pushToolCallId(sk, toolCallId);
       }
     });
 
     // Emit TOOL_CALL_RESULT + TOOL_CALL_END for server-side tools only.
     // Client tools already emitted TOOL_CALL_END in before_tool_call.
-    api.on("tool_result_persist", (_event, ctx) => {
+    api.on("tool_result_persist", (event, ctx) => {
       const sk = ctx.sessionKey;
-      if (!sk) return;
+      console.log(`[clawg-ui] tool_result_persist: sessionKey=${sk ?? "none"}, event=${JSON.stringify(event)}`);
+      if (!sk) {
+        console.log(`[clawg-ui] tool_result_persist: skipping, no sessionKey`);
+        return;
+      }
       const writer = getWriter(sk);
       const toolCallId = popToolCallId(sk);
-      if (writer && toolCallId) {
+      const messageId = getMessageId(sk);
+      console.log(`[clawg-ui] tool_result_persist: writer=${writer ? "present" : "missing"}, toolCallId=${toolCallId ?? "none"}, messageId=${messageId ?? "none"}`);
+      if (writer && toolCallId && messageId) {
+        console.log(`[clawg-ui] tool_result_persist: emitting TOOL_CALL_RESULT and TOOL_CALL_END`);
         writer({
           type: EventType.TOOL_CALL_RESULT,
           toolCallId,
+          messageId,
           content: "",
         });
         writer({

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@contextableai/clawg-ui",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "AG-UI protocol channel plugin for OpenClaw — connect CopilotKit and AG-UI clients to your OpenClaw gateway",
   "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/contextable/clawg-ui"
+    "url": "git+https://github.com/contextable/clawg-ui.git"
   },
   "keywords": [
     "openclaw",

package/src/client-tools.ts

@@ -10,13 +10,21 @@ import { popTools } from "./tool-store.js";
  */
 export function clawgUiToolFactory(ctx: { sessionKey?: string }) {
   const sessionKey = ctx.sessionKey;
+  console.log(`[clawg-ui] clawgUiToolFactory: sessionKey=${sessionKey ?? "none"}`);
   if (!sessionKey) {
+    console.log(`[clawg-ui] clawgUiToolFactory: returning null, no sessionKey`);
     return null;
   }
   const clientTools = popTools(sessionKey);
+  console.log(`[clawg-ui] clawgUiToolFactory: popped ${clientTools.length} client tools`);
   if (clientTools.length === 0) {
+    console.log(`[clawg-ui] clawgUiToolFactory: returning null, no client tools`);
     return null;
   }
+  console.log(`[clawg-ui] clawgUiToolFactory: creating ${clientTools.length} agent tools`);
+  for (const t of clientTools) {
+    console.log(`[clawg-ui]   creating tool: name=${t.name}, description=${t.description ?? "(none)"}, hasParams=${!!t.parameters}, params=${JSON.stringify(t.parameters ?? {})}`);
+  }
   return clientTools.map((t) => ({
     name: t.name,
     label: t.name,
@@ -28,6 +36,7 @@ export function clawgUiToolFactory(ctx: { sessionKey?: string }) {
       // The run ends, and the client initiates a new run with the tool result.
       // Return args so the agent loop can continue (the dispatcher will
       // suppress any text output after a client tool call).
+      console.log(`[clawg-ui] client tool execute: name=${t.name}, args=${JSON.stringify(args)}`);
       return {
         content: [
           {

package/src/http-handler.ts

@@ -240,6 +240,17 @@ export function createAguiHttpHandler(api: OpenClawPluginApi) {
         pairingAdapter: aguiChannelPlugin.pairing,
       });
 
+      // Rate limit reached - max pending requests exceeded
+      if (!pairingCode) {
+        sendJson(res, 429, {
+          error: {
+            type: "rate_limit",
+            message: "Too many pending pairing requests. Please wait for existing requests to expire (10 minutes) or ask the owner to approve/reject them.",
+          },
+        });
+        return;
+      }
+
       // Generate signed device token
       const deviceToken = createDeviceToken(gatewaySecret, deviceId);
 
@@ -397,7 +408,7 @@ export function createAguiHttpHandler(api: OpenClawPluginApi) {
     }
 
     // Register SSE writer so before/after_tool_call hooks can emit AG-UI events
-    setWriter(sessionKey, writeEvent);
+    setWriter(sessionKey, writeEvent, messageId);
     const storePath = runtime.channel.session.resolveStorePath(cfg.session?.store, {
       agentId: route.agentId,
     });

package/src/tool-store.ts

@@ -1,6 +1,6 @@
 import type { Tool } from "@ag-ui/core";
 
-export type EventWriter = (event: Record<string, unknown>) => void;
+export type EventWriter = (event: { type: string } & Record<string, unknown>) => void;
 
 /**
  * Per-session store for:
@@ -15,27 +15,44 @@ const writerStore = new Map<string, EventWriter>();
 // --- Client tools (for the plugin tool factory) ---
 
 export function stashTools(sessionKey: string, tools: Tool[]): void {
+  console.log(`[clawg-ui] stashTools: sessionKey=${sessionKey}, toolCount=${tools.length}`);
+  for (const t of tools) {
+    console.log(`[clawg-ui]   tool: name=${t.name}, description=${t.description ?? "(none)"}, hasParams=${!!t.parameters}, params=${JSON.stringify(t.parameters ?? {})}`);
+  }
   toolStore.set(sessionKey, tools);
 }
 
 export function popTools(sessionKey: string): Tool[] {
   const tools = toolStore.get(sessionKey) ?? [];
+  console.log(`[clawg-ui] popTools: sessionKey=${sessionKey}, tools=${tools.length}`);
   toolStore.delete(sessionKey);
   return tools;
 }
 
 // --- SSE event writer (for before/after_tool_call hooks) ---
 
-export function setWriter(sessionKey: string, writer: EventWriter): void {
+const messageIdStore = new Map<string, string>();
+
+export function setWriter(
+  sessionKey: string,
+  writer: EventWriter,
+  messageId: string,
+): void {
   writerStore.set(sessionKey, writer);
+  messageIdStore.set(sessionKey, messageId);
 }
 
 export function getWriter(sessionKey: string): EventWriter | undefined {
   return writerStore.get(sessionKey);
 }
 
+export function getMessageId(sessionKey: string): string | undefined {
+  return messageIdStore.get(sessionKey);
+}
+
 export function clearWriter(sessionKey: string): void {
   writerStore.delete(sessionKey);
+  messageIdStore.delete(sessionKey);
 }
 
 // --- Pending toolCallId stack (before_tool_call pushes, tool_result_persist pops) ---
@@ -51,11 +68,13 @@ export function pushToolCallId(sessionKey: string, toolCallId: string): void {
     pendingStacks.set(sessionKey, stack);
   }
   stack.push(toolCallId);
+  console.log(`[clawg-ui] pushToolCallId: sessionKey=${sessionKey}, toolCallId=${toolCallId}, stackSize=${stack.length}`);
 }
 
 export function popToolCallId(sessionKey: string): string | undefined {
   const stack = pendingStacks.get(sessionKey);
   const id = stack?.pop();
+  console.log(`[clawg-ui] popToolCallId: sessionKey=${sessionKey}, toolCallId=${id ?? "none"}, stackSize=${stack?.length ?? 0}`);
   if (stack && stack.length === 0) {
     pendingStacks.delete(sessionKey);
   }
@@ -71,6 +90,7 @@ export function markClientToolNames(
   sessionKey: string,
   names: string[],
 ): void {
+  console.log(`[clawg-ui] markClientToolNames: sessionKey=${sessionKey}, names=${names.join(", ")}`);
   clientToolNames.set(sessionKey, new Set(names));
 }
 
@@ -78,10 +98,13 @@ export function isClientTool(
   sessionKey: string,
   toolName: string,
 ): boolean {
-  return clientToolNames.get(sessionKey)?.has(toolName) ?? false;
+  const result = clientToolNames.get(sessionKey)?.has(toolName) ?? false;
+  console.log(`[clawg-ui] isClientTool: sessionKey=${sessionKey}, toolName=${toolName}, result=${result}`);
+  return result;
 }
 
 export function clearClientToolNames(sessionKey: string): void {
+  console.log(`[clawg-ui] clearClientToolNames: sessionKey=${sessionKey}`);
   clientToolNames.delete(sessionKey);
 }
 
@@ -92,13 +115,17 @@ export function clearClientToolNames(sessionKey: string): void {
 const clientToolCalledFlags = new Map<string, boolean>();
 
 export function setClientToolCalled(sessionKey: string): void {
+  console.log(`[clawg-ui] setClientToolCalled: sessionKey=${sessionKey}`);
   clientToolCalledFlags.set(sessionKey, true);
 }
 
 export function wasClientToolCalled(sessionKey: string): boolean {
-  return clientToolCalledFlags.get(sessionKey) ?? false;
+  const result = clientToolCalledFlags.get(sessionKey) ?? false;
+  console.log(`[clawg-ui] wasClientToolCalled: sessionKey=${sessionKey}, result=${result}`);
+  return result;
 }
 
 export function clearClientToolCalled(sessionKey: string): void {
+  console.log(`[clawg-ui] clearClientToolCalled: sessionKey=${sessionKey}`);
   clientToolCalledFlags.delete(sessionKey);
 }