@townco/ui 0.1.114 → 0.1.116

package/dist/core/hooks/use-chat-messages.d.ts

@@ -158,11 +158,36 @@ export declare function useChatMessages(client: AcpClient | null, startSession:
                     };
                 })[] | undefined;
                 isStreaming?: boolean | undefined;
+                context_size?: {
+                    systemPromptTokens: number;
+                    toolOverheadTokens?: number | undefined;
+                    mcpOverheadTokens?: number | undefined;
+                    userMessagesTokens: number;
+                    assistantMessagesTokens: number;
+                    toolInputTokens: number;
+                    toolResultsTokens: number;
+                    totalEstimated: number;
+                    llmReportedInputTokens?: number | undefined;
+                    modelContextWindow?: number | undefined;
+                } | undefined;
                 _meta?: {
+                    [x: string]: unknown;
                     semanticName?: string | undefined;
                     agentDefinitionName?: string | undefined;
                     currentActivity?: string | undefined;
                     statusGenerating?: boolean | undefined;
+                    context_size?: {
+                        systemPromptTokens: number;
+                        toolOverheadTokens?: number | undefined;
+                        mcpOverheadTokens?: number | undefined;
+                        userMessagesTokens: number;
+                        assistantMessagesTokens: number;
+                        toolInputTokens: number;
+                        toolResultsTokens: number;
+                        totalEstimated: number;
+                        llmReportedInputTokens?: number | undefined;
+                        modelContextWindow?: number | undefined;
+                    } | undefined;
                 } | undefined;
             }[] | undefined;
             subagentStreaming?: boolean | undefined;

package/dist/core/hooks/use-subagent-stream.d.ts

@@ -0,0 +1,28 @@
+import type { SubagentMessage } from "../schemas/tool-call.js";
+export interface UseSubagentStreamOptions {
+    /** Sub-agent HTTP port */
+    port: number;
+    /** Sub-agent session ID */
+    sessionId: string;
+    /** Base host (defaults to localhost) */
+    host?: string;
+}
+export interface UseSubagentStreamReturn {
+    /** Accumulated messages from the sub-agent */
+    messages: SubagentMessage[];
+    /** Whether the stream is currently active */
+    isStreaming: boolean;
+    /** Error message if connection failed */
+    error: string | null;
+}
+/**
+ * Hook to connect directly to a sub-agent's SSE endpoint and stream messages.
+ *
+ * This hook:
+ * - Connects to the sub-agent's HTTP server at the given port
+ * - Subscribes to the /events SSE endpoint with the session ID
+ * - Parses incoming session/update notifications
+ * - Extracts text chunks and tool calls
+ * - Returns accumulated messages for display
+ */
+export declare function useSubagentStream(options: UseSubagentStreamOptions | null): UseSubagentStreamReturn;

package/dist/core/hooks/use-subagent-stream.js

@@ -0,0 +1,256 @@
+import { createLogger } from "@townco/core";
+import { useCallback, useEffect, useRef, useState } from "react";
+const logger = createLogger("subagent-stream");
+/**
+ * Hook to connect directly to a sub-agent's SSE endpoint and stream messages.
+ *
+ * This hook:
+ * - Connects to the sub-agent's HTTP server at the given port
+ * - Subscribes to the /events SSE endpoint with the session ID
+ * - Parses incoming session/update notifications
+ * - Extracts text chunks and tool calls
+ * - Returns accumulated messages for display
+ */
+export function useSubagentStream(options) {
+    const [messages, setMessages] = useState([]);
+    // Start as streaming=true if options provided, since we're about to connect
+    const [_isStreaming, setIsStreaming] = useState(!!options);
+    const [hasCompleted, setHasCompleted] = useState(false);
+    const [error, setError] = useState(null);
+    const abortControllerRef = useRef(null);
+    const currentMessageRef = useRef(null);
+    const updateTimeoutRef = useRef(null);
+    // Throttled update to prevent excessive re-renders
+    const scheduleUpdate = useCallback(() => {
+        // If there's already a pending timeout, let it handle the update
+        // (it will read the latest currentMessageRef value)
+        if (updateTimeoutRef.current)
+            return;
+        updateTimeoutRef.current = setTimeout(() => {
+            updateTimeoutRef.current = null;
+            if (currentMessageRef.current) {
+                setMessages([{ ...currentMessageRef.current }]);
+            }
+        }, 250); // Batch updates every 250ms
+    }, []);
+    // Process incoming SSE message from sub-agent
+    // Defined BEFORE connectToSubagent so it's available in the closure
+    const processSSEMessage = useCallback((data) => {
+        try {
+            const message = JSON.parse(data);
+            logger.debug("Processing SSE message", {
+                method: message.method,
+                hasParams: !!message.params,
+            });
+            // Check if this is a session/update notification
+            if (message.method === "session/update" && message.params?.update) {
+                const update = message.params.update;
+                logger.debug("Got session update", {
+                    sessionUpdate: update.sessionUpdate,
+                });
+                if (update.sessionUpdate === "agent_message_chunk") {
+                    // Handle text chunk
+                    const content = update.content;
+                    if (content?.type === "text" && typeof content.text === "string") {
+                        if (currentMessageRef.current) {
+                            currentMessageRef.current.content += content.text;
+                            // Add to contentBlocks - append to last text block or create new one
+                            const blocks = currentMessageRef.current.contentBlocks ?? [];
+                            const lastBlock = blocks[blocks.length - 1];
+                            if (lastBlock && lastBlock.type === "text") {
+                                lastBlock.text += content.text;
+                            }
+                            else {
+                                blocks.push({ type: "text", text: content.text });
+                            }
+                            currentMessageRef.current.contentBlocks = blocks;
+                            scheduleUpdate();
+                        }
+                    }
+                }
+                else if (update.sessionUpdate === "tool_call") {
+                    // Handle new tool call
+                    const toolCall = {
+                        id: update.toolCallId ?? `tc-${Date.now()}`,
+                        title: update.title ?? "Tool call",
+                        prettyName: update._meta?.prettyName,
+                        icon: update._meta?.icon,
+                        status: update.status ?? "pending",
+                        content: [],
+                    };
+                    if (currentMessageRef.current) {
+                        currentMessageRef.current.toolCalls = [
+                            ...(currentMessageRef.current.toolCalls ?? []),
+                            toolCall,
+                        ];
+                        // Add to contentBlocks for interleaved display
+                        const blocks = currentMessageRef.current.contentBlocks ?? [];
+                        blocks.push({ type: "tool_call", toolCall });
+                        currentMessageRef.current.contentBlocks = blocks;
+                        scheduleUpdate();
+                    }
+                }
+                else if (update.sessionUpdate === "tool_call_update") {
+                    // Handle tool call update (status change, completion)
+                    if (currentMessageRef.current?.toolCalls) {
+                        const toolCallId = update.toolCallId;
+                        const updateToolCall = (tc) => tc.id === toolCallId
+                            ? {
+                                ...tc,
+                                status: update.status ?? tc.status,
+                                content: update.content ?? tc.content,
+                            }
+                            : tc;
+                        currentMessageRef.current.toolCalls =
+                            currentMessageRef.current.toolCalls.map(updateToolCall);
+                        // Also update in contentBlocks
+                        if (currentMessageRef.current.contentBlocks) {
+                            currentMessageRef.current.contentBlocks =
+                                currentMessageRef.current.contentBlocks.map((block) => block.type === "tool_call"
+                                    ? { ...block, toolCall: updateToolCall(block.toolCall) }
+                                    : block);
+                        }
+                        scheduleUpdate();
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger.error("Failed to parse sub-agent SSE message", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }, [scheduleUpdate]);
+    const connectToSubagent = useCallback(async (port, sessionId, host, protocol) => {
+        const baseUrl = `${protocol}//${host}:${port}`;
+        logger.info("Connecting to sub-agent SSE", { baseUrl, sessionId });
+        setIsStreaming(true);
+        setError(null);
+        // Create abort controller for cleanup
+        const abortController = new AbortController();
+        abortControllerRef.current = abortController;
+        try {
+            logger.info("Fetching SSE endpoint", {
+                url: `${baseUrl}/events`,
+                sessionId,
+            });
+            const response = await fetch(`${baseUrl}/events`, {
+                method: "GET",
+                headers: {
+                    "X-Session-ID": sessionId,
+                },
+                signal: abortController.signal,
+            });
+            logger.info("SSE response received", {
+                status: response.status,
+                ok: response.ok,
+            });
+            if (!response.ok) {
+                throw new Error(`SSE connection failed: HTTP ${response.status}`);
+            }
+            if (!response.body) {
+                throw new Error("Response body is null");
+            }
+            logger.info("Sub-agent SSE connection opened, starting to read stream");
+            // Read the SSE stream
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            // Initialize current message
+            currentMessageRef.current = {
+                id: `subagent-${Date.now()}`,
+                content: "",
+                toolCalls: [],
+                contentBlocks: [],
+                isStreaming: true,
+            };
+            setMessages([currentMessageRef.current]);
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    logger.debug("Sub-agent SSE stream closed");
+                    break;
+                }
+                // Decode the chunk and add to buffer
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete SSE messages
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || ""; // Keep incomplete line in buffer
+                let currentEvent = { event: "message", data: "" };
+                for (const line of lines) {
+                    if (line.startsWith("event:")) {
+                        currentEvent.event = line.substring(6).trim();
+                    }
+                    else if (line.startsWith("data:")) {
+                        currentEvent.data = line.substring(5).trim();
+                    }
+                    else if (line === "") {
+                        // Empty line signals end of event
+                        if (currentEvent.event === "message" && currentEvent.data) {
+                            processSSEMessage(currentEvent.data);
+                        }
+                        // Reset for next event
+                        currentEvent = { event: "message", data: "" };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                logger.debug("Sub-agent SSE stream aborted");
+            }
+            else {
+                const errorMessage = err instanceof Error
+                    ? err.message
+                    : "Failed to connect to sub-agent";
+                logger.error("Sub-agent SSE error", { error: errorMessage });
+                setError(errorMessage);
+            }
+        }
+        finally {
+            // Mark streaming as complete
+            if (currentMessageRef.current) {
+                currentMessageRef.current.isStreaming = false;
+                setMessages((prev) => prev.map((m) => m.id === currentMessageRef.current?.id
+                    ? { ...m, isStreaming: false }
+                    : m));
+            }
+            setHasCompleted(true);
+            setIsStreaming(false);
+            abortControllerRef.current = null;
+            logger.debug("Sub-agent stream completed");
+        }
+    }, [processSSEMessage]);
+    // Extract values from options (memoized to avoid dependency issues)
+    const port = options?.port;
+    const sessionId = options?.sessionId;
+    const host = options?.host ??
+        (typeof window !== "undefined" ? window.location.hostname : "localhost");
+    const protocol = typeof window !== "undefined" ? window.location.protocol : "http:";
+    // Connect when options change
+    useEffect(() => {
+        if (!port || !sessionId) {
+            return;
+        }
+        // Reset state for new connection
+        setMessages([]);
+        setError(null);
+        setHasCompleted(false);
+        setIsStreaming(true);
+        connectToSubagent(port, sessionId, host, protocol);
+        // Cleanup on unmount or options change
+        return () => {
+            if (abortControllerRef.current) {
+                abortControllerRef.current.abort();
+                abortControllerRef.current = null;
+            }
+            if (updateTimeoutRef.current) {
+                clearTimeout(updateTimeoutRef.current);
+                updateTimeoutRef.current = null;
+            }
+        };
+    }, [port, sessionId, host, protocol, connectToSubagent]);
+    // Derive streaming status: streaming if we haven't completed yet
+    const effectiveIsStreaming = !hasCompleted;
+    return { messages, isStreaming: effectiveIsStreaming, error };
+}

package/dist/core/hooks/use-tool-calls.d.ts

@@ -155,11 +155,36 @@ export declare function useToolCalls(client: AcpClient | null): {
                 };
             })[] | undefined;
             isStreaming?: boolean | undefined;
+            context_size?: {
+                systemPromptTokens: number;
+                toolOverheadTokens?: number | undefined;
+                mcpOverheadTokens?: number | undefined;
+                userMessagesTokens: number;
+                assistantMessagesTokens: number;
+                toolInputTokens: number;
+                toolResultsTokens: number;
+                totalEstimated: number;
+                llmReportedInputTokens?: number | undefined;
+                modelContextWindow?: number | undefined;
+            } | undefined;
             _meta?: {
+                [x: string]: unknown;
                 semanticName?: string | undefined;
                 agentDefinitionName?: string | undefined;
                 currentActivity?: string | undefined;
                 statusGenerating?: boolean | undefined;
+                context_size?: {
+                    systemPromptTokens: number;
+                    toolOverheadTokens?: number | undefined;
+                    mcpOverheadTokens?: number | undefined;
+                    userMessagesTokens: number;
+                    assistantMessagesTokens: number;
+                    toolInputTokens: number;
+                    toolResultsTokens: number;
+                    totalEstimated: number;
+                    llmReportedInputTokens?: number | undefined;
+                    modelContextWindow?: number | undefined;
+                } | undefined;
             } | undefined;
         }[] | undefined;
         subagentStreaming?: boolean | undefined;
@@ -312,11 +337,36 @@ export declare function useToolCalls(client: AcpClient | null): {
                 };
             })[] | undefined;
             isStreaming?: boolean | undefined;
+            context_size?: {
+                systemPromptTokens: number;
+                toolOverheadTokens?: number | undefined;
+                mcpOverheadTokens?: number | undefined;
+                userMessagesTokens: number;
+                assistantMessagesTokens: number;
+                toolInputTokens: number;
+                toolResultsTokens: number;
+                totalEstimated: number;
+                llmReportedInputTokens?: number | undefined;
+                modelContextWindow?: number | undefined;
+            } | undefined;
             _meta?: {
+                [x: string]: unknown;
                 semanticName?: string | undefined;
                 agentDefinitionName?: string | undefined;
                 currentActivity?: string | undefined;
                 statusGenerating?: boolean | undefined;
+                context_size?: {
+                    systemPromptTokens: number;
+                    toolOverheadTokens?: number | undefined;
+                    mcpOverheadTokens?: number | undefined;
+                    userMessagesTokens: number;
+                    assistantMessagesTokens: number;
+                    toolInputTokens: number;
+                    toolResultsTokens: number;
+                    totalEstimated: number;
+                    llmReportedInputTokens?: number | undefined;
+                    modelContextWindow?: number | undefined;
+                } | undefined;
             } | undefined;
         }[] | undefined;
         subagentStreaming?: boolean | undefined;

package/dist/core/schemas/chat.d.ts

@@ -237,12 +237,36 @@ export declare const DisplayMessage: z.ZodObject<{
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">>>;
             isStreaming: z.ZodOptional<z.ZodBoolean>;
+            context_size: z.ZodOptional<z.ZodObject<{
+                systemPromptTokens: z.ZodNumber;
+                toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                userMessagesTokens: z.ZodNumber;
+                assistantMessagesTokens: z.ZodNumber;
+                toolInputTokens: z.ZodNumber;
+                toolResultsTokens: z.ZodNumber;
+                totalEstimated: z.ZodNumber;
+                llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+                modelContextWindow: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
             _meta: z.ZodOptional<z.ZodObject<{
                 semanticName: z.ZodOptional<z.ZodString>;
                 agentDefinitionName: z.ZodOptional<z.ZodString>;
                 currentActivity: z.ZodOptional<z.ZodString>;
                 statusGenerating: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strip>>;
+                context_size: z.ZodOptional<z.ZodObject<{
+                    systemPromptTokens: z.ZodNumber;
+                    toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                    mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                    userMessagesTokens: z.ZodNumber;
+                    assistantMessagesTokens: z.ZodNumber;
+                    toolInputTokens: z.ZodNumber;
+                    toolResultsTokens: z.ZodNumber;
+                    totalEstimated: z.ZodNumber;
+                    llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+                    modelContextWindow: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$loose>>;
         }, z.core.$strip>>>;
         subagentStreaming: z.ZodOptional<z.ZodBoolean>;
         subagentCompleted: z.ZodOptional<z.ZodBoolean>;
@@ -508,12 +532,36 @@ export declare const ChatSessionState: z.ZodObject<{
                     }, z.core.$strip>;
                 }, z.core.$strip>], "type">>>;
                 isStreaming: z.ZodOptional<z.ZodBoolean>;
+                context_size: z.ZodOptional<z.ZodObject<{
+                    systemPromptTokens: z.ZodNumber;
+                    toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                    mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                    userMessagesTokens: z.ZodNumber;
+                    assistantMessagesTokens: z.ZodNumber;
+                    toolInputTokens: z.ZodNumber;
+                    toolResultsTokens: z.ZodNumber;
+                    totalEstimated: z.ZodNumber;
+                    llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+                    modelContextWindow: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
                 _meta: z.ZodOptional<z.ZodObject<{
                     semanticName: z.ZodOptional<z.ZodString>;
                     agentDefinitionName: z.ZodOptional<z.ZodString>;
                     currentActivity: z.ZodOptional<z.ZodString>;
                     statusGenerating: z.ZodOptional<z.ZodBoolean>;
-                }, z.core.$strip>>;
+                    context_size: z.ZodOptional<z.ZodObject<{
+                        systemPromptTokens: z.ZodNumber;
+                        toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                        mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                        userMessagesTokens: z.ZodNumber;
+                        assistantMessagesTokens: z.ZodNumber;
+                        toolInputTokens: z.ZodNumber;
+                        toolResultsTokens: z.ZodNumber;
+                        totalEstimated: z.ZodNumber;
+                        llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+                        modelContextWindow: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$loose>>;
             }, z.core.$strip>>>;
             subagentStreaming: z.ZodOptional<z.ZodBoolean>;
             subagentCompleted: z.ZodOptional<z.ZodBoolean>;

package/dist/core/schemas/tool-call.d.ts

@@ -1,4 +1,20 @@
 import { z } from "zod";
+/**
+ * Context size breakdown (as provided by agent metadata).
+ * Stored on message metadata as `_meta.context_size` (or sometimes `context_size`).
+ */
+export declare const ContextSizeSchema: z.ZodObject<{
+    systemPromptTokens: z.ZodNumber;
+    toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+    mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+    userMessagesTokens: z.ZodNumber;
+    assistantMessagesTokens: z.ZodNumber;
+    toolInputTokens: z.ZodNumber;
+    toolResultsTokens: z.ZodNumber;
+    totalEstimated: z.ZodNumber;
+    llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+    modelContextWindow: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 /**
  * Tool call status lifecycle
  */
@@ -262,12 +278,36 @@ export declare const SubagentMessageSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>], "type">>>;
     isStreaming: z.ZodOptional<z.ZodBoolean>;
+    context_size: z.ZodOptional<z.ZodObject<{
+        systemPromptTokens: z.ZodNumber;
+        toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+        mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+        userMessagesTokens: z.ZodNumber;
+        assistantMessagesTokens: z.ZodNumber;
+        toolInputTokens: z.ZodNumber;
+        toolResultsTokens: z.ZodNumber;
+        totalEstimated: z.ZodNumber;
+        llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+        modelContextWindow: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     _meta: z.ZodOptional<z.ZodObject<{
         semanticName: z.ZodOptional<z.ZodString>;
         agentDefinitionName: z.ZodOptional<z.ZodString>;
         currentActivity: z.ZodOptional<z.ZodString>;
         statusGenerating: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
+        context_size: z.ZodOptional<z.ZodObject<{
+            systemPromptTokens: z.ZodNumber;
+            toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+            mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+            userMessagesTokens: z.ZodNumber;
+            assistantMessagesTokens: z.ZodNumber;
+            toolInputTokens: z.ZodNumber;
+            toolResultsTokens: z.ZodNumber;
+            totalEstimated: z.ZodNumber;
+            llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+            modelContextWindow: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>;
 }, z.core.$strip>;
 export type SubagentMessage = z.infer<typeof SubagentMessageSchema>;
 /**
@@ -449,12 +489,36 @@ export declare const ToolCallSchema: z.ZodObject<{
             }, z.core.$strip>;
         }, z.core.$strip>], "type">>>;
         isStreaming: z.ZodOptional<z.ZodBoolean>;
+        context_size: z.ZodOptional<z.ZodObject<{
+            systemPromptTokens: z.ZodNumber;
+            toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+            mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+            userMessagesTokens: z.ZodNumber;
+            assistantMessagesTokens: z.ZodNumber;
+            toolInputTokens: z.ZodNumber;
+            toolResultsTokens: z.ZodNumber;
+            totalEstimated: z.ZodNumber;
+            llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+            modelContextWindow: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         _meta: z.ZodOptional<z.ZodObject<{
             semanticName: z.ZodOptional<z.ZodString>;
             agentDefinitionName: z.ZodOptional<z.ZodString>;
             currentActivity: z.ZodOptional<z.ZodString>;
             statusGenerating: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
+            context_size: z.ZodOptional<z.ZodObject<{
+                systemPromptTokens: z.ZodNumber;
+                toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                userMessagesTokens: z.ZodNumber;
+                assistantMessagesTokens: z.ZodNumber;
+                toolInputTokens: z.ZodNumber;
+                toolResultsTokens: z.ZodNumber;
+                totalEstimated: z.ZodNumber;
+                llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+                modelContextWindow: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
     }, z.core.$strip>>>;
     subagentStreaming: z.ZodOptional<z.ZodBoolean>;
     subagentCompleted: z.ZodOptional<z.ZodBoolean>;
@@ -608,12 +672,36 @@ export declare const ToolCallUpdateSchema: z.ZodObject<{
             }, z.core.$strip>;
         }, z.core.$strip>], "type">>>;
         isStreaming: z.ZodOptional<z.ZodBoolean>;
+        context_size: z.ZodOptional<z.ZodObject<{
+            systemPromptTokens: z.ZodNumber;
+            toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+            mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+            userMessagesTokens: z.ZodNumber;
+            assistantMessagesTokens: z.ZodNumber;
+            toolInputTokens: z.ZodNumber;
+            toolResultsTokens: z.ZodNumber;
+            totalEstimated: z.ZodNumber;
+            llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+            modelContextWindow: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         _meta: z.ZodOptional<z.ZodObject<{
             semanticName: z.ZodOptional<z.ZodString>;
             agentDefinitionName: z.ZodOptional<z.ZodString>;
             currentActivity: z.ZodOptional<z.ZodString>;
             statusGenerating: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
+            context_size: z.ZodOptional<z.ZodObject<{
+                systemPromptTokens: z.ZodNumber;
+                toolOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                mcpOverheadTokens: z.ZodOptional<z.ZodNumber>;
+                userMessagesTokens: z.ZodNumber;
+                assistantMessagesTokens: z.ZodNumber;
+                toolInputTokens: z.ZodNumber;
+                toolResultsTokens: z.ZodNumber;
+                totalEstimated: z.ZodNumber;
+                llmReportedInputTokens: z.ZodOptional<z.ZodNumber>;
+                modelContextWindow: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
     }, z.core.$strip>>>;
     subagentCompleted: z.ZodOptional<z.ZodBoolean>;
     _meta: z.ZodOptional<z.ZodObject<{

package/dist/core/schemas/tool-call.js

@@ -1,4 +1,20 @@
 import { z } from "zod";
+/**
+ * Context size breakdown (as provided by agent metadata).
+ * Stored on message metadata as `_meta.context_size` (or sometimes `context_size`).
+ */
+export const ContextSizeSchema = z.object({
+    systemPromptTokens: z.number(),
+    toolOverheadTokens: z.number().optional(), // Optional for backward compatibility
+    mcpOverheadTokens: z.number().optional(), // Optional for backward compatibility
+    userMessagesTokens: z.number(),
+    assistantMessagesTokens: z.number(),
+    toolInputTokens: z.number(),
+    toolResultsTokens: z.number(),
+    totalEstimated: z.number(),
+    llmReportedInputTokens: z.number().optional(),
+    modelContextWindow: z.number().optional(), // Model's max context window
+});
 /**
  * Tool call status lifecycle
  */
@@ -117,13 +133,19 @@ export const SubagentMessageSchema = z.object({
     /** Interleaved content blocks in arrival order */
     contentBlocks: z.array(SubagentContentBlockSchema).optional(),
     isStreaming: z.boolean().optional(),
+    /** Context size metadata (may be present at top-level in some payloads) */
+    context_size: ContextSizeSchema.optional(),
     _meta: z
         .object({
         semanticName: z.string().optional(),
         agentDefinitionName: z.string().optional(),
         currentActivity: z.string().optional(),
         statusGenerating: z.boolean().optional(),
+        /** Context size metadata (preferred location) */
+        context_size: ContextSizeSchema.optional(),
     })
+        // Preserve forward-compatible metadata fields
+        .passthrough()
         .optional(),
 });
 /**