@tyvm/knowhow 0.0.157 → 0.0.158

package/src/services/Mcp.ts

@@ -1,11 +1,14 @@
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import Anthropic from "@anthropic-ai/sdk";
+import { spawn } from "child_process";
 
 import fs from "fs";
+import path from "path";
 import { McpConfig } from "../types";
 import { Tool } from "../clients";
 import { getConfig } from "../config";
+import { loadJwtFromDisk } from "../auth/jwtStore";
 import { TraceAll } from "../util/Trace";
 import { ToolsService } from "./Tools";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
@@ -30,6 +33,84 @@ export const knowhowConfig = {
 export * from "./McpServer";
 export * from "./McpWebsocketTransport";
 
+/*
+ * Returns true if the given URL string points to localhost / 127.x / ::1.
+ */
+function isLocalhostUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname;
+    return (
+      host === "localhost" ||
+      host === "127.0.0.1" ||
+      host === "::1" ||
+      /^127\./.test(host)
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a URL is reachable by making a simple HTTP GET/HEAD request.
+ * Resolves true if we get any HTTP response (even 4xx), false on network error.
+ */
+async function isUrlReachable(url: string, timeoutMs = 2000): Promise<boolean> {
+  return new Promise((resolve) => {
+    const parsed = new URL(url);
+    const lib = parsed.protocol === "https:" ? require("https") : require("http");
+    const req = lib.request(
+      { hostname: parsed.hostname, port: parsed.port || (parsed.protocol === "https:" ? 443 : 80), path: parsed.pathname || "/", method: "GET", timeout: timeoutMs },
+      () => { resolve(true); req.destroy(); }
+    );
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => { req.destroy(); resolve(false); });
+    req.end();
+  });
+}
+
+/**
+ * If an MCP config has both a localhost `url` and a `command`, this function
+ * ensures the server is running: checks reachability, and if not up, spawns
+ * the command and waits until the URL is reachable (or timeout expires).
+ */
+async function ensureLocalServer(mcp: McpConfig): Promise<void> {
+  if (!mcp.url || !mcp.command || !isLocalhostUrl(mcp.url)) return;
+
+  const alreadyUp = await isUrlReachable(mcp.url);
+  if (alreadyUp) {
+    console.log(`MCP '${mcp.name}': server already running at ${mcp.url}`);
+    return;
+  }
+
+  console.log(`MCP '${mcp.name}': starting server with command: ${mcp.command} ${(mcp.args || []).join(" ")}`);
+
+  const child = spawn(mcp.command, mcp.args || [], {
+    detached: true,
+    stdio: "ignore",
+    env: mcp.env ? { ...process.env, ...mcp.env } : process.env,
+  });
+  child.unref(); // don't keep the knowhow process alive just for this child
+
+  // Wait up to 30s for the server to become reachable
+  const maxWait = 30_000;
+  const interval = 500;
+  const started = Date.now();
+
+  while (Date.now() - started < maxWait) {
+    await new Promise((r) => setTimeout(r, interval));
+    const up = await isUrlReachable(mcp.url!);
+    if (up) {
+      console.log(`MCP '${mcp.name}': server is up at ${mcp.url}`);
+      return;
+    }
+  }
+
+  throw new Error(
+    `MCP '${mcp.name}': timed out waiting for server to start at ${mcp.url} (command: ${mcp.command} ${(mcp.args || []).join(" ")})`
+  );
+}
+
 /*
  *
  * McpService is a service that manages connections to multiple MCP servers.
@@ -53,7 +134,7 @@ export class McpService {
     }
 
     this.config = mcpServers;
-    this.transports = mcpServers.map((mcp) => this.createTransport(mcp));
+    this.transports = await Promise.all(mcpServers.map((mcp) => this.createTransport(mcp)));
     this.clients = this.transports.map(() => new Client(knowhowMcpClient, knowhowConfig));
 
     return this.clients;
@@ -64,8 +145,9 @@ export class McpService {
    * Re-reads authorization_token_file every time so that token refreshes
    * are picked up without restarting the agent process.
    */
-  createTransport(mcp: McpConfig): Transport {
-    if (mcp.command) {
+  async createTransport(mcp: McpConfig): Promise<Transport> {
+    await ensureLocalServer(mcp);
+    if (mcp.command && !mcp.url) {
       const stdioParams: StdioServerParameters = {
         command: mcp.command,
         args: mcp.args,
@@ -79,8 +161,13 @@ export class McpService {
     if (mcp.url) {
       // Always re-read the token file so refreshed tokens are picked up
       if (mcp.authorization_token_file) {
-        const token = fs.readFileSync(mcp.authorization_token_file, "utf-8");
-        mcp.authorization_token = token.trim();
+        if (path.basename(mcp.authorization_token_file) === ".jwt") {
+          const apiUrl = process.env.KNOWHOW_API_URL || "https://api.knowhow.tyvm.ai";
+          mcp.authorization_token = loadJwtFromDisk(apiUrl, mcp.authorization_token_file);
+        } else {
+          const token = fs.readFileSync(mcp.authorization_token_file, "utf-8");
+          mcp.authorization_token = token.trim();
+        }
       }
       const scheme = mcp.authorization_scheme === "basic" ? "Basic" : "Bearer";
       const transport = new StreamableHTTPClientTransport(new URL(mcp.url), {
@@ -216,7 +303,7 @@ export class McpService {
       // Always create a fresh transport + client before connecting.
       // This handles cases where a previous connection attempt failed and left
       // the transport in a started-but-not-connected state.
-      this.transports[index] = this.createTransport(this.config[index]);
+      this.transports[index] = await this.createTransport(this.config[index]);
       this.clients[index] = new Client(knowhowMcpClient, knowhowConfig);
 
       const client = this.clients[index];
@@ -315,7 +402,7 @@ export class McpService {
       // Replace with a fresh transport + client so connectSingle() can reconnect
       // without hitting "StreamableHTTPClientTransport already started".
       // createTransport() re-reads authorization_token_file, picking up refreshed tokens.
-      this.transports[index] = this.createTransport(this.config[index]);
+      this.transports[index] = await this.createTransport(this.config[index]);
       this.clients[index] = new Client(knowhowMcpClient, knowhowConfig);
 
       // Remove tools from cache

package/src/services/McpWebsocketTransport.ts

@@ -1,4 +1,3 @@
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import {
   JSONRPCMessage,
   JSONRPCMessageSchema,
@@ -9,6 +8,7 @@ import { WebSocket } from "ws";
 export class MCPWebSocketTransport implements Transport {
   protected _socket: WebSocket;
   onmessage?: (message: JSONRPCMessage) => void;
+  onrawmessage?: (message: unknown) => boolean | Promise<boolean>;
   onerror?: (error: Error) => void;
   onclose?: () => void;
 
@@ -27,15 +27,19 @@ export class MCPWebSocketTransport implements Transport {
         } else {
           parsed = JSON.parse(data.toString());
         }
-        console.log("MCPW Message received", JSON.stringify(parsed));
-        const message = JSONRPCMessageSchema.parse(parsed);
-        // Process message asynchronously to avoid blocking the WebSocket
-        // event loop while a long-running tool call is in progress.
-        // Without this, all subsequent messages are queued until the
-        // current tool call completes.
-        setImmediate(() => {
-          this.onmessage?.(message);
-        });
+        Promise.resolve(this.onrawmessage?.(parsed) ?? false)
+          .then((consumed) => {
+            if (consumed) return;
+            const message = JSONRPCMessageSchema.parse(parsed);
+            // Process message asynchronously to avoid blocking the WebSocket
+            // event loop while a long-running tool call is in progress.
+            // Without this, all subsequent messages are queued until the
+            // current tool call completes.
+            setImmediate(() => {
+              this.onmessage?.(message);
+            });
+          })
+          .catch((error) => this.onerror?.(error as Error));
       } catch (error) {
         this.onerror?.(error as Error);
       }
@@ -53,7 +57,6 @@ export class MCPWebSocketTransport implements Transport {
   async send(message: JSONRPCMessage): Promise<void> {
     return new Promise((resolve, reject) => {
       const json = JSON.stringify(message);
-      console.log("MCPWs sending", json);
 
       if (this._socket.readyState !== WebSocket.OPEN) {
         return reject(

package/src/types.ts

@@ -70,11 +70,23 @@ export type EmbedSource = {
   minLength?: number;
 };
 
+export type KnowhowRemote = {
+  name: string;
+  apiUrl: string;
+  jwtPath: string;
+  orgId?: string;
+};
+
 export type Config = {
   openaiBaseUrl?: string;
   promptsDir: string;
   lintCommands?: { [fileExtension: string]: string };
+  /** Legacy organization field; migrated into the selected remote on login. */
   orgId?: string;
+  /** Legacy environment map retained for reading pre-remote configurations. */
+  orgIds?: Record<string, string>;
+  remotes?: Record<string, KnowhowRemote>;
+  activeRemote?: string;
   /** Private Ed25519 identity selected with `knowhow login --identity`. */
   cliIdentityPath?: string;
   syncRemote?: boolean;

package/tests/unit/McpWebsocketTransport.test.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from "events";
+import { WebSocket } from "ws";
+import { MCPWebSocketTransport } from "../../src/services/McpWebsocketTransport";
+
+class TestSocket extends EventEmitter {
+  readyState = WebSocket.OPEN;
+  // Simulate send() calling the callback immediately (required by MCPWebSocketTransport.send())
+  send = jest.fn((data: string, cb?: (err?: Error) => void) => { cb?.(); });
+  close = jest.fn();
+}
+
+const flush = () => new Promise<void>((resolve) => setImmediate(resolve));
+
+describe("MCPWebSocketTransport", () => {
+  it("delivers valid JSON-RPC frames to onmessage", async () => {
+    const socket = new TestSocket();
+    const transport = new MCPWebSocketTransport(socket as unknown as WebSocket);
+    const response = { jsonrpc: "2.0", id: 1, result: {} };
+    transport.onmessage = jest.fn();
+    transport.onerror = jest.fn();
+
+    await transport.start();
+    socket.emit("message", JSON.stringify(response));
+    await flush();
+    await flush();
+
+    expect(transport.onmessage).toHaveBeenCalledWith(response);
+    expect(transport.onerror).not.toHaveBeenCalled();
+  });
+
+  it("calls onerror for invalid JSON-RPC frames", async () => {
+    const socket = new TestSocket();
+    const transport = new MCPWebSocketTransport(socket as unknown as WebSocket);
+    const invalid = { notJsonRpc: true };
+    transport.onmessage = jest.fn();
+    transport.onerror = jest.fn();
+
+    await transport.start();
+    socket.emit("message", JSON.stringify(invalid));
+    await flush();
+
+    expect(transport.onmessage).not.toHaveBeenCalled();
+    expect(transport.onerror).toHaveBeenCalled();
+  });
+
+  it("sends serialized JSON over the socket", async () => {
+    const socket = new TestSocket();
+    const transport = new MCPWebSocketTransport(socket as unknown as WebSocket);
+    await transport.start();
+
+    const msg = { jsonrpc: "2.0" as const, method: "ping", id: 42 };
+    await transport.send(msg);
+
+    expect(socket.send).toHaveBeenCalledWith(JSON.stringify(msg), expect.any(Function));
+  });
+});

package/tests/unit/auth/jwtStore.test.ts

@@ -0,0 +1,55 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import {
+  getJwtFileName,
+  loadJwtFromDisk,
+  storeJwtForApi,
+} from "../../../src/auth/jwtStore";
+
+describe("environment-specific JWT storage", () => {
+  const originalCwd = process.cwd();
+  let workDir: string;
+
+  beforeEach(() => {
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-jwt-store-"));
+    process.chdir(workDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(workDir, { recursive: true, force: true });
+  });
+
+  it("uses readable names for production, development, and local APIs", () => {
+    expect(getJwtFileName("https://api.knowhow.tyvm.ai")).toBe(".jwt");
+    expect(getJwtFileName("https://api.dev.knowhow.tyvm.ai")).toBe(".jwt.dev");
+    expect(getJwtFileName("http://localhost:4000")).toBe(".jwt.local");
+  });
+
+  it("keeps tokens for each API environment independent", () => {
+    storeJwtForApi("prod-token", "https://api.knowhow.tyvm.ai");
+    storeJwtForApi("dev-token", "https://api.dev.knowhow.tyvm.ai");
+    storeJwtForApi("local-token", "http://localhost:4000");
+
+    expect(loadJwtFromDisk("https://api.knowhow.tyvm.ai")).toBe("prod-token");
+    expect(loadJwtFromDisk("https://api.dev.knowhow.tyvm.ai")).toBe("dev-token");
+    expect(loadJwtFromDisk("http://localhost:4000")).toBe("local-token");
+    expect(fs.statSync(path.join(workDir, ".knowhow", ".jwt.dev")).mode & 0o777).toBe(0o600);
+  });
+
+  it("does not send the legacy production token to another environment", () => {
+    const configDir = path.join(workDir, ".knowhow");
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(path.join(configDir, ".jwt"), "production-token");
+
+    expect(loadJwtFromDisk("https://api.dev.knowhow.tyvm.ai")).toBe("");
+    expect(loadJwtFromDisk("https://api.knowhow.tyvm.ai")).toBe("production-token");
+  });
+
+  it("uses a host-specific file for additional Knowhow instances", () => {
+    expect(getJwtFileName("https://api.staging.example.com:8443")).toBe(
+      ".jwt.api.staging.example.com-8443"
+    );
+  });
+});

package/tests/unit/auth/registerIdentity.test.ts

@@ -31,6 +31,7 @@ describe("registerIdentity", () => {
     workDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-register-identity-"));
     fs.mkdirSync(path.join(workDir, ".knowhow"), { recursive: true });
     fs.writeFileSync(path.join(workDir, ".knowhow", ".jwt"), sourceJwt);
+    fs.writeFileSync(path.join(workDir, ".knowhow", ".jwt.api.example"), sourceJwt);
     process.chdir(workDir);
     getOrCreatePublicKey.mockReturnValue({
       publicKeyBase64,
@@ -53,11 +54,16 @@ describe("registerIdentity", () => {
     await registerIdentity({ apiUrl: "https://api.example" });
     expect(registerPublicKey).toHaveBeenCalledWith(sourceJwt, publicKeyBase64, "https://api.example");
     expect(exchangePublicKeyJwt).toHaveBeenCalledWith("org-test", "https://api.example", undefined);
-    expect(storeJwt).toHaveBeenCalledWith("identity.jwt.token");
+    expect(storeJwt).toHaveBeenCalledWith("identity.jwt.token", "https://api.example");
     expect(updateConfig).toHaveBeenCalledWith(expect.objectContaining({
-      orgId: "org-test",
       modelProviders: [{ provider: "knowhow" }],
       cliIdentityPath: expect.stringContaining("id_ed25519"),
+      remotes: {
+        origin: expect.objectContaining({
+          apiUrl: "https://api.example",
+          orgId: "org-test",
+        }),
+      },
     }));
   });
 

package/tests/unit/commands/remote.test.ts

@@ -0,0 +1,79 @@
+import { Command } from "commander";
+
+const getConfig = jest.fn();
+const updateConfig = jest.fn();
+
+jest.mock("../../../src/config", () => ({ getConfig, updateConfig }));
+
+import { addRemoteCommand } from "../../../src/commands/remote";
+
+describe("remote command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(console, "log").mockImplementation(() => undefined);
+    program = new Command();
+    program.exitOverride();
+    addRemoteCommand(program);
+  });
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it("adds a named remote with an independent JWT path", async () => {
+    const config: any = {
+      orgIds: {
+        "http://localhost:4000": "org-local",
+      },
+    };
+    getConfig.mockResolvedValue(config);
+
+    await program.parseAsync([
+      "node",
+      "knowhow",
+      "remote",
+      "add",
+      "dev",
+      "https://api.dev.knowhow.tyvm.ai/",
+    ]);
+
+    expect(updateConfig).toHaveBeenCalledWith(config);
+    expect(config.remotes.dev).toEqual({
+      name: "dev",
+      apiUrl: "https://api.dev.knowhow.tyvm.ai",
+      jwtPath: ".knowhow/.jwt.dev",
+    });
+    expect(config.orgIds).toBeUndefined();
+    expect(config.remotes.local).toEqual({
+      name: "local",
+      apiUrl: "http://localhost:4000",
+      jwtPath: ".knowhow/.jwt.local",
+      orgId: "org-local",
+    });
+  });
+
+  it("selects a configured remote for subsequent commands", async () => {
+    const config: any = {
+      remotes: {
+        local: {
+          name: "local",
+          apiUrl: "http://localhost:4000",
+          jwtPath: ".knowhow/.jwt.local",
+          orgId: "org-local",
+        },
+      },
+    };
+    getConfig.mockResolvedValue(config);
+
+    await program.parseAsync([
+      "node",
+      "knowhow",
+      "remote",
+      "use",
+      "local",
+    ]);
+
+    expect(config.activeRemote).toBe("local");
+    expect(updateConfig).toHaveBeenCalledWith(config);
+  });
+});

package/tests/unit/login.test.ts

@@ -48,7 +48,7 @@ describe("login public-key bootstrap", () => {
     jest.spyOn(console, "warn").mockImplementation(() => undefined);
     workingDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-login-"));
     fs.mkdirSync(path.join(workingDirectory, ".knowhow"));
-    fs.writeFileSync(path.join(workingDirectory, ".knowhow", ".jwt"), "raw-jwt");
+    fs.writeFileSync(path.join(workingDirectory, ".knowhow", ".jwt.api.example"), "raw-jwt");
     process.chdir(workingDirectory);
     hasKeyPair.mockReturnValue(false);
     browserLogin.mockResolvedValue(undefined);
@@ -87,7 +87,42 @@ describe("login public-key bootstrap", () => {
       "https://api.example"
     );
     expect(updateConfig).toHaveBeenCalledWith(
-      expect.objectContaining({ orgId: "org-1", modelProviders: [{ provider: "knowhow" }] })
+      expect.objectContaining({
+        activeRemote: "api.example",
+        modelProviders: [{ provider: "knowhow" }],
+        remotes: expect.objectContaining({
+          "api.example": {
+            name: "api.example",
+            apiUrl: "https://api.example",
+            jwtPath: ".knowhow/.jwt.api.example",
+            orgId: "org-1",
+          },
+        }),
+      })
+    );
+  });
+
+  it("persists an explicit --api-url as the authenticated remote", async () => {
+    fs.writeFileSync(path.join(workingDirectory, ".knowhow", ".jwt.local"), "local-jwt");
+
+    await login(false, undefined, "http://localhost:4000/", "local");
+
+    expect(updateConfig).toHaveBeenCalledWith(
+      expect.objectContaining({
+        activeRemote: "local",
+        remotes: expect.objectContaining({
+          local: {
+            name: "local",
+            apiUrl: "http://localhost:4000",
+            jwtPath: ".knowhow/.jwt.local",
+            orgId: "org-1",
+          },
+        }),
+      })
+    );
+    expect(httpGet).toHaveBeenCalledWith(
+      "http://localhost:4000/api/users/me",
+      expect.any(Object)
     );
   });
 
@@ -119,9 +154,9 @@ describe("login public-key bootstrap", () => {
     expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/default");
     expect(updateConfig).toHaveBeenCalledWith(
       expect.objectContaining({
-        orgId: "org-1",
         cliIdentityPath: "/keys/default",
         modelProviders: [{ provider: "knowhow" }],
+        remotes: expect.objectContaining({ "api.example": expect.objectContaining({ orgId: "org-1" }) }),
       })
     );
   });
@@ -143,6 +178,32 @@ describe("login public-key bootstrap", () => {
     expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/dev");
   });
 
+  it("uses the selected API's JWT org instead of an org saved by another environment", async () => {
+    const devJwt = `${Buffer.from("{}").toString("base64url")}.${Buffer.from(
+      JSON.stringify({ org: "org-dev" })
+    ).toString("base64url")}.signature`;
+    fs.writeFileSync(
+      path.join(workingDirectory, ".knowhow", ".jwt.api.example"),
+      devJwt
+    );
+    hasKeyPair.mockReturnValue(true);
+    getConfig.mockResolvedValue({
+      orgId: "org-local",
+      orgIds: { "http://localhost:4000": "org-local" },
+      modelProviders: [],
+    });
+    authenticateWithKey.mockResolvedValueOnce(true);
+
+    await expect(login(false, "/keys/default")).resolves.toBeUndefined();
+
+    expect(authenticateWithKey).toHaveBeenCalledWith(
+      "org-dev",
+      "https://api.example",
+      "/keys/default"
+    );
+    expect(browserLogin).not.toHaveBeenCalled();
+  });
+
   it("does not attempt key authentication without a configured organization", async () => {
     hasKeyPair.mockReturnValue(true);
     getConfig.mockResolvedValue({ modelProviders: [] });

package/tests/unit/services/KnowhowClient.test.ts

@@ -54,7 +54,7 @@ describe("KnowhowSimpleClient identity renewal", () => {
       "https://api.example.test",
       "/tmp/identity"
     );
-    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt");
+    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt", "https://api.example.test");
     expect(mockGet.mock.calls[0][1].headers.Authorization).toBe("Bearer fresh-jwt");
   });
 
@@ -77,7 +77,7 @@ describe("KnowhowSimpleClient identity renewal", () => {
       "https://api.example.test",
       "/tmp/identity"
     );
-    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt");
+    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt", "https://api.example.test");
     expect(mockGet).toHaveBeenCalledTimes(1);
     expect(mockGet.mock.calls[0][1].headers.Authorization).toBe("Bearer fresh-jwt");
   });

package/tests/unit/services/Mcp.test.ts

@@ -33,11 +33,11 @@ describe("McpService JWT file transport", () => {
     fs.rmSync(temporaryDirectory, { recursive: true, force: true });
   });
 
-  it("reads the refreshed JWT when the transport is created", () => {
+  it("reads the refreshed JWT when the transport is created", async () => {
     fs.writeFileSync(tokenFile, "expired-jwt");
     fs.writeFileSync(tokenFile, "fresh-jwt");
 
-    new McpService().createTransport({
+    await new McpService().createTransport({
       name: "authenticated-remote",
       url: "https://api.example.test/mcp",
       authorization_token_file: tokenFile,

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.157",
+    "version": "0.0.158",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {

package/ts_build/src/agents/base/base.d.ts

@@ -70,6 +70,9 @@ export declare abstract class BaseAgent implements IAgent {
     protected compressThreshold: number;
     protected compressMinMessages: number;
     protected _forceCompact: boolean;
+    private _compactionPromise;
+    private _completedCompaction;
+    private _compactionGeneration;
     private _interruptResolve;
     private _interruptToken;
     protected threads: Message[][];
@@ -147,7 +150,7 @@ export declare abstract class BaseAgent implements IAgent {
     getTurnCount(): number;
     adjustTotalCostUsd(cost: number): void;
     getTotalCostUsd(): number;
-    adjustTokenUsage(usage: any, messages?: Message[]): void;
+    adjustTokenUsage(usage: any, messages?: Message[], updateLastPromptTokens?: boolean): void;
     getTokenUsage(): {
         totalInputTokens: number;
         totalOutputTokens: number;
@@ -156,6 +159,7 @@ export declare abstract class BaseAgent implements IAgent {
     };
     protected createAgentCompletion(params: CachedChatCompletion, options?: {
         interruptValue?: CompletionResponse;
+        updateLastPromptTokens?: boolean;
     }): Promise<CompletionResponse>;
     startNewThread(messages: Message[]): void;
     updateCurrentThread(messages: Message[]): void;
@@ -192,6 +196,7 @@ export declare abstract class BaseAgent implements IAgent {
         content: string;
     } | null;
     extractContentFromMessages(messages: Message[]): string;
-    getTaskBreakdown(messages: Message[]): Promise<string>;
-    compressMessages(messages: Message[]): Promise<Message[]>;
+    private startBackgroundCompaction;
+    getTaskBreakdown(messages: Message[], cacheResult?: boolean): Promise<string>;
+    compressMessages(messages: Message[], onSummary?: (summary: string) => void, taskBreakdown?: string): Promise<Message[]>;
 }