@townco/agent 0.1.117 → 0.1.118

package/dist/runner/index.d.ts

@@ -1,68 +1,4 @@
+import type { AgentDefinition } from "../definition";
 import { type AgentRunner, type SessionUpdateNotification } from "./agent-runner";
 export type { AgentRunner, SessionUpdateNotification };
-export declare const makeRunnerFromDefinition: (definition: {
-    displayName?: string | undefined;
-    version?: string | undefined;
-    description?: string | undefined;
-    suggestedPrompts?: string[] | undefined;
-    systemPrompt: string | null;
-    model: string;
-    tools?: (string | {
-        type: "custom";
-        modulePath: string;
-    } | {
-        type: "filesystem";
-        working_directory?: string | undefined;
-    } | {
-        type: "direct";
-        name: string;
-        description: string;
-        fn: import("zod/v4/core").$InferOuterFunctionType<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>;
-        schema: any;
-        prettyName?: string | undefined;
-        icon?: string | undefined;
-    })[] | undefined;
-    mcps?: (string | {
-        name: string;
-        transport: "stdio";
-        command: string;
-        args?: string[] | undefined;
-    } | {
-        name: string;
-        transport: "http";
-        url: string;
-        headers?: Record<string, string> | undefined;
-    })[] | undefined;
-    harnessImplementation?: "langchain" | undefined;
-    hooks?: {
-        type: "context_size" | "tool_response";
-        setting?: Record<string, unknown> | {
-            threshold: number;
-        } | {
-            maxTokensSize?: number | undefined;
-        } | undefined;
-        callback?: string | undefined;
-        callbacks?: {
-            name: string;
-            setting?: Record<string, unknown> | undefined;
-        }[] | undefined;
-    }[] | undefined;
-    initialMessage?: {
-        enabled: boolean;
-        content: string;
-    } | undefined;
-    uiConfig?: {
-        hideTopBar?: boolean | undefined;
-    } | undefined;
-    promptParameters?: {
-        id: string;
-        label: string;
-        description?: string | undefined;
-        options: {
-            id: string;
-            label: string;
-            systemPromptAddendum?: string | undefined;
-        }[];
-        defaultOptionId?: string | undefined;
-    }[] | undefined;
-}) => AgentRunner;
+export declare const makeRunnerFromDefinition: (definition: AgentDefinition) => AgentRunner;

package/dist/runner/langchain/index.js

@@ -892,7 +892,7 @@ export class LangchainAgent {
                 }
             }
             // Iterate through the merged stream
-            let messageCount = 0;
+            let _messageCount = 0;
             for await (const item of mergeStreams()) {
                 if (item.source === "subagent") {
                     // Yield any queued subagent messages
@@ -901,7 +901,7 @@ export class LangchainAgent {
                 }
                 // Process the stream item
                 const streamItem = item.value;
-                messageCount++;
+                _messageCount++;
                 // biome-ignore lint/suspicious/noExplicitAny: LangChain stream items are tuples with dynamic types
                 const [streamMode, chunk] = streamItem;
                 if (streamMode === "updates") {
@@ -1293,9 +1293,9 @@ export class LangchainAgent {
             const maxWaitTime = 300000; // Absolute max 5 minutes
             const startTime = Date.now();
             let lastMessageTime = Date.now();
-            let iterations = 0;
+            let _iterations = 0;
             while (Date.now() - startTime < maxWaitTime) {
-                iterations++;
+                _iterations++;
                 // Check if there are pending messages
                 if (subagentMessagesQueue.length > 0) {
                     yield* yieldPendingSubagentUpdates();

package/dist/runner/langchain/tools/subagent-connections.d.ts

@@ -7,6 +7,8 @@ export interface SubagentToolCall {
     prettyName?: string | undefined;
     icon?: string | undefined;
     status: "pending" | "in_progress" | "completed" | "failed";
+    rawInput?: Record<string, unknown> | undefined;
+    rawOutput?: Record<string, unknown> | undefined;
 }
 /**
  * Content block for sub-agent messages

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.js

@@ -74,16 +74,21 @@ export async function generateIndexTs(vars) {
     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";
-
-const logger = createLogger("agent-index");
+    return prettier.format(`import type { AgentDefinition } from "@townco/agent/definition";
 
-// 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 +98,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() {