@elizaos/plugin-groq 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/node/index.node.js

@@ -0,0 +1,571 @@
+// index.ts
+import { createGroq } from "@ai-sdk/groq";
+import {
+  buildCanonicalSystemPrompt,
+  EventType,
+  logger,
+  ModelType,
+  recordLlmCall,
+  renderChatMessagesForPrompt,
+  resolveEffectiveSystemPrompt
+} from "@elizaos/core";
+import {
+  APICallError,
+  generateText,
+  jsonSchema,
+  Output
+} from "ai";
+var _globalThis = globalThis;
+_globalThis.AI_SDK_LOG_WARNINGS ??= false;
+var DEFAULT_SMALL_MODEL = "openai/gpt-oss-120b";
+var DEFAULT_LARGE_MODEL = "openai/gpt-oss-120b";
+var DEFAULT_TTS_MODEL = "canopylabs/orpheus-v1-english";
+var DEFAULT_TTS_VOICE = "troy";
+var DEFAULT_TTS_RESPONSE_FORMAT = "wav";
+var DEFAULT_TRANSCRIPTION_MODEL = "whisper-large-v3-turbo";
+var DEFAULT_BASE_URL = "https://api.groq.com/openai/v1";
+function resolveGroqSystemPrompt(runtime, params) {
+  return resolveEffectiveSystemPrompt({
+    params,
+    fallback: buildCanonicalSystemPrompt({ character: runtime.character })
+  });
+}
+function resolveGroqPrompt(params, systemPrompt) {
+  return renderChatMessagesForPrompt(params.messages, {
+    omitDuplicateSystem: systemPrompt
+  }) ?? params.prompt ?? "";
+}
+function toFiniteNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return;
+  }
+  return Math.max(0, Math.round(value));
+}
+function normalizeTokenUsage(usage) {
+  if (!usage || typeof usage !== "object") {
+    return null;
+  }
+  const record = usage;
+  const promptTokens = toFiniteNumber(record.inputTokens ?? record.promptTokens);
+  const completionTokens = toFiniteNumber(record.outputTokens ?? record.completionTokens);
+  const totalTokens = toFiniteNumber(record.totalTokens);
+  if (promptTokens === undefined && completionTokens === undefined && totalTokens === undefined) {
+    return null;
+  }
+  const normalizedPromptTokens = promptTokens ?? (completionTokens === undefined && totalTokens !== undefined ? totalTokens : Math.max(0, (totalTokens ?? 0) - (completionTokens ?? 0)));
+  const normalizedCompletionTokens = completionTokens ?? Math.max(0, (totalTokens ?? normalizedPromptTokens) - normalizedPromptTokens);
+  return {
+    promptTokens: normalizedPromptTokens,
+    completionTokens: normalizedCompletionTokens,
+    totalTokens: totalTokens ?? normalizedPromptTokens + normalizedCompletionTokens
+  };
+}
+function applyUsageToDetails(details, usage) {
+  const normalized = normalizeTokenUsage(usage);
+  if (!normalized) {
+    return;
+  }
+  details.promptTokens = normalized.promptTokens;
+  details.completionTokens = normalized.completionTokens;
+}
+function estimateTokenCount(text) {
+  return text.length === 0 ? 0 : Math.ceil(text.length / 4);
+}
+function stringifyForUsage(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function estimateUsage(prompt, response) {
+  const promptTokens = estimateTokenCount(prompt);
+  const completionTokens = estimateTokenCount(stringifyForUsage(response));
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    estimated: true
+  };
+}
+function boundedNumber(value, fallback, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.min(max, Math.max(min, value));
+}
+function positiveInteger(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string");
+}
+function emitModelUsed(runtime, type, model, usage) {
+  runtime.emitEvent(EventType.MODEL_USED, {
+    runtime,
+    source: "groq",
+    provider: "groq",
+    type,
+    model,
+    modelName: model,
+    tokens: {
+      prompt: usage.promptTokens,
+      completion: usage.completionTokens,
+      total: usage.totalTokens,
+      ...usage.estimated ? { estimated: true } : {}
+    },
+    ...usage.estimated ? { usageEstimated: true } : {}
+  });
+}
+function isBrowser() {
+  return typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
+}
+function env(name) {
+  return _globalThis.process?.env?.[name] ?? null;
+}
+function nonEmptyString(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function getRuntimeBuffer() {
+  return _globalThis.Buffer ?? null;
+}
+function getBaseURL(runtime) {
+  const configured = nonEmptyString(runtime.getSetting("GROQ_BASE_URL"));
+  if (!configured) {
+    return DEFAULT_BASE_URL;
+  }
+  let parsed;
+  try {
+    parsed = new URL(configured);
+  } catch {
+    throw new Error("GROQ_BASE_URL must be a valid http(s) URL");
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new Error("GROQ_BASE_URL must be a valid http(s) URL");
+  }
+  return configured.replace(/\/+$/, "");
+}
+function getSmallModel(runtime) {
+  const setting = runtime.getSetting("GROQ_SMALL_MODEL") || runtime.getSetting("SMALL_MODEL");
+  return typeof setting === "string" ? setting : DEFAULT_SMALL_MODEL;
+}
+function getNanoModel(runtime) {
+  const setting = runtime.getSetting("GROQ_NANO_MODEL") || runtime.getSetting("NANO_MODEL");
+  return typeof setting === "string" ? setting : getSmallModel(runtime);
+}
+function getMediumModel(runtime) {
+  const setting = runtime.getSetting("GROQ_MEDIUM_MODEL") || runtime.getSetting("MEDIUM_MODEL");
+  return typeof setting === "string" ? setting : getSmallModel(runtime);
+}
+function getLargeModel(runtime) {
+  const setting = runtime.getSetting("GROQ_LARGE_MODEL") || runtime.getSetting("LARGE_MODEL");
+  return typeof setting === "string" ? setting : DEFAULT_LARGE_MODEL;
+}
+function getMegaModel(runtime) {
+  const setting = runtime.getSetting("GROQ_MEGA_MODEL") || runtime.getSetting("MEGA_MODEL");
+  return typeof setting === "string" ? setting : getLargeModel(runtime);
+}
+function getResponseHandlerModel(runtime) {
+  const setting = runtime.getSetting("GROQ_RESPONSE_HANDLER_MODEL") || runtime.getSetting("GROQ_SHOULD_RESPOND_MODEL") || runtime.getSetting("RESPONSE_HANDLER_MODEL") || runtime.getSetting("SHOULD_RESPOND_MODEL");
+  return typeof setting === "string" ? setting : getNanoModel(runtime);
+}
+function getTranscriptionModel(runtime) {
+  const setting = runtime.getSetting("GROQ_TRANSCRIPTION_MODEL") || runtime.getSetting("TRANSCRIPTION_MODEL");
+  return typeof setting === "string" ? setting : DEFAULT_TRANSCRIPTION_MODEL;
+}
+function getActionPlannerModel(runtime) {
+  const setting = runtime.getSetting("GROQ_ACTION_PLANNER_MODEL") || runtime.getSetting("GROQ_PLANNER_MODEL") || runtime.getSetting("ACTION_PLANNER_MODEL") || runtime.getSetting("PLANNER_MODEL");
+  return typeof setting === "string" ? setting : getLargeModel(runtime);
+}
+function createGroqClient(runtime) {
+  const allowBrowserKey = !isBrowser() || String(runtime.getSetting("GROQ_ALLOW_BROWSER_API_KEY") ?? "").toLowerCase() === "true";
+  const apiKey = allowBrowserKey ? nonEmptyString(runtime.getSetting("GROQ_API_KEY")) : undefined;
+  return createGroq({
+    apiKey,
+    fetch: runtime.fetch ?? undefined,
+    baseURL: getBaseURL(runtime)
+  });
+}
+function extractRetryDelay(message) {
+  const match = message.match(/try again in (\d+\.?\d*)s/i);
+  if (match?.[1]) {
+    return Math.ceil(Number.parseFloat(match[1]) * 1000) + 1000;
+  }
+  return 1e4;
+}
+function classifyRetryError(error) {
+  if (APICallError.isInstance(error)) {
+    if (error.statusCode === 429)
+      return "rate-limit";
+    if (typeof error.statusCode === "number" && error.statusCode >= 500 && error.statusCode < 600) {
+      return "transient";
+    }
+    if (error.isRetryable)
+      return "transient";
+    return "fatal";
+  }
+  if (!(error instanceof Error))
+    return "fatal";
+  const message = error.message.toLowerCase();
+  if (message.includes("rate limit") || message.includes("rate_limit") || message.includes("too many requests") || /try again in \d/i.test(error.message)) {
+    return "rate-limit";
+  }
+  if (message.includes("econnreset") || message.includes("etimedout") || message.includes("enotfound") || message.includes("econnrefused") || message.includes("socket hang up") || message.includes("network error") || message.includes("fetch failed")) {
+    return "transient";
+  }
+  return "fatal";
+}
+function buildGroqStructuredOutput(responseSchema) {
+  if (responseSchema && typeof responseSchema === "object" && "responseFormat" in responseSchema && "parseCompleteOutput" in responseSchema) {
+    return responseSchema;
+  }
+  const schemaOptions = responseSchema && typeof responseSchema === "object" && "schema" in responseSchema ? responseSchema : { schema: responseSchema };
+  return Output.object({
+    schema: jsonSchema(schemaOptions.schema),
+    ...schemaOptions.name ? { name: schemaOptions.name } : {},
+    ...schemaOptions.description ? { description: schemaOptions.description } : {}
+  });
+}
+function buildGroqNativeTextResult(result) {
+  const inputTokens = result.usage?.inputTokens ?? result.usage?.promptTokens ?? 0;
+  const outputTokens = result.usage?.outputTokens ?? result.usage?.completionTokens ?? 0;
+  const usage = result.usage ? {
+    promptTokens: inputTokens,
+    completionTokens: outputTokens,
+    totalTokens: result.usage.totalTokens ?? inputTokens + outputTokens
+  } : undefined;
+  return {
+    text: result.text,
+    toolCalls: result.toolCalls ?? [],
+    finishReason: result.finishReason,
+    ...usage ? { usage } : {}
+  };
+}
+async function generateWithRetry(runtime, groq, modelType, model, params) {
+  const generate = () => {
+    const details = {
+      model,
+      systemPrompt: params.system ?? "",
+      userPrompt: params.prompt,
+      temperature: params.temperature,
+      maxTokens: params.maxTokens ?? 0,
+      maxTokensOmitted: params.omitMaxTokens ? true : undefined,
+      purpose: "external_llm",
+      actionType: "ai.generateText"
+    };
+    return recordLlmCall(runtime, details, async () => {
+      const sharedSettings = {
+        model: groq.languageModel(model),
+        system: params.system,
+        temperature: params.temperature,
+        ...params.omitMaxTokens ? {} : { maxOutputTokens: params.maxTokens },
+        maxRetries: 3,
+        frequencyPenalty: params.frequencyPenalty,
+        presencePenalty: params.presencePenalty,
+        stopSequences: params.stopSequences,
+        ...params.tools ? { tools: params.tools } : {},
+        ...params.toolChoice ? { toolChoice: params.toolChoice } : {},
+        ...params.responseSchema ? { output: buildGroqStructuredOutput(params.responseSchema) } : {}
+      };
+      const result = params.messages && params.messages.length > 0 ? await generateText({ ...sharedSettings, messages: params.messages }) : await generateText({ ...sharedSettings, prompt: params.prompt });
+      details.response = result.text;
+      applyUsageToDetails(details, result.usage);
+      return result;
+    });
+  };
+  const MAX_RATE_LIMIT_RETRIES = 5;
+  const MAX_TRANSIENT_RETRIES = 2;
+  let rateLimitAttempts = 0;
+  let transientAttempts = 0;
+  while (true) {
+    try {
+      const result = await generate();
+      const usage = normalizeTokenUsage(result.usage) ?? estimateUsage(params.prompt, result.text);
+      emitModelUsed(runtime, modelType, model, usage);
+      if (params.returnNative) {
+        return buildGroqNativeTextResult(result);
+      }
+      const { text } = result;
+      return text;
+    } catch (error) {
+      const kind = classifyRetryError(error);
+      if (kind === "rate-limit" && rateLimitAttempts < MAX_RATE_LIMIT_RETRIES) {
+        const message = error instanceof Error ? error.message : String(error);
+        const hinted = extractRetryDelay(message);
+        const backoff = Math.min(30000, 500 * 2 ** rateLimitAttempts);
+        const delay = hinted + backoff;
+        rateLimitAttempts += 1;
+        logger.warn(`Groq rate limit hit (attempt ${rateLimitAttempts}/${MAX_RATE_LIMIT_RETRIES}), retrying in ${delay}ms`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      }
+      if (kind === "transient" && transientAttempts < MAX_TRANSIENT_RETRIES) {
+        const delay = 1000 + Math.floor(Math.random() * 1500);
+        transientAttempts += 1;
+        logger.warn(`Groq transient failure (attempt ${transientAttempts}/${MAX_TRANSIENT_RETRIES}), retrying in ${delay}ms: ${error instanceof Error ? error.message : String(error)}`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+function buildGroqGenerateParams(params, systemPrompt, promptText) {
+  const paramsWithNative = params;
+  const returnNative = Boolean(paramsWithNative.messages || paramsWithNative.tools || paramsWithNative.toolChoice || paramsWithNative.responseSchema);
+  return {
+    prompt: promptText,
+    system: systemPrompt,
+    temperature: boundedNumber(params.temperature, 0.7, 0, 2),
+    maxTokens: params.omitMaxTokens ? undefined : positiveInteger(params.maxTokens, 8192),
+    omitMaxTokens: params.omitMaxTokens,
+    frequencyPenalty: boundedNumber(params.frequencyPenalty, 0.7, -2, 2),
+    presencePenalty: boundedNumber(params.presencePenalty, 0.7, -2, 2),
+    stopSequences: stringArray(params.stopSequences),
+    ...paramsWithNative.messages ? { messages: paramsWithNative.messages } : {},
+    ...paramsWithNative.tools ? { tools: paramsWithNative.tools } : {},
+    ...paramsWithNative.toolChoice ? { toolChoice: paramsWithNative.toolChoice } : {},
+    ...paramsWithNative.responseSchema ? { responseSchema: paramsWithNative.responseSchema } : {},
+    ...returnNative ? { returnNative } : {}
+  };
+}
+async function handleTextModel(runtime, params, modelType) {
+  const groq = createGroqClient(runtime);
+  const model = getTextModelForType(runtime, modelType);
+  const system = resolveGroqSystemPrompt(runtime, params);
+  const result = await generateWithRetry(runtime, groq, modelType, model, buildGroqGenerateParams(params, system, resolveGroqPrompt(params, system)));
+  return result;
+}
+function getTextModelForType(runtime, modelType) {
+  switch (modelType) {
+    case ModelType.TEXT_NANO:
+      return getNanoModel(runtime);
+    case ModelType.TEXT_MEDIUM:
+      return getMediumModel(runtime);
+    case ModelType.TEXT_SMALL:
+      return getSmallModel(runtime);
+    case ModelType.TEXT_LARGE:
+      return getLargeModel(runtime);
+    case ModelType.TEXT_MEGA:
+      return getMegaModel(runtime);
+    case ModelType.RESPONSE_HANDLER:
+      return getResponseHandlerModel(runtime);
+    case ModelType.ACTION_PLANNER:
+      return getActionPlannerModel(runtime);
+    default:
+      return getLargeModel(runtime);
+  }
+}
+var groqPlugin = {
+  name: "groq",
+  description: "Groq LLM provider - fast inference with GPT-OSS models",
+  autoEnable: {
+    envKeys: ["GROQ_API_KEY"]
+  },
+  config: {
+    GROQ_API_KEY: env("GROQ_API_KEY"),
+    GROQ_BASE_URL: env("GROQ_BASE_URL"),
+    GROQ_NANO_MODEL: env("GROQ_NANO_MODEL"),
+    GROQ_MEDIUM_MODEL: env("GROQ_MEDIUM_MODEL"),
+    GROQ_SMALL_MODEL: env("GROQ_SMALL_MODEL"),
+    GROQ_LARGE_MODEL: env("GROQ_LARGE_MODEL"),
+    GROQ_MEGA_MODEL: env("GROQ_MEGA_MODEL"),
+    GROQ_RESPONSE_HANDLER_MODEL: env("GROQ_RESPONSE_HANDLER_MODEL"),
+    GROQ_SHOULD_RESPOND_MODEL: env("GROQ_SHOULD_RESPOND_MODEL"),
+    GROQ_ACTION_PLANNER_MODEL: env("GROQ_ACTION_PLANNER_MODEL"),
+    GROQ_PLANNER_MODEL: env("GROQ_PLANNER_MODEL"),
+    GROQ_TRANSCRIPTION_MODEL: env("GROQ_TRANSCRIPTION_MODEL"),
+    TRANSCRIPTION_MODEL: env("TRANSCRIPTION_MODEL"),
+    NANO_MODEL: env("NANO_MODEL"),
+    MEDIUM_MODEL: env("MEDIUM_MODEL"),
+    SMALL_MODEL: env("SMALL_MODEL"),
+    LARGE_MODEL: env("LARGE_MODEL"),
+    MEGA_MODEL: env("MEGA_MODEL"),
+    RESPONSE_HANDLER_MODEL: env("RESPONSE_HANDLER_MODEL"),
+    SHOULD_RESPOND_MODEL: env("SHOULD_RESPOND_MODEL"),
+    ACTION_PLANNER_MODEL: env("ACTION_PLANNER_MODEL"),
+    PLANNER_MODEL: env("PLANNER_MODEL")
+  },
+  async init(_config, runtime) {
+    const apiKey = nonEmptyString(runtime.getSetting("GROQ_API_KEY"));
+    if (!apiKey && !isBrowser()) {
+      throw new Error("GROQ_API_KEY is required");
+    }
+  },
+  models: {
+    [ModelType.TEXT_NANO]: (runtime, params) => handleTextModel(runtime, params, ModelType.TEXT_NANO),
+    [ModelType.TEXT_SMALL]: (runtime, params) => handleTextModel(runtime, params, ModelType.TEXT_SMALL),
+    [ModelType.TEXT_MEDIUM]: (runtime, params) => handleTextModel(runtime, params, ModelType.TEXT_MEDIUM),
+    [ModelType.TEXT_LARGE]: (runtime, params) => handleTextModel(runtime, params, ModelType.TEXT_LARGE),
+    [ModelType.TEXT_MEGA]: (runtime, params) => handleTextModel(runtime, params, ModelType.TEXT_MEGA),
+    [ModelType.RESPONSE_HANDLER]: (runtime, params) => handleTextModel(runtime, params, ModelType.RESPONSE_HANDLER),
+    [ModelType.ACTION_PLANNER]: (runtime, params) => handleTextModel(runtime, params, ModelType.ACTION_PLANNER),
+    [ModelType.TRANSCRIPTION]: async (runtime, params) => {
+      function hasAudioData(obj) {
+        return "audioData" in obj && obj.audioData instanceof Uint8Array;
+      }
+      if (isBrowser()) {
+        throw new Error("Groq TRANSCRIPTION is not supported directly in browsers. Use a server proxy or submit a Blob/ArrayBuffer to a server.");
+      }
+      const buffer = getRuntimeBuffer();
+      if (!buffer) {
+        throw new Error("Groq TRANSCRIPTION requires Buffer support outside browsers.");
+      }
+      const audioBuffer = typeof params === "string" ? buffer.from(params, "base64") : buffer.isBuffer(params) ? params : typeof params === "object" && params !== null && hasAudioData(params) ? buffer.from(params.audioData) : buffer.alloc(0);
+      if (audioBuffer.byteLength === 0) {
+        throw new Error("Groq TRANSCRIPTION requires non-empty audio data.");
+      }
+      const baseURL = getBaseURL(runtime);
+      const transcriptionModel = getTranscriptionModel(runtime);
+      const formData = new FormData;
+      formData.append("file", new File([audioBuffer], "audio.mp3", { type: "audio/mp3" }));
+      formData.append("model", transcriptionModel);
+      const apiKey = nonEmptyString(runtime.getSetting("GROQ_API_KEY"));
+      const details = {
+        model: transcriptionModel,
+        systemPrompt: "",
+        userPrompt: `audio transcription request: ${audioBuffer.byteLength} bytes`,
+        temperature: 0,
+        maxTokens: 0,
+        purpose: "external_llm",
+        actionType: "groq.audio.transcriptions.create"
+      };
+      const data = await recordLlmCall(runtime, details, async () => {
+        const response = await fetch(`${baseURL}/audio/transcriptions`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey ?? ""}`
+          },
+          body: formData
+        });
+        if (!response.ok) {
+          throw new Error(`Transcription failed: ${response.status} ${await response.text()}`);
+        }
+        const result = await response.json();
+        details.response = result.text;
+        return result;
+      });
+      return data.text;
+    },
+    [ModelType.TEXT_TO_SPEECH]: async (runtime, params) => {
+      if (isBrowser()) {
+        throw new Error("Groq TEXT_TO_SPEECH is not supported directly in browsers. Use a server proxy.");
+      }
+      const payload = typeof params === "string" ? { text: params } : params && typeof params === "object" ? params : {};
+      const text = nonEmptyString(payload.text);
+      if (!text) {
+        throw new Error("Groq TEXT_TO_SPEECH requires non-empty text.");
+      }
+      const baseURL = getBaseURL(runtime);
+      const modelSetting = runtime.getSetting("GROQ_TTS_MODEL");
+      const voiceSetting = runtime.getSetting("GROQ_TTS_VOICE");
+      const responseFormatSetting = runtime.getSetting("GROQ_TTS_RESPONSE_FORMAT");
+      const model = typeof payload.model === "string" && payload.model ? payload.model : typeof modelSetting === "string" ? modelSetting : DEFAULT_TTS_MODEL;
+      const voice = typeof payload.voice === "string" && payload.voice ? payload.voice : typeof voiceSetting === "string" ? voiceSetting : DEFAULT_TTS_VOICE;
+      const responseFormat = typeof payload.responseFormat === "string" && payload.responseFormat ? payload.responseFormat : typeof payload.response_format === "string" && payload.response_format ? payload.response_format : typeof responseFormatSetting === "string" ? responseFormatSetting : DEFAULT_TTS_RESPONSE_FORMAT;
+      const apiKey = nonEmptyString(runtime.getSetting("GROQ_API_KEY"));
+      const details = {
+        model,
+        systemPrompt: "",
+        userPrompt: text,
+        temperature: 0,
+        maxTokens: 0,
+        purpose: "external_llm",
+        actionType: "groq.audio.speech.create"
+      };
+      const arrayBuffer = await recordLlmCall(runtime, details, async () => {
+        const response = await fetch(`${baseURL}/audio/speech`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey ?? ""}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model,
+            voice,
+            input: text,
+            response_format: responseFormat
+          })
+        });
+        if (!response.ok) {
+          throw new Error(`TTS failed: ${response.status} ${await response.text()}`);
+        }
+        const result = await response.arrayBuffer();
+        details.response = `[audio bytes=${result.byteLength} format=${responseFormat}]`;
+        return result;
+      });
+      return new Uint8Array(arrayBuffer);
+    }
+  },
+  tests: [
+    {
+      name: "groq_plugin_tests",
+      tests: [
+        {
+          name: "validate_api_key",
+          fn: async (runtime) => {
+            const baseURL = getBaseURL(runtime);
+            const response = await fetch(`${baseURL}/models`, {
+              headers: {
+                Authorization: `Bearer ${runtime.getSetting("GROQ_API_KEY")}`
+              }
+            });
+            if (!response.ok) {
+              throw new Error(`API key validation failed: ${response.statusText}`);
+            }
+            const data = await response.json();
+            logger.info(`Groq API validated, ${data.data.length} models available`);
+          }
+        },
+        {
+          name: "text_small",
+          fn: async (runtime) => {
+            const text = await runtime.useModel(ModelType.TEXT_SMALL, {
+              prompt: "Say hello in exactly 3 words."
+            });
+            if (!text || text.length === 0) {
+              throw new Error("Empty response from TEXT_SMALL");
+            }
+            logger.info("TEXT_SMALL:", text);
+          }
+        },
+        {
+          name: "text_large",
+          fn: async (runtime) => {
+            const text = await runtime.useModel(ModelType.TEXT_LARGE, {
+              prompt: "What is 2+2? Answer with just the number."
+            });
+            if (!text || text.length === 0) {
+              throw new Error("Empty response from TEXT_LARGE");
+            }
+            logger.info("TEXT_LARGE:", text);
+          }
+        }
+      ]
+    }
+  ]
+};
+var plugin_groq_default = groqPlugin;
+
+// index.node.ts
+var index_node_default = plugin_groq_default;
+export {
+  groqPlugin,
+  index_node_default as default,
+  classifyRetryError
+};
+
+//# debugId=BC4554A41753610164756E2164756E21