@poncho-ai/harness 0.34.1 → 0.36.0

package/src/mcp.ts

@@ -273,6 +273,15 @@ export class LocalMcpBridge {
   private readonly toolCatalog = new Map<string, McpToolDescriptor[]>();
   private readonly unavailableServers = new Map<string, string>();
   private readonly authFailedServers = new Set<string>();
+  private envResolver?: (tenantId: string | undefined, envName: string) => Promise<string | undefined>;
+
+  /**
+   * Set a resolver for per-tenant env vars (e.g. MCP auth tokens).
+   * Called by the harness after creating the secrets store.
+   */
+  setEnvResolver(resolver: (tenantId: string | undefined, envName: string) => Promise<string | undefined>): void {
+    this.envResolver = resolver;
+  }
 
   constructor(config: McpConfig | undefined) {
     this.remoteServers = (config?.mcp ?? []).filter((entry): entry is RemoteMcpServerConfig =>
@@ -316,8 +325,12 @@ export class LocalMcpBridge {
     console.info(`[poncho][mcp] ${line}`);
   }
 
+  /** Set of servers where discovery was deferred (no default token, has env resolver). */
+  private readonly deferredDiscoveryServers = new Set<string>();
+
   async discoverTools(): Promise<void> {
     this.toolCatalog.clear();
+    this.deferredDiscoveryServers.clear();
     for (const remoteServer of this.remoteServers) {
       const name = this.getServerName(remoteServer);
       if (this.unavailableServers.has(name)) {
@@ -338,6 +351,13 @@ export class LocalMcpBridge {
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         if (error instanceof McpHttpError && error.status === 401) {
+          if (this.envResolver && remoteServer.auth?.tokenEnv) {
+            // Discovery failed without token but tenant secrets may provide one —
+            // defer discovery to first loadTools() call with a tenant context
+            this.deferredDiscoveryServers.add(name);
+            this.log("info", "catalog.deferred", { server: name, reason: "auth_deferred_to_tenant" });
+            continue;
+          }
           this.authFailedServers.add(name);
           this.log("warn", "auth.failed", {
             server: name,
@@ -351,6 +371,64 @@ export class LocalMcpBridge {
     }
   }
 
+  /**
+   * Run deferred discovery and return ToolDefinitions for all newly discovered tools.
+   * Call this during run() so the tools are available to the model immediately.
+   */
+  async discoverAndLoadDeferred(tenantId: string): Promise<ToolDefinition[]> {
+    if (this.deferredDiscoveryServers.size === 0) return [];
+    for (const server of this.remoteServers) {
+      await this.tryDeferredDiscovery(server, tenantId);
+    }
+    // Build tool definitions only for servers that were deferred and now have tools
+    const tools: ToolDefinition[] = [];
+    for (const server of this.remoteServers) {
+      const name = this.getServerName(server);
+      // Only include servers that WERE deferred (whether discovery succeeded or not)
+      if (!server.auth?.tokenEnv) continue;
+      const discovered = this.toolCatalog.get(name);
+      if (!discovered || discovered.length === 0) continue;
+      const client = this.rpcClients.get(name);
+      if (!client) continue;
+      tools.push(...this.toToolDefinitions(name, discovered, client, server));
+    }
+    return tools;
+  }
+
+  private async tryDeferredDiscovery(server: RemoteMcpServerConfig, tenantId: string): Promise<void> {
+    const name = this.getServerName(server);
+    if (!this.deferredDiscoveryServers.has(name)) return;
+    if (this.toolCatalog.has(name)) return; // already discovered
+
+    const tokenEnv = server.auth?.tokenEnv;
+    if (!tokenEnv || !this.envResolver) return;
+
+    const token = await this.envResolver(tenantId, tokenEnv);
+    if (!token) return;
+
+    try {
+      const probeClient = new StreamableHttpMcpRpcClient(
+        server.url,
+        server.timeoutMs ?? 10_000,
+        token,
+        server.headers,
+      );
+      const discovered = await probeClient.listTools();
+      this.toolCatalog.set(name, discovered);
+      this.deferredDiscoveryServers.delete(name);
+      this.log("info", "catalog.loaded", {
+        server: name,
+        discoveredCount: discovered.length,
+        via: "deferred_tenant_discovery",
+      });
+    } catch (error) {
+      this.log("warn", "catalog.deferred_failed", {
+        server: name,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
   async startLocalServers(): Promise<void> {
     this.unavailableServers.clear();
     for (const server of this.remoteServers) {
@@ -359,15 +437,24 @@ export class LocalMcpBridge {
       if (tokenEnv) {
         const token = process.env[tokenEnv];
         if (!token || token.trim().length === 0) {
-          this.unavailableServers.set(
-            name,
-            `Missing bearer token value from env var ${tokenEnv}`,
-          );
-          this.log("warn", "auth.token_missing", {
+          if (!this.envResolver) {
+            // No tenant secrets resolver — server is genuinely unavailable
+            this.unavailableServers.set(
+              name,
+              `Missing bearer token value from env var ${tokenEnv}`,
+            );
+            this.log("warn", "auth.token_missing", {
+              server: name,
+              tokenEnv,
+            });
+            continue;
+          }
+          // Tenant secrets resolver available — create client without a default token;
+          // per-tenant tokens will be resolved at call time in toToolDefinitions
+          this.log("info", "auth.token_deferred", {
             server: name,
             tokenEnv,
           });
-          continue;
         }
       }
       this.rpcClients.set(
@@ -441,6 +528,31 @@ export class LocalMcpBridge {
     return output.sort();
   }
 
+  hasDeferredServers(): boolean {
+    return this.deferredDiscoveryServers.size > 0;
+  }
+
+  /**
+   * Return ToolDefinitions for catalog tools not already registered in the dispatcher.
+   */
+  getUnregisteredTools(registeredNames: Set<string>): ToolDefinition[] {
+    const tools: ToolDefinition[] = [];
+    for (const server of this.remoteServers) {
+      const name = this.getServerName(server);
+      const discovered = this.toolCatalog.get(name);
+      if (!discovered || discovered.length === 0) continue;
+      const client = this.rpcClients.get(name);
+      if (!client) continue;
+      const unregistered = discovered.filter(
+        (d) => !registeredNames.has(`${name}/${d.name}`),
+      );
+      if (unregistered.length > 0) {
+        tools.push(...this.toToolDefinitions(name, unregistered, client, server));
+      }
+    }
+    return tools;
+  }
+
   async loadTools(
     requestedPatterns: string[],
   ): Promise<ToolDefinition[]> {
@@ -474,7 +586,7 @@ export class LocalMcpBridge {
       const selectedDescriptors = discovered.filter((descriptor) =>
         selectedRawNames.has(descriptor.name),
       );
-      tools.push(...this.toToolDefinitions(serverName, selectedDescriptors, client));
+      tools.push(...this.toToolDefinitions(serverName, selectedDescriptors, client, server));
     }
     this.log("info", "tools.selected", {
       requestedPatternCount: requestedPatterns.length,
@@ -489,6 +601,7 @@ export class LocalMcpBridge {
     serverName: string,
     tools: McpToolDescriptor[],
     client: McpRpcClient,
+    server?: RemoteMcpServerConfig,
   ): ToolDefinition[] {
     return tools.map((tool) => ({
       name: `${serverName}/${tool.name}`,
@@ -498,9 +611,27 @@ export class LocalMcpBridge {
           type: "object",
           properties: {},
         },
-      handler: async (input) => {
+      handler: async (input, context) => {
         try {
-          return await client.callTool(tool.name, input);
+          // Per-tenant token resolution: if we have a resolver and the server uses tokenEnv,
+          // create a per-request client with the tenant-specific token
+          const tokenEnv = server?.auth?.tokenEnv;
+          let callClient = client;
+          if (tokenEnv && this.envResolver && context?.tenantId) {
+            const tenantToken = await this.envResolver(context.tenantId, tokenEnv);
+            const defaultToken = process.env[tokenEnv];
+            // Only create a per-request client when the tenant has a different token.
+            // Using the original client preserves the established MCP session.
+            if (tenantToken && tenantToken !== defaultToken) {
+              callClient = new StreamableHttpMcpRpcClient(
+                server.url,
+                server.timeoutMs ?? 10_000,
+                tenantToken,
+                server.headers,
+              );
+            }
+          }
+          return await callClient.callTool(tool.name, input);
         } catch (error) {
           if (error instanceof McpHttpError && error.status === 401) {
             this.authFailedServers.add(serverName);

package/src/memory.ts

@@ -1,14 +1,5 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { defineTool, type ToolDefinition } from "@poncho-ai/sdk";
+import { defineTool, type ToolContext, type ToolDefinition } from "@poncho-ai/sdk";
 import type { StateProviderName } from "./state.js";
-import {
-  ensureAgentIdentity,
-  getAgentStoreDirectory,
-  slugifyStorageComponent,
-  STORAGE_SCHEMA_VERSION,
-} from "./agent-identity.js";
-import { createRawKVStore, type RawKVStore } from "./kv-store.js";
 
 export interface MainMemory {
   content: string;
@@ -31,10 +22,6 @@ export interface MemoryStore {
   updateMainMemory(input: { content: string }): Promise<MainMemory>;
 }
 
-type MainMemoryPayload = {
-  main: MainMemory;
-};
-
 type RecallItem = {
   conversationId: string;
   title: string;
@@ -42,18 +29,27 @@ type RecallItem = {
   content: string;
 };
 
+type ConversationListItem = {
+  conversationId: string;
+  title: string;
+  createdAt?: number;
+  updatedAt: number;
+  messageCount?: number;
+};
+
+type ConversationDetail = {
+  conversationId: string;
+  title: string;
+  createdAt?: number;
+  updatedAt: number;
+  messages: Array<{ role: string; content: string }>;
+};
+
+
 const DEFAULT_MAIN_MEMORY: MainMemory = {
   content: "",
   updatedAt: 0,
 };
-const LOCAL_MEMORY_FILE = "memory.json";
-
-const writeJsonAtomic = async (filePath: string, payload: unknown): Promise<void> => {
-  await mkdir(dirname(filePath), { recursive: true });
-  const tmpPath = `${filePath}.tmp`;
-  await writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf8");
-  await rename(tmpPath, filePath);
-};
 
 const scoreText = (text: string, query: string): number => {
   const normalized = query.trim().toLowerCase();
@@ -99,150 +95,12 @@ class InMemoryMemoryStore implements MemoryStore {
   }
 }
 
-class FileMainMemoryStore implements MemoryStore {
-  private readonly workingDir: string;
-  private filePath = "";
-  private readonly ttlMs?: number;
-  private loaded = false;
-  private writing = Promise.resolve();
-  private mainMemory: MainMemory = { ...DEFAULT_MAIN_MEMORY };
-
-  constructor(workingDir: string, ttlSeconds?: number) {
-    this.workingDir = workingDir;
-    this.ttlMs = typeof ttlSeconds === "number" ? ttlSeconds * 1000 : undefined;
-  }
-
-  private async ensureFilePath(): Promise<void> {
-    if (this.filePath) {
-      return;
-    }
-    const identity = await ensureAgentIdentity(this.workingDir);
-    this.filePath = resolve(getAgentStoreDirectory(identity), LOCAL_MEMORY_FILE);
-  }
-
-  private isExpired(updatedAt: number): boolean {
-    return typeof this.ttlMs === "number" && Date.now() - updatedAt > this.ttlMs;
-  }
-
-  private async ensureLoaded(): Promise<void> {
-    await this.ensureFilePath();
-    if (this.loaded) {
-      return;
-    }
-    this.loaded = true;
-    try {
-      const raw = await readFile(this.filePath, "utf8");
-      const parsed = JSON.parse(raw) as MainMemoryPayload;
-      const content = typeof parsed.main?.content === "string" ? parsed.main.content : "";
-      const updatedAt = typeof parsed.main?.updatedAt === "number" ? parsed.main.updatedAt : 0;
-      this.mainMemory = { content, updatedAt };
-    } catch {
-      // Missing or invalid file should not crash local mode.
-    }
-  }
-
-  private async persist(): Promise<void> {
-    const payload: MainMemoryPayload = { main: this.mainMemory };
-    this.writing = this.writing.then(async () => {
-      await writeJsonAtomic(this.filePath, payload);
-    });
-    await this.writing;
-  }
-
-  async getMainMemory(): Promise<MainMemory> {
-    await this.ensureLoaded();
-    if (this.mainMemory.updatedAt > 0 && this.isExpired(this.mainMemory.updatedAt)) {
-      this.mainMemory = { ...DEFAULT_MAIN_MEMORY };
-      await this.persist();
-    }
-    return this.mainMemory;
-  }
-
-  async updateMainMemory(input: { content: string }): Promise<MainMemory> {
-    await this.ensureLoaded();
-    this.mainMemory = {
-      content: input.content.trim(),
-      updatedAt: Date.now(),
-    };
-    await this.persist();
-    return this.mainMemory;
-  }
-}
-
-class KVBackedMemoryStore implements MemoryStore {
-  private readonly kv: RawKVStore;
-  private readonly storageKey: string;
-  private readonly ttl?: number;
-  private readonly memoryFallback: InMemoryMemoryStore;
-
-  constructor(kv: RawKVStore, storageKey: string, ttl?: number) {
-    this.kv = kv;
-    this.storageKey = storageKey;
-    this.ttl = ttl;
-    this.memoryFallback = new InMemoryMemoryStore(ttl);
-  }
-
-  private async readPayload(): Promise<MainMemoryPayload> {
-    try {
-      const raw = await this.kv.get(this.storageKey);
-      if (!raw) return { main: { ...DEFAULT_MAIN_MEMORY } };
-      const parsed = JSON.parse(raw) as MainMemoryPayload;
-      const content = typeof parsed.main?.content === "string" ? parsed.main.content : "";
-      const updatedAt = typeof parsed.main?.updatedAt === "number" ? parsed.main.updatedAt : 0;
-      return { main: { content, updatedAt } };
-    } catch {
-      const main = await this.memoryFallback.getMainMemory();
-      return { main };
-    }
-  }
-
-  private async writePayload(payload: MainMemoryPayload): Promise<void> {
-    try {
-      const serialized = JSON.stringify(payload);
-      if (typeof this.ttl === "number") {
-        await this.kv.setWithTtl(this.storageKey, serialized, Math.max(1, this.ttl));
-      } else {
-        await this.kv.set(this.storageKey, serialized);
-      }
-    } catch {
-      await this.memoryFallback.updateMainMemory({ content: payload.main.content });
-    }
-  }
-
-  async getMainMemory(): Promise<MainMemory> {
-    const payload = await this.readPayload();
-    return payload.main;
-  }
-
-  async updateMainMemory(input: { content: string }): Promise<MainMemory> {
-    const payload = await this.readPayload();
-    payload.main = { content: input.content.trim(), updatedAt: Date.now() };
-    await this.writePayload(payload);
-    return payload.main;
-  }
-}
-
 export const createMemoryStore = (
   agentId: string,
   config?: MemoryConfig,
-  options?: { workingDir?: string },
+  options?: { workingDir?: string; tenantId?: string },
 ): MemoryStore => {
-  const provider = config?.provider ?? "local";
   const ttl = config?.ttl;
-  const workingDir = options?.workingDir ?? process.cwd();
-
-  if (provider === "local") {
-    return new FileMainMemoryStore(workingDir, ttl);
-  }
-  if (provider === "memory") {
-    return new InMemoryMemoryStore(ttl);
-  }
-
-  const kv = createRawKVStore(config);
-  if (kv) {
-    const storageKey = `poncho:${STORAGE_SCHEMA_VERSION}:${slugifyStorageComponent(agentId)}:memory:main`;
-    return new KVBackedMemoryStore(kv, storageKey, ttl);
-  }
   return new InMemoryMemoryStore(ttl);
 };
 
@@ -281,9 +139,12 @@ const buildRecallSnippet = (content: string, query: string, maxChars = 360): str
 };
 
 export const createMemoryTools = (
-  store: MemoryStore,
+  store: MemoryStore | ((context: ToolContext) => MemoryStore),
   options?: { maxRecallConversations?: number },
 ): ToolDefinition[] => {
+  const resolveStore = typeof store === "function"
+    ? store
+    : () => store;
   const maxRecallConversations = Math.max(1, options?.maxRecallConversations ?? 20);
   return [
     defineTool({
@@ -294,8 +155,8 @@ export const createMemoryTools = (
         properties: {},
         additionalProperties: false,
       },
-      handler: async () => {
-        const memory = await store.getMainMemory();
+      handler: async (_input, context) => {
+        const memory = await resolveStore(context).getMainMemory();
         return { memory };
       },
     }),
@@ -316,12 +177,12 @@ export const createMemoryTools = (
         required: ["content"],
         additionalProperties: false,
       },
-      handler: async (input) => {
+      handler: async (input, context) => {
         const content = typeof input.content === "string" ? input.content.trim() : "";
         if (!content) {
           throw new Error("content is required");
         }
-        const memory = await store.updateMainMemory({ content });
+        const memory = await resolveStore(context).updateMainMemory({ content });
         return { ok: true, memory };
       },
     }),
@@ -349,13 +210,13 @@ export const createMemoryTools = (
         required: ["old_str", "new_str"],
         additionalProperties: false,
       },
-      handler: async (input) => {
+      handler: async (input, context) => {
         const oldStr = typeof input.old_str === "string" ? input.old_str : "";
         const newStr = typeof input.new_str === "string" ? input.new_str : "";
         if (!oldStr) {
           throw new Error("old_str must not be empty.");
         }
-        const current = await store.getMainMemory();
+        const current = await resolveStore(context).getMainMemory();
         const content = current.content;
         const first = content.indexOf(oldStr);
         if (first === -1) {
@@ -370,63 +231,153 @@ export const createMemoryTools = (
           );
         }
         const newContent = content.slice(0, first) + newStr + content.slice(first + oldStr.length);
-        const memory = await store.updateMainMemory({ content: newContent });
+        const memory = await resolveStore(context).updateMainMemory({ content: newContent });
         return { ok: true, memory };
       },
     }),
     defineTool({
       name: "conversation_recall",
       description:
-        "Recall relevant snippets from previous conversations when prior context is likely important (for example: 'as we discussed', 'last time', or ambiguous references).",
+        "Recall past conversations. Three modes:\n" +
+        "- Search: provide 'query' to keyword-search past conversations for relevant snippets.\n" +
+        "- List: provide 'after' and/or 'before' dates to browse conversations by date range.\n" +
+        "- Fetch: provide 'conversationId' to load the full message history of a specific conversation.\n" +
+        "Modes can be combined (e.g. query + date range to search within a time window).",
       inputSchema: {
         type: "object",
         properties: {
           query: {
             type: "string",
-            description: "Search query for past conversation recall",
+            description: "Keyword search query for past conversations",
           },
-          limit: {
-            type: "number",
-            description: "Maximum snippets to return",
+          after: {
+            type: "string",
+            description:
+              "ISO 8601 date string. Only return conversations updated after this date (e.g. '2025-03-01').",
           },
-          excludeConversationId: {
+          before: {
             type: "string",
-            description: "Optional conversation id to exclude from recall",
+            description:
+              "ISO 8601 date string. Only return conversations updated before this date.",
+          },
+          conversationId: {
+            type: "string",
+            description: "Fetch the full message history of a specific conversation by ID",
+          },
+          lastN: {
+            type: "number",
+            description: "When fetching a conversation, only return the last N messages (max 50)",
+          },
+          limit: {
+            type: "number",
+            description: "Maximum results to return (default 20 for list, 3 for search, max 50)",
           },
         },
-        required: ["query"],
         additionalProperties: false,
       },
       handler: async (input, context) => {
         const query = typeof input.query === "string" ? input.query.trim() : "";
-        if (!query) {
-          throw new Error("query is required");
+        const after = typeof input.after === "string" ? input.after : "";
+        const before = typeof input.before === "string" ? input.before : "";
+        const fetchId = typeof input.conversationId === "string" ? input.conversationId.trim() : "";
+        const hasDateFilter = after !== "" || before !== "";
+
+        // Determine mode
+        const mode = fetchId ? "fetch" : (query && !hasDateFilter) ? "search" : "list";
+
+        // --- Fetch mode: load full conversation by ID ---
+        if (mode === "fetch") {
+          const rawFetchFn = context.parameters.__conversationFetchFn;
+          if (typeof rawFetchFn !== "function") {
+            throw new Error("Conversation fetching is not available in this environment.");
+          }
+          const conversation = (await (rawFetchFn as (id: string) => Promise<unknown>)(fetchId)) as
+            | ConversationDetail
+            | undefined;
+          if (!conversation) {
+            throw new Error(`Conversation '${fetchId}' not found.`);
+          }
+          const lastN = typeof input.lastN === "number" ? Math.max(1, Math.min(50, input.lastN)) : undefined;
+          const messages = lastN
+            ? conversation.messages.slice(-lastN)
+            : conversation.messages.slice(-50);
+          return {
+            mode: "fetch",
+            conversationId: conversation.conversationId,
+            title: conversation.title,
+            createdAt: conversation.createdAt
+              ? new Date(conversation.createdAt).toISOString()
+              : undefined,
+            updatedAt: new Date(conversation.updatedAt).toISOString(),
+            messageCount: conversation.messages.length,
+            messages: messages.map((m) => ({
+              role: m.role,
+              content: m.content.slice(0, 4000),
+            })),
+          };
         }
+
+        // --- List mode: browse by date, optionally with keyword filtering ---
+        if (mode === "list") {
+          const rawListFn = context.parameters.__conversationListFn;
+          if (typeof rawListFn !== "function") {
+            throw new Error("Conversation listing is not available in this environment.");
+          }
+          const allConversations = (await (rawListFn as () => Promise<unknown>)()) as ConversationListItem[];
+          const limit = Math.max(1, Math.min(50, typeof input.limit === "number" ? input.limit : 20));
+          const afterMs = after ? new Date(after).getTime() : 0;
+          const beforeMs = before ? new Date(before).getTime() : Infinity;
+
+          let filtered = allConversations.filter((item) => {
+            const ts = item.updatedAt;
+            return ts >= afterMs && ts <= beforeMs;
+          });
+
+          // If query is also provided, score and rank by relevance
+          if (query) {
+            filtered = filtered
+              .map((item) => ({
+                ...item,
+                _score: scoreText(item.title, query),
+              }))
+              .filter((item) => item._score > 0)
+              .sort((a, b) => {
+                if (b._score === a._score) return b.updatedAt - a.updatedAt;
+                return b._score - a._score;
+              });
+          }
+
+          return {
+            mode: "list",
+            conversations: filtered.slice(0, limit).map((item) => ({
+              conversationId: item.conversationId,
+              title: item.title,
+              createdAt: item.createdAt
+                ? new Date(item.createdAt).toISOString()
+                : undefined,
+              updatedAt: new Date(item.updatedAt).toISOString(),
+              messageCount: item.messageCount,
+            })),
+          };
+        }
+
+        // --- Search mode: keyword search across conversation content ---
         const limit = Math.max(
           1,
-          Math.min(5, typeof input.limit === "number" ? input.limit : 3),
+          Math.min(10, typeof input.limit === "number" ? input.limit : 3),
         );
-        const excludeConversationId =
-          typeof input.excludeConversationId === "string"
-            ? input.excludeConversationId
-            : "";
         const rawCorpus = context.parameters.__conversationRecallCorpus;
         const resolvedCorpus =
           typeof rawCorpus === "function" ? await (rawCorpus as () => Promise<unknown>)() : rawCorpus;
         const corpus = asRecallCorpus(resolvedCorpus).slice(0, maxRecallConversations);
         const results = corpus
-          .filter((item) =>
-            excludeConversationId ? item.conversationId !== excludeConversationId : true,
-          )
           .map((item) => ({
             ...item,
             score: scoreText(`${item.title}\n${item.content}`, query),
           }))
           .filter((item) => item.score > 0)
           .sort((a, b) => {
-            if (b.score === a.score) {
-              return b.updatedAt - a.updatedAt;
-            }
+            if (b.score === a.score) return b.updatedAt - a.updatedAt;
             return b.score - a.score;
           })
           .slice(0, limit)
@@ -436,7 +387,7 @@ export const createMemoryTools = (
             updatedAt: item.updatedAt,
             snippet: buildRecallSnippet(item.content, query),
           }));
-        return { results };
+        return { mode: "search", results };
       },
     }),
   ];