@tyvm/knowhow 0.0.129 → 0.0.131

package/src/clients/openai.ts

@@ -107,7 +107,11 @@ export class GenericOpenAiClient implements GenericClient {
   }
 
   resolveReasoningEffort(options: CompletionOptions): "low" | "medium" | "high" {
-    return options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
+    const effort = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
+    // "none" is not a valid SDK ReasoningEffort — callers that need "none" should
+    // check isReasoningDisabled() separately and skip the reasoning params.
+    if (effort === "none") return "low";
+    return effort;
   }
 
   /**
@@ -116,7 +120,8 @@ export class GenericOpenAiClient implements GenericClient {
    * If the requested level is not supported, picks the lowest supported level.
    */
   resolveReasoningEffortForModel(options: CompletionOptions): string {
-    const requested = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
+    const raw = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
+    const requested = raw === "none" ? "none" : raw;
     const pricing = OpenAiTextPricing[options.model];
     const supportedLevels = pricing?.reasoningLevels;
     if (!supportedLevels || supportedLevels.length === 0) {
@@ -130,6 +135,11 @@ export class GenericOpenAiClient implements GenericClient {
     return supportedLevels[0];
   }
 
+  /** Returns true when the caller explicitly requested thinking/reasoning to be disabled. */
+  isReasoningDisabled(options: CompletionOptions): boolean {
+    return options.reasoning_effort === "none";
+  }
+
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -154,7 +164,7 @@ export class GenericOpenAiClient implements GenericClient {
       model: options.model,
       messages: openaiMessages,
       max_tokens: options.max_tokens,
-      ...(OpenAiReasoningModels.includes(options.model) && {
+      ...(OpenAiReasoningModels.includes(options.model) && !this.isReasoningDisabled(options) && {
         max_tokens: undefined,
         max_completion_tokens: Math.max(options.max_tokens ?? 0, 16_000),
         reasoning_effort: this.resolveReasoningEffort(options),
@@ -186,6 +196,11 @@ export class GenericOpenAiClient implements GenericClient {
         prompt_tokens_details: {
           cached_tokens: response.usage.prompt_tokens_details?.cached_tokens ?? 0,
         },
+        ...(response.usage.completion_tokens_details?.reasoning_tokens != null && {
+          output_tokens_details: {
+            reasoning_tokens: response.usage.completion_tokens_details.reasoning_tokens,
+          },
+        }),
       } : undefined,
       usd_cost: usdCost,
     };
@@ -350,9 +365,12 @@ export class GenericOpenAiClient implements GenericClient {
       input,
       ...(instructions && { instructions }),
       // Don't limit max_output_tokens for Responses API - codex truncates tool call arguments when limited
-      ...(OpenAiReasoningModels.includes(options.model) && {
+      ...(OpenAiReasoningModels.includes(options.model) && !this.isReasoningDisabled(options) && {
         max_output_tokens: Math.max(options.max_tokens || 0, 16000),
-        reasoning: { effort: this.resolveReasoningEffortForModel(options) },
+        reasoning: {
+          effort: this.resolveReasoningEffortForModel(options),
+          ...(options.reasoning_summary && { summary: "auto" }),
+        },
       }),
       ...(tools?.length && {
         tools,
@@ -372,6 +390,11 @@ export class GenericOpenAiClient implements GenericClient {
             cached_tokens:
               response.usage.input_tokens_details?.cached_tokens ?? 0,
           },
+          ...((response.usage as any).output_tokens_details?.reasoning_tokens != null && {
+            output_tokens_details: {
+              reasoning_tokens: (response.usage as any).output_tokens_details.reasoning_tokens,
+            },
+          }),
         }
       : undefined;
 

package/src/clients/pricing/anthropic.ts

@@ -10,6 +10,13 @@ import { completions, ModelCatalogEntry, ModelPricing } from "./types";
 export const AnthropicModels = {
   // Active models
   Fable5:    "claude-fable-5",
+  // Short aliases (without date suffix) — Anthropic resolves these to the latest
+  // dated version. Pricing entries for the short aliases are added to the pricing
+  // table below so cost tracking works regardless of whether the user specifies
+  // the full dated name or the short alias.
+  Sonnet4_5Short: "claude-sonnet-4-5",
+  Haiku4_5Short:  "claude-haiku-4-5",
+  Opus4_5Short:   "claude-opus-4-5",
   Sonnet5:   "claude-sonnet-5",
   Mythos5:   "claude-mythos-5",
   MythosPreview: "claude-mythos-preview",
@@ -101,6 +108,10 @@ export const AnthropicTextPricing: Record<string, ModelPricing> = {
   [AnthropicModels.Opus4_1]:   { input: 15.0, cache_write: 18.75,  cache_hit: 1.5,  output: 75.0 },
   [AnthropicModels.Sonnet4_5]: { input: 3.0,  input_gt_200k: 6.0,  cache_write: 3.75, cache_hit: 0.3, output: 15.0, output_gt_200k: 22.5 },
   [AnthropicModels.Haiku4_5]:  { input: 1.0,  cache_write: 1.25,   cache_hit: 0.1,  output: 5.0 },
+  // Short aliases — same pricing as their dated counterparts
+  [AnthropicModels.Sonnet4_5Short]: { input: 3.0, input_gt_200k: 6.0, cache_write: 3.75, cache_hit: 0.3, output: 15.0, output_gt_200k: 22.5 },
+  [AnthropicModels.Haiku4_5Short]:  { input: 1.0, cache_write: 1.25, cache_hit: 0.1, output: 5.0 },
+  [AnthropicModels.Opus4_5Short]:   { input: 5.0, cache_write: 6.25, cache_hit: 0.5, output: 25.0 },
   // Deprecated — pricing retained for cost tracking
   [AnthropicModels.Opus4]:     { input: 15.0, cache_write: 18.75,  cache_hit: 1.5,  output: 75.0,  deprecated: true, deprecationDate: "2026-06-15" },
   [AnthropicModels.Sonnet4]:   { input: 3.0,  input_gt_200k: 6.0,  cache_write: 3.75, cache_hit: 0.3, output: 15.0, output_gt_200k: 22.5, deprecated: true, deprecationDate: "2026-06-15" },

package/src/clients/pricing/fireworks.ts

@@ -40,3 +40,15 @@ export const FireworksTextPricing: Record<string, ModelPricing> = {
   // OpenAI OSS
   "accounts/fireworks/models/gpt-oss-120b": { input: 0.15, cache_hit: 0.01, output: 0.60 },
 };
+
+/**
+ * Fireworks AI embedding/reranker model pricing (USD per 1M tokens)
+ * Source: https://fireworks.ai/pricing
+ */
+export const FireworksEmbeddingPricing: Record<string, ModelPricing> = {
+  // Qwen3 Embedding 8B — $0.10/M tokens, context 40k
+  "accounts/fireworks/models/qwen3-embedding-8b": { input: 0.10, output: 0.10 },
+
+  // Qwen3 Reranker 8B — $0.20/M tokens, context 40k
+  "accounts/fireworks/models/qwen3-reranker-8b": { input: 0.20, output: 0.20 },
+};

package/src/clients/pricing/openai.ts

@@ -167,6 +167,9 @@ export const OpenAiResponsesOnlyModels: string[] = [
   OpenAiModels.GPT_55_Pro,
   OpenAiModels.GPT_55,
   OpenAiModels.GPT_5_Pro,
+  OpenAiModels.GPT_56_Sol,
+  OpenAiModels.GPT_56_Terra,
+  OpenAiModels.GPT_56_Luna,
   OpenAiModels.o1,
   OpenAiModels.o1_Pro,
 ];

package/src/clients/types.ts

@@ -86,10 +86,26 @@ export interface CompletionOptions extends RetryOptions {
   tools?: Tool[];
   tool_choice?: "auto" | "none";
   max_tokens?: number;
-  /** Reasoning effort level for models that support it.
-   *  Maps to: OpenAI reasoning_effort, xAI reasoning.effort, Gemini thinkingLevel/thinkingBudget, Anthropic thinking budget.
-   *  "low" = minimal thinking, "medium" = balanced, "high" = maximum reasoning */
-  reasoning_effort?: "low" | "medium" | "high";
+  /**
+   * Reasoning effort level for models that support it.
+   * Maps to: OpenAI reasoning_effort/reasoning.effort, xAI reasoning.effort,
+   *          Gemini thinkingLevel/thinkingBudget, Anthropic thinking mode.
+   *
+   * "none"   = disable thinking entirely (Anthropic: thinking.type="disabled",
+   *            OpenAI: reasoning.effort="none").  Only supported by models that
+   *            allow disabling thinking (e.g. claude-sonnet-5).
+   * "low"    = minimal thinking
+   * "medium" = balanced (default for most models)
+   * "high"   = maximum reasoning
+   */
+  reasoning_effort?: "none" | "low" | "medium" | "high";
+  /**
+   * When true, request a summarized view of the model's thinking process.
+   * - Anthropic: thinking.display = "summarized"
+   * - OpenAI:    reasoning.summary = "auto"
+   * Defaults to false (no summary displayed).
+   */
+  reasoning_summary?: boolean;
   /**
    * When true, hints to the client that this task is long-running and it should
    * use a long-TTL cache where available.
@@ -115,6 +131,13 @@ export interface TokenUsage {
   output_tokens?: number;
   /** Convenience total (prompt + completion) */
   total_tokens?: number;
+  /** Breakdown of output tokens — thinking/reasoning tokens are billed as output
+   *  but should NOT be counted toward the visible-content heuristics. */
+  output_tokens_details?: {
+    /** Anthropic: thinking_tokens, OpenAI: reasoning_tokens */
+    thinking_tokens?: number;
+    reasoning_tokens?: number;
+  };
   /** Cache details */
   prompt_tokens_details?: {
     /** Tokens served from the prompt cache (reduces cost) */

package/src/clients/xai.ts

@@ -76,9 +76,9 @@ export class GenericXAIClient implements GenericClient {
       model: options.model,
       messages: xaiMessages,
       max_tokens: options.max_tokens,
-      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && {
+      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && options.reasoning_effort !== "none" && {
         // grok-3-mini models support reasoning_effort: "low" | "medium" | "high"
-        reasoning_effort: options.reasoning_effort,
+        reasoning_effort: options.reasoning_effort as "low" | "medium" | "high",
       }),
       ...(options.tools && {
         tools: options.tools,

package/src/commands/agent.ts

@@ -1,13 +1,31 @@
 import { Command } from "commander";
 import { readPromptFile } from "../ai";
+import { BehaviorsService } from "../services/BehaviorsService";
 import { AgentModule } from "../chat/modules/AgentModule";
 import { AskModule } from "../chat/modules/AskModule";
 import { SearchModule } from "../chat/modules/SearchModule";
 import { SessionsModule } from "../chat/modules/SessionsModule";
 import { SetupModule } from "../chat/modules/SetupModule";
+import { PlainRenderer } from "../chat/renderer/PlainRenderer";
 import { loadRenderer } from "../chat/renderer/loadRenderer";
 import { getConfig } from "../config";
 
+async function setupRenderer(chatService: any, rendererSpecifier: string): Promise<void> {
+  const resolved =
+    rendererSpecifier === "basic" && !process.stdout.isTTY ? "plain" : rendererSpecifier;
+  try {
+    const renderer = await loadRenderer(resolved);
+    chatService.setContext({ renderer });
+  } catch (err: any) {
+    console.warn(`⚠ Could not load renderer "${resolved}": ${err.message}`);
+    console.warn("  Falling back to basic renderer.");
+    try {
+      const fallback = !process.stdout.isTTY ? new PlainRenderer() : await loadRenderer("basic");
+      chatService.setContext({ renderer: fallback });
+    } catch (_) {}
+  }
+}
+
 async function readStdin(): Promise<string> {
   return new Promise((resolve) => {
     let data = "";
@@ -27,24 +45,6 @@ async function readStdin(): Promise<string> {
   });
 }
 
-/**
- * Set up the renderer on the chat service context.
- * Priority: CLI --renderer flag > config.chat.renderer > "basic" (ConsoleRenderer)
- */
-async function setupRenderer(chatService: any, rendererSpecifier: string): Promise<void> {
-  try {
-    const renderer = await loadRenderer(rendererSpecifier);
-    chatService.setContext({ renderer });
-  } catch (err: any) {
-    console.warn(`⚠ Could not load renderer "${rendererSpecifier}": ${err.message}`);
-    console.warn("  Falling back to basic renderer.");
-    try {
-      const fallback = await loadRenderer("basic");
-      chatService.setContext({ renderer: fallback });
-    } catch (_) {}
-  }
-}
-
 export function addAgentCommand(program: Command, getChatService: () => any): void {
   program
     .command("agent")
@@ -67,6 +67,14 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
     )
     .option("--message-id <messageId>", "Knowhow message ID for task tracking")
     .option("--sync-fs", "Enable filesystem-based synchronization")
+    .option(
+      "--behavior-id <id>",
+      "Force a specific behavior by its ID (skips trigger matching)"
+    )
+    .option(
+      "--behavior-file <path>",
+      "Force a specific behavior by its file path (skips trigger matching)"
+    )
     .option(
       "--task-id <taskId>",
       "Pre-generated task ID (used with --sync-fs for predictable agent directory path)"
@@ -92,6 +100,7 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
         try { config = await getConfig(); } catch (_) {}
         const rendererSpecifier = options.renderer ?? config.chat?.renderer ?? "basic";
         await setupRenderer(chatService, rendererSpecifier);
+
         const agentModule = new AgentModule();
 
         if (options.resume) {
@@ -131,11 +140,54 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
         }
 
         await agentModule.initialize(chatService);
+
+        // Match a behavior from local disk (.knowhow/behaviors/)
+        let behaviorSystemPrompt: string | undefined;
+        let behaviorModel: string | undefined;
+        const behaviorsSvc = new BehaviorsService();
+
+        let matchedBehavior = null;
+
+        if (options.behaviorFile) {
+          // Load behavior directly from a file path
+          matchedBehavior = behaviorsSvc.loadBehaviorFromFile(options.behaviorFile);
+          if (matchedBehavior) {
+            console.log(`🎯 Using behavior from file: ${options.behaviorFile}`);
+          } else {
+            console.error(`❌ Could not load behavior from file: ${options.behaviorFile}`);
+            process.exit(1);
+          }
+        } else if (options.behaviorId) {
+          // Load behavior by ID (searches local disk behaviors)
+          matchedBehavior = behaviorsSvc.findBehaviorById(options.behaviorId);
+          if (matchedBehavior) {
+            console.log(`🎯 Using behavior by ID: ${options.behaviorId} (${matchedBehavior.name})`);
+          } else {
+            console.error(`❌ No behavior found with ID: ${options.behaviorId}`);
+            process.exit(1);
+          }
+        } else {
+          // Default: match by trigger text
+          matchedBehavior = behaviorsSvc.matchBehaviorLocal(input);
+        }
+
+        if (matchedBehavior) {
+          console.log(`🎯 Matched behavior: ${matchedBehavior.name}`);
+          if (matchedBehavior.instructions) {
+            behaviorSystemPrompt = matchedBehavior.instructions;
+          }
+          if (matchedBehavior.model) {
+            behaviorModel = matchedBehavior.model;
+          }
+        }
+
         const { taskCompleted } = await agentModule.setupAgent({
           ...options,
           input,
           maxTimeLimit: parseInt(options.maxTimeLimit, 10),
           maxSpendLimit: parseFloat(options.maxSpendLimit),
+          ...(behaviorSystemPrompt ? { systemPrompt: behaviorSystemPrompt } : {}),
+          ...(behaviorModel ? { model: behaviorModel } : {}),
           run: true,
         });
         await taskCompleted;