@tyvm/knowhow 0.0.120 → 0.0.122

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.120",
+  "version": "0.0.122",
   "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/http.ts

@@ -3,6 +3,7 @@ import {
   GenericClient,
   CompletionOptions,
   CompletionResponse,
+  StreamChunk,
   EmbeddingOptions,
   EmbeddingResponse,
 } from "./types";
@@ -91,6 +92,17 @@ export class HttpClient implements GenericClient {
     this.pricingMap = pricingMap;
   }
 
+  /**
+   * Returns the pricing entry for a specific model, or all pricing entries if no model is given.
+   * Returns undefined for a specific model if no pricing is known.
+   */
+  getPricing(model?: string): ModelPricing | Record<string, ModelPricing> | undefined {
+    if (model !== undefined) {
+      return this.pricingMap[model];
+    }
+    return this.pricingMap;
+  }
+
   /**
    * Calculate USD cost for a completion/embedding call from token usage.
    * Returns undefined if no pricing entry exists for the model.
@@ -186,6 +198,88 @@ export class HttpClient implements GenericClient {
     });
   }
 
+  /**
+   * Streams a chat completion via OpenAI-compatible SSE (`stream: true`).
+   * Parses `data: {...}` lines and yields token deltas, then a final done chunk.
+   */
+  async *createChatCompletionStream(
+    options: CompletionOptions
+  ): AsyncGenerator<StreamChunk> {
+    const body = {
+      ...options,
+      model: options.model,
+      messages: options.messages,
+      max_tokens: options.max_tokens || 4000,
+      ...this.extra_body,
+      stream: true,
+      stream_options: { include_usage: true },
+      ...(options.tools && {
+        tools: options.tools,
+        tool_choice: "auto",
+      }),
+    };
+
+    const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        ...(this.headers as Record<string, string>),
+        "Content-Type": "application/json",
+        "Accept": "text/event-stream",
+      },
+      body: JSON.stringify(body),
+      signal: options.signal,
+    });
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}: ${text}`);
+    }
+
+    if (!response.body) {
+      throw new Error("No response body for streaming request");
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let usage: StreamChunk["usage"] | undefined;
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data: ")) continue;
+        const jsonStr = trimmed.slice(6);
+        if (jsonStr === "[DONE]") continue;
+        try {
+          const chunk = JSON.parse(jsonStr);
+          const delta = chunk.choices?.[0]?.delta?.content;
+          if (delta) {
+            yield { delta, done: false };
+          }
+          if (chunk.usage) {
+            usage = {
+              prompt_tokens: chunk.usage.prompt_tokens ?? 0,
+              completion_tokens: chunk.usage.completion_tokens ?? 0,
+              total_tokens: chunk.usage.total_tokens,
+            };
+          }
+        } catch {
+          // Ignore malformed SSE lines
+        }
+      }
+    }
+
+    const usdCost = this.calculateCost(options.model, usage);
+    yield { done: true, usage, usd_cost: usdCost };
+  }
+
   /**
    * Creates a completion using the Responses API (/v1/responses).
    * Compatible with providers that implement the OpenAI Responses API spec

package/src/clients/index.ts

@@ -1,6 +1,7 @@
 import {
   CompletionOptions,
   CompletionResponse,
+  StreamChunk,
   EmbeddingOptions,
   EmbeddingResponse,
   GenericClient,
@@ -34,6 +35,7 @@ import { OpenAiTextPricing } from "./pricing/openai";
 import { AnthropicTextPricing } from "./pricing/anthropic";
 import { GeminiPricing } from "./pricing/google";
 import { withRetry } from "./withRetry";
+import { FireworksTextPricing } from "./pricing/fireworks";
 import {
   XaiTextPricing,
   XaiImagePricing,
@@ -397,9 +399,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 +612,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 +628,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();
@@ -672,6 +685,31 @@ export class AIClient {
     );
   }
 
+  async *createCompletionStream(
+    provider: string,
+    options: CompletionOptions
+  ): AsyncGenerator<StreamChunk> {
+    const { client, model } = this.getClient(provider, options.model);
+    if (!model || !client) {
+      throw new Error(
+        `provider: ${provider} does not have ${
+          options.model
+        } model registered. Try using ${JSON.stringify(this.listAllModels())}`
+      );
+    }
+    if (client.createChatCompletionStream) {
+      yield* client.createChatCompletionStream({ ...options, model });
+    } else {
+      // Fallback: non-streaming clients — call normal completion and yield as single chunk
+      const result = await withRetry(
+        (signal) => client.createChatCompletion({ ...options, model, signal }),
+        options
+      );
+      yield { delta: result.choices[0]?.message?.content ?? "", done: false };
+      yield { done: true, usage: result.usage, usd_cost: result.usd_cost };
+    }
+  }
+
   async createEmbedding(
     provider: string,
     options: EmbeddingOptions
@@ -821,12 +859,24 @@ export class AIClient {
     return this.clientModels;
   }
 
-  listAllModelsWithProvider() {
-    return Object.entries(this.listAllModels())
-      .map(([provider, models]) =>
-        models.map((m) => ({ id: `${provider}/${m}` }))
-      )
-      .flat();
+  /**
+   * Filters a provider→models map to only include models that have known pricing.
+   * For HttpClient-based providers with getPricing(), only priced models are kept.
+   * For other providers (no getPricing()), all models pass through unchanged.
+   */
+  private _filterByPricing(models: Record<string, string[]>): Record<string, string[]> {
+    const result: Record<string, string[]> = {};
+    for (const [provider, ids] of Object.entries(models)) {
+      const client = this.clients[provider];
+      if (client?.getPricing) {
+        const pricingMap = client.getPricing() as Record<string, ModelPricing>;
+        const priced = ids.filter((id) => !!pricingMap[id]);
+        if (priced.length > 0) result[provider] = priced;
+      } else {
+        result[provider] = ids;
+      }
+    }
+    return result;
   }
 
   /*
@@ -879,11 +929,8 @@ export class AIClient {
     return providerModels;
   }
 
-  listAllEmbeddingModels() {
-    return this.embeddingModels;
-  }
-
-  listAllCompletionModels() {
+  listAllCompletionModels(options?: { pricing?: boolean }) {
+    if (options?.pricing) return this._filterByPricing(this.completionModels);
     return this.completionModels;
   }
 
@@ -891,18 +938,33 @@ export class AIClient {
     return Object.keys(this.clientModels);
   }
 
-  listAllImageModels() {
+  listAllEmbeddingModels(options?: { pricing?: boolean }) {
+    if (options?.pricing) return this._filterByPricing(this.embeddingModels);
+    return this.embeddingModels;
+  }
+
+  listAllImageModels(options?: { pricing?: boolean }) {
+    if (options?.pricing) return this._filterByPricing(this.imageModels);
     return this.imageModels;
   }
 
-  listAllAudioModels() {
+  listAllAudioModels(options?: { pricing?: boolean }) {
+    if (options?.pricing) return this._filterByPricing(this.audioModels);
     return this.audioModels;
   }
 
-  listAllVideoModels() {
+  listAllVideoModels(options?: { pricing?: boolean }) {
+    if (options?.pricing) return this._filterByPricing(this.videoModels);
     return this.videoModels;
   }
 
+  listAllModelsWithProvider(options?: { pricing?: boolean }) {
+    const models = options?.pricing ? this._filterByPricing(this.clientModels) : this.clientModels;
+    return Object.entries(models)
+      .map(([provider, ids]) => ids.map((m) => ({ id: `${provider}/${m}` })))
+      .flat();
+  }
+
   /**
    * Returns the context window limit (in tokens) for a given model.
    * Delegates to the registered client's getContextLimit() if available.
@@ -958,6 +1020,7 @@ export class AIClient {
       ...AnthropicTextPricing,
       ...GeminiPricing,
       ...XaiTextPricing,
+      ...FireworksTextPricing,
     };
     const allImagePricing: Record<string, ModelPricing> = {
       ...XaiImagePricing,

package/src/clients/openai.ts

@@ -190,6 +190,64 @@ export class GenericOpenAiClient implements GenericClient {
       usd_cost: usdCost,
     };
   }
+
+  /**
+   * Streams a chat completion token-by-token.
+   * Yields delta content strings as they arrive, then yields a final
+   * CompletionResponse with usage info when the stream ends.
+   */
+  async *createChatCompletionStream(
+    options: CompletionOptions
+  ): AsyncGenerator<{ delta?: string; done: boolean; usage?: CompletionResponse['usage']; usd_cost?: number }> {
+    if (OpenAiResponsesOnlyModels.includes(options.model)) {
+      // Fallback: non-streaming for Responses-only models
+      const result = await this.createChatCompletion(options);
+      yield { delta: result.choices[0]?.message?.content ?? "", done: false };
+      yield { done: true, usage: result.usage, usd_cost: result.usd_cost };
+      return;
+    }
+
+    const openaiMessages = options.messages.map((msg) => {
+      if (msg.role === "tool") {
+        return {
+          ...msg,
+          content: msg.content || "",
+          role: "tool",
+          tool_call_id: msg.tool_call_id,
+        } as ChatCompletionToolMessageParam;
+      }
+      return msg as ChatCompletionMessageParam;
+    });
+
+    const stream = await this.client.chat.completions.create({
+      model: options.model,
+      messages: openaiMessages,
+      max_tokens: options.max_tokens,
+      stream: true,
+      stream_options: { include_usage: true },
+      ...(options.tools && { tools: options.tools, tool_choice: "auto" }),
+    }, { signal: options.signal });
+
+    let usage: CompletionResponse['usage'] | undefined;
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta?.content;
+      if (delta) {
+        yield { delta, done: false };
+      }
+      if (chunk.usage) {
+        usage = {
+          prompt_tokens: chunk.usage.prompt_tokens ?? 0,
+          completion_tokens: chunk.usage.completion_tokens ?? 0,
+          total_tokens: chunk.usage.total_tokens ?? 0,
+        };
+      }
+    }
+    const usdCost = usage
+      ? this.calculateCost(options.model, usage as OpenAI.ChatCompletion["usage"])
+      : undefined;
+    yield { done: true, usage, usd_cost: usdCost };
+  }
+
   /**
    * Creates a completion using the OpenAI Responses API.
    * Used for models that only support the Responses API (e.g. gpt-5.3-codex, gpt-5.4).

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/clients/types.ts

@@ -136,6 +136,16 @@ export interface CompletionResponse {
   usd_cost?: number;
 }
 
+/** A single chunk yielded by a streaming completion. */
+export interface StreamChunk {
+  /** Incremental text token(s). Only present on intermediate chunks. */
+  delta?: string;
+  /** True on the final chunk (no delta, but usage/cost available). */
+  done: boolean;
+  usage?: TokenUsage;
+  usd_cost?: number;
+}
+
 export interface EmbeddingOptions extends RetryOptions {
   input: string;
   model?: string;
@@ -305,6 +315,8 @@ export interface FileDownloadResponse {
 export interface GenericClient {
   setKey(key: string): void;
   createChatCompletion(options: CompletionOptions): Promise<CompletionResponse>;
+  /** Optional streaming variant — yields incremental tokens then a final done chunk. */
+  createChatCompletionStream?(options: CompletionOptions): AsyncGenerator<StreamChunk>;
   createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse>;
   createAudioTranscription?(
     options: AudioTranscriptionOptions
@@ -343,4 +355,10 @@ export interface GenericClient {
   getContextLimit?(
     model: string
   ): { contextLimit: number; threshold: number } | undefined;
+  /**
+   * Returns the pricing entry for a specific model, or the entire pricing map if no model is given.
+   * Returns undefined for a specific model if no pricing is known.
+   * Only implemented by HttpClient-based providers that have been given a pricing map via setPrices().
+   */
+  getPricing?(model?: string): import("./pricing/types").ModelPricing | Record<string, import("./pricing/types").ModelPricing> | undefined;
 }