@townco/agent 0.1.31 → 0.1.33

package/dist/example.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+import { makeHttpTransport, makeStdioTransport } from "./acp-server/index.js";
+
+const exampleAgent = {
+	model: "claude-sonnet-4-5-20250929",
+	systemPrompt: "You are a helpful assistant.",
+	tools: ["todo_write", "get_weather", "web_search"],
+};
+// Parse transport type from command line argument
+const transport = process.argv[2] || "stdio";
+if (transport === "http") {
+	makeHttpTransport(exampleAgent);
+} else if (transport === "stdio") {
+	makeStdioTransport(exampleAgent);
+} else {
+	console.error(`Invalid transport: ${transport}`);
+	console.error("Usage: bun run example.ts [stdio|http]");
+	process.exit(1);
+}

package/dist/index.js

@@ -1,3 +1,4 @@
+import { basename } from "node:path";
 import { makeHttpTransport, makeStdioTransport } from "./acp-server";
 import { makeSubagentsTool } from "./utils";
 const exampleAgent = {
@@ -23,8 +24,11 @@ const exampleAgent = {
 };
 // Parse transport type from command line argument
 const transport = process.argv[2] || "stdio";
+// Get agent directory and name for session storage
+const agentDir = process.cwd();
+const agentName = basename(agentDir);
 if (transport === "http") {
-    makeHttpTransport(exampleAgent);
+    makeHttpTransport(exampleAgent, agentDir, agentName);
 }
 else if (transport === "stdio") {
     makeStdioTransport(exampleAgent);

package/dist/runner/agent-runner.d.ts

@@ -29,9 +29,15 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     }, z.core.$strip>]>>>;
 }, z.core.$strip>;
 export type CreateAgentRunnerParams = z.infer<typeof zAgentRunnerParams>;
+export interface SessionMessage {
+    role: "user" | "assistant";
+    content: string;
+    timestamp: string;
+}
 export type InvokeRequest = Omit<PromptRequest, "_meta"> & {
     messageId: string;
     sessionMeta?: Record<string, unknown>;
+    sessionMessages?: SessionMessage[];
 };
 export interface TokenUsage {
     inputTokens?: number;

package/dist/runner/index.d.ts

@@ -1,4 +1,6 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "./agent-runner";
 export type { AgentRunner };
-export declare const makeRunnerFromDefinition: (definition: AgentDefinition) => AgentRunner;
+export declare const makeRunnerFromDefinition: (
+	definition: AgentDefinition,
+) => AgentRunner;

package/dist/runner/index.js

@@ -1,18 +1,22 @@
 import { zAgentRunnerParams } from "./agent-runner";
 import { LangchainAgent } from "./langchain";
 export const makeRunnerFromDefinition = (definition) => {
-    const agentRunnerParams = zAgentRunnerParams.safeParse(definition);
-    if (!agentRunnerParams.success) {
-        throw new Error(`Invalid agent definition: ${agentRunnerParams.error.message}`);
-    }
-    switch (definition.harnessImplementation) {
-        case undefined:
-        case "langchain": {
-            return new LangchainAgent(agentRunnerParams.data);
-        }
-        default: {
-            const _exhaustiveCheck = definition.harnessImplementation;
-            throw new Error(`Unsupported harness implementation: ${definition.harnessImplementation}`);
-        }
-    }
+	const agentRunnerParams = zAgentRunnerParams.safeParse(definition);
+	if (!agentRunnerParams.success) {
+		throw new Error(
+			`Invalid agent definition: ${agentRunnerParams.error.message}`,
+		);
+	}
+	switch (definition.harnessImplementation) {
+		case undefined:
+		case "langchain": {
+			return new LangchainAgent(agentRunnerParams.data);
+		}
+		default: {
+			const _exhaustiveCheck = definition.harnessImplementation;
+			throw new Error(
+				`Unsupported harness implementation: ${definition.harnessImplementation}`,
+			);
+		}
+	}
 };

package/dist/runner/langchain/index.js

@@ -4,6 +4,7 @@ import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../acp-server/adapter";
 import { loadCustomToolModule, } from "../tool-loader.js";
+import { createModelFromString } from "./model-factory.js";
 import { makeFilesystemTools } from "./tools/filesystem";
 import { TASK_TOOL_NAME } from "./tools/subagent";
 import { TODO_WRITE_TOOL_NAME, todoWrite } from "./tools/todo";
@@ -120,8 +121,14 @@ export class LangchainAgent {
         const finalTools = isSubagent
             ? enabledTools.filter((t) => t.name !== TODO_WRITE_TOOL_NAME && t.name !== TASK_TOOL_NAME)
             : enabledTools;
+        // Create the model instance using the factory
+        // This detects the provider from the model string:
+        // - "gemini-2.0-flash" → Google Generative AI
+        // - "vertex-gemini-2.0-flash" → Vertex AI (strips prefix)
+        // - "claude-sonnet-4-5-20250929" → Anthropic
+        const model = createModelFromString(this.definition.model);
         const agentConfig = {
-            model: this.definition.model,
+            model,
             tools: finalTools,
         };
         // Inject system prompt with optional TodoWrite instructions
@@ -130,12 +137,35 @@ export class LangchainAgent {
             agentConfig.systemPrompt = `${agentConfig.systemPrompt ?? ""}\n\n${TODO_WRITE_INSTRUCTIONS}`;
         }
         const agent = createAgent(agentConfig);
-        const messages = req.prompt
-            .filter((promptMsg) => promptMsg.type === "text")
-            .map((promptMsg) => ({
-            type: "human",
-            content: promptMsg.text,
-        }));
+        // Build messages from session history if available, otherwise use just the prompt
+        let messages;
+        if (req.sessionMessages && req.sessionMessages.length > 0) {
+            // Use session message history - convert to LangChain format
+            // Only include messages BEFORE the current user message (exclude the last one since it's the current prompt)
+            const historyMessages = req.sessionMessages.slice(0, -1);
+            messages = historyMessages.map((msg) => ({
+                type: msg.role === "user" ? "human" : "ai",
+                content: msg.content,
+            }));
+            // Add the current prompt as the final human message
+            const currentPromptText = req.prompt
+                .filter((promptMsg) => promptMsg.type === "text")
+                .map((promptMsg) => promptMsg.text)
+                .join("\n");
+            messages.push({
+                type: "human",
+                content: currentPromptText,
+            });
+        }
+        else {
+            // Fallback: No session history, use just the prompt (legacy behavior)
+            messages = req.prompt
+                .filter((promptMsg) => promptMsg.type === "text")
+                .map((promptMsg) => ({
+                type: "human",
+                content: promptMsg.text,
+            }));
+        }
         const stream = agent.stream({ messages }, {
             streamMode: ["updates", "messages"],
         });
@@ -230,7 +260,7 @@ export class LangchainAgent {
                             : typeof aiMessage.content === "string"
                                 ? aiMessage.content.length
                                 : -1;
-                        console.error("DEBUG agent: messageTokenUsage:", JSON.stringify(messageTokenUsage), "contentType:", contentType, "isArray:", contentIsArray, "length:", contentLength);
+                        console.log("DEBUG agent: messageTokenUsage:", JSON.stringify(messageTokenUsage), "contentType:", contentType, "isArray:", contentIsArray, "length:", contentLength);
                     }
                     // If we have tokenUsage but no content, send a token-only chunk
                     if (messageTokenUsage &&
@@ -238,7 +268,7 @@ export class LangchainAgent {
                             ? aiMessage.content === ""
                             : Array.isArray(aiMessage.content) &&
                                 aiMessage.content.length === 0)) {
-                        console.error("DEBUG agent: sending token-only chunk:", JSON.stringify(messageTokenUsage));
+                        console.log("DEBUG agent: sending token-only chunk:", JSON.stringify(messageTokenUsage));
                         const msgToYield = {
                             sessionUpdate: "agent_message_chunk",
                             content: {
@@ -271,7 +301,7 @@ export class LangchainAgent {
                                     text: aiMessage.content,
                                 },
                             };
-                        console.error("DEBUG agent: yielding message (string content):", JSON.stringify(msgToYield));
+                        console.log("DEBUG agent: yielding message (string content):", JSON.stringify(msgToYield));
                         yield msgToYield;
                     }
                     else if (Array.isArray(aiMessage.content)) {
@@ -295,7 +325,7 @@ export class LangchainAgent {
                                             text: part.text,
                                         },
                                     };
-                                console.error("DEBUG agent: yielding message (array content):", JSON.stringify(msgToYield));
+                                console.log("DEBUG agent: yielding message (array content):", JSON.stringify(msgToYield));
                                 yield msgToYield;
                             }
                             else if (part.type === "tool_use") {

package/dist/runner/langchain/model-factory.d.ts

@@ -0,0 +1,20 @@
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+/**
+ * Detects the provider from a model string and returns the appropriate
+ * LangChain chat model instance.
+ *
+ * Detection logic:
+ * - If model starts with "vertex-" → Google Vertex AI (strips prefix)
+ * - If model contains "gemini" (unprefixed) → Google Generative AI
+ * - If model contains "gpt" → OpenAI (future support)
+ * - Otherwise → Anthropic (default for backward compatibility)
+ *
+ * Supported formats:
+ * - Direct model name: "gemini-2.0-flash", "vertex-gemini-2.0-flash", "claude-sonnet-4-5-20250929"
+ * - Provider prefix: "google_vertexai:gemini-2.0-flash", "google_genai:gemini-2.0-flash", "anthropic:claude-3-5-sonnet"
+ */
+export declare function createModelFromString(modelString: string): BaseChatModel;
+/**
+ * Helper function to detect if a model string is for a specific provider
+ */
+export declare function detectProvider(modelString: string): string;

package/dist/runner/langchain/model-factory.js

@@ -0,0 +1,113 @@
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
+import { ChatVertexAI } from "@langchain/google-vertexai";
+/**
+ * Detects the provider from a model string and returns the appropriate
+ * LangChain chat model instance.
+ *
+ * Detection logic:
+ * - If model starts with "vertex-" → Google Vertex AI (strips prefix)
+ * - If model contains "gemini" (unprefixed) → Google Generative AI
+ * - If model contains "gpt" → OpenAI (future support)
+ * - Otherwise → Anthropic (default for backward compatibility)
+ *
+ * Supported formats:
+ * - Direct model name: "gemini-2.0-flash", "vertex-gemini-2.0-flash", "claude-sonnet-4-5-20250929"
+ * - Provider prefix: "google_vertexai:gemini-2.0-flash", "google_genai:gemini-2.0-flash", "anthropic:claude-3-5-sonnet"
+ */
+export function createModelFromString(modelString) {
+    // Check if the model string uses provider prefix format
+    const parts = modelString.split(":", 2);
+    const maybeProvider = parts[0];
+    const maybeModel = parts[1];
+    let provider = null;
+    let modelName = modelString;
+    // If there's a colon, treat the first part as the provider
+    if (maybeModel) {
+        provider = maybeProvider?.toLowerCase() ?? null;
+        modelName = maybeModel;
+    }
+    else {
+        // Auto-detect provider from model name
+        const lowerModel = modelString.toLowerCase();
+        // Check for vertex- prefix
+        if (lowerModel.startsWith("vertex-")) {
+            provider = "google_vertexai";
+            modelName = modelString.substring(7); // Strip "vertex-" prefix
+        }
+        else if (lowerModel.includes("gemini")) {
+            // Unprefixed gemini models use Google Generative AI
+            provider = "google_genai";
+        }
+        else if (lowerModel.includes("gpt")) {
+            provider = "openai";
+        }
+        else if (lowerModel.includes("claude")) {
+            provider = "anthropic";
+        }
+        else {
+            // Default to Anthropic for backward compatibility
+            provider = "anthropic";
+        }
+    }
+    // Create the appropriate model instance based on provider
+    switch (provider) {
+        case "google_vertexai":
+        case "vertex":
+        case "vertexai":
+            return new ChatVertexAI({
+                model: modelName,
+                // Default to reasonable settings
+                temperature: 0,
+                location: "global",
+            });
+        case "google_genai":
+        case "gemini":
+            return new ChatGoogleGenerativeAI({
+                model: modelName,
+                // Default to reasonable settings
+                temperature: 0,
+            });
+        case "openai":
+            throw new Error("OpenAI provider is not yet supported. Please install @langchain/openai and add implementation.");
+        case "anthropic":
+        case "claude":
+            return new ChatAnthropic({
+                model: modelName,
+                // Use default Anthropic settings
+            });
+        default:
+            // Fallback to Anthropic for unknown providers (backward compatibility)
+            console.warn(`Unknown provider "${provider}" in model string "${modelString}". Defaulting to Anthropic.`);
+            return new ChatAnthropic({
+                model: modelString,
+            });
+    }
+}
+/**
+ * Helper function to detect if a model string is for a specific provider
+ */
+export function detectProvider(modelString) {
+    const parts = modelString.split(":", 2);
+    const maybeProvider = parts[0];
+    const maybeModel = parts[1];
+    if (maybeModel && maybeProvider) {
+        return maybeProvider.toLowerCase();
+    }
+    const lowerModel = modelString.toLowerCase();
+    // Check for vertex- prefix
+    if (lowerModel.startsWith("vertex-")) {
+        return "google_vertexai";
+    }
+    else if (lowerModel.includes("gemini")) {
+        // Unprefixed gemini models use Google Generative AI
+        return "google_genai";
+    }
+    else if (lowerModel.includes("gpt")) {
+        return "openai";
+    }
+    else if (lowerModel.includes("claude")) {
+        return "anthropic";
+    }
+    return "anthropic"; // default
+}

package/dist/templates/index.js

@@ -50,14 +50,21 @@ export async function generateIndexTs(vars) {
     };
     return prettier.format(`import { makeHttpTransport, makeStdioTransport } from "@townco/agent/acp-server";
 import type { AgentDefinition } from "@townco/agent/definition";
+import { basename } from "node:path";
 
 // Load agent definition from JSON file
 const agent: AgentDefinition = ${JSON.stringify(agentDef)};
 
 const transport = process.argv[2] || "stdio";
 
+// Get agent directory and name for session storage
+const agentDir = process.cwd();
+const agentName = basename(agentDir);
+
+console.log("[agent] Configuration:", { transport, agentDir, agentName });
+
 if (transport === "http") {
-	makeHttpTransport(agent);
+	makeHttpTransport(agent, agentDir, agentName);
 } else if (transport === "stdio") {
 	makeStdioTransport(agent);
 } else {
@@ -75,6 +82,7 @@ export function generateGitignore() {
     return `node_modules
 dist
 .env
+.sessions
 `;
 }
 export function generateTsConfig() {