@tyvm/knowhow 0.0.154 → 0.0.155

package/src/services/watchers/RemoteSyncer.ts

@@ -16,7 +16,9 @@ export class WebSyncedAgentWatcher implements SyncedAgentWatcher {
   public taskId: string = "";
   private client: KnowhowSimpleClient;
   private pollInterval: NodeJS.Timeout | null = null;
+  private lastThreadIndex: number = -1;
   private lastThreadLength: number = 0;
+  private lastMessageJson: string | null = null;
   public agentName: string = "remote-agent";
   private stopped: boolean = false;
   public agentEvents = new EventService();
@@ -41,8 +43,10 @@ export class WebSyncedAgentWatcher implements SyncedAgentWatcher {
       const details = await this.client.getTaskDetails(taskId);
       const threads: any[][] = details?.data?.threads || [];
       const lastThread = threads[threads.length - 1] || [];
+      this.lastThreadIndex = threads.length - 1;
       this.agentName = "remote-agent";
       this.lastThreadLength = lastThread.length;
+      this.lastMessageJson = this.messageJson(lastThread[lastThread.length - 1]);
     } catch (err: any) {
       console.warn(
         `⚠️  Could not load initial state for task ${taskId}: ${err.message}`
@@ -68,8 +72,26 @@ export class WebSyncedAgentWatcher implements SyncedAgentWatcher {
       const details = await this.client.getTaskDetails(this.taskId);
       const threads: any[][] = details?.data?.threads || [];
       const lastThread = threads[threads.length - 1] || [];
+      const threadIndex = threads.length - 1;
+
+      let newMessages: any[];
+      if (
+        threadIndex === this.lastThreadIndex &&
+        lastThread.length >= this.lastThreadLength
+      ) {
+        newMessages = lastThread.slice(this.lastThreadLength);
+      } else {
+        const retainedIndex = this.findLastMessage(
+          lastThread,
+          this.lastMessageJson
+        );
+        newMessages = lastThread.slice(retainedIndex + 1);
+      }
+
+      this.lastThreadIndex = threadIndex;
+      this.lastThreadLength = lastThread.length;
+      this.lastMessageJson = this.messageJson(lastThread[lastThread.length - 1]);
 
-      const newMessages = lastThread.slice(this.lastThreadLength);
       if (newMessages.length > 0) {
         const renderEvents = messagesToRenderEvents(
           newMessages,
@@ -93,7 +115,6 @@ export class WebSyncedAgentWatcher implements SyncedAgentWatcher {
           }
         }
         this.agentEvents.emit(this.eventTypes.threadUpdate, lastThread);
-        this.lastThreadLength = lastThread.length;
       }
 
       // Stop polling and emit done if task is complete with a result
@@ -155,4 +176,21 @@ export class WebSyncedAgentWatcher implements SyncedAgentWatcher {
     await this.client.sendMessageToAgent(this.taskId, `/poke ${message || ""}`.trim());
     console.log(`🫵 Interrupt sent to remote web agent: ${this.taskId}`);
   }
+
+  private messageJson(message: any): string | null {
+    if (message == null) return null;
+    try {
+      return JSON.stringify(message);
+    } catch {
+      return null;
+    }
+  }
+
+  private findLastMessage(messages: any[], messageJson: string | null): number {
+    if (messageJson == null) return -1;
+    for (let index = messages.length - 1; index >= 0; index--) {
+      if (this.messageJson(messages[index]) === messageJson) return index;
+    }
+    return -1;
+  }
 }

package/src/tunnel.ts

@@ -10,10 +10,12 @@ import { WorkerPasskeyAuthService } from "./workers/auth/WorkerPasskeyAuth";
 import { WsMiddlewareStack } from "./workers/auth/WsMiddleware";
 import { makeAuthMiddleware } from "./workers/auth/authMiddleware";
 
+const PROD_TUNNEL_WORKER_DOMAIN = "worker.tyvm-apps.com";
+
 /**
- * Extract the tunnel domain and protocol from the API URL.
- * e.g., "https://api.knowhow.tyvm.ai" -> { domain: "worker.knowhow.tyvm.ai", useHttps: true }
- * e.g., "http://localhost:4000" -> { domain: "worker.localhost:4000", useHttps: false }
+ * Resolve the tunnel domain and protocol from the environment and API URL.
+ * TUNNEL_WORKER_DOMAIN takes precedence. Otherwise dev API URLs use the dev
+ * tunnel domain and all other API URLs use the production tunnel domain.
  */
 export function extractTunnelDomain(apiUrl: string): {
   domain: string;
@@ -22,18 +24,22 @@ export function extractTunnelDomain(apiUrl: string): {
   try {
     const url = new URL(apiUrl);
     const useHttps = url.protocol === "https:";
+    const configuredDomain = process.env.TUNNEL_WORKER_DOMAIN?.trim();
 
-    // For localhost, include port; for production, just use hostname
-    if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
-      return {
-        domain: `worker.${url.hostname}:${url.port || "80"}`,
-        useHttps,
-      };
-    }
-    return { domain: `worker.${url.hostname}`, useHttps };
+    const isDevApi = url.hostname.split(".").includes("dev");
+    const domain =
+      configuredDomain ||
+      (isDevApi ? `worker.dev.tyvm-apps.com` : PROD_TUNNEL_WORKER_DOMAIN);
+
+    return { domain, useHttps };
   } catch (err) {
     console.error("Failed to parse API_URL for tunnel domain:", err);
-    return { domain: "worker.localhost:4000", useHttps: false }; // fallback
+    return {
+      domain:
+        process.env.TUNNEL_WORKER_DOMAIN?.trim() ||
+        PROD_TUNNEL_WORKER_DOMAIN,
+      useHttps: false,
+    };
   }
 }
 

package/src/worker.ts

@@ -6,6 +6,7 @@ import { loadJwt } from "./login";
 import { services } from "./services";
 import { PasskeySetupService } from "./workers/auth/PasskeySetup";
 import { WorkerPasskeyAuthService } from "./workers/auth/WorkerPasskeyAuth";
+import { authenticateWithKey, hasKeyPair } from "./auth/keyAuth";
 import {
   makeUnlockTool,
   makeLockTool,
@@ -303,8 +304,8 @@ export async function worker(options?: {
   let connected = false;
   let tunnelHandler: TunnelHandler | null = null;
   let tunnelWs: WebSocket | null = null;
-  let lastJwt: string | null = null;
   let unauthorizedJwt: string | null = null;
+  let refreshAttemptedJwt: string | null = null;
 
   // ---------------------------------------------------------------------------
   // Liveness watchdog state
@@ -353,7 +354,6 @@ export async function worker(options?: {
   async function connectWebSocket() {
     const jwt = await loadJwt();
     console.log(`Connecting to ${API_URL}`);
-    lastJwt = jwt;
 
     // Reset the MCP server to avoid "Already connected to a transport" error on reconnects
     await mcpServer.reset();
@@ -476,11 +476,17 @@ export async function worker(options?: {
         },
         onClose: (code, _reason) => {
           if (code === 1008) {
-            unauthorizedJwt = lastJwt;
+            unauthorizedJwt = jwt;
+            // The worker and tunnel sockets share a JWT and must be renewed as
+            // one connection cycle. Ensure a later worker "open" event cannot
+            // leave us connected with a permanently closed tunnel.
+            if (ws.readyState !== WebSocket.CLOSED) {
+              ws.terminate();
+            }
             console.error(
               "❌ Tunnel received Unauthorized (1008). The JWT may be expired."
             );
-            console.error("   Pausing reconnection until JWT changes...");
+            console.error("   Attempting to refresh the JWT with the CLI identity...");
           } else {
             console.log(
               "Tunnel connection will reconnect on next connection cycle..."
@@ -532,14 +538,16 @@ export async function worker(options?: {
       // If we got an Unauthorized (1008) close, record the JWT that failed
       // so we don't keep hammering the server with the same expired token
       if (code === 1008) {
-        unauthorizedJwt = lastJwt;
+        unauthorizedJwt = jwt;
+        if (tunnelConnection?.readyState !== WebSocket.CLOSED) {
+          tunnelConnection?.terminate();
+        }
         console.error(
           "❌ Worker received Unauthorized (1008). The JWT may be expired."
         );
         console.error(
-          "   Run 'knowhow login' to refresh your token, then restart the worker."
+          "   Attempting to refresh the JWT with the CLI identity..."
         );
-        console.error("   Pausing reconnection until JWT changes...");
       } else {
         console.log("Attempting to reconnect...");
       }
@@ -566,17 +574,59 @@ export async function worker(options?: {
 
   while (true) {
     if (!connected) {
-      // If we got an Unauthorized error, check if the JWT has changed before retrying
+      // A registered CLI identity can renew an expired JWT without requiring an
+      // interactive login. Attempt this once per rejected token; if it fails,
+      // continue watching the JWT file so `knowhow login` in another shell works.
       if (unauthorizedJwt !== null) {
-        const currentJwt = await loadJwt().catch(() => null);
+        let currentJwt = await loadJwt().catch(() => null);
         if (currentJwt === unauthorizedJwt) {
-          // JWT hasn't changed - don't reconnect, just wait
-          await wait(5000);
-          continue;
+          let attemptedRefreshNow = false;
+          if (refreshAttemptedJwt !== currentJwt) {
+            refreshAttemptedJwt = currentJwt;
+            attemptedRefreshNow = true;
+            const freshConfig = await getConfig();
+            const identityPath = freshConfig.cliIdentityPath;
+            if (freshConfig.orgId && hasKeyPair(identityPath)) {
+              try {
+                const refreshed = await authenticateWithKey(
+                  freshConfig.orgId,
+                  API_URL,
+                  identityPath
+                );
+                if (refreshed) {
+                  currentJwt = await loadJwt();
+                  console.log("✅ JWT refreshed automatically; reconnecting...");
+                } else {
+                  console.error(
+                    "❌ CLI identity was rejected and could not refresh the JWT."
+                  );
+                }
+              } catch (error) {
+                const message =
+                  error instanceof Error ? error.message : String(error);
+                console.error(`❌ Automatic JWT refresh failed: ${message}`);
+              }
+            } else {
+              console.error(
+                "❌ No registered CLI identity is available for automatic JWT refresh."
+              );
+            }
+          }
+
+          if (currentJwt === unauthorizedJwt) {
+            if (attemptedRefreshNow) {
+              console.error(
+                "   Run 'knowhow login' in another shell; reconnection will resume when the JWT changes."
+              );
+            }
+            await wait(5000);
+            continue;
+          }
         }
         // JWT changed - clear the unauthorized state and reconnect
         console.log("🔄 JWT has changed, attempting to reconnect...");
         unauthorizedJwt = null;
+        refreshAttemptedJwt = null;
       }
 
       console.log("Attempting to connect...");

package/tests/clients/reasoningEffort.test.ts

@@ -45,6 +45,63 @@ describe("reasoning effort values", () => {
     expect(client.resolveReasoningEffortForModel(options("unknown", "max"))).toBe("xhigh");
   });
 
+  it("explicitly disables reasoning in Responses API requests", async () => {
+    const client = new GenericOpenAiClient("fake-key");
+    const create = jest.fn().mockResolvedValue({
+      id: "resp_disabled",
+      status: "completed",
+      output: [{ type: "message", content: [{ type: "output_text", text: "summary" }] }],
+      usage: { input_tokens: 1, output_tokens: 1 },
+    });
+    (client.client as any).responses.create = create;
+
+    await client.createChatResponse({
+      model: Models.openai.GPT_56_Sol,
+      messages: [{ role: "user", content: "summarize" }],
+      reasoning_effort: "none",
+    });
+
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({ reasoning: { effort: "none" } })
+    );
+  });
+
+  it("diagnoses empty Responses output but not valid tool-only output", async () => {
+    const client = new GenericOpenAiClient("fake-key");
+    const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+    const create = jest.fn()
+      .mockResolvedValueOnce({
+        id: "resp_empty",
+        status: "incomplete",
+        incomplete_details: { reason: "max_output_tokens" },
+        output: [{ type: "reasoning", summary: [] }],
+        usage: { input_tokens: 2, output_tokens: 3 },
+      })
+      .mockResolvedValueOnce({
+        id: "resp_tool",
+        status: "completed",
+        output: [{
+          type: "function_call", call_id: "call_1", name: "readFile", arguments: "{}",
+        }],
+        usage: { input_tokens: 2, output_tokens: 3 },
+      });
+    (client.client as any).responses.create = create;
+    const request = {
+      model: Models.openai.GPT_56_Sol,
+      messages: [{ role: "user" as const, content: "continue" }],
+    };
+
+    await client.createChatResponse(request);
+    expect(warn).toHaveBeenCalledWith(
+      "[Responses API] Response contained no text or tool calls",
+      expect.objectContaining({ responseId: "resp_empty", status: "incomplete" })
+    );
+    warn.mockClear();
+    await client.createChatResponse(request);
+    expect(warn).not.toHaveBeenCalled();
+    warn.mockRestore();
+  });
+
   it("maps all values to valid Gemini thinking levels and budgets", () => {
     const client = new GenericGeminiClient("fake-key");
     const levelModel = GoogleThinkingLevelModels.find(

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

@@ -14,6 +14,7 @@ jest.mock("../../../src/utils/http", () => ({
 }));
 
 jest.mock("../../../src/auth/keyManager", () => ({
+  getDefaultPrivateKeyPath: () => "/keys/default",
   keyPairExists,
   loadKeyPair,
   signMessage,
@@ -25,6 +26,7 @@ jest.mock("../../../src/auth/browserLogin", () => ({
 
 import {
   authenticateWithKey,
+  exchangeAvailablePublicKeyJwt,
   exchangePublicKeyJwt,
   hasKeyPair,
   registerPublicKey,
@@ -69,14 +71,41 @@ describe("keyAuth", () => {
     ]);
   });
 
+  it("uses the registered default identity when a configured identity is rejected", async () => {
+    post
+      .mockRejectedValueOnce({ status: 401 })
+      .mockResolvedValueOnce({
+        data: {
+          challengeId: "challenge_2",
+          message: "default key challenge",
+          expiresAt: "2099-01-01T00:00:00.000Z",
+        },
+        status: 201,
+      })
+      .mockResolvedValueOnce({ data: { jwt: "default-key-jwt" }, status: 200 });
+
+    await expect(
+      exchangeAvailablePublicKeyJwt("org-1", "https://work.example", "/keys/stale")
+    ).resolves.toBe("default-key-jwt");
+
+    expect(loadKeyPair.mock.calls).toEqual([
+      ["/keys/stale"],
+      ["/keys/default"],
+    ]);
+    expect(signMessage).toHaveBeenCalledWith(
+      "default key challenge",
+      "/keys/default"
+    );
+  });
+
   it("falls back when the key is unavailable without signing a challenge", async () => {
-    post.mockRejectedValueOnce({ status: 401 });
+    post.mockRejectedValue({ status: 401 });
 
     await expect(
       authenticateWithKey("org-1", "https://work.example", "/keys/work")
     ).resolves.toBe(false);
 
-    expect(post).toHaveBeenCalledTimes(1);
+    expect(post).toHaveBeenCalledTimes(2);
     expect(signMessage).not.toHaveBeenCalled();
   });
 

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

@@ -0,0 +1,84 @@
+import fs from "fs";
+
+const mockGet = jest.fn();
+const mockExchangePublicKeyJwt = jest.fn();
+const mockStoreJwt = jest.fn();
+
+jest.mock("../../../src/utils/http", () => {
+  const actual = jest.requireActual("../../../src/utils/http");
+  const mockedHttp = {
+    get: (...args: unknown[]) => mockGet(...args),
+  };
+  return {
+    __esModule: true,
+    ...actual,
+    http: mockedHttp,
+    default: mockedHttp,
+  };
+});
+
+jest.mock("../../../src/config", () => ({
+  getConfigSync: jest.fn().mockReturnValue({
+    orgId: "org-1",
+    cliIdentityPath: "/tmp/identity",
+  }),
+}));
+
+jest.mock("../../../src/auth/keyManager", () => ({
+  keyPairExists: jest.fn().mockReturnValue(true),
+}));
+
+jest.mock("../../../src/auth/keyAuth", () => ({
+  exchangeAvailablePublicKeyJwt: (...args: unknown[]) => mockExchangePublicKeyJwt(...args),
+  storeJwt: (...args: unknown[]) => mockStoreJwt(...args),
+}));
+
+import { KnowhowSimpleClient } from "../../../src/services/KnowhowClient";
+
+describe("KnowhowSimpleClient identity renewal", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+  });
+
+  it("obtains a JWT from the registered identity before loading models when no JWT exists", async () => {
+    jest.spyOn(fs, "existsSync").mockReturnValue(false);
+    mockExchangePublicKeyJwt.mockResolvedValue("fresh-jwt");
+    mockGet.mockResolvedValueOnce({ data: { data: [] } });
+
+    const client = new KnowhowSimpleClient("https://api.example.test");
+    await client.getModels();
+
+    expect(mockExchangePublicKeyJwt).toHaveBeenCalledWith(
+      "org-1",
+      "https://api.example.test",
+      "/tmp/identity"
+    );
+    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt");
+    expect(mockGet.mock.calls[0][1].headers.Authorization).toBe("Bearer fresh-jwt");
+  });
+
+  it("replaces an expired JWT with one signed by the registered identity before loading models", async () => {
+    const expiredJwt = [
+      Buffer.from('{"alg":"none"}').toString("base64url"),
+      Buffer.from('{"exp":0}').toString("base64url"),
+      "old-signature",
+    ].join(".");
+    jest.spyOn(fs, "existsSync").mockReturnValue(true);
+    jest.spyOn(fs, "readFileSync").mockReturnValue(expiredJwt);
+    mockExchangePublicKeyJwt.mockResolvedValue("fresh-jwt");
+    mockGet.mockResolvedValueOnce({ data: { data: [] } });
+
+    const client = new KnowhowSimpleClient("https://api.example.test");
+    await client.getModels();
+
+    expect(mockExchangePublicKeyJwt).toHaveBeenCalledWith(
+      "org-1",
+      "https://api.example.test",
+      "/tmp/identity"
+    );
+    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt");
+    expect(mockGet).toHaveBeenCalledTimes(1);
+    expect(mockGet.mock.calls[0][1].headers.Authorization).toBe("Bearer fresh-jwt");
+  });
+});

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

@@ -0,0 +1,89 @@
+import { FsSyncedAgentWatcher } from "../../../src/services/watchers/FsSyncer";
+import { WebSyncedAgentWatcher } from "../../../src/services/watchers/RemoteSyncer";
+
+const retained = { role: "assistant", content: "before compaction" };
+const oldThread = [
+  { role: "system", content: "instructions" },
+  { role: "user", content: "task" },
+  retained,
+];
+const compactedThread = [
+  { role: "system", content: "instructions" },
+  { role: "user", content: "compressed summary" },
+  retained,
+  { role: "assistant", content: "after compaction" },
+];
+
+function seedCursor(watcher: any): void {
+  watcher.taskId = "task-1";
+  watcher.agentName = "Developer";
+  watcher.lastThreadIndex = 0;
+  watcher.lastThreadLength = oldThread.length;
+  watcher.lastMessageJson = JSON.stringify(retained);
+}
+
+describe("synced agent watcher thread rollover", () => {
+  it("continues rendering after filesystem agent compaction", async () => {
+    const watcher: any = new FsSyncedAgentWatcher();
+    seedCursor(watcher);
+    watcher.readMetadata = jest.fn().mockResolvedValue({
+      threads: [oldThread, compactedThread],
+      status: "running",
+    });
+
+    const messages: string[] = [];
+    watcher.agentEvents.on(watcher.eventTypes.agentSay, (data: any) => {
+      messages.push(data.message);
+    });
+
+    await watcher.onMetadataChanged();
+
+    expect(messages).toEqual(["after compaction"]);
+    expect(watcher.lastThreadIndex).toBe(1);
+    expect(watcher.lastThreadLength).toBe(compactedThread.length);
+  });
+
+  it("continues rendering after web agent compaction", async () => {
+    const client = {
+      getTaskDetails: jest.fn().mockResolvedValue({
+        data: {
+          threads: [oldThread, compactedThread],
+          status: "running",
+        },
+      }),
+    };
+    const watcher: any = new WebSyncedAgentWatcher(client as any);
+    seedCursor(watcher);
+
+    const messages: string[] = [];
+    watcher.agentEvents.on(watcher.eventTypes.agentSay, (data: any) => {
+      messages.push(data.message);
+    });
+
+    await watcher.onPoll();
+
+    expect(messages).toEqual(["after compaction"]);
+    expect(watcher.lastThreadIndex).toBe(1);
+    expect(watcher.lastThreadLength).toBe(compactedThread.length);
+  });
+
+  it("resets a cursor when a thread shrinks without changing index", async () => {
+    const watcher: any = new FsSyncedAgentWatcher();
+    seedCursor(watcher);
+    watcher.lastThreadLength = 10;
+    watcher.readMetadata = jest.fn().mockResolvedValue({
+      threads: [compactedThread],
+      status: "running",
+    });
+
+    const messages: string[] = [];
+    watcher.agentEvents.on(watcher.eventTypes.agentSay, (data: any) => {
+      messages.push(data.message);
+    });
+
+    await watcher.onMetadataChanged();
+
+    expect(messages).toEqual(["after compaction"]);
+    expect(watcher.lastThreadLength).toBe(compactedThread.length);
+  });
+});

package/ts_build/package.json

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

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

@@ -191,6 +191,7 @@ export declare abstract class BaseAgent implements IAgent {
         role: string;
         content: string;
     } | null;
+    extractContentFromMessages(messages: Message[]): string;
     getTaskBreakdown(messages: Message[]): Promise<string>;
     compressMessages(messages: Message[]): Promise<Message[]>;
 }

package/ts_build/src/agents/base/base.js

@@ -1017,6 +1017,17 @@ let BaseAgent = class BaseAgent {
         }
         return null;
     }
+    extractContentFromMessages(messages) {
+        const content = messages
+            .filter((m) => typeof m.content === "string" && m.content.trim())
+            .map((m) => m.content);
+        const finalAnswer = messages
+            .filter((m) => m.tool_calls?.length)
+            .flatMap((t) => t.tool_calls)
+            .filter((t) => t.function.name === "finalAnswer")
+            .map((t) => t.function.arguments);
+        return [...content, ...finalAnswer].join("\n\n");
+    }
     async getTaskBreakdown(messages) {
         if (this.taskBreakdown) {
             return this.taskBreakdown;
@@ -1039,22 +1050,12 @@ let BaseAgent = class BaseAgent {
             },
         ];
         const response = await this.createAgentCompletion({
-            model,
             messages: taskBreakdownMessages,
             tool_choice: "none",
-            long_ttl_cache: this.runTime() > 300_000,
-            ...(this.reasoningEffort !== undefined && {
-                reasoning_effort: this.reasoningEffort,
-            }),
-            ...(this.summarizeReasoning !== undefined && {
-                reasoning_summary: this.summarizeReasoning,
-            }),
         });
-        const breakdownContent = response.choices
-            .map((c) => c.message.content)
-            .filter((s) => typeof s === "string" && s.trim().length > 0)
-            .join("\n\n");
+        const breakdownContent = this.extractContentFromMessages(response.choices?.map((c) => c.message));
         if (!breakdownContent) {
+            console.log(JSON.stringify(response.choices, null, 2));
             throw new Error("Compaction task-breakdown request returned no text content");
         }
         this.taskBreakdown = breakdownContent;
@@ -1063,8 +1064,7 @@ let BaseAgent = class BaseAgent {
     }
     async compressMessages(messages) {
         let resumeIndex = messages.length - 1;
-        while (resumeIndex >= 0 &&
-            messages[resumeIndex].role !== "assistant") {
+        while (resumeIndex >= 0 && messages[resumeIndex].role !== "assistant") {
             resumeIndex--;
         }
         const compressionEnd = resumeIndex === -1 ? messages.length : resumeIndex;
@@ -1080,7 +1080,9 @@ let BaseAgent = class BaseAgent {
     3. Next Steps - what we're about to do next to continue the user's original request.
     4. Tasks remaining - what tasks are left from the initial task breakdown.
 
-    ${this.taskBreakdown ? `Our initial task breakdown: ${this.taskBreakdown}` : ""}
+    ${this.taskBreakdown
+            ? `Our initial task breakdown: ${this.taskBreakdown}`
+            : ""}
 
     This summary will replace the older history. The latest agent interaction will remain verbatim:
 
@@ -1096,21 +1098,24 @@ let BaseAgent = class BaseAgent {
             messages: compressMessagesPayload,
             tool_choice: "none",
         });
-        const summaries = response.choices
-            .map((c) => c.message.content)
-            .filter((s) => typeof s === "string" && s.trim().length > 0);
-        if (summaries.length === 0) {
+        const summary = this.extractContentFromMessages(response.choices?.map((c) => c.message));
+        if (summary.length === 0) {
+            console.log(JSON.stringify(response.choices, null, 2));
             throw new Error("Compaction summary request returned no text content");
         }
-        this.summaries.push(...summaries);
+        this.summaries.push(summary);
         const startMessages = [
             {
                 role: "user",
                 content: `
-        ${this.taskBreakdown ? `Initial task breakdown:\n        ${this.taskBreakdown}` : "(No task breakdown available — summarize what you know from context above)"}
+        ${this.taskBreakdown
+                    ? `Initial task breakdown:\n        ${this.taskBreakdown}`
+                    : "(No task breakdown available — summarize what you know from context above)"}
 
         We have just compressed the conversation to save memory:
-        ${summaries.length > 0 ? JSON.stringify(summaries) : "(summary unavailable — please continue from the task breakdown above)"}
+        ${summary.length > 0
+                    ? JSON.stringify(summary)
+                    : "(summary unavailable — please continue from the task breakdown above)"}
 
         Please continue the task from where we left off
         `,