@tyvm/knowhow 0.0.105 → 0.0.106

package/src/agents/base/base.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "events"; // kept for reference; agentEvents now uses EventService
 import {
+  CompletionResponse,
   GenericClient,
   Message,
   MessageContent,
@@ -59,6 +60,10 @@ export abstract class BaseAgent implements IAgent {
   protected turnCount = 0;
   protected totalCostUsd = 0;
   protected currentThread = 0;
+  protected totalInputTokens = 0;
+  protected totalOutputTokens = 0;
+  protected totalCacheReadTokens = 0;
+  protected totalCacheWriteTokens = 0;
 
   protected compressThreshold = 30000;
   protected compressMinMessages = 30;
@@ -95,6 +100,7 @@ export abstract class BaseAgent implements IAgent {
     agentSay: "agent:say",
     agentNewTask: "agent:newTask",
     agentTaskComplete: "agent:taskComplete",
+    tokenUsage: "agent:tokenUsage",
   };
 
   public tools: ToolsService;
@@ -194,6 +200,10 @@ export abstract class BaseAgent implements IAgent {
     this.taskBreakdown = "";
     this.summaries = [];
     this.totalCostUsd = 0;
+    this.totalInputTokens = 0;
+    this.totalOutputTokens = 0;
+    this.totalCacheReadTokens = 0;
+    this.totalCacheWriteTokens = 0;
     this.status = this.eventTypes.inProgress;
     this.turnCount = 0;
     this.startTimeMs = Date.now();
@@ -369,6 +379,44 @@ export abstract class BaseAgent implements IAgent {
     return this.totalCostUsd;
   }
 
+  adjustTokenUsage(usage: any) {
+    if (!usage) return;
+    // Support both OpenAI-style (prompt_tokens/completion_tokens) and Anthropic-style (input_tokens/output_tokens)
+    const inputTokens = usage.input_tokens ?? usage.prompt_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? usage.completion_tokens ?? 0;
+
+    const cacheReadTokens =
+      usage.cache_read_input_tokens ?? usage.cache_read_tokens ??
+      usage.prompt_tokens_details?.cached_tokens ?? 0;
+    const cacheWriteTokens =
+      usage.cache_creation_input_tokens ?? usage.cache_write_tokens ?? 0;
+
+    this.totalInputTokens += inputTokens;
+    this.totalOutputTokens += outputTokens;
+    this.totalCacheReadTokens += cacheReadTokens;
+    this.totalCacheWriteTokens += cacheWriteTokens;
+
+    this.agentEvents.emit(this.eventTypes.tokenUsage, {
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      totalInputTokens: this.totalInputTokens,
+      totalOutputTokens: this.totalOutputTokens,
+      totalCacheReadTokens: this.totalCacheReadTokens,
+      totalCacheWriteTokens: this.totalCacheWriteTokens,
+    });
+  }
+
+  getTokenUsage() {
+    return {
+      totalInputTokens: this.totalInputTokens,
+      totalOutputTokens: this.totalOutputTokens,
+      totalCacheReadTokens: this.totalCacheReadTokens,
+      totalCacheWriteTokens: this.totalCacheWriteTokens,
+    };
+  }
+
   startNewThread(messages: Message[]) {
     this.currentThread++;
     this.agentEvents.emit(this.eventTypes.newThread, messages);
@@ -544,8 +592,14 @@ export abstract class BaseAgent implements IAgent {
 
   async kill() {
     this.log("Killing agent");
-    if (this.status === this.eventTypes.kill || this.status === this.eventTypes.done) {
-      this.log("Agent is already being killed or done, ignoring duplicate kill()", "warn");
+    if (
+      this.status === this.eventTypes.kill ||
+      this.status === this.eventTypes.done
+    ) {
+      this.log(
+        "Agent is already being killed or done, ignoring duplicate kill()",
+        "warn"
+      );
       return;
     }
     this.agentEvents.emit(this.eventTypes.kill, this);
@@ -657,9 +711,16 @@ export abstract class BaseAgent implements IAgent {
             "warn"
           );
         }
+        if (!response?.choices) {
+          const errMsg =
+            (error?.error?.message ?? error?.message) ||
+            JSON.stringify(response);
+          throw new Error(`AI response error: ${errMsg}`);
+        }
       }
 
       this.adjustTotalCostUsd(response?.usd_cost);
+      this.adjustTokenUsage(response?.usage);
       this.log("agent response cost: " + response?.usd_cost);
 
       // Typically, there's only one choice in the array, but you could have many
@@ -687,6 +748,16 @@ export abstract class BaseAgent implements IAgent {
 
           this.updateCurrentThread(messages);
 
+          const truncationWarning = this.detectTruncatedToolCalls(
+            toolCalls,
+            response
+          );
+          if (truncationWarning) {
+            messages.push(truncationWarning as Message);
+            this.updateCurrentThread(messages);
+            return this.call(userInput, messages);
+          }
+
           for (const toolCall of toolCalls) {
             if (this.status === this.eventTypes.pause) {
               this.log(
@@ -958,6 +1029,60 @@ export abstract class BaseAgent implements IAgent {
     return JSON.stringify(messages).split(" ").length;
   }
 
+  /**
+   * Detects whether tool call arguments appear truncated due to hitting the output token limit.
+   * Two signals are checked:
+   *   1. Any tool call argument is empty or invalid JSON (hard truncation).
+   *   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).
+   *
+   * Returns a warning system message if truncation is detected, or null otherwise.
+   */
+  detectTruncatedToolCalls(
+    toolCalls: ToolCall[],
+    response: CompletionResponse
+  ): { role: string; content: string } | null {
+    const outputTokens: number = response?.usage?.output_tokens || 0;
+    const totalArgLength = toolCalls.reduce(
+      (sum, tc) => sum + (tc.function?.arguments?.length || 0),
+      0
+    );
+
+    // Percentage-based heuristic: if actual arg chars are less than ~10% of the
+    // expected chars (outputTokens * 4 chars/token), the output was likely truncated.
+    // Only apply when outputTokens > 1000 to avoid false positives on small responses.
+    const expectedArgChars = outputTokens * 4;
+    const suspiciouslySmallArgs =
+      outputTokens > 1000 && totalArgLength < expectedArgChars * 0.1;
+
+    for (const toolCall of toolCalls) {
+      const args = toolCall.function?.arguments || "";
+      let isInvalidJson = false;
+      try {
+        JSON.parse(args);
+      } catch {
+        isInvalidJson = true;
+      }
+      if (isInvalidJson || args.trim() === "" || suspiciouslySmallArgs) {
+        this.log(
+          `Tool call '${toolCall.function?.name}' has malformed/truncated arguments — likely hit output token limit (outputTokens=${outputTokens}, argLength=${args.length})`,
+          "warn"
+        );
+        return {
+          role: "user",
+          content:
+            "⚠️ Output limit warning: Your last tool call had incomplete or missing arguments, which usually means you exceeded the output token limit mid-response. The model reported " +
+            outputTokens +
+            " output tokens but only " +
+            totalArgLength +
+            " characters of tool call arguments were received. Please write smaller, more concise content in your tool calls. Aim for no more than 4000 tokens of output per response. Break large responses into smaller pieces if needed.",
+        };
+      }
+    }
+
+    return null;
+  }
+
   async getTaskBreakdown(messages: Message[]) {
     if (this.taskBreakdown) {
       return this.taskBreakdown;

package/src/agents/tools/execCommand.ts

@@ -262,6 +262,10 @@ export const execCommand = async (
   continueInBackground?: boolean,
   logFileName?: string
 ): Promise<string> => {
+  if(!command || typeof command !== "string") {
+    throw new Error("Invalid command. We received a non-string value. Please ensure you are sending strings of 4k tokens or less.");
+  }
+
   const { stdout, stderr, timedOut, killed, pid, logPath } =
     await execWithTimeout(command, {
       timeout,

package/src/agents/tools/executeScript/definition.ts

@@ -53,7 +53,7 @@ export const executeScriptDefinition: Tool = {
       properties: {
         script: {
           type: "string",
-          description: "The TypeScript code to execute",
+          description: "The TypeScript code to execute. 4000 tokens or less",
         },
         maxToolCalls: {
           type: "number",

package/src/agents/tools/index.ts

@@ -19,7 +19,6 @@ export * from "./language";
 export * from "./askHuman";
 export * from "./aiClient";
 export * from "./googleSearch";
-export * from "./loadWebpage";
 export * from "./stringReplace";
 export * from "./executeScript";
 export * from "./startAgentTask";

package/src/agents/tools/list.ts

@@ -55,7 +55,7 @@ export const includedTools = [
         properties: {
           command: {
             type: "string",
-            description: "The command to execute",
+            description: "The command to execute. 4000 tokens or less",
           },
           timeout: {
             type: "number",
@@ -346,7 +346,7 @@ export const includedTools = [
     function: {
       name: "writeFileChunk",
       description:
-        "Update or create files by writing in small chunks of text. Suitable for larger files, this tool allows incremental writing by calling it multiple times.",
+        "Update or create files by writing in small chunks of text. Suitable for larger files, this tool allows incremental writing by calling it multiple times. Write chunks of around 4000 tokens",
       parameters: {
         type: "object",
         positional: true,
@@ -358,7 +358,7 @@ export const includedTools = [
           },
           content: {
             type: "string",
-            description: "The chunk of content to write to the file",
+            description: "The chunk of content to write to the file. 4000 tokens or less",
           },
           isContinuing: {
             type: "boolean",
@@ -631,46 +631,6 @@ export const includedTools = [
       },
     },
   },
-  {
-    type: "function",
-    function: {
-      name: "loadWebpage",
-      description:
-        "Load a webpage using a stealth browser to avoid bot detection. Can return either text content with console logs or a screenshot.",
-      parameters: {
-        type: "object",
-        positional: true,
-        properties: {
-          url: {
-            type: "string",
-            description: "The URL of the webpage to load",
-          },
-          mode: {
-            type: "string",
-            description:
-              "The mode for content extraction: 'text' for text content with console logs, 'screenshot' for a base64 encoded screenshot",
-            enum: ["text", "screenshot"],
-          },
-          waitForSelector: {
-            type: "string",
-            description:
-              "Optional CSS selector to wait for before extracting content",
-          },
-          timeout: {
-            type: "number",
-            description:
-              "Timeout in milliseconds for page loading (default: 30000)",
-          },
-        },
-        required: ["url"],
-      },
-      returns: {
-        type: "string",
-        description:
-          "The webpage content as text with console logs, or a base64 encoded screenshot",
-      },
-    },
-  },
   {
     type: "function",
     function: {

package/src/agents/tools/writeFile.ts

@@ -28,7 +28,7 @@ export async function writeFileChunk(
       `File path and content are both required. We received: ${JSON.stringify({
         filePath,
         content,
-      })}. Make sure you write small chunks of content, otherwise you will hit output limits, resulting in content being empty.`
+      })}. Make sure you write small chunks of content (4k tokens), otherwise you will hit output limits, resulting in content being empty.`
     );
   }
 

package/src/auth/browserLogin.ts

@@ -26,7 +26,7 @@ interface RetrieveTokenResponse {
 export class BrowserLoginService {
   private baseUrl: string;
 
-  constructor(baseUrl: string = KNOWHOW_API_URL) {
+  constructor(baseUrl: string = KNOWHOW_API_URL, private orgId?: string) {
     if (!baseUrl) {
       throw new BrowserLoginError(
         "KNOWHOW_API_URL environment variable not set"
@@ -52,11 +52,16 @@ export class BrowserLoginService {
       spinner.start("Opening browser for authentication");
 
       // Step 2: Open browser
-      await openBrowser(sessionData.browserUrl);
+      let browserUrl = sessionData.browserUrl;
+      // Append orgId as query string so the frontend can pre-select the correct organization
+      if (this.orgId) {
+        const separator = browserUrl.includes("?") ? "&" : "?";
+        browserUrl = `${browserUrl}${separator}orgId=${encodeURIComponent(this.orgId)}`;
+      }
+      await openBrowser(browserUrl);
       console.log(
-        `\nIf the browser didn't open automatically, please visit: ${sessionData.browserUrl}\n`
+        `\nIf the browser didn't open automatically, please visit: ${browserUrl}\n`
       );
-
       spinner.stop();
       spinner.start("Waiting for browser authentication");
 

package/src/chat/modules/RemoteSyncModule.ts

@@ -247,6 +247,9 @@ export class RemoteSyncModule extends BaseChatModule {
     const registry = this.agentModule.getTaskRegistry();
     const taskInfo = registry.get(taskId);
 
+    // Refresh JWT in case it was updated since client was instantiated (e.g. after knowhow login)
+    this.client.refreshJwt();
+
     if (!taskInfo) {
       console.log(
         `⚠️  Task "${taskId}" not found in registry.`

package/src/cli.ts

@@ -14,9 +14,10 @@ import { includedTools } from "./agents/tools/list";
 import * as allTools from "./agents/tools";
 import { LazyToolsService, services } from "./services";
 import { login } from "./login";
-import { worker } from "./worker";
+import { worker, tunnel } from "./worker";
 import { fileSync } from "./fileSync";
 import { KnowhowSimpleClient } from "./services/KnowhowClient";
+import { ModulesService } from "./services/modules";
 import {
   startAllWorkers,
   listWorkerPaths,
@@ -56,6 +57,7 @@ async function setupServices() {
   const { Agents, Mcp, Clients, Tools: OldTools } = services();
   const Tools = new LazyToolsService(); // eslint-disable-line no-shadow
 
+  // Load modules from config first so module-provided tools/agents/plugins are available
   // We need to wireup the LazyTools to be connected to the same singletons that are in services()
   Tools.setContext({
     ...OldTools.getContext(),
@@ -100,6 +102,19 @@ async function setupServices() {
   await Clients.registerConfiguredModels();
   console.log("✓ Services are set up and ready to go!");
 
+  // Load modules (tools, plugins, agents) from knowhow.json config
+  console.log("📦 Loading modules from config...");
+  const modulesService = new ModulesService();
+  await modulesService.loadModulesFromConfig({
+    Agents,
+    Embeddings: services().Embeddings,
+    Plugins: services().Plugins,
+    Clients,
+    // Use LazyToolsService so module-provided tools are visible to agents and scripts
+    Tools: Tools as any,
+    MediaProcessor: services().MediaProcessor,
+  });
+
   // Return both LazyToolsService (for agents) and OldTools (plain ToolsService with all tools for scripts)
   return { Tools, Clients, PlainTools: OldTools };
 }
@@ -527,6 +542,21 @@ async function main() {
       }
     });
 
+  program
+    .command("tunnel")
+    .description(
+      "Start tunnel-only mode: expose local ports to the cloud without registering any tools"
+    )
+    .option(
+      "--share",
+      "Share this tunnel with your organization (allows other users to use it)"
+    )
+    .option("--unshare", "Make this tunnel private (only you can use it)")
+    .action(async (options) => {
+      await tunnel(options);
+    });
+
+
   program
     .command("script")
     .description("Run a local tool script file using the executeScript sandbox")

package/src/clients/cerebras.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from "./http";
+import { CerebrasTextPricing } from "./pricing/cerebras";
+
+export class GenericCerebrasClient extends HttpClient {
+  constructor(apiKey: string) {
+    super("https://api.cerebras.ai");
+    this.setJwt(apiKey);
+    this.setPrices(CerebrasTextPricing);
+  }
+}

package/src/clients/contextLimits.ts

@@ -19,8 +19,8 @@ export const ContextLimits: Record<string, number> = {
   [Models.openai.GPT_5]: 1_000_000,
   [Models.openai.GPT_5_Mini]: 1_000_000,
   [Models.openai.GPT_5_Nano]: 1_000_000,
-  [Models.openai.GPT_5_1]: 1_000_000,
-  [Models.openai.GPT_5_2]: 1_000_000,
+  [Models.openai.GPT_51]: 1_000_000,
+  [Models.openai.GPT_52]: 1_000_000,
   [Models.openai.GPT_41]: 1_047_576,
   [Models.openai.GPT_41_Mini]: 1_047_576,
   [Models.openai.GPT_41_Nano]: 1_047_576,
@@ -43,6 +43,7 @@ export const ContextLimits: Record<string, number> = {
 
   // ─── Anthropic ────────────────────────────────────────────────────────────
   [Models.anthropic.Opus4_6]: 1_000_000,
+  [Models.anthropic.Opus4_6Fast]: 1_000_000,
   [Models.anthropic.Sonnet4_6]: 1_000_000,
   [Models.anthropic.Opus4_5]: 1_000_000,
   [Models.anthropic.Opus4]: 200_000,
@@ -54,6 +55,7 @@ export const ContextLimits: Record<string, number> = {
   [Models.anthropic.Sonnet3_5]: 200_000,
   [Models.anthropic.Opus3]: 200_000,
   [Models.anthropic.Haiku3]: 200_000,
+  [Models.anthropic.Haiku3_5]: 200_000,
 
   // ─── Google ───────────────────────────────────────────────────────────────
   [Models.google.Gemini_31_Pro_Preview]: 1_000_000,
@@ -82,6 +84,9 @@ export const ContextLimits: Record<string, number> = {
   // ─── xAI ──────────────────────────────────────────────────────────────────
   [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,
+  [Models.xai.Grok_4_20_NonReasoning]: 131_072,
+  [Models.xai.Grok_4_20_MultiAgent]: 2_000_000,
   [Models.xai.GrokCodeFast]: 2_000_000,
   [Models.xai.Grok4]: 131_072,
   [Models.xai.Grok3Beta]: 131_072,

package/src/clients/copilot.ts

@@ -0,0 +1,23 @@
+import { HttpClient } from "./http";
+import { CopilotTextPricing } from "./pricing/copilot";
+
+/**
+ * GitHub Copilot client — OpenAI-compatible API
+ * https://docs.github.com/en/copilot/reference/ai-models/supported-models
+ *
+ * GitHub Copilot exposes an OpenAI-compatible endpoint at https://api.githubcopilot.com
+ * that allows subscribers to use premium models (Claude Opus, GPT-5.x, Gemini, Grok etc.)
+ * via their Copilot subscription's premium request allowance — no per-token charges.
+ *
+ * Authentication: uses a GitHub token (same as GITHUB_TOKEN / a personal access token
+ * or OAuth token with copilot scope).
+ *
+ * Set env var GITHUB_COPILOT_TOKEN (preferred) or GITHUB_TOKEN to enable.
+ */
+export class GitHubCopilotClient extends HttpClient {
+  constructor(apiKey = process.env.GITHUB_COPILOT_TOKEN ?? process.env.GITHUB_TOKEN) {
+    super("https://api.githubcopilot.com");
+    if (apiKey) this.setJwt(apiKey);
+    this.setPrices(CopilotTextPricing);
+  }
+}

package/src/clients/deepseek.ts

@@ -0,0 +1,16 @@
+import { HttpClient } from "./http";
+import { DeepSeekTextPricing } from "./pricing/deepseek";
+
+/**
+ * DeepSeek client — OpenAI-compatible API
+ * https://platform.deepseek.com/api-docs/
+ * Industry-leading reasoning (R1) and coding (V3) models at very low cost.
+ * Set env var DEEPSEEK_API_KEY to enable.
+ */
+export class GenericDeepSeekClient extends HttpClient {
+  constructor(apiKey = process.env.DEEPSEEK_API_KEY) {
+    super("https://api.deepseek.com");
+    if (apiKey) this.setJwt(apiKey);
+    this.setPrices(DeepSeekTextPricing);
+  }
+}

package/src/clients/fireworks.ts

@@ -0,0 +1,15 @@
+import { HttpClient } from "./http";
+import { FireworksTextPricing } from "./pricing/fireworks";
+
+/**
+ * Fireworks AI client — OpenAI-compatible API (fast serverless inference)
+ * https://docs.fireworks.ai/api-reference/introduction
+ * Set env var FIREWORKS_API_KEY to enable.
+ */
+export class GenericFireworksClient extends HttpClient {
+  constructor(apiKey = process.env.FIREWORKS_API_KEY) {
+    super("https://api.fireworks.ai/inference");
+    if (apiKey) this.setJwt(apiKey);
+    this.setPrices(FireworksTextPricing);
+  }
+}

package/src/clients/gemini.ts

@@ -16,10 +16,12 @@ import { wait } from "../utils";
 import {
   EmbeddingModels,
   Models,
+  GoogleThinkingLevelModels,
+  GoogleThinkingBudgetModels,
   GoogleImageModels,
   GoogleVideoModels,
   GoogleTTSModels,
-  GoogleEmbeddingModels,
+  GoogleEmbeddingModelsList,
   GoogleReasoningModels,
 } from "../types";
 import { GeminiTextPricing } from "./pricing";
@@ -389,9 +391,49 @@ export class GenericGeminiClient implements GenericClient {
     return [{ functionDeclarations }];
   }
 
+  /**
+   * Builds the thinkingConfig for Gemini models that support it.
+   * - Gemini 3.x models use thinkingLevel: "minimal" | "low" | "medium" | "high"
+   * - Gemini 2.5 models use thinkingBudget: number (0 = off, -1 = dynamic)
+   *
+   * Maps CompletionOptions.reasoning_effort to provider-specific values.
+   */
+  buildThinkingConfig(options: CompletionOptions): Record<string, unknown> | undefined {
+    const model = options.model;
+    const effort = options.reasoning_effort ?? "low";
+
+    // Gemini 3.x — use thinkingLevel
+    if (GoogleThinkingLevelModels.includes(model)) {
+      const levelMap: Record<string, string> = {
+        low: "low",
+        medium: "medium",
+        high: "high",
+      };
+      return {
+        thinkingLevel: levelMap[effort] ?? "low",
+      };
+    }
+
+    // Gemini 2.5 — use thinkingBudget
+    if (GoogleThinkingBudgetModels.includes(model)) {
+      // Map effort to token budget
+      const budgetMap: Record<string, number> = {
+        low: 1024,
+        medium: 8192,
+        high: -1, // dynamic
+      };
+      return {
+        thinkingBudget: budgetMap[effort] ?? 1024,
+      };
+    }
+
+    return undefined;
+  }
+
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
+    const thinkingConfig = this.buildThinkingConfig(options);
     const { systemInstruction, contents } = this.transformMessages(
       options.messages
     );
@@ -403,6 +445,7 @@ export class GenericGeminiClient implements GenericClient {
         contents,
         config: {
           systemInstruction,
+          thinkingConfig,
           tools: this.transformTools(options.tools),
           maxOutputTokens: options.max_tokens,
         },
@@ -600,7 +643,7 @@ export class GenericGeminiClient implements GenericClient {
     if (modality) {
       const map: Partial<Record<ModelModality, string[]>> = {
         completion: GoogleReasoningModels,
-        embedding: GoogleEmbeddingModels,
+        embedding: GoogleEmbeddingModelsList,
         image: GoogleImageModels,
         audio: GoogleTTSModels,
         video: GoogleVideoModels,

package/src/clients/github.ts

@@ -0,0 +1,16 @@
+import { HttpClient } from "./http";
+import { GitHubModelsTextPricing } from "./pricing/github";
+
+/**
+ * GitHub Models client — OpenAI-compatible API
+ * https://docs.github.com/en/github-models
+ * Free access to premium models (GPT-4o, DeepSeek R1, Llama, Phi etc.) with a GitHub token.
+ * Set env var GITHUB_TOKEN to enable.
+ */
+export class GenericGitHubModelsClient extends HttpClient {
+  constructor(apiKey = process.env.GITHUB_TOKEN) {
+    super("https://models.github.ai/inference");
+    if (apiKey) this.setJwt(apiKey);
+    this.setPrices(GitHubModelsTextPricing);
+  }
+}

package/src/clients/groq.ts

@@ -0,0 +1,15 @@
+import { HttpClient } from "./http";
+import { GroqTextPricing } from "./pricing/groq";
+
+/**
+ * Groq client — OpenAI-compatible API (ultra-fast inference)
+ * https://console.groq.com/docs/openai
+ * Set env var GROQ_API_KEY to enable.
+ */
+export class GenericGroqClient extends HttpClient {
+  constructor(apiKey = process.env.GROQ_API_KEY) {
+    super("https://api.groq.com/openai");
+    if (apiKey) this.setJwt(apiKey);
+    this.setPrices(GroqTextPricing);
+  }
+}