@townco/agent 0.1.32 → 0.1.34

package/dist/acp-server/adapter.d.ts

@@ -17,6 +17,7 @@ export declare class AgentAcpAdapter implements acp.Agent {
     private sessions;
     private agent;
     private storage;
+    private noSession;
     constructor(agent: AgentRunner, connection: acp.AgentSideConnection, agentDir?: string, agentName?: string);
     initialize(_params: acp.InitializeRequest): Promise<acp.InitializeResponse>;
     newSession(params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;

package/dist/acp-server/adapter.js

@@ -11,24 +11,29 @@ export class AgentAcpAdapter {
     sessions;
     agent;
     storage;
+    noSession;
     constructor(agent, connection, agentDir, agentName) {
         this.connection = connection;
         this.sessions = new Map();
         this.agent = agent;
+        this.noSession = process.env.TOWN_NO_SESSION === "true";
         this.storage =
-            agentDir && agentName ? new SessionStorage(agentDir, agentName) : null;
+            agentDir && agentName && !this.noSession
+                ? new SessionStorage(agentDir, agentName)
+                : null;
         console.log("[adapter] Initialized with:", {
             agentDir,
             agentName,
+            noSession: this.noSession,
             hasStorage: this.storage !== null,
-            sessionStoragePath: this.storage ? `${agentDir}/.sessions` : null
+            sessionStoragePath: this.storage ? `${agentDir}/.sessions` : null,
         });
     }
     async initialize(_params) {
         return {
             protocolVersion: acp.PROTOCOL_VERSION,
             agentCapabilities: {
-                loadSession: this.storage !== null,
+                loadSession: !this.noSession && this.storage !== null,
             },
         };
     }
@@ -103,12 +108,15 @@ export class AgentAcpAdapter {
             .filter((p) => p.type === "text")
             .map((p) => p.text)
             .join("\n");
-        const userMessage = {
-            role: "user",
-            content: userMessageContent,
-            timestamp: new Date().toISOString(),
-        };
-        session.messages.push(userMessage);
+        // Only store messages if session persistence is enabled
+        if (!this.noSession) {
+            const userMessage = {
+                role: "user",
+                content: userMessageContent,
+                timestamp: new Date().toISOString(),
+            };
+            session.messages.push(userMessage);
+        }
         // Accumulate assistant response content
         let assistantContent = "";
         try {
@@ -116,7 +124,8 @@ export class AgentAcpAdapter {
                 prompt: params.prompt,
                 sessionId: params.sessionId,
                 messageId,
-                sessionMessages: session.messages, // Pass session history to agent
+                // Only pass session history if session persistence is enabled
+                sessionMessages: this.noSession ? [] : session.messages,
             };
             // Only add sessionMeta if it's defined
             if (session.requestParams._meta) {
@@ -157,7 +166,8 @@ export class AgentAcpAdapter {
             throw err;
         }
         // Store the complete assistant response in session messages
-        if (assistantContent.length > 0) {
+        // Only store if session persistence is enabled
+        if (!this.noSession && assistantContent.length > 0) {
             const assistantMessage = {
                 role: "assistant",
                 content: assistantContent,
@@ -165,8 +175,8 @@ export class AgentAcpAdapter {
             };
             session.messages.push(assistantMessage);
         }
-        // Save session to disk if storage is configured
-        if (this.storage) {
+        // Save session to disk if storage is configured and session persistence is enabled
+        if (!this.noSession && this.storage) {
             try {
                 await this.storage.saveSession(params.sessionId, session.messages);
             }

package/dist/acp-server/session-storage.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { z } from "zod";
 /**
  * Zod schema for validating session files

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

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
+}