@poncho-ai/harness 0.40.1 → 0.42.0

package/dist/index.js

@@ -5911,6 +5911,11 @@ var McpHttpError = class extends Error {
     this.status = status;
   }
 };
+var McpSessionExpiredError = class extends Error {
+  constructor() {
+    super("MCP session expired");
+  }
+};
 var StreamableHttpMcpRpcClient = class {
   endpoint;
   timeoutMs;
@@ -5962,6 +5967,9 @@ var StreamableHttpMcpRpcClient = class {
       if (response.status === 403) {
         throw new McpHttpError(403, "MCP server forbidden");
       }
+      if (response.status === 404 && this.sessionId) {
+        throw new McpSessionExpiredError();
+      }
       if (!response.ok) {
         throw new Error(`MCP HTTP request failed with status ${response.status}`);
       }
@@ -6036,20 +6044,32 @@ var StreamableHttpMcpRpcClient = class {
     throw new Error(`MCP response missing JSON-RPC payload for id ${id}`);
   }
   async request(method, params) {
-    await this.ensureInitialized();
-    const id = this.idCounter++;
-    const payload = {
-      jsonrpc: "2.0",
-      id,
-      method,
-      params: params ?? {}
-    };
-    const payloads = await this.postMessage(payload);
-    const result = this.extractResult(payloads, id);
-    if (result.error) {
-      throw new Error(result.error.message ?? `MCP error on ${method}`);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        await this.ensureInitialized();
+        const id = this.idCounter++;
+        const payload = {
+          jsonrpc: "2.0",
+          id,
+          method,
+          params: params ?? {}
+        };
+        const payloads = await this.postMessage(payload);
+        const result = this.extractResult(payloads, id);
+        if (result.error) {
+          throw new Error(result.error.message ?? `MCP error on ${method}`);
+        }
+        return result.result;
+      } catch (error) {
+        if (error instanceof McpSessionExpiredError && attempt === 0) {
+          this.sessionId = void 0;
+          this.initialized = false;
+          continue;
+        }
+        throw error;
+      }
     }
-    return result.result;
+    throw new Error(`MCP request to ${method} failed after session retry`);
   }
   async ensureInitialized() {
     if (this.initialized) {
@@ -6105,6 +6125,8 @@ var StreamableHttpMcpRpcClient = class {
     }
   }
 };
+var TENANT_CLIENT_TTL_MS = 15 * 60 * 1e3;
+var tenantClientKey = (serverName, tenantId) => `${serverName}\0${tenantId}`;
 var LocalMcpBridge = class {
   remoteServers;
   rpcClients = /* @__PURE__ */ new Map();
@@ -6112,6 +6134,18 @@ var LocalMcpBridge = class {
   unavailableServers = /* @__PURE__ */ new Map();
   authFailedServers = /* @__PURE__ */ new Set();
   envResolver;
+  /**
+   * Per-tenant MCP client cache. For consumer/SaaS deployments where every
+   * call resolves a different bearer token, building a fresh
+   * `StreamableHttpMcpRpcClient` per call would force a fresh `initialize`
+   * round-trip every time. We keep one client per `(serverName, tenantId)`
+   * with TTL-based idle eviction; on token rotation we evict the entry
+   * lazily and rebuild.
+   */
+  tenantClients = /* @__PURE__ */ new Map();
+  /** Test/observability hook: bumped every time a new tenant client is constructed. */
+  tenantClientConstructions = 0;
+  tenantClientTtlMs;
   /**
    * Set a resolver for per-tenant env vars (e.g. MCP auth tokens).
    * Called by the harness after creating the secrets store.
@@ -6119,7 +6153,8 @@ var LocalMcpBridge = class {
   setEnvResolver(resolver) {
     this.envResolver = resolver;
   }
-  constructor(config) {
+  constructor(config, options) {
+    this.tenantClientTtlMs = options?.tenantClientTtlMs ?? TENANT_CLIENT_TTL_MS;
     this.remoteServers = (config?.mcp ?? []).filter(
       (entry) => typeof entry.url === "string"
     );
@@ -6290,6 +6325,35 @@ var LocalMcpBridge = class {
       await client.close();
     }
     this.rpcClients.clear();
+    for (const [, entry] of this.tenantClients) {
+      await entry.client.close();
+    }
+    this.tenantClients.clear();
+  }
+  getOrCreateTenantClient(serverName, tenantId, token, server) {
+    const key = tenantClientKey(serverName, tenantId);
+    const now2 = Date.now();
+    const existing = this.tenantClients.get(key);
+    if (existing) {
+      const idle = now2 - existing.lastUsed > this.tenantClientTtlMs;
+      const tokenChanged = existing.token !== token;
+      if (idle || tokenChanged) {
+        void existing.client.close();
+        this.tenantClients.delete(key);
+      } else {
+        existing.lastUsed = now2;
+        return existing.client;
+      }
+    }
+    const client = new StreamableHttpMcpRpcClient(
+      server.url,
+      server.timeoutMs ?? 1e4,
+      token,
+      server.headers
+    );
+    this.tenantClients.set(key, { client, token, lastUsed: now2 });
+    this.tenantClientConstructions += 1;
+    return client;
   }
   listServers() {
     return [...this.remoteServers];
@@ -6411,15 +6475,15 @@ var LocalMcpBridge = class {
         try {
           const tokenEnv = server?.auth?.tokenEnv;
           let callClient = client;
-          if (tokenEnv && this.envResolver && context?.tenantId) {
+          if (tokenEnv && this.envResolver && context?.tenantId && server) {
             const tenantToken = await this.envResolver(context.tenantId, tokenEnv);
             const defaultToken = process.env[tokenEnv];
             if (tenantToken && tenantToken !== defaultToken) {
-              callClient = new StreamableHttpMcpRpcClient(
-                server.url,
-                server.timeoutMs ?? 1e4,
+              callClient = this.getOrCreateTenantClient(
+                serverName,
+                context.tenantId,
                 tenantToken,
-                server.headers
+                server
               );
             }
           }
@@ -8640,6 +8704,7 @@ var AgentHarness = class _AgentHarness {
   reminderStore;
   secretsStore;
   loadedConfig;
+  injectedConfig;
   loadedSkills = [];
   skillFingerprint = "";
   lastSkillRefreshAt = 0;
@@ -8654,6 +8719,8 @@ var AgentHarness = class _AgentHarness {
   _browserMod;
   parsedAgent;
   agentFileFingerprint = "";
+  injectedAgentDefinition;
+  injectedStorageEngine = false;
   mcpBridge;
   subagentManager;
   archivedToolResultsByConversation = /* @__PURE__ */ new Map();
@@ -8821,6 +8888,17 @@ var AgentHarness = class _AgentHarness {
     this.modelProviderInjected = !!options.modelProvider;
     this.modelProvider = options.modelProvider ?? createModelProvider("anthropic");
     this.uploadStore = options.uploadStore;
+    this.injectedConfig = options.config;
+    if (options.agentDefinition !== void 0 && options.storageEngine === void 0) {
+      throw new Error(
+        "HarnessOptions.agentDefinition requires HarnessOptions.storageEngine \u2014 construct a StorageEngine with the desired agentId and pass both."
+      );
+    }
+    this.injectedAgentDefinition = options.agentDefinition;
+    if (options.storageEngine) {
+      this.storageEngine = options.storageEngine;
+      this.injectedStorageEngine = true;
+    }
     if (options.toolDefinitions?.length) {
       this.dispatcher.registerMany(options.toolDefinitions);
     }
@@ -9237,6 +9315,9 @@ var AgentHarness = class _AgentHarness {
     if (this.environment !== "development") {
       return false;
     }
+    if (this.injectedAgentDefinition !== void 0) {
+      return false;
+    }
     try {
       const agentFilePath = resolve11(this.workingDir, "AGENT.md");
       const rawContent = await readFile8(agentFilePath, "utf8");
@@ -9304,15 +9385,23 @@ var AgentHarness = class _AgentHarness {
     }
   }
   async initialize() {
-    const agentFilePath = resolve11(this.workingDir, "AGENT.md");
-    const agentRawContent = await readFile8(agentFilePath, "utf8");
-    this.parsedAgent = parseAgentMarkdown(agentRawContent);
-    this.agentFileFingerprint = agentRawContent;
-    const identity = await ensureAgentIdentity(this.workingDir);
-    if (!this.parsedAgent.frontmatter.id) {
-      this.parsedAgent.frontmatter.id = identity.id;
+    if (this.injectedAgentDefinition !== void 0) {
+      this.parsedAgent = typeof this.injectedAgentDefinition === "string" ? parseAgentMarkdown(this.injectedAgentDefinition) : this.injectedAgentDefinition;
+      this.agentFileFingerprint = "";
+      if (this.storageEngine) {
+        this.parsedAgent.frontmatter.id = this.storageEngine.agentId;
+      }
+    } else {
+      const agentFilePath = resolve11(this.workingDir, "AGENT.md");
+      const agentRawContent = await readFile8(agentFilePath, "utf8");
+      this.parsedAgent = parseAgentMarkdown(agentRawContent);
+      this.agentFileFingerprint = agentRawContent;
+      const identity = await ensureAgentIdentity(this.workingDir);
+      if (!this.parsedAgent.frontmatter.id) {
+        this.parsedAgent.frontmatter.id = identity.id;
+      }
     }
-    const config = await loadPonchoConfig(this.workingDir);
+    const config = this.injectedConfig ?? await loadPonchoConfig(this.workingDir);
     this.loadedConfig = config;
     this.registerConfiguredBuiltInTools(config);
     const provider = this.parsedAgent.frontmatter.model?.provider ?? "anthropic";
@@ -9328,15 +9417,21 @@ var AgentHarness = class _AgentHarness {
     this.skillFingerprint = this.buildSkillFingerprint(skillMetadata);
     this.registerSkillTools();
     const agentId = this.parsedAgent.frontmatter.id ?? this.parsedAgent.frontmatter.name;
-    const storageProvider = config?.storage?.provider ?? "sqlite";
-    const engine = createStorageEngine({
-      provider: storageProvider,
-      workingDir: this.workingDir,
-      agentId,
-      urlEnv: config?.storage?.urlEnv
-    });
-    await engine.initialize();
-    this.storageEngine = engine;
+    let engine;
+    if (this.injectedStorageEngine && this.storageEngine) {
+      engine = this.storageEngine;
+      await engine.initialize();
+    } else {
+      const storageProvider = config?.storage?.provider ?? "sqlite";
+      engine = createStorageEngine({
+        provider: storageProvider,
+        workingDir: this.workingDir,
+        agentId,
+        urlEnv: config?.storage?.urlEnv
+      });
+      await engine.initialize();
+      this.storageEngine = engine;
+    }
     const maxFileSize = config?.storage?.limits?.maxFileSize ?? 100 * 1024 * 1024;
     const maxTotalStorage = config?.storage?.limits?.maxTotalStorage ?? 1024 * 1024 * 1024;
     const bashWorkingDir = this.environment === "production" ? null : this.workingDir;
@@ -9559,6 +9654,10 @@ var AgentHarness = class _AgentHarness {
   listSkills() {
     return this.loadedSkills.map((s) => ({ name: s.name, description: s.description }));
   }
+  async listSkillsForTenant(tenantId) {
+    const skills = await this.getSkillsForTenant(tenantId);
+    return skills.map((s) => ({ name: s.name, description: s.description }));
+  }
   /**
    * Wraps the run() generator with an OTel root span (invoke_agent) so all
    * child spans (LLM calls via AI SDK, tool execution) group under one trace.
@@ -12896,6 +12995,311 @@ ${resultBody}`,
   }
 };
 
+// src/orchestrator/run-conversation-turn.ts
+import { randomUUID as randomUUID6 } from "crypto";
+import { createLogger as createLogger7 } from "@poncho-ai/sdk";
+var log = createLogger7("orchestrator");
+var runConversationTurn = async (opts) => {
+  const conversation = await opts.conversationStore.getWithArchive(opts.conversationId);
+  if (!conversation) {
+    throw new Error(`Conversation not found: ${opts.conversationId}`);
+  }
+  const canonicalHistory = resolveRunRequest(conversation, {
+    conversationId: opts.conversationId,
+    messages: conversation.messages
+  });
+  const shouldRebuildCanonical = canonicalHistory.shouldRebuildCanonical;
+  const harnessMessages = [...canonicalHistory.messages];
+  const historyMessages = [...conversation.messages];
+  const preRunMessages = [...conversation.messages];
+  let userContent = opts.task;
+  if (opts.files && opts.files.length > 0 && opts.harness.uploadStore) {
+    const uploadedParts = await Promise.all(
+      opts.files.map(async (f) => {
+        const buf = Buffer.from(f.data, "base64");
+        const key = deriveUploadKey(buf, f.mediaType);
+        const ref = await opts.harness.uploadStore.put(key, buf, f.mediaType);
+        return {
+          type: "file",
+          data: ref,
+          mediaType: f.mediaType,
+          filename: f.filename
+        };
+      })
+    );
+    userContent = [
+      { type: "text", text: opts.task },
+      ...uploadedParts
+    ];
+  }
+  const turnTimestamp = Date.now();
+  const userMessage = {
+    role: "user",
+    content: userContent,
+    metadata: { id: randomUUID6(), timestamp: turnTimestamp }
+  };
+  const assistantId = randomUUID6();
+  const draft = createTurnDraftState();
+  let latestRunId = conversation.runtimeRunId ?? "";
+  let runCancelled = false;
+  let runContinuationMessages;
+  let cancelHarnessMessages;
+  let checkpointedRun = false;
+  const buildMessages = () => {
+    const draftSections = cloneSections(draft.sections);
+    if (draft.currentTools.length > 0) {
+      draftSections.push({ type: "tools", content: [...draft.currentTools] });
+    }
+    if (draft.currentText.length > 0) {
+      draftSections.push({ type: "text", content: draft.currentText });
+    }
+    const userTurn = [userMessage];
+    const hasDraftContent = draft.assistantResponse.length > 0 || draft.toolTimeline.length > 0 || draftSections.length > 0;
+    if (!hasDraftContent) {
+      return [...historyMessages, ...userTurn];
+    }
+    return [
+      ...historyMessages,
+      ...userTurn,
+      {
+        role: "assistant",
+        content: draft.assistantResponse,
+        metadata: buildAssistantMetadata(draft, draftSections, {
+          id: assistantId,
+          timestamp: turnTimestamp
+        })
+      }
+    ];
+  };
+  const persistDraft = async () => {
+    if (draft.assistantResponse.length === 0 && draft.toolTimeline.length === 0) return;
+    conversation.messages = buildMessages();
+    conversation.updatedAt = Date.now();
+    await opts.conversationStore.update(conversation);
+  };
+  conversation.messages = [...historyMessages, userMessage];
+  conversation.subagentCallbackCount = 0;
+  conversation._continuationCount = void 0;
+  conversation.updatedAt = Date.now();
+  opts.conversationStore.update(conversation).catch((err) => {
+    log.error(
+      `failed to persist user turn: ${err instanceof Error ? err.message : String(err)}`
+    );
+  });
+  try {
+    const execution = await executeConversationTurn({
+      harness: opts.harness,
+      runInput: {
+        task: opts.task,
+        conversationId: opts.conversationId,
+        tenantId: opts.tenantId ?? void 0,
+        parameters: withToolResultArchiveParam(
+          {
+            ...opts.parameters ?? {},
+            __activeConversationId: opts.conversationId,
+            __ownerId: conversation.ownerId
+          },
+          conversation
+        ),
+        messages: harnessMessages,
+        files: opts.files && opts.files.length > 0 ? opts.files : void 0,
+        abortSignal: opts.abortSignal
+      },
+      initialContextTokens: conversation.contextTokens ?? 0,
+      initialContextWindow: conversation.contextWindow ?? 0,
+      onEvent: async (event, eventDraft) => {
+        draft.assistantResponse = eventDraft.assistantResponse;
+        draft.toolTimeline = eventDraft.toolTimeline;
+        draft.sections = eventDraft.sections;
+        draft.currentTools = eventDraft.currentTools;
+        draft.currentText = eventDraft.currentText;
+        if (event.type === "run:started") {
+          latestRunId = event.runId;
+        }
+        if (event.type === "run:cancelled") {
+          runCancelled = true;
+          if (event.messages) cancelHarnessMessages = event.messages;
+        }
+        if (event.type === "compaction:completed") {
+          if (event.compactedMessages) {
+            historyMessages.length = 0;
+            historyMessages.push(...event.compactedMessages);
+            const preservedFromHistory = historyMessages.length - 1;
+            const removedCount = preRunMessages.length - Math.max(0, preservedFromHistory);
+            const existingHistory = conversation.compactedHistory ?? [];
+            conversation.compactedHistory = [
+              ...existingHistory,
+              ...preRunMessages.slice(0, removedCount)
+            ];
+          }
+        }
+        if (event.type === "step:completed") {
+          await persistDraft();
+        }
+        if (event.type === "tool:approval:required") {
+          const toolText = `- approval required \`${event.tool}\``;
+          draft.toolTimeline.push(toolText);
+          draft.currentTools.push(toolText);
+          const existing = Array.isArray(conversation.pendingApprovals) ? conversation.pendingApprovals : [];
+          if (!existing.some((a) => a.approvalId === event.approvalId)) {
+            conversation.pendingApprovals = [
+              ...existing,
+              {
+                approvalId: event.approvalId,
+                runId: latestRunId || conversation.runtimeRunId || "",
+                tool: event.tool,
+                toolCallId: void 0,
+                input: event.input ?? {},
+                checkpointMessages: void 0,
+                baseMessageCount: historyMessages.length,
+                pendingToolCalls: []
+              }
+            ];
+            conversation.updatedAt = Date.now();
+            await opts.conversationStore.update(conversation);
+          }
+          await persistDraft();
+        }
+        if (event.type === "tool:approval:checkpoint") {
+          conversation.messages = buildMessages();
+          conversation.pendingApprovals = buildApprovalCheckpoints({
+            approvals: event.approvals,
+            runId: latestRunId,
+            checkpointMessages: event.checkpointMessages,
+            baseMessageCount: historyMessages.length,
+            pendingToolCalls: event.pendingToolCalls
+          });
+          conversation._toolResultArchive = opts.harness.getToolResultArchive(
+            opts.conversationId
+          );
+          conversation.updatedAt = Date.now();
+          await opts.conversationStore.update(conversation);
+          checkpointedRun = true;
+        }
+        if (event.type === "run:completed") {
+          if (event.result.continuation && event.result.continuationMessages) {
+            runContinuationMessages = event.result.continuationMessages;
+            conversation.messages = buildMessages();
+            conversation._continuationMessages = runContinuationMessages;
+            conversation._harnessMessages = runContinuationMessages;
+            conversation._toolResultArchive = opts.harness.getToolResultArchive(
+              opts.conversationId
+            );
+            conversation.runtimeRunId = latestRunId || conversation.runtimeRunId;
+            if (!checkpointedRun) {
+              conversation.pendingApprovals = [];
+            }
+            if ((event.result.contextTokens ?? 0) > 0) {
+              conversation.contextTokens = event.result.contextTokens;
+            }
+            if ((event.result.contextWindow ?? 0) > 0) {
+              conversation.contextWindow = event.result.contextWindow;
+            }
+            conversation.updatedAt = Date.now();
+            await opts.conversationStore.update(conversation);
+          }
+        }
+        if (opts.onEvent) {
+          await opts.onEvent(event);
+        }
+      }
+    });
+    flushTurnDraft(draft);
+    latestRunId = execution.latestRunId || latestRunId;
+    if (!checkpointedRun && !runContinuationMessages) {
+      conversation.messages = buildMessages();
+      applyTurnMetadata(
+        conversation,
+        {
+          latestRunId,
+          contextTokens: execution.runContextTokens,
+          contextWindow: execution.runContextWindow,
+          harnessMessages: execution.runHarnessMessages,
+          toolResultArchive: opts.harness.getToolResultArchive(opts.conversationId)
+        },
+        { shouldRebuildCanonical }
+      );
+      await opts.conversationStore.update(conversation);
+    }
+    return {
+      latestRunId,
+      cancelled: runCancelled,
+      errored: false,
+      continuation: !!runContinuationMessages,
+      checkpointed: checkpointedRun,
+      contextTokens: execution.runContextTokens,
+      contextWindow: execution.runContextWindow
+    };
+  } catch (error) {
+    flushTurnDraft(draft);
+    const aborted = opts.abortSignal?.aborted === true;
+    if (aborted || runCancelled) {
+      if (draft.assistantResponse.length > 0 || draft.toolTimeline.length > 0 || draft.sections.length > 0) {
+        conversation.messages = buildMessages();
+        applyTurnMetadata(
+          conversation,
+          {
+            latestRunId,
+            contextTokens: 0,
+            contextWindow: 0,
+            harnessMessages: cancelHarnessMessages,
+            toolResultArchive: opts.harness.getToolResultArchive(opts.conversationId)
+          },
+          { shouldRebuildCanonical: true }
+        );
+        await opts.conversationStore.update(conversation);
+      }
+      if (!checkpointedRun) {
+        const fresh = await opts.conversationStore.get(opts.conversationId);
+        if (fresh && Array.isArray(fresh.pendingApprovals) && fresh.pendingApprovals.length > 0) {
+          fresh.pendingApprovals = [];
+          await opts.conversationStore.update(fresh);
+        }
+      }
+      return {
+        latestRunId,
+        cancelled: true,
+        errored: false,
+        continuation: false,
+        checkpointed: checkpointedRun,
+        contextTokens: 0,
+        contextWindow: 0
+      };
+    }
+    const errorEvent = {
+      type: "run:error",
+      runId: latestRunId || "run_unknown",
+      error: {
+        code: "RUN_ERROR",
+        message: error instanceof Error ? error.message : "Unknown error"
+      }
+    };
+    if (opts.onEvent) {
+      try {
+        await opts.onEvent(errorEvent);
+      } catch (hookErr) {
+        log.error(
+          `onEvent threw on run:error: ${hookErr instanceof Error ? hookErr.message : String(hookErr)}`
+        );
+      }
+    }
+    if (draft.assistantResponse.length > 0 || draft.toolTimeline.length > 0 || draft.sections.length > 0) {
+      conversation.messages = buildMessages();
+      conversation.updatedAt = Date.now();
+      await opts.conversationStore.update(conversation);
+    }
+    return {
+      latestRunId,
+      cancelled: false,
+      errored: true,
+      continuation: false,
+      checkpointed: checkpointedRun,
+      contextTokens: 0,
+      contextWindow: 0
+    };
+  }
+};
+
 // src/index.ts
 import { defineTool as defineTool13 } from "@poncho-ai/sdk";
 export {
@@ -13003,6 +13407,7 @@ export {
   resolveRunRequest,
   resolveSkillDirs,
   resolveStateConfig,
+  runConversationTurn,
   slugifyStorageComponent,
   startOpenAICodexDeviceAuth,
   verifyTenantToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/harness",
-  "version": "0.40.1",
+  "version": "0.42.0",
   "description": "Agent execution runtime - conversation loop, tool dispatch, streaming",
   "repository": {
     "type": "git",