@tyvm/knowhow 0.0.153 → 0.0.155

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.153",
+  "version": "0.0.155",
   "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
     );
@@ -1642,6 +1660,20 @@ export abstract class BaseAgent implements IAgent {
     return null;
   }
 
+  extractContentFromMessages(messages: Message[]): string {
+    const content = messages
+      .filter((m) => typeof m.content === "string" && m.content.trim())
+      .map((m) => m.content);
+
+    const finalAnswer = messages
+      .filter((m) => m.tool_calls?.length)
+      .flatMap((t) => t.tool_calls)
+      .filter((t) => t.function.name === "finalAnswer")
+      .map((t) => t.function.arguments);
+
+    return [...content, ...finalAnswer].join("\n\n");
+  }
+
   async getTaskBreakdown(messages: Message[]) {
     if (this.taskBreakdown) {
       return this.taskBreakdown;
@@ -1668,29 +1700,26 @@ export abstract class BaseAgent implements IAgent {
     ] as Message[];
 
     const response = await this.createAgentCompletion({
-      model,
       messages: taskBreakdownMessages,
       tool_choice: "none",
-      long_ttl_cache: this.runTime() > 300_000,
-      ...(this.reasoningEffort !== undefined && {
-        reasoning_effort: this.reasoningEffort,
-      }),
-      ...(this.summarizeReasoning !== undefined && {
-        reasoning_summary: this.summarizeReasoning,
-      }),
     });
 
+    const breakdownContent = this.extractContentFromMessages(
+      response.choices?.map((c) => c.message)
+    );
     // The model may return null content (e.g. when it responds with tool calls
     // instead of text). Guard against storing a literal null so that template
     // strings don't render "null".
-    const breakdownContent = response.choices
-      .map((c) => c.message.content)
-      .filter((s): s is string => typeof s === "string" && s.trim().length > 0)
-      .join("\n\n");
+    if (!breakdownContent) {
+      console.log(JSON.stringify(response.choices, null, 2));
+      throw new Error(
+        "Compaction task-breakdown request returned no text content"
+      );
+    }
 
-    this.taskBreakdown = breakdownContent || "";
+    this.taskBreakdown = breakdownContent;
     this.log(`task breakdown cost: ${response.usd_cost}`);
-    return this.taskBreakdown || undefined;
+    return this.taskBreakdown;
   }
 
   async compressMessages(messages: Message[]) {
@@ -1698,10 +1727,7 @@ export abstract class BaseAgent implements IAgent {
     // at the final assistant message keeps its tool calls, every tool response,
     // and any subsequent user messages together as one protocol-valid unit.
     let resumeIndex = messages.length - 1;
-    while (
-      resumeIndex >= 0 &&
-      messages[resumeIndex].role !== "assistant"
-    ) {
+    while (resumeIndex >= 0 && messages[resumeIndex].role !== "assistant") {
       resumeIndex--;
     }
     const compressionEnd = resumeIndex === -1 ? messages.length : resumeIndex;
@@ -1720,7 +1746,11 @@ export abstract class BaseAgent implements IAgent {
     3. Next Steps - what we're about to do next to continue the user's original request.
     4. Tasks remaining - what tasks are left from the initial task breakdown.
 
-    ${this.taskBreakdown ? `Our initial task breakdown: ${this.taskBreakdown}` : ""}
+    ${
+      this.taskBreakdown
+        ? `Our initial task breakdown: ${this.taskBreakdown}`
+        : ""
+    }
 
     This summary will replace the older history. The latest agent interaction will remain verbatim:
 
@@ -1739,19 +1769,33 @@ export abstract class BaseAgent implements IAgent {
       tool_choice: "none",
     });
 
-    const summaries = response.choices
-      .map((c) => c.message.content)
-      .filter((s): s is string => typeof s === "string" && s.trim().length > 0);
-    this.summaries.push(...summaries);
+    const summary = this.extractContentFromMessages(
+      response.choices?.map((c) => c.message)
+    );
+
+    if (summary.length === 0) {
+      console.log(JSON.stringify(response.choices, null, 2));
+      throw new Error("Compaction summary request returned no text content");
+    }
+
+    this.summaries.push(summary);
 
     const startMessages = [
       {
         role: "user",
         content: `
-        ${this.taskBreakdown ? `Initial task breakdown:\n        ${this.taskBreakdown}` : "(No task breakdown available — summarize what you know from context above)"}
+        ${
+          this.taskBreakdown
+            ? `Initial task breakdown:\n        ${this.taskBreakdown}`
+            : "(No task breakdown available — summarize what you know from context above)"
+        }
 
         We have just compressed the conversation to save memory:
-        ${summaries.length > 0 ? JSON.stringify(summaries) : "(summary unavailable — please continue from the task breakdown above)"}
+        ${
+          summary.length > 0
+            ? JSON.stringify(summary)
+            : "(summary unavailable — please continue from the task breakdown above)"
+        }
 
         Please continue the task from where we left off
         `,

package/src/agents/base/prompt.ts

@@ -4,8 +4,9 @@ You use the tools to read and write code, to help the developer implement featur
 
 # Completing your work
 
-You always call finalAnswer once you have finished implementing or answering what is requested.
-As an agent you will receive multiple rounds of input until you call finalAnswer.
+You may answer questions and provide requested information directly in your assistant message content. Content responses are valid and visible to the user; you do not need to use a tool merely to answer a question.
+Call finalAnswer only once the overall task is complete and you are ready to end the agent run. Put your final result or completion summary in that tool call.
+As an agent you may receive multiple rounds of input before you call finalAnswer.
 You are not able to request feedback from the user, so proceed with your plans and the developer will contact you afterwards if they need more help.
 
 ## Modification Guidelines

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/keyAuth.ts

@@ -3,7 +3,12 @@ import os from "os";
 import path from "path";
 import http from "../utils/http";
 import { getCliUserAgent } from "./browserLogin";
-import { keyPairExists, loadKeyPair, signMessage } from "./keyManager";
+import {
+  getDefaultPrivateKeyPath,
+  keyPairExists,
+  loadKeyPair,
+  signMessage,
+} from "./keyManager";
 
 const JWT_FILE_PATH = path.join(process.cwd(), ".knowhow", ".jwt");
 const DEFAULT_API_URL = process.env.KNOWHOW_API_URL || "https://api.knowhow.tyvm.ai";
@@ -62,15 +67,42 @@ export async function exchangePublicKeyJwt(
   return response.data.jwt;
 }
 
+/**
+ * Try the configured identity first, then the default CLI identity. Project
+ * configs can outlive temporary/custom keys, while the globally registered
+ * default identity remains valid.
+ */
+export async function exchangeAvailablePublicKeyJwt(
+  orgId: string,
+  apiUrl: string = DEFAULT_API_URL,
+  preferredPrivateKeyPath?: string
+): Promise<string> {
+  const defaultPath = getDefaultPrivateKeyPath();
+  const candidates = Array.from(
+    new Set([preferredPrivateKeyPath, defaultPath].filter((value): value is string => Boolean(value)))
+  ).filter((candidate) => keyPairExists(candidate));
+  if (candidates.length === 0) throw new Error("CLI identity is unavailable");
+
+  let lastError: unknown;
+  for (const candidate of candidates) {
+    try {
+      return await exchangePublicKeyJwt(orgId, apiUrl, candidate);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError;
+}
+
 export async function authenticateWithKey(
   orgId: string,
   apiUrl: string = DEFAULT_API_URL,
   privateKeyPath?: string
 ): Promise<boolean> {
-  if (!keyPairExists(privateKeyPath)) return false;
+  if (!keyPairExists(privateKeyPath) && !keyPairExists()) return false;
 
   try {
-    storeJwt(await exchangePublicKeyJwt(orgId, apiUrl, privateKeyPath));
+    storeJwt(await exchangeAvailablePublicKeyJwt(orgId, apiUrl, privateKeyPath));
     return true;
   } catch (error: unknown) {
     // The identity is not registered for this environment/org (or was revoked).

package/src/chat/modules/AgentModule.ts

@@ -67,6 +67,9 @@ export class AgentModule extends BaseChatModule {
   /** Whether to request a reasoning summary from supporting models */
   private summarizeReasoning: boolean = true;
 
+  /** Delayed finalAnswer output, cancelled when the task's done event arrives. */
+  private pendingFinalAnswers = new Map<string, ReturnType<typeof setTimeout>>();
+
   /** Stored wire params for rewireAgentRendering */
   private _wireAgentEvents: EventService | undefined;
   private _wireTaskId: string | undefined;
@@ -514,6 +517,28 @@ export class AgentModule extends BaseChatModule {
     this.activeAgentTaskId = id;
   }
 
+  private scheduleFinalAnswer(taskId: string, answer: unknown): void {
+    this.cancelFinalAnswer(taskId);
+    const renderedAnswer = typeof answer === "string"
+      ? answer
+      : JSON.stringify(answer) ?? String(answer);
+    const timeout = setTimeout(() => {
+      this.pendingFinalAnswers.delete(taskId);
+      console.log(Marked.parse(renderedAnswer));
+    }, 50);
+    this.pendingFinalAnswers.set(taskId, timeout);
+  }
+
+  private cancelFinalAnswer(taskId: string): void {
+    const timeout = this.pendingFinalAnswers.get(taskId);
+    if (!timeout) {
+      return;
+    }
+
+    clearTimeout(timeout);
+    this.pendingFinalAnswers.delete(taskId);
+  }
+
   /**
    * Wire up agentEvents to the renderer for a given task.
    * Uses setListener with stable keys so re-calling automatically replaces old listeners.
@@ -549,16 +574,27 @@ export class AgentModule extends BaseChatModule {
     if (eventTypes.toolUsed) {
       agentEvents.setListener(
         { key: "agentModule:render:toolUsed", event: eventTypes.toolUsed },
-        (data: any) =>
+        (data: any) => {
           this.renderer.render({
             type: "toolResult",
             taskId,
             agentName,
             toolCall: data.toolCall,
             result: data.functionResp,
-          })
+          });
+          // Give the done event a chance to render the same answer first. If the
+          // agent continues, the tool result becomes the fallback output.
+          const toolName: string = data.toolCall?.function?.name ?? "";
+          if (toolName === "finalAnswer" || toolName.endsWith("finalAnswer")) {
+            this.scheduleFinalAnswer(taskId, data.functionResp);
+          }
+        }
       );
     }
+    agentEvents.setListener(
+      { key: "agentModule:render:done", event: eventTypes.done },
+      () => this.cancelFinalAnswer(taskId)
+    );
     if (eventTypes.agentSay) {
       agentEvents.setListener(
         { key: "agentModule:render:agentSay", event: eventTypes.agentSay },
@@ -589,6 +625,9 @@ export class AgentModule extends BaseChatModule {
    * Clears the active task on the renderer.
    */
   public unwireAgentRendering(): void {
+    if (this._wireTaskId) {
+      this.cancelFinalAnswer(this._wireTaskId);
+    }
     if (this._wireAgentEvents) {
       this._wireAgentEvents.removeManagedListenersByPrefix(
         "agentModule:render:"
@@ -681,8 +720,14 @@ export class AgentModule extends BaseChatModule {
         console.error(`Session ${sessionId} not found.`);
         return;
       }
+      // Session files from older runs may not contain model/provider settings.
+      // Prefer task metadata, which is updated from the live agent on every
+      // thread update and is therefore the authoritative resume configuration.
+      const savedSettings = await this.loadTaskSettings(
+        session.taskId || sessionId
+      );
       console.log(`\n🔄 Resuming session: ${sessionId}`);
-      console.log(`Agent: ${session.agentName}`);
+      console.log(`Agent: ${savedSettings.agentName || session.agentName}`);
       console.log(`Original task: ${session.initialInput}`);
       console.log(`Status: ${session.status}`);
 
@@ -726,7 +771,8 @@ export class AgentModule extends BaseChatModule {
 
       console.log("🚀 Session resuming...");
       const context = this.chatService?.getContext();
-      const agentName = session.agentName || context.currentAgent;
+      const agentName =
+        savedSettings.agentName || session.agentName || context.currentAgent;
       const previousAgentMode = context?.agentMode;
 
       if (!agentName) {
@@ -738,7 +784,9 @@ export class AgentModule extends BaseChatModule {
       // not reject config-defined agents here before it gets that opportunity.
 
       // Start agent with Knowhow task context and restored message history
-      const remoteTaskId = asRemoteTaskId(session.knowhowTaskId);
+      const remoteTaskId = asRemoteTaskId(
+        savedSettings.remoteTaskId || session.knowhowTaskId
+      );
       const { agent, taskId } = await this.setupAgent({
         agentName,
         input: resumePrompt,
@@ -751,12 +799,12 @@ export class AgentModule extends BaseChatModule {
         taskId: session.taskId || sessionId,
         chatHistory: [],
         run: false, // Don't run yet, we need to set up event listeners first
-        // Restore the exact model/provider/reasoning the original run used.
-        model: session.model,
-        provider: session.provider,
-        reasoningEffort: session.reasoningEffort,
-        summarizeReasoning: session.summarizeReasoning,
-        enabledTools: session.enabledTools,
+        // Prefer authoritative task metadata over potentially incomplete sessions.
+        model: savedSettings.model || session.model,
+        provider: savedSettings.provider || session.provider,
+        reasoningEffort: savedSettings.reasoningEffort ?? session.reasoningEffort,
+        summarizeReasoning: savedSettings.summarizeReasoning ?? session.summarizeReasoning,
+        enabledTools: savedSettings.enabledTools || session.enabledTools,
       });
 
       // Match new interactive threads: local-only sessions get a fresh remote
@@ -871,6 +919,34 @@ export class AgentModule extends BaseChatModule {
       agent.restoreEnabledTools(options.enabledTools);
     }
 
+    // Restore persisted configuration before registering or saving this task.
+    // Otherwise the newly constructed agent's defaults can overwrite the
+    // original run settings during resume setup.
+    if (options.model) {
+      console.log("Setting model:", options.model);
+      agent.setModel(options.model);
+      agent.setModelPreferences([
+        { model: options.model, provider: options.provider as any },
+      ]);
+    }
+
+    if (options.provider) {
+      agent.setProvider(options.provider as any);
+    }
+
+    const effectiveReasoningEffort =
+      options.reasoningEffort !== undefined
+        ? options.reasoningEffort
+        : this.reasoningEffort;
+    if (effectiveReasoningEffort !== undefined) {
+      agent.setReasoningEffort(effectiveReasoningEffort);
+    }
+    agent.setSummarizeReasoning(
+      options.summarizeReasoning !== undefined
+        ? options.summarizeReasoning
+        : this.summarizeReasoning
+    );
+
     let done = false;
     let output = "Done";
     const taskId = options.taskId || this.sessionManager.generateTaskId(input);
@@ -907,6 +983,10 @@ export class AgentModule extends BaseChatModule {
         startTime: Date.now(),
         totalCost: 0,
         enabledTools: agent.getEnabledToolNames(),
+        model: agent.getModel(),
+        provider: agent.getProvider(),
+        reasoningEffort: agent.getReasoningEffort?.(),
+        summarizeReasoning: agent.getSummarizeReasoning?.(),
       };
 
       // Add to task registry
@@ -967,37 +1047,6 @@ export class AgentModule extends BaseChatModule {
         agent.setParentTaskId(options.parentTaskId);
       }
 
-      if (options.model) {
-        console.log("Setting model:", options.model);
-        agent.setModel(options.model);
-        agent.setModelPreferences([
-          { model: options.model, provider: options.provider as any },
-        ]);
-      }
-
-      // Restore the provider explicitly (e.g. on resume) so the agent talks to
-      // the same client the original run used, not the model's default provider.
-      if (options.provider) {
-        agent.setProvider(options.provider as any);
-      }
-
-      // Apply reasoning settings to the agent. Explicit per-task settings
-      // (e.g. restored from a resumed task's metadata) take precedence over
-      // the module-level CLI defaults so a /resume keeps the same reasoning
-      // effort the original run used.
-      const effectiveReasoningEffort =
-        options.reasoningEffort !== undefined
-          ? options.reasoningEffort
-          : this.reasoningEffort;
-      if (effectiveReasoningEffort !== undefined) {
-        agent.setReasoningEffort(effectiveReasoningEffort);
-      }
-      agent.setSummarizeReasoning(
-        options.summarizeReasoning !== undefined
-          ? options.summarizeReasoning
-          : this.summarizeReasoning
-      );
-
       // Set up message processors like in original startAgent
 
       // Register an override for askHuman to use CLI input method
@@ -1097,6 +1146,12 @@ export class AgentModule extends BaseChatModule {
           toolCall: data.toolCall,
           result: data.functionResp,
         });
+        // Give the done event a chance to render the same answer first. If the
+        // agent continues, the tool result becomes the fallback output.
+        const toolName: string = data.toolCall?.function?.name ?? "";
+        if (toolName === "finalAnswer" || toolName.endsWith("finalAnswer")) {
+          this.scheduleFinalAnswer(taskId, data.functionResp);
+        }
       };
       const agentSayHandler = (data: any) => {
         this.renderer.render({
@@ -1130,6 +1185,7 @@ export class AgentModule extends BaseChatModule {
       const taskCompleted = new Promise<string>((resolve) => {
         agent.agentEvents.once(agent.eventTypes.done, async (doneMsg) => {
           console.log("🎯 [AgentModule] Task Completed");
+          this.cancelFinalAnswer(taskId);
           done = true;
           output = doneMsg || "No response from the AI";
           // Remove threadUpdate listener to prevent cost sharing across tasks

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,
         },
       });