@warlock.js/ai-groq 5.30.0 → 5.32.0

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to `@warlock.js/ai-groq` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 5.32.0 - 2026-10-18
+
+### Changed
+
+- Pin the package development compiler to TypeScript 7.0.2 and use explicit Node types and source roots with supported module resolution.
+
+## 5.31.0 - 2026-10-18
+
+### Added
+
+- An adapter contract test verifies that aborting `signal` rejects `complete()` and `stream()` on the model and cancels the HTTP request.
+
+### Changed
+
+- Chat calls inherit `providerOptions.openai.body` from the OpenAI adapter, including its protected fields and one-level plain-object merge. Use only this provider's accepted fields when sharing fallback options. Native `countTokens` remains absent; `sdk.count(text)` is an offline estimate.
+
+### Fixed
+
+- `GROQ_DEFAULT_PRICING` (now exported) matches Groq's published prices (2026-10-17): `openai/gpt-oss-120b` output is 0.60, the gpt-oss models get their 50% cache-read rate, and `qwen/qwen3.8-27b` is added.
+
+### Upgrading
+
+- **BREAKING** `llama-3.3-70b-versatile`, `llama-3.1-8b-instant` and `deepseek-r1-distill-llama-70b` no longer have built-in prices (Groq publishes none), so a USD budget on them rejects the run as unpriced. Pass `pricing` for them.
+
 ## 5.30.0 - 2026-10-16
 
 ### Changed
@@ -81,6 +105,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ### Changed
 
 - Lockstep release maintenance and dependency refresh.
+
 ## 5.20.0 - 2026-09-24
 
 ### Changed

package/README.md

@@ -51,12 +51,12 @@ GroqModelConfig {
 
 A curated (not exhaustive, not an allow-list) set of current production ids is exported as `GROQ_KNOWN_MODELS`:
 
-| Model id | Notes |
-| --- | --- |
-| `llama-3.3-70b-versatile` | Flagship general-purpose text |
-| `llama-3.1-8b-instant` | Fastest / cheapest small text |
+| Model id                                     | Notes                                                  |
+| -------------------------------------------- | ------------------------------------------------------ |
+| `llama-3.3-70b-versatile`                    | Flagship general-purpose text                          |
+| `llama-3.1-8b-instant`                       | Fastest / cheapest small text                          |
 | `openai/gpt-oss-120b` / `openai/gpt-oss-20b` | OpenAI open-weight family — vision + reasoning capable |
-| `deepseek-r1-distill-llama-70b` | DeepSeek-R1-style reasoning |
+| `deepseek-r1-distill-llama-70b`              | DeepSeek-R1-style reasoning                            |
 
 `name` is the upstream open-weight id (e.g. `openai/gpt-oss-120b`), NOT an OpenAI id. `groq.model()` accepts any string, so a newly launched Groq id works the moment Groq ships it.
 
@@ -64,23 +64,23 @@ A curated (not exhaustive, not an allow-list) set of current production ids is e
 
 The whole reason this wrapper exists: Groq's ids aren't OpenAI's, so the OpenAI adapter's prefix inference would never fire. `GroqSDK` carries its **own** name lists and injects the result as explicit capability config, which wins over the inner adapter's inference. An explicit caller value always wins.
 
-| Capability | Default |
-| --- | --- |
-| `vision` | Inferred from the Groq id — `true` for `gpt-oss`, `llama-4`, `llama-3.2-*-vision`; `false` otherwise (e.g. `llama-3.3-70b-versatile`). |
-| `reasoning` | Inferred from the Groq id — `true` for `gpt-oss`, `deepseek-r1` / `deepseek-r1-distill`, `qwq`, `qwen3`; `false` otherwise. Drives whether `reasoning.effort` maps to `reasoning_effort` on the wire. |
-| `structuredOutput` | `true` — Groq accepts OpenAI-style `response_format`. |
+| Capability         | Default                                                                                                                                                                                               |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `vision`           | Inferred from the Groq id — `true` for `gpt-oss`, `llama-4`, `llama-3.2-*-vision`; `false` otherwise (e.g. `llama-3.3-70b-versatile`).                                                                |
+| `reasoning`        | Inferred from the Groq id — `true` for `gpt-oss`, `deepseek-r1` / `deepseek-r1-distill`, `qwq`, `qwen3`; `false` otherwise. Drives whether `reasoning.effort` maps to `reasoning_effort` on the wire. |
+| `structuredOutput` | `true` — Groq accepts OpenAI-style `response_format`.                                                                                                                                                 |
 
 ```ts
-groq.model({ name: "openai/gpt-oss-120b" });                 // vision + reasoning auto-true
-groq.model({ name: "deepseek-r1-distill-llama-70b" });       // reasoning auto-true
-groq.model({ name: "some-custom-llama", vision: true });     // explicit override
+groq.model({ name: "openai/gpt-oss-120b" }); // vision + reasoning auto-true
+groq.model({ name: "deepseek-r1-distill-llama-70b" }); // reasoning auto-true
+groq.model({ name: "some-custom-llama", vision: true }); // explicit override
 ```
 
 Reasoning models accept a discrete effort knob forwarded by the inner adapter as OpenAI's `reasoning_effort`:
 
 ```ts
 const model = groq.model({ name: "deepseek-r1-distill-llama-70b" });
-await model.complete(messages, { reasoning: { effort: "high" } });   // → reasoning_effort: "high"
+await model.complete(messages, { reasoning: { effort: "high" } }); // → reasoning_effort: "high"
 ```
 
 ## Embeddings — not available on Groq

package/cjs/index.cjs

@@ -232,47 +232,50 @@ var GroqSDK = class {
 	}
 };
 /**
-* Built-in default USD-per-1,000,000-token rates for the current Groq
-* production models (mid-2026), used as the last fallback in `model()`'s
-* pricing resolution. A per-model or SDK-level `pricing` entry always
-* wins over these. Returns `undefined` for any unlisted id so cost stays
-* an honest absence rather than a false zero. Update when Groq revises
-* its public price list.
+* Built-in default USD-per-1,000,000-token rates for the Groq models with
+* a published price, used as the last fallback in `model()`'s pricing
+* resolution. A per-model or SDK-level `pricing` entry always wins over
+* these. Returns `undefined` for any unlisted id so cost stays an honest
+* absence rather than a false zero.
 */
 function defaultPricingFor(name) {
 	return GROQ_DEFAULT_PRICING[name];
 }
 /**
-* Default per-million-token USD rates for known Groq models. Kept inline
-* (not exported) so the public surface stays the inference helpers; a
-* caller who wants different numbers supplies `pricing` on the SDK or
-* per model.
+* Default per-million-token USD rates for Groq models.
+*
+* Source: https://console.groq.com/docs/models (groq.com/pricing now
+* redirects to the home page), fetched 2026-10-17. Cached input is 50%
+* of the input rate for the gpt-oss models, the only ones Groq caches
+* (https://console.groq.com/docs/prompt-caching; no write charge). The
+* Llama models are listed as "Enterprise – Contact Sales" with no public
+* price, so they stay unpriced — pass `pricing` for them.
 */
 const GROQ_DEFAULT_PRICING = {
-	"llama-3.3-70b-versatile": {
-		input: .59,
-		output: .79
-	},
-	"llama-3.1-8b-instant": {
-		input: .05,
-		output: .08
-	},
 	"openai/gpt-oss-120b": {
 		input: .15,
-		output: .75
+		output: .6,
+		cachedInput: .075
 	},
 	"openai/gpt-oss-20b": {
-		input: .1,
-		output: .5
+		input: .075,
+		output: .3,
+		cachedInput: .0375
+	},
+	"openai/gpt-oss-safeguard-20b": {
+		input: .075,
+		output: .3,
+		cachedInput: .0375
 	},
-	"deepseek-r1-distill-llama-70b": {
-		input: .75,
-		output: .99
+	"qwen/qwen3.8-27b": {
+		input: .8,
+		output: 4
 	}
 };
 
 //#endregion
 exports.GROQ_BASE_URL = GROQ_BASE_URL;
+exports.GROQ_DEFAULT_PRICING = GROQ_DEFAULT_PRICING;
 exports.GROQ_KNOWN_MODELS = GROQ_KNOWN_MODELS;
 exports.GROQ_PROVIDER = GROQ_PROVIDER;
 exports.GroqSDK = GroqSDK;

package/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["OpenAISDK"],"sources":["../../../../../../../packages/ai-groq/src/known-models.ts","../../../../../../../packages/ai-groq/src/sdk.ts"],"sourcesContent":["/**\n * Default base URL for Groq's OpenAI-compatible Chat Completions\n * endpoint. Groq exposes the same wire protocol as OpenAI under this\n * prefix, which is exactly why `GroqSDK` can delegate to the\n * battle-tested `OpenAISDK` instead of reimplementing the transport.\n *\n * Verified against Groq's \"OpenAI Compatibility\" docs (mid-2026).\n * Override via `new GroqSDK({ baseURL })` if Groq ever relocates it.\n */\nexport const GROQ_BASE_URL = \"https://api.groq.com/openai/v1\";\n\n/**\n * The provider label every model produced by `GroqSDK` self-identifies\n * with. Flows through to `ModelContract.provider`, `AgentReport.model`,\n * logs, and any provider-aware middleware. Kept as a constant so the\n * wrapper and the inner `OpenAISDK` agree on one spelling.\n */\nexport const GROQ_PROVIDER = \"groq\";\n\n/**\n * Substrings identifying Groq-hosted model ids whose family accepts\n * image input (vision).\n *\n * Groq hosts *open* models on its LPU hardware, so the ids are the\n * upstream open-weight names rather than OpenAI's — which is why the\n * OpenAI adapter's `gpt-4o*` prefix inference would never fire here and\n * this provider must carry its OWN list. Verified against Groq's\n * supported-models catalog (mid-2026):\n *\n * - `openai/gpt-oss-*` — natively multimodal OpenAI open-weight family\n *   (the current production vision + reasoning models on Groq).\n * - `llama-4` / `llama-3.2-*-vision` — Meta's multimodal Llama families.\n *   Kept as substrings so any still-hosted or re-introduced variant is\n *   covered even though some `llama-4` ids were deprecated in 2026.\n *\n * Matched as a substring (not a prefix) because Groq prefixes several\n * ids with an org segment (`openai/`, `meta-llama/`) and appends size /\n * date suffixes. Override per-model via\n * `groq.model({ name, vision: true | false })`.\n */\nconst VISION_CAPABLE_SUBSTRINGS = [\n  \"gpt-oss\",\n  \"llama-4\",\n  \"llama-3.2-11b-vision\",\n  \"llama-3.2-90b-vision\",\n  \"vision\",\n];\n\n/**\n * Substrings identifying Groq-hosted model ids that expose an internal\n * reasoning / thinking channel and accept the `reasoning_effort`\n * request parameter on the OpenAI-compatible Chat Completions endpoint.\n *\n * Verified against Groq's catalog (mid-2026):\n * - `gpt-oss` — the OpenAI open-weight family reasons by default.\n * - `deepseek-r1-distill` — DeepSeek-R1-style reasoning at Groq speed.\n * - `qwq` / `qwen3` — Qwen reasoning families (when hosted).\n *\n * Matched as a substring for the same org-prefix / suffix reason as the\n * vision list. Override per-model via\n * `groq.model({ name, reasoning: true | false })`.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\n  \"gpt-oss\",\n  \"deepseek-r1\",\n  \"deepseek-r1-distill\",\n  \"qwq\",\n  \"qwen3\",\n];\n\n/**\n * Infer whether a Groq-hosted model id supports vision based on the\n * known multimodal-family substrings. Unknown ids default to `false`\n * so passing an image attachment to a text-only model (e.g.\n * `llama-3.3-70b-versatile`) surfaces a clear, agent-side capability\n * error instead of an opaque upstream 400.\n *\n * @example\n * inferVisionCapability(\"openai/gpt-oss-120b\");        // → true\n * inferVisionCapability(\"meta-llama/llama-4-scout\");   // → true\n * inferVisionCapability(\"llama-3.3-70b-versatile\");    // → false\n * inferVisionCapability(\"llama-3.1-8b-instant\");       // → false\n */\nexport function inferVisionCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Infer whether a Groq-hosted model id is a reasoning model based on\n * the known reasoning-family substrings. Unknown ids default to `false`\n * so the adapter never forwards an unsupported `reasoning_effort` param\n * to a non-reasoning model (which would 400).\n *\n * @example\n * inferReasoningCapability(\"openai/gpt-oss-20b\");           // → true\n * inferReasoningCapability(\"deepseek-r1-distill-llama-70b\"); // → true\n * inferReasoningCapability(\"llama-3.3-70b-versatile\");      // → false\n */\nexport function inferReasoningCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Curated list of current Groq production chat model ids (mid-2026),\n * for autocomplete, docs, and default selection. NOT exhaustive and NOT\n * a runtime allow-list — `groq.model({ name })` accepts any string, so\n * a newly launched id works the moment Groq ships it without a package\n * bump. Deprecated ids (e.g. several `llama-4` variants retired in 2026)\n * are intentionally excluded.\n *\n * - `llama-3.3-70b-versatile` — flagship general-purpose text model.\n * - `llama-3.1-8b-instant` — fastest/cheapest small text model.\n * - `openai/gpt-oss-120b` / `openai/gpt-oss-20b` — OpenAI open-weight\n *   family; vision + reasoning capable.\n * - `deepseek-r1-distill-llama-70b` — DeepSeek-R1-style reasoning.\n */\nexport const GROQ_KNOWN_MODELS = [\n  \"llama-3.3-70b-versatile\",\n  \"llama-3.1-8b-instant\",\n  \"openai/gpt-oss-120b\",\n  \"openai/gpt-oss-20b\",\n  \"deepseek-r1-distill-llama-70b\",\n] as const;\n","import type {\n  EmbedderContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type {\n  GroqEmbedderConfig,\n  GroqModelConfig,\n  GroqSDKConfig,\n} from \"./config.type\";\nimport {\n  GROQ_BASE_URL,\n  GROQ_PROVIDER,\n  inferReasoningCapability,\n  inferVisionCapability,\n} from \"./known-models\";\n\n/**\n * Groq-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for Groq-hosted open models\n * (`llama-3.3-70b-versatile`, `llama-3.1-8b-instant`,\n * `openai/gpt-oss-*`, `deepseek-r1-distill-*`, …) served on Groq's fast\n * LPU hardware. Because Groq exposes the OpenAI Chat Completions wire\n * protocol verbatim, `GroqSDK` is a **thin wrapper over the already\n * battle-tested {@link OpenAISDK}** rather than a fresh transport\n * implementation — it owns one internal `OpenAISDK` pointed at Groq's\n * `baseURL` with the `\"groq\"` provider label, and delegates `model()` /\n * `embedder()` / `count()` to it.\n *\n * **Why a wrapper and not `OpenAISDK` directly?** Groq hosts *open*\n * models whose ids are the upstream open-weight names (`llama-…`,\n * `openai/gpt-oss-…`), not OpenAI's (`gpt-4o`, `o3`). The OpenAI\n * adapter's capability inference keys on OpenAI prefixes and would never\n * fire here, so every Groq model would come back with `vision`/\n * `reasoning` silently `false`. `GroqSDK` fixes that by computing\n * **this provider's own** vision/reasoning inference (see\n * `known-models.ts`) and injecting the result as explicit capability\n * config — which wins over the inner adapter's inference — plus a set of\n * default per-model pricing rates. Everything else (transport, retries,\n * streaming, structured output, error wrapping, usage accounting) is\n * inherited unchanged from `OpenAISDK`.\n *\n * **Responsibility.**\n * - Owns: one long-lived internal `OpenAISDK` (auth + Groq base URL) and\n *   this provider's capability + default-pricing inference.\n * - Does NOT own: the wire protocol, streaming loop, structured-output\n *   mapping, or error wrapping — all inherited from `OpenAISDK`.\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"), fronted by FP usage like the other adapters.\n *\n * @example\n * const groq = new GroqSDK({ apiKey: process.env.GROQ_API_KEY! });\n * const model = groq.model({ name: \"llama-3.3-70b-versatile\", temperature: 0.7 });\n * const reasoner = groq.model({ name: \"openai/gpt-oss-120b\" }); // vision + reasoning auto-true\n *\n * @example\n * // Compose into an `ai.groq` namespace for ergonomic agent wiring\n * const ai = { agent, tool, systemPrompt, groq: new GroqSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.groq.model({ name: \"llama-3.1-8b-instant\" }) });\n */\nexport class GroqSDK implements SDKAdapterContract {\n  /**\n   * The wrapped OpenAI-compatible adapter, pre-pointed at Groq's\n   * `baseURL` and labeled with the `\"groq\"` provider. All real wire work\n   * happens here; `GroqSDK` only enriches the per-model config before\n   * delegating.\n   */\n  private readonly openai: OpenAISDK;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: GroqSDKConfig) {\n    const { baseURL, provider, pricing, ...clientOptions } = config;\n\n    this.provider = provider ?? GROQ_PROVIDER;\n    this.pricing = pricing;\n\n    // Build the inner OpenAI-compatible client pointed at Groq. Forward\n    // every other upstream ClientOptions (timeout, maxRetries,\n    // defaultHeaders, fetch, …) verbatim — they type-check, so dropping\n    // them would be a silent footgun. We pass `pricing` through too so\n    // the inner registry stays a fallback, while THIS class's `model()`\n    // layers Groq default rates on top.\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? GROQ_BASE_URL,\n      provider: this.provider,\n      pricing,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` bound to the internal Groq-pointed client.\n   *\n   * The wrapper's whole job lives here: it computes **Groq's** vision /\n   * reasoning inference from the model id and forwards the result as\n   * *explicit* `vision` / `reasoning` config to the inner\n   * `OpenAISDK.model()`. Because explicit capability config wins over the\n   * inner adapter's OpenAI-prefix inference, the returned model reports\n   * the right capabilities even though the id isn't an OpenAI name. A\n   * caller-supplied `vision` / `reasoning` still wins over this\n   * inference (we only fill the gap when the field is omitted).\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise this\n   * SDK's `pricing` registry keyed by `config.name`; otherwise the\n   * adapter's built-in default rate for the model; otherwise `undefined`\n   * (no cost computed).\n   */\n  public model(config: GroqModelConfig): ModelContract {\n    const resolvedPricing =\n      config.pricing ?? this.pricing?.[config.name] ?? defaultPricingFor(config.name);\n\n    return this.openai.model({\n      ...config,\n      // Fill capability inference only when the caller didn't pin it —\n      // explicit caller config always wins, then Groq inference, then\n      // (inside OpenAISDK) the harmless OpenAI inference that won't match.\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      structuredOutput: config.structuredOutput ?? true,\n      pricing: resolvedPricing,\n    });\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegated straight to the inner\n   * `OpenAISDK`, which uses the core character-heuristic\n   * (`approximateTokenCount`). Good for budgeting / quota guards, not for\n   * billing.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an embedder bound to the internal client. Delegated to the\n   * inner `OpenAISDK`.\n   *\n   * IMPORTANT: as of mid-2026 Groq does **not** expose an\n   * OpenAI-compatible embeddings endpoint, so a live `.embed()` /\n   * `.embedMany()` call will fail at the provider. The method is kept for\n   * adapter symmetry; use `@warlock.js/ai-openai` or\n   * `@warlock.js/ai-google` for retrieval embeddings.\n   */\n  public embedder(config: GroqEmbedderConfig): EmbedderContract {\n    return this.openai.embedder(config);\n  }\n\n  // NOTE: `image()` is intentionally NOT implemented. Groq hosts no\n  // image-generation API, and `SDKAdapterContract.image` is optional —\n  // its structural absence IS the capability guard, so\n  // `ai.groq.image(...)` is a compile-time error rather than a runtime\n  // surprise (mirrors Anthropic / Bedrock / Ollama).\n}\n\n/**\n * Built-in default USD-per-1,000,000-token rates for the current Groq\n * production models (mid-2026), used as the last fallback in `model()`'s\n * pricing resolution. A per-model or SDK-level `pricing` entry always\n * wins over these. Returns `undefined` for any unlisted id so cost stays\n * an honest absence rather than a false zero. Update when Groq revises\n * its public price list.\n */\nfunction defaultPricingFor(name: string): ModelPricing | undefined {\n  return GROQ_DEFAULT_PRICING[name];\n}\n\n/**\n * Default per-million-token USD rates for known Groq models. Kept inline\n * (not exported) so the public surface stays the inference helpers; a\n * caller who wants different numbers supplies `pricing` on the SDK or\n * per model.\n */\nconst GROQ_DEFAULT_PRICING: Record<string, ModelPricing> = {\n  \"llama-3.3-70b-versatile\": { input: 0.59, output: 0.79 },\n  \"llama-3.1-8b-instant\": { input: 0.05, output: 0.08 },\n  \"openai/gpt-oss-120b\": { input: 0.15, output: 0.75 },\n  \"openai/gpt-oss-20b\": { input: 0.1, output: 0.5 },\n  \"deepseek-r1-distill-llama-70b\": { input: 0.75, output: 0.99 },\n};\n"],"mappings":";;;;;;;;;;;;;AASA,MAAa,gBAAgB;;;;;;;AAQ7B,MAAa,gBAAgB;;;;;;;;;;;;;;;;;;;;;;AAuB7B,MAAM,4BAA4B;CAChC;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;AAgBA,MAAM,+BAA+B;CACnC;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,SAAgB,sBAAsB,SAA0B;CAC9D,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF;;;;;;;;;;;;AAaA,SAAgB,yBAAyB,SAA0B;CACjE,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;;;;;;AAgBA,MAAa,oBAAoB;CAC/B;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9DA,IAAa,UAAb,MAAmD;CAWjD,AAAO,YAAY,QAAuB;EACxC,MAAM,EAAE,SAAS,UAAU,SAAS,GAAG,kBAAkB;EAEzD,KAAK,WAAW;EAChB,KAAK,UAAU;EAQf,KAAK,SAAS,IAAIA,gCAAU;GAC1B,GAAG;GACH,SAAS;GACT,UAAU,KAAK;GACf;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;CAmBA,AAAO,MAAM,QAAwC;EACnD,MAAM,kBACJ,OAAO,WAAW,KAAK,UAAU,OAAO,SAAS,kBAAkB,OAAO,IAAI;EAEhF,OAAO,KAAK,OAAO,MAAM;GACvB,GAAG;GAIH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;GACnE,kBAAkB,OAAO,oBAAoB;GAC7C,SAAS;EACX,CAAC;CACH;;;;;;;CAQA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAA8C;EAC5D,OAAO,KAAK,OAAO,SAAS,MAAM;CACpC;AAOF;;;;;;;;;AAUA,SAAS,kBAAkB,MAAwC;CACjE,OAAO,qBAAqB;AAC9B;;;;;;;AAQA,MAAM,uBAAqD;CACzD,2BAA2B;EAAE,OAAO;EAAM,QAAQ;CAAK;CACvD,wBAAwB;EAAE,OAAO;EAAM,QAAQ;CAAK;CACpD,uBAAuB;EAAE,OAAO;EAAM,QAAQ;CAAK;CACnD,sBAAsB;EAAE,OAAO;EAAK,QAAQ;CAAI;CAChD,iCAAiC;EAAE,OAAO;EAAM,QAAQ;CAAK;AAC/D"}
+{"version":3,"file":"index.cjs","names":["OpenAISDK"],"sources":["../../../../../../../packages/ai-groq/src/known-models.ts","../../../../../../../packages/ai-groq/src/sdk.ts"],"sourcesContent":["/**\n * Default base URL for Groq's OpenAI-compatible Chat Completions\n * endpoint. Groq exposes the same wire protocol as OpenAI under this\n * prefix, which is exactly why `GroqSDK` can delegate to the\n * battle-tested `OpenAISDK` instead of reimplementing the transport.\n *\n * Verified against Groq's \"OpenAI Compatibility\" docs (mid-2026).\n * Override via `new GroqSDK({ baseURL })` if Groq ever relocates it.\n */\nexport const GROQ_BASE_URL = \"https://api.groq.com/openai/v1\";\n\n/**\n * The provider label every model produced by `GroqSDK` self-identifies\n * with. Flows through to `ModelContract.provider`, `AgentReport.model`,\n * logs, and any provider-aware middleware. Kept as a constant so the\n * wrapper and the inner `OpenAISDK` agree on one spelling.\n */\nexport const GROQ_PROVIDER = \"groq\";\n\n/**\n * Substrings identifying Groq-hosted model ids whose family accepts\n * image input (vision).\n *\n * Groq hosts *open* models on its LPU hardware, so the ids are the\n * upstream open-weight names rather than OpenAI's — which is why the\n * OpenAI adapter's `gpt-4o*` prefix inference would never fire here and\n * this provider must carry its OWN list. Verified against Groq's\n * supported-models catalog (mid-2026):\n *\n * - `openai/gpt-oss-*` — natively multimodal OpenAI open-weight family\n *   (the current production vision + reasoning models on Groq).\n * - `llama-4` / `llama-3.2-*-vision` — Meta's multimodal Llama families.\n *   Kept as substrings so any still-hosted or re-introduced variant is\n *   covered even though some `llama-4` ids were deprecated in 2026.\n *\n * Matched as a substring (not a prefix) because Groq prefixes several\n * ids with an org segment (`openai/`, `meta-llama/`) and appends size /\n * date suffixes. Override per-model via\n * `groq.model({ name, vision: true | false })`.\n */\nconst VISION_CAPABLE_SUBSTRINGS = [\n  \"gpt-oss\",\n  \"llama-4\",\n  \"llama-3.2-11b-vision\",\n  \"llama-3.2-90b-vision\",\n  \"vision\",\n];\n\n/**\n * Substrings identifying Groq-hosted model ids that expose an internal\n * reasoning / thinking channel and accept the `reasoning_effort`\n * request parameter on the OpenAI-compatible Chat Completions endpoint.\n *\n * Verified against Groq's catalog (mid-2026):\n * - `gpt-oss` — the OpenAI open-weight family reasons by default.\n * - `deepseek-r1-distill` — DeepSeek-R1-style reasoning at Groq speed.\n * - `qwq` / `qwen3` — Qwen reasoning families (when hosted).\n *\n * Matched as a substring for the same org-prefix / suffix reason as the\n * vision list. Override per-model via\n * `groq.model({ name, reasoning: true | false })`.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\n  \"gpt-oss\",\n  \"deepseek-r1\",\n  \"deepseek-r1-distill\",\n  \"qwq\",\n  \"qwen3\",\n];\n\n/**\n * Infer whether a Groq-hosted model id supports vision based on the\n * known multimodal-family substrings. Unknown ids default to `false`\n * so passing an image attachment to a text-only model (e.g.\n * `llama-3.3-70b-versatile`) surfaces a clear, agent-side capability\n * error instead of an opaque upstream 400.\n *\n * @example\n * inferVisionCapability(\"openai/gpt-oss-120b\");        // → true\n * inferVisionCapability(\"meta-llama/llama-4-scout\");   // → true\n * inferVisionCapability(\"llama-3.3-70b-versatile\");    // → false\n * inferVisionCapability(\"llama-3.1-8b-instant\");       // → false\n */\nexport function inferVisionCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Infer whether a Groq-hosted model id is a reasoning model based on\n * the known reasoning-family substrings. Unknown ids default to `false`\n * so the adapter never forwards an unsupported `reasoning_effort` param\n * to a non-reasoning model (which would 400).\n *\n * @example\n * inferReasoningCapability(\"openai/gpt-oss-20b\");           // → true\n * inferReasoningCapability(\"deepseek-r1-distill-llama-70b\"); // → true\n * inferReasoningCapability(\"llama-3.3-70b-versatile\");      // → false\n */\nexport function inferReasoningCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Curated list of current Groq production chat model ids (mid-2026),\n * for autocomplete, docs, and default selection. NOT exhaustive and NOT\n * a runtime allow-list — `groq.model({ name })` accepts any string, so\n * a newly launched id works the moment Groq ships it without a package\n * bump. Deprecated ids (e.g. several `llama-4` variants retired in 2026)\n * are intentionally excluded.\n *\n * - `llama-3.3-70b-versatile` — flagship general-purpose text model.\n * - `llama-3.1-8b-instant` — fastest/cheapest small text model.\n * - `openai/gpt-oss-120b` / `openai/gpt-oss-20b` — OpenAI open-weight\n *   family; vision + reasoning capable.\n * - `deepseek-r1-distill-llama-70b` — DeepSeek-R1-style reasoning.\n */\nexport const GROQ_KNOWN_MODELS = [\n  \"llama-3.3-70b-versatile\",\n  \"llama-3.1-8b-instant\",\n  \"openai/gpt-oss-120b\",\n  \"openai/gpt-oss-20b\",\n  \"deepseek-r1-distill-llama-70b\",\n] as const;\n","import type {\n  EmbedderContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type { GroqEmbedderConfig, GroqModelConfig, GroqSDKConfig } from \"./config.type\";\nimport {\n  GROQ_BASE_URL,\n  GROQ_PROVIDER,\n  inferReasoningCapability,\n  inferVisionCapability,\n} from \"./known-models\";\n\n/**\n * Groq-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for Groq-hosted open models\n * (`llama-3.3-70b-versatile`, `llama-3.1-8b-instant`,\n * `openai/gpt-oss-*`, `deepseek-r1-distill-*`, …) served on Groq's fast\n * LPU hardware. Because Groq exposes the OpenAI Chat Completions wire\n * protocol verbatim, `GroqSDK` is a **thin wrapper over the already\n * battle-tested {@link OpenAISDK}** rather than a fresh transport\n * implementation — it owns one internal `OpenAISDK` pointed at Groq's\n * `baseURL` with the `\"groq\"` provider label, and delegates `model()` /\n * `embedder()` / `count()` to it.\n *\n * **Why a wrapper and not `OpenAISDK` directly?** Groq hosts *open*\n * models whose ids are the upstream open-weight names (`llama-…`,\n * `openai/gpt-oss-…`), not OpenAI's (`gpt-4o`, `o3`). The OpenAI\n * adapter's capability inference keys on OpenAI prefixes and would never\n * fire here, so every Groq model would come back with `vision`/\n * `reasoning` silently `false`. `GroqSDK` fixes that by computing\n * **this provider's own** vision/reasoning inference (see\n * `known-models.ts`) and injecting the result as explicit capability\n * config — which wins over the inner adapter's inference — plus a set of\n * default per-model pricing rates. Everything else (transport, retries,\n * streaming, structured output, error wrapping, usage accounting) is\n * inherited unchanged from `OpenAISDK`.\n *\n * **Responsibility.**\n * - Owns: one long-lived internal `OpenAISDK` (auth + Groq base URL) and\n *   this provider's capability + default-pricing inference.\n * - Does NOT own: the wire protocol, streaming loop, structured-output\n *   mapping, or error wrapping — all inherited from `OpenAISDK`.\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"), fronted by FP usage like the other adapters.\n *\n * @example\n * const groq = new GroqSDK({ apiKey: process.env.GROQ_API_KEY! });\n * const model = groq.model({ name: \"llama-3.3-70b-versatile\", temperature: 0.7 });\n * const reasoner = groq.model({ name: \"openai/gpt-oss-120b\" }); // vision + reasoning auto-true\n *\n * @example\n * // Compose into an `ai.groq` namespace for ergonomic agent wiring\n * const ai = { agent, tool, systemPrompt, groq: new GroqSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.groq.model({ name: \"llama-3.1-8b-instant\" }) });\n */\nexport class GroqSDK implements SDKAdapterContract {\n  /**\n   * The wrapped OpenAI-compatible adapter, pre-pointed at Groq's\n   * `baseURL` and labeled with the `\"groq\"` provider. All real wire work\n   * happens here; `GroqSDK` only enriches the per-model config before\n   * delegating.\n   */\n  private readonly openai: OpenAISDK;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: GroqSDKConfig) {\n    const { baseURL, provider, pricing, ...clientOptions } = config;\n\n    this.provider = provider ?? GROQ_PROVIDER;\n    this.pricing = pricing;\n\n    // Build the inner OpenAI-compatible client pointed at Groq. Forward\n    // every other upstream ClientOptions (timeout, maxRetries,\n    // defaultHeaders, fetch, …) verbatim — they type-check, so dropping\n    // them would be a silent footgun. We pass `pricing` through too so\n    // the inner registry stays a fallback, while THIS class's `model()`\n    // layers Groq default rates on top.\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? GROQ_BASE_URL,\n      provider: this.provider,\n      pricing,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` bound to the internal Groq-pointed client.\n   *\n   * The wrapper's whole job lives here: it computes **Groq's** vision /\n   * reasoning inference from the model id and forwards the result as\n   * *explicit* `vision` / `reasoning` config to the inner\n   * `OpenAISDK.model()`. Because explicit capability config wins over the\n   * inner adapter's OpenAI-prefix inference, the returned model reports\n   * the right capabilities even though the id isn't an OpenAI name. A\n   * caller-supplied `vision` / `reasoning` still wins over this\n   * inference (we only fill the gap when the field is omitted).\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise this\n   * SDK's `pricing` registry keyed by `config.name`; otherwise the\n   * adapter's built-in default rate for the model; otherwise `undefined`\n   * (no cost computed).\n   */\n  public model(config: GroqModelConfig): ModelContract {\n    const resolvedPricing =\n      config.pricing ?? this.pricing?.[config.name] ?? defaultPricingFor(config.name);\n\n    return this.openai.model({\n      ...config,\n      // Fill capability inference only when the caller didn't pin it —\n      // explicit caller config always wins, then Groq inference, then\n      // (inside OpenAISDK) the harmless OpenAI inference that won't match.\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      structuredOutput: config.structuredOutput ?? true,\n      pricing: resolvedPricing,\n    });\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegated straight to the inner\n   * `OpenAISDK`, which uses the core character-heuristic\n   * (`approximateTokenCount`). Good for budgeting / quota guards, not for\n   * billing.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an embedder bound to the internal client. Delegated to the\n   * inner `OpenAISDK`.\n   *\n   * IMPORTANT: as of mid-2026 Groq does **not** expose an\n   * OpenAI-compatible embeddings endpoint, so a live `.embed()` /\n   * `.embedMany()` call will fail at the provider. The method is kept for\n   * adapter symmetry; use `@warlock.js/ai-openai` or\n   * `@warlock.js/ai-google` for retrieval embeddings.\n   */\n  public embedder(config: GroqEmbedderConfig): EmbedderContract {\n    return this.openai.embedder(config);\n  }\n\n  // NOTE: `image()` is intentionally NOT implemented. Groq hosts no\n  // image-generation API, and `SDKAdapterContract.image` is optional —\n  // its structural absence IS the capability guard, so\n  // `ai.groq.image(...)` is a compile-time error rather than a runtime\n  // surprise (mirrors Anthropic / Bedrock / Ollama).\n}\n\n/**\n * Built-in default USD-per-1,000,000-token rates for the Groq models with\n * a published price, used as the last fallback in `model()`'s pricing\n * resolution. A per-model or SDK-level `pricing` entry always wins over\n * these. Returns `undefined` for any unlisted id so cost stays an honest\n * absence rather than a false zero.\n */\nfunction defaultPricingFor(name: string): ModelPricing | undefined {\n  return GROQ_DEFAULT_PRICING[name];\n}\n\n/**\n * Default per-million-token USD rates for Groq models.\n *\n * Source: https://console.groq.com/docs/models (groq.com/pricing now\n * redirects to the home page), fetched 2026-10-17. Cached input is 50%\n * of the input rate for the gpt-oss models, the only ones Groq caches\n * (https://console.groq.com/docs/prompt-caching; no write charge). The\n * Llama models are listed as \"Enterprise – Contact Sales\" with no public\n * price, so they stay unpriced — pass `pricing` for them.\n */\nexport const GROQ_DEFAULT_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"openai/gpt-oss-120b\": { input: 0.15, output: 0.6, cachedInput: 0.075 },\n  \"openai/gpt-oss-20b\": { input: 0.075, output: 0.3, cachedInput: 0.0375 },\n  \"openai/gpt-oss-safeguard-20b\": { input: 0.075, output: 0.3, cachedInput: 0.0375 },\n  \"qwen/qwen3.8-27b\": { input: 0.8, output: 4 },\n};\n"],"mappings":";;;;;;;;;;;;;AASA,MAAa,gBAAgB;;;;;;;AAQ7B,MAAa,gBAAgB;;;;;;;;;;;;;;;;;;;;;;AAuB7B,MAAM,4BAA4B;CAChC;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;AAgBA,MAAM,+BAA+B;CACnC;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,SAAgB,sBAAsB,SAA0B;CAC9D,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF;;;;;;;;;;;;AAaA,SAAgB,yBAAyB,SAA0B;CACjE,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;;;;;;AAgBA,MAAa,oBAAoB;CAC/B;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClEA,IAAa,UAAb,MAAmD;CAWjD,AAAO,YAAY,QAAuB;EACxC,MAAM,EAAE,SAAS,UAAU,SAAS,GAAG,kBAAkB;EAEzD,KAAK,WAAW;EAChB,KAAK,UAAU;EAQf,KAAK,SAAS,IAAIA,gCAAU;GAC1B,GAAG;GACH,SAAS;GACT,UAAU,KAAK;GACf;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;CAmBA,AAAO,MAAM,QAAwC;EACnD,MAAM,kBACJ,OAAO,WAAW,KAAK,UAAU,OAAO,SAAS,kBAAkB,OAAO,IAAI;EAEhF,OAAO,KAAK,OAAO,MAAM;GACvB,GAAG;GAIH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;GACnE,kBAAkB,OAAO,oBAAoB;GAC7C,SAAS;EACX,CAAC;CACH;;;;;;;CAQA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAA8C;EAC5D,OAAO,KAAK,OAAO,SAAS,MAAM;CACpC;AAOF;;;;;;;;AASA,SAAS,kBAAkB,MAAwC;CACjE,OAAO,qBAAqB;AAC9B;;;;;;;;;;;AAYA,MAAa,uBAA+D;CAC1E,uBAAuB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACtE,sBAAsB;EAAE,OAAO;EAAO,QAAQ;EAAK,aAAa;CAAO;CACvE,gCAAgC;EAAE,OAAO;EAAO,QAAQ;EAAK,aAAa;CAAO;CACjF,oBAAoB;EAAE,OAAO;EAAK,QAAQ;CAAE;AAC9C"}

package/esm/config.type.d.mts

@@ -1,6 +1,5 @@
 import { OpenAISDKConfig } from "@warlock.js/ai-openai";
 import { EmbedderConfig, ModelConfig, ModelPricing } from "@warlock.js/ai";
-
 //#region ../../packages/ai-groq/src/config.type.d.ts
 /**
  * Configuration for the Groq SDK adapter.
@@ -37,7 +36,7 @@ import { EmbedderConfig, ModelConfig, ModelPricing } from "@warlock.js/ai";
  *   pricing: { "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 } },
  * });
  */
-type GroqSDKConfig = Omit<OpenAISDKConfig, "baseURL" | "provider"> & {
+export type GroqSDKConfig = Omit<OpenAISDKConfig, "baseURL" | "provider"> & {
   /**
    * Override Groq's OpenAI-compatible endpoint. Defaults to
    * `https://api.groq.com/openai/v1` when omitted — set this only to
@@ -75,7 +74,7 @@ type GroqSDKConfig = Omit<OpenAISDKConfig, "baseURL" | "provider"> & {
  * groq.model({ name: "openai/gpt-oss-120b" });               // vision + reasoning auto-true
  * groq.model({ name: "custom-llama", vision: true });        // explicit override
  */
-type GroqModelConfig = ModelConfig & {
+export type GroqModelConfig = ModelConfig & {
   /**
    * Override the auto-inferred vision capability. When omitted, the
    * adapter checks the model id against Groq's known multimodal families
@@ -116,7 +115,6 @@ type GroqModelConfig = ModelConfig & {
  * // Will construct, but Groq currently has no embeddings model to call.
  * groq.embedder({ name: "some-future-embeddings-model" });
  */
-type GroqEmbedderConfig = EmbedderConfig;
+export type GroqEmbedderConfig = EmbedderConfig;
 //#endregion
-export { GroqEmbedderConfig, GroqModelConfig, GroqSDKConfig };
 //# sourceMappingURL=config.type.d.mts.map

package/esm/config.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../../packages/ai-groq/src/config.type.ts"],"mappings":";;;;;;AAsCA;;;;;;;;;;;;;;;;;AAmBuC;AAoBvC;;;;;;;;;AAyBkB;AAiBlB;;;;AAA+C;KAjFnC,aAAA,GAAgB,IAAA,CAAK,eAAA;;;;;;EAM/B,OAAA;;;;;;EAMA,QAAA;;;;;;;EAOA,OAAA,GAAU,MAAA,SAAe,YAAA;AAAA;;;;;;;;;;;;;;;;;;KAoBf,eAAA,GAAkB,WAAW;;;;;;;;EAQvC,MAAA;;;;;;;;;EASA,SAAA;;;;;;;;EAQA,gBAAA;AAAA;;;;;;;;;;;;;;;KAiBU,kBAAA,GAAqB,cAAc"}
+{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../../packages/ai-groq/src/config.type.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsCY,gBAAgB,KAAK;;;;;;EAM/B;;;;;;EAMA;;;;;;;EAOA,UAAU,eAAe;;;;;;;;;;;;;;;;;;;YAoBf,kBAAkB;;;;;;;;EAQ5B;;;;;;;;;EASA;;;;;;;;EAQA;;;;;;;;;;;;;;;;YAiBU,qBAAqB"}

package/esm/index.d.mts

@@ -1,4 +1,4 @@
 import { GroqEmbedderConfig, GroqModelConfig, GroqSDKConfig } from "./config.type.mjs";
-import { GroqSDK } from "./sdk.mjs";
+import { GROQ_DEFAULT_PRICING, GroqSDK } from "./sdk.mjs";
 import { GROQ_BASE_URL, GROQ_KNOWN_MODELS, GROQ_PROVIDER, inferReasoningCapability, inferVisionCapability } from "./known-models.mjs";
-export { GROQ_BASE_URL, GROQ_KNOWN_MODELS, GROQ_PROVIDER, type GroqEmbedderConfig, type GroqModelConfig, GroqSDK, type GroqSDKConfig, inferReasoningCapability, inferVisionCapability };
+export { GROQ_BASE_URL, GROQ_DEFAULT_PRICING, GROQ_KNOWN_MODELS, GROQ_PROVIDER, type GroqEmbedderConfig, type GroqModelConfig, GroqSDK, type GroqSDKConfig, inferReasoningCapability, inferVisionCapability };

package/esm/index.mjs

@@ -1,4 +1,4 @@
 import { GROQ_BASE_URL, GROQ_KNOWN_MODELS, GROQ_PROVIDER, inferReasoningCapability, inferVisionCapability } from "./known-models.mjs";
-import { GroqSDK } from "./sdk.mjs";
+import { GROQ_DEFAULT_PRICING, GroqSDK } from "./sdk.mjs";
 
-export { GROQ_BASE_URL, GROQ_KNOWN_MODELS, GROQ_PROVIDER, GroqSDK, inferReasoningCapability, inferVisionCapability };
+export { GROQ_BASE_URL, GROQ_DEFAULT_PRICING, GROQ_KNOWN_MODELS, GROQ_PROVIDER, GroqSDK, inferReasoningCapability, inferVisionCapability };

package/esm/known-models.d.mts

@@ -8,14 +8,14 @@
  * Verified against Groq's "OpenAI Compatibility" docs (mid-2026).
  * Override via `new GroqSDK({ baseURL })` if Groq ever relocates it.
  */
-declare const GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+export declare const GROQ_BASE_URL = "https://api.groq.com/openai/v1";
 /**
  * The provider label every model produced by `GroqSDK` self-identifies
  * with. Flows through to `ModelContract.provider`, `AgentReport.model`,
  * logs, and any provider-aware middleware. Kept as a constant so the
  * wrapper and the inner `OpenAISDK` agree on one spelling.
  */
-declare const GROQ_PROVIDER = "groq";
+export declare const GROQ_PROVIDER = "groq";
 /**
  * Infer whether a Groq-hosted model id supports vision based on the
  * known multimodal-family substrings. Unknown ids default to `false`
@@ -29,7 +29,7 @@ declare const GROQ_PROVIDER = "groq";
  * inferVisionCapability("llama-3.3-70b-versatile");    // → false
  * inferVisionCapability("llama-3.1-8b-instant");       // → false
  */
-declare function inferVisionCapability(modelId: string): boolean;
+export declare function inferVisionCapability(modelId: string): boolean;
 /**
  * Infer whether a Groq-hosted model id is a reasoning model based on
  * the known reasoning-family substrings. Unknown ids default to `false`
@@ -41,7 +41,7 @@ declare function inferVisionCapability(modelId: string): boolean;
  * inferReasoningCapability("deepseek-r1-distill-llama-70b"); // → true
  * inferReasoningCapability("llama-3.3-70b-versatile");      // → false
  */
-declare function inferReasoningCapability(modelId: string): boolean;
+export declare function inferReasoningCapability(modelId: string): boolean;
 /**
  * Curated list of current Groq production chat model ids (mid-2026),
  * for autocomplete, docs, and default selection. NOT exhaustive and NOT
@@ -56,7 +56,6 @@ declare function inferReasoningCapability(modelId: string): boolean;
  *   family; vision + reasoning capable.
  * - `deepseek-r1-distill-llama-70b` — DeepSeek-R1-style reasoning.
  */
-declare const GROQ_KNOWN_MODELS: readonly ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "openai/gpt-oss-120b", "openai/gpt-oss-20b", "deepseek-r1-distill-llama-70b"];
+export declare const GROQ_KNOWN_MODELS: readonly ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "openai/gpt-oss-120b", "openai/gpt-oss-20b", "deepseek-r1-distill-llama-70b"];
 //#endregion
-export { GROQ_BASE_URL, GROQ_KNOWN_MODELS, GROQ_PROVIDER, inferReasoningCapability, inferVisionCapability };
 //# sourceMappingURL=known-models.d.mts.map

package/esm/known-models.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"known-models.d.mts","names":[],"sources":["../../../../../../../packages/ai-groq/src/known-models.ts"],"mappings":";;AASA;;;;AAA0B;AAQ1B;;;cARa,aAAA;AAQa;AAkE1B;;;;AAAqD;AAlE3B,cAAb,aAAA;;;;AAmF2C;AAoBxD;;;;AAMU;;;;;iBA3CM,qBAAA,CAAsB,OAAe;;;;;;;;;;;;iBAiBrC,wBAAA,CAAyB,OAAe;;;;;;;;;;;;;;;cAoB3C,iBAAA"}
+{"version":3,"file":"known-models.d.mts","names":[],"sources":["../../../../../../../packages/ai-groq/src/known-models.ts"],"mappings":";;;;;;;;;;qBASa;;;;;;;qBAQA;;;;;;;;;;;;;;wBAkEG,sBAAsB;;;;;;;;;;;;wBAiBtB,yBAAyB;;;;;;;;;;;;;;;qBAoB5B"}

package/esm/sdk.d.mts

@@ -1,6 +1,5 @@
 import { GroqEmbedderConfig, GroqModelConfig, GroqSDKConfig } from "./config.type.mjs";
-import { EmbedderContract, ModelContract, SDKAdapterContract } from "@warlock.js/ai";
-
+import { EmbedderContract, ModelContract, ModelPricing, SDKAdapterContract } from "@warlock.js/ai";
 //#region ../../packages/ai-groq/src/sdk.d.ts
 /**
  * Groq-backed implementation of `SDKAdapterContract`.
@@ -47,7 +46,7 @@ import { EmbedderContract, ModelContract, SDKAdapterContract } from "@warlock.js
  * const ai = { agent, tool, systemPrompt, groq: new GroqSDK({ apiKey }) };
  * const myAgent = ai.agent({ model: ai.groq.model({ name: "llama-3.1-8b-instant" }) });
  */
-declare class GroqSDK implements SDKAdapterContract {
+export declare class GroqSDK implements SDKAdapterContract {
   /**
    * The wrapped OpenAI-compatible adapter, pre-pointed at Groq's
    * `baseURL` and labeled with the `"groq"` provider. All real wire work
@@ -95,6 +94,16 @@ declare class GroqSDK implements SDKAdapterContract {
    */
   embedder(config: GroqEmbedderConfig): EmbedderContract;
 }
+/**
+ * Default per-million-token USD rates for Groq models.
+ *
+ * Source: https://console.groq.com/docs/models (groq.com/pricing now
+ * redirects to the home page), fetched 2026-10-17. Cached input is 50%
+ * of the input rate for the gpt-oss models, the only ones Groq caches
+ * (https://console.groq.com/docs/prompt-caching; no write charge). The
+ * Llama models are listed as "Enterprise – Contact Sales" with no public
+ * price, so they stay unpriced — pass `pricing` for them.
+ */
+export declare const GROQ_DEFAULT_PRICING: Readonly<Record<string, ModelPricing>>;
 //#endregion
-export { GroqSDK };
 //# sourceMappingURL=sdk.d.mts.map

package/esm/sdk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../../../packages/ai-groq/src/sdk.ts"],"mappings":";;;;;;AAgEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoF+D;;;;;;;;;;;cApFlD,OAAA,YAAmB,kBAAA;;;;;;;mBAOb,MAAA;EAAA,iBACA,QAAA;EAAA,iBACA,OAAA;cAEE,MAAA,EAAQ,aAAA;;;;;;;;;;;;;;;;;;EAqCpB,KAAA,CAAM,MAAA,EAAQ,eAAA,GAAkB,aAAA;;;;;;;EAsB1B,KAAA,CAAM,IAAA,UAAc,KAAA,YAAiB,OAAA;;;;;;;;;;;EAc3C,QAAA,CAAS,MAAA,EAAQ,kBAAA,GAAqB,gBAAA;AAAA"}
+{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../../../packages/ai-groq/src/sdk.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4Da,mBAAmB;;;;;;;mBAOb;mBACA;mBACA;EAEjB,YAAmB,QAAQ;;;;;;;;;;;;;;;;;;EAqCpB,MAAM,QAAQ,kBAAkB;;;;;;;EAsB1B,MAAM,cAAc,iBAAiB;;;;;;;;;;;EAc3C,SAAS,QAAQ,qBAAqB;;;;;;;;;;;;qBAgClC,sBAAsB,SAAS,eAAe"}

package/esm/sdk.mjs

@@ -110,45 +110,47 @@ var GroqSDK = class {
 	}
 };
 /**
-* Built-in default USD-per-1,000,000-token rates for the current Groq
-* production models (mid-2026), used as the last fallback in `model()`'s
-* pricing resolution. A per-model or SDK-level `pricing` entry always
-* wins over these. Returns `undefined` for any unlisted id so cost stays
-* an honest absence rather than a false zero. Update when Groq revises
-* its public price list.
+* Built-in default USD-per-1,000,000-token rates for the Groq models with
+* a published price, used as the last fallback in `model()`'s pricing
+* resolution. A per-model or SDK-level `pricing` entry always wins over
+* these. Returns `undefined` for any unlisted id so cost stays an honest
+* absence rather than a false zero.
 */
 function defaultPricingFor(name) {
 	return GROQ_DEFAULT_PRICING[name];
 }
 /**
-* Default per-million-token USD rates for known Groq models. Kept inline
-* (not exported) so the public surface stays the inference helpers; a
-* caller who wants different numbers supplies `pricing` on the SDK or
-* per model.
+* Default per-million-token USD rates for Groq models.
+*
+* Source: https://console.groq.com/docs/models (groq.com/pricing now
+* redirects to the home page), fetched 2026-10-17. Cached input is 50%
+* of the input rate for the gpt-oss models, the only ones Groq caches
+* (https://console.groq.com/docs/prompt-caching; no write charge). The
+* Llama models are listed as "Enterprise – Contact Sales" with no public
+* price, so they stay unpriced — pass `pricing` for them.
 */
 const GROQ_DEFAULT_PRICING = {
-	"llama-3.3-70b-versatile": {
-		input: .59,
-		output: .79
-	},
-	"llama-3.1-8b-instant": {
-		input: .05,
-		output: .08
-	},
 	"openai/gpt-oss-120b": {
 		input: .15,
-		output: .75
+		output: .6,
+		cachedInput: .075
 	},
 	"openai/gpt-oss-20b": {
-		input: .1,
-		output: .5
+		input: .075,
+		output: .3,
+		cachedInput: .0375
+	},
+	"openai/gpt-oss-safeguard-20b": {
+		input: .075,
+		output: .3,
+		cachedInput: .0375
 	},
-	"deepseek-r1-distill-llama-70b": {
-		input: .75,
-		output: .99
+	"qwen/qwen3.8-27b": {
+		input: .8,
+		output: 4
 	}
 };
 
 //#endregion
-export { GroqSDK };
+export { GROQ_DEFAULT_PRICING, GroqSDK };
 //# sourceMappingURL=sdk.mjs.map

package/esm/sdk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../../../packages/ai-groq/src/sdk.ts"],"sourcesContent":["import type {\n  EmbedderContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type {\n  GroqEmbedderConfig,\n  GroqModelConfig,\n  GroqSDKConfig,\n} from \"./config.type\";\nimport {\n  GROQ_BASE_URL,\n  GROQ_PROVIDER,\n  inferReasoningCapability,\n  inferVisionCapability,\n} from \"./known-models\";\n\n/**\n * Groq-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for Groq-hosted open models\n * (`llama-3.3-70b-versatile`, `llama-3.1-8b-instant`,\n * `openai/gpt-oss-*`, `deepseek-r1-distill-*`, …) served on Groq's fast\n * LPU hardware. Because Groq exposes the OpenAI Chat Completions wire\n * protocol verbatim, `GroqSDK` is a **thin wrapper over the already\n * battle-tested {@link OpenAISDK}** rather than a fresh transport\n * implementation — it owns one internal `OpenAISDK` pointed at Groq's\n * `baseURL` with the `\"groq\"` provider label, and delegates `model()` /\n * `embedder()` / `count()` to it.\n *\n * **Why a wrapper and not `OpenAISDK` directly?** Groq hosts *open*\n * models whose ids are the upstream open-weight names (`llama-…`,\n * `openai/gpt-oss-…`), not OpenAI's (`gpt-4o`, `o3`). The OpenAI\n * adapter's capability inference keys on OpenAI prefixes and would never\n * fire here, so every Groq model would come back with `vision`/\n * `reasoning` silently `false`. `GroqSDK` fixes that by computing\n * **this provider's own** vision/reasoning inference (see\n * `known-models.ts`) and injecting the result as explicit capability\n * config — which wins over the inner adapter's inference — plus a set of\n * default per-model pricing rates. Everything else (transport, retries,\n * streaming, structured output, error wrapping, usage accounting) is\n * inherited unchanged from `OpenAISDK`.\n *\n * **Responsibility.**\n * - Owns: one long-lived internal `OpenAISDK` (auth + Groq base URL) and\n *   this provider's capability + default-pricing inference.\n * - Does NOT own: the wire protocol, streaming loop, structured-output\n *   mapping, or error wrapping — all inherited from `OpenAISDK`.\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"), fronted by FP usage like the other adapters.\n *\n * @example\n * const groq = new GroqSDK({ apiKey: process.env.GROQ_API_KEY! });\n * const model = groq.model({ name: \"llama-3.3-70b-versatile\", temperature: 0.7 });\n * const reasoner = groq.model({ name: \"openai/gpt-oss-120b\" }); // vision + reasoning auto-true\n *\n * @example\n * // Compose into an `ai.groq` namespace for ergonomic agent wiring\n * const ai = { agent, tool, systemPrompt, groq: new GroqSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.groq.model({ name: \"llama-3.1-8b-instant\" }) });\n */\nexport class GroqSDK implements SDKAdapterContract {\n  /**\n   * The wrapped OpenAI-compatible adapter, pre-pointed at Groq's\n   * `baseURL` and labeled with the `\"groq\"` provider. All real wire work\n   * happens here; `GroqSDK` only enriches the per-model config before\n   * delegating.\n   */\n  private readonly openai: OpenAISDK;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: GroqSDKConfig) {\n    const { baseURL, provider, pricing, ...clientOptions } = config;\n\n    this.provider = provider ?? GROQ_PROVIDER;\n    this.pricing = pricing;\n\n    // Build the inner OpenAI-compatible client pointed at Groq. Forward\n    // every other upstream ClientOptions (timeout, maxRetries,\n    // defaultHeaders, fetch, …) verbatim — they type-check, so dropping\n    // them would be a silent footgun. We pass `pricing` through too so\n    // the inner registry stays a fallback, while THIS class's `model()`\n    // layers Groq default rates on top.\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? GROQ_BASE_URL,\n      provider: this.provider,\n      pricing,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` bound to the internal Groq-pointed client.\n   *\n   * The wrapper's whole job lives here: it computes **Groq's** vision /\n   * reasoning inference from the model id and forwards the result as\n   * *explicit* `vision` / `reasoning` config to the inner\n   * `OpenAISDK.model()`. Because explicit capability config wins over the\n   * inner adapter's OpenAI-prefix inference, the returned model reports\n   * the right capabilities even though the id isn't an OpenAI name. A\n   * caller-supplied `vision` / `reasoning` still wins over this\n   * inference (we only fill the gap when the field is omitted).\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise this\n   * SDK's `pricing` registry keyed by `config.name`; otherwise the\n   * adapter's built-in default rate for the model; otherwise `undefined`\n   * (no cost computed).\n   */\n  public model(config: GroqModelConfig): ModelContract {\n    const resolvedPricing =\n      config.pricing ?? this.pricing?.[config.name] ?? defaultPricingFor(config.name);\n\n    return this.openai.model({\n      ...config,\n      // Fill capability inference only when the caller didn't pin it —\n      // explicit caller config always wins, then Groq inference, then\n      // (inside OpenAISDK) the harmless OpenAI inference that won't match.\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      structuredOutput: config.structuredOutput ?? true,\n      pricing: resolvedPricing,\n    });\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegated straight to the inner\n   * `OpenAISDK`, which uses the core character-heuristic\n   * (`approximateTokenCount`). Good for budgeting / quota guards, not for\n   * billing.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an embedder bound to the internal client. Delegated to the\n   * inner `OpenAISDK`.\n   *\n   * IMPORTANT: as of mid-2026 Groq does **not** expose an\n   * OpenAI-compatible embeddings endpoint, so a live `.embed()` /\n   * `.embedMany()` call will fail at the provider. The method is kept for\n   * adapter symmetry; use `@warlock.js/ai-openai` or\n   * `@warlock.js/ai-google` for retrieval embeddings.\n   */\n  public embedder(config: GroqEmbedderConfig): EmbedderContract {\n    return this.openai.embedder(config);\n  }\n\n  // NOTE: `image()` is intentionally NOT implemented. Groq hosts no\n  // image-generation API, and `SDKAdapterContract.image` is optional —\n  // its structural absence IS the capability guard, so\n  // `ai.groq.image(...)` is a compile-time error rather than a runtime\n  // surprise (mirrors Anthropic / Bedrock / Ollama).\n}\n\n/**\n * Built-in default USD-per-1,000,000-token rates for the current Groq\n * production models (mid-2026), used as the last fallback in `model()`'s\n * pricing resolution. A per-model or SDK-level `pricing` entry always\n * wins over these. Returns `undefined` for any unlisted id so cost stays\n * an honest absence rather than a false zero. Update when Groq revises\n * its public price list.\n */\nfunction defaultPricingFor(name: string): ModelPricing | undefined {\n  return GROQ_DEFAULT_PRICING[name];\n}\n\n/**\n * Default per-million-token USD rates for known Groq models. Kept inline\n * (not exported) so the public surface stays the inference helpers; a\n * caller who wants different numbers supplies `pricing` on the SDK or\n * per model.\n */\nconst GROQ_DEFAULT_PRICING: Record<string, ModelPricing> = {\n  \"llama-3.3-70b-versatile\": { input: 0.59, output: 0.79 },\n  \"llama-3.1-8b-instant\": { input: 0.05, output: 0.08 },\n  \"openai/gpt-oss-120b\": { input: 0.15, output: 0.75 },\n  \"openai/gpt-oss-20b\": { input: 0.1, output: 0.5 },\n  \"deepseek-r1-distill-llama-70b\": { input: 0.75, output: 0.99 },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,IAAa,UAAb,MAAmD;CAWjD,AAAO,YAAY,QAAuB;EACxC,MAAM,EAAE,SAAS,UAAU,SAAS,GAAG,kBAAkB;EAEzD,KAAK,WAAW;EAChB,KAAK,UAAU;EAQf,KAAK,SAAS,IAAI,UAAU;GAC1B,GAAG;GACH,SAAS;GACT,UAAU,KAAK;GACf;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;CAmBA,AAAO,MAAM,QAAwC;EACnD,MAAM,kBACJ,OAAO,WAAW,KAAK,UAAU,OAAO,SAAS,kBAAkB,OAAO,IAAI;EAEhF,OAAO,KAAK,OAAO,MAAM;GACvB,GAAG;GAIH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;GACnE,kBAAkB,OAAO,oBAAoB;GAC7C,SAAS;EACX,CAAC;CACH;;;;;;;CAQA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAA8C;EAC5D,OAAO,KAAK,OAAO,SAAS,MAAM;CACpC;AAOF;;;;;;;;;AAUA,SAAS,kBAAkB,MAAwC;CACjE,OAAO,qBAAqB;AAC9B;;;;;;;AAQA,MAAM,uBAAqD;CACzD,2BAA2B;EAAE,OAAO;EAAM,QAAQ;CAAK;CACvD,wBAAwB;EAAE,OAAO;EAAM,QAAQ;CAAK;CACpD,uBAAuB;EAAE,OAAO;EAAM,QAAQ;CAAK;CACnD,sBAAsB;EAAE,OAAO;EAAK,QAAQ;CAAI;CAChD,iCAAiC;EAAE,OAAO;EAAM,QAAQ;CAAK;AAC/D"}
+{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../../../packages/ai-groq/src/sdk.ts"],"sourcesContent":["import type {\n  EmbedderContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type { GroqEmbedderConfig, GroqModelConfig, GroqSDKConfig } from \"./config.type\";\nimport {\n  GROQ_BASE_URL,\n  GROQ_PROVIDER,\n  inferReasoningCapability,\n  inferVisionCapability,\n} from \"./known-models\";\n\n/**\n * Groq-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for Groq-hosted open models\n * (`llama-3.3-70b-versatile`, `llama-3.1-8b-instant`,\n * `openai/gpt-oss-*`, `deepseek-r1-distill-*`, …) served on Groq's fast\n * LPU hardware. Because Groq exposes the OpenAI Chat Completions wire\n * protocol verbatim, `GroqSDK` is a **thin wrapper over the already\n * battle-tested {@link OpenAISDK}** rather than a fresh transport\n * implementation — it owns one internal `OpenAISDK` pointed at Groq's\n * `baseURL` with the `\"groq\"` provider label, and delegates `model()` /\n * `embedder()` / `count()` to it.\n *\n * **Why a wrapper and not `OpenAISDK` directly?** Groq hosts *open*\n * models whose ids are the upstream open-weight names (`llama-…`,\n * `openai/gpt-oss-…`), not OpenAI's (`gpt-4o`, `o3`). The OpenAI\n * adapter's capability inference keys on OpenAI prefixes and would never\n * fire here, so every Groq model would come back with `vision`/\n * `reasoning` silently `false`. `GroqSDK` fixes that by computing\n * **this provider's own** vision/reasoning inference (see\n * `known-models.ts`) and injecting the result as explicit capability\n * config — which wins over the inner adapter's inference — plus a set of\n * default per-model pricing rates. Everything else (transport, retries,\n * streaming, structured output, error wrapping, usage accounting) is\n * inherited unchanged from `OpenAISDK`.\n *\n * **Responsibility.**\n * - Owns: one long-lived internal `OpenAISDK` (auth + Groq base URL) and\n *   this provider's capability + default-pricing inference.\n * - Does NOT own: the wire protocol, streaming loop, structured-output\n *   mapping, or error wrapping — all inherited from `OpenAISDK`.\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"), fronted by FP usage like the other adapters.\n *\n * @example\n * const groq = new GroqSDK({ apiKey: process.env.GROQ_API_KEY! });\n * const model = groq.model({ name: \"llama-3.3-70b-versatile\", temperature: 0.7 });\n * const reasoner = groq.model({ name: \"openai/gpt-oss-120b\" }); // vision + reasoning auto-true\n *\n * @example\n * // Compose into an `ai.groq` namespace for ergonomic agent wiring\n * const ai = { agent, tool, systemPrompt, groq: new GroqSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.groq.model({ name: \"llama-3.1-8b-instant\" }) });\n */\nexport class GroqSDK implements SDKAdapterContract {\n  /**\n   * The wrapped OpenAI-compatible adapter, pre-pointed at Groq's\n   * `baseURL` and labeled with the `\"groq\"` provider. All real wire work\n   * happens here; `GroqSDK` only enriches the per-model config before\n   * delegating.\n   */\n  private readonly openai: OpenAISDK;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: GroqSDKConfig) {\n    const { baseURL, provider, pricing, ...clientOptions } = config;\n\n    this.provider = provider ?? GROQ_PROVIDER;\n    this.pricing = pricing;\n\n    // Build the inner OpenAI-compatible client pointed at Groq. Forward\n    // every other upstream ClientOptions (timeout, maxRetries,\n    // defaultHeaders, fetch, …) verbatim — they type-check, so dropping\n    // them would be a silent footgun. We pass `pricing` through too so\n    // the inner registry stays a fallback, while THIS class's `model()`\n    // layers Groq default rates on top.\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? GROQ_BASE_URL,\n      provider: this.provider,\n      pricing,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` bound to the internal Groq-pointed client.\n   *\n   * The wrapper's whole job lives here: it computes **Groq's** vision /\n   * reasoning inference from the model id and forwards the result as\n   * *explicit* `vision` / `reasoning` config to the inner\n   * `OpenAISDK.model()`. Because explicit capability config wins over the\n   * inner adapter's OpenAI-prefix inference, the returned model reports\n   * the right capabilities even though the id isn't an OpenAI name. A\n   * caller-supplied `vision` / `reasoning` still wins over this\n   * inference (we only fill the gap when the field is omitted).\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise this\n   * SDK's `pricing` registry keyed by `config.name`; otherwise the\n   * adapter's built-in default rate for the model; otherwise `undefined`\n   * (no cost computed).\n   */\n  public model(config: GroqModelConfig): ModelContract {\n    const resolvedPricing =\n      config.pricing ?? this.pricing?.[config.name] ?? defaultPricingFor(config.name);\n\n    return this.openai.model({\n      ...config,\n      // Fill capability inference only when the caller didn't pin it —\n      // explicit caller config always wins, then Groq inference, then\n      // (inside OpenAISDK) the harmless OpenAI inference that won't match.\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      structuredOutput: config.structuredOutput ?? true,\n      pricing: resolvedPricing,\n    });\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegated straight to the inner\n   * `OpenAISDK`, which uses the core character-heuristic\n   * (`approximateTokenCount`). Good for budgeting / quota guards, not for\n   * billing.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an embedder bound to the internal client. Delegated to the\n   * inner `OpenAISDK`.\n   *\n   * IMPORTANT: as of mid-2026 Groq does **not** expose an\n   * OpenAI-compatible embeddings endpoint, so a live `.embed()` /\n   * `.embedMany()` call will fail at the provider. The method is kept for\n   * adapter symmetry; use `@warlock.js/ai-openai` or\n   * `@warlock.js/ai-google` for retrieval embeddings.\n   */\n  public embedder(config: GroqEmbedderConfig): EmbedderContract {\n    return this.openai.embedder(config);\n  }\n\n  // NOTE: `image()` is intentionally NOT implemented. Groq hosts no\n  // image-generation API, and `SDKAdapterContract.image` is optional —\n  // its structural absence IS the capability guard, so\n  // `ai.groq.image(...)` is a compile-time error rather than a runtime\n  // surprise (mirrors Anthropic / Bedrock / Ollama).\n}\n\n/**\n * Built-in default USD-per-1,000,000-token rates for the Groq models with\n * a published price, used as the last fallback in `model()`'s pricing\n * resolution. A per-model or SDK-level `pricing` entry always wins over\n * these. Returns `undefined` for any unlisted id so cost stays an honest\n * absence rather than a false zero.\n */\nfunction defaultPricingFor(name: string): ModelPricing | undefined {\n  return GROQ_DEFAULT_PRICING[name];\n}\n\n/**\n * Default per-million-token USD rates for Groq models.\n *\n * Source: https://console.groq.com/docs/models (groq.com/pricing now\n * redirects to the home page), fetched 2026-10-17. Cached input is 50%\n * of the input rate for the gpt-oss models, the only ones Groq caches\n * (https://console.groq.com/docs/prompt-caching; no write charge). The\n * Llama models are listed as \"Enterprise – Contact Sales\" with no public\n * price, so they stay unpriced — pass `pricing` for them.\n */\nexport const GROQ_DEFAULT_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"openai/gpt-oss-120b\": { input: 0.15, output: 0.6, cachedInput: 0.075 },\n  \"openai/gpt-oss-20b\": { input: 0.075, output: 0.3, cachedInput: 0.0375 },\n  \"openai/gpt-oss-safeguard-20b\": { input: 0.075, output: 0.3, cachedInput: 0.0375 },\n  \"qwen/qwen3.8-27b\": { input: 0.8, output: 4 },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,IAAa,UAAb,MAAmD;CAWjD,AAAO,YAAY,QAAuB;EACxC,MAAM,EAAE,SAAS,UAAU,SAAS,GAAG,kBAAkB;EAEzD,KAAK,WAAW;EAChB,KAAK,UAAU;EAQf,KAAK,SAAS,IAAI,UAAU;GAC1B,GAAG;GACH,SAAS;GACT,UAAU,KAAK;GACf;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;CAmBA,AAAO,MAAM,QAAwC;EACnD,MAAM,kBACJ,OAAO,WAAW,KAAK,UAAU,OAAO,SAAS,kBAAkB,OAAO,IAAI;EAEhF,OAAO,KAAK,OAAO,MAAM;GACvB,GAAG;GAIH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;GACnE,kBAAkB,OAAO,oBAAoB;GAC7C,SAAS;EACX,CAAC;CACH;;;;;;;CAQA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAA8C;EAC5D,OAAO,KAAK,OAAO,SAAS,MAAM;CACpC;AAOF;;;;;;;;AASA,SAAS,kBAAkB,MAAwC;CACjE,OAAO,qBAAqB;AAC9B;;;;;;;;;;;AAYA,MAAa,uBAA+D;CAC1E,uBAAuB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACtE,sBAAsB;EAAE,OAAO;EAAO,QAAQ;EAAK,aAAa;CAAO;CACvE,gCAAgC;EAAE,OAAO;EAAO,QAAQ;EAAK,aAAa;CAAO;CACjF,oBAAoB;EAAE,OAAO;EAAK,QAAQ;CAAE;AAC9C"}

package/llms-full.txt

@@ -8,7 +8,7 @@
 
 ---
 name: setup-groq
-description: 'Wire @warlock.js/ai-groq — new GroqSDK({apiKey, baseURL?, provider?, pricing?}) for Groq-hosted open models on LPU hardware (llama-3.3-70b-versatile, llama-3.1-8b-instant, openai/gpt-oss-120b/20b, deepseek-r1-distill-llama-70b). Thin wrapper over @warlock.js/ai-openai — uses the OpenAI-compatible endpoint https://api.groq.com/openai/v1, delegating transport/streaming/structured-output/errors to OpenAISDK while injecting Groqs OWN vision/reasoning inference + default pricing. .model({name, vision?, reasoning?, structuredOutput?}) for ModelContract. Triggers: `GroqSDK`, `groq.model`, `groq.count`, `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`, `gpt-oss`, `deepseek-r1-distill`, `groq vision`, `groq reasoning`, `reasoning_effort`, `https://api.groq.com/openai/v1`, OpenAI-compatible Groq, LPU, fast inference; "wire groq into a warlock agent", "use llama 3.3 on groq", "run gpt-oss / deepseek reasoning on groq", "point warlock at the groq endpoint"; import `import { GroqSDK } from "@warlock.js/ai-groq"`. Skip: agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; the wrapped adapter `@warlock.js/ai-openai` (`setup-openai`); embeddings (Groq has none — use openai/google); siblings `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `groq-sdk` / `openai` SDK.'
+description: 'Wire @warlock.js/ai-groq — new GroqSDK({apiKey, baseURL?, provider?, pricing?}) for Groq-hosted open models on LPU hardware (llama-3.3-70b-versatile, llama-3.1-8b-instant, openai/gpt-oss-120b/20b, deepseek-r1-distill-llama-70b). Thin wrapper over @warlock.js/ai-openai — uses the OpenAI-compatible endpoint https://api.groq.com/openai/v1, delegating transport/streaming/structured-output/errors to OpenAISDK while injecting Groqs OWN vision/reasoning inference + default pricing. .model({name, vision?, reasoning?, structuredOutput?}) for ModelContract. Triggers: `GroqSDK`, `GROQ_DEFAULT_PRICING`, `groq.model`, `groq.count`, `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`, `gpt-oss`, `deepseek-r1-distill`, `groq vision`, `groq reasoning`, `reasoning_effort`, `https://api.groq.com/openai/v1`, OpenAI-compatible Groq, LPU, fast inference; "wire groq into a warlock agent", "use llama 3.3 on groq", "run gpt-oss / deepseek reasoning on groq", "point warlock at the groq endpoint"; import `import { GroqSDK } from "@warlock.js/ai-groq"`. Skip: agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; the wrapped adapter `@warlock.js/ai-openai` (`setup-openai`); embeddings (Groq has none — use openai/google); siblings `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `groq-sdk` / `openai` SDK.'
 ---
 
 # `@warlock.js/ai-groq`
@@ -31,10 +31,10 @@ const groq = new GroqSDK({ apiKey: process.env.GROQ_API_KEY! });
 ## Producing a model
 
 ```ts
-groq.model({ name: "llama-3.3-70b-versatile" })          // flagship general-purpose text
-groq.model({ name: "llama-3.1-8b-instant" })             // fastest / cheapest small text
-groq.model({ name: "openai/gpt-oss-120b" })              // vision + reasoning auto-true
-groq.model({ name: "deepseek-r1-distill-llama-70b" })    // reasoning auto-true
+groq.model({ name: "llama-3.3-70b-versatile" }); // flagship general-purpose text
+groq.model({ name: "llama-3.1-8b-instant" }); // fastest / cheapest small text
+groq.model({ name: "openai/gpt-oss-120b" }); // vision + reasoning auto-true
+groq.model({ name: "deepseek-r1-distill-llama-70b" }); // reasoning auto-true
 ```
 
 Returns a `ModelContract` you pass straight into `ai.agent({ model })`. `name` is the Groq-hosted **open-weight** id (the upstream name, e.g. `openai/gpt-oss-120b`), NOT an OpenAI id. Any current Groq model id works — the list above is curated, not an allow-list.
@@ -43,18 +43,18 @@ Returns a `ModelContract` you pass straight into `ai.agent({ model })`. `name` i
 
 The whole reason this wrapper exists: Groq's ids aren't OpenAI's, so the OpenAI adapter's prefix inference would never fire. `GroqSDK` carries its **own** name lists.
 
-| Flag | Default |
-| --- | --- |
-| `vision` | Inferred from the Groq model id. `true` for `gpt-oss`, `llama-4`, `llama-3.2-*-vision`; `false` otherwise (e.g. `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`). |
-| `reasoning` | Inferred from the Groq model id. `true` for `gpt-oss`, `deepseek-r1` / `deepseek-r1-distill`, `qwq`, `qwen3`; `false` otherwise. Drives whether `reasoning_effort` is forwarded. |
-| `structuredOutput` | `true` — Groq accepts OpenAI-style `response_format`. |
-| `promptCaching` | Inherited from the inner OpenAI adapter (`true`; read-side `cachedTokens` accounting). |
+| Flag               | Default                                                                                                                                                                          |
+| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `vision`           | Inferred from the Groq model id. `true` for `gpt-oss`, `llama-4`, `llama-3.2-*-vision`; `false` otherwise (e.g. `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`).              |
+| `reasoning`        | Inferred from the Groq model id. `true` for `gpt-oss`, `deepseek-r1` / `deepseek-r1-distill`, `qwq`, `qwen3`; `false` otherwise. Drives whether `reasoning_effort` is forwarded. |
+| `structuredOutput` | `true` — Groq accepts OpenAI-style `response_format`.                                                                                                                            |
+| `promptCaching`    | Inherited from the inner OpenAI adapter (`true`; read-side `cachedTokens` accounting).                                                                                           |
 
 **Override `vision`, `reasoning`, or `structuredOutput` explicitly** via `.model({ name, vision?, reasoning?, structuredOutput? })` — an explicit value always wins over inference.
 
 ```ts
-groq.model({ name: "some-custom-llama", vision: true })  // force on for an unlisted multimodal id
-groq.model({ name: "openai/gpt-oss-120b", reasoning: false }) // pin off
+groq.model({ name: "some-custom-llama", vision: true }); // force on for an unlisted multimodal id
+groq.model({ name: "openai/gpt-oss-120b", reasoning: false }); // pin off
 ```
 
 ## Reasoning (gpt-oss / deepseek-r1 distill)
@@ -63,7 +63,7 @@ Reasoning models accept a discrete effort knob, forwarded by the inner adapter a
 
 ```ts
 const model = groq.model({ name: "deepseek-r1-distill-llama-70b" }); // reasoning auto-true
-await model.complete(messages, { reasoning: { effort: "high" } });   // → reasoning_effort: "high"
+await model.complete(messages, { reasoning: { effort: "high" } }); // → reasoning_effort: "high"
 ```
 
 - `reasoning.effort` (`"low" | "medium" | "high"`) maps verbatim.
@@ -82,30 +82,44 @@ There is also no image-generation API on Groq, so `GroqSDK` intentionally does *
 
 ## Pricing — per-model registry + built-in defaults
 
-`pricing` is a registry keyed by model name, rates in **USD per 1,000,000 tokens** (`ModelPricing`: `input`, `output`, optional `cachedInput` / `cachedOutput`). The adapter ships **built-in default rates** for the known Groq models as the final fallback.
+`pricing` is a registry keyed by model name, rates in **USD per 1,000,000 tokens** (`ModelPricing`: `input`, `output`, optional `cachedInput`). The adapter ships **built-in default rates** (`GROQ_DEFAULT_PRICING`) as the final fallback.
 
 ```ts
+import { totalCost } from "@warlock.js/ai";
+import { GROQ_DEFAULT_PRICING, GroqSDK } from "@warlock.js/ai-groq";
+
 const groq = new GroqSDK({
-  apiKey,
+  apiKey: process.env.GROQ_API_KEY ?? "",
   pricing: {
-    "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 }, // USD per 1M tokens
+    // No public price for Llama on Groq — use your contract rate.
+    "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 },
   },
 });
+
+GROQ_DEFAULT_PRICING["openai/gpt-oss-120b"]; // { input: 0.15, output: 0.6, cachedInput: 0.075 }
+
+const { usage } = await groq
+  .model({ name: "openai/gpt-oss-120b" })
+  .complete([{ role: "user", content: "hi" }]);
+console.log(totalCost(usage.cost));
 ```
 
-Resolution at `model()` time: per-model `pricing` (`groq.model({ name, pricing })`) > SDK `pricing[name]` > adapter built-in default for the id > `undefined` (no cost computed). Built-in defaults exist for `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`, `openai/gpt-oss-120b`, `openai/gpt-oss-20b`, and `deepseek-r1-distill-llama-70b`; supply your own for anything else.
+Resolution at `model()` time: per-model `pricing` (`groq.model({ name, pricing })`) > SDK `pricing[name]` > `GROQ_DEFAULT_PRICING` > `undefined` (no cost computed).
+
+- **Source.** https://console.groq.com/docs/models (groq.com/pricing now redirects to the home page), fetched 2026-10-17: `openai/gpt-oss-120b`, `openai/gpt-oss-20b`, `openai/gpt-oss-safeguard-20b`, `qwen/qwen3.8-27b`. Cached input is 50% of the input rate for the gpt-oss models, the only ones Groq caches — automatically, with no write charge and no request hint (https://console.groq.com/docs/prompt-caching).
+- **Unpriced:** the Llama models (listed as "Enterprise – Contact Sales", no public price) and anything else not listed — supply your own rate.
 
 ## Token counting
 
 ```ts
-await groq.count("some text")  // approximate heuristic (delegated), not a real tokenizer
+await groq.count("some text"); // approximate heuristic (delegated), not a real tokenizer
 ```
 
 Good for budgeting; not for billing.
 
 ## Errors
 
-Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by the inner OpenAI adapter's error wrapper (dispatch keys on `status + code`). See the `handle-ai-errors` topic of the `warlock-js-ai` skill. Note Groq's documented OpenAI-compat gaps — `n` must be `1`, and `logprobs` / `logit_bias` / `top_logprobs` / `messages[].name` are unsupported.
+Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by the inner OpenAI adapter's error wrapper (dispatch keys on `status + code`). See the `handle-ai-errors` topic of the `warlock-js-ai` skill. HTTP 503 maps to `ProviderOverloadedError` (`code: "PROVIDER_OVERLOADED"`, `retryable: true`); every wrapped error carries `status`, `retryable` and `billed` (`false` for 401 / 402 / 403, otherwise `"unknown"`). Note Groq's documented OpenAI-compat gaps — `n` must be `1`, and `logprobs` / `logit_bias` / `top_logprobs` / `messages[].name` are unsupported.
 
 ## When NOT to use this skill
 
@@ -119,4 +133,18 @@ Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by th
 - The `run-ai-agent` topic of the `warlock-js-ai` skill — passing the model into `ai.agent({...})`
 - The `pick-ai-provider` topic of the `warlock-js-ai` skill — adapter comparison
 
+## Provider body options and token estimates
+
+This adapter delegates Chat Completions to the OpenAI adapter, so
+`providerOptions.openai.body` adds native Chat request fields. Other provider
+keys are ignored. Plain-object fields merge one level deep with neutral options;
+caller-provided keys win, while arrays, scalars and `null` replace the field.
+The OpenAI adapter's protected conversation, tool and transport fields remain
+protected here too. Send only fields supported by this provider; do not reuse
+OpenAI-only bodies across a mixed-provider fallback chain.
+
+Models from this adapter have no native `countTokens` method. Check
+`model.countTokens` before using an optional native counting capability;
+`sdk.count(text)` is a separate offline estimate.
+
 

package/llms.txt

@@ -6,4 +6,4 @@
 
 ## Skills
 
-- [setup-groq](@warlock.js/ai-groq/setup-groq/SKILL.md): Wire @warlock.js/ai-groq — new GroqSDK({apiKey, baseURL?, provider?, pricing?}) for Groq-hosted open models on LPU hardware (llama-3.3-70b-versatile, llama-3.1-8b-instant, openai/gpt-oss-120b/20b, deepseek-r1-distill-llama-70b). Thin wrapper over @warlock.js/ai-openai — uses the OpenAI-compatible endpoint https://api.groq.com/openai/v1, delegating transport/streaming/structured-output/errors to OpenAISDK while injecting Groqs OWN vision/reasoning inference + default pricing. .model({name, vision?, reasoning?, structuredOutput?}) for ModelContract. Triggers: `GroqSDK`, `groq.model`, `groq.count`, `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`, `gpt-oss`, `deepseek-r1-distill`, `groq vision`, `groq reasoning`, `reasoning_effort`, `https://api.groq.com/openai/v1`, OpenAI-compatible Groq, LPU, fast inference; "wire groq into a warlock agent", "use llama 3.3 on groq", "run gpt-oss / deepseek reasoning on groq", "point warlock at the groq endpoint"; import `import { GroqSDK } from "@warlock.js/ai-groq"`. Skip: agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; the wrapped adapter `@warlock.js/ai-openai` (`setup-openai`); embeddings (Groq has none — use openai/google); siblings `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `groq-sdk` / `openai` SDK.
+- [setup-groq](@warlock.js/ai-groq/setup-groq/SKILL.md): Wire @warlock.js/ai-groq — new GroqSDK({apiKey, baseURL?, provider?, pricing?}) for Groq-hosted open models on LPU hardware (llama-3.3-70b-versatile, llama-3.1-8b-instant, openai/gpt-oss-120b/20b, deepseek-r1-distill-llama-70b). Thin wrapper over @warlock.js/ai-openai — uses the OpenAI-compatible endpoint https://api.groq.com/openai/v1, delegating transport/streaming/structured-output/errors to OpenAISDK while injecting Groqs OWN vision/reasoning inference + default pricing. .model({name, vision?, reasoning?, structuredOutput?}) for ModelContract. Triggers: `GroqSDK`, `GROQ_DEFAULT_PRICING`, `groq.model`, `groq.count`, `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`, `gpt-oss`, `deepseek-r1-distill`, `groq vision`, `groq reasoning`, `reasoning_effort`, `https://api.groq.com/openai/v1`, OpenAI-compatible Groq, LPU, fast inference; "wire groq into a warlock agent", "use llama 3.3 on groq", "run gpt-oss / deepseek reasoning on groq", "point warlock at the groq endpoint"; import `import { GroqSDK } from "@warlock.js/ai-groq"`. Skip: agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; the wrapped adapter `@warlock.js/ai-openai` (`setup-openai`); embeddings (Groq has none — use openai/google); siblings `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `groq-sdk` / `openai` SDK.

package/package.json

@@ -16,13 +16,13 @@
     "directory": "packages/ai-groq"
   },
   "peerDependencies": {
-    "@warlock.js/ai": "5.30.0"
+    "@warlock.js/ai": "5.32.0"
   },
   "dependencies": {
-    "@warlock.js/ai-openai": "5.30.0",
-    "@warlock.js/logger": "5.30.0"
+    "@warlock.js/ai-openai": "5.32.0",
+    "@warlock.js/logger": "5.32.0"
   },
-  "version": "5.30.0",
+  "version": "5.32.0",
   "main": "./cjs/index.cjs",
   "module": "./esm/index.mjs",
   "types": "./esm/index.d.mts",

package/skills/setup-groq/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: setup-groq
-description: 'Wire @warlock.js/ai-groq — new GroqSDK({apiKey, baseURL?, provider?, pricing?}) for Groq-hosted open models on LPU hardware (llama-3.3-70b-versatile, llama-3.1-8b-instant, openai/gpt-oss-120b/20b, deepseek-r1-distill-llama-70b). Thin wrapper over @warlock.js/ai-openai — uses the OpenAI-compatible endpoint https://api.groq.com/openai/v1, delegating transport/streaming/structured-output/errors to OpenAISDK while injecting Groqs OWN vision/reasoning inference + default pricing. .model({name, vision?, reasoning?, structuredOutput?}) for ModelContract. Triggers: `GroqSDK`, `groq.model`, `groq.count`, `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`, `gpt-oss`, `deepseek-r1-distill`, `groq vision`, `groq reasoning`, `reasoning_effort`, `https://api.groq.com/openai/v1`, OpenAI-compatible Groq, LPU, fast inference; "wire groq into a warlock agent", "use llama 3.3 on groq", "run gpt-oss / deepseek reasoning on groq", "point warlock at the groq endpoint"; import `import { GroqSDK } from "@warlock.js/ai-groq"`. Skip: agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; the wrapped adapter `@warlock.js/ai-openai` (`setup-openai`); embeddings (Groq has none — use openai/google); siblings `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `groq-sdk` / `openai` SDK.'
+description: 'Wire @warlock.js/ai-groq — new GroqSDK({apiKey, baseURL?, provider?, pricing?}) for Groq-hosted open models on LPU hardware (llama-3.3-70b-versatile, llama-3.1-8b-instant, openai/gpt-oss-120b/20b, deepseek-r1-distill-llama-70b). Thin wrapper over @warlock.js/ai-openai — uses the OpenAI-compatible endpoint https://api.groq.com/openai/v1, delegating transport/streaming/structured-output/errors to OpenAISDK while injecting Groqs OWN vision/reasoning inference + default pricing. .model({name, vision?, reasoning?, structuredOutput?}) for ModelContract. Triggers: `GroqSDK`, `GROQ_DEFAULT_PRICING`, `groq.model`, `groq.count`, `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`, `gpt-oss`, `deepseek-r1-distill`, `groq vision`, `groq reasoning`, `reasoning_effort`, `https://api.groq.com/openai/v1`, OpenAI-compatible Groq, LPU, fast inference; "wire groq into a warlock agent", "use llama 3.3 on groq", "run gpt-oss / deepseek reasoning on groq", "point warlock at the groq endpoint"; import `import { GroqSDK } from "@warlock.js/ai-groq"`. Skip: agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; the wrapped adapter `@warlock.js/ai-openai` (`setup-openai`); embeddings (Groq has none — use openai/google); siblings `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `groq-sdk` / `openai` SDK.'
 ---
 
 # `@warlock.js/ai-groq`
@@ -23,10 +23,10 @@ const groq = new GroqSDK({ apiKey: process.env.GROQ_API_KEY! });
 ## Producing a model
 
 ```ts
-groq.model({ name: "llama-3.3-70b-versatile" })          // flagship general-purpose text
-groq.model({ name: "llama-3.1-8b-instant" })             // fastest / cheapest small text
-groq.model({ name: "openai/gpt-oss-120b" })              // vision + reasoning auto-true
-groq.model({ name: "deepseek-r1-distill-llama-70b" })    // reasoning auto-true
+groq.model({ name: "llama-3.3-70b-versatile" }); // flagship general-purpose text
+groq.model({ name: "llama-3.1-8b-instant" }); // fastest / cheapest small text
+groq.model({ name: "openai/gpt-oss-120b" }); // vision + reasoning auto-true
+groq.model({ name: "deepseek-r1-distill-llama-70b" }); // reasoning auto-true
 ```
 
 Returns a `ModelContract` you pass straight into `ai.agent({ model })`. `name` is the Groq-hosted **open-weight** id (the upstream name, e.g. `openai/gpt-oss-120b`), NOT an OpenAI id. Any current Groq model id works — the list above is curated, not an allow-list.
@@ -35,18 +35,18 @@ Returns a `ModelContract` you pass straight into `ai.agent({ model })`. `name` i
 
 The whole reason this wrapper exists: Groq's ids aren't OpenAI's, so the OpenAI adapter's prefix inference would never fire. `GroqSDK` carries its **own** name lists.
 
-| Flag | Default |
-| --- | --- |
-| `vision` | Inferred from the Groq model id. `true` for `gpt-oss`, `llama-4`, `llama-3.2-*-vision`; `false` otherwise (e.g. `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`). |
-| `reasoning` | Inferred from the Groq model id. `true` for `gpt-oss`, `deepseek-r1` / `deepseek-r1-distill`, `qwq`, `qwen3`; `false` otherwise. Drives whether `reasoning_effort` is forwarded. |
-| `structuredOutput` | `true` — Groq accepts OpenAI-style `response_format`. |
-| `promptCaching` | Inherited from the inner OpenAI adapter (`true`; read-side `cachedTokens` accounting). |
+| Flag               | Default                                                                                                                                                                          |
+| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `vision`           | Inferred from the Groq model id. `true` for `gpt-oss`, `llama-4`, `llama-3.2-*-vision`; `false` otherwise (e.g. `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`).              |
+| `reasoning`        | Inferred from the Groq model id. `true` for `gpt-oss`, `deepseek-r1` / `deepseek-r1-distill`, `qwq`, `qwen3`; `false` otherwise. Drives whether `reasoning_effort` is forwarded. |
+| `structuredOutput` | `true` — Groq accepts OpenAI-style `response_format`.                                                                                                                            |
+| `promptCaching`    | Inherited from the inner OpenAI adapter (`true`; read-side `cachedTokens` accounting).                                                                                           |
 
 **Override `vision`, `reasoning`, or `structuredOutput` explicitly** via `.model({ name, vision?, reasoning?, structuredOutput? })` — an explicit value always wins over inference.
 
 ```ts
-groq.model({ name: "some-custom-llama", vision: true })  // force on for an unlisted multimodal id
-groq.model({ name: "openai/gpt-oss-120b", reasoning: false }) // pin off
+groq.model({ name: "some-custom-llama", vision: true }); // force on for an unlisted multimodal id
+groq.model({ name: "openai/gpt-oss-120b", reasoning: false }); // pin off
 ```
 
 ## Reasoning (gpt-oss / deepseek-r1 distill)
@@ -55,7 +55,7 @@ Reasoning models accept a discrete effort knob, forwarded by the inner adapter a
 
 ```ts
 const model = groq.model({ name: "deepseek-r1-distill-llama-70b" }); // reasoning auto-true
-await model.complete(messages, { reasoning: { effort: "high" } });   // → reasoning_effort: "high"
+await model.complete(messages, { reasoning: { effort: "high" } }); // → reasoning_effort: "high"
 ```
 
 - `reasoning.effort` (`"low" | "medium" | "high"`) maps verbatim.
@@ -74,30 +74,44 @@ There is also no image-generation API on Groq, so `GroqSDK` intentionally does *
 
 ## Pricing — per-model registry + built-in defaults
 
-`pricing` is a registry keyed by model name, rates in **USD per 1,000,000 tokens** (`ModelPricing`: `input`, `output`, optional `cachedInput` / `cachedOutput`). The adapter ships **built-in default rates** for the known Groq models as the final fallback.
+`pricing` is a registry keyed by model name, rates in **USD per 1,000,000 tokens** (`ModelPricing`: `input`, `output`, optional `cachedInput`). The adapter ships **built-in default rates** (`GROQ_DEFAULT_PRICING`) as the final fallback.
 
 ```ts
+import { totalCost } from "@warlock.js/ai";
+import { GROQ_DEFAULT_PRICING, GroqSDK } from "@warlock.js/ai-groq";
+
 const groq = new GroqSDK({
-  apiKey,
+  apiKey: process.env.GROQ_API_KEY ?? "",
   pricing: {
-    "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 }, // USD per 1M tokens
+    // No public price for Llama on Groq — use your contract rate.
+    "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 },
   },
 });
+
+GROQ_DEFAULT_PRICING["openai/gpt-oss-120b"]; // { input: 0.15, output: 0.6, cachedInput: 0.075 }
+
+const { usage } = await groq
+  .model({ name: "openai/gpt-oss-120b" })
+  .complete([{ role: "user", content: "hi" }]);
+console.log(totalCost(usage.cost));
 ```
 
-Resolution at `model()` time: per-model `pricing` (`groq.model({ name, pricing })`) > SDK `pricing[name]` > adapter built-in default for the id > `undefined` (no cost computed). Built-in defaults exist for `llama-3.3-70b-versatile`, `llama-3.1-8b-instant`, `openai/gpt-oss-120b`, `openai/gpt-oss-20b`, and `deepseek-r1-distill-llama-70b`; supply your own for anything else.
+Resolution at `model()` time: per-model `pricing` (`groq.model({ name, pricing })`) > SDK `pricing[name]` > `GROQ_DEFAULT_PRICING` > `undefined` (no cost computed).
+
+- **Source.** https://console.groq.com/docs/models (groq.com/pricing now redirects to the home page), fetched 2026-10-17: `openai/gpt-oss-120b`, `openai/gpt-oss-20b`, `openai/gpt-oss-safeguard-20b`, `qwen/qwen3.8-27b`. Cached input is 50% of the input rate for the gpt-oss models, the only ones Groq caches — automatically, with no write charge and no request hint (https://console.groq.com/docs/prompt-caching).
+- **Unpriced:** the Llama models (listed as "Enterprise – Contact Sales", no public price) and anything else not listed — supply your own rate.
 
 ## Token counting
 
 ```ts
-await groq.count("some text")  // approximate heuristic (delegated), not a real tokenizer
+await groq.count("some text"); // approximate heuristic (delegated), not a real tokenizer
 ```
 
 Good for budgeting; not for billing.
 
 ## Errors
 
-Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by the inner OpenAI adapter's error wrapper (dispatch keys on `status + code`). See the `handle-ai-errors` topic of the `warlock-js-ai` skill. Note Groq's documented OpenAI-compat gaps — `n` must be `1`, and `logprobs` / `logit_bias` / `top_logprobs` / `messages[].name` are unsupported.
+Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by the inner OpenAI adapter's error wrapper (dispatch keys on `status + code`). See the `handle-ai-errors` topic of the `warlock-js-ai` skill. HTTP 503 maps to `ProviderOverloadedError` (`code: "PROVIDER_OVERLOADED"`, `retryable: true`); every wrapped error carries `status`, `retryable` and `billed` (`false` for 401 / 402 / 403, otherwise `"unknown"`). Note Groq's documented OpenAI-compat gaps — `n` must be `1`, and `logprobs` / `logit_bias` / `top_logprobs` / `messages[].name` are unsupported.
 
 ## When NOT to use this skill
 
@@ -110,3 +124,17 @@ Raw errors are wrapped into the typed `@warlock.js/ai` `AIError` hierarchy by th
 - The `setup-openai` topic of the `warlock-js-ai-openai` skill — the wrapped adapter; full wire / streaming / structured-output detail
 - The `run-ai-agent` topic of the `warlock-js-ai` skill — passing the model into `ai.agent({...})`
 - The `pick-ai-provider` topic of the `warlock-js-ai` skill — adapter comparison
+
+## Provider body options and token estimates
+
+This adapter delegates Chat Completions to the OpenAI adapter, so
+`providerOptions.openai.body` adds native Chat request fields. Other provider
+keys are ignored. Plain-object fields merge one level deep with neutral options;
+caller-provided keys win, while arrays, scalars and `null` replace the field.
+The OpenAI adapter's protected conversation, tool and transport fields remain
+protected here too. Send only fields supported by this provider; do not reuse
+OpenAI-only bodies across a mixed-provider fallback chain.
+
+Models from this adapter have no native `countTokens` method. Check
+`model.countTokens` before using an optional native counting capability;
+`sdk.count(text)` is a separate offline estimate.