@tyvm/knowhow 0.0.128 → 0.0.130

package/src/agents/tools/skills.ts

@@ -0,0 +1,79 @@
+import { ToolsService } from "../../services/Tools";
+import { services } from "../../services";
+
+/**
+ * List all skills currently loaded in memory.
+ * Returns a formatted string of name: description lines.
+ */
+export async function listSkills(this: ToolsService): Promise<string> {
+  const toolService =
+    this instanceof ToolsService ? (this as ToolsService) : services().Tools;
+
+  const { Behaviors } = toolService.getContext();
+
+  const skills = Behaviors.listSkills();
+  if (skills.length === 0) {
+    return "No skills available. Run `knowhow behaviors download --skills-only` to fetch skills.";
+  }
+  return skills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+}
+
+/**
+ * Load full instructions for a named skill from memory.
+ */
+export async function loadSkill(
+  this: ToolsService,
+  name: string
+): Promise<string> {
+  const toolService =
+    this instanceof ToolsService ? (this as ToolsService) : services().Tools;
+
+  const { Behaviors } = toolService.getContext();
+
+  const skill = Behaviors.findSkill(name);
+  if (!skill) {
+    const names = Behaviors.listSkills()
+      .map((s) => s.name)
+      .join(", ");
+    return `Skill "${name}" not found. Available skills: ${names || "none"}`;
+  }
+  return `## Skill: ${skill.name}\n\n${skill.instructions}`;
+}
+
+/** Tool definitions for listSkills + loadSkill */
+export const skillsToolDefinitions = [
+  {
+    type: "function" as const,
+    function: {
+      name: "listSkills",
+      description:
+        "List all available skills by name and description. Call this to discover what skills are available before loading one.",
+      parameters: {
+        type: "object" as const,
+        positional: true,
+        properties: {} as Record<string, never>,
+        required: [] as string[],
+      },
+    },
+  },
+  {
+    type: "function" as const,
+    function: {
+      name: "loadSkill",
+      description:
+        "Load the full instructions for a named skill. Use this when you need to follow a specific skill's guidance.",
+      parameters: {
+        type: "object" as const,
+        positional: true,
+        properties: {
+          name: {
+            type: "string",
+            description:
+              "The skill name to load (must match exactly or approximately)",
+          },
+        },
+        required: ["name"] as string[],
+      },
+    },
+  },
+];

package/src/chat/modules/AgentModule.ts

@@ -18,7 +18,7 @@ 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 { Message, CompletionOptions } from "../../clients/types";
 import { ChatInteraction } from "../../types";
 import { Marked } from "../../utils/index";
 import { TokenCompressor } from "../../processors/TokenCompressor";
@@ -28,6 +28,7 @@ import {
   XmlToolCallProcessor,
   HarmonyToolProcessor,
   Base64ImageProcessor,
+  MinimalToolsMessageProcessor,
 } from "../../processors/index";
 import { TaskInfo } from "../types";
 import { createAgent, agentConstructors, AgentName } from "../../agents";
@@ -51,6 +52,11 @@ export class AgentModule extends BaseChatModule {
   /** Currently active synced agent watcher (for FS or Web agents) */
   private activeSyncedWatcher: SyncedAgentWatcher | undefined;
 
+  /** Reasoning effort to apply to agents started from this module */
+  private reasoningEffort: CompletionOptions["reasoning_effort"] | undefined = undefined;
+  /** Whether to request a reasoning summary from supporting models */
+  private summarizeReasoning: boolean = true;
+
   /** Stored wire params for rewireAgentRendering */
   private _wireAgentEvents: EventService | undefined;
   private _wireTaskId: string | undefined;
@@ -124,14 +130,89 @@ export class AgentModule extends BaseChatModule {
       },
       {
         name: "poke",
-        description: "Interrupt the agent's current tool call or AI completion, so it can continue with the next step",
+        description:
+          "Interrupt the agent's current tool call or AI completion, so it can continue with the next step",
         modes: ["agent:attached"],
         handler: async (args: string[]): Promise<void> => {
           if (this.attachedAgent) {
             const message = args.length > 0 ? args.join(" ") : undefined;
             this.attachedAgent.interrupt(message);
-            console.log("Agent interrupted — it will continue with the next step.");
+            console.log(
+              "Agent interrupted — it will continue with the next step."
+            );
+          }
+        },
+      },
+      {
+        name: "reasoning_effort",
+        description:
+          "Set the reasoning effort for the agent (none, low, medium, high). Use 'none' to disable thinking on models that support it.",
+        handler: async (args: string[]): Promise<void> => {
+          const validEfforts: CompletionOptions["reasoning_effort"][] = [
+            "none",
+            "low",
+            "medium",
+            "high",
+          ];
+          const effort = args[0] as CompletionOptions["reasoning_effort"];
+          if (!effort || !validEfforts.includes(effort)) {
+            console.log(
+              `Current reasoning effort: ${this.reasoningEffort ?? "(not set — model default)"}`
+            );
+            console.log(
+              `Usage: /reasoning_effort <${validEfforts.join("|")}>`
+            );
+            return;
           }
+          this.reasoningEffort = effort;
+          const agent = (this.chatService?.getContext()?.selectedAgent as BaseAgent);
+          if (agent) agent.setReasoningEffort(effort);
+          console.log(`Reasoning effort set to: ${effort}`);
+        },
+      },
+      {
+        name: "effort",
+        description: "Alias for /reasoning_effort",
+        handler: async (args: string[]): Promise<void> => {
+          const validEfforts: CompletionOptions["reasoning_effort"][] = [
+            "none",
+            "low",
+            "medium",
+            "high",
+          ];
+          const effort = args[0] as CompletionOptions["reasoning_effort"];
+          if (!effort || !validEfforts.includes(effort)) {
+            console.log(
+              `Current reasoning effort: ${this.reasoningEffort ?? "(not set — model default)"}`
+            );
+            console.log(
+              `Usage: /effort <${validEfforts.join("|")}>`
+            );
+            return;
+          }
+          this.reasoningEffort = effort;
+          const agent = (this.chatService?.getContext()?.selectedAgent as BaseAgent);
+          if (agent) agent.setReasoningEffort(effort);
+          console.log(`Reasoning effort set to: ${effort}`);
+        },
+      },
+      {
+        name: "reasoning_summary",
+        description:
+          "Toggle whether the agent displays a reasoning summary (true/false). Supported by reasoning models only.",
+        handler: async (args: string[]): Promise<void> => {
+          const val = args[0];
+          if (val !== "true" && val !== "false") {
+            console.log(
+              `Current reasoning summary: ${this.summarizeReasoning}`
+            );
+            console.log(`Usage: /reasoning_summary <true|false>`);
+            return;
+          }
+          this.summarizeReasoning = val === "true";
+          const agent = (this.chatService?.getContext()?.selectedAgent as BaseAgent);
+          if (agent) agent.setSummarizeReasoning(this.summarizeReasoning);
+          console.log(`Reasoning summary set to: ${this.summarizeReasoning}`);
         },
       },
       {
@@ -531,10 +612,14 @@ export class AgentModule extends BaseChatModule {
       const threads = session.threads || [];
       // Guard against sessions saved with a flat Message[] instead of Message[][]
       // (a bug where threadUpdate emitted a single thread instead of all threads)
-      const normalizedThreads: Message[][] = threads.length > 0 && !Array.isArray(threads[0])
-        ? [threads as unknown as Message[]]
-        : threads as Message[][];
-      const lastThread = normalizedThreads.length > 0 ? normalizedThreads[normalizedThreads.length - 1] : [];
+      const normalizedThreads: Message[][] =
+        threads.length > 0 && !Array.isArray(threads[0])
+          ? [threads as unknown as Message[]]
+          : (threads as Message[][]);
+      const lastThread =
+        normalizedThreads.length > 0
+          ? normalizedThreads[normalizedThreads.length - 1]
+          : [];
       const resumeMessages = [...lastThread];
 
       // Append the resume prompt to the last user message (or add a new one)
@@ -548,7 +633,9 @@ export class AgentModule extends BaseChatModule {
         const actualIndex = lastThread.length - 1 - reversedIndex;
         resumeMessages[actualIndex] = {
           ...resumeMessages[actualIndex],
-          content: resumeMessages[actualIndex].content + `\n\n<Workflow>[RESUME CONTEXT]: ${resumePrompt}</Workflow>`,
+          content:
+            resumeMessages[actualIndex].content +
+            `\n\n<Workflow>[RESUME CONTEXT]: ${resumePrompt}</Workflow>`,
         };
       }
 
@@ -584,7 +671,12 @@ export class AgentModule extends BaseChatModule {
         }
       });
 
-      await this.attachedAgentChatLoop(taskId, agent, resumePrompt, resumeMessages);
+      await this.attachedAgentChatLoop(
+        taskId,
+        agent,
+        resumePrompt,
+        resumeMessages
+      );
     } catch (error) {
       console.error(
         `Failed to resume session ${sessionId}:`,
@@ -739,6 +831,12 @@ export class AgentModule extends BaseChatModule {
         ]);
       }
 
+      // Apply module-level reasoning settings to the agent
+      if (this.reasoningEffort !== undefined) {
+        agent.setReasoningEffort(this.reasoningEffort);
+      }
+      agent.setSummarizeReasoning(this.summarizeReasoning);
+
       // Set up message processors like in original startAgent
 
       // Register an override for askHuman to use CLI input method
@@ -781,6 +879,10 @@ export class AgentModule extends BaseChatModule {
         new HarmonyToolProcessor().createProcessor(),
       ]);
 
+      agent.messageProcessor.setProcessors("pre_tools", [
+        new MinimalToolsMessageProcessor().createProcessor(),
+      ]);
+
       agent.messageProcessor.setProcessors("post_tools", [
         new Base64ImageProcessor(agent.tools).createProcessor(),
         ...caching,

package/src/cli.ts

@@ -38,6 +38,8 @@ import {
 } from "./commands/misc";
 import { addConvertCommand } from "./commands/convert";
 import { addReplayCommand } from "./commands/replay";
+import { addBehaviorsCommand } from "./commands/behaviors";
+import { addSkillsCommand } from "./commands/skills";
 
 // Handle unhandled promise rejections gracefully — particularly from MCP SDK
 // which fires errors via event emitters that can bypass Promise.allSettled.
@@ -102,6 +104,8 @@ async function main() {
   addMcpCommands(program);
   addConvertCommand(program);
   addReplayCommand(program);
+  addBehaviorsCommand(program);
+  addSkillsCommand(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/anthropic.ts

@@ -1,6 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { wait } from "../utils";
-import { AnthropicTextPricing } from "./pricing";
+import { AnthropicTextPricing, AnthropicModels } from "./pricing";
 import { ContextLimits } from "./contextLimits";
 import { ModelModality } from "./types";
 import { Models } from "../types";
@@ -24,6 +24,16 @@ import {
 
 type MessageParam = Anthropic.MessageParam;
 type Usage = Anthropic.Usage;
+type ThinkingParam = Anthropic.Messages.ThinkingConfigParam;
+
+const alwaysOnModels: readonly string[] = [
+  AnthropicModels.Sonnet5, AnthropicModels.Fable5,
+  AnthropicModels.Mythos5, AnthropicModels.MythosPreview,
+];
+const optInModels: readonly string[] = [
+  AnthropicModels.Opus4_8, AnthropicModels.Opus4_7,
+  AnthropicModels.Opus4_6, AnthropicModels.Sonnet4_6,
+];
 
 export class GenericAnthropicClient implements GenericClient {
   private client: Anthropic;
@@ -48,6 +58,36 @@ export class GenericAnthropicClient implements GenericClient {
     }
   }
 
+  /**
+   * Determine the Anthropic `thinking` param from CompletionOptions.
+   * Returns undefined if the model does not support thinking.
+   */
+  getThinkingParam(
+    model: string,
+    reasoning_effort?: CompletionOptions["reasoning_effort"],
+    reasoning_summary?: boolean,
+  ): ThinkingParam | undefined {
+    const effortIsNone = reasoning_effort === "none";
+    const withSummary = reasoning_summary ? ({ display: "summarized" } as const) : {};
+
+    if (alwaysOnModels.includes(model)) {
+      return effortIsNone
+        ? { type: "disabled" }
+        : { type: "adaptive", ...withSummary };
+    }
+
+    if (optInModels.includes(model)) {
+      // Only enable when explicitly requested (not "none" and not undefined).
+      if (!effortIsNone && reasoning_effort !== undefined) {
+        return { type: "adaptive", ...withSummary };
+      }
+      return undefined;
+    }
+
+    // Model does not support thinking.
+    return undefined;
+  }
+
   /**
    * Clean JSON Schema for Anthropic API compatibility.
    * Removes unsupported fields like additionalProperties, $ref, $defs, positional.
@@ -360,6 +400,13 @@ export class GenericAnthropicClient implements GenericClient {
     options: CompletionOptions
   ): Promise<CompletionResponse> {
     const longTtl = !!options.long_ttl_cache;
+
+    const thinkingParam = this.getThinkingParam(
+      options.model,
+      options.reasoning_effort,
+      options.reasoning_summary,
+    );
+
     const systemMessage = options.messages
       .filter((msg) => msg.role === "system")
       .map((msg) => msg.content || "")
@@ -382,6 +429,7 @@ export class GenericAnthropicClient implements GenericClient {
             ]
           : undefined,
         max_tokens: options.max_tokens || 8000,
+        ...(thinkingParam && { thinking: thinkingParam }),
         ...(tools.length && {
           tool_choice: { type: "auto" },
           tools,
@@ -431,6 +479,16 @@ export class GenericAnthropicClient implements GenericClient {
           total_tokens: (response.usage.input_tokens ?? 0) + (response.usage.output_tokens ?? 0),
           cache_creation_input_tokens: response.usage.cache_creation_input_tokens ?? 0,
           cache_read_input_tokens: response.usage.cache_read_input_tokens ?? 0,
+          ...((response.usage as any).thinking_input_tokens != null ||
+              (response.usage as any).output_tokens_details?.thinking_tokens != null
+            ? {
+                output_tokens_details: {
+                  thinking_tokens:
+                    (response.usage as any).thinking_input_tokens ??
+                    (response.usage as any).output_tokens_details?.thinking_tokens ?? 0,
+                },
+              }
+            : {}),
         } : undefined,
         usd_cost: this.calculateCost(options.model, response.usage),
       };

package/src/clients/contextLimits.ts

@@ -10,6 +10,9 @@ import { Models, EmbeddingModels } from "../types";
  */
 export const ContextLimits: Record<string, number> = {
   // ─── OpenAI ───────────────────────────────────────────────────────────────
+  [Models.openai.GPT_56_Sol]: 1_000_000,
+  [Models.openai.GPT_56_Terra]: 1_000_000,
+  [Models.openai.GPT_56_Luna]: 1_000_000,
   [Models.openai.GPT_55]: 1_000_000,
   [Models.openai.GPT_54]: 1_000_000,
   [Models.openai.GPT_54_Mini]: 400_000,
@@ -83,6 +86,11 @@ export const ContextLimits: Record<string, number> = {
   // ─── Anthropic ────────────────────────────────────────────────────────────
   [Models.anthropic.Opus4_8Fast]: 1_000_000,
   [Models.anthropic.Opus4_8]: 1_000_000,
+  // Claude 5 generation (launched 2026-06-09, 1M context window)
+  [Models.anthropic.Fable5]: 1_000_000,
+  [Models.anthropic.Sonnet5]: 1_000_000,
+  [Models.anthropic.Mythos5]: 1_000_000,
+  [Models.anthropic.MythosPreview]: 1_000_000,
   [Models.anthropic.Opus4_7]: 1_000_000,
   [Models.anthropic.Opus4_6]: 1_000_000,
   [Models.anthropic.Opus4_6Fast]: 1_000_000,
@@ -166,6 +174,7 @@ export const ContextLimits: Record<string, number> = {
   [Models.xai.GrokBeta]: 131_072,
   [Models.xai.GrokVisionBeta]: 131_072,
   [Models.xai.Grok4_1_Fast]: 2_000_000,
+  [Models.xai.Grok4_5]: 500_000,
   [Models.xai.Grok4Fast]: 2_000_000,
   [Models.xai.Grok4FastNonReasoning]: 2_000_000,
   // xAI image/video models — no text context window

package/src/clients/index.ts

@@ -41,6 +41,7 @@ import {
   XaiImagePricing,
   XaiVideoPricing,
 } from "./pricing/xai";
+import { MetaTextPricing } from "./pricing/meta";
 import type {
   ModelPricing,
   ModelType,
@@ -56,6 +57,7 @@ import { GenericMistralClient } from "./mistral";
 import { GitHubCopilotClient } from "./copilot";
 import { GenericLlamaClient } from "./llama";
 import { GenericFireworksClient } from "./fireworks";
+import { GenericMetaClient } from "./meta";
 export {
   OpenAiTextPricing,
   AnthropicTextPricing,
@@ -100,6 +102,7 @@ const BUILT_IN_PROVIDER_REGISTRY: Record<string, ProviderRegistryEntry> = {
   "github-copilot": { clientClass: GitHubCopilotClient },
   llama: { clientClass: GenericLlamaClient },
   fireworks: { clientClass: GenericFireworksClient },
+  meta: { clientClass: GenericMetaClient },
   knowhow: {
     createClient: (entry: ModelProvider) => {
       const jwt = loadKnowhowJwt();
@@ -130,6 +133,7 @@ const DEFAULT_PROVIDERS: ModelProvider[] = [
   { provider: "github-copilot", envKey: "GITHUB_COPILOT_TOKEN" },
   { provider: "llama", envKey: "LLAMA_API_KEY" },
   { provider: "fireworks", envKey: "FIREWORKS_API_KEY" },
+  { provider: "meta", envKey: "META_API_KEY" },
 ];
 
 export class AIClient {
@@ -1021,6 +1025,7 @@ export class AIClient {
       ...GeminiPricing,
       ...XaiTextPricing,
       ...FireworksTextPricing,
+      ...MetaTextPricing,
     };
     const allImagePricing: Record<string, ModelPricing> = {
       ...XaiImagePricing,
@@ -1066,3 +1071,4 @@ export * from "./mistral";
 export * from "./llama";
 export * from "./copilot";
 export * from "./fireworks";
+export * from "./meta";

package/src/clients/meta.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from "./http";
+import { MetaTextPricing } from "./pricing/meta";
+
+/**
+ * Meta Model API client — OpenAI-compatible API
+ * https://api.meta.ai
+ * Drop-in compatible with the OpenAI SDK (Responses + Chat Completions) and
+ * the Anthropic SDK (Messages API). Serves Meta's Muse Spark model with a
+ * 1,048,576 token context window.
+ * Set env var META_API_KEY to enable.
+ */
+export class GenericMetaClient extends HttpClient {
+  constructor(apiKey = process.env.META_API_KEY) {
+    super("https://api.meta.ai");
+    if (apiKey) this.setJwt(apiKey);
+    this.setPrices(MetaTextPricing);
+  }
+}

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

@@ -9,6 +9,10 @@ import { completions, ModelCatalogEntry, ModelPricing } from "./types";
 
 export const AnthropicModels = {
   // Active models
+  Fable5:    "claude-fable-5",
+  Sonnet5:   "claude-sonnet-5",
+  Mythos5:   "claude-mythos-5",
+  MythosPreview: "claude-mythos-preview",
   Opus4_8:   "claude-opus-4-8",
   Opus4_8Fast: "claude-opus-4-8-fast",
   Opus4_7:   "claude-opus-4-7",
@@ -39,6 +43,8 @@ export const AnthropicModels = {
 
 export const AnthropicTextModels: string[] = [
   AnthropicModels.Opus4_8,
+  AnthropicModels.Fable5,
+  AnthropicModels.Sonnet5,
   AnthropicModels.Opus4_7,
   AnthropicModels.Opus4_6,
   AnthropicModels.Sonnet4_6,
@@ -51,6 +57,8 @@ export const AnthropicTextModels: string[] = [
 // Models in our catalog but not yet publicly available
 export const AnthropicLimitedAvailabilityModels: string[] = [
   AnthropicModels.Opus4_8Fast, // fast mode pricing
+  AnthropicModels.Mythos5,     // invitation-only (Project Glasswing)
+  AnthropicModels.MythosPreview, // invitation-only (defensive cybersecurity)
   AnthropicModels.Opus4_6Fast, // 404 – not publicly available yet
 ];
 
@@ -80,6 +88,11 @@ const AnthropicAllModels: string[] = [
 export const AnthropicTextPricing: Record<string, ModelPricing> = {
   [AnthropicModels.Opus4_8]:   { input: 5.0,  cache_write: 6.25,   cache_hit: 0.5,  output: 25.0 },
   [AnthropicModels.Opus4_8Fast]: { input: 10.0, cache_write: 12.5,  cache_hit: 1.0,  output: 50.0, limitedAvailability: true },
+  // Claude 5 generation (launched 2026-06-09)
+  [AnthropicModels.Fable5]:    { input: 10.0, cache_write: 12.5,   cache_hit: 1.0,  output: 50.0 },
+  [AnthropicModels.Sonnet5]:   { input: 3.0,  cache_write: 3.75,   cache_hit: 0.3,  output: 15.0 },
+  [AnthropicModels.Mythos5]:   { input: 10.0, cache_write: 12.5,   cache_hit: 1.0,  output: 50.0, limitedAvailability: true },
+  [AnthropicModels.MythosPreview]: { input: 10.0, cache_write: 12.5, cache_hit: 1.0, output: 50.0, limitedAvailability: true },
   [AnthropicModels.Opus4_7]:   { input: 5.0,  cache_write: 6.25,   cache_hit: 0.5,  output: 25.0 },
   [AnthropicModels.Opus4_6]:   { input: 5.0,  cache_write: 6.25,   cache_hit: 0.5,  output: 25.0 },
   [AnthropicModels.Opus4_6Fast]: { input: 30.0, cache_write: 37.5, cache_hit: 3.0,  output: 150.0, limitedAvailability: true },

package/src/clients/pricing/fireworks.ts

@@ -1,8 +1,10 @@
+import { ModelPricing } from "./types";
+
 /**
  * Fireworks AI pricing (USD per 1M tokens)
  * Source: https://fireworks.ai/pricing
  */
-export const FireworksTextPricing: Record<string, { input: number; output: number; cache_hit?: number }> = {
+export const FireworksTextPricing: Record<string, ModelPricing> = {
   // 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 },
@@ -14,22 +16,26 @@ export const FireworksTextPricing: Record<string, { input: number; output: numbe
   "accounts/fireworks/models/minimax-m2-5": { input: 0.30, cache_hit: 0.03, output: 1.20 },
 
   // Qwen
-  "accounts/fireworks/models/qwen3-6-plus": { input: 0.50, cache_hit: 0.10, output: 3.0 },
-  "accounts/fireworks/models/qwen3p6-plus": { input: 0.50, cache_hit: 0.10, output: 3.0 },
-  "accounts/fireworks/models/qwen3-vl-30b-a3b-thinking": { input: 0.15, cache_hit: 0.08, output: 0.60 },
-  "accounts/fireworks/models/qwen3-vl-30b-a3b-instruct": { input: 0.15, cache_hit: 0.08, output: 0.60 },
-  "accounts/fireworks/models/qwen3-8b": { input: 0.20, cache_hit: 0.10, output: 0.20 },
+  "accounts/fireworks/models/qwen3p7-plus": { input: 0.40, cache_hit: 0.08, output: 1.60 },
+
+  // Deprecated QWEN Models
+  "accounts/fireworks/models/qwen3-6-plus": { input: 0.50, cache_hit: 0.10, output: 3.0, deprecated: true},
+  "accounts/fireworks/models/qwen3p6-plus": { input: 0.50, cache_hit: 0.10, output: 3.0, deprecated: true},
+  "accounts/fireworks/models/qwen3-vl-30b-a3b-thinking": { input: 0.15, cache_hit: 0.08, output: 0.60, deprecated: true},
+  "accounts/fireworks/models/qwen3-vl-30b-a3b-instruct": { input: 0.15, cache_hit: 0.08, output: 0.60, deprecated: true},
+  "accounts/fireworks/models/qwen3-8b": { input: 0.20, cache_hit: 0.10, output: 0.20, deprecated: true},
 
   // Z.ai
   "accounts/fireworks/models/glm-5p2": { input: 1.40, cache_hit: 0.26, output: 4.40 },
-  "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 },
+  "accounts/fireworks/models/glm-5p1": { 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, deprecated: true },
+  "accounts/fireworks/models/glm-4-7": { input: 0.60, cache_hit: 0.30, output: 2.20, deprecated: true},
 
   // DeepSeek AI
-  "accounts/fireworks/models/deepseek-v3-2": { input: 0.56, cache_hit: 0.28, output: 1.68 },
-  "accounts/fireworks/models/deepseek-v3-1": { input: 0.56, cache_hit: 0.28, output: 1.68 },
+  "accounts/fireworks/models/deepseek-v4-pro": { input: 1.74, cache_hit: 0.15, output: 3.48 },
+  "accounts/fireworks/models/deepseek-v4-flash": { input: 0.14, cache_hit: 0.03, output: 0.28 },
+  "accounts/fireworks/models/deepseek-v3-2": { input: 0.56, cache_hit: 0.28, output: 1.68, deprecated: true },
+  "accounts/fireworks/models/deepseek-v3-1": { input: 0.56, cache_hit: 0.28, output: 1.68, deprecated: true },
 
   // OpenAI OSS
   "accounts/fireworks/models/gpt-oss-120b": { input: 0.15, cache_hit: 0.01, output: 0.60 },

package/src/clients/pricing/index.ts

@@ -36,6 +36,7 @@ export { OpenRouterTextPricing } from "./openrouter";
 export { LlamaTextPricing } from "./llama";
 export { CopilotTextPricing, CopilotModelMultipliers } from "./copilot";
 export { FireworksTextPricing } from "./fireworks";
+export { MetaTextPricing, MetaWebSearchPricingPer1000Queries } from "./meta";
 
 // ─── Combined catalog ─────────────────────────────────────────────────────────
 export { ALL_MODEL_CATALOG, USAGE_MARKUP_PERCENT } from "./models";