@tyvm/knowhow 0.0.151 → 0.0.154

package/package.json

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

package/src/agents/base/base.ts

@@ -1107,6 +1107,14 @@ export abstract class BaseAgent implements IAgent {
 
       // Typically, there's only one choice in the array, but you could have many
       // If you set `n` to more than 1, you will get multiple choices
+      // Collect all tool calls across all choices up front.
+      // This is used by detectTruncatedToolCalls so that the size heuristic
+      // compares the full completion_tokens against ALL argument content,
+      // rather than just the current choice's single tool call (Anthropic maps
+      // each parallel tool_use block to a separate choice).
+      const allResponseToolCalls = response.choices.flatMap(
+        (c) => c.message.tool_calls ?? []
+      );
       for (const choice of response.choices) {
         messages.push(choice.message);
 
@@ -1136,7 +1144,8 @@ export abstract class BaseAgent implements IAgent {
 
           const truncationWarning = this.detectTruncatedToolCalls(
             toolCalls,
-            response
+            response,
+            allResponseToolCalls
           );
           if (truncationWarning) {
             messages.push(truncationWarning as Message);
@@ -1589,11 +1598,14 @@ export abstract class BaseAgent implements IAgent {
    *   2. The model reported many output tokens but the total argument content received is tiny
    *      relative to what those tokens should represent (soft/silent truncation).
    *
+   * @param toolCalls - The tool calls from the CURRENT choice being checked.
+   * @param allToolCalls - ALL tool calls across ALL choices in the response (used for the size heuristic).
    * Returns a warning system message if truncation is detected, or null otherwise.
    */
   detectTruncatedToolCalls(
     toolCalls: ToolCall[],
-    response: CompletionResponse
+    response: CompletionResponse,
+    allToolCalls?: ToolCall[]
   ): { role: string; content: string } | null {
     // Subtract thinking/reasoning tokens — they're billed as output tokens but
     // don't produce visible argument content, so including them inflates the heuristic.
@@ -1602,7 +1614,13 @@ export abstract class BaseAgent implements IAgent {
       (response?.usage?.output_tokens_details?.thinking_tokens ?? 0) +
       (response?.usage?.output_tokens_details?.reasoning_tokens ?? 0);
     const outputTokens = Math.max(0, rawOutputTokens - thinkingTokens);
-    const totalArgLength = toolCalls.reduce(
+    // Use allToolCalls for the size heuristic so that parallel tool calls from
+    // Anthropic (each mapped to a separate choice) are counted together. Without
+    // this, a response with N parallel tool calls would compare the full
+    // completion_tokens count against only 1/N of the actual argument content,
+    // causing false-positive truncation warnings.
+    const callsForSizeCheck = allToolCalls ?? toolCalls;
+    const totalArgLength = callsForSizeCheck.reduce(
       (sum, tc) => sum + (tc.function?.arguments?.length || 0),
       0
     );
@@ -1688,9 +1706,13 @@ export abstract class BaseAgent implements IAgent {
       .filter((s): s is string => typeof s === "string" && s.trim().length > 0)
       .join("\n\n");
 
-    this.taskBreakdown = breakdownContent || "";
+    if (!breakdownContent) {
+      throw new Error("Compaction task-breakdown request returned no text content");
+    }
+
+    this.taskBreakdown = breakdownContent;
     this.log(`task breakdown cost: ${response.usd_cost}`);
-    return this.taskBreakdown || undefined;
+    return this.taskBreakdown;
   }
 
   async compressMessages(messages: Message[]) {
@@ -1742,6 +1764,10 @@ export abstract class BaseAgent implements IAgent {
     const summaries = response.choices
       .map((c) => c.message.content)
       .filter((s): s is string => typeof s === "string" && s.trim().length > 0);
+    if (summaries.length === 0) {
+      throw new Error("Compaction summary request returned no text content");
+    }
+
     this.summaries.push(...summaries);
 
     const startMessages = [

package/src/agents/tools/list.ts

@@ -31,34 +31,37 @@ function getPluginNames(): string {
 }
 
 export const includedTools = [
-  {
-    type: "function",
-    function: {
-      name: "agentCall",
-      description:
-        "Run another registered agent in-process as a blocking call and get its final answer back as a string. Unlike a plain llm() call, the target agent can use tools, loop, and maintain its own context. Useful as a graph node that delegates to a specialized agent (e.g. Researcher, Patcher). For long-running / parallel / detached work prefer startAgentTask.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          agentName: {
-            type: "string",
-            description:
-              "The name of the agent to call (e.g. Researcher, Developer, Patcher).",
-          },
-          query: {
-            type: "string",
-            description: "The query / task to send to the agent.",
-          },
-        },
-        required: ["agentName", "query"],
-      },
-      returns: {
-        type: "string",
-        description: "The agent's final answer text.",
-      },
-    },
-  },
+  /*
+   * This doesn't use messageProcessors etc, needs rewrite
+   *{
+   *  type: "function",
+   *  function: {
+   *    name: "agentCall",
+   *    description:
+   *      "Run another registered agent in-process as a blocking call and get its final answer back as a string. Unlike a plain llm() call, the target agent can use tools, loop, and maintain its own context. Useful as a graph node that delegates to a specialized agent (e.g. Researcher, Patcher). For long-running / parallel / detached work prefer startAgentTask.",
+   *    parameters: {
+   *      type: "object",
+   *      positional: true,
+   *      properties: {
+   *        agentName: {
+   *          type: "string",
+   *          description:
+   *            "The name of the agent to call (e.g. Researcher, Developer, Patcher).",
+   *        },
+   *        query: {
+   *          type: "string",
+   *          description: "The query / task to send to the agent.",
+   *        },
+   *      },
+   *      required: ["agentName", "query"],
+   *    },
+   *    returns: {
+   *      type: "string",
+   *      description: "The agent's final answer text.",
+   *    },
+   *  },
+   *},
+   */
   {
     type: "function",
     function: {

package/src/auth/keyManager.ts

@@ -6,6 +6,13 @@ import path from "path";
 const ED25519_KEY_TYPE = "ssh-ed25519";
 const ED25519_RAW_KEY_LENGTH = 32;
 const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+const ED25519_PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+
+interface OpenSshMetadata {
+  encrypted: boolean;
+  algorithm?: string;
+  seed?: Buffer;
+}
 
 export interface KeyPair {
   privateKeyPath: string;
@@ -90,6 +97,14 @@ export function getOrCreatePublicKey(privateKeyPath?: string): KeyPair {
     : generateKeyPair(privateKeyPath);
 }
 
+export function ensureIdentityKeyPair(privateKeyPath?: string): {
+  keyPair: KeyPair;
+  created: boolean;
+} {
+  if (keyPairExists(privateKeyPath)) return { keyPair: loadKeyPair(privateKeyPath), created: false };
+  return { keyPair: generateKeyPair(privateKeyPath), created: true };
+}
+
 export function signMessage(message: string, privateKeyPath?: string): string {
   const privatePath = privateKeyPath ?? getDefaultPrivateKeyPath();
   if (!fs.existsSync(privatePath)) throw new Error(`Private key not found at: ${privatePath}`);
@@ -98,14 +113,50 @@ export function signMessage(message: string, privateKeyPath?: string): string {
 
 function readEd25519PrivateKey(privatePath: string): crypto.KeyObject {
   let key: crypto.KeyObject;
+  const privateKeyContents = fs.readFileSync(privatePath, "utf8");
+  const openSshMetadata = parseOpenSshMetadata(privateKeyContents);
+
+  if (openSshMetadata?.encrypted) {
+    throw new Error(
+      `Identity at ${privatePath} is an encrypted OpenSSH key. Use an unencrypted Ed25519 key for CLI auth (example: ssh-keygen -t ed25519 -N '' -f ${privatePath})`
+    );
+  }
+
   try {
-    key = crypto.createPrivateKey(fs.readFileSync(privatePath));
+    key = crypto.createPrivateKey({ key: privateKeyContents, format: "pem" });
   } catch {
-    throw new Error(`Identity at ${privatePath} is not a supported PEM Ed25519 private key`);
+    if (openSshMetadata) {
+      if (openSshMetadata.algorithm && openSshMetadata.algorithm !== ED25519_KEY_TYPE) {
+        throw new Error(
+          `Identity at ${privatePath} must be an OpenSSH Ed25519 key (found ${openSshMetadata.algorithm})`
+        );
+      }
+
+      if (openSshMetadata.seed) {
+        key = createEd25519PrivateKeyFromSeed(openSshMetadata.seed, privatePath);
+      } else {
+        throw new Error(
+          `Identity at ${privatePath} must be a PKCS#8 Ed25519 private key or an unencrypted OpenSSH Ed25519 private key`
+        );
+      }
+      return key;
+    }
+
+    throw new Error(`Identity at ${privatePath} must be a PKCS#8 Ed25519 private key or an unencrypted OpenSSH Ed25519 private key`);
   }
+
+  const detectedAlgorithm = key.asymmetricKeyType === "ed25519" ? openSshMetadata?.algorithm ?? "ed25519" : key.asymmetricKeyType;
+
   if (key.asymmetricKeyType !== "ed25519") {
-    throw new Error(`Identity at ${privatePath} must be an Ed25519 private key`);
+    throw new Error(
+      `Identity at ${privatePath} must be an Ed25519 private key (found ${detectedAlgorithm ?? "unknown"})`
+    );
+  }
+
+  if (openSshMetadata?.algorithm && openSshMetadata.algorithm !== ED25519_KEY_TYPE) {
+    throw new Error(`Identity at ${privatePath} must be an OpenSSH Ed25519 key (found ${openSshMetadata.algorithm})`);
   }
+
   return key;
 }
 
@@ -164,3 +215,117 @@ function keyPairMetadata(privatePath: string, rawPublicKey: Buffer): KeyPair {
     fingerprint: `SHA256:${hash}`,
   };
 }
+
+function createEd25519PrivateKeyFromSeed(seed: Buffer, privatePath: string): crypto.KeyObject {
+  if (seed.length !== ED25519_RAW_KEY_LENGTH) {
+    throw new Error(`Identity at ${privatePath} has an invalid OpenSSH Ed25519 private key payload`);
+  }
+
+  try {
+    const der = Buffer.concat([ED25519_PKCS8_PREFIX, seed]);
+    return crypto.createPrivateKey({ key: der, format: "der", type: "pkcs8" });
+  } catch {
+    throw new Error(
+      `Identity at ${privatePath} must be a PKCS#8 Ed25519 private key or an unencrypted OpenSSH Ed25519 private key`
+    );
+  }
+}
+
+function parseOpenSshMetadata(privateKeyContents: string): OpenSshMetadata | undefined {
+  const trimmed = privateKeyContents.trim();
+  if (!trimmed.startsWith("-----BEGIN OPENSSH PRIVATE KEY-----")) {
+    return undefined;
+  }
+
+  const body = trimmed
+    .replace("-----BEGIN OPENSSH PRIVATE KEY-----", "")
+    .replace("-----END OPENSSH PRIVATE KEY-----", "")
+    .replace(/\s+/g, "");
+
+  let buffer: Buffer;
+  try {
+    buffer = Buffer.from(body, "base64");
+  } catch {
+    return undefined;
+  }
+
+  let offset = 0;
+
+  const magic = Buffer.from("openssh-key-v1\0", "utf8");
+  if (buffer.length < magic.length || !buffer.subarray(0, magic.length).equals(magic)) {
+    return undefined;
+  }
+  offset += magic.length;
+
+  const readString = (): string | undefined => {
+    if (offset + 4 > buffer.length) return undefined;
+    const length = buffer.readUInt32BE(offset);
+    offset += 4;
+    if (offset + length > buffer.length) return undefined;
+    const value = buffer.subarray(offset, offset + length).toString("utf8");
+    offset += length;
+    return value;
+  };
+
+  const readBuffer = (): Buffer | undefined => {
+    if (offset + 4 > buffer.length) return undefined;
+    const length = buffer.readUInt32BE(offset);
+    offset += 4;
+    if (offset + length > buffer.length) return undefined;
+    const value = buffer.subarray(offset, offset + length);
+    offset += length;
+    return value;
+  };
+
+  const ciphername = readString();
+  const kdfname = readString();
+  const kdfoptions = readBuffer();
+  if (!ciphername || !kdfname || !kdfoptions) {
+    return undefined;
+  }
+
+  if (offset + 4 > buffer.length) return { encrypted: ciphername !== "none" || kdfname !== "none" };
+  const keyCount = buffer.readUInt32BE(offset);
+  offset += 4;
+
+  for (let i = 0; i < keyCount; i++) {
+    const skippedPublic = readBuffer();
+    if (!skippedPublic) return { encrypted: ciphername !== "none" || kdfname !== "none" };
+  }
+
+  const privateBlock = readBuffer();
+  if (!privateBlock) return { encrypted: ciphername !== "none" || kdfname !== "none" };
+
+  let privateOffset = 0;
+  const readPrivateString = (): string | undefined => {
+    if (privateOffset + 4 > privateBlock.length) return undefined;
+    const length = privateBlock.readUInt32BE(privateOffset);
+    privateOffset += 4;
+    if (privateOffset + length > privateBlock.length) return undefined;
+    const value = privateBlock.subarray(privateOffset, privateOffset + length).toString("utf8");
+    privateOffset += length;
+    return value;
+  };
+
+  const readPrivateBuffer = (): Buffer | undefined => {
+    if (privateOffset + 4 > privateBlock.length) return undefined;
+    const length = privateBlock.readUInt32BE(privateOffset);
+    privateOffset += 4;
+    if (privateOffset + length > privateBlock.length) return undefined;
+    const value = privateBlock.subarray(privateOffset, privateOffset + length);
+    privateOffset += length;
+    return value;
+  };
+
+  privateOffset += 8; // checkints
+
+  const algorithm = readPrivateString();
+  let seed: Buffer | undefined;
+  if (algorithm === ED25519_KEY_TYPE) {
+    readPrivateBuffer(); // public key (32 bytes)
+    const privateConcat = readPrivateBuffer(); // private seed (32) + public key (32)
+    seed = privateConcat?.subarray(0, ED25519_RAW_KEY_LENGTH);
+  }
+
+  return { encrypted: ciphername !== "none" || kdfname !== "none", algorithm, seed };
+}

package/src/auth/registerIdentity.ts

@@ -28,7 +28,7 @@ export function decodeJwtPayload(jwt: string): Record<string, unknown> {
 
 export function extractOrgIdFromJwt(jwt: string): string {
   const payload = decodeJwtPayload(jwt);
-  const orgId = payload["org"] ?? payload["orgId"] ?? payload["org_id"] ?? payload["organizationId"];
+  const orgId = payload.org ?? payload.orgId ?? payload.org_id ?? payload.organizationId;
   if (typeof orgId !== "string" || !orgId) {
     throw new Error("JWT does not contain an organization claim (expected org, orgId, org_id, or organizationId)");
   }

package/src/clients/anthropic.ts

@@ -472,7 +472,9 @@ export class GenericAnthropicClient implements GenericClient {
         ...(thinkingParam && { thinking: thinkingParam }),
         ...(effortOutputConfig && { output_config: effortOutputConfig }),
         ...(tools.length && {
-          tool_choice: { type: "auto" },
+          tool_choice: {
+            type: options.tool_choice ?? "auto",
+          },
           tools,
         }),
       }, { signal: options.signal });

package/src/clients/contextLimits.ts

@@ -123,7 +123,8 @@ export const ContextLimits: Record<string, number> = {
   [Models.anthropic.Sonnet4_0]: 200_000,
 
   // ─── Google ───────────────────────────────────────────────────────────────
-  // Gemini 3.6 / 3.5 (text)
+  // Gemini 3.7 / 3.6 / 3.5 (text)
+  [Models.google.Gemini_37_Flash]: 1_048_576,
   [Models.google.Gemini_36_Flash]: 1_000_000,
   [Models.google.Gemini_35_Flash]: 1_000_000,
   [Models.google.Gemini_35_Flash_Lite]: 1_000_000,
@@ -178,6 +179,7 @@ export const ContextLimits: Record<string, number> = {
   [Models.google.Gemini_15_Pro]: 2_000_000,
 
   // ─── xAI ──────────────────────────────────────────────────────────────────
+  [Models.xai.Grok4_6]: 500_000,
   [Models.xai.Grok4_1_Fast_Reasoning]: 2_000_000,
   [Models.xai.Grok4_1_Fast_NonReasoning]: 2_000_000,
   [Models.xai.Grok_4_20_Reasoning]: 131_072,

package/src/clients/gemini.ts

@@ -420,7 +420,7 @@ export class GenericGeminiClient implements GenericClient {
 
   /**
    * Builds the thinkingConfig for Gemini models that support it.
-   * - Gemini 3.x models use thinkingLevel: "minimal" | "low" | "medium" | "high"
+   * - Gemini 3.x models use thinkingLevel (supported levels vary by model)
    * - Gemini 2.5 models use thinkingBudget: number (0 = off, -1 = dynamic)
    *
    * Maps CompletionOptions.reasoning_effort to provider-specific values.
@@ -433,9 +433,11 @@ export class GenericGeminiClient implements GenericClient {
 
     // Gemini 3.x — use thinkingLevel
     if (GoogleThinkingLevelModels.includes(model)) {
+      // Gemini 3.7 Flash rejects "minimal"; low is its least intensive level.
+      const minimumLevel = model === Models.google.Gemini_37_Flash ? "low" : "minimal";
       const levelMap: Record<string, string> = {
-        none: "minimal",
-        minimal: "minimal",
+        none: minimumLevel,
+        minimal: minimumLevel,
         low: "low",
         medium: "medium",
         high: "high",
@@ -474,6 +476,7 @@ export class GenericGeminiClient implements GenericClient {
     const { systemInstruction, contents } = this.transformMessages(
       options.messages
     );
+    const tools = this.transformTools(options.tools);
 
     try {
       await wait(2000);
@@ -483,7 +486,16 @@ export class GenericGeminiClient implements GenericClient {
         config: {
           systemInstruction,
           thinkingConfig,
-          tools: this.transformTools(options.tools),
+          tools,
+          ...(tools.length && {
+            toolConfig: {
+              functionCallingConfig: {
+                mode: options.tool_choice === "none"
+                  ? FunctionCallingConfigMode.NONE
+                  : FunctionCallingConfigMode.AUTO,
+              },
+            },
+          }),
           maxOutputTokens: options.max_tokens,
         },
       });

package/src/clients/http.ts

@@ -247,9 +247,9 @@ export class HttpClient implements GenericClient {
         max_tokens: options.max_tokens || 4000,
         ...this.extra_body,
 
-        ...(options.tools && {
+        ...(options.tools?.length && {
           tools: options.tools,
-          tool_choice: "auto",
+          tool_choice: options.tool_choice ?? "auto",
         }),
       };
 
@@ -297,9 +297,9 @@ export class HttpClient implements GenericClient {
       ...this.extra_body,
       stream: true,
       stream_options: { include_usage: true },
-      ...(options.tools && {
+      ...(options.tools?.length && {
         tools: options.tools,
-        tool_choice: "auto",
+        tool_choice: options.tool_choice ?? "auto",
       }),
     };
 
@@ -442,7 +442,10 @@ export class HttpClient implements GenericClient {
         input,
         ...(instructions && { instructions }),
         ...(options.max_tokens && { max_output_tokens: options.max_tokens }),
-        ...(tools?.length && { tools, tool_choice: "auto" }),
+        ...(tools?.length && {
+          tools,
+          tool_choice: options.tool_choice ?? "auto",
+        }),
         // Reasoning persistence: store server-side when requested, otherwise
         // ask the provider to return encrypted reasoning content so we can
         // thread the reasoning items back into the next request ourselves.

package/src/clients/knowhowMcp.ts

@@ -62,9 +62,9 @@ export class KnowhowMcpClient implements GenericClient {
           ...options,
           max_tokens: options.max_tokens || 3000,
 
-          ...(options.tools && {
+          ...(options.tools?.length && {
             tools: options.tools,
-            tool_choice: "auto",
+            tool_choice: options.tool_choice ?? "auto",
           }),
         },
       }

package/src/clients/openai.ts

@@ -235,9 +235,9 @@ export class GenericOpenAiClient implements GenericClient {
         max_completion_tokens: Math.max(options.max_tokens ?? 0, 16_000),
         reasoning_effort: this.resolveReasoningEffort(options),
       }),
-      ...(options.tools && {
+      ...(options.tools?.length && {
         tools: options.tools,
-        tool_choice: "auto",
+        tool_choice: options.tool_choice ?? "auto",
       }),
     }, { signal: options.signal });
 
@@ -296,7 +296,10 @@ export class GenericOpenAiClient implements GenericClient {
       max_tokens: options.max_tokens,
       stream: true,
       stream_options: { include_usage: true },
-      ...(options.tools && { tools: options.tools, tool_choice: "auto" }),
+      ...(options.tools?.length && {
+        tools: options.tools,
+        tool_choice: options.tool_choice ?? "auto",
+      }),
     }, { signal: options.signal });
 
     let usage: CompletionResponse['usage'] | undefined;
@@ -501,7 +504,7 @@ export class GenericOpenAiClient implements GenericClient {
       }),
       ...(tools?.length && {
         tools,
-        tool_choice: "auto",
+        tool_choice: options.tool_choice ?? "auto",
       }),
     } as any);
 

package/src/clients/pricing/google.ts

@@ -7,7 +7,8 @@ import { completions, embeddings, images, videos, audios, liveApi, ModelCatalogE
 // ─── Model IDs ────────────────────────────────────────────────────────────────
 
 export const GoogleModels = {
-  // Gemini 3.6 / 3.5
+  // Gemini 3.7 / 3.6 / 3.5
+  Gemini_37_Flash: "gemini-3.7-flash",
   Gemini_36_Flash: "gemini-3.6-flash",
   Gemini_35_Flash: "gemini-3.5-flash",
   Gemini_35_Flash_Lite: "gemini-3.5-flash-lite",
@@ -86,6 +87,7 @@ export const GoogleEmbeddingModels: Record<string, string> = {
 // ─── Modality arrays ──────────────────────────────────────────────────────────
 
 export const GoogleTextModels: string[] = [
+  GoogleModels.Gemini_37_Flash,
   GoogleModels.Gemini_36_Flash,
   GoogleModels.Gemini_35_Flash,
   GoogleModels.Gemini_35_Flash_Lite,
@@ -101,6 +103,7 @@ export const GoogleTextModels: string[] = [
 
 // Models that support thinkingLevel (Gemini 3.x series)
 export const GoogleThinkingLevelModels: string[] = [
+  GoogleModels.Gemini_37_Flash,
   GoogleModels.Gemini_36_Flash,
   GoogleModels.Gemini_35_Flash,
   GoogleModels.Gemini_35_Flash_Lite,
@@ -214,7 +217,13 @@ export interface GeminiModelPricing extends ModelPricing {
 }
 
 export const GeminiPricing: Record<string, GeminiModelPricing> = {
-  // ── Gemini 3.6 / 3.5 ──────────────────────────────────────────────────────
+  // ── Gemini 3.7 / 3.6 / 3.5 ────────────────────────────────────────────────
+  // Introductory pricing through December 31, 2026. Standard pricing beginning
+  // January 1, 2027 is $1.50 input, $7.50 output, and $0.15 cached input.
+  [GoogleModels.Gemini_37_Flash]: {
+    input: 0.75, output: 3.75,
+    context_caching: 0.075, context_caching_storage: 0.5,
+  },
   [GoogleModels.Gemini_36_Flash]: {
     input: 1.5, output: 7.5,
     context_caching: 0.15, context_caching_storage: 1.0,

package/src/clients/pricing/xai.ts

@@ -7,6 +7,7 @@ import { completions, images, videos, ModelCatalogEntry, ModelPricing } from "./
 // ─── Model IDs ────────────────────────────────────────────────────────────────
 
 export const XaiModels = {
+  Grok4_6: "grok-4.6",
   Grok_4_20_Reasoning: "grok-4.20-0309-reasoning",
   Grok_4_20_NonReasoning: "grok-4.20-0309-non-reasoning",
   Grok_4_20_MultiAgent: "grok-4.20-multi-agent-0309",
@@ -42,6 +43,7 @@ export const XaiModels = {
 // ─── Modality arrays ──────────────────────────────────────────────────────────
 
 export const XaiTextModels: string[] = [
+  XaiModels.Grok4_6,
   XaiModels.Grok_4_20_Reasoning, XaiModels.Grok_4_20_NonReasoning,
   XaiModels.Grok_4_20_MultiAgent,
   XaiModels.Grok4_1_Fast_Reasoning, XaiModels.Grok4_1_Fast_NonReasoning,
@@ -61,8 +63,9 @@ export const XaiResponsesOnlyModels: string[] = [
 ];
 
 // Models that support the reasoning_effort parameter
-// grok-3-mini variants support reasoning_effort; grok-3-beta, grok-4 etc. do NOT
+// Grok 4.6, Grok 4.20 multi-agent, and grok-3-mini variants support reasoning_effort
 export const XaiReasoningModels: string[] = [
+  XaiModels.Grok4_6,
   XaiModels.Grok_4_20_MultiAgent,
   XaiModels.Grok3MiniBeta,
   XaiModels.Grok3MiniFastBeta,
@@ -84,6 +87,7 @@ export const XaiVideoModels: string[] = [XaiModels.GrokImagineVideo];
 // ─── Pricing (USD per 1M tokens / per-image / per-second) ────────────────────
 
 export const XaiTextPricing: Record<string, ModelPricing> = {
+  [XaiModels.Grok4_6]:                    { input: 2.0, input_gt_200k: 4.0, cache_hit: 0.50, output: 6.0, output_gt_200k: 12.0, reasoningLevels: ["low", "medium", "high", "xhigh"] },
   [XaiModels.Grok_4_20_Reasoning]:       { input: 2.0, cache_hit: 0.20, output: 6.0, useResponsesApi: true },
   [XaiModels.Grok_4_20_NonReasoning]:    { input: 2.0, cache_hit: 0.20, output: 6.0, useResponsesApi: true },
   [XaiModels.Grok_4_20_MultiAgent]:      { input: 2.0, cache_hit: 0.20, output: 6.0, reasoningLevels: ["low", "medium", "high", "xhigh"], useResponsesApi: true },

package/src/clients/xai.ts

@@ -90,9 +90,9 @@ export class GenericXAIClient implements GenericClient {
         // grok-3-mini models support reasoning_effort: "low" | "medium" | "high"
         reasoning_effort: reasoningEffort,
       }),
-      ...(options.tools && {
+      ...(options.tools?.length && {
         tools: options.tools,
-        tool_choice: "auto",
+        tool_choice: options.tool_choice ?? "auto",
       }),
     });
 
@@ -238,7 +238,10 @@ export class GenericXAIClient implements GenericClient {
       ...(instructions && { instructions }),
       ...(options.max_tokens && { max_output_tokens: Math.max(options.max_tokens, 16_000) }),
       ...(reasoningEffort && { reasoning: { effort: reasoningEffort } }),
-      ...(tools?.length && { tools, tool_choice: "auto" }),
+      ...(tools?.length && {
+        tools,
+        tool_choice: options.tool_choice ?? "auto",
+      }),
       // Reasoning persistence (same construct as OpenAI's Responses API):
       //  - store === true  → xAI persists the response; next turn passes
       //    previous_response_id to continue the reasoning chain server-side.