@tyvm/knowhow 0.0.80 → 0.0.82

package/package.json

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

package/src/agents/base/base.ts

@@ -480,7 +480,7 @@ export abstract class BaseAgent implements IAgent {
     } as Message);
   }
 
-  async call(userInput: string | MessageContent[], _messages?: Message[]) {
+  async call(userInput: string | MessageContent[], _messages?: Message[], retryCount = 0) {
     if (this.status === this.eventTypes.notStarted) {
       this.status = this.eventTypes.inProgress;
     }
@@ -704,7 +704,32 @@ export abstract class BaseAgent implements IAgent {
     } catch (e) {
       if (e.toString().includes("429")) {
         this.setNotHealthy();
-        return this.call(userInput, _messages);
+        return this.call(userInput, _messages, retryCount);
+      const errorStr = e.toString();
+      const isNonRetriable =
+        errorStr.includes("401") ||
+        errorStr.includes("403") ||
+        errorStr.includes("404");
+
+      const isRetriable =
+        !isNonRetriable &&
+        (errorStr.match(/5\d\d/) ||
+          errorStr.includes("Failed to get models") ||
+          errorStr.includes("timeout") ||
+          errorStr.includes("ECONNRESET") ||
+          errorStr.includes("ETIMEDOUT") ||
+          errorStr.includes("Invalid response format from MCP"));
+
+      if (isRetriable && retryCount < 3) {
+        const delay = 1000 * Math.pow(2, retryCount);
+        console.warn(
+          `Agent request failed (attempt ${retryCount + 1}/3), retrying in ${delay}ms...`,
+          e.message
+        );
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return this.call(userInput, _messages, retryCount + 1);
+      }
+
       }
 
       console.error("Agent failed", e);

package/src/agents/tools/startAgentTask.ts

@@ -6,6 +6,8 @@ import { spawn } from "child_process";
 interface StartAgentTaskParams {
   messageId?: string;
   syncFs?: boolean;
+  taskId?: string;
+  resume?: boolean;
   prompt: string;
   provider?: string;
   model?: string;
@@ -51,6 +53,8 @@ export async function startAgentTask(params: StartAgentTaskParams): Promise<stri
   const {
     messageId,
     prompt,
+    taskId: providedTaskId,
+    resume,
     syncFs,
     provider,
     model,
@@ -62,8 +66,8 @@ export async function startAgentTask(params: StartAgentTaskParams): Promise<stri
     throw new Error("prompt is required to create a chat task");
   }
 
-  // Pre-generate taskId so we can return the agents dir path to the caller
-  const taskId = generateTaskId(prompt);
+  // Use provided taskId if given, otherwise generate one from the prompt
+  const taskId = providedTaskId ?? generateTaskId(prompt);
   const agentTaskDir = path.join(AGENTS_DIR, taskId);
 
   // Build args array (no shell escaping needed - args are passed directly)
@@ -73,7 +77,10 @@ export async function startAgentTask(params: StartAgentTaskParams): Promise<stri
     args.push("--message-id", messageId);
   } else if (syncFs) {
     args.push("--sync-fs");
-    // Pass the pre-generated taskId so the agent dir path is predictable
+  }
+
+  if (syncFs || providedTaskId) {
+    // Pass --task-id whenever we have a known taskId (syncFs or explicit taskId)
     args.push("--task-id", taskId);
   }
 
@@ -96,6 +103,10 @@ export async function startAgentTask(params: StartAgentTaskParams): Promise<stri
   if (maxSpendLimit !== undefined) {
     args.push("--max-spend-limit", String(maxSpendLimit));
   }
+  if (resume) {
+    // --resume is a boolean flag; task ID is already passed via --task-id above
+    args.push("--resume");
+  }
 
   const timeoutMs = maxTimeLimit ? maxTimeLimit * 60 * 1000 : 60 * 60 * 1000;
 
@@ -211,6 +222,16 @@ export const startAgentTaskDefinition: Tool = {
           type: "number",
           description: "Cost limit for agent execution in dollars. Default: 10",
         },
+        taskId: {
+          type: "string",
+          description:
+            "Pre-generated task ID to use for this agent run. When provided with syncFs, the agent directory will use this ID for a predictable path. Required when using resume.",
+        },
+        resume: {
+          type: "boolean",
+          description:
+            "Resume a previously started task from where it left off. Must be used together with taskId which identifies the task to resume.",
+        },
       },
       required: ["prompt"],
     },

package/src/chat/modules/AgentModule.ts

@@ -8,12 +8,14 @@ import {
   TaskRegistry,
 } from "../../services/index";
 import * as fs from "fs";
+import * as fsPromises from "fs/promises";
 import * as path from "path";
 
 import { BaseChatModule } from "./BaseChatModule";
 import { services } from "../../services/index";
 import { BaseAgent } from "../../agents/index";
 import { ChatCommand, ChatMode, ChatContext, ChatService } from "../types";
+import { Message } from "../../clients/types";
 import { ChatInteraction } from "../../types";
 import { Marked } from "../../utils/index";
 import { TokenCompressor } from "../../processors/TokenCompressor";
@@ -28,6 +30,7 @@ import { TaskInfo, ChatSession } from "../types";
 import { agents } from "../../agents";
 import { ToolCallEvent } from "../../agents/base/base";
 import { $Command } from "@aws-sdk/client-s3";
+import { KnowhowSimpleClient } from "../../services/KnowhowClient";
 
 export class AgentModule extends BaseChatModule {
   name = "agent";
@@ -668,7 +671,10 @@ Please continue from where you left off and complete the original request.
           done = true;
           output = doneMsg || "No response from the AI";
           // Remove threadUpdate listener to prevent cost sharing across tasks
-          agent.agentEvents.removeListener(agent.eventTypes.threadUpdate, threadUpdateHandler);
+          agent.agentEvents.removeListener(
+            agent.eventTypes.threadUpdate,
+            threadUpdateHandler
+          );
           // Update task info
           taskInfo = this.taskRegistry.get(taskId);
 
@@ -732,6 +738,117 @@ Please continue from where you left off and complete the original request.
     }
   }
 
+  public async loadThreadsForTask(taskId: string, messageId?: string) {
+    const resumeTaskId: string = taskId;
+    const localMetadataPath = path.join(
+      ".knowhow",
+      "processes",
+      "agents",
+      resumeTaskId,
+      "metadata.json"
+    );
+
+    let threads: Message[][] = [];
+
+    // Try local FS first
+    if (!messageId && fs.existsSync(localMetadataPath)) {
+      try {
+        const raw = await fsPromises.readFile(localMetadataPath, "utf-8");
+        const metadata = JSON.parse(raw);
+        threads = metadata.threads || [];
+        console.log(`📁 Loaded threads from local FS: ${localMetadataPath}`);
+      } catch (e) {
+        console.warn(`⚠️ Failed to parse local metadata: ${e.message}`);
+      }
+    } else {
+      // Try remote via KnowhowSimpleClient
+      try {
+        const client = new KnowhowSimpleClient();
+        threads = await client.getTaskThreads(resumeTaskId);
+        console.log(`🌐 Loaded threads from remote for task: ${resumeTaskId}`);
+      } catch (e) {
+        console.warn(`⚠️ Could not load threads from remote: ${e.message}`);
+      }
+    }
+
+    return threads;
+  }
+
+  /**
+   * Resume an agent from a set of existing message threads
+   * Used by the CLI --resume flag to continue crashed/failed tasks
+   */
+  public async resumeFromMessages(options: {
+    agentName: string;
+    input: string;
+    threads: Message[][];
+    messageId?: string;
+    taskId?: string;
+  }): Promise<{ taskCompleted: Promise<string> }> {
+    const { agentName, input, threads, messageId, taskId } = options;
+
+    // Try to extract the original request from the first user message in threads
+    let originalRequest = "";
+    if (threads && threads.length > 0) {
+      const firstThread = threads[0];
+      if (Array.isArray(firstThread)) {
+        const firstUserMsg = firstThread.find(
+          (m: any) => m.role === "user" && m.content
+        );
+        if (firstUserMsg) {
+          originalRequest =
+            typeof firstUserMsg.content === "string"
+              ? firstUserMsg.content
+              : JSON.stringify(firstUserMsg.content);
+        }
+      }
+    }
+
+    // Build the resume prompt
+    const resumePrompt = [
+      "You are resuming a previously started task.",
+      originalRequest ? `ORIGINAL REQUEST: ${originalRequest}` : "",
+      "Please continue from where you left off.",
+      input ? input : "",
+    ]
+      .filter(Boolean)
+      .join("\n");
+
+    // Flatten threads into a single messages array for the agent
+    const lastThread =
+      threads && threads.length > 0 ? threads[threads.length - 1] : [];
+    const resumeMessages = [...lastThread];
+
+    // find last user message index
+    const resumeIndex = lastThread
+      .reverse()
+      .findIndex((e) => e.role === "user" && typeof e.content === "string");
+
+    if (resumeIndex === -1) {
+      resumeMessages.push({
+        role: "user",
+        content: resumePrompt,
+      });
+    } else {
+      const actualIndex = lastThread.length - 1 - resumeIndex;
+      const lastUserMessage = resumeMessages[actualIndex];
+      lastUserMessage.content += `\n\n<Workflow>[RESUME CONTEXT]: ${resumePrompt}</Workflow>`;
+    }
+
+    const result = await this.setupAgent({
+      agentName,
+      input: resumePrompt,
+      messageId,
+      existingKnowhowTaskId: taskId,
+      run: false,
+    });
+
+    // Start agent with prior messages as context
+    result.agent.call(resumePrompt, resumeMessages);
+
+    return { taskCompleted: result.taskCompleted };
+  }
+
   /**
    * Get list of active agent tasks
    */

package/src/cli.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node --no-node-snapshot
 import "source-map-support/register";
 import * as fs from "fs";
+import * as fsPromises from "fs/promises";
 import * as path from "path";
 import * as os from "os";
 import { Command } from "commander";
@@ -39,7 +40,6 @@ import { SetupModule } from "./chat/modules/SetupModule";
 import { CliChatService } from "./chat/CliChatService";
 
 async function setupServices() {
-
   const { Agents, Mcp, Clients, Tools: OldTools } = services();
   const Tools = new LazyToolsService();
 
@@ -206,12 +206,42 @@ async function main() {
     )
     .option("--message-id <messageId>", "Knowhow message ID for task tracking")
     .option("--sync-fs", "Enable filesystem-based synchronization")
-    .option("--task-id <taskId>", "Pre-generated task ID (used with --sync-fs for predictable agent directory path)")
+    .option(
+      "--task-id <taskId>",
+      "Pre-generated task ID (used with --sync-fs for predictable agent directory path)"
+    )
     .option("--prompt-file <path>", "Custom prompt template file with {text}")
     .option("--input <text>", "Task input (fallback to stdin if not provided)")
+    .option(
+      "--resume",
+      "Resume a previously started task using the --task-id (local FS or remote)"
+    )
     .action(async (options) => {
       try {
         await setupServices();
+        const agentModule = new AgentModule();
+
+        // Handle --resume flag: load threads from local FS or remote using --task-id
+        if (options.resume) {
+          const threads = await agentModule.loadThreadsForTask(
+            options.taskId,
+            options.messageId
+          );
+          const resumeInput =
+            options.input || "Please continue from where you left off.";
+
+          await agentModule.initialize(chatService);
+          const { taskCompleted } = await agentModule.resumeFromMessages({
+            agentName: options.agentName || "Patcher",
+            input: resumeInput,
+            threads,
+            messageId: options.messageId,
+            taskId: options.taskId,
+          });
+          await taskCompleted;
+          return;
+        }
+
         let input = options.input;
 
         // Only read from stdin if we don't have input and don't have a standalone prompt file
@@ -230,7 +260,6 @@ async function main() {
           process.exit(1);
         }
 
-        const agentModule = new AgentModule();
         await agentModule.initialize(chatService);
         const { taskCompleted } = await agentModule.setupAgent({
           ...options,
@@ -372,7 +401,9 @@ async function main() {
 
   program
     .command("files")
-    .description("Sync files between local filesystem and Knowhow FS (uses fileMounts config)")
+    .description(
+      "Sync files between local filesystem and Knowhow FS (uses fileMounts config)"
+    )
     .option("--upload", "Force upload direction for all mounts")
     .option("--download", "Force download direction for all mounts")
     .option("--config <path>", "Path to knowhow.json", "./knowhow.json")
@@ -434,7 +465,10 @@ async function main() {
     .description(
       "Git credential helper for GitHub. Use as: git config credential.helper 'knowhow github-credentials'"
     )
-    .option("--repo <repo>", "Repository in owner/repo format (e.g. myorg/myrepo)")
+    .option(
+      "--repo <repo>",
+      "Repository in owner/repo format (e.g. myorg/myrepo)"
+    )
     .action(async (action: string | undefined, options: { repo?: string }) => {
       const client = new KnowhowSimpleClient();
 
@@ -447,7 +481,10 @@ async function main() {
         // Read from stdin (git sends protocol/host/username)
         const lines: string[] = [];
         const readline = await import("readline");
-        const rl = readline.createInterface({ input: process.stdin, terminal: false });
+        const rl = readline.createInterface({
+          input: process.stdin,
+          terminal: false,
+        });
         await new Promise<void>((resolve) => {
           rl.on("line", (line) => {
             if (line.trim()) lines.push(line.trim());

package/src/clients/http.ts

@@ -12,6 +12,41 @@ import path from "path";
 export class HttpClient implements GenericClient {
   constructor(private baseUrl: string, private headers = {}) {}
 
+  private async withRetry<T>(fn: () => Promise<T>, retries = 3): Promise<T> {
+    let lastError: any;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        return await fn();
+      } catch (e: any) {
+        lastError = e;
+        const errorStr = e.toString();
+        const isNonRetriable =
+          errorStr.includes("401") ||
+          errorStr.includes("403") ||
+          errorStr.includes("404") ||
+          errorStr.includes("429");
+        const isRetriable =
+          !isNonRetriable &&
+          (errorStr.match(/5\d\d/) ||
+            errorStr.includes("timeout") ||
+            errorStr.includes("ECONNRESET") ||
+            errorStr.includes("ETIMEDOUT") ||
+            errorStr.includes("Invalid response format from MCP") ||
+            errorStr.includes("Failed to get models"));
+        if (!isRetriable || attempt >= retries) {
+          throw e;
+        }
+        const delay = 1000 * Math.pow(2, attempt);
+        console.warn(
+          `HTTP request failed (attempt ${attempt + 1}/${retries}), retrying in ${delay}ms...`,
+          e.message
+        );
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError;
+  }
+
   setJwt(jwt: string) {
     this.headers = {
       ...this.headers,
@@ -43,85 +78,91 @@ export class HttpClient implements GenericClient {
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
-    const body = {
-      ...options,
-      model: options.model,
-      messages: options.messages,
-      max_tokens: options.max_tokens || 3000,
-
-      ...(options.tools && {
-        tools: options.tools,
-        tool_choice: "auto",
-      }),
-    };
-
-    const response = await axios.post(
-      `${this.baseUrl}/v1/chat/completions`,
-      body,
-      {
-        headers: this.headers,
+    return this.withRetry(async () => {
+      const body = {
+        ...options,
+        model: options.model,
+        messages: options.messages,
+        max_tokens: options.max_tokens || 3000,
+
+        ...(options.tools && {
+          tools: options.tools,
+          tool_choice: "auto",
+        }),
+      };
+
+      const response = await axios.post(
+        `${this.baseUrl}/v1/chat/completions`,
+        body,
+        {
+          headers: this.headers,
+        }
+      );
+
+      const data = response.data;
+
+      // Since this uses a keepalive, we need to detect 200 with error in body
+      if (data.error) {
+        throw new Error(JSON.stringify(data.error, null, 2));
       }
-    );
-
-    const data = response.data;
-
-    // Since this uses a keepalive, we need to detect 200 with error in body
-    if (data.error) {
-      throw new Error(JSON.stringify(data.error, null, 2));
-    }
 
-    return {
-      choices: data.choices.map((choice: any) => ({
-        message: {
-          role: choice.message.role,
-          content: choice.message.content,
-          tool_calls: choice.message.tool_calls,
-        },
-      })),
-      model: data.model,
-      usage: data.usage,
-      usd_cost: data.usd_cost,
-    };
+      return {
+        choices: data.choices.map((choice: any) => ({
+          message: {
+            role: choice.message.role,
+            content: choice.message.content,
+            tool_calls: choice.message.tool_calls,
+          },
+        })),
+        model: data.model,
+        usage: data.usage,
+        usd_cost: data.usd_cost,
+      };
+    });
   }
 
   async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
-    const response = await axios.post(
-      `${this.baseUrl}/v1/embeddings`,
-      {
-        model: options.model,
-        input: options.input,
-      },
-      {
-        headers: this.headers,
-      }
-    );
+    return this.withRetry(async () => {
+      const response = await axios.post(
+        `${this.baseUrl}/v1/embeddings`,
+        {
+          model: options.model,
+          input: options.input,
+        },
+        {
+          headers: this.headers,
+        }
+      );
 
-    const data = response.data;
+      const data = response.data;
 
-    // Since this uses a keepalive, we need to detect 200 with error in body
-    if (data.error) {
-      throw new Error(JSON.stringify(data.error, null, 2));
-    }
+      // Since this uses a keepalive, we need to detect 200 with error in body
+      if (data.error) {
+        throw new Error(JSON.stringify(data.error, null, 2));
+      }
 
-    return {
-      data: data.data,
-      model: options.model,
-      usage: data.usage,
-      usd_cost: data.usd_cost,
-    };
+      return {
+        data: data.data,
+        model: options.model,
+        usage: data.usage,
+        usd_cost: data.usd_cost,
+      };
+    });
   }
 
   async getModels() {
-    const response = await axios.get(`${this.baseUrl}/v1/models`, {
-      headers: this.headers,
-    });
+    return this.withRetry(async () => {
+      const response = await axios.get(`${this.baseUrl}/v1/models`, {
+        headers: this.headers,
+      });
 
-    const data = response.data?.data;
+      const data = response.data?.data;
 
-    return data.map((model: any) => ({
-      id: model.id,
-      object: model.object,
-      owned_by: model.owned_by,
-    }));
+      return data.map((model: any) => ({
+        id: model.id,
+        object: model.object,
+        owned_by: model.owned_by,
+      }));
+    });
   }
 }

package/src/index.ts

@@ -135,6 +135,14 @@ export async function upload() {
       const url = await knowhowApiClient.getPresignedUploadUrl(source);
       console.log("Uploading to", url);
       await AwsS3.uploadToPresignedUrl(url, source.output);
+      // Sync config metadata back to the backend DB
+      await knowhowApiClient.updateEmbeddingMetadata(source.remoteId, {
+        inputGlob: source.input,
+        outputPath: source.output,
+        chunkSize: source.chunkSize,
+        remoteType: source.remoteType,
+      });
+      console.log("Synced metadata for", source.remoteId);
     } else {
       console.log(
         "Skipping upload to",
@@ -376,6 +384,9 @@ export async function download() {
       const preSignedUrl = await knowhowApiClient.getPresignedDownloadUrl(
         source
       );
+      // Ensure output directory exists
+      const outputDir = path.dirname(destinationPath);
+      if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
       await AwsS3.downloadFromPresignedUrl(preSignedUrl, destinationPath);
     } else {
       console.log("Unsupported remote type for", source.output);

package/src/login.ts

@@ -111,9 +111,5 @@ export async function checkJwt(storedJwt: string) {
     return org.organizationId === orgId;
   });
 
-  console.log(
-    `Current user: ${user.email}, \nOrganization: ${currentOrg?.organization?.name} - ${orgId}`
-  );
-
   return { user, currentOrg };
 }

package/src/services/KnowhowClient.ts

@@ -53,7 +53,7 @@ export interface TaskDetailsResponse {
   inProgress: boolean;
   status: "running" | "paused" | "killed" | "completed";
   totalUsdCost: number;
-  threads: any;
+  threads: any[][];
   createdAt: string;
   updatedAt: string;
   messageId?: string;
@@ -192,6 +192,25 @@ export class KnowhowSimpleClient {
     return presignedUrl;
   }
 
+  async updateEmbeddingMetadata(
+    id: string,
+    data: {
+      inputGlob?: string;
+      outputPath?: string;
+      chunkSize?: number;
+      remoteType?: string;
+    }
+  ) {
+    await this.checkJwt();
+    return axios.put(
+      `${this.baseUrl}/api/org-embeddings/${id}`,
+      data,
+      {
+        headers: this.headers,
+      }
+    );
+  }
+
   async createChatCompletion(options: CompletionOptions) {
     await this.checkJwt();
     return axios.post<CompletionResponse>(
@@ -431,6 +450,14 @@ export class KnowhowSimpleClient {
     );
   }
 
+  /**
+   * Get threads from a task by task ID
+   */
+  async getTaskThreads(taskId: string): Promise<any[][]> {
+    const response = await this.getTaskDetails(taskId);
+    return response.data.threads || [];
+  }
+
   /**
    * Kill/cancel a running or paused agent task
    */

package/src/services/McpWebsocketTransport.ts

@@ -29,7 +29,13 @@ export class MCPWebSocketTransport implements Transport {
         }
         console.log("MCPW Message received", JSON.stringify(parsed));
         const message = JSONRPCMessageSchema.parse(parsed);
-        this.onmessage?.(message);
+        // Process message asynchronously to avoid blocking the WebSocket
+        // event loop while a long-running tool call is in progress.
+        // Without this, all subsequent messages are queued until the
+        // current tool call completes.
+        setImmediate(() => {
+          this.onmessage?.(message);
+        });
       } catch (error) {
         this.onerror?.(error as Error);
       }

package/ts_build/package.json

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