@tyvm/knowhow 0.0.153 → 0.0.155

package/tests/clients/reasoningEffort.test.ts

@@ -10,6 +10,7 @@ import {
 import {
   GoogleThinkingBudgetModels,
   GoogleThinkingLevelModels,
+  Models,
 } from "../../src/types";
 import { GenericXAIClient } from "../../src/clients/xai";
 
@@ -44,15 +45,75 @@ 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[0];
+    const levelModel = GoogleThinkingLevelModels.find(
+      (model) => model !== Models.google.Gemini_37_Flash
+    )!;
     const budgetModel = GoogleThinkingBudgetModels[0];
 
     expect(client.buildThinkingConfig(options(levelModel, "none"))).toEqual({ thinkingLevel: "minimal" });
     expect(client.buildThinkingConfig(options(levelModel, "minimal"))).toEqual({ thinkingLevel: "minimal" });
     expect(client.buildThinkingConfig(options(levelModel, "xhigh"))).toEqual({ thinkingLevel: "high" });
     expect(client.buildThinkingConfig(options(levelModel, "max"))).toEqual({ thinkingLevel: "high" });
+    expect(client.buildThinkingConfig(options(Models.google.Gemini_37_Flash, "minimal"))).toEqual({ thinkingLevel: "low" });
     expect(client.buildThinkingConfig(options(budgetModel, "none"))).toEqual({ thinkingBudget: 0 });
     expect(client.buildThinkingConfig(options(budgetModel, "minimal"))).toEqual({ thinkingBudget: 512 });
     expect(client.buildThinkingConfig(options(budgetModel, "medium"))).toEqual({ thinkingBudget: 8192 });

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.153",
+    "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

@@ -187,10 +187,11 @@ export declare abstract class BaseAgent implements IAgent {
     stopObserving(id?: string, reason?: string): string;
     getMessagesLength(messages: Message[]): number;
     getContextTokenCount(messages: Message[]): number;
-    detectTruncatedToolCalls(toolCalls: ToolCall[], response: CompletionResponse): {
+    detectTruncatedToolCalls(toolCalls: ToolCall[], response: CompletionResponse, allToolCalls?: ToolCall[]): {
         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

@@ -691,6 +691,7 @@ let BaseAgent = class BaseAgent {
                 }
             }
             this.log("agent response cost: " + response?.usd_cost);
+            const allResponseToolCalls = response.choices.flatMap((c) => c.message.tool_calls ?? []);
             for (const choice of response.choices) {
                 messages.push(choice.message);
                 messages = await this.messageProcessor.processMessages(messages, "post_call");
@@ -700,7 +701,7 @@ let BaseAgent = class BaseAgent {
                     messages = await this.messageProcessor.processMessages(messages, "pre_tools");
                     const toolCalls = messages[messages.length - 1].tool_calls;
                     this.updateCurrentThread(messages);
-                    const truncationWarning = this.detectTruncatedToolCalls(toolCalls, response);
+                    const truncationWarning = this.detectTruncatedToolCalls(toolCalls, response, allResponseToolCalls);
                     if (truncationWarning) {
                         messages.push(truncationWarning);
                         this.updateCurrentThread(messages);
@@ -984,12 +985,13 @@ let BaseAgent = class BaseAgent {
         }
         return this.getMessagesLength(messages);
     }
-    detectTruncatedToolCalls(toolCalls, response) {
+    detectTruncatedToolCalls(toolCalls, response, allToolCalls) {
         const rawOutputTokens = response?.usage?.completion_tokens || 0;
         const thinkingTokens = (response?.usage?.output_tokens_details?.thinking_tokens ?? 0) +
             (response?.usage?.output_tokens_details?.reasoning_tokens ?? 0);
         const outputTokens = Math.max(0, rawOutputTokens - thinkingTokens);
-        const totalArgLength = toolCalls.reduce((sum, tc) => sum + (tc.function?.arguments?.length || 0), 0);
+        const callsForSizeCheck = allToolCalls ?? toolCalls;
+        const totalArgLength = callsForSizeCheck.reduce((sum, tc) => sum + (tc.function?.arguments?.length || 0), 0);
         const expectedArgChars = outputTokens * 4;
         const suspiciouslySmallArgs = outputTokens > 1000 && totalArgLength < expectedArgChars * 0.1;
         for (const toolCall of toolCalls) {
@@ -1015,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;
@@ -1037,29 +1050,21 @@ 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");
-        this.taskBreakdown = breakdownContent || "";
+        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;
         this.log(`task breakdown cost: ${response.usd_cost}`);
-        return this.taskBreakdown || undefined;
+        return this.taskBreakdown;
     }
     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;
@@ -1075,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:
 
@@ -1091,18 +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);
-        this.summaries.push(...summaries);
+        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(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
         `,