@townco/agent 0.1.117 → 0.1.119

package/dist/runner/langchain/tools/subagent.js

@@ -10,6 +10,175 @@ import { makeRunnerFromDefinition } from "../../index.js";
 import { bindGeneratorToSessionContext, getAbortSignal, } from "../../session-context.js";
 import { emitSubagentMessages, hashQuery, } from "./subagent-connections.js";
 const logger = createLogger("subagent-tool", "debug");
+/**
+ * Helper to derive favicon URL from a domain
+ */
+function getFaviconUrl(url) {
+    try {
+        const domain = new URL(url).hostname;
+        return `https://www.google.com/s2/favicons?domain=${domain}&sz=32`;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Helper to get a human-readable source name from URL
+ */
+function getSourceName(url) {
+    try {
+        const hostname = new URL(url).hostname;
+        // Remove www. prefix and return domain name
+        return hostname.replace(/^www\./, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Extract citation sources from a tool's raw output.
+ * This handles WebSearch, WebFetch, and library tools.
+ *
+ * Note: The runner wraps tool results as { content: JSON.stringify(result) },
+ * so we need to parse rawOutput.content if it's a string.
+ */
+function extractSourcesFromToolOutput(toolName, rawOutput, toolCallId, sourceCounter) {
+    const sources = [];
+    // Parse the actual output from the wrapper
+    // The runner wraps results as { content: JSON.stringify(actualResult) }
+    let actualOutput = rawOutput;
+    if (typeof rawOutput.content === "string") {
+        try {
+            const parsed = JSON.parse(rawOutput.content);
+            if (typeof parsed === "object" && parsed !== null) {
+                actualOutput = parsed;
+            }
+        }
+        catch {
+            // Not valid JSON, use rawOutput as-is
+        }
+    }
+    // Handle WebSearch (Exa) results
+    if (toolName === "WebSearch" || toolName === "web_search") {
+        // Check for formatted results with citation IDs first
+        const formattedResults = actualOutput.formattedForCitation;
+        if (Array.isArray(formattedResults)) {
+            for (const result of formattedResults) {
+                if (result &&
+                    typeof result === "object" &&
+                    "url" in result &&
+                    typeof result.url === "string") {
+                    // Use the citationId from the tool output if available
+                    const citationId = typeof result.citationId === "number"
+                        ? String(result.citationId)
+                        : (() => {
+                            sourceCounter.value++;
+                            return String(sourceCounter.value);
+                        })();
+                    const url = result.url;
+                    const title = typeof result.title === "string" ? result.title : "Untitled";
+                    const snippet = typeof result.text === "string"
+                        ? result.text.slice(0, 200)
+                        : undefined;
+                    sources.push({
+                        id: citationId,
+                        url,
+                        title,
+                        snippet,
+                        favicon: getFaviconUrl(url),
+                        toolCallId,
+                        sourceName: getSourceName(url),
+                    });
+                }
+            }
+        }
+        else {
+            // Fallback to raw results (backwards compatibility)
+            const results = actualOutput.results;
+            if (Array.isArray(results)) {
+                for (const result of results) {
+                    if (result &&
+                        typeof result === "object" &&
+                        "url" in result &&
+                        typeof result.url === "string") {
+                        sourceCounter.value++;
+                        const url = result.url;
+                        const title = typeof result.title === "string" ? result.title : "Untitled";
+                        const snippet = typeof result.text === "string"
+                            ? result.text.slice(0, 200)
+                            : undefined;
+                        sources.push({
+                            id: String(sourceCounter.value),
+                            url,
+                            title,
+                            snippet,
+                            favicon: getFaviconUrl(url),
+                            toolCallId,
+                            sourceName: getSourceName(url),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Handle WebFetch - extract URLs from the fetched content
+    // Note: WebFetch returns plain text (the AI-processed result), not structured data
+    // So we skip URL extraction here as the URLs would be from the content itself
+    // The actual fetched URL should be tracked via tool input, not output
+    // Handle library/document retrieval tools
+    const isLibraryTool = toolName.startsWith("library__") ||
+        toolName.includes("get_document") ||
+        toolName.includes("retrieve_document") ||
+        toolName.includes("bibliotecha");
+    if (isLibraryTool) {
+        // Helper to extract a single document source
+        const extractDocSource = (doc) => {
+            const docUrl = typeof doc.document_url === "string"
+                ? doc.document_url
+                : typeof doc.url === "string"
+                    ? doc.url
+                    : typeof doc.source_url === "string"
+                        ? doc.source_url
+                        : null;
+            const docTitle = typeof doc.title === "string" ? doc.title : null;
+            const docId = typeof doc.document_id === "number"
+                ? String(doc.document_id)
+                : typeof doc.document_id === "string"
+                    ? doc.document_id
+                    : null;
+            if (!docUrl && !docTitle) {
+                return null;
+            }
+            sourceCounter.value++;
+            return {
+                id: docId || String(sourceCounter.value),
+                url: docUrl || "",
+                title: docTitle || docUrl || "Document",
+                toolCallId,
+                ...(docUrl && { favicon: getFaviconUrl(docUrl) }),
+                ...(docUrl && { sourceName: getSourceName(docUrl) }),
+            };
+        };
+        // Extract from single document fields
+        const singleDoc = extractDocSource(actualOutput);
+        if (singleDoc) {
+            sources.push(singleDoc);
+        }
+        // Extract from documents array
+        const documents = actualOutput.documents;
+        if (Array.isArray(documents)) {
+            for (const doc of documents) {
+                if (doc && typeof doc === "object") {
+                    const docSource = extractDocSource(doc);
+                    if (docSource) {
+                        sources.push(docSource);
+                    }
+                }
+            }
+        }
+    }
+    return sources;
+}
 /**
  * Name of the Task tool created by makeSubagentsTool
  */
@@ -211,6 +380,7 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
     // Consume stream, accumulate results, and emit incremental updates
     let responseText = "";
     const collectedSources = [];
+    const sourceCounter = { value: 0 }; // Mutable counter for source ID generation
     const currentMessage = {
         id: `subagent-${Date.now()}`,
         content: "",
@@ -218,6 +388,7 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
         toolCalls: [],
     };
     const toolCallMap = new Map();
+    const toolNameMap = new Map(); // Map toolCallId -> toolName
     const queryHash = hashQuery(query);
     logger.info("[DEBUG] Starting subagent generator loop", {
         agentName,
@@ -249,15 +420,23 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
             // Handle tool_call
             if (update.sessionUpdate === "tool_call" && update.toolCallId) {
                 const meta = update._meta;
+                // Extract rawInput from the update
+                const rawInput = update
+                    .rawInput;
                 const toolCall = {
                     id: update.toolCallId,
                     title: update.title || "Tool call",
                     prettyName: meta?.prettyName,
                     icon: meta?.icon,
                     status: update.status || "pending",
+                    rawInput,
                 };
                 currentMessage.toolCalls.push(toolCall);
                 toolCallMap.set(update.toolCallId, currentMessage.toolCalls.length - 1);
+                // Store tool name for source extraction when output arrives
+                if (update.title) {
+                    toolNameMap.set(update.toolCallId, update.title);
+                }
                 currentMessage.contentBlocks.push({ type: "tool_call", toolCall });
                 shouldEmit = true; // Emit when new tool call appears
             }
@@ -276,9 +455,41 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
                     shouldEmit = true; // Emit when tool status changes
                 }
             }
+            // Handle tool_output - capture rawOutput and extract sources
+            // (rawOutput will be included in final emit when subagent completes)
+            if (update.sessionUpdate === "tool_output" && update.toolCallId) {
+                const outputUpdate = update;
+                const idx = toolCallMap.get(update.toolCallId);
+                if (idx !== undefined && currentMessage.toolCalls[idx]) {
+                    if (outputUpdate.rawOutput) {
+                        currentMessage.toolCalls[idx].rawOutput = outputUpdate.rawOutput;
+                        // Also update the content block
+                        const block = currentMessage.contentBlocks.find((b) => b.type === "tool_call" && b.toolCall.id === update.toolCallId);
+                        if (block) {
+                            block.toolCall.rawOutput = outputUpdate.rawOutput;
+                        }
+                        // Extract citation sources from tool output (WebSearch, WebFetch, library tools)
+                        const toolName = toolNameMap.get(update.toolCallId) || "";
+                        const extractedSources = extractSourcesFromToolOutput(toolName, outputUpdate.rawOutput, update.toolCallId, sourceCounter);
+                        if (extractedSources.length > 0) {
+                            collectedSources.push(...extractedSources);
+                            logger.info("Extracted sources from subagent tool output", {
+                                toolName,
+                                toolCallId: update.toolCallId,
+                                sourcesCount: extractedSources.length,
+                            });
+                            shouldEmit = true; // Emit when sources are extracted
+                        }
+                    }
+                    // NOTE: Don't set shouldEmit for rawOutput alone - rawOutput is large and will be
+                    // included in the final emit when the subagent completes
+                }
+            }
             // Handle sources (from ACP protocol)
-            if ("sources" in update && Array.isArray(update.sources)) {
-                const sources = update.sources;
+            if ("sources" in update &&
+                Array.isArray(update.sources)) {
+                const sources = update
+                    .sources;
                 for (const source of sources) {
                     const citationSource = {
                         id: source.id,
@@ -305,7 +516,23 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
                     contentBlocksCount: currentMessage.contentBlocks.length,
                     toolCallsCount: currentMessage.toolCalls.length,
                 });
-                emitSubagentMessages(queryHash, [{ ...currentMessage }]);
+                // Strip rawOutput from streamed messages to avoid OOM in browser
+                // rawOutput is preserved in currentMessage for final session save
+                const streamMessage = {
+                    ...currentMessage,
+                    toolCalls: currentMessage.toolCalls.map((tc) => {
+                        const { rawOutput: _rawOutput, ...rest } = tc;
+                        return rest;
+                    }),
+                    contentBlocks: currentMessage.contentBlocks.map((block) => {
+                        if (block.type === "tool_call") {
+                            const { rawOutput: _rawOutput, ...rest } = block.toolCall;
+                            return { type: "tool_call", toolCall: rest };
+                        }
+                        return block;
+                    }),
+                };
+                emitSubagentMessages(queryHash, [streamMessage]);
             }
         }
         logger.info("[DEBUG] Subagent generator loop finished", {

package/dist/templates/index.d.ts

@@ -1,4 +1,6 @@
-import type { AgentDefinition } from "../definition";
+import type { z } from "zod";
+import type { AgentDefinition, McpConfigSchema } from "../definition";
+type McpConfig = z.infer<typeof McpConfigSchema>;
 export interface TemplateVars {
     name: string;
     model: string;
@@ -18,6 +20,7 @@ export interface TemplateVars {
         fn: any;
         schema: unknown;
     }>;
+    mcps?: McpConfig[];
     systemPrompt: string | null;
     hasWebSearch: boolean;
     hasGenerateImage: boolean;
@@ -44,3 +47,4 @@ export declare function generateGitignore(): string;
 export declare function generateTsConfig(): string;
 export declare function generateReadme(vars: TemplateVars): string;
 export declare function generateEnvExample(vars: TemplateVars): string | null;
+export {};

package/dist/templates/index.js

@@ -20,6 +20,9 @@ export function getTemplateVars(name, definition) {
     if (definition.suggestedPrompts) {
         result.suggestedPrompts = definition.suggestedPrompts;
     }
+    if (definition.mcps && definition.mcps.length > 0) {
+        result.mcps = definition.mcps;
+    }
     return result;
 }
 export function generatePackageJson(vars) {
@@ -71,19 +74,27 @@ export async function generateIndexTs(vars) {
     }
     agentDef.systemPrompt = vars.systemPrompt;
     agentDef.tools = vars.tools;
+    if (vars.mcps && vars.mcps.length > 0) {
+        agentDef.mcps = vars.mcps;
+    }
     if (vars.hooks) {
         agentDef.hooks = vars.hooks;
     }
-    return prettier.format(`import { makeHttpTransport, makeStdioTransport } from "@townco/agent/acp-server";
-import type { AgentDefinition } from "@townco/agent/definition";
-import { createLogger } from "@townco/agent/logger";
-import { basename } from "node:path";
+    return prettier.format(`import type { AgentDefinition } from "@townco/agent/definition";
 
-const logger = createLogger("agent-index");
-
-// Load agent definition from JSON file
 const agent: AgentDefinition = ${JSON.stringify(agentDef)};
 
+export default agent;
+`, { parser: "typescript" });
+}
+export function generateBinTs() {
+    return `#!/usr/bin/env bun
+import { basename } from "node:path";
+import { makeHttpTransport, makeStdioTransport } from "@townco/agent/acp-server";
+import { createLogger } from "@townco/agent/logger";
+import agent from "./index";
+
+const logger = createLogger("agent-index");
 const transport = process.argv[2] || "stdio";
 
 // Get agent directory and name for session storage
@@ -93,18 +104,13 @@ const agentName = basename(agentDir);
 logger.info("Configuration", { transport, agentDir, agentName });
 
 if (transport === "http") {
-	makeHttpTransport(agent, agentDir, agentName);
+  makeHttpTransport(agent, agentDir, agentName);
 } else if (transport === "stdio") {
-	makeStdioTransport(agent);
+  makeStdioTransport(agent);
 } else {
-	logger.error(\`Invalid transport: \${transport}\`);
-	process.exit(1);
+  logger.error(\`Invalid transport: \${transport}\`);
+  process.exit(1);
 }
-`, { parser: "typescript" });
-}
-export function generateBinTs() {
-    return `#!/usr/bin/env bun
-import "./index.ts";
 `;
 }
 export function generateGitignore() {