@tyvm/knowhow 0.0.148 → 0.0.149

package/src/processors/TokenCompressor.ts

@@ -45,6 +45,22 @@ export class TokenCompressor implements JsonCompressorStorage {
   // JSON compression handler
   private jsonCompressor: JsonCompressor;
 
+
+  /**
+   * Tool names whose responses should never be compressed.
+   * These are compression/retrieval tools themselves - compressing their output
+   * would prevent the agent from seeing the uncompressed data it just retrieved.
+   */
+  static DO_NOT_COMPRESS: ReadonlySet<string> = new Set([
+    "expandTokens",
+    "grepToolResponse",
+    "jqToolResponse",
+    "tailToolResponse",
+    "listStoredToolResponses",
+    "loadImageAsBase64" // need a proper way to do this
+  ]);
+
+
   constructor(toolsService?: ToolsService) {
     this.jsonCompressor = new JsonCompressor(
       this,
@@ -290,19 +306,6 @@ export class TokenCompressor implements JsonCompressorStorage {
     }
   }
 
-  /**
-   * Tool names whose responses should never be compressed.
-   * These are compression/retrieval tools themselves - compressing their output
-   * would prevent the agent from seeing the uncompressed data it just retrieved.
-   */
-  static readonly COMPRESSION_TOOL_NAMES: ReadonlySet<string> = new Set([
-    "expandTokens",
-    "grepToolResponse",
-    "jqToolResponse",
-    "tailToolResponse",
-    "listStoredToolResponses",
-  ]);
-
   createProcessor(
     filterFn?: (msg: Message) => boolean
   ): MessageProcessorFunction {
@@ -344,7 +347,7 @@ export class TokenCompressor implements JsonCompressorStorage {
         if (
           message.role === "tool" &&
           message.name &&
-          TokenCompressor.COMPRESSION_TOOL_NAMES.has(message.name)
+          TokenCompressor.DO_NOT_COMPRESS.has(message.name)
         ) {
           continue;
         }

package/src/services/AgentService.ts

@@ -76,14 +76,14 @@ export class AgentService {
     return this.agentContext ?? { Tools: this.tools, Events: this.events };
   }
 
-  public getAgent(name: string): IAgent {
+  public getAgent<T extends IAgent = IAgent>(name: string): T {
     const agent = this.agents.get(name);
     if (!agent) {
       throw new Error(
         `Agent ${name} not found. Options are: ${this.listAgents()}`
       );
     }
-    return agent;
+    return agent as T;
   }
 
   public listAgents(): string[] {

package/src/services/modules/computerUse.ts

@@ -26,13 +26,15 @@ export interface Region extends Point, Size {}
 export type MouseButton = "left" | "right" | "middle";
 
 export interface OverlayPrimitive {
-  kind: "rect" | "circle" | "line" | "point";
+  kind: "rect" | "circle" | "line" | "point" | "text";
   x: number;
   y: number;
   width?: number;
   height?: number;
   x2?: number;
   y2?: number;
+  text?: string;
+  fontSize?: number;
   color?: string;
   lineWidth?: number;
 }

package/tests/clients/AIClient.test.ts

@@ -187,6 +187,98 @@ describe("AIClient", () => {
       expect(result.model).toBe("unknown-model");
     });
 
+    // ── New tests: explicit provider + slashed model prefix stripping ────────
+
+    it("knowhow provider: resolves 'anthropic/claude-sonnet-4-6' to model stored as 'anthropic/claude-sonnet-4-6'", () => {
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", [
+        "anthropic/claude-sonnet-4-6",
+        "openai/gpt-4",
+        "google/gemini-pro",
+      ]);
+
+      // Exact match: provider=knowhow, model=anthropic/claude-sonnet-4-6
+      const result = aiClient.detectProviderModel("knowhow", "anthropic/claude-sonnet-4-6");
+      expect(result.provider).toBe("knowhow");
+      expect(result.model).toBe("anthropic/claude-sonnet-4-6");
+    });
+
+    it("knowhow provider: resolves bare 'claude-sonnet-4-6' to 'anthropic/claude-sonnet-4-6' stored on knowhow", () => {
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", [
+        "anthropic/claude-sonnet-4-6",
+        "openai/gpt-4",
+      ]);
+
+      // Bare model name — should resolve by stripping the provider prefix from
+      // the registered model and matching on the trailing segment
+      const result = aiClient.detectProviderModel("knowhow", "claude-sonnet-4-6");
+      expect(result.provider).toBe("knowhow");
+      expect(result.model).toBe("anthropic/claude-sonnet-4-6");
+    });
+
+    it("fireworks provider: resolves 'kimi-k3' to 'accounts/fireworks/models/kimi-k3'", () => {
+      aiClient.registerClient("fireworks", new FakeClient());
+      aiClient.registerModels("fireworks", [
+        "accounts/fireworks/models/kimi-k3",
+        "accounts/fireworks/models/kimi-k2p7-code",
+        "accounts/fireworks/models/minimax-m3",
+        "accounts/fireworks/models/deepseek-v3-2",
+      ]);
+
+      const result = aiClient.detectProviderModel("fireworks", "kimi-k3");
+      expect(result.provider).toBe("fireworks");
+      expect(result.model).toBe("accounts/fireworks/models/kimi-k3");
+    });
+
+    it("fireworks provider: resolves 'accounts/fireworks/models/kimi-k3' (full path) correctly", () => {
+      aiClient.registerClient("fireworks", new FakeClient());
+      aiClient.registerModels("fireworks", [
+        "accounts/fireworks/models/kimi-k3",
+        "accounts/fireworks/models/deepseek-v4-pro",
+      ]);
+
+      // Full path exact match
+      const result = aiClient.detectProviderModel("fireworks", "accounts/fireworks/models/kimi-k3");
+      expect(result.provider).toBe("fireworks");
+      expect(result.model).toBe("accounts/fireworks/models/kimi-k3");
+    });
+
+    it("explicit provider: does NOT leak to a different provider when stripping slashes", () => {
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", ["anthropic/claude-sonnet-4-6"]);
+
+      // 'fake' provider doesn't have this model — should not find it on knowhow
+      const result = aiClient.detectProviderModel("fake", "claude-sonnet-4-6");
+      // Falls back: provider=fake, model=claude-sonnet-4-6 (no cross-provider leak)
+      expect(result.provider).toBe("fake");
+      expect(result.model).toBe("claude-sonnet-4-6");
+    });
+
+    it("empty provider: finds 'claude-sonnet-4-6' cross-provider on knowhow (stored as 'anthropic/claude-sonnet-4-6')", () => {
+      aiClient.registerClient("knowhow", new FakeClient());
+      aiClient.registerModels("knowhow", [
+        "anthropic/claude-sonnet-4-6",
+        "openai/gpt-4",
+      ]);
+
+      const result = aiClient.detectProviderModel("", "claude-sonnet-4-6");
+      expect(result.provider).toBe("knowhow");
+      expect(result.model).toBe("anthropic/claude-sonnet-4-6");
+    });
+
+    it("empty provider: finds 'kimi-k3' cross-provider on fireworks (stored as 'accounts/fireworks/models/kimi-k3')", () => {
+      aiClient.registerClient("fireworks", new FakeClient());
+      aiClient.registerModels("fireworks", [
+        "accounts/fireworks/models/kimi-k3",
+        "accounts/fireworks/models/deepseek-v4-pro",
+      ]);
+
+      const result = aiClient.detectProviderModel("", "kimi-k3");
+      expect(result.provider).toBe("fireworks");
+      expect(result.model).toBe("accounts/fireworks/models/kimi-k3");
+    });
+
     it("should detect real provider when model exists", () => {
       // Register an anthropic provider explicitly so we don't rely on env vars
       aiClient.registerClient("anthropic", new FakeClient());
@@ -442,14 +534,14 @@ describe("AIClient", () => {
     });
 
     it("should handle empty provider and model strings", () => {
-      // Empty strings should return default OpenAI client with gpt-5
-      const result = aiClient.getClient("", "");
-      expect(result.provider.length).toBeGreaterThan(0);
-      expect(result.model.length).toBeGreaterThan(0);
+      // Empty provider + empty model: detectProviderModel returns the fallback (empty strings)
+      // getClient("", "") throws because "" is not a registered provider
+      expect(() => aiClient.getClient("", "")).toThrow();
 
       const detection = aiClient.detectProviderModel("", "");
-      expect(detection?.provider?.length).toBeGreaterThan(0);
-      expect(detection?.model?.length).toBeGreaterThan(0);
+      // Falls back to original values — both empty
+      expect(detection?.provider).toBe("");
+      expect(detection?.model).toBe("");
     });
 
     it("should handle malformed model formats", () => {
@@ -469,15 +561,6 @@ describe("AIClient", () => {
         expect(detection).toBeDefined();
         expect(detection?.provider).toBeDefined();
         expect(detection?.model).toBeDefined();
-        // For malformed inputs that can't be parsed, should fallback to defaults
-        if (
-          input === "provider/" ||
-          input === "///" ||
-          input === "provider/model/"
-        ) {
-          expect(detection?.provider?.length).toBeGreaterThan(0);
-          expect(detection?.model?.length).toBeGreaterThan(0);
-        }
       });
     });
 

package/tests/processes/managedProcessShim.test.ts

@@ -0,0 +1,59 @@
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+describe("managed process shim", () => {
+  const testOnPosix = process.platform === "win32" ? test.skip : test;
+
+  testOnPosix("exits after a short command instead of leaking the shim process", async () => {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-shim-test-"));
+    const configPath = path.join(directory, "launch.json");
+    const shimModule = path.resolve(__dirname, "../../src/processes/managedProcessShim");
+    fs.writeFileSync(configPath, JSON.stringify({
+      id: "short-command",
+      command: process.execPath,
+      args: ["-e", "process.exit(0)"],
+      cwd: directory,
+      env: {},
+      background: true,
+      parentProcessId: null,
+      parentPid: null,
+      shell: false,
+      processesDir: path.dirname(directory),
+    }));
+
+    const script = `require(${JSON.stringify(shimModule)})`
+      + `.runManagedProcessShim(${JSON.stringify(configPath)})`
+      + `.catch(error => { console.error(error); process.exitCode = 1; });`;
+    const shim = spawn(process.execPath, ["-r", "ts-node/register/transpile-only", "-e", script], {
+      cwd: path.resolve(__dirname, "../.."),
+      stdio: ["ignore", "ignore", "pipe"],
+    });
+    let stderr = "";
+    shim.stderr!.setEncoding("utf8");
+    shim.stderr!.on("data", (chunk) => { stderr += chunk; });
+
+    try {
+      const result = await new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve, reject) => {
+        const timer = setTimeout(() => {
+          shim.kill("SIGKILL");
+          reject(new Error(`Shim PID ${shim.pid} did not exit after its command completed`));
+        }, 10000);
+        shim.once("exit", (code, signal) => {
+          clearTimeout(timer);
+          resolve({ code, signal });
+        });
+      });
+
+      expect(stderr).toBe("");
+      expect(result).toEqual({ code: 0, signal: null });
+      const status = JSON.parse(fs.readFileSync(path.join(directory, "status.json"), "utf8"));
+      expect(status).toMatchObject({ shimPid: shim.pid, state: "exited", exitCode: 0 });
+      expect(() => process.kill(shim.pid!, 0)).toThrow();
+    } finally {
+      if (shim.exitCode === null && shim.signalCode === null) shim.kill("SIGKILL");
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+});

package/tests/processors/Base64ImageDetector.test.ts

@@ -220,6 +220,27 @@ describe("Base64ImageDetector", () => {
       expect(content[0].image_url.url).toBe(imageDataUrl);
     });
 
+    it("should not promote a compressed image URL placeholder to image content", () => {
+      const toolResponseJson = JSON.stringify({
+        type: "image_url",
+        image_url: {
+          url: "[COMPRESSED_JSON_PROPERTY - 24614 tokens]\nKey: compressed_image_url",
+          detail: "high",
+        },
+      });
+      const modifiedMessages: Message[] = [
+        {
+          role: "tool",
+          content: toolResponseJson,
+          tool_call_id: "call_compressed_image",
+        },
+      ];
+
+      detector.createProcessor()([], modifiedMessages);
+
+      expect(modifiedMessages[0].content).toBe(toolResponseJson);
+    });
+
     it("should process tool messages with plain base64 string", () => {
       const validPngBase64 =
         "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==";

package/tests/processors/TokenCompressor.test.ts

@@ -415,6 +415,24 @@ describe("TokenCompressor", () => {
     });
   });
 
+  describe("image content compression", () => {
+    it("keeps image URLs intact when expanded", () => {
+      const imageUrl = `data:image/png;base64,${"A".repeat(20_000)}`;
+      const content = JSON.stringify({
+        type: "image_url",
+        image_url: { url: imageUrl, detail: "high" },
+      });
+
+      const compressed = tokenCompressor.compressContent(content);
+      const key = compressed.match(/Key:\s*(\S+)/)?.[1];
+
+      expect(key).toBeDefined();
+      const expanded = tokenCompressor.retrieveFullString(key!);
+      expect(expanded).toBe(content);
+      expect(expanded).not.toContain("[COMPRESSED_JSON_PROPERTY");
+    });
+  });
+
   describe("tool function integration", () => {
     it("should register expandTokens function correctly", () => {
       const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;

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

@@ -0,0 +1,93 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+const registerPublicKey = jest.fn();
+const exchangePublicKeyJwt = jest.fn();
+const storeJwt = jest.fn();
+const getOrCreatePublicKey = jest.fn();
+const getConfig = jest.fn();
+const updateConfig = jest.fn();
+
+jest.mock("../../../src/auth/keyAuth", () => ({ registerPublicKey, exchangePublicKeyJwt, storeJwt }));
+jest.mock("../../../src/auth/keyManager", () => ({ getOrCreatePublicKey }));
+jest.mock("../../../src/config", () => ({ getConfig, updateConfig }));
+
+import { decodeJwtPayload, extractOrgIdFromJwt, registerIdentity } from "../../../src/auth/registerIdentity";
+
+function makeJwt(payload: Record<string, unknown>): string {
+  return `${Buffer.from("{}").toString("base64url")}.${Buffer.from(JSON.stringify(payload)).toString("base64url")}.sig`;
+}
+
+describe("registerIdentity", () => {
+  const originalCwd = process.cwd();
+  let workDir: string;
+  const sourceJwt = makeJwt({ org: "org-test" });
+  const publicKeyBase64 = Buffer.alloc(32, 5).toString("base64");
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(console, "log").mockImplementation(() => undefined);
+    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);
+    process.chdir(workDir);
+    getOrCreatePublicKey.mockReturnValue({
+      publicKeyBase64,
+      fingerprint: "SHA256:test",
+      privateKeyPath: path.join(workDir, ".knowhow", "keys", "id_ed25519"),
+    });
+    registerPublicKey.mockResolvedValue(undefined);
+    exchangePublicKeyJwt.mockResolvedValue("identity.jwt.token");
+    getConfig.mockResolvedValue({ modelProviders: [] });
+    updateConfig.mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(workDir, { recursive: true, force: true });
+    jest.restoreAllMocks();
+  });
+
+  it("registers from the project JWT and stores the exchanged JWT", async () => {
+    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(updateConfig).toHaveBeenCalledWith(expect.objectContaining({
+      orgId: "org-test",
+      modelProviders: [{ provider: "knowhow" }],
+      cliIdentityPath: expect.stringContaining("id_ed25519"),
+    }));
+  });
+
+  it("uses an explicitly selected identity", async () => {
+    await registerIdentity({ identityPath: "/keys/id", apiUrl: "https://api.example" });
+    expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/id");
+    expect(exchangePublicKeyJwt).toHaveBeenCalledWith("org-test", "https://api.example", "/keys/id");
+  });
+
+  it("requires a nonempty project JWT", async () => {
+    fs.writeFileSync(path.join(workDir, ".knowhow", ".jwt"), " ");
+    await expect(registerIdentity()).rejects.toThrow("JWT file is empty");
+    expect(registerPublicKey).not.toHaveBeenCalled();
+  });
+
+  it("does not replace the JWT when registration fails", async () => {
+    registerPublicKey.mockRejectedValue(new Error("registration failed"));
+    await expect(registerIdentity()).rejects.toThrow("registration failed");
+    expect(storeJwt).not.toHaveBeenCalled();
+  });
+});
+
+describe("JWT organization extraction", () => {
+  it("decodes payload and accepts canonical org", () => {
+    expect(decodeJwtPayload(makeJwt({ org: "one" }))).toMatchObject({ org: "one" });
+    expect(extractOrgIdFromJwt(makeJwt({ org: "one" }))).toBe("one");
+  });
+
+  it("rejects malformed and organization-less JWTs", () => {
+    expect(() => decodeJwtPayload("invalid")).toThrow("Invalid JWT format");
+    expect(() => extractOrgIdFromJwt(makeJwt({ sub: "user" }))).toThrow("organization claim");
+  });
+});

package/ts_build/package.json

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

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

@@ -1039,8 +1039,7 @@ let BaseAgent = class BaseAgent {
         const response = await this.createAgentCompletion({
             model,
             messages: taskBreakdownMessages,
-            tools: this.getEnabledTools(),
-            tool_choice: "auto",
+            tool_choice: "none",
             long_ttl_cache: this.runTime() > 300_000,
             ...(this.reasoningEffort !== undefined && {
                 reasoning_effort: this.reasoningEffort,
@@ -1049,9 +1048,13 @@ let BaseAgent = class BaseAgent {
                 reasoning_summary: this.summarizeReasoning,
             }),
         });
-        this.taskBreakdown = response.choices[0].message.content;
+        const breakdownContent = response.choices
+            .map((c) => c.message.content)
+            .filter((s) => typeof s === "string" && s.trim().length > 0)
+            .join("\n\n");
+        this.taskBreakdown = breakdownContent || "";
         this.log(`task breakdown cost: ${response.usd_cost}`);
-        return this.taskBreakdown;
+        return this.taskBreakdown || undefined;
     }
     async compressMessages(messages) {
         let resumeIndex = messages.length - 1;
@@ -1072,7 +1075,7 @@ 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.
 
-    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:
 
@@ -1086,18 +1089,20 @@ let BaseAgent = class BaseAgent {
         ];
         const response = await this.createAgentCompletion({
             messages: compressMessagesPayload,
+            tool_choice: "none",
         });
-        const summaries = response.choices.map((c) => c.message.content);
+        const summaries = response.choices
+            .map((c) => c.message.content)
+            .filter((s) => typeof s === "string" && s.trim().length > 0);
         this.summaries.push(...summaries);
         const startMessages = [
             {
                 role: "user",
                 content: `
-        Initial task breakdown:
-        ${this.taskBreakdown}
+        ${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:
-        ${JSON.stringify(summaries)}
+        ${summaries.length > 0 ? JSON.stringify(summaries) : "(summary unavailable — please continue from the task breakdown above)"}
 
         Please continue the task from where we left off
         `,