@contextableai/clawg-ui 0.2.9 → 0.3.0

package/dist/src/http-handler.js

@@ -0,0 +1,545 @@
+import { randomUUID, createHmac, timingSafeEqual } from "node:crypto";
+import { EventType } from "@ag-ui/core";
+import { EventEncoder } from "@ag-ui/encoder";
+import { stashTools, setWriter, clearWriter, markClientToolNames, wasClientToolCalled, clearClientToolCalled, clearClientToolNames, wasToolFiredInRun, clearToolFiredInRun, } from "./tool-store.js";
+import { aguiChannelPlugin } from "./channel.js";
+import { resolveGatewaySecret } from "./gateway-secret.js";
+// ---------------------------------------------------------------------------
+// Lightweight HTTP helpers (no internal imports needed)
+// ---------------------------------------------------------------------------
+function sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(body));
+}
+function sendMethodNotAllowed(res) {
+    res.setHeader("Allow", "POST");
+    res.statusCode = 405;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end("Method Not Allowed");
+}
+function sendUnauthorized(res) {
+    sendJson(res, 401, { error: { message: "Authentication required", type: "unauthorized" } });
+}
+function readJsonBody(req, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > maxBytes) {
+                reject(new Error("Request body too large"));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+            }
+            catch {
+                reject(new Error("Invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function getBearerToken(req) {
+    const raw = req.headers.authorization?.trim() ?? "";
+    if (!raw.toLowerCase().startsWith("bearer ")) {
+        return undefined;
+    }
+    return raw.slice(7).trim() || undefined;
+}
+// ---------------------------------------------------------------------------
+// HMAC-signed device token utilities
+// ---------------------------------------------------------------------------
+function createDeviceToken(secret, deviceId) {
+    const encodedId = Buffer.from(deviceId).toString("base64url");
+    const signature = createHmac("sha256", secret).update(deviceId).digest("hex").slice(0, 32);
+    return `${encodedId}.${signature}`;
+}
+function verifyDeviceToken(token, secret) {
+    const dotIndex = token.indexOf(".");
+    if (dotIndex <= 0 || dotIndex >= token.length - 1) {
+        return null;
+    }
+    const encodedId = token.slice(0, dotIndex);
+    const providedSig = token.slice(dotIndex + 1);
+    try {
+        const deviceId = Buffer.from(encodedId, "base64url").toString("utf-8");
+        // Validate it looks like a UUID
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(deviceId)) {
+            return null;
+        }
+        const expectedSig = createHmac("sha256", secret).update(deviceId).digest("hex").slice(0, 32);
+        // Constant-time comparison
+        if (providedSig.length !== expectedSig.length) {
+            return null;
+        }
+        const providedBuf = Buffer.from(providedSig);
+        const expectedBuf = Buffer.from(expectedSig);
+        if (!timingSafeEqual(providedBuf, expectedBuf)) {
+            return null;
+        }
+        return deviceId;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Extract text from AG-UI messages
+// ---------------------------------------------------------------------------
+function extractTextContent(msg) {
+    if (typeof msg.content === "string") {
+        return msg.content;
+    }
+    return "";
+}
+// ---------------------------------------------------------------------------
+// Build MsgContext-compatible body from AG-UI messages
+// ---------------------------------------------------------------------------
+function buildBodyFromMessages(messages) {
+    const systemParts = [];
+    const parts = [];
+    let lastUserBody = "";
+    let lastToolBody = "";
+    for (const msg of messages) {
+        const role = msg.role?.trim() ?? "";
+        const content = extractTextContent(msg).trim();
+        // Allow messages with no content (e.g., assistant with only toolCalls)
+        if (!role) {
+            continue;
+        }
+        if (role === "system") {
+            if (content)
+                systemParts.push(content);
+            continue;
+        }
+        if (role === "user") {
+            lastUserBody = content;
+            if (content)
+                parts.push(`User: ${content}`);
+        }
+        else if (role === "assistant") {
+            if (content)
+                parts.push(`Assistant: ${content}`);
+        }
+        else if (role === "tool") {
+            lastToolBody = content;
+            if (content)
+                parts.push(`Tool result: ${content}`);
+        }
+    }
+    // If there's only a single user message, use it directly (no envelope needed)
+    // If there's only a tool result (resuming after client tool), use it directly
+    const userMessages = messages.filter((m) => m.role === "user");
+    const toolMessages = messages.filter((m) => m.role === "tool");
+    let body;
+    if (userMessages.length === 1 && parts.length === 1) {
+        body = lastUserBody;
+    }
+    else if (userMessages.length === 0 && toolMessages.length > 0 && parts.length === toolMessages.length) {
+        // Tool-result-only submission: format as tool result for agent context
+        body = `Tool result: ${lastToolBody}`;
+    }
+    else {
+        body = parts.join("\n");
+    }
+    return {
+        body,
+        systemPrompt: systemParts.length > 0 ? systemParts.join("\n\n") : undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// HTTP handler factory
+// ---------------------------------------------------------------------------
+export function createAguiHttpHandler(api) {
+    const runtime = api.runtime;
+    // Resolve once at init so the per-request handler never touches env vars.
+    const gatewaySecret = resolveGatewaySecret(api);
+    return async function handleAguiRequest(req, res) {
+        // POST-only
+        if (req.method !== "POST") {
+            sendMethodNotAllowed(res);
+            return;
+        }
+        // Verify gateway secret was resolved at startup
+        if (!gatewaySecret) {
+            sendJson(res, 500, {
+                error: { message: "Gateway not configured", type: "server_error" },
+            });
+            return;
+        }
+        // ---------------------------------------------------------------------------
+        // Authentication: No auth (pairing initiation) or Device token
+        // ---------------------------------------------------------------------------
+        let deviceId;
+        const bearerToken = getBearerToken(req);
+        if (!bearerToken) {
+            // No auth header: initiate pairing
+            // Generate new device ID
+            deviceId = randomUUID();
+            // Add to pending via OpenClaw pairing API - returns a pairing code for approval
+            const { code: pairingCode } = await runtime.channel.pairing.upsertPairingRequest({
+                channel: "clawg-ui",
+                id: deviceId,
+                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);
+            // Return pairing pending response with device token and pairing code
+            sendJson(res, 403, {
+                pairing_code: pairingCode,
+                bearer_token: deviceToken,
+                error: {
+                    type: "pairing_pending",
+                    message: "Device pending approval",
+                    pairing: {
+                        pairingCode,
+                        token: deviceToken,
+                        instructions: `Save this token for use as a Bearer token and ask the owner to approve: openclaw pairing approve clawg-ui ${pairingCode}`,
+                    },
+                },
+            });
+            return;
+        }
+        // Device token flow: verify HMAC signature, extract device ID
+        const extractedDeviceId = verifyDeviceToken(bearerToken, gatewaySecret);
+        if (!extractedDeviceId) {
+            sendUnauthorized(res);
+            return;
+        }
+        deviceId = extractedDeviceId;
+        // ---------------------------------------------------------------------------
+        // Pairing check: verify device is approved
+        // ---------------------------------------------------------------------------
+        const storeAllowFrom = await runtime.channel.pairing
+            .readAllowFromStore("clawg-ui")
+            .catch(() => []);
+        const normalizedAllowFrom = storeAllowFrom.map((e) => e.replace(/^clawg-ui:/i, "").toLowerCase());
+        const allowed = normalizedAllowFrom.includes(deviceId.toLowerCase());
+        if (!allowed) {
+            sendJson(res, 403, {
+                error: {
+                    type: "pairing_pending",
+                    message: "Device pending approval. Ask the owner to approve using the pairing code from your initial pairing response.",
+                },
+            });
+            return;
+        }
+        // ---------------------------------------------------------------------------
+        // Device approved - proceed with request
+        // ---------------------------------------------------------------------------
+        // Parse body
+        let body;
+        try {
+            body = await readJsonBody(req, 1024 * 1024);
+        }
+        catch (err) {
+            sendJson(res, 400, {
+                error: { message: String(err), type: "invalid_request_error" },
+            });
+            return;
+        }
+        const input = body;
+        const threadId = input.threadId || `clawg-ui-${randomUUID()}`;
+        const runId = input.runId || `clawg-ui-run-${randomUUID()}`;
+        // Validate messages
+        const messages = Array.isArray(input.messages)
+            ? input.messages
+            : [];
+        const hasUserMessage = messages.some((m) => m.role === "user");
+        const hasToolMessage = messages.some((m) => m.role === "tool");
+        if (!hasUserMessage && !hasToolMessage) {
+            console.log(`[clawg-ui] 400: no user/tool message, roles=[${messages.map((m) => m.role).join(",")}], messageCount=${messages.length}`);
+            sendJson(res, 400, {
+                error: {
+                    message: "At least one user or tool message is required in `messages`.",
+                    type: "invalid_request_error",
+                },
+            });
+            return;
+        }
+        // Build body from messages
+        const { body: messageBody } = buildBodyFromMessages(messages);
+        if (!messageBody.trim()) {
+            console.log(`[clawg-ui] 400: empty extracted body, roles=[${messages.map((m) => m.role).join(",")}], contents=[${messages.map((m) => JSON.stringify(m.content)).join(",")}]`);
+            sendJson(res, 400, {
+                error: {
+                    message: "Could not extract a prompt from `messages`.",
+                    type: "invalid_request_error",
+                },
+            });
+            return;
+        }
+        // Resolve agent route
+        const cfg = runtime.config.loadConfig();
+        const route = runtime.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: "clawg-ui",
+            peer: { kind: "dm", id: `clawg-ui-${threadId}` },
+        });
+        // Set up SSE via EventEncoder
+        const accept = typeof req.headers.accept === "string"
+            ? req.headers.accept
+            : "text/event-stream";
+        const encoder = new EventEncoder({ accept });
+        res.statusCode = 200;
+        res.setHeader("Content-Type", encoder.getContentType());
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        res.setHeader("X-Accel-Buffering", "no");
+        res.flushHeaders?.();
+        let closed = false;
+        let currentMessageId = `msg-${randomUUID()}`;
+        let messageStarted = false;
+        let currentRunId = runId;
+        const writeEvent = (event) => {
+            if (closed) {
+                return;
+            }
+            try {
+                res.write(encoder.encode(event));
+            }
+            catch {
+                // Client may have disconnected
+                closed = true;
+            }
+        };
+        // 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;
+            }
+            // Close any open text message before ending the run
+            if (messageStarted) {
+                writeEvent({
+                    type: EventType.TEXT_MESSAGE_END,
+                    messageId: currentMessageId,
+                    runId: currentRunId,
+                });
+                messageStarted = false;
+            }
+            // 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;
+        });
+        // Emit RUN_STARTED
+        writeEvent({
+            type: EventType.RUN_STARTED,
+            threadId,
+            runId,
+        });
+        // Build inbound context using the plugin runtime (same pattern as msteams)
+        const sessionKey = route.sessionKey;
+        // Stash client-provided tools so the plugin tool factory can pick them up
+        if (Array.isArray(input.tools) && input.tools.length > 0) {
+            stashTools(sessionKey, input.tools);
+            markClientToolNames(sessionKey, input.tools.map((t) => t.name));
+        }
+        // Register SSE writer so before/after_tool_call hooks can emit AG-UI events
+        setWriter(sessionKey, writeEvent, currentMessageId);
+        const storePath = runtime.channel.session.resolveStorePath(cfg.session?.store, {
+            agentId: route.agentId,
+        });
+        const envelopeOptions = runtime.channel.reply.resolveEnvelopeFormatOptions(cfg);
+        const previousTimestamp = runtime.channel.session.readSessionUpdatedAt({
+            storePath,
+            sessionKey,
+        });
+        const envelopedBody = runtime.channel.reply.formatAgentEnvelope({
+            channel: "AG-UI",
+            from: "User",
+            timestamp: new Date(),
+            previousTimestamp,
+            envelope: envelopeOptions,
+            body: messageBody,
+        });
+        const ctxPayload = runtime.channel.reply.finalizeInboundContext({
+            Body: envelopedBody,
+            RawBody: messageBody,
+            CommandBody: messageBody,
+            From: `clawg-ui:${deviceId}`,
+            To: "clawg-ui",
+            SessionKey: sessionKey,
+            ChatType: "direct",
+            ConversationLabel: "AG-UI",
+            SenderName: "AG-UI Client",
+            SenderId: deviceId,
+            Provider: "clawg-ui",
+            Surface: "clawg-ui",
+            MessageSid: runId,
+            Timestamp: Date.now(),
+            WasMentioned: true,
+            CommandAuthorized: true,
+            OriginatingChannel: "clawg-ui",
+        });
+        // Record inbound session
+        await runtime.channel.session.recordInboundSession({
+            storePath,
+            sessionKey,
+            ctx: ctxPayload,
+            onRecordError: () => { },
+        });
+        // Create reply dispatcher — translates reply payloads into AG-UI SSE events
+        const abortController = new AbortController();
+        req.on("close", () => {
+            abortController.abort();
+        });
+        const dispatcher = {
+            sendToolResult: (_payload) => {
+                // Tool call events are emitted by before/after_tool_call hooks
+                return !closed;
+            },
+            sendBlockReply: (payload) => {
+                if (closed || wasClientToolCalled(sessionKey)) {
+                    return false;
+                }
+                const text = payload.text?.trim();
+                if (!text) {
+                    return false;
+                }
+                splitRunIfToolFired();
+                if (!messageStarted) {
+                    messageStarted = true;
+                    writeEvent({
+                        type: EventType.TEXT_MESSAGE_START,
+                        messageId: currentMessageId,
+                        runId: currentRunId,
+                        role: "assistant",
+                    });
+                }
+                // Join chunks with \n\n (breakPreference: paragraph uses double-newline joiner)
+                writeEvent({
+                    type: EventType.TEXT_MESSAGE_CONTENT,
+                    messageId: currentMessageId,
+                    runId: currentRunId,
+                    delta: text + "\n\n",
+                });
+                return true;
+            },
+            sendFinalReply: (payload) => {
+                if (closed) {
+                    return false;
+                }
+                const text = wasClientToolCalled(sessionKey) ? "" : payload.text?.trim();
+                if (text) {
+                    splitRunIfToolFired();
+                    if (!messageStarted) {
+                        messageStarted = true;
+                        writeEvent({
+                            type: EventType.TEXT_MESSAGE_START,
+                            messageId: currentMessageId,
+                            runId: currentRunId,
+                            role: "assistant",
+                        });
+                    }
+                    // Join chunks with \n\n (breakPreference: paragraph uses double-newline joiner)
+                    writeEvent({
+                        type: EventType.TEXT_MESSAGE_CONTENT,
+                        messageId: currentMessageId,
+                        runId: currentRunId,
+                        delta: text + "\n\n",
+                    });
+                }
+                // End the message and run
+                if (messageStarted) {
+                    writeEvent({
+                        type: EventType.TEXT_MESSAGE_END,
+                        messageId: currentMessageId,
+                        runId: currentRunId,
+                    });
+                }
+                writeEvent({
+                    type: EventType.RUN_FINISHED,
+                    threadId,
+                    runId: currentRunId,
+                });
+                closed = true;
+                res.end();
+                return true;
+            },
+            waitForIdle: () => Promise.resolve(),
+            getQueuedCounts: () => ({ tool: 0, block: 0, final: 0 }),
+        };
+        // Dispatch the inbound message — this triggers the agent run
+        try {
+            await runtime.channel.reply.dispatchReplyFromConfig({
+                ctx: ctxPayload,
+                cfg,
+                dispatcher,
+                replyOptions: {
+                    runId,
+                    abortSignal: abortController.signal,
+                    disableBlockStreaming: false,
+                    onAgentRunStart: () => { },
+                },
+            });
+            // If the dispatcher's final reply didn't close the stream, close it now
+            if (!closed) {
+                if (messageStarted) {
+                    writeEvent({
+                        type: EventType.TEXT_MESSAGE_END,
+                        messageId: currentMessageId,
+                        runId: currentRunId,
+                    });
+                }
+                writeEvent({
+                    type: EventType.RUN_FINISHED,
+                    threadId,
+                    runId: currentRunId,
+                });
+                closed = true;
+                res.end();
+            }
+        }
+        catch (err) {
+            if (!closed) {
+                writeEvent({
+                    type: EventType.RUN_ERROR,
+                    message: String(err),
+                });
+                closed = true;
+                res.end();
+            }
+        }
+        finally {
+            clearWriter(sessionKey);
+            clearClientToolCalled(sessionKey);
+            clearClientToolNames(sessionKey);
+            clearToolFiredInRun(sessionKey);
+        }
+    };
+}

package/dist/src/tool-store.d.ts

@@ -0,0 +1,21 @@
+import type { EventType, Tool } from "@ag-ui/core";
+export type EventWriter = (event: {
+    type: EventType;
+} & Record<string, unknown>) => void;
+export declare function stashTools(sessionKey: string, tools: Tool[]): void;
+export declare function popTools(sessionKey: string): Tool[];
+export declare function setWriter(sessionKey: string, writer: EventWriter, messageId: string): void;
+export declare function getWriter(sessionKey: string): EventWriter | undefined;
+export declare function getMessageId(sessionKey: string): string | undefined;
+export declare function clearWriter(sessionKey: string): void;
+export declare function pushToolCallId(sessionKey: string, toolCallId: string): void;
+export declare function popToolCallId(sessionKey: string): string | undefined;
+export declare function markClientToolNames(sessionKey: string, names: string[]): void;
+export declare function isClientTool(sessionKey: string, toolName: string): boolean;
+export declare function clearClientToolNames(sessionKey: string): void;
+export declare function setToolFiredInRun(sessionKey: string): void;
+export declare function wasToolFiredInRun(sessionKey: string): boolean;
+export declare function clearToolFiredInRun(sessionKey: string): void;
+export declare function setClientToolCalled(sessionKey: string): void;
+export declare function wasClientToolCalled(sessionKey: string): boolean;
+export declare function clearClientToolCalled(sessionKey: string): void;

package/dist/src/tool-store.js

@@ -0,0 +1,109 @@
+/**
+ * Per-session store for:
+ * 1. AG-UI client-provided tools (read by the plugin tool factory)
+ * 2. SSE event writer (read by before/after_tool_call hooks)
+ *
+ * Fully reentrant — concurrent requests use different session keys.
+ */
+const toolStore = new Map();
+const writerStore = new Map();
+// --- Client tools (for the plugin tool factory) ---
+export function stashTools(sessionKey, tools) {
+    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) {
+    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) ---
+const messageIdStore = new Map();
+export function setWriter(sessionKey, writer, messageId) {
+    writerStore.set(sessionKey, writer);
+    messageIdStore.set(sessionKey, messageId);
+}
+export function getWriter(sessionKey) {
+    return writerStore.get(sessionKey);
+}
+export function getMessageId(sessionKey) {
+    return messageIdStore.get(sessionKey);
+}
+export function clearWriter(sessionKey) {
+    writerStore.delete(sessionKey);
+    messageIdStore.delete(sessionKey);
+}
+// --- Pending toolCallId stack (before_tool_call pushes, tool_result_persist pops) ---
+// Only used for SERVER-side tools. Client tools emit TOOL_CALL_END in
+// before_tool_call and never push to this stack.
+const pendingStacks = new Map();
+export function pushToolCallId(sessionKey, toolCallId) {
+    let stack = pendingStacks.get(sessionKey);
+    if (!stack) {
+        stack = [];
+        pendingStacks.set(sessionKey, stack);
+    }
+    stack.push(toolCallId);
+    console.log(`[clawg-ui] pushToolCallId: sessionKey=${sessionKey}, toolCallId=${toolCallId}, stackSize=${stack.length}`);
+}
+export function popToolCallId(sessionKey) {
+    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);
+    }
+    return id;
+}
+// --- Client tool name tracking ---
+// Tracks which tool names are client-provided so hooks can distinguish them.
+const clientToolNames = new Map();
+export function markClientToolNames(sessionKey, names) {
+    console.log(`[clawg-ui] markClientToolNames: sessionKey=${sessionKey}, names=${names.join(", ")}`);
+    clientToolNames.set(sessionKey, new Set(names));
+}
+export function isClientTool(sessionKey, toolName) {
+    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) {
+    console.log(`[clawg-ui] clearClientToolNames: sessionKey=${sessionKey}`);
+    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();
+export function setToolFiredInRun(sessionKey) {
+    toolFiredInRunFlags.set(sessionKey, true);
+}
+export function wasToolFiredInRun(sessionKey) {
+    return toolFiredInRunFlags.get(sessionKey) ?? false;
+}
+export function clearToolFiredInRun(sessionKey) {
+    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.
+const clientToolCalledFlags = new Map();
+export function setClientToolCalled(sessionKey) {
+    console.log(`[clawg-ui] setClientToolCalled: sessionKey=${sessionKey}`);
+    clientToolCalledFlags.set(sessionKey, true);
+}
+export function wasClientToolCalled(sessionKey) {
+    const result = clientToolCalledFlags.get(sessionKey) ?? false;
+    console.log(`[clawg-ui] wasClientToolCalled: sessionKey=${sessionKey}, result=${result}`);
+    return result;
+}
+export function clearClientToolCalled(sessionKey) {
+    console.log(`[clawg-ui] clearClientToolCalled: sessionKey=${sessionKey}`);
+    clientToolCalledFlags.delete(sessionKey);
+}