@tyvm/knowhow 0.0.80 → 0.0.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.80",
+  "version": "0.0.81",
   "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

@@ -732,6 +732,65 @@ Please continue from where you left off and complete the original request.
     }
   }
 
+  /**
+   * 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: any[][];
+    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 flattenedMessages = threads.flat();
+
+    const result = await this.setupAgent({
+      agentName,
+      input: resumePrompt,
+      messageId,
+      existingKnowhowTaskId: taskId,
+      run: false,
+    });
+
+    // Start agent with prior messages as context
+    result.agent.call(resumePrompt, flattenedMessages as any);
+
+    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";
@@ -209,9 +210,61 @@ async function main() {
     .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();
+
+        // Handle --resume flag: load threads from local FS or remote using --task-id
+        if (options.resume && options.taskId) {
+          const resumeTaskId: string = options.taskId;
+          const localMetadataPath = path.join(
+            ".knowhow",
+            "processes",
+            "agents",
+            resumeTaskId,
+            "metadata.json"
+          );
+
+          let threads: any[][] = [];
+
+          // Try local FS first
+          if (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}`);
+            }
+          }
+
+          const resumeInput =
+            options.input || "Please continue from where you left off.";
+
+          const agentModule = new AgentModule();
+          await agentModule.initialize(chatService);
+          const { taskCompleted } = await agentModule.resumeFromMessages({
+            agentName: options.agentName || "Patcher",
+            input: resumeInput,
+            threads,
+            messageId: options.messageId,
+            taskId: resumeTaskId,
+          });
+          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

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/ts_build/package.json

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

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

@@ -115,7 +115,7 @@ export declare abstract class BaseAgent implements IAgent {
     unpause(): void;
     unpaused(): Promise<unknown>;
     kill(): Promise<void>;
-    call(userInput: string | MessageContent[], _messages?: Message[]): any;
+    call(userInput: string | MessageContent[], _messages?: Message[], retryCount?: number): any;
     getStatusMessage(): string;
     logStatus(): void;
     addPendingMessage(message: Message): void;

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

@@ -345,7 +345,7 @@ class BaseAgent {
             content: `<Workflow>The user has requested the task to end, please call ${this.requiredToolNames} with a report of your ending state</Workflow>`,
         });
     }
-    async call(userInput, _messages) {
+    async call(userInput, _messages, retryCount = 0) {
         if (this.status === this.eventTypes.notStarted) {
             this.status = this.eventTypes.inProgress;
         }
@@ -475,7 +475,24 @@ class BaseAgent {
         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);
             if ("response" in e && "data" in e.response) {