@tyvm/knowhow 0.0.120 → 0.0.121

package/package.json

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

package/src/agents/base/base.ts

@@ -668,11 +668,15 @@ export abstract class BaseAgent implements IAgent {
     promise: Promise<T>,
     interruptValue: T
   ): Promise<T> {
-    return new Promise<T>((resolve) => {
+    return new Promise<T>((resolve, reject) => {
+      let interrupted = false;
+
       this._interruptResolve = (value: any) => {
+        interrupted = true;
         this._interruptResolve = null;
         resolve(value);
       };
+
       promise.then((result) => {
         if (this._interruptResolve) {
           this._interruptResolve = null;
@@ -681,7 +685,13 @@ export abstract class BaseAgent implements IAgent {
       }).catch((err) => {
         if (this._interruptResolve) {
           this._interruptResolve = null;
+        }
+        // Only swallow the error if interrupt() was explicitly called.
+        // Otherwise re-throw so callers see the real error.
+        if (interrupted) {
           resolve(interruptValue);
+        } else {
+          reject(err);
         }
       });
     });

package/src/cli.ts

@@ -37,6 +37,7 @@ import {
   addGithubCredentialsCommand,
 } from "./commands/misc";
 import { addConvertCommand } from "./commands/convert";
+import { addReplayCommand } from "./commands/replay";
 
 // Handle unhandled promise rejections gracefully — particularly from MCP SDK
 // which fires errors via event emitters that can bypass Promise.allSettled.
@@ -100,6 +101,7 @@ async function main() {
   addModulesCommand(program);
   addMcpCommands(program);
   addConvertCommand(program);
+  addReplayCommand(program);
 
   // Load global modules early (before parse) so they can register CLI subcommands.
   // We pass only the Program in context — no services are spun up at this stage.

package/src/clients/fireworks.ts

@@ -1,5 +1,8 @@
 import { HttpClient } from "./http";
 import { FireworksTextPricing } from "./pricing/fireworks";
+import { CompletionOptions, CompletionResponse } from "./types";
+
+type ModelInfo = { id: string; object: string; owned_by: string };
 
 /**
  * Fireworks AI client — OpenAI-compatible API (fast serverless inference)
@@ -12,4 +15,55 @@ export class GenericFireworksClient extends HttpClient {
     if (apiKey) this.setJwt(apiKey);
     this.setPrices(FireworksTextPricing);
   }
+
+  /**
+   * Supplement the live /v1/models response with any models we have in the
+   * pricing table. The Fireworks API sometimes doesn't return newly-released
+   * models (e.g. minimax-m3, kimi-k2p7-code) even though they are available
+   * for inference — so we use the pricing map as the source of truth for
+   * "models we know exist on this provider".
+   */
+  async getModels(type = "all"): Promise<ModelInfo[]> {
+    let liveModels: ModelInfo[] = [];
+    try {
+      liveModels = await super.getModels(type);
+    } catch (_err) {
+      // Live API call failed — fall back to pricing map only
+    }
+
+    const liveIds = new Set(liveModels.map((m) => m.id));
+    const pricingModels: ModelInfo[] = Object.keys(FireworksTextPricing)
+      .filter((id) => !liveIds.has(id))
+      .map((id) => ({ id, object: "model", owned_by: "fireworks" }));
+
+    return [...liveModels, ...pricingModels];
+  }
+
+  /**
+   * Sanitize the request before sending to Fireworks.
+   * Some models (e.g. kimi-k2p7-code) reject extra fields like:
+   *   - tools[N].function.returns  (non-standard extension)
+   *   - long_ttl_cache             (Anthropic-specific cache flag)
+   */
+  async createChatCompletion(
+    options: CompletionOptions
+  ): Promise<CompletionResponse> {
+    const sanitized: CompletionOptions = {
+      ...options,
+      // Strip Anthropic-specific field not accepted by Fireworks
+      long_ttl_cache: undefined,
+    };
+
+    if (sanitized.tools) {
+      sanitized.tools = sanitized.tools.map((tool) => {
+        const { returns, ...fnRest } = tool.function as any;
+        return {
+          ...tool,
+          function: fnRest,
+        };
+      });
+    }
+
+    return super.createChatCompletion(sanitized);
+  }
 }

package/src/clients/index.ts

@@ -397,9 +397,10 @@ export class AIClient {
     const hasModel = this.providerHasModel(provider, model);
 
     if (!hasModel) {
-      throw new Error(
-        `Model ${model} not registered for provider ${provider}.`
-      );
+      // Model not in local registry — pass it through anyway so the provider
+      // API can accept or reject it directly (e.g. newly-released models that
+      // haven't been fetched into our local model list yet).
+      console.warn(`⚠️  Model '${model}' not in local registry for provider '${provider}', attempting anyway.`);
     }
 
     return { client: this.clients[provider], provider, model };
@@ -609,6 +610,11 @@ export class AIClient {
       return { provider, model };
     }
 
+    // If an explicit provider was given, don't fall through to fuzzy cross-provider
+    // search — that would silently pick a completely different provider (e.g. nvidia
+    // instead of fireworks). Just pass through and let the API accept/reject the model.
+    const hasExplicitProvider = !!provider;
+
     if (model?.includes("/")) {
       const split = model.split("/");
 
@@ -620,16 +626,21 @@ export class AIClient {
         return { provider: inferredProvider, model: inferredModel };
       }
 
-      // Starts with match
-      const foundBySplit = this.findModel(inferredModel);
-      if (foundBySplit) {
-        return foundBySplit;
+      // Starts with match — only if no explicit provider was given
+      if (!hasExplicitProvider) {
+        const foundBySplit = this.findModel(inferredModel);
+        if (foundBySplit) {
+          return foundBySplit;
+        }
       }
     }
 
-    const foundByModel = this.findModel(model);
-    if (foundByModel) {
-      return foundByModel;
+    // Fuzzy cross-provider search — only if no explicit provider was given
+    if (!hasExplicitProvider) {
+      const foundByModel = this.findModel(model);
+      if (foundByModel) {
+        return foundByModel;
+      }
     }
 
     const allModels = this.listAllModels();

package/src/clients/pricing/fireworks.ts

@@ -4,10 +4,12 @@
  */
 export const FireworksTextPricing: Record<string, { input: number; output: number; cache_hit?: number }> = {
   // Moonshot AI
+  "accounts/fireworks/models/kimi-k2p7-code": { input: 0.95, cache_hit: 0.19, output: 4.0 },
   "accounts/fireworks/models/kimi-k2-6": { input: 0.95, cache_hit: 0.16, output: 4.0 },
   "accounts/fireworks/models/kimi-k2-5": { input: 0.60, cache_hit: 0.10, output: 3.0 },
 
   // MiniMax
+  "accounts/fireworks/models/minimax-m3": { input: 0.30, cache_hit: 0.06, output: 1.20 },
   "accounts/fireworks/models/minimax-m2-7": { input: 0.30, cache_hit: 0.06, output: 1.20 },
   "accounts/fireworks/models/minimax-m2-5": { input: 0.30, cache_hit: 0.03, output: 1.20 },
 
@@ -19,6 +21,7 @@ export const FireworksTextPricing: Record<string, { input: number; output: numbe
   "accounts/fireworks/models/qwen3-8b": { input: 0.20, cache_hit: 0.10, output: 0.20 },
 
   // Z.ai
+  "accounts/fireworks/models/glm-5-2": { input: 1.40, cache_hit: 0.26, output: 4.40 },
   "accounts/fireworks/models/glm-5-1": { input: 1.40, cache_hit: 0.26, output: 4.40 },
   "accounts/fireworks/models/glm-5": { input: 1.00, cache_hit: 0.20, output: 3.20 },
   "accounts/fireworks/models/glm-4-7": { input: 0.60, cache_hit: 0.30, output: 2.20 },

package/src/commands/replay.ts

@@ -0,0 +1,424 @@
+import { Command } from "commander";
+import * as readline from "readline";
+import { KnowhowSimpleClient, KNOWHOW_API_URL } from "../services/KnowhowClient";
+import { ToolCall } from "../clients/types";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+interface ReplayResult {
+  toolName: string;
+  toolId: string;
+  status: "success" | "failed" | "skipped";
+  error?: string;
+  output?: string;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Flatten all tool_use blocks from all threads in order */
+function extractToolCalls(threads: any[][]): { toolCall: ToolCall; threadIdx: number; msgIdx: number }[] {
+  const calls: { toolCall: ToolCall; threadIdx: number; msgIdx: number }[] = [];
+
+  for (let ti = 0; ti < threads.length; ti++) {
+    const thread = threads[ti];
+    for (let mi = 0; mi < thread.length; mi++) {
+      const msg = thread[mi];
+      if (msg.role !== "assistant") continue;
+
+      const content = msg.content;
+
+      // Handle Anthropic-style: content is an array of blocks with type "tool_use"
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type !== "tool_use") continue;
+          // Convert from Anthropic tool_use block to our ToolCall shape
+          const toolCall: ToolCall = {
+            id: block.id || `replay_${Date.now()}_${Math.random()}`,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments:
+                typeof block.input === "string"
+                  ? block.input
+                  : JSON.stringify(block.input ?? {}),
+            },
+          };
+          calls.push({ toolCall, threadIdx: ti, msgIdx: mi });
+        }
+      }
+
+      // Handle OpenAI-style: tool_calls array on the message (content may be a string)
+      if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+          calls.push({ toolCall: tc, threadIdx: ti, msgIdx: mi });
+        }
+      }
+    }
+  }
+
+  return calls;
+}
+
+/** Fetch threads by taskId (direct task) */
+async function fetchThreadsByTaskId(
+  client: KnowhowSimpleClient,
+  taskId: string
+): Promise<any[][]> {
+  return client.getTaskThreads(taskId);
+}
+
+/** Fetch threads from a session's messages and find the task embedded within */
+async function fetchThreadsBySessionMessage(
+  client: KnowhowSimpleClient,
+  sessionId: string,
+  messageId: string
+): Promise<any[][]> {
+  // GET /api/chat/sessions/:sessionId/messages
+  const baseUrl = (client as any).baseUrl || KNOWHOW_API_URL;
+  const headers = (client as any).headers || {};
+
+  const resp = await fetch(`${baseUrl}/api/chat/sessions/${sessionId}/messages`, {
+    headers,
+  });
+
+  if (!resp.ok) {
+    throw new Error(`Failed to fetch session messages: ${resp.status} ${resp.statusText}`);
+  }
+
+  const messages: any[] = await resp.json();
+
+  // Find the message with our target messageId
+  let targetMsg = messages.find((m: any) => m.id === messageId);
+  if (!targetMsg) {
+    // messageId might be on a task inside an assistant message
+    for (const m of messages) {
+      if (m.tasks) {
+        for (const task of m.tasks) {
+          if (task.id === messageId) {
+            targetMsg = m;
+            break;
+          }
+        }
+      }
+      if (targetMsg) break;
+    }
+  }
+
+  if (!targetMsg) {
+    throw new Error(`Message ${messageId} not found in session ${sessionId}`);
+  }
+
+  // Extract threads - they may be directly on a task inside the message
+  if (targetMsg.tasks && targetMsg.tasks.length > 0) {
+    // Find task that contains our messageId, or use first task
+    let task = targetMsg.tasks.find((t: any) => t.id === messageId);
+    if (!task) task = targetMsg.tasks[0];
+
+    if (task.threads && Array.isArray(task.threads)) {
+      return task.threads;
+    }
+
+    // If task has an id but no inline threads, fetch via task API
+    if (task.id) {
+      return client.getTaskThreads(task.id);
+    }
+  }
+
+  // Fallback: if threads are directly on the message
+  if (targetMsg.threads) return targetMsg.threads;
+
+  throw new Error(`No threads found for message ${messageId}`);
+}
+
+/** Prompt user for approval (y/n/s for skip/q for quit) */
+async function promptApproval(toolName: string, args: string): Promise<"run" | "skip" | "quit"> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    const preview = args.length > 200 ? args.slice(0, 200) + "…" : args;
+    rl.question(
+      `\n🔧 Tool: ${toolName}\n   Args: ${preview}\n   Run this? [y/n/q] (y=run, n=skip, q=quit): `,
+      (answer) => {
+        rl.close();
+        const a = answer.trim().toLowerCase();
+        if (a === "q" || a === "quit") resolve("quit");
+        else if (a === "n" || a === "skip" || a === "s") resolve("skip");
+        else resolve("run");
+      }
+    );
+  });
+}
+
+/**
+ * Parse --replace-path options like "/workspace/repo:./" into a list of [from, to] pairs.
+ * Multiple --replace-path flags are supported.
+ */
+function parseReplacePaths(replacePaths: string[]): Array<[string, string]> {
+  return replacePaths.map((rp) => {
+    const colonIdx = rp.indexOf(":");
+    if (colonIdx === -1) {
+      throw new Error(`Invalid --replace-path value "${rp}": expected format "from:to" (e.g. /workspace/repo:./)`);
+    }
+    const from = rp.slice(0, colonIdx);
+    const to = rp.slice(colonIdx + 1);
+    return [from, to];
+  });
+}
+
+/** Apply all path replacements to a tool arguments string */
+function applyPathReplacements(argsStr: string, replacements: Array<[string, string]>): string {
+  let result = argsStr;
+  for (const [from, to] of replacements) {
+    // Replace all occurrences globally
+    result = result.split(from).join(to);
+  }
+  return result;
+}
+
+// ─── Main replay logic ────────────────────────────────────────────────────────
+
+async function runReplay(options: {
+  taskId?: string;
+  sessionId?: string;
+  messageId?: string;
+  approve: boolean;
+  fromStep?: number;
+  toStep?: number;
+  only?: string[];
+  ignore?: string[];
+  dryRun: boolean;
+  replacePaths: Array<[string, string]>;
+}) {
+  // 1. Setup services + tools
+  console.log("🔧 Setting up services...");
+  const { setupServices } = await import("./services");
+  const { Tools } = await setupServices();
+
+  // 2. Fetch the threads from the remote API
+  const client = new KnowhowSimpleClient(KNOWHOW_API_URL);
+
+  let threads: any[][] = [];
+
+  if (options.taskId && !options.sessionId) {
+    console.log(`\n📡 Fetching threads for task: ${options.taskId}`);
+    threads = await fetchThreadsByTaskId(client, options.taskId);
+  } else if (options.sessionId && options.messageId) {
+    console.log(`\n📡 Fetching threads for session=${options.sessionId} message=${options.messageId}`);
+    threads = await fetchThreadsBySessionMessage(client, options.sessionId, options.messageId);
+  } else if (options.taskId) {
+    // taskId might actually be a task UUID from a message
+    console.log(`\n📡 Fetching threads for task: ${options.taskId}`);
+    threads = await fetchThreadsByTaskId(client, options.taskId);
+  } else {
+    throw new Error("Provide --task-id or --session-id + --message-id");
+  }
+
+  if (!threads || threads.length === 0) {
+    console.log("⚠️  No threads found. Nothing to replay.");
+    return;
+  }
+
+  console.log(`✅ Loaded ${threads.length} thread(s)`);
+
+  // 3. Extract all tool calls
+  const allToolCalls = extractToolCalls(threads);
+
+  if (allToolCalls.length === 0) {
+    console.log("⚠️  No tool calls found in threads. Nothing to replay.");
+    return;
+  }
+
+  console.log(`\n📋 Found ${allToolCalls.length} tool call(s) total`);
+
+  // 4. Apply filters
+  let filtered = allToolCalls;
+
+  if (options.fromStep != null) {
+    filtered = filtered.slice(options.fromStep - 1);
+  }
+  if (options.toStep != null) {
+    const end = options.toStep - (options.fromStep ?? 1) + 1;
+    filtered = filtered.slice(0, end);
+  }
+  if (options.only && options.only.length > 0) {
+    filtered = filtered.filter(({ toolCall }) =>
+      options.only!.some((n) => toolCall.function.name.includes(n))
+    );
+    console.log(`   Filtered to tools matching: ${options.only.join(", ")} → ${filtered.length} call(s)`);
+  }
+  if (options.ignore && options.ignore.length > 0) {
+    filtered = filtered.filter(({ toolCall }) =>
+      !options.ignore!.some((n) => toolCall.function.name.includes(n))
+    );
+    console.log(`   Ignoring tools matching: ${options.ignore.join(", ")} → ${filtered.length} call(s)`);
+  }
+
+  if (options.replacePaths.length > 0) {
+    const pairs = options.replacePaths.map(([f, t]) => `"${f}" → "${t}"`).join(", ");
+    console.log(`   Path replacements: ${pairs}`);
+  }
+
+  if (filtered.length === 0) {
+    console.log("⚠️  No tool calls remain after filtering. Nothing to replay.");
+    return;
+  }
+
+  // 5. Print summary table
+  console.log("\n┌─────────────────────────────────────────────────────────────┐");
+  console.log(`│  Replay Plan: ${filtered.length} tool call(s)${" ".repeat(Math.max(0, 47 - String(filtered.length).length))}│`);
+  console.log("├──────┬──────────────────────────────────────────────────────┤");
+  console.log("│  #   │  Tool Name                                           │");
+  console.log("├──────┼──────────────────────────────────────────────────────┤");
+  for (let i = 0; i < filtered.length; i++) {
+    const name = filtered[i].toolCall.function.name.padEnd(52).slice(0, 52);
+    const num = String(i + 1).padStart(4);
+    console.log(`│ ${num} │  ${name}│`);
+  }
+  console.log("└──────┴──────────────────────────────────────────────────────┘\n");
+
+  if (options.dryRun) {
+    console.log("🏃 Dry-run mode: no tools will be executed.");
+    return;
+  }
+
+  // 6. Execute tool calls
+  const results: ReplayResult[] = [];
+  let stepNum = 0;
+
+  for (const { toolCall } of filtered) {
+    stepNum++;
+    const toolName = toolCall.function.name;
+    const argsStr =
+      typeof toolCall.function.arguments === "string"
+        ? toolCall.function.arguments
+        : JSON.stringify(toolCall.function.arguments);
+
+    // Apply path replacements to the arguments string before execution
+    const patchedArgsStr =
+      options.replacePaths.length > 0
+        ? applyPathReplacements(argsStr, options.replacePaths)
+        : argsStr;
+
+    const patchedToolCall: ToolCall = {
+      ...toolCall,
+      function: { ...toolCall.function, arguments: patchedArgsStr },
+    };
+
+    // Prompt for approval if requested
+    if (options.approve) {
+      const decision = await promptApproval(toolName, patchedArgsStr);
+      if (decision === "quit") {
+        console.log("\n⛔ Quit by user.");
+        break;
+      }
+      if (decision === "skip") {
+        console.log(`   ⏭  Skipped: ${toolName}`);
+        results.push({ toolName, toolId: toolCall.id, status: "skipped" });
+        continue;
+      }
+    }
+
+    process.stdout.write(`[${stepNum}/${filtered.length}] Running ${toolName}... `);
+
+    try {
+      const { functionResp } = await Tools.callTool(patchedToolCall, Tools.getToolNames());
+      const output = typeof functionResp === "string" ? functionResp : JSON.stringify(functionResp);
+      const preview = output.length > 120 ? output.slice(0, 120) + "…" : output;
+      console.log(`✅`);
+      if (output) {
+        console.log(`         → ${preview}`);
+      }
+      results.push({ toolName, toolId: toolCall.id, status: "success", output });
+    } catch (err: any) {
+      console.log(`❌`);
+      const errMsg = err?.message || String(err);
+      console.log(`         ⚠ ${errMsg}`);
+      results.push({ toolName, toolId: toolCall.id, status: "failed", error: errMsg });
+    }
+  }
+
+  // 7. Print summary
+  const succeeded = results.filter((r) => r.status === "success").length;
+  const failed = results.filter((r) => r.status === "failed").length;
+  const skipped = results.filter((r) => r.status === "skipped").length;
+
+  console.log("\n═══════════════════════════════════════════════════════════════");
+  console.log("  Replay Complete");
+  console.log(`  ✅ ${succeeded} succeeded   ❌ ${failed} failed   ⏭  ${skipped} skipped`);
+
+  if (failed > 0) {
+    console.log("\n  Failed tool calls:");
+    results
+      .filter((r) => r.status === "failed")
+      .forEach((r) => {
+        console.log(`    • ${r.toolName}: ${r.error}`);
+      });
+  }
+
+  console.log("═══════════════════════════════════════════════════════════════\n");
+}
+
+// ─── Command registration ─────────────────────────────────────────────────────
+
+export function addReplayCommand(program: Command): void {
+  program
+    .command("replay")
+    .description(
+      "Replay tool calls from a remote session/task locally. " +
+      "Useful for recreating agent work from a cloud sandbox on your local machine."
+    )
+    .option("--task-id <taskId>", "Task UUID to replay tool calls from")
+    .option("--session-id <sessionId>", "Chat session UUID (use with --message-id)")
+    .option("--message-id <messageId>", "Message UUID within a session to replay")
+    .option(
+      "--approve",
+      "Approval mode: prompt before each tool call (y=run, n=skip, q=quit)"
+    )
+    .option("--dry-run", "List tool calls without executing them")
+    .option(
+      "--from-step <n>",
+      "Start replaying from step N (1-based)",
+      (v) => parseInt(v, 10)
+    )
+    .option(
+      "--to-step <n>",
+      "Stop replaying after step N (1-based)",
+      (v) => parseInt(v, 10)
+    )
+    .option(
+      "--only <tools>",
+      "Comma-separated list of tool name substrings to include (e.g. writeFile,patchFile)",
+      (v) => v.split(",").map((s) => s.trim()).filter(Boolean)
+    )
+    .option(
+      "--ignore <tools>",
+      "Comma-separated list of tool name substrings to skip (e.g. execCommand,readFile)",
+      (v) => v.split(",").map((s) => s.trim()).filter(Boolean)
+    )
+    .option(
+      "--replace-path <mapping>",
+      'Replace a path prefix in all tool call arguments. Format: "from:to" (e.g. /workspace/repo:./). ' +
+      "Can be specified multiple times.",
+      (v: string, acc: string[]) => { acc.push(v); return acc; },
+      [] as string[]
+    )
+    .action(async (options) => {
+      try {
+        const replacePaths = parseReplacePaths(options.replacePath || []);
+        await runReplay({
+          taskId: options.taskId,
+          sessionId: options.sessionId,
+          messageId: options.messageId,
+          approve: options.approve || false,
+          fromStep: options.fromStep,
+          toStep: options.toStep,
+          only: options.only,
+          ignore: options.ignore,
+          dryRun: options.dryRun || false,
+          replacePaths,
+        });
+      } catch (err: any) {
+        console.error(`\n❌ Replay failed: ${err?.message || err}`);
+        process.exit(1);
+      }
+    });
+}