@tyvm/knowhow 0.0.106 → 0.0.108-dev.126b29e

package/README.md

@@ -362,3 +362,48 @@ For command usage and behavior details, see:
 - Website: https://knowhow.tyvm.ai
 - Twitter/X: https://x.com/micahriggan
 - npm: https://www.npmjs.com/package/@tyvm/knowhow
+
+---
+
+## 🚧 Dev & Nightly Releases
+
+Knowhow publishes unstable/preview builds under separate npm dist-tags so that regular users on `latest` are never affected.
+
+### Installing a pre-release build
+
+```bash
+# Latest nightly (date-stamped)
+npm install -g @tyvm/knowhow@nightly
+
+# Latest dev snapshot (git-hash-stamped)
+npm install -g @tyvm/knowhow@dev
+
+# Pin a specific pre-release version
+npm install -g @tyvm/knowhow@0.0.108-nightly.20250428
+```
+
+### How dist-tags work
+
+| Tag | Installed by default? | Audience |
+|-----|-----------------------|---------|
+| `latest` | ✅ Yes (`npm install @tyvm/knowhow`) | All stable users |
+| `nightly` | ❌ No (must opt-in) | Testers / early adopters |
+| `dev` | ❌ No (must opt-in) | Developers / contributors |
+
+Publishing a `nightly` or `dev` release **never moves the `latest` tag**, so existing users won't receive unstable code through normal updates.
+
+### Publishing scripts (for maintainers)
+
+```bash
+# Publish a date-stamped nightly (e.g. 0.0.108-nightly.20250428)
+npm run publish:nightly
+
+# Publish a git-hash-stamped dev snapshot (e.g. 0.0.108-dev.abc1234)
+npm run publish:dev
+
+# Publish a stable release to `latest`
+npm version patch   # or minor / major
+npm run publish:stable
+```
+
+> **Note:** `publish:nightly` and `publish:dev` automatically version-bump the `package.json` with a pre-release suffix before publishing and do **not** create a git tag, keeping your git history clean.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.106",
+  "version": "0.0.108-dev.126b29e",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -21,7 +21,13 @@
     "lint": "tslint ./src/**/*.ts",
     "lint:deps": "depcheck --config=.depcheckrc",
     "lint:all": "npm run lint && npm run lint:deps",
-    "check:model-pricing": "ts-node scripts/check-model-pricing.ts"
+    "check:model-pricing": "ts-node scripts/check-model-pricing.ts",
+    "version:nightly": "bash scripts/publish.sh version:nightly",
+    "version:dev": "bash scripts/publish.sh version:dev",
+    "publish:nightly": "bash scripts/publish.sh nightly",
+    "publish:dev": "bash scripts/publish.sh dev",
+    "publish:latest": "bash scripts/publish.sh stable",
+    "publish:stable": "bash scripts/publish.sh stable"
   },
   "keywords": [],
   "author": "Micah Riggan",

package/scripts/publish.sh

@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+COMMAND="${1:-}"
+
+get_current_version() {
+  node -e "process.stdout.write(require('./package.json').version)"
+}
+
+version_nightly() {
+  local version
+  version=$(get_current_version)
+  # Strip any existing pre-release suffix (e.g. -dev.xxx or -nightly.xxx)
+  version=$(echo "$version" | sed 's/-.*$//')
+  local stamp
+  stamp=$(date -u +%Y%m%d)
+  local pre="${version}-nightly.${stamp}"
+  local current
+  current=$(get_current_version)
+  if [ "$current" = "$pre" ]; then
+    echo "Version already set to: $pre (no change needed)"
+  else
+    echo "Bumping version to: $pre"
+    npm version "$pre" --no-git-tag-version
+  fi
+}
+
+version_dev() {
+  local version
+  version=$(get_current_version)
+  # Strip any existing pre-release suffix (e.g. -dev.xxx or -nightly.xxx)
+  version=$(echo "$version" | sed 's/-.*$//')
+  local hash
+  hash=$(git rev-parse --short HEAD)
+  local pre="${version}-dev.${hash}"
+  local current
+  current=$(get_current_version)
+  if [ "$current" = "$pre" ]; then
+    echo "Version already set to: $pre (no change needed)"
+  else
+    echo "Bumping version to: $pre"
+    npm version "$pre" --no-git-tag-version
+  fi
+}
+
+case "$COMMAND" in
+  nightly)
+    echo "🌙 Publishing nightly release..."
+    npm run compile
+    bash scripts/check-isolated-deps.sh
+    version_nightly
+    npm publish --tag nightly
+    echo "✅ Nightly published!"
+    ;;
+  dev)
+    echo "🔧 Publishing dev release..."
+    npm run compile
+    bash scripts/check-isolated-deps.sh
+    version_dev
+    npm publish --tag dev
+    echo "✅ Dev release published!"
+    ;;
+  stable|latest)
+    echo "🚀 Publishing stable release..."
+    npm run compile
+    bash scripts/check-isolated-deps.sh
+    npm publish --tag latest
+    echo "✅ Stable release published!"
+    ;;
+  version:nightly)
+    version_nightly
+    ;;
+  version:dev)
+    version_dev
+    ;;
+  *)
+    echo "Usage: $0 <nightly|dev|stable|version:nightly|version:dev>"
+    echo ""
+    echo "  nightly        - Compile, check deps, bump version with nightly stamp, publish to 'nightly' tag"
+    echo "  dev            - Compile, check deps, bump version with git hash, publish to 'dev' tag"
+    echo "  stable         - Compile, check deps, publish to 'latest' tag"
+    echo "  version:nightly - Only bump version with nightly stamp (no publish)"
+    echo "  version:dev     - Only bump version with git hash (no publish)"
+    exit 1
+    ;;
+esac

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()
@@ -686,6 +713,7 @@ export abstract class BaseAgent implements IAgent {
         messages,
         tools: this.getEnabledTools(),
         tool_choice: "auto",
+        long_ttl_cache: this.runTime() > 300_000,
       });
 
       // If the agent was paused while the completion was in-flight, wait here
@@ -705,7 +733,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 +854,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 +919,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 +965,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 +1082,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/agents/tools/execCommand.ts

@@ -3,6 +3,7 @@ import { promisify } from "util";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { services, ToolsService } from "../../services";
 
 export const execAsync = promisify(exec);
 
@@ -256,16 +257,32 @@ const execWithTimeout = async (
 };
 
 // Public tool
-export const execCommand = async (
+export async function execCommand(
   command: string,
   timeout?: number,
   continueInBackground?: boolean,
   logFileName?: string
-): Promise<string> => {
-  if(!command || typeof command !== "string") {
+): Promise<string> {
+  if (!command || typeof command !== "string") {
     throw new Error("Invalid command. We received a non-string value. Please ensure you are sending strings of 4k tokens or less.");
   }
 
+  // Get context from bound ToolsService (same pattern as writeFile)
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+  const context = toolService.getContext();
+
+  // Emit pre-run blocking event — handlers can throw to block the command
+  if (context.Events) {
+    await context.Events.emitBlocking("exec:pre-run", {
+      command,
+      timeout,
+      continueInBackground,
+      logFileName,
+    });
+  }
+
   const { stdout, stderr, timedOut, killed, pid, logPath } =
     await execWithTimeout(command, {
       timeout,
@@ -298,6 +315,32 @@ export const execCommand = async (
    *    : "";
    */
 
-  // return `$ ${command}${statusMsg}\n${trimmed}${trimmedMsg}`;
-  return `$ ${command}${statusMsg}\n${output}`;
-};
+  const result = `$ ${command}${statusMsg}\n${output}`;
+
+  // Emit post-run blocking event — handlers can append extra context
+  let eventResults: any[] = [];
+  if (context.Events) {
+    eventResults = await context.Events.emitBlocking("exec:post-run", {
+      command,
+      timeout,
+      continueInBackground,
+      logFileName,
+      stdout,
+      stderr,
+      timedOut,
+      killed,
+      pid,
+      logPath,
+      output,
+    });
+  }
+
+  // Append any additional context returned by post-run handlers
+  let eventResultsText = "";
+  if (eventResults && eventResults.length > 0) {
+    eventResultsText =
+      "\n\nAdditional Information:\n" + JSON.stringify(eventResults, null, 2);
+  }
+
+  return result + eventResultsText;
+};

package/src/chat/modules/AgentModule.ts

@@ -30,11 +30,7 @@ import {
   Base64ImageProcessor,
 } from "../../processors/index";
 import { TaskInfo } from "../types";
-import {
-  createAgent,
-  agentConstructors,
-  AgentName,
-} from "../../agents";
+import { createAgent, agentConstructors, AgentName } from "../../agents";
 import { ToolCallEvent } from "../../agents/base/base";
 import { KnowhowSimpleClient } from "../../services/KnowhowClient";
 
@@ -80,7 +76,6 @@ export class AgentModule extends BaseChatModule {
     this.remoteSyncModule = module;
   }
 
-
   getCommands(): ChatCommand[] {
     return [
       {
@@ -260,7 +255,10 @@ export class AgentModule extends BaseChatModule {
         if (context) {
           // Create a temporary agent instance to read its default model/provider
           const agentContext = services().Agents.getAgentContext();
-          const tempAgent = createAgent(agentName as AgentName, agentContext) as BaseAgent;
+          const tempAgent = createAgent(
+            agentName as AgentName,
+            agentContext
+          ) as BaseAgent;
           context.selectedAgent = tempAgent;
           context.agentMode = true;
           context.currentAgent = agentName;
@@ -455,7 +453,6 @@ export class AgentModule extends BaseChatModule {
       const agentNames = Object.keys(agentConstructors);
 
       if (agentNames.length > 0) {
-
         console.log("\nAvailable agents:");
         agentNames.forEach((name) => {
           console.log(`  - ${name}`);
@@ -503,39 +500,52 @@ export class AgentModule extends BaseChatModule {
         console.error(`Session ${sessionId} not found.`);
         return;
       }
-      const lastThread = session.threads[session.threads.length - 1];
       console.log(`\n🔄 Resuming session: ${sessionId}`);
       console.log(`Agent: ${session.agentName}`);
       console.log(`Original task: ${session.initialInput}`);
       console.log(`Status: ${session.status}`);
 
-      const reason = resumeReason
-        ? `Reason for resuming:  ${resumeReason}`
-        : "";
-
-      // Create resume prompt
-      const resumePrompt = `You are resuming a previously started task. Here's the context:
-ORIGINAL REQUEST:
-      ${session.initialInput}
-
-LAST Progress State:
-      ${JSON.stringify(lastThread)}
-
-Please continue from where you left off and complete the original request.
-        ${reason}
-
-`;
+      // Build resume prompt (same pattern as resumeFromMessages)
+      const resumePrompt = [
+        "You are resuming a previously started task.",
+        session.initialInput ? `ORIGINAL REQUEST: ${session.initialInput}` : "",
+        "Please continue from where you left off and complete the original request.",
+        resumeReason ? `Reason for resuming: ${resumeReason}` : "",
+      ]
+        .filter(Boolean)
+        .join("\n");
+
+      // Restore the full message history from the last thread
+      const threads = session.threads || [];
+      const lastThread = threads.length > 0 ? threads[threads.length - 1] : [];
+      const resumeMessages = [...lastThread];
+
+      // Append the resume prompt to the last user message (or add a new one)
+      const reversedIndex = [...lastThread]
+        .reverse()
+        .findIndex((e) => e.role === "user" && typeof e.content === "string");
+
+      if (reversedIndex === -1) {
+        resumeMessages.push({ role: "user", content: resumePrompt });
+      } else {
+        const actualIndex = lastThread.length - 1 - reversedIndex;
+        resumeMessages[actualIndex] = {
+          ...resumeMessages[actualIndex],
+          content: resumeMessages[actualIndex].content + `\n\n<Workflow>[RESUME CONTEXT]: ${resumePrompt}</Workflow>`,
+        };
+      }
 
       console.log("🚀 Session resuming...");
       const context = this.chatService?.getContext();
       const agentName = session.agentName || context.currentAgent;
+      const previousAgentMode = context?.agentMode;
 
       if (!agentName || !agentConstructors[agentName as AgentName]) {
         console.error(`Agent ${agentName} not found.`);
         return;
       }
 
-      // Start agent with Knowhow task context if available
+      // Start agent with Knowhow task context and restored message history
       const { agent, taskId } = await this.setupAgent({
         agentName,
         input: resumePrompt,
@@ -544,7 +554,20 @@ Please continue from where you left off and complete the original request.
         chatHistory: [],
         run: false, // Don't run yet, we need to set up event listeners first
       });
-      await this.attachedAgentChatLoop(taskId, agent, resumePrompt);
+
+      // After resume finishes, revert to normal chat (non-agent mode) so the
+      // user can start a fresh conversation instead of staying locked in agent mode.
+      agent.agentEvents.once(agent.eventTypes.done, () => {
+        const ctx = this.chatService?.getContext();
+        if (ctx && !previousAgentMode) {
+          ctx.agentMode = false;
+          ctx.selectedAgent = undefined;
+          ctx.currentAgent = undefined;
+          this.chatService?.disableMode("agent");
+        }
+      });
+
+      await this.attachedAgentChatLoop(taskId, agent, resumePrompt, resumeMessages);
     } catch (error) {
       console.error(
         `Failed to resume session ${sessionId}:`,
@@ -1033,7 +1056,8 @@ Please continue from where you left off and complete the original request.
   async attachedAgentChatLoop(
     taskId: string,
     agent: AttachableAgent,
-    initialInput?: string
+    initialInput?: string,
+    initialMessages?: any[]
   ): Promise<void> {
     try {
       let agentFinalOutput: string | undefined;
@@ -1075,7 +1099,7 @@ Please continue from where you left off and complete the original request.
 
           if (context.chatHistory) {
             const found = context.chatHistory.find((h) => h.taskId === taskId);
-            found.output = agentFinalOutput;
+            if (found) found.output = agentFinalOutput;
           }
 
           resolve("done");
@@ -1088,7 +1112,8 @@ Please continue from where you left off and complete the original request.
       if (initialInput) {
         const taskInfo = this.taskRegistry.get(taskId);
         (agent as BaseAgent).call(
-          taskInfo?.formattedPrompt || taskInfo?.initialInput || initialInput
+          taskInfo?.formattedPrompt || taskInfo?.initialInput || initialInput,
+          initialMessages
         );
       }
     } catch (error) {

package/src/chat/modules/SessionsModule.ts

@@ -304,15 +304,20 @@ export class SessionsModule extends BaseChatModule {
   async handleResumeCommand(args: string[]): Promise<void> {
     const sessionManager = this.agentModule.getSessionManager();
 
-    if (args.length === 0) {
+    if (args.length === 0 || args[0] === "--all") {
       // Interactive: show saved sessions for selection
-      const savedSessions = sessionManager.listAvailableSessions();
+      const showAll = args[0] === "--all";
+      const allSessions = sessionManager.listAvailableSessions();
+      const savedSessions = showAll ? allSessions : allSessions.slice(0, 10);
       if (savedSessions.length === 0) {
         console.log("No saved sessions found to resume.");
         return;
       }
 
       this.printSavedSessionsTable(savedSessions);
+      if (!showAll && allSessions.length > 10) {
+        console.log(`   ... and ${allSessions.length - 10} more. Use /resume --all to see all sessions.`);
+      }
 
       const allIds = savedSessions.map((s) => s.sessionId);
       const selectedId = await this.selectByNumber(

package/src/cli.ts

@@ -530,12 +530,17 @@ async function main() {
     .description("Create or sync a cloud worker with your local knowhow config")
     .option("--create", "Create a new cloud worker with synced config and files")
     .option("--push <uid>", "Push/sync local config and files to an existing cloud worker")
+    .option("--pull <id>", "Pull the latest workerConfigJson from a cloud worker and update local config")
     .option("--name <name>", "Name for the cloud worker (used with --create)")
     .option("--dry-run", "Print what would be synced without doing it")
     .action(async (options) => {
       try {
-        const { cloudWorker } = await import("./cloudWorker");
-        await cloudWorker(options);
+        const { cloudWorker, pullCloudWorkerConfig } = await import("./cloudWorker");
+        if (options.pull) {
+          await pullCloudWorkerConfig({ id: options.pull });
+        } else {
+          await cloudWorker(options);
+        }
       } catch (error) {
         console.error("Error running cloudworker:", error);
         process.exit(1);

package/src/clients/anthropic.ts

@@ -40,11 +40,11 @@ export class GenericAnthropicClient implements GenericClient {
     });
   }
 
-  handleToolCaching(tools: Anthropic.Tool[]) {
+  handleToolCaching(tools: Anthropic.Tool[], longTtl = false) {
     const lastTool = tools[tools.length - 1];
 
     if (lastTool) {
-      lastTool.cache_control = { type: "ephemeral" };
+      lastTool.cache_control = longTtl ? { type: "ephemeral", ttl: "1h" } as any : { type: "ephemeral" };
     }
   }
 
@@ -94,7 +94,7 @@ export class GenericAnthropicClient implements GenericClient {
     return cleaned;
   }
 
-  transformTools(tools?: Tool[]): Anthropic.Tool[] {
+  transformTools(tools?: Tool[], longTtl = false): Anthropic.Tool[] {
     if (!tools) {
       return [];
     }
@@ -104,7 +104,7 @@ export class GenericAnthropicClient implements GenericClient {
       input_schema: this.cleanSchemaForAnthropic(tool.function.parameters) as any,
     }));
 
-    this.handleToolCaching(transformed);
+    this.handleToolCaching(transformed, longTtl);
 
     return transformed;
   }
@@ -153,16 +153,16 @@ export class GenericAnthropicClient implements GenericClient {
     return messages;
   }
 
-  cacheLastContent(message: MessageParam) {
+  cacheLastContent(message: MessageParam, longTtl = false) {
     if (Array.isArray(message.content)) {
       const lastMessage = message.content[message.content.length - 1];
       if (
         lastMessage.type !== "thinking" &&
         lastMessage.type !== "redacted_thinking"
       ) {
-        lastMessage.cache_control = {
-          type: "ephemeral",
-        };
+        lastMessage.cache_control = longTtl
+          ? ({ type: "ephemeral", ttl: "1h" } as any)
+          : { type: "ephemeral" };
       }
     }
   }
@@ -179,7 +179,7 @@ export class GenericAnthropicClient implements GenericClient {
     }
   }
 
-  handleMessageCaching(groupedMessages: MessageParam[]) {
+  handleMessageCaching(groupedMessages: MessageParam[], longTtl = false) {
     this.handleClearingCache(groupedMessages);
 
     // find the last two messages and mark them as ephemeral
@@ -189,7 +189,7 @@ export class GenericAnthropicClient implements GenericClient {
 
     for (const m of lastTwoUserMessages) {
       if (Array.isArray(m.content)) {
-        this.cacheLastContent(m);
+        this.cacheLastContent(m, longTtl);
       }
     }
   }
@@ -203,11 +203,11 @@ export class GenericAnthropicClient implements GenericClient {
     }
   }
 
-  transformMessages(messages: Message[]): MessageParam[] {
+  transformMessages(messages: Message[], longTtl = false): MessageParam[] {
     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);
@@ -302,7 +302,7 @@ export class GenericAnthropicClient implements GenericClient {
 
     const groupedMessages = this.combineMessages(claudeMessages);
 
-    this.handleMessageCaching(groupedMessages);
+    this.handleMessageCaching(groupedMessages, longTtl);
 
     return groupedMessages;
   }
@@ -349,14 +349,15 @@ export class GenericAnthropicClient implements GenericClient {
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
+    const longTtl = !!options.long_ttl_cache;
     const systemMessage = options.messages
       .filter((msg) => msg.role === "system")
       .map((msg) => msg.content || "")
       .join("\n");
 
-    const claudeMessages = this.transformMessages(options.messages);
+    const claudeMessages = this.transformMessages(options.messages, longTtl);
 
-    const tools = this.transformTools(options.tools);
+    const tools = this.transformTools(options.tools, longTtl);
     try {
       const response = await this.client.messages.create({
         model: options.model,
@@ -365,7 +366,7 @@ export class GenericAnthropicClient implements GenericClient {
           ? [
               {
                 text: systemMessage,
-                cache_control: { type: "ephemeral" },
+                cache_control: longTtl ? ({ type: "ephemeral", ttl: "1h" } as any) : { type: "ephemeral" },
                 type: "text",
               },
             ]
@@ -412,11 +413,19 @@ export class GenericAnthropicClient implements GenericClient {
         }),
 
         model: options.model,
-        usage: response.usage,
+        usage: response.usage ? {
+          input_tokens: response.usage.input_tokens ?? 0,
+          output_tokens: response.usage.output_tokens ?? 0,
+          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) {
-      if ("headers" in err && err.headers["x-should-retry"] === "true") {
+      if ("headers" in err && err.headers?.["x-should-retry"] === "true") {
         console.warn("Retrying failed request", err);
         await wait(2500);
         return this.createChatCompletion(options);