@townco/agent 0.1.50 → 0.1.52

package/dist/acp-server/adapter.d.ts

@@ -19,7 +19,17 @@ export declare class AgentAcpAdapter implements acp.Agent {
     private storage;
     private noSession;
     private agentDir;
+    private agentName;
+    private agentDisplayName;
+    private agentVersion;
+    private agentDescription;
+    private agentSuggestedPrompts;
     constructor(agent: AgentRunner, connection: acp.AgentSideConnection, agentDir?: string, agentName?: string);
+    /**
+     * Helper to save session to disk
+     * Call this after any modification to session.messages or session.context
+     */
+    private saveSessionToDisk;
     initialize(_params: acp.InitializeRequest): Promise<acp.InitializeResponse>;
     newSession(params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;
     loadSession(params: acp.LoadSessionRequest): Promise<acp.LoadSessionResponse>;

package/dist/acp-server/adapter.js

@@ -1,6 +1,8 @@
 import * as acp from "@agentclientprotocol/sdk";
 import { createLogger } from "@townco/core";
 import { HookExecutor, loadHookCallback } from "../runner/hooks";
+import { calculateContextSize, } from "../utils/context-size-calculator.js";
+import { countToolResultTokens } from "../utils/token-counter.js";
 import { SessionStorage, } from "./session-storage.js";
 const logger = createLogger("adapter");
 /**
@@ -12,7 +14,7 @@ export const SUBAGENT_MODE_KEY = "town.com/isSubagent";
  * Create a context snapshot based on the previous context
  * Preserves full messages from previous context and adds new pointers
  */
-function createContextSnapshot(messageCount, timestamp, previousContext, inputTokens) {
+function createContextSnapshot(messageCount, timestamp, previousContext, context_size) {
     const messages = [];
     if (previousContext) {
         // Start with all messages from previous context
@@ -49,7 +51,14 @@ function createContextSnapshot(messageCount, timestamp, previousContext, inputTo
         timestamp,
         messages,
         compactedUpTo: previousContext?.compactedUpTo,
-        inputTokens,
+        context_size: context_size || {
+            systemPromptTokens: 0,
+            userMessagesTokens: 0,
+            assistantMessagesTokens: 0,
+            toolInputTokens: 0,
+            toolResultsTokens: 0,
+            totalEstimated: 0,
+        },
     };
 }
 /**
@@ -89,11 +98,21 @@ export class AgentAcpAdapter {
     storage;
     noSession;
     agentDir;
+    agentName;
+    agentDisplayName;
+    agentVersion;
+    agentDescription;
+    agentSuggestedPrompts;
     constructor(agent, connection, agentDir, agentName) {
         this.connection = connection;
         this.sessions = new Map();
         this.agent = agent;
         this.agentDir = agentDir;
+        this.agentName = agentName;
+        this.agentDisplayName = agent.definition.displayName;
+        this.agentVersion = agent.definition.version;
+        this.agentDescription = agent.definition.description;
+        this.agentSuggestedPrompts = agent.definition.suggestedPrompts;
         this.noSession = process.env.TOWN_NO_SESSION === "true";
         this.storage =
             agentDir && agentName && !this.noSession
@@ -102,18 +121,65 @@ export class AgentAcpAdapter {
         logger.info("Initialized with", {
             agentDir,
             agentName,
+            agentDisplayName: this.agentDisplayName,
+            agentVersion: this.agentVersion,
+            agentDescription: this.agentDescription,
+            suggestedPrompts: this.agentSuggestedPrompts,
             noSession: this.noSession,
             hasStorage: this.storage !== null,
             sessionStoragePath: this.storage ? `${agentDir}/.sessions` : null,
         });
     }
+    /**
+     * Helper to save session to disk
+     * Call this after any modification to session.messages or session.context
+     */
+    async saveSessionToDisk(sessionId, session) {
+        if (!this.noSession && this.storage) {
+            try {
+                await this.storage.saveSession(sessionId, session.messages, session.context);
+                logger.debug("Saved session to disk", {
+                    sessionId,
+                    messageCount: session.messages.length,
+                    contextCount: session.context.length,
+                });
+            }
+            catch (error) {
+                logger.error(`Failed to save session ${sessionId}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
     async initialize(_params) {
-        return {
+        const response = {
             protocolVersion: acp.PROTOCOL_VERSION,
             agentCapabilities: {
                 loadSession: !this.noSession && this.storage !== null,
             },
         };
+        if (this.agentName) {
+            response.agentInfo = {
+                name: this.agentName,
+                version: this.agentVersion ?? "0.0.0",
+                // title is the ACP field for human-readable display name
+                ...(this.agentDisplayName ? { title: this.agentDisplayName } : {}),
+            };
+        }
+        // Pass description and suggestedPrompts via _meta extension point
+        // since Implementation doesn't support these fields
+        if (this.agentDescription || this.agentSuggestedPrompts) {
+            response._meta = {
+                ...response._meta,
+                ...(this.agentDescription
+                    ? { agentDescription: this.agentDescription }
+                    : {}),
+                ...(this.agentSuggestedPrompts
+                    ? { suggestedPrompts: this.agentSuggestedPrompts }
+                    : {}),
+            };
+        }
+        return response;
     }
     async newSession(params) {
         const sessionId = Math.random().toString(36).substring(2);
@@ -216,6 +282,37 @@ export class AgentAcpAdapter {
                 }
             }
         }
+        // After replay completes, send the latest context size to the UI
+        const latestContext = storedSession.context.length > 0
+            ? storedSession.context[storedSession.context.length - 1]
+            : undefined;
+        if (latestContext?.context_size) {
+            logger.info("Sending context size to UI after session replay", {
+                sessionId: params.sessionId,
+                contextSize: latestContext.context_size,
+            });
+            this.connection.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: "agent_message_chunk",
+                    content: {
+                        type: "text",
+                        text: "",
+                    },
+                    _meta: {
+                        context_size: latestContext.context_size,
+                        isReplay: true,
+                    },
+                },
+            });
+        }
+        else {
+            logger.warn("No context size available after session replay", {
+                sessionId: params.sessionId,
+                hasLatestContext: !!latestContext,
+                contextLength: storedSession.context.length,
+            });
+        }
         return {};
     }
     async authenticate(_params) {
@@ -261,12 +358,49 @@ export class AgentAcpAdapter {
                 timestamp: new Date().toISOString(),
             };
             session.messages.push(userMessage);
+            logger.debug("User message added to session", {
+                sessionId: params.sessionId,
+                messageCount: session.messages.length,
+            });
+            // Save immediately after user message, even before context calculation
+            // This ensures the session file exists if anything crashes below
+            await this.saveSessionToDisk(params.sessionId, session);
+            logger.debug("Session saved after user message", {
+                sessionId: params.sessionId,
+            });
             // Create context snapshot based on previous context
+            logger.debug("Starting context snapshot creation", {
+                sessionId: params.sessionId,
+            });
             const previousContext = session.context.length > 0
                 ? session.context[session.context.length - 1]
                 : undefined;
-            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, previousContext?.inputTokens ?? 0);
+            // Calculate context size for this snapshot
+            // Build message pointers for the new context (previous messages + new user message)
+            const messageEntries = previousContext
+                ? [
+                    ...previousContext.messages,
+                    { type: "pointer", index: session.messages.length - 1 },
+                ]
+                : [{ type: "pointer", index: 0 }];
+            // Resolve message entries to actual messages
+            const contextMessages = [];
+            for (const entry of messageEntries) {
+                if (entry.type === "pointer") {
+                    const message = session.messages[entry.index];
+                    if (message) {
+                        contextMessages.push(message);
+                    }
+                }
+                else if (entry.type === "full") {
+                    contextMessages.push(entry.message);
+                }
+            }
+            // Calculate context size - no LLM call yet, so only estimated values
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined);
+            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
             session.context.push(contextSnapshot);
+            await this.saveSessionToDisk(params.sessionId, session);
         }
         // Build ordered content blocks for the assistant response
         const contentBlocks = [];
@@ -293,23 +427,24 @@ export class AgentAcpAdapter {
             if (turnStartContextEntries.length > 0) {
                 logger.info(`Appending ${turnStartContextEntries.length} new context entries from turn_start hooks`);
                 session.context.push(...turnStartContextEntries);
-                // Save session immediately after hooks to persist compacted context
-                if (this.storage) {
-                    try {
-                        await this.storage.saveSession(params.sessionId, session.messages, session.context);
-                        logger.info("Session saved after turn_start hook execution with new context entries");
-                    }
-                    catch (error) {
-                        logger.error(`Failed to save session ${params.sessionId} after turn_start hook execution`, {
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    }
-                }
+                await this.saveSessionToDisk(params.sessionId, session);
             }
             // Resolve context to messages for agent invocation
             const contextMessages = this.noSession
                 ? []
                 : resolveContextToMessages(session.context, session.messages);
+            logger.debug("Resolved context messages for agent invocation", {
+                sessionId: params.sessionId,
+                contextMessageCount: contextMessages.length,
+                totalSessionMessages: session.messages.length,
+                latestContextEntry: session.context.length > 0 &&
+                    session.context[session.context.length - 1]
+                    ? {
+                        messageCount: session.context[session.context.length - 1].messages.length,
+                        contextSize: session.context[session.context.length - 1].context_size,
+                    }
+                    : null,
+            });
             const invokeParams = {
                 prompt: params.prompt,
                 sessionId: params.sessionId,
@@ -340,6 +475,19 @@ export class AgentAcpAdapter {
                         if (tokenUsage.inputTokens !== undefined &&
                             tokenUsage.inputTokens > 0) {
                             turnTokenUsage.inputTokens = tokenUsage.inputTokens;
+                            // Update the LAST context entry with LLM-reported tokens
+                            if (!this.noSession && session.context.length > 0) {
+                                const lastContext = session.context[session.context.length - 1];
+                                if (lastContext) {
+                                    lastContext.context_size.llmReportedInputTokens =
+                                        tokenUsage.inputTokens;
+                                    logger.debug("Updated context entry with LLM-reported tokens", {
+                                        contextIndex: session.context.length - 1,
+                                        llmReportedTokens: tokenUsage.inputTokens,
+                                        estimatedTokens: lastContext.context_size.totalEstimated,
+                                    });
+                                }
+                            }
                         }
                         turnTokenUsage.outputTokens += tokenUsage.outputTokens ?? 0;
                         turnTokenUsage.totalTokens += tokenUsage.totalTokens ?? 0;
@@ -409,12 +557,52 @@ export class AgentAcpAdapter {
                     const outputMsg = msg;
                     const toolCallBlock = contentBlocks.find((block) => block.type === "tool_call" && block.id === outputMsg.toolCallId);
                     if (toolCallBlock) {
-                        // Store both rawOutput and output from tool_output
-                        if (outputMsg.rawOutput) {
-                            toolCallBlock.rawOutput = outputMsg.rawOutput;
+                        // Get the raw output
+                        let rawOutput = outputMsg.rawOutput || outputMsg.output;
+                        let truncationWarning;
+                        if (rawOutput && !this.noSession) {
+                            // Execute tool_response hooks if configured
+                            const hooks = this.agent.definition.hooks ?? [];
+                            if (hooks.some((h) => h.type === "tool_response")) {
+                                const latestContext = session.context[session.context.length - 1];
+                                const currentContextTokens = latestContext?.context_size.llmReportedInputTokens ??
+                                    latestContext?.context_size.totalEstimated ??
+                                    0;
+                                const outputTokens = countToolResultTokens(rawOutput);
+                                const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir));
+                                const hookResult = await hookExecutor.executeToolResponseHooks({
+                                    messages: session.messages,
+                                    context: session.context,
+                                    requestParams: session.requestParams,
+                                }, currentContextTokens, {
+                                    toolCallId: outputMsg.toolCallId,
+                                    toolName: toolCallBlock.title || "unknown",
+                                    toolInput: toolCallBlock.rawInput || {},
+                                    rawOutput,
+                                    outputTokens,
+                                });
+                                // Apply modifications if hook returned them
+                                if (hookResult.modifiedOutput) {
+                                    rawOutput = hookResult.modifiedOutput;
+                                    logger.info("Tool response modified by hook", {
+                                        toolCallId: outputMsg.toolCallId,
+                                        originalTokens: outputTokens,
+                                        finalTokens: countToolResultTokens(rawOutput),
+                                    });
+                                }
+                                truncationWarning = hookResult.truncationWarning;
+                            }
+                        }
+                        // Store the (potentially modified) output
+                        if (rawOutput) {
+                            toolCallBlock.rawOutput = rawOutput;
                         }
-                        else if (outputMsg.output) {
-                            toolCallBlock.rawOutput = outputMsg.output;
+                        // Store truncation warning if present (for UI display)
+                        if (truncationWarning) {
+                            if (!toolCallBlock._meta) {
+                                toolCallBlock._meta = {};
+                            }
+                            toolCallBlock._meta.truncationWarning = truncationWarning;
                         }
                         // Note: content blocks are handled by the transport for display
                         // We store the raw output here for session persistence
@@ -445,22 +633,48 @@ export class AgentAcpAdapter {
                             const latestContext = session.context.length > 0
                                 ? session.context[session.context.length - 1]
                                 : undefined;
+                            // Build message entries for the new context
+                            // Check if we already have a pointer to this message (during mid-turn updates)
+                            const existingMessages = latestContext?.messages ?? [];
+                            const lastEntry = existingMessages[existingMessages.length - 1];
+                            const alreadyHasPointer = lastEntry?.type === "pointer" &&
+                                lastEntry.index === partialMessageIndex;
+                            const messageEntries = alreadyHasPointer
+                                ? existingMessages // Don't add duplicate pointer
+                                : [
+                                    ...existingMessages,
+                                    { type: "pointer", index: partialMessageIndex },
+                                ];
+                            // Resolve message entries to actual messages
+                            const contextMessages = [];
+                            for (const entry of messageEntries) {
+                                if (entry.type === "pointer") {
+                                    const message = session.messages[entry.index];
+                                    if (message) {
+                                        contextMessages.push(message);
+                                    }
+                                }
+                                else if (entry.type === "full") {
+                                    contextMessages.push(entry.message);
+                                }
+                            }
+                            // Calculate context size - tool result is now in the message, but hasn't been sent to LLM yet
+                            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined);
                             // Create snapshot with a pointer to the partial message (not a full copy!)
                             const midTurnSnapshot = {
                                 timestamp: new Date().toISOString(),
-                                messages: [
-                                    ...(latestContext?.messages ?? []),
-                                    { type: "pointer", index: partialMessageIndex },
-                                ],
+                                messages: messageEntries,
                                 compactedUpTo: latestContext?.compactedUpTo,
-                                inputTokens: turnTokenUsage.inputTokens || latestContext?.inputTokens || 0,
+                                context_size,
                             };
                             session.context.push(midTurnSnapshot);
+                            await this.saveSessionToDisk(params.sessionId, session);
                             logger.debug("Created mid-turn context snapshot after tool output", {
                                 toolCallId: outputMsg.toolCallId,
                                 contentBlocks: contentBlocks.length,
                                 partialMessageIndex,
-                                inputTokens: midTurnSnapshot.inputTokens,
+                                totalEstimated: midTurnSnapshot.context_size.totalEstimated,
+                                toolResultsTokens: midTurnSnapshot.context_size.toolResultsTokens,
                             });
                             // Execute hooks mid-turn to check if compaction is needed
                             const midTurnContextEntries = await this.executeHooksIfConfigured(session, params.sessionId, "mid_turn");
@@ -470,23 +684,7 @@ export class AgentAcpAdapter {
                                     toolCallId: outputMsg.toolCallId,
                                 });
                                 session.context.push(...midTurnContextEntries);
-                                // Save session immediately after mid-turn compaction
-                                if (this.storage) {
-                                    try {
-                                        await this.storage.saveSession(params.sessionId, session.messages, session.context);
-                                        logger.info("Session saved after mid_turn hook execution with new context entries", {
-                                            toolCallId: outputMsg.toolCallId,
-                                        });
-                                    }
-                                    catch (error) {
-                                        logger.error(`Failed to save session ${params.sessionId} after mid_turn hook execution`, {
-                                            toolCallId: outputMsg.toolCallId,
-                                            error: error instanceof Error
-                                                ? error.message
-                                                : String(error),
-                                        });
-                                    }
-                                }
+                                await this.saveSessionToDisk(params.sessionId, session);
                             }
                         }
                     }
@@ -500,32 +698,23 @@ export class AgentAcpAdapter {
                     msg._meta &&
                     typeof msg._meta === "object" &&
                     "tokenUsage" in msg._meta) {
-                    // Use accumulated turn tokens if available, otherwise fall back to previous context
-                    let contextInputTokens;
-                    if (turnTokenUsage.inputTokens > 0) {
-                        // Use current turn's accumulated tokens (most up-to-date)
-                        contextInputTokens = turnTokenUsage.inputTokens;
-                    }
-                    else {
-                        // Fall back to previous context's tokens (for start of turn)
-                        const latestContext = session.context.length > 0
-                            ? session.context[session.context.length - 1]
-                            : undefined;
-                        contextInputTokens = latestContext?.inputTokens;
-                    }
-                    // Add context tokens to _meta only if defined
-                    if (contextInputTokens !== undefined) {
+                    // Get latest context entry and send its full context_size breakdown to GUI
+                    const latestContext = session.context.length > 0
+                        ? session.context[session.context.length - 1]
+                        : undefined;
+                    if (latestContext?.context_size) {
                         enhancedMsg = {
                             ...msg,
                             _meta: {
                                 ...msg._meta,
-                                contextInputTokens,
+                                context_size: latestContext.context_size,
                             },
                         };
-                        logger.debug("Sending contextInputTokens to GUI", {
-                            contextInputTokens,
-                            turnTokens: turnTokenUsage.inputTokens,
-                            previousContextTokens: session.context[session.context.length - 1]?.inputTokens,
+                    }
+                    else {
+                        logger.warn("⚠️ No context_size to send to GUI", {
+                            hasLatestContext: !!latestContext,
+                            contextLength: session.context.length,
                         });
                     }
                 }
@@ -568,22 +757,32 @@ export class AgentAcpAdapter {
             const previousContext = session.context.length > 0
                 ? session.context[session.context.length - 1]
                 : undefined;
-            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, 
-            // Use accumulated turn tokens (latest API call's input tokens)
-            // not agentResponse.tokenUsage which may sum all calls in the turn
-            turnTokenUsage.inputTokens || previousContext?.inputTokens || 0);
-            session.context.push(contextSnapshot);
-        }
-        // Save session to disk if storage is configured and session persistence is enabled
-        if (!this.noSession && this.storage) {
-            try {
-                await this.storage.saveSession(params.sessionId, session.messages, session.context);
-            }
-            catch (error) {
-                logger.error(`Failed to save session ${params.sessionId}`, {
-                    error: error instanceof Error ? error.message : String(error),
-                });
+            // Calculate final context size
+            // Build message pointers for the new context
+            const messageEntries = previousContext
+                ? [
+                    ...previousContext.messages,
+                    { type: "pointer", index: session.messages.length - 1 },
+                ]
+                : [{ type: "pointer", index: session.messages.length - 1 }];
+            // Resolve message entries to actual messages
+            const contextMessages = [];
+            for (const entry of messageEntries) {
+                if (entry.type === "pointer") {
+                    const message = session.messages[entry.index];
+                    if (message) {
+                        contextMessages.push(message);
+                    }
+                }
+                else if (entry.type === "full") {
+                    contextMessages.push(entry.message);
+                }
             }
+            // Calculate context size with LLM-reported tokens from this turn
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, turnTokenUsage.inputTokens);
+            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
+            session.context.push(contextSnapshot);
+            await this.saveSessionToDisk(params.sessionId, session);
         }
         session.pendingPrompt = null;
         return {
@@ -616,7 +815,15 @@ export class AgentAcpAdapter {
         const latestContext = session.context.length > 0
             ? session.context[session.context.length - 1]
             : undefined;
-        const actualInputTokens = latestContext?.inputTokens ?? 0;
+        // Prefer LLM-reported tokens (most accurate), fall back to our estimate
+        const actualInputTokens = latestContext?.context_size.llmReportedInputTokens ??
+            latestContext?.context_size.totalEstimated ??
+            0;
+        logger.debug("Using tokens for hook execution", {
+            llmReported: latestContext?.context_size.llmReportedInputTokens,
+            estimated: latestContext?.context_size.totalEstimated,
+            used: actualInputTokens,
+        });
         const hookResult = await hookExecutor.executeHooks(readonlySession, actualInputTokens);
         // Send hook notifications to client
         for (const notification of hookResult.notifications) {

package/dist/acp-server/cli.d.ts

@@ -1,5 +1,3 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "../runner";
-export declare function makeStdioTransport(
-	agent: AgentRunner | AgentDefinition,
-): void;
+export declare function makeStdioTransport(agent: AgentRunner | AgentDefinition): void;

package/dist/acp-server/http.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
+import { join } from "node:path";
 import { gzipSync } from "node:zlib";
 import * as acp from "@agentclientprotocol/sdk";
 import { PGlite } from "@electric-sql/pglite";
-import { createLogger } from "@townco/core";
+import { configureLogsDir, createLogger } from "@townco/core";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
@@ -48,6 +49,12 @@ function safeChannelName(prefix, id) {
     return `${prefix}_${hash}`;
 }
 export function makeHttpTransport(agent, agentDir, agentName) {
+    // Configure logger to write to .logs/ directory if agentDir is provided
+    if (agentDir) {
+        const logsDir = join(agentDir, ".logs");
+        configureLogsDir(logsDir);
+        logger.info("Configured logs directory", { logsDir });
+    }
     const inbound = new TransformStream();
     const outbound = new TransformStream();
     const bridge = acp.ndJsonStream(outbound.writable, inbound.readable);

package/dist/acp-server/index.js

@@ -1,2 +1,7 @@
+import { initializeOpenTelemetryFromEnv } from "../telemetry/setup.js";
+// Initialize OpenTelemetry when this module is imported (if enabled)
+if (process.env.ENABLE_TELEMETRY === "true") {
+    initializeOpenTelemetryFromEnv();
+}
 export { makeStdioTransport } from "./cli";
 export { makeHttpTransport } from "./http";

package/dist/acp-server/session-storage.d.ts

@@ -16,6 +16,12 @@ export interface ToolCallBlock {
     error?: string | undefined;
     startedAt?: number | undefined;
     completedAt?: number | undefined;
+    _meta?: {
+        truncationWarning?: string;
+        compactionAction?: "compacted" | "truncated";
+        originalTokens?: number;
+        finalTokens?: number;
+    };
 }
 export type ContentBlock = TextBlock | ToolCallBlock;
 /**
@@ -51,10 +57,18 @@ export interface ContextEntry {
      */
     compactedUpTo?: number | undefined;
     /**
-     * Actual input token count from API for this context.
-     * Used for accurate context size tracking and compaction decisions.
+     * Complete breakdown of context size at this snapshot.
+     * Calculated by counting ALL tokens in the messages referenced by this context entry.
      */
-    inputTokens?: number | undefined;
+    context_size: {
+        systemPromptTokens: number;
+        userMessagesTokens: number;
+        assistantMessagesTokens: number;
+        toolInputTokens: number;
+        toolResultsTokens: number;
+        totalEstimated: number;
+        llmReportedInputTokens?: number | undefined;
+    };
 }
 /**
  * Session metadata

package/dist/acp-server/session-storage.js

@@ -56,6 +56,15 @@ const contextEntrySchema = z.object({
     timestamp: z.string(),
     messages: z.array(contextMessageEntrySchema),
     compactedUpTo: z.number().optional(),
+    context_size: z.object({
+        systemPromptTokens: z.number(),
+        userMessagesTokens: z.number(),
+        assistantMessagesTokens: z.number(),
+        toolInputTokens: z.number(),
+        toolResultsTokens: z.number(),
+        totalEstimated: z.number(),
+        llmReportedInputTokens: z.number().optional(),
+    }),
 });
 const sessionMetadataSchema = z.object({
     createdAt: z.string(),

package/dist/check-jaeger.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Quick script to verify Jaeger connectivity
+ * Run with: bun check-jaeger.ts
+ */
+export {};