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

package/src/cloudWorker.ts

@@ -4,9 +4,14 @@ import { KnowhowSimpleClient, KNOWHOW_API_URL } from "./services/KnowhowClient";
 import { loadJwt } from "./login";
 import { getConfig, updateConfig, getLanguageConfig } from "./config";
 import { services } from "./services";
-import { Language, Config } from "./types";
+import { Language, Config, McpConfig } from "./types";
 import { S3Service } from "./services/S3";
 
+export interface CloudWorkerPullOptions {
+  id: string;
+  apiUrl?: string;
+}
+
 export interface CloudWorkerOptions {
   create?: boolean;
   push?: string; // uid of existing cloud worker
@@ -330,3 +335,72 @@ export async function cloudWorker(options: CloudWorkerOptions) {
     console.log(`\n✅ Cloud worker sync complete!`);
   }
 }
+
+/**
+ * Pull the latest workerConfigJson from the cloud worker API and update the
+ * local knowhow.json config to match.
+ *
+ * This is the "pull" half of the config sync cycle.  After running this,
+ * you can reload the worker's MCPs (in-process) via the reloadConfig
+ * WebSocket message or by calling `knowhow worker` again.
+ *
+ * Merged fields from workerConfigJson:
+ *   - mcps        → overwrites config.mcps
+ *   - modules     → overwrites config.modules  (optional, only if present)
+ *   - plugins     → overwrites config.plugins  (optional, only if present)
+ *   - agents      → overwrites config.agents   (optional, only if present)
+ */
+export async function pullCloudWorkerConfig(options: CloudWorkerPullOptions) {
+  const { id, apiUrl = KNOWHOW_API_URL } = options;
+
+  // Load JWT
+  const jwt = await loadJwt();
+  if (!jwt) {
+    console.error("❌ No JWT token found. Please run 'knowhow login' first.");
+    process.exit(1);
+  }
+
+  const client = new KnowhowSimpleClient(apiUrl, jwt);
+
+  console.log(`🔄 Pulling config for cloud worker ${id}...`);
+
+  const resp = await client.getCloudWorker(id);
+  const remoteWorker = resp.data;
+
+  if (!remoteWorker) {
+    console.error(`❌ Cloud worker ${id} not found.`);
+    process.exit(1);
+  }
+
+  const remoteConfig = (remoteWorker.workerConfigJson ?? {}) as {
+    mcps?: McpConfig[];
+    modules?: string[];
+    plugins?: Config["plugins"];
+    agents?: Config["agents"];
+  };
+
+  // Load current local config
+  const localConfig = await getConfig();
+
+  // Merge remote fields into local config
+  if (remoteConfig.mcps !== undefined) {
+    localConfig.mcps = remoteConfig.mcps;
+  }
+  if (remoteConfig.modules !== undefined) {
+    localConfig.modules = remoteConfig.modules;
+  }
+  if (remoteConfig.plugins !== undefined) {
+    localConfig.plugins = remoteConfig.plugins;
+  }
+  if (remoteConfig.agents !== undefined) {
+    localConfig.agents = remoteConfig.agents;
+  }
+
+  await updateConfig(localConfig);
+
+  const mcpCount = remoteConfig.mcps?.length ?? 0;
+  console.log(`✅ Config pulled! ${mcpCount} MCP(s) now configured locally.`);
+  console.log(`   Run 'knowhow worker' or trigger reloadConfig to apply changes.`);
+
+  return { mcps: remoteConfig.mcps, modules: remoteConfig.modules };
+}

package/src/index.ts

@@ -138,6 +138,23 @@ export async function upload() {
       if (!source.remoteId) {
         throw new Error("remoteId is required for knowhow uploads");
       }
+      // Warn if the local embeddingModel differs from the one stored on the backend
+      try {
+        const remoteEmbedding = await knowhowApiClient.getOrgEmbedding(source.remoteId);
+        const localModel = config.embeddingModel || EmbeddingModels.openai.EmbeddingAda2;
+        const remoteModel = remoteEmbedding?.modelName;
+        if (remoteModel && remoteModel !== localModel) {
+          console.warn(
+            `⚠️  WARNING: Embedding model mismatch for "${remoteEmbedding.name}" (remoteId: ${source.remoteId}).\n` +
+            `   Local config.embeddingModel:  ${localModel}\n` +
+            `   Backend embedding modelName:  ${remoteModel}\n` +
+            `   Vectors generated with different models are not comparable — search results will be incorrect.\n` +
+            `   Update your config.embeddingModel to "${remoteModel}" or update the backend embedding to "${localModel}".`
+          );
+        }
+      } catch (e) {
+        // Non-fatal — don't block upload if metadata fetch fails
+      }
       const url = await knowhowApiClient.getPresignedUploadUrl(source);
       console.log("Uploading to", url);
       await AwsS3.uploadToPresignedUrl(url, source.output);

package/src/plugins/embedding.ts

@@ -20,9 +20,12 @@ export class EmbeddingPlugin extends PluginBase {
 
   constructor(context) {
     super(context);
-    
+
     // Subscribe to file:post-edit events
-    this.context.Events.on("file:post-edit", this.handleFilePostEdit.bind(this));
+    this.context.Events.on(
+      "file:post-edit",
+      this.handleFilePostEdit.bind(this)
+    );
   }
 
   async embed() {
@@ -68,10 +71,12 @@ export class EmbeddingPlugin extends PluginBase {
       this.log(`Reading entry ${entry.id}`);
     }
 
-    const contextLength = JSON.stringify(context).split(" ").length;
+    const ids = context.map((entry) => entry.id);
+
+    const contextLength = JSON.stringify(ids).split(" ").length;
     this.log(`Found ${context.length} entries. Loading ${contextLength} words`);
 
-    return `EMBEDDING PLUGIN: Our knowledgebase contains this information which can be used to answer the question:
-    ${JSON.stringify(context)}`;
+    return `EMBEDDING PLUGIN: Our knowledgebase indicates these embedding entries may be related to the question:
+    ${JSON.stringify(ids)}`;
   }
-}
+}

package/src/plugins/vim.ts

@@ -73,22 +73,11 @@ export class VimPlugin extends PluginBase {
 
   async call() {
     const vimFiles = await this.getVimFiles();
-    const fileContents = await Promise.all(
-      vimFiles.map(async (f) => {
-        const loaded = await this.getFileContents(f);
-
-        const preview =
-          loaded.content.length > 1000
-            ? loaded.content.slice(0, 1000) +
-              "... file trimmed, read file for full content"
-            : loaded.content;
-
-        return {
-          sourceFile: loaded.filePath,
-          content: loaded.content.slice(0, 1000),
-        };
-      })
-    );
+    const fileContents = vimFiles.map((f) => {
+      return {
+        sourceFile: f,
+      };
+    });
     if (fileContents.length === 0) {
       return "VIM PLUGIN: No files open in vim";
     }

package/src/services/KnowhowClient.ts

@@ -171,11 +171,9 @@ export class KnowhowSimpleClient {
       try {
         this.jwtValidated = true;
         const response = await this.me();
-
         const user = response.data.user;
         const orgs = user.orgs;
         const orgId = response.data.orgId;
-
         const currentOrg = orgs.find((org) => {
           return org.organizationId === orgId;
         });
@@ -227,6 +225,17 @@ export class KnowhowSimpleClient {
     return presignedUrl;
   }
 
+  async getOrgEmbedding(id: string) {
+    await this.checkJwt();
+    const resp = await http.get(
+      `${this.baseUrl}/api/org-embeddings/${id}`,
+      {
+        headers: this.headers,
+      }
+    );
+    return resp.data as { id: string; modelName: string; name: string; [key: string]: unknown };
+  }
+
   async updateEmbeddingMetadata(
     id: string,
     data: {
@@ -718,6 +727,17 @@ export class KnowhowSimpleClient {
     );
   }
 
+  /**
+   * Get a single cloud worker by ID
+   */
+  async getCloudWorker(id: string) {
+    await this.checkJwt();
+    return http.get<{ id: string; name: string; status: string; workerConfigJson?: Record<string, unknown> }>(
+      `${this.baseUrl}/api/cloud-workers/${id}`,
+      { headers: this.headers }
+    );
+  }
+
   /**
    * Update an existing cloud worker
    */

package/src/services/S3.ts

@@ -1,5 +1,6 @@
 import * as fs from "fs";
 import { createWriteStream, createReadStream } from "fs";
+import * as crypto from "crypto";
 import { pipeline, Readable } from "stream";
 import * as util from "util";
 
@@ -14,10 +15,19 @@ export class S3Service {
       const fileContent = fs.readFileSync(filePath);
       const fileStats = await fs.promises.stat(filePath);
 
+      // Compute SHA-256 checksum (base64) — required when presigned URL was
+      // generated with ChecksumAlgorithm: SHA256
+      const sha256Base64 = crypto
+        .createHash("sha256")
+        .update(fileContent)
+        .digest("base64");
+
       const response = await fetch(presignedUrl, {
         method: "PUT",
         headers: {
           "Content-Length": String(fileStats.size),
+          "x-amz-checksum-sha256": sha256Base64,
+          "x-amz-sdk-checksum-algorithm": "SHA256",
         },
         body: fileContent,
         // @ts-ignore

package/src/services/modules/types.ts

@@ -9,6 +9,7 @@ import { PluginService } from "../../plugins/plugins";
 import { AIClient } from "../../clients";
 import { ToolsService } from "../Tools";
 import { MediaProcessorService } from "../MediaProcessorService";
+import { TunnelHandler } from "@tyvm/knowhow-tunnel";
 
 /*
  *
@@ -53,6 +54,7 @@ export interface ModuleContext {
   Clients: AIClient;
   Tools: ToolsService;
   MediaProcessor?: MediaProcessorService;
+  Tunnel?: TunnelHandler;
 }
 
 export interface KnowhowModule {

package/src/worker.ts

@@ -6,7 +6,7 @@ import { loadJwt } from "./login";
 import { services } from "./services";
 import { PasskeySetupService } from "./workers/auth/PasskeySetup";
 import { WorkerPasskeyAuthService } from "./workers/auth/WorkerPasskeyAuth";
-import { makeUnlockTool, makeLockTool } from "./workers/tools";
+import { makeUnlockTool, makeLockTool, makeReloadConfigTool } from "./workers/tools";
 import { McpServerService } from "./services/Mcp";
 import * as allTools from "./agents/tools";
 import workerTools from "./workers/tools";
@@ -14,6 +14,7 @@ import { wait } from "./utils";
 import { getConfig, updateConfig } from "./config";
 import { KNOWHOW_API_URL } from "./services/KnowhowClient";
 import { registerWorkerPath } from "./workerRegistry";
+import { ModulesService } from "./services/modules";
 
 const API_URL = KNOWHOW_API_URL;
 
@@ -264,6 +265,22 @@ export async function worker(options?: {
     console.log("🔑 Auth tools registered: unlock, lock");
   }
 
+  // Register the reloadConfig tool so agents can hot-reload MCPs/config
+  // without restarting the worker process.
+  // Uses a closure over `toolsToUse` so the tool can update it in-place.
+  const { reloadConfig, reloadConfigDefinition } = makeReloadConfigTool(
+    Mcp,
+    Tools,
+    mcpServer,
+    (newTools) => {
+      toolsToUse = newTools;
+    }
+  );
+  Tools.addFunctions({ reloadConfig });
+  toolsToUse = [...toolsToUse, reloadConfigDefinition];
+
+  console.log("🔄 reloadConfig tool registered");
+
   mcpServer.createServer(clientName, clientVersion).withTools(toolsToUse);
 
   let connected = false;
@@ -403,6 +420,33 @@ export async function worker(options?: {
             console.log(`✅ Worker ID recorded: ${parsed.workerId}`);
           }
         }
+
+        // Hot-reload: re-read config, reconnect MCPs, and rebuild the tool list
+        // without restarting the worker process.
+        if (parsed?.type === "reloadConfig") {
+          console.log("🔄 Received reloadConfig — reloading MCPs, modules and tools...");
+          try {
+            // Re-read fresh config from disk
+            const freshConfig = await getConfig();
+
+            // Close all existing MCP connections
+            await Mcp.closeAll();
+
+            // Reconnect from fresh config and re-register tools
+            await Mcp.connectToConfigured(Tools);
+
+            // Rebuild the allowed tools list from fresh config
+            const allowedToolNames = freshConfig.worker?.allowedTools ?? Tools.getToolNames();
+            toolsToUse = Tools.getToolsByNames(allowedToolNames);
+
+            // Update the MCP server with new tool list
+            mcpServer.withTools(toolsToUse);
+
+            console.log(`✅ Config reloaded: ${toolsToUse.length} tools active`);
+          } catch (err) {
+            console.error("❌ Failed to reload config:", err);
+          }
+        }
       } catch {
         // Not our message — ignore parse errors
       }
@@ -462,6 +506,16 @@ export async function worker(options?: {
         tunnelHandler = createTunnelHandler(tunnelConnection!, tunnelConfig);
         console.log("🌐 Tunnel handler initialized");
         console.log(tunnelConfig);
+
+        // Let modules that need the tunnel handler register their addons now
+        const tunnelModulesService = new ModulesService();
+        const { Agents, Embeddings, Plugins, Clients, Tools, MediaProcessor } = services();
+        tunnelModulesService.loadModulesFromConfig({
+          Agents, Embeddings, Plugins, Clients, Tools, MediaProcessor,
+          Tunnel: tunnelHandler,
+        }).catch((err) => {
+          console.error("Failed to load tunnel modules:", err);
+        });
       });
 
       tunnelConnection.on("close", (code, reason) => {
@@ -708,6 +762,16 @@ export async function tunnel(options?: {
       tunnelHandler = createTunnelHandler(tunnelConnection, tunnelConfig);
       console.log("🌐 Tunnel handler initialized");
       console.log(tunnelConfig);
+
+      // Let modules that need the tunnel handler register their addons now
+      const tunnelModulesService2 = new ModulesService();
+      const { Agents: A2, Embeddings: E2, Plugins: P2, Clients: C2, Tools: T2, MediaProcessor: MP2 } = services();
+      tunnelModulesService2.loadModulesFromConfig({
+        Agents: A2, Embeddings: E2, Plugins: P2, Clients: C2, Tools: T2, MediaProcessor: MP2,
+        Tunnel: tunnelHandler,
+      }).catch((err) => {
+        console.error("Failed to load tunnel modules:", err);
+      });
     });
 
     tunnelConnection.on("close", (code, reason) => {

package/src/workers/tools/index.ts

@@ -2,6 +2,7 @@ export * from "./listAllowedPorts";
 export * from "./getChallenge";
 export * from "./unlock";
 export * from "./lock";
+export * from "./reloadConfig";
 
 import {
   listAllowedPorts,
@@ -11,6 +12,7 @@ import {
 export { makeGetChallengeTool } from "./getChallenge";
 export { makeUnlockTool } from "./unlock";
 export { makeLockTool } from "./lock";
+export { makeReloadConfigTool } from "./reloadConfig";
 
 export default {
   tools: { listAllowedPorts },

package/src/workers/tools/reloadConfig.ts

@@ -0,0 +1,84 @@
+import { Tool } from "../../clients/types";
+import { getConfig } from "../../config";
+import { McpServerService } from "../../services/McpServer";
+import { McpService } from "../../services/Mcp";
+import { ToolsService } from "../../services/Tools";
+
+export interface ReloadConfigResult {
+  success: boolean;
+  toolCount: number;
+  mcpCount: number;
+  message: string;
+}
+
+/**
+ * Factory that creates the reloadConfig tool with access to runtime services.
+ * The tool re-reads the config from disk, reconnects all MCPs, and rebuilds
+ * the active tool list — the same logic as the WebSocket reloadConfig handler.
+ *
+ * Typical usage after pulling updated config from the cloud worker API:
+ *   1. execCommand("knowhow cloudworker --pull <cloudWorkerId>")
+ *   2. reloadConfig()
+ */
+export function makeReloadConfigTool(
+  Mcp: McpService,
+  Tools: ToolsService,
+  mcpServer: McpServerService,
+  setToolsToUse: (tools: ReturnType<typeof Tools.getToolsByNames>) => void
+) {
+  const reloadConfig = async (): Promise<ReloadConfigResult> => {
+    try {
+      // Re-read fresh config from disk
+      const freshConfig = await getConfig();
+
+      // Close all existing MCP connections
+      await Mcp.closeAll();
+
+      // Reconnect from fresh config and re-register tools
+      await Mcp.connectToConfigured(Tools);
+
+      // Rebuild the allowed tools list from fresh config
+      const allowedToolNames =
+        freshConfig.worker?.allowedTools ?? Tools.getToolNames();
+      const newToolsToUse = Tools.getToolsByNames(allowedToolNames);
+      setToolsToUse(newToolsToUse);
+
+      // Update the MCP server with the new tool list
+      mcpServer.withTools(newToolsToUse);
+
+      const mcpCount = freshConfig.mcps?.length ?? 0;
+
+      return {
+        success: true,
+        toolCount: newToolsToUse.length,
+        mcpCount,
+        message: `Config reloaded: ${newToolsToUse.length} tools active, ${mcpCount} MCP(s) configured`,
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        toolCount: 0,
+        mcpCount: 0,
+        message: `Failed to reload config: ${message}`,
+      };
+    }
+  };
+
+  const reloadConfigDefinition: Tool = {
+    type: "function" as const,
+    function: {
+      name: "reloadConfig",
+      description:
+        "Reload the worker config from disk, reconnect all MCPs, and rebuild the active tool list. " +
+        "Call this after running `knowhow cloudworker --pull <id>` to apply updated MCPs without restarting the worker.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+      },
+    },
+  };
+
+  return { reloadConfig, reloadConfigDefinition };
+}

package/tests/services/WorkerReloadConfig.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Tests for the worker reloadConfig message handler.
+ *
+ * We test the core logic in isolation — simulating the "reloadConfig" message
+ * arriving on the WebSocket and verifying that MCPs are torn down and
+ * re-connected, and that the tool list is rebuilt from fresh config.
+ */
+
+import { McpService } from "../../src/services/Mcp";
+import { ToolsService } from "../../src/services/Tools";
+
+// ---------------------------------------------------------------------------
+// Helpers: build the same reload logic that lives in worker.ts so we can
+// test it in isolation without spinning up a real WebSocket server.
+// ---------------------------------------------------------------------------
+
+async function simulateReloadConfig(
+  Mcp: McpService,
+  Tools: ToolsService,
+  mcpServer: { withTools: (tools: unknown[]) => void },
+  getConfig: () => Promise<{ worker?: { allowedTools?: string[] } }>,
+  toolsToUseRef: { value: unknown[] }
+) {
+  // This mirrors the handler in worker.ts
+  const freshConfig = await getConfig();
+  await Mcp.closeAll();
+  await Mcp.connectToConfigured(Tools);
+  const allowedToolNames =
+    freshConfig.worker?.allowedTools ?? Tools.getToolNames();
+  toolsToUseRef.value = Tools.getToolsByNames(allowedToolNames);
+  mcpServer.withTools(toolsToUseRef.value);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("Worker reloadConfig handler", () => {
+  let Mcp: McpService;
+  let Tools: ToolsService;
+  let mcpServer: { withTools: jest.Mock };
+  let toolsToUseRef: { value: unknown[] };
+
+  beforeEach(() => {
+    Mcp = new McpService();
+    Tools = new ToolsService();
+    mcpServer = { withTools: jest.fn() };
+    toolsToUseRef = { value: [] };
+
+    // Spy on MCP methods
+    jest.spyOn(Mcp, "closeAll").mockResolvedValue(undefined);
+    jest.spyOn(Mcp, "connectToConfigured").mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("should call closeAll() to tear down existing MCP connections", async () => {
+    const getConfig = jest
+      .fn()
+      .mockResolvedValue({ worker: { allowedTools: [] } });
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(Mcp.closeAll).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call connectToConfigured() to reconnect MCPs from fresh config", async () => {
+    const getConfig = jest
+      .fn()
+      .mockResolvedValue({ worker: { allowedTools: [] } });
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(Mcp.connectToConfigured).toHaveBeenCalledWith(Tools);
+  });
+
+  it("should rebuild the tool list from allowedTools in fresh config", async () => {
+    // Spy on getToolsByNames so we can track what names were requested
+    const toolsByNamesSpy = jest
+      .spyOn(Tools, "getToolsByNames")
+      .mockReturnValue([{ function: { name: "execCommand" } }] as ReturnType<ToolsService["getToolsByNames"]>);
+
+    const getConfig = jest
+      .fn()
+      .mockResolvedValue({ worker: { allowedTools: ["execCommand"] } });
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(toolsByNamesSpy).toHaveBeenCalledWith(["execCommand"]);
+    expect(toolsToUseRef.value).toHaveLength(1);
+  });
+
+  it("should fall back to all tool names when allowedTools is not set", async () => {
+    const allNames = ["execCommand", "readFile", "writeFileChunk"];
+    jest.spyOn(Tools, "getToolNames").mockReturnValue(allNames);
+    const toolsByNamesSpy = jest
+      .spyOn(Tools, "getToolsByNames")
+      .mockReturnValue([] as ReturnType<ToolsService["getToolsByNames"]>);
+
+    // Config has no worker.allowedTools
+    const getConfig = jest.fn().mockResolvedValue({});
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(toolsByNamesSpy).toHaveBeenCalledWith(allNames);
+  });
+
+  it("should call mcpServer.withTools() with the rebuilt tool list", async () => {
+    const fakeTools = [{ function: { name: "readFile" } }] as ReturnType<ToolsService["getToolsByNames"]>;
+    jest.spyOn(Tools, "getToolsByNames").mockReturnValue(fakeTools);
+
+    const getConfig = jest
+      .fn()
+      .mockResolvedValue({ worker: { allowedTools: ["readFile"] } });
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(mcpServer.withTools).toHaveBeenCalledWith(fakeTools);
+  });
+
+  it("should re-read the config on every reload (not use stale config)", async () => {
+    const getConfig = jest
+      .fn()
+      .mockResolvedValueOnce({ worker: { allowedTools: ["execCommand"] } })
+      .mockResolvedValueOnce({ worker: { allowedTools: ["readFile", "writeFileChunk"] } });
+
+    jest.spyOn(Tools, "getToolsByNames").mockReturnValue([]);
+
+    // First reload
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+    // Second reload
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(getConfig).toHaveBeenCalledTimes(2);
+    // Each reload should tear down and reconnect
+    expect(Mcp.closeAll).toHaveBeenCalledTimes(2);
+    expect(Mcp.connectToConfigured).toHaveBeenCalledTimes(2);
+  });
+});

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.107",
+    "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/ts_build/src/agents/base/base.js

@@ -486,6 +486,7 @@ class BaseAgent {
                 messages,
                 tools: this.getEnabledTools(),
                 tool_choice: "auto",
+                long_ttl_cache: this.runTime() > 300_000,
             });
             if (this.status === this.eventTypes.pause) {
                 this.log("Agent was paused after completion, waiting before processing tool calls");