@tyvm/knowhow 0.0.106 → 0.0.107

package/package.json

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

package/src/agents/base/base.ts

@@ -293,6 +293,33 @@ export abstract class BaseAgent implements IAgent {
     this.easyFinalAnswer = value;
   }
 
+  /**
+   * Detect if the model's response is a termination signal (e.g. "Done", "Complete", "Finished", "finalAnswer")
+   * This handles the case where an agent refuses to call finalAnswer and just says a short termination word.
+   */
+  protected isTerminationResponse(content: string): boolean {
+    const trimmed = content.trim();
+    // Short response (≤ 3 words) that matches a termination word/phrase exactly
+    const wordCount = trimmed.split(/\s+/).filter(Boolean).length;
+    if (wordCount <= 3) {
+      const terminationPattern = /^(done|complete|completed|finished|final\s*answer|task\s*complete|all\s*done|that'?s\s*(all|it)|ok(ay)?|yes)[.!]*$/i;
+      if (terminationPattern.test(trimmed)) return true;
+    }
+
+    // Check if the first 1-3 words indicate task completion (for longer responses)
+    // e.g. "Task complete: ...", "All done.", "No further changes needed.", "Confirmed complete."
+    const firstWords = trimmed.split(/\s+/).slice(0, 3).join(" ");
+    const firstWordPattern = /^(task\s*(complete|completed|done|finished)|all\s*done|no\s*(further|more|additional|changes|action)|confirmed?\s*(complete|done|finished|one\s*last)|nothing\s*(more|further|else)|standing\s*by|everything\s*is|still\s*confirmed|acknowledged|done\s*and|complete\s*(and|\.)|completed\s*successfully|no\s*additional|verified\s*and)/i;
+    if (firstWordPattern.test(firstWords)) return true;
+
+    // If easyFinalAnswer mode is on, also match response starting with "✅" or numbered confirmation lists
+    if (this.easyFinalAnswer) {
+      if (trimmed.startsWith("✅") || /^[\d\.\-\*]/.test(trimmed)) return true;
+    }
+
+    return false;
+  }
+
   getEnabledTools() {
     return this.tools
       .getTools()
@@ -705,7 +732,7 @@ export abstract class BaseAgent implements IAgent {
           "warn"
         );
         const error = response as any;
-        if ("response" in error && "data" in error.response) {
+        if (error != null && "response" in error && "data" in error.response) {
           this.log(
             `Response data: ${JSON.stringify(error.response.data, null, 2)}`,
             "warn"
@@ -826,6 +853,18 @@ export abstract class BaseAgent implements IAgent {
 
       // Early exit: not required to call tool
       const firstMessage = response.choices[0].message;
+      // Auto-detect termination words: if the model is just saying "Done", "Complete", etc.
+      if (
+        response.choices.length === 1 &&
+        firstMessage.content &&
+        this.isTerminationResponse(firstMessage.content)
+      ) {
+        this.log(`Termination word detected: "${firstMessage.content.trim()}", treating as finalAnswer`);
+        this.status = this.eventTypes.done;
+        this.agentEvents.emit(this.eventTypes.done, firstMessage.content);
+        return firstMessage.content;
+      }
+
       if (
         response.choices.length === 1 &&
         firstMessage.content &&
@@ -879,7 +918,7 @@ export abstract class BaseAgent implements IAgent {
         this.logStatus();
 
         const continuation = `<Workflow>
-        workflow continues until you call one of ${this.requiredToolNames}.\n
+        workflow continues until you call one of ${JSON.stringify(this.requiredToolNames)}.\n
         ${statusMessage}
         </Workflow>`;
 
@@ -925,7 +964,7 @@ export abstract class BaseAgent implements IAgent {
 
       this.log(`Agent failed: ${e}`, "error");
 
-      if ("response" in e && "data" in e.response) {
+      if (e != null && typeof e === "object" && "response" in e && "data" in (e as any).response) {
         this.log(
           `Error response data: ${JSON.stringify(e.response.data, null, 2)}`,
           "error"
@@ -1042,7 +1081,7 @@ export abstract class BaseAgent implements IAgent {
     toolCalls: ToolCall[],
     response: CompletionResponse
   ): { role: string; content: string } | null {
-    const outputTokens: number = response?.usage?.output_tokens || 0;
+    const outputTokens: number = response?.usage?.completion_tokens || 0;
     const totalArgLength = toolCalls.reduce(
       (sum, tc) => sum + (tc.function?.arguments?.length || 0),
       0

package/src/clients/anthropic.ts

@@ -207,7 +207,7 @@ export class GenericAnthropicClient implements GenericClient {
     const toolCalls = messages.flatMap((msg) => msg.tool_calls || []);
     const claudeMessages: MessageParam[] = messages
       .filter((msg) => msg.role !== "system")
-      .filter((msg) => msg.content)
+      .filter((msg) => msg.content || msg.role === "tool")
       .map((msg) => {
         if (msg.role === "tool") {
           const toolCall = toolCalls.find((tc) => tc.id === msg.tool_call_id);
@@ -412,7 +412,13 @@ export class GenericAnthropicClient implements GenericClient {
         }),
 
         model: options.model,
-        usage: response.usage,
+        usage: response.usage ? {
+          prompt_tokens: response.usage.input_tokens ?? 0,
+          completion_tokens: response.usage.output_tokens ?? 0,
+          total_tokens: (response.usage.input_tokens ?? 0) + (response.usage.output_tokens ?? 0),
+          cache_creation_input_tokens: response.usage.cache_creation_input_tokens ?? 0,
+          cache_read_input_tokens: response.usage.cache_read_input_tokens ?? 0,
+        } : undefined,
         usd_cost: this.calculateCost(options.model, response.usage),
       };
     } catch (err) {

package/src/clients/gemini.ts

@@ -26,7 +26,7 @@ import {
 } from "../types";
 import { GeminiTextPricing } from "./pricing";
 import { ContextLimits } from "./contextLimits";
-import { ModelModality } from "./types";
+import { ModelModality, TokenUsage } from "./types";
 
 import {
   GenericClient,
@@ -524,10 +524,22 @@ export class GenericGeminiClient implements GenericClient {
         ? this.calculateCost(options.model, usage)
         : undefined;
 
+      // Map cachedContentTokenCount → prompt_tokens_details.cached_tokens so that
+      // base.ts can read cache hit tokens via usage.prompt_tokens_details?.cached_tokens
+      const cachedTokens = (usage as any)?.cachedContentTokenCount ?? 0;
+      const usageWithCache: TokenUsage | undefined = usage
+        ? ({
+            prompt_tokens: (usage as any).promptTokenCount ?? 0,
+            completion_tokens: (usage as any).candidatesTokenCount ?? 0,
+            total_tokens: (usage as any).totalTokenCount,
+            prompt_tokens_details: { cached_tokens: cachedTokens },
+          } as TokenUsage)
+        : undefined;
+
       return {
         choices,
         model: options.model,
-        usage,
+        usage: usageWithCache,
         usd_cost: usdCost,
       };
     } catch (error) {

package/src/clients/http.ts

@@ -264,6 +264,10 @@ export class HttpClient implements GenericClient {
             prompt_tokens: data.usage.input_tokens,
             completion_tokens: data.usage.output_tokens,
             total_tokens: data.usage.input_tokens + data.usage.output_tokens,
+            prompt_tokens_details: {
+              cached_tokens:
+                data.usage.input_tokens_details?.cached_tokens ?? 0,
+            },
           }
         : undefined;
 

package/src/clients/openai.ts

@@ -176,7 +176,14 @@ export class GenericOpenAiClient implements GenericClient {
       })),
 
       model: options.model,
-      usage: response.usage,
+      usage: response.usage ? {
+        prompt_tokens: response.usage.prompt_tokens ?? 0,
+        completion_tokens: response.usage.completion_tokens ?? 0,
+        total_tokens: response.usage.total_tokens,
+        prompt_tokens_details: {
+          cached_tokens: response.usage.prompt_tokens_details?.cached_tokens ?? 0,
+        },
+      } : undefined,
       usd_cost: usdCost,
     };
   }
@@ -300,6 +307,10 @@ export class GenericOpenAiClient implements GenericClient {
           completion_tokens: response.usage.output_tokens,
           total_tokens:
             response.usage.input_tokens + response.usage.output_tokens,
+          prompt_tokens_details: {
+            cached_tokens:
+              response.usage.input_tokens_details?.cached_tokens ?? 0,
+          },
         }
       : undefined;
 

package/src/clients/pricing/openai.ts

@@ -156,6 +156,7 @@ export const OpenAiResponsesOnlyModels: string[] = [
   OpenAiModels.GPT_54_Nano,
   OpenAiModels.GPT_54_Pro,
   OpenAiModels.GPT_55_Pro,
+  OpenAiModels.GPT_55,
   OpenAiModels.GPT_5_Pro,
   OpenAiModels.o1,
   OpenAiModels.o1_Pro,

package/src/clients/types.ts

@@ -63,13 +63,36 @@ export interface CompletionOptions {
   reasoning_effort?: "low" | "medium" | "high";
 }
 
+/**
+ * Normalised token-usage shape that every client must return.
+ * All clients must map their provider-specific field names into this structure
+ * so that base.ts can accurately track input/output and cache utilization.
+ */
+export interface TokenUsage {
+  /** Total input/prompt tokens consumed */
+  prompt_tokens: number;
+  /** Total output/completion tokens generated */
+  completion_tokens: number;
+  /** Convenience total (prompt + completion) */
+  total_tokens?: number;
+  /** Cache details */
+  prompt_tokens_details?: {
+    /** Tokens served from the prompt cache (reduces cost) */
+    cached_tokens: number;
+  };
+  /** Anthropic-style cache write tokens */
+  cache_creation_input_tokens?: number;
+  /** Anthropic-style cache read tokens (alternative field name) */
+  cache_read_input_tokens?: number;
+}
+
 export interface CompletionResponse {
   choices: {
     message: OutputMessage;
   }[];
 
   model: string;
-  usage: any;
+  usage: TokenUsage | undefined;
   usd_cost?: number;
 }
 

package/src/clients/xai.ts

@@ -99,7 +99,14 @@ export class GenericXAIClient implements GenericClient {
       })),
 
       model: options.model,
-      usage: response.usage,
+      usage: response.usage ? {
+        prompt_tokens: response.usage.prompt_tokens ?? 0,
+        completion_tokens: response.usage.completion_tokens ?? 0,
+        total_tokens: response.usage.total_tokens,
+        prompt_tokens_details: {
+          cached_tokens: response.usage.prompt_tokens_details?.cached_tokens ?? 0,
+        },
+      } : undefined,
       usd_cost: usdCost,
     };
   }
@@ -200,6 +207,9 @@ export class GenericXAIClient implements GenericClient {
           prompt_tokens: data.usage.input_tokens,
           completion_tokens: data.usage.output_tokens,
           total_tokens: data.usage.input_tokens + data.usage.output_tokens,
+          prompt_tokens_details: {
+            cached_tokens: data.usage.input_tokens_details?.cached_tokens ?? 0,
+          },
         }
       : undefined;
 

package/tests/clients/AIClient.test.ts

@@ -42,7 +42,7 @@ class FakeClient implements GenericClient {
         },
       ],
       model: options.model,
-      usage: { total_tokens: 100 },
+      usage: { prompt_tokens: 50, completion_tokens: 50, total_tokens: 100 },
     };
   }
 

package/tests/clients/anthropic.test.ts

@@ -0,0 +1,202 @@
+import { GenericAnthropicClient } from "../../src/clients/anthropic";
+
+// We only need to test transformMessages, which doesn't require an API key
+function createClient() {
+  return new GenericAnthropicClient("fake-key");
+}
+
+describe("GenericAnthropicClient.transformMessages", () => {
+  let client: GenericAnthropicClient;
+
+  beforeEach(() => {
+    client = createClient();
+  });
+
+  it("should handle a simple user message", () => {
+    const messages = [
+      { role: "user" as const, content: "Hello" },
+    ];
+    const result = client.transformMessages(messages);
+    expect(result).toHaveLength(1);
+    expect(result[0].role).toBe("user");
+    expect(result[0].content).toBe("Hello");
+  });
+
+  it("should filter out system messages", () => {
+    const messages = [
+      { role: "system" as const, content: "You are helpful" },
+      { role: "user" as const, content: "Hello" },
+    ];
+    const result = client.transformMessages(messages);
+    expect(result).toHaveLength(1);
+    expect(result[0].role).toBe("user");
+  });
+
+  it("should inject tool_use assistant block when processing tool result", () => {
+    // Simulates: assistant responds with tool_call (content: ""), then tool result comes back
+    const messages = [
+      { role: "user" as const, content: "Use a tool" },
+      {
+        role: "assistant" as const,
+        content: "",
+        tool_calls: [
+          {
+            id: "toolu_abc123",
+            type: "function" as const,
+            function: {
+              name: "listAvailableTools",
+              arguments: "{}",
+            },
+          },
+        ],
+      },
+      {
+        role: "tool" as const,
+        tool_call_id: "toolu_abc123",
+        name: "listAvailableTools",
+        content: '{"enabled": ["finalAnswer"], "disabled": []}',
+      },
+    ];
+
+    const result = client.transformMessages(messages);
+
+    // Should have: user msg, assistant tool_use block, user tool_result block
+    expect(result.length).toBeGreaterThanOrEqual(2);
+
+    // Find the assistant message with tool_use
+    const assistantMsg = result.find(
+      (m) =>
+        m.role === "assistant" &&
+        Array.isArray(m.content) &&
+        (m.content as any[]).some((c) => c.type === "tool_use")
+    );
+    expect(assistantMsg).toBeDefined();
+    const toolUseBlock = (assistantMsg!.content as any[]).find(
+      (c) => c.type === "tool_use"
+    );
+    expect(toolUseBlock.id).toBe("toolu_abc123");
+    expect(toolUseBlock.name).toBe("listAvailableTools");
+
+    // Find the user message with tool_result
+    const userToolResult = result.find(
+      (m) =>
+        m.role === "user" &&
+        Array.isArray(m.content) &&
+        (m.content as any[]).some((c) => c.type === "tool_result")
+    );
+    expect(userToolResult).toBeDefined();
+    const toolResultBlock = (userToolResult!.content as any[]).find(
+      (c) => c.type === "tool_result"
+    );
+    expect(toolResultBlock.tool_use_id).toBe("toolu_abc123");
+  });
+
+  it("should not have undefined tool_use_id when assistant message has empty content with tool_calls", () => {
+    // This is the failing scenario: assistant has content: "" (falsy) but has tool_calls
+    const messages = [
+      { role: "user" as const, content: "Use a tool" },
+      {
+        role: "assistant" as const,
+        content: "",  // empty string - would be filtered by `msg.content` check
+        tool_calls: [
+          {
+            id: "toolu_abc123",
+            type: "function" as const,
+            function: {
+              name: "listAvailableTools",
+              arguments: "{}",
+            },
+          },
+        ],
+      },
+      {
+        role: "tool" as const,
+        tool_call_id: "toolu_abc123",
+        name: "listAvailableTools",
+        content: '{"enabled": ["finalAnswer"]}',
+      },
+    ];
+
+    const result = client.transformMessages(messages);
+
+    // Find the user message with tool_result - tool_use_id must NOT be undefined
+    const userToolResult = result.find(
+      (m) =>
+        m.role === "user" &&
+        Array.isArray(m.content) &&
+        (m.content as any[]).some((c) => c.type === "tool_result")
+    );
+    expect(userToolResult).toBeDefined();
+    const toolResultBlock = (userToolResult!.content as any[]).find(
+      (c) => c.type === "tool_result"
+    );
+    // This should be "toolu_abc123", NOT undefined
+    expect(toolResultBlock.tool_use_id).toBe("toolu_abc123");
+    expect(toolResultBlock.tool_use_id).not.toBeUndefined();
+  });
+
+  it("should handle multiple sequential tool calls", () => {
+    const messages = [
+      { role: "user" as const, content: "Do two things" },
+      {
+        role: "assistant" as const,
+        content: "",
+        tool_calls: [
+          {
+            id: "toolu_111",
+            type: "function" as const,
+            function: { name: "toolOne", arguments: "{}" },
+          },
+        ],
+      },
+      {
+        role: "tool" as const,
+        tool_call_id: "toolu_111",
+        name: "toolOne",
+        content: "result one",
+      },
+      {
+        role: "assistant" as const,
+        content: "",
+        tool_calls: [
+          {
+            id: "toolu_222",
+            type: "function" as const,
+            function: { name: "toolTwo", arguments: "{}" },
+          },
+        ],
+      },
+      {
+        role: "tool" as const,
+        tool_call_id: "toolu_222",
+        name: "toolTwo",
+        content: "result two",
+      },
+    ];
+
+    const result = client.transformMessages(messages);
+
+    // Both tool results should have correct tool_use_ids
+    const toolResults = result
+      .filter((m) => m.role === "user" && Array.isArray(m.content))
+      .flatMap((m) => (m.content as any[]).filter((c) => c.type === "tool_result"));
+
+    expect(toolResults).toHaveLength(2);
+    const ids = toolResults.map((r) => r.tool_use_id);
+    expect(ids).toContain("toolu_111");
+    expect(ids).toContain("toolu_222");
+    expect(ids).not.toContain(undefined);
+  });
+
+  it("should not crash when response is undefined (Cannot use in operator bug)", () => {
+    // Test that the base agent undefined response check doesn't throw
+    // This tests the guard we added to base.ts
+    const undefinedLike = undefined as any;
+    // Should not throw "Cannot use 'in' operator to search for 'response' in undefined"
+    expect(() => {
+      if (undefinedLike != null && "response" in undefinedLike) {
+        // This should not be reached
+      }
+    }).not.toThrow();
+  });
+});

package/ts_build/package.json

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

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

@@ -96,6 +96,7 @@ export declare abstract class BaseAgent implements IAgent {
     getClient(): GenericClient;
     setClient(client: GenericClient): void;
     setEasyFinalAnswer(value: boolean): void;
+    protected isTerminationResponse(content: string): boolean;
     getEnabledTools(): Tool[];
     getEnabledToolNames(): string[];
     disableTool(toolName: string): void;

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

@@ -197,6 +197,24 @@ class BaseAgent {
     setEasyFinalAnswer(value) {
         this.easyFinalAnswer = value;
     }
+    isTerminationResponse(content) {
+        const trimmed = content.trim();
+        const wordCount = trimmed.split(/\s+/).filter(Boolean).length;
+        if (wordCount <= 3) {
+            const terminationPattern = /^(done|complete|completed|finished|final\s*answer|task\s*complete|all\s*done|that'?s\s*(all|it)|ok(ay)?|yes)[.!]*$/i;
+            if (terminationPattern.test(trimmed))
+                return true;
+        }
+        const firstWords = trimmed.split(/\s+/).slice(0, 3).join(" ");
+        const firstWordPattern = /^(task\s*(complete|completed|done|finished)|all\s*done|no\s*(further|more|additional|changes|action)|confirmed?\s*(complete|done|finished|one\s*last)|nothing\s*(more|further|else)|standing\s*by|everything\s*is|still\s*confirmed|acknowledged|done\s*and|complete\s*(and|\.)|completed\s*successfully|no\s*additional|verified\s*and)/i;
+        if (firstWordPattern.test(firstWords))
+            return true;
+        if (this.easyFinalAnswer) {
+            if (trimmed.startsWith("✅") || /^[\d\.\-\*]/.test(trimmed))
+                return true;
+        }
+        return false;
+    }
     getEnabledTools() {
         return this.tools
             .getTools()
@@ -476,7 +494,7 @@ class BaseAgent {
             if (response?.usd_cost === undefined) {
                 this.log(`Response cost is undefined: ${JSON.stringify(response, null, 2)}`, "warn");
                 const error = response;
-                if ("response" in error && "data" in error.response) {
+                if (error != null && "response" in error && "data" in error.response) {
                     this.log(`Response data: ${JSON.stringify(error.response.data, null, 2)}`, "warn");
                 }
                 if (!response?.choices) {
@@ -541,6 +559,14 @@ class BaseAgent {
                 messages = await this.messageProcessor.processMessages(messages, "post_tools");
             }
             const firstMessage = response.choices[0].message;
+            if (response.choices.length === 1 &&
+                firstMessage.content &&
+                this.isTerminationResponse(firstMessage.content)) {
+                this.log(`Termination word detected: "${firstMessage.content.trim()}", treating as finalAnswer`);
+                this.status = this.eventTypes.done;
+                this.agentEvents.emit(this.eventTypes.done, firstMessage.content);
+                return firstMessage.content;
+            }
             if (response.choices.length === 1 &&
                 firstMessage.content &&
                 this.easyFinalAnswer) {
@@ -573,7 +599,7 @@ class BaseAgent {
                 const statusMessage = this.getStatusMessage();
                 this.logStatus();
                 const continuation = `<Workflow>
-        workflow continues until you call one of ${this.requiredToolNames}.\n
+        workflow continues until you call one of ${JSON.stringify(this.requiredToolNames)}.\n
         ${statusMessage}
         </Workflow>`;
                 messages.push({
@@ -607,7 +633,7 @@ class BaseAgent {
                 return this.call(userInput, _messages, retryCount + 1);
             }
             this.log(`Agent failed: ${e}`, "error");
-            if ("response" in e && "data" in e.response) {
+            if (e != null && typeof e === "object" && "response" in e && "data" in e.response) {
                 this.log(`Error response data: ${JSON.stringify(e.response.data, null, 2)}`, "error");
             }
             this.agentEvents.emit(this.eventTypes.done, e.message);
@@ -688,7 +714,7 @@ class BaseAgent {
         return JSON.stringify(messages).split(" ").length;
     }
     detectTruncatedToolCalls(toolCalls, response) {
-        const outputTokens = response?.usage?.output_tokens || 0;
+        const outputTokens = response?.usage?.completion_tokens || 0;
         const totalArgLength = toolCalls.reduce((sum, tc) => sum + (tc.function?.arguments?.length || 0), 0);
         const expectedArgChars = outputTokens * 4;
         const suspiciouslySmallArgs = outputTokens > 1000 && totalArgLength < expectedArgChars * 0.1;