@townco/agent 0.1.63 → 0.1.70

package/dist/acp-server/adapter.js

@@ -569,7 +569,8 @@ export class AgentAcpAdapter {
             const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined, // No LLM-reported tokens yet
             this.currentToolOverheadTokens, // Include tool overhead
             this.currentMcpOverheadTokens);
-            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
+            const contextSnapshot = createContextSnapshot(session.messages.length - 1, // Exclude the newly added user message (it will be passed separately via prompt)
+            new Date().toISOString(), previousContext, context_size);
             session.context.push(contextSnapshot);
             await this.saveSessionToDisk(params.sessionId, session);
         }
@@ -608,6 +609,13 @@ export class AgentAcpAdapter {
                 sessionId: params.sessionId,
                 contextMessageCount: contextMessages.length,
                 totalSessionMessages: session.messages.length,
+                contextMessages: contextMessages.map((m) => ({
+                    role: m.role,
+                    content: JSON.stringify(m.content).slice(0, 100),
+                })),
+                promptContent: params.prompt
+                    .map((p) => p.type === "text" ? p.text.slice(0, 100) : `[${p.type}]`)
+                    .join(" "),
                 latestContextEntry: session.context.length > 0 &&
                     session.context[session.context.length - 1]
                     ? {

package/dist/acp-server/http.js

@@ -553,6 +553,7 @@ export function makeHttpTransport(agent, agentDir, agentName) {
     logger.info("Starting HTTP server", { port });
     Bun.serve({
         fetch: app.fetch,
+        hostname: Bun.env.BIND_HOST || "localhost",
         port,
     });
     logger.info("HTTP server listening", {

package/dist/runner/langchain/index.js

@@ -82,6 +82,20 @@ export class LangchainAgent {
         const countedMessageIds = new Set();
         // Track tool calls for which we've emitted preliminary notifications (from early tool_use blocks)
         const preliminaryToolCallIds = new Set();
+        // Buffer tool call notifications until content streaming completes
+        const pendingToolCallNotifications = [];
+        // Helper to flush all buffered tool calls (called when we detect text streaming is done)
+        function* flushPendingToolCalls() {
+            if (pendingToolCallNotifications.length === 0) {
+                return;
+            }
+            // Yield all buffered notifications
+            for (const notification of pendingToolCallNotifications) {
+                yield notification;
+            }
+            // Clear the buffer after flushing
+            pendingToolCallNotifications.length = 0;
+        }
         // Set session_id as a base attribute so all spans in this invocation include it
         telemetry.setBaseAttributes({
             "agent.session_id": req.sessionId,
@@ -629,8 +643,8 @@ export class LangchainAgent {
                             // Check if we already emitted a preliminary notification from early tool_use block
                             const alreadyEmittedPreliminary = preliminaryToolCallIds.has(toolCall.id);
                             if (alreadyEmittedPreliminary) {
-                                // Update the existing preliminary notification with full details
-                                yield {
+                                // Buffer the update notification
+                                pendingToolCallNotifications.push({
                                     sessionUpdate: "tool_call_update",
                                     toolCallId: toolCall.id,
                                     title: toolCall.name,
@@ -642,11 +656,11 @@ export class LangchainAgent {
                                         ...(icon ? { icon } : {}),
                                         ...(batchId ? { batchId } : {}),
                                     },
-                                };
+                                });
                             }
                             else {
-                                // Emit full tool_call notification (fallback for non-streaming scenarios)
-                                yield {
+                                // Buffer full tool_call notification
+                                pendingToolCallNotifications.push({
                                     sessionUpdate: "tool_call",
                                     toolCallId: toolCall.id,
                                     title: toolCall.name,
@@ -660,16 +674,21 @@ export class LangchainAgent {
                                         ...(icon ? { icon } : {}),
                                         ...(batchId ? { batchId } : {}),
                                     },
-                                };
+                                });
                             }
-                            // Always emit in_progress status update
-                            yield {
+                            // Buffer in_progress status update
+                            pendingToolCallNotifications.push({
                                 sessionUpdate: "tool_call_update",
                                 toolCallId: toolCall.id,
                                 status: "in_progress",
                                 ...(tokenUsage ? { tokenUsage } : {}),
                                 _meta: { messageId: req.messageId },
-                            };
+                            });
+                        }
+                        // After processing all tool calls in this chunk, flush them
+                        // (tool calls indicate text streaming is complete)
+                        if (toolCalls.length > 0) {
+                            yield* flushPendingToolCalls();
                         }
                     }
                 }
@@ -776,14 +795,14 @@ export class LangchainAgent {
                                     yield msgToYield;
                                 }
                                 else if (part.type === "tool_use") {
-                                    // Emit early notification for tool use as soon as we detect it
+                                    // Buffer early notification for tool use
                                     // The tool_use block contains { type, id, name, input }
                                     const toolUseBlock = part;
                                     if (toolUseBlock.id &&
                                         toolUseBlock.name &&
                                         !preliminaryToolCallIds.has(toolUseBlock.id)) {
                                         preliminaryToolCallIds.add(toolUseBlock.id);
-                                        yield {
+                                        pendingToolCallNotifications.push({
                                             sessionUpdate: "tool_call",
                                             toolCallId: toolUseBlock.id,
                                             title: toolUseBlock.name,
@@ -791,7 +810,7 @@ export class LangchainAgent {
                                             status: "pending",
                                             rawInput: {}, // Args not available yet
                                             _meta: { messageId: req.messageId },
-                                        };
+                                        });
                                     }
                                 }
                                 else if (part.type === "input_json_delta") {
@@ -801,6 +820,8 @@ export class LangchainAgent {
                                     throw new Error(`Unhandled AIMessageChunk content block type: ${part.type}\n${JSON.stringify(part)}`);
                                 }
                             }
+                            // Don't flush here - these are preliminary tool_use blocks
+                            // We'll flush when we get the full tool calls in "updates" mode
                         }
                         else {
                             throw new Error(`Unhandled AIMessageChunk content type: ${typeof aiMessage.content}`);
@@ -822,16 +843,16 @@ export class LangchainAgent {
                                 toolCallId: aiMessage.tool_call_id,
                                 ...(isError ? { error: aiMessage.content } : {}),
                             });
-                            // Send status update (metadata only, no content)
-                            yield {
+                            // Buffer status update (metadata only, no content)
+                            pendingToolCallNotifications.push({
                                 sessionUpdate: "tool_call_update",
                                 toolCallId: aiMessage.tool_call_id,
                                 status,
                                 ...(isError ? { error: aiMessage.content } : {}),
                                 _meta: { messageId: req.messageId },
-                            };
-                            // Send tool output separately (via direct SSE, bypassing PostgreSQL NOTIFY)
-                            yield {
+                            });
+                            // Buffer tool output separately
+                            pendingToolCallNotifications.push({
                                 sessionUpdate: "tool_output",
                                 toolCallId: aiMessage.tool_call_id,
                                 content: [
@@ -845,7 +866,9 @@ export class LangchainAgent {
                                 ],
                                 rawOutput: { content: aiMessage.content },
                                 _meta: { messageId: req.messageId },
-                            };
+                            });
+                            // Flush tool outputs after buffering
+                            yield* flushPendingToolCalls();
                         }
                         else {
                             throw new Error(`Unhandled ToolMessage content type: ${typeof aiMessage.content}`);
@@ -863,6 +886,8 @@ export class LangchainAgent {
             }
             // Yield any remaining pending subagent connection updates after stream ends
             yield* yieldPendingSubagentUpdates();
+            // Now that content streaming is complete, yield all buffered tool call notifications
+            yield* flushPendingToolCalls();
             // Clean up subagent connection listener
             subagentEvents.off("connection", onSubagentConnection);
             // Cancel any pending wait