@townco/agent 0.1.113 → 0.1.114

package/dist/acp-server/adapter.js

@@ -273,14 +273,12 @@ export class AgentAcpAdapter {
                         "url" in result &&
                         typeof result.url === "string") {
                         // Use the citationId from the tool output if available
-                        let citationId;
-                        if (typeof result.citationId === "number") {
-                            citationId = String(result.citationId);
-                        }
-                        else {
-                            session.sourceCounter++;
-                            citationId = String(session.sourceCounter);
-                        }
+                        const citationId = typeof result.citationId === "number"
+                            ? String(result.citationId)
+                            : (() => {
+                                session.sourceCounter++;
+                                return String(session.sourceCounter);
+                            })();
                         const url = result.url;
                         const title = typeof result.title === "string" ? result.title : "Untitled";
                         const snippet = typeof result.text === "string"
@@ -420,14 +418,11 @@ export class AgentAcpAdapter {
                 if (!docUrl && !docTitle)
                     return null;
                 // Use document_id as the citation ID if available, otherwise use counter
-                let citationId;
-                if (docId) {
-                    citationId = docId;
-                }
-                else {
-                    session.sourceCounter++;
-                    citationId = String(session.sourceCounter);
-                }
+                const citationId = docId ||
+                    (() => {
+                        session.sourceCounter++;
+                        return String(session.sourceCounter);
+                    })();
                 // Extract snippet from summary or content
                 let snippet;
                 if (typeof doc.summary === "string") {
@@ -1075,7 +1070,7 @@ export class AgentAcpAdapter {
         }
         logger.info("User message received", {
             sessionId: params.sessionId,
-            messagePreview: userMessageText.slice(0, 100),
+            message: userMessageText,
             noSession: this.noSession,
         });
         // Only store messages if session persistence is enabled
@@ -1134,12 +1129,40 @@ export class AgentAcpAdapter {
         // Build ordered content blocks for the assistant response
         const contentBlocks = [];
         let pendingText = "";
+        // Buffer for logging agent response in readable chunks
+        let logBuffer = "";
+        const flushLogBuffer = (force = false) => {
+            if (logBuffer.length === 0)
+                return;
+            if (force) {
+                // Flush everything
+                logger.info("Agent response", {
+                    sessionId: params.sessionId,
+                    text: logBuffer,
+                });
+                logBuffer = "";
+            }
+            else {
+                // Only flush complete lines (up to and including the last newline)
+                const lastNewline = logBuffer.lastIndexOf("\n");
+                if (lastNewline !== -1) {
+                    const completeLines = logBuffer.slice(0, lastNewline + 1);
+                    logBuffer = logBuffer.slice(lastNewline + 1);
+                    logger.info("Agent response", {
+                        sessionId: params.sessionId,
+                        text: completeLines,
+                    });
+                }
+            }
+        };
         // Helper function to flush pending text as a TextBlock
         const flushPendingText = () => {
             if (pendingText.length > 0) {
                 contentBlocks.push({ type: "text", text: pendingText });
                 pendingText = "";
             }
+            // Force flush any remaining log buffer when text block completes
+            flushLogBuffer(true);
         };
         // Helper to save cancelled message to session
         const saveCancelledMessage = async () => {
@@ -1332,6 +1355,11 @@ export class AgentAcpAdapter {
                         const content = msg.content;
                         if (content.type === "text" && typeof content.text === "string") {
                             pendingText += content.text;
+                            // Buffer for logging - flush on newlines
+                            logBuffer += content.text;
+                            if (logBuffer.includes("\n")) {
+                                flushLogBuffer();
+                            }
                         }
                     }
                     // Debug: log if this chunk has tokenUsage in _meta
@@ -1405,28 +1433,20 @@ export class AgentAcpAdapter {
                     if (toolCallMsg.rawInput) {
                         toolCall.rawInput = toolCallMsg.rawInput;
                     }
+                    // Log tool call start
+                    logger.info("Tool call started", {
+                        sessionId: params.sessionId,
+                        toolCallId: toolCall.id,
+                        tool: toolCall.title,
+                        prettyName: toolCall.prettyName,
+                    });
                     contentBlocks.push(toolCall);
                 }
                 // Handle tool_call_update - update existing ToolCallBlock
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "tool_call_update") {
                     const updateMsg = msg;
-                    logger.info("[SUBAGENT] Adapter received tool_call_update", {
-                        sessionId: params.sessionId,
-                        toolCallId: updateMsg.toolCallId,
-                        status: updateMsg.status,
-                        hasMeta: !!updateMsg._meta,
-                        hasSubagentMessages: !!updateMsg._meta?.subagentMessages,
-                        subagentMessageCount: updateMsg._meta?.subagentMessages?.length ||
-                            0,
-                    });
                     const toolCallBlock = contentBlocks.find((block) => block.type === "tool_call" && block.id === updateMsg.toolCallId);
-                    logger.info("[SUBAGENT] Tool call block lookup result", {
-                        sessionId: params.sessionId,
-                        toolCallId: updateMsg.toolCallId,
-                        found: !!toolCallBlock,
-                        blockStatus: toolCallBlock?.status,
-                    });
                     if (toolCallBlock) {
                         if (updateMsg.status) {
                             toolCallBlock.status =
@@ -1446,6 +1466,17 @@ export class AgentAcpAdapter {
                         if (toolCallBlock.status === "completed" ||
                             toolCallBlock.status === "failed") {
                             toolCallBlock.completedAt = Date.now();
+                            // Log tool call completion
+                            logger.info("Tool call completed", {
+                                sessionId: params.sessionId,
+                                toolCallId: updateMsg.toolCallId,
+                                tool: toolCallBlock.title,
+                                status: toolCallBlock.status,
+                                durationMs: toolCallBlock.startedAt
+                                    ? toolCallBlock.completedAt - toolCallBlock.startedAt
+                                    : undefined,
+                                error: toolCallBlock.error,
+                            });
                         }
                         const meta = updateMsg._meta;
                         // Update batchId from _meta (comes from tool_call_update after preliminary tool_call)
@@ -1459,31 +1490,11 @@ export class AgentAcpAdapter {
                             toolCallBlock.subagentSessionId = meta.subagentSessionId;
                         }
                         if (meta?.subagentMessages) {
-                            logger.info("[SUBAGENT] Storing subagent messages for session replay", {
-                                sessionId: params.sessionId,
-                                toolCallId: updateMsg.toolCallId,
-                                messageCount: meta.subagentMessages.length,
-                                contentPreview: meta.subagentMessages[0]?.content?.substring(0, 100),
-                            });
                             toolCallBlock.subagentMessages = meta.subagentMessages;
-                            logger.info("[SUBAGENT] Successfully stored messages", {
-                                sessionId: params.sessionId,
-                                toolCallId: updateMsg.toolCallId,
-                                storedCount: toolCallBlock.subagentMessages?.length,
-                            });
                         }
                     }
                     // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
                     if (updateMsg._meta) {
-                        logger.info("[SUBAGENT] Forwarding tool_call_update with _meta to client", {
-                            sessionId: params.sessionId,
-                            toolCallId: updateMsg.toolCallId,
-                            status: updateMsg.status,
-                            hasSubagentMessages: !!updateMsg._meta
-                                ?.subagentMessages,
-                            subagentMessageCount: updateMsg._meta?.subagentMessages
-                                ?.length || 0,
-                        });
                         this.connection.sessionUpdate({
                             sessionId: params.sessionId,
                             update: {
@@ -1493,10 +1504,6 @@ export class AgentAcpAdapter {
                                 _meta: updateMsg._meta,
                             },
                         });
-                        logger.info("[SUBAGENT] Successfully forwarded to client", {
-                            sessionId: params.sessionId,
-                            toolCallId: updateMsg.toolCallId,
-                        });
                     }
                 }
                 // Handle tool_output - update ToolCallBlock with output content

package/dist/runner/langchain/index.js

@@ -181,21 +181,14 @@ export class LangchainAgent {
         subagentInvCtx.subagentEventEmitter.on("messages", onSubagentMessages);
         // Helper to check and yield all pending subagent message updates
         async function* yieldPendingSubagentUpdates() {
-            _logger.info("[SUBAGENT] yieldPendingSubagentUpdates called", {
-                sessionId: req.sessionId,
-                queueLength: subagentMessagesQueue.length,
-            });
             while (subagentMessagesQueue.length > 0) {
                 const messagesUpdate = subagentMessagesQueue.shift();
                 if (!messagesUpdate)
                     continue;
-                _logger.info("[SUBAGENT] Yielding queued subagent messages update", {
+                _logger.debug("[SUBAGENT] Yielding queued subagent messages update", {
                     sessionId: req.sessionId,
                     toolCallId: messagesUpdate.toolCallId,
                     messageCount: messagesUpdate.messages.length,
-                    contentPreview: messagesUpdate.messages[0]?.content?.substring(0, 100),
-                    hasContentBlocks: (messagesUpdate.messages[0]?.contentBlocks?.length ?? 0) > 0,
-                    toolCallCount: messagesUpdate.messages[0]?.toolCalls?.length ?? 0,
                 });
                 const updateToYield = {
                     sessionUpdate: "tool_call_update",
@@ -205,17 +198,7 @@ export class LangchainAgent {
                         subagentMessages: messagesUpdate.messages,
                     },
                 };
-                _logger.info("[SUBAGENT] About to yield update object", {
-                    sessionId: req.sessionId,
-                    toolCallId: messagesUpdate.toolCallId,
-                    updateType: updateToYield.sessionUpdate,
-                    hasMetaSubagentMessages: !!updateToYield._meta?.subagentMessages,
-                });
                 yield updateToYield;
-                _logger.info("[SUBAGENT] Successfully yielded update", {
-                    sessionId: req.sessionId,
-                    toolCallId: messagesUpdate.toolCallId,
-                });
             }
         }
         // Add agent.session_id as a base attribute so it propagates to all child spans
@@ -1330,10 +1313,6 @@ export class LangchainAgent {
             yield* yieldPendingSubagentUpdates();
             // Keep polling for subagent messages after stream ends
             // This ensures we capture messages that arrive after LangChain stream completes
-            _logger.info("[SUBAGENT] Starting post-stream polling for subagent messages", {
-                sessionId: req.sessionId,
-                activeSubagentCount: activeSubagentToolCalls.size,
-            });
             const checkInterval = 100; // Check every 100ms
             const maxIdleTime = 5000; // Stop if no messages for 5 seconds (fallback)
             const maxWaitTime = 300000; // Absolute max 5 minutes
@@ -1343,28 +1322,15 @@ export class LangchainAgent {
                 // Check if all subagent tool calls have completed
                 if (activeSubagentToolCalls.size > 0 &&
                     completedSubagentToolCalls.size >= activeSubagentToolCalls.size) {
-                    _logger.info("[SUBAGENT] All subagent tool calls completed", {
-                        sessionId: req.sessionId,
-                        totalSubagents: activeSubagentToolCalls.size,
-                        completedCount: completedSubagentToolCalls.size,
-                    });
                     break;
                 }
                 // Check if there are pending messages
                 if (subagentMessagesQueue.length > 0) {
-                    _logger.info("[SUBAGENT] Found pending messages, yielding", {
-                        sessionId: req.sessionId,
-                        queueLength: subagentMessagesQueue.length,
-                    });
                     yield* yieldPendingSubagentUpdates();
                     lastMessageTime = Date.now();
                 }
                 // Stop if we haven't seen messages for maxIdleTime (fallback for no subagents)
                 if (Date.now() - lastMessageTime > maxIdleTime) {
-                    _logger.info("[SUBAGENT] No new messages for 5 seconds, finishing", {
-                        sessionId: req.sessionId,
-                        hasActiveSubagents: activeSubagentToolCalls.size > 0,
-                    });
                     break;
                 }
                 // Wait a bit before checking again
@@ -1377,9 +1343,6 @@ export class LangchainAgent {
             }
             // Final yield of any remaining messages
             yield* yieldPendingSubagentUpdates();
-            _logger.info("[SUBAGENT] Finished post-stream polling", {
-                sessionId: req.sessionId,
-            });
             // Now that content streaming is complete, yield all buffered tool call notifications
             yield* flushPendingToolCalls();
             // Clean up subagent event listener from invocation-scoped emitter