@tyvm/knowhow 0.0.129 → 0.0.131

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";
@@ -52,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;
@@ -138,6 +143,78 @@ export class AgentModule extends BaseChatModule {
           }
         },
       },
+      {
+        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}`);
+        },
+      },
       {
         name: "detach",
         description: "Detach from the currently attached agent",
@@ -656,22 +733,24 @@ export class AgentModule extends BaseChatModule {
     run?: boolean; // whether to run immediately
     taskId?: string; // optional pre-generated taskId
   }) {
-    if (!agentConstructors[options.agentName as AgentName]) {
-      throw new Error(
-        `Agent "${
-          options.agentName
-        }" not found. Available agents: ${Object.keys(agentConstructors).join(
-          ", "
-        )}`
-      );
-    }
-
     const { input, chatHistory = [], agentName } = options;
     const agentContext = services().Agents.getAgentContext();
-    const agent = createAgent(
-      options.agentName as AgentName,
-      agentContext
-    ) as BaseAgent;
+
+    // Resolve agent: built-in agents first, then fall back to ConfigAgents from knowhow.json
+    let agent: BaseAgent;
+    if (agentConstructors[options.agentName as AgentName]) {
+      agent = createAgent(options.agentName as AgentName, agentContext) as BaseAgent;
+    } else {
+      // Try to find a ConfigAgent registered via loadAgentsFromConfig (from knowhow.json agents[])
+      try {
+        const configAgent = services().Agents.getAgent(options.agentName);
+        agent = configAgent as unknown as BaseAgent;
+      } catch {
+        throw new Error(
+          `Agent "${options.agentName}" not found. Available agents: ${Object.keys(agentConstructors).join(", ")} (plus any agents defined in knowhow.json)`
+        );
+      }
+    }
 
     let done = false;
     let output = "Done";
@@ -754,6 +833,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
@@ -832,7 +917,63 @@ export class AgentModule extends BaseChatModule {
       agent.agentEvents.on(agent.eventTypes.agentLog, agentLogHandler);
       agent.agentEvents.on(agent.eventTypes.agentStatus, agentStatusHandler);
 
+      // Wire tool call / tool result / agent message rendering so that all
+      // renderer types (including PlainRenderer for non-TTY) receive events
+      // even when running via the CLI `knowhow agent` command (which uses
+      // run:true and does NOT go through attachedAgentChatLoop / wireAgentRendering).
+      const toolCallHandler = (data: any) => {
+        this.renderer.render({
+          type: "toolCall",
+          taskId,
+          agentName: agent.name,
+          toolCall: data.toolCall,
+        });
+      };
+      const toolResultHandler = (data: any) => {
+        this.renderer.render({
+          type: "toolResult",
+          taskId,
+          agentName: agent.name,
+          toolCall: data.toolCall,
+          result: data.functionResp,
+        });
+      };
+      const agentSayHandler = (data: any) => {
+        this.renderer.render({
+          type: "agentMessage",
+          taskId,
+          agentName: agent.name,
+          message: data.message,
+          role: "assistant",
+        });
+      };
+      if (agent.eventTypes.toolCall) {
+        agent.agentEvents.on(agent.eventTypes.toolCall, toolCallHandler);
+      }
+      if (agent.eventTypes.toolUsed) {
+        agent.agentEvents.on(agent.eventTypes.toolUsed, toolResultHandler);
+      }
+      if (agent.eventTypes.agentSay) {
+        agent.agentEvents.on(agent.eventTypes.agentSay, agentSayHandler);
+      }
+      // Track the active task on the renderer so it doesn't filter out events
+      this.renderer.setActiveTaskId(taskId);
+      this.activeAgentTaskId = taskId;
+
       const taskCompleted = new Promise<string>((resolve) => {
+          // Remove tool rendering listeners
+          if (agent.eventTypes.toolCall) {
+            agent.agentEvents.removeListener(agent.eventTypes.toolCall, toolCallHandler);
+          }
+          if (agent.eventTypes.toolUsed) {
+            agent.agentEvents.removeListener(agent.eventTypes.toolUsed, toolResultHandler);
+          }
+          if (agent.eventTypes.agentSay) {
+            agent.agentEvents.removeListener(agent.eventTypes.agentSay, agentSayHandler);
+          }
+          // Clear active task on renderer
+          this.renderer.setActiveTaskId(undefined);
+          this.activeAgentTaskId = undefined;
         agent.agentEvents.once(agent.eventTypes.done, async (doneMsg) => {
           console.log("🎯 [AgentModule] Task Completed");
           done = true;

package/src/chat/renderer/PlainRenderer.ts

@@ -0,0 +1,218 @@
+/**
+ * PlainRenderer - A plain-text, append-only renderer for non-TTY environments.
+ *
+ * Used automatically when stdout is not a TTY (e.g. redirected to a file,
+ * piped, or run in background). Emits simple timestamped log lines with no
+ * ANSI codes, no cursor movement, and no spinner — safe for logfiles.
+ *
+ * Activate explicitly via:
+ *   knowhow agent --renderer plain ...
+ * or it is selected automatically when !process.stdout.isTTY and no renderer
+ * is configured.
+ */
+
+import {
+  AgentRenderer,
+  LogEvent,
+  AgentStatusEvent,
+  ToolCallEvent,
+  ToolResultEvent,
+  AgentMessageEvent,
+  AgentDoneEvent,
+  RenderEvent,
+} from "./types";
+import { EventEmitter } from "events";
+
+function ts(): string {
+  return new Date().toISOString();
+}
+
+function truncate(s: string, n: number): string {
+  return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+
+function formatArgs(raw: string): string {
+  try {
+    const obj = JSON.parse(raw || "{}");
+    const entries = Object.entries(obj);
+    if (!entries.length) return "{}";
+    return entries
+      .map(([k, v]) => {
+        const val = typeof v === "string" ? v : JSON.stringify(v);
+        return `${k}=${truncate(val, 80)}`;
+      })
+      .join(", ");
+  } catch {
+    return truncate(raw || "", 120);
+  }
+}
+
+function formatResult(result: any): string {
+  try {
+    const s = typeof result === "string" ? result : JSON.stringify(result);
+    return truncate(s.replace(/\s+/g, " "), 200);
+  } catch {
+    return truncate(String(result), 200);
+  }
+}
+
+export class PlainRenderer implements AgentRenderer {
+  private activeTaskId: string | undefined;
+  private emitter = new EventEmitter();
+  private paused = false;
+  private bufferedEvents: RenderEvent[] = [];
+
+  setActiveTaskId(taskId: string | undefined): void {
+    this.activeTaskId = taskId;
+  }
+
+  getActiveTaskId(): string | undefined {
+    return this.activeTaskId;
+  }
+
+  private isActiveTask(taskId: string): boolean {
+    if (!this.activeTaskId) return true;
+    return taskId === this.activeTaskId;
+  }
+
+  onLog(handler: (event: LogEvent) => void): void {
+    this.emitter.on("log", handler);
+  }
+
+  onAgentStatus(handler: (event: AgentStatusEvent) => void): void {
+    this.emitter.on("agentStatus", handler);
+  }
+
+  onToolCall(handler: (event: ToolCallEvent) => void): void {
+    this.emitter.on("toolCall", handler);
+  }
+
+  onToolResult(handler: (event: ToolResultEvent) => void): void {
+    this.emitter.on("toolResult", handler);
+  }
+
+  onAgentMessage(handler: (event: AgentMessageEvent) => void): void {
+    this.emitter.on("agentMessage", handler);
+  }
+
+  onAgentDone(handler: (event: AgentDoneEvent) => void): void {
+    this.emitter.on("agentDone", handler);
+  }
+
+  pause(): void {
+    this.paused = true;
+  }
+
+  resume(): void {
+    this.paused = false;
+    const buffered = this.bufferedEvents.splice(0);
+    for (const event of buffered) {
+      this.render(event);
+    }
+  }
+
+  render(event: RenderEvent): void {
+    if (!this.isActiveTask(event.taskId)) return;
+
+    if (this.paused) {
+      this.bufferedEvents.push(event);
+      return;
+    }
+
+    this.emitter.emit(event.type, event);
+
+    switch (event.type) {
+      case "log":
+        this._log(event);
+        break;
+      case "agentStatus":
+        this._status(event);
+        break;
+      case "toolCall":
+        this._toolCall(event);
+        break;
+      case "toolResult":
+        this._toolResult(event);
+        break;
+      case "agentMessage":
+        this._message(event);
+        break;
+      case "agentDone":
+        this._done(event);
+        break;
+    }
+  }
+
+  private _write(line: string): void {
+    process.stdout.write(line + "\n");
+  }
+
+  private _log(e: LogEvent): void {
+    const level = e.level.toUpperCase().padEnd(5);
+    this._write(`${ts()} [${level}] [${e.agentName}] ${e.message}`);
+  }
+
+  private _status(e: AgentStatusEvent): void {
+    const cost = `$${e.details.totalCostUsd.toFixed(3)}`;
+    const elapsed = `${Math.floor(e.details.elapsedMs / 1000)}s`;
+    const parts = [`cost=${cost}`, `elapsed=${elapsed}`];
+    if (e.details.remainingTurns !== undefined) {
+      parts.push(`turns_left=${e.details.remainingTurns}`);
+    }
+    if (e.details.remainingTimeMs !== undefined) {
+      parts.push(`time_left=${Math.floor(e.details.remainingTimeMs / 1000)}s`);
+    }
+    this._write(
+      `${ts()} [STATUS] [${e.agentName}] ${e.statusMessage} | ${parts.join(" | ")}`
+    );
+  }
+
+  private _toolCall(e: ToolCallEvent): void {
+    const args = formatArgs(e.toolCall.function.arguments);
+    this._write(
+      `${ts()} [TOOL->] [${e.agentName}] ${e.toolCall.function.name}(${args})`
+    );
+  }
+
+  private _toolResult(e: ToolResultEvent): void {
+    const result = formatResult(e.result);
+    this._write(
+      `${ts()} [TOOL<-] [${e.agentName}] ${e.toolCall.function.name} => ${result}`
+    );
+  }
+
+  private _message(e: AgentMessageEvent): void {
+    if (e.role !== "assistant") return;
+    // Print the message with line-by-line prefix
+    const lines = e.message.split("\n");
+    for (const line of lines) {
+      if (line.trim()) {
+        this._write(`${ts()} [MSG  ] [${e.agentName}] ${line}`);
+      }
+    }
+  }
+
+  private _done(e: AgentDoneEvent): void {
+    const cost = e.totalCost ? ` | total_cost=$${e.totalCost.toFixed(4)}` : "";
+    this._write(`${ts()} [DONE ] [${e.agentName}] Agent finished${cost}`);
+    // Print final output lines
+    const lines = e.output.split("\n");
+    for (const line of lines) {
+      if (line.trim()) {
+        this._write(`${ts()} [OUT  ] [${e.agentName}] ${line}`);
+      }
+    }
+  }
+
+  logMessages(events: RenderEvent[], count: number = 20): void {
+    const recent = events.slice(-count);
+    this._write(`\n[LOGS ] Last ${recent.length} events:`);
+    this._write("-".repeat(80));
+    for (const event of recent) {
+      this.render(event);
+    }
+    this._write("-".repeat(80));
+  }
+}
+
+export default PlainRenderer;

package/src/chat/renderer/index.ts

@@ -1,5 +1,6 @@
 export * from "./types";
 export { ConsoleRenderer } from "./ConsoleRenderer";
 export { FancyRenderer } from "./FancyRenderer";
+export { PlainRenderer } from "./PlainRenderer";
 export { CompactRenderer } from "./CompactRenderer";
 export { loadRenderer, loadRootModule, loadChatModule } from "./loadRenderer";

package/src/chat/renderer/loadRenderer.ts

@@ -12,6 +12,7 @@ import path from "path";
 import fs from "fs";
 import { AgentRenderer } from "./types";
 import { ConsoleRenderer } from "./ConsoleRenderer";
+import { PlainRenderer } from "./PlainRenderer";
 import { FancyRenderer } from "./FancyRenderer";
 import { CompactRenderer } from "./CompactRenderer";
 
@@ -19,6 +20,7 @@ import { CompactRenderer } from "./CompactRenderer";
 const BUILTIN_RENDERERS: Record<string, () => AgentRenderer> = {
   basic: () => new ConsoleRenderer(),
   fancy: () => new FancyRenderer(),
+  plain: () => new PlainRenderer(),
   compact: () => new CompactRenderer(),
 };
 

package/src/chat.ts

@@ -21,7 +21,7 @@ import { getConfig } from "./config.js";
 import { loadRenderer, loadRootModule, loadChatModule } from "./chat/renderer/loadRenderer.js";
 import { AgentModule } from "./chat/modules/AgentModule.js";
 
-async function main() {
+async function main(initialCommand?: string) {
   try {
     // Load configuration and plugins
     let config;
@@ -108,7 +108,7 @@ async function main() {
     }
 
     // Start the chat loop
-    await chatService.startChatLoop();
+    await chatService.startChatLoop(initialCommand);
   } catch (error) {
     console.error("Error starting chat:", error);
     process.exit(1);

package/src/cli.ts

@@ -1,4 +1,6 @@
 #!/usr/bin/env node --no-node-snapshot
+// Mark this process as running the Knowhow CLI (not just the SDK)
+process.env.KNOWHOW_CLI = "1";
 import { Command } from "commander";
 import { version } from "../package.json";
 import { logger } from "./logger";
@@ -38,6 +40,10 @@ import {
 } from "./commands/misc";
 import { addConvertCommand } from "./commands/convert";
 import { addReplayCommand } from "./commands/replay";
+import { addBehaviorsCommand } from "./commands/behaviors";
+import { addSkillsCommand } from "./commands/skills";
+import { addAgentsCommand } from "./commands/agents";
+import { addHashCommand } from "./commands/hash";
 
 // Handle unhandled promise rejections gracefully — particularly from MCP SDK
 // which fires errors via event emitters that can bypass Promise.allSettled.
@@ -102,6 +108,10 @@ async function main() {
   addMcpCommands(program);
   addConvertCommand(program);
   addReplayCommand(program);
+  addBehaviorsCommand(program);
+  addSkillsCommand(program);
+  addAgentsCommand(program);
+  addHashCommand(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),
       };
@@ -461,7 +519,15 @@ export class GenericAnthropicClient implements GenericClient {
     const rawP = this.pricesPerMillion()[model];
     // Fall back to pricing file for unknown/newer models
     const fallback = AnthropicTextPricing[model as keyof typeof AnthropicTextPricing];
-    const p: any = rawP || fallback || undefined;
+    // Second fallback: short aliases like "claude-sonnet-4-5" don't have their
+    // own entry but map to a dated version like "claude-sonnet-4-5-20250929".
+    // Find the first pricing entry whose key starts with the short model name.
+    const aliasFallback = !rawP && !fallback
+      ? Object.entries(AnthropicTextPricing).find(([key]) =>
+          key.startsWith(model + "-")
+        )?.[1]
+      : undefined;
+    const p: any = rawP || fallback || aliasFallback || undefined;
     if (!p) return undefined;
 
     const inputTokens = usage.input_tokens ?? 0;

package/src/clients/fireworks.ts

@@ -1,5 +1,5 @@
 import { HttpClient } from "./http";
-import { FireworksTextPricing } from "./pricing/fireworks";
+import { FireworksTextPricing, FireworksEmbeddingPricing } from "./pricing/fireworks";
 import { CompletionOptions, CompletionResponse } from "./types";
 
 type ModelInfo = { id: string; object: string; owned_by: string };
@@ -22,6 +22,15 @@ export class GenericFireworksClient extends HttpClient {
    * Our pricing map is the authoritative source of truth for available models.
    */
   async getModels(_type = "all"): Promise<ModelInfo[]> {
+    // Return embedding/reranker models when requested
+    if (_type === "embedding") {
+      return Object.keys(FireworksEmbeddingPricing).map((id) => ({
+        id,
+        object: "model",
+        owned_by: "fireworks",
+      }));
+    }
+
     return Object.keys(FireworksTextPricing).map((id) => ({
       id,
       object: "model",

package/src/clients/index.ts

@@ -310,9 +310,11 @@ export class AIClient {
 
       if (!client) {
         if (entry.provider === "knowhow") {
-          console.warn(
-            `⚠️  Knowhow provider is not logged in. Run 'knowhow login' to enable Knowhow models.`
-          );
+          if (process.env.KNOWHOW_CLI) {
+            console.warn(
+              `⚠️  Knowhow provider is not logged in. Run 'knowhow login' to enable Knowhow models.`
+            );
+          }
         }
         continue;
       }

package/src/clients/meta.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from "./http";
 import { MetaTextPricing } from "./pricing/meta";
+import { ModelModality } from "./types";
 
 /**
  * Meta Model API client — OpenAI-compatible API
@@ -15,4 +16,12 @@ export class GenericMetaClient extends HttpClient {
     if (apiKey) this.setJwt(apiKey);
     this.setPrices(MetaTextPricing);
   }
+
+  /**
+   * Meta Model API only provides chat completion models — no embeddings, images, audio, or video.
+   */
+  async getModels(type: ModelModality | "all" = "all") {
+    if (type === "embedding") return [];
+    return super.getModels(type as string);
+  }
 }