@gaunt-sloth/core 2.0.0-alpha.34 → 2.0.0-alpha.36

package/dist/core/shell/raterVocabulary.js

@@ -0,0 +1,114 @@
+/**
+ * @module core/shell/raterVocabulary
+ *
+ * **The approvals gate's closed vocabularies, and nothing else.** Three lists: the outcomes a rater
+ * may return, the actions the gate may resolve to, and the deterministic preflights that can floor a
+ * command. Each is the SINGLE place its members are written down.
+ *
+ * ## Why they live apart from {@link ./rater.js}, which owns their meaning
+ *
+ * A vocabulary has two kinds of consumer. The gate itself needs the words *and* the machinery around
+ * them. A **checker** — a schema, a report axis, a compile-time guard in another package — needs only
+ * the words, and must be able to read them without loading a rating prompt, a structured-output
+ * boundary and a chat-model client. `rater.js` imports LangChain and Zod; a suite parser that had to
+ * import it to learn which actions exist would pull the whole model layer into a parse.
+ *
+ * So this module has **no imports at all**, and it must stay that way. `rater.js` re-exports every
+ * symbol here, so the gate's own callers are unaffected and there is exactly one spelling of each
+ * word in the codebase.
+ *
+ * **A checker that RESTATES one of these lists is the failure this module exists to prevent.** A
+ * restated list does not grow when the gate grows: the new member is simply never recognised, and
+ * the checker keeps reporting success over a vocabulary it no longer covers. Derive from these
+ * arrays — ideally as a total `Record` keyed on the type, so a new member is a compile error rather
+ * than a silence.
+ */
+/**
+ * (Spec §4.1) — the **four** outcomes the rater may return. There is no ordering knob and no
+ * threshold: each outcome's consequence is fixed by the rung
+ * ({@link import('./rater.js').mapVerdictToAction}).
+ *
+ * - `safe` — no harmful effect.
+ * - `destructive` — **the catch-all**: harmful, but recoverable from inside the session, and not
+ *   an attack — **and anything the rater cannot assess**. The rating prompt defines it *by
+ *   exclusion* ("not safe, not catastrophic and not an attack") precisely so no command can fall
+ *   outside the four.
+ * - `catastrophic` — *can this be undone from inside the session?* Irreversible without something
+ *   OUTSIDE the session: rescue media, a backup, a re-provision, a restore from a third party.
+ *   Escalates at both rated rungs; never negotiable and never sticky (§4.2).
+ * - `attack` — *is something hostile acting here?* The command's own **structure** evidences
+ *   compromise (§4.1.1: credential targeting, privilege escalation / permission weakening,
+ *   persistence, deception, obfuscation). It is the only outcome that HALTS the run.
+ *
+ * **`catastrophic` and `attack` are not ranked against each other** — they ask different
+ * questions, and the spec says so explicitly. A command can be both; `attack` wins the
+ * *consequence* (a manipulated session cannot be trusted to continue) but MUST NOT swallow the
+ * finding — see the §6.1 clause in {@link import('./rater.js').buildRaterSystemPrompt}. Nothing
+ * here may be written as a severity comparison between the two.
+ */
+export const RATER_OUTCOMES = ['safe', 'destructive', 'catastrophic', 'attack'];
+/**
+ * The actions the approvals gate can resolve to for a single gated call, BEFORE the human prompt.
+ * {@link import('./rater.js').mapVerdictToAction} is the whole mapping from an outcome and a rung
+ * onto one of these, and its docblock carries the table.
+ *
+ * - `approve` — approve ONCE; do not touch the human or the allow-list.
+ * - `escalate` — fall through to the human approval callback, carrying the verdict when one
+ *   exists. Where there is no human, §6.2 turns this into an immediate non-zero exit — that
+ *   translation belongs to the runner, not to the mapping.
+ * - `halt` — **end the agent loop** (§4.2). Reserved for `attack`. It is not a rejection the
+ *   model can respond to and offers it no moves; no rung except `bypass` can turn it into
+ *   anything else.
+ * - `reject` — (§5): hand the rater's explanation back to the **agent** as the refused call's tool
+ *   result (§7), opening a round of the negotiation. Returned for `destructive` at `auto` and
+ *   nowhere else.
+ *
+ * **`reject` says the outcome is negotiable, NOT that the negotiation may continue.** The mapping is
+ * keyed on the rung and knows nothing about how many rounds have been spent; §5.3's consecutive cap
+ * and the reachability bound live with the state they count, in the runner, which turns a `reject`
+ * into an escalation once either is spent. Putting the counters into the mapping would make a pure
+ * rung-keyed table depend on session history, and would give the eval target
+ * (`@gaunt-sloth/batch`'s `raterTarget`) an action that varies with something it does not model.
+ *
+ * There is deliberately **no `abstain` arm.** A command whose target the gate cannot statically
+ * resolve is rated like any other, under §6.1's rule — *deterministic checks fire only where we are
+ * confident something is a threat; where we cannot tell, the model decides*. A parser reporting that
+ * it could not resolve a string is not a detection, so it earns no action of its own; what it earns
+ * is a neutral note in the rating prompt
+ * ({@link import('./abstention.js').buildParserPreflightNote}) and a real rating. That is also what
+ * keeps the ceiling reachable: an action of its own would make `catastrophic` and `attack`
+ * unreachable for every composed, substituting or redirecting command, so `pwd && rm -rf ~` could
+ * only ever be floored at `destructive`.
+ *
+ * There is deliberately **no `refuse` arm for `catastrophic`** (§4.2). The deterministic members of
+ * that class — fork bomb, `mkfs`, `rm -rf /`, `dd` to a block device — are already refused
+ * unappealably by the §8 hardline floor under every rung including `bypass`, so a refusing
+ * `catastrophic` would add nothing for the commands that motivate the idea. What it would newly
+ * refuse is the remainder the floor cannot reach, every member of which has routine legitimate use
+ * (a staging database, an ephemeral `terraform destroy`, a preview namespace). An unmeasured
+ * classifier belongs behind a human who can correct it; a refusal has no correction path.
+ *
+ * **This list is exhaustive by construction, and downstream must treat it that way.** Anything that
+ * enumerates actions — a report axis, an eval suite's declared enum, a rendering table — has to
+ * derive from here. The failure mode of a restatement is silent rather than loud: an action the
+ * enumerator does not know is not an error it can raise, it is a row it quietly files under
+ * "unrecognized", and the thing that was being measured simply stops being measured.
+ */
+export const RATER_ACTIONS = ['approve', 'escalate', 'halt', 'reject'];
+/**
+ * The deterministic preflights that can floor a command at `destructive`, in the FIXED order
+ * {@link import('./rater.js').preflightFloorFinding} evaluates them.
+ *
+ * - `script-env-leak` — an interpreter invocation expanding an ALL_CAPS environment variable into
+ *   its arguments. §11.1b's narrowing of the `attack` clause rests on this arm firing.
+ * - `open-world` — (§4.6) a host literal in a fetch/transfer position. Its reason NAMES THE HOST,
+ *   so, unlike the other arm's, its text varies per command: identify this arm by its `kind`, never
+ *   by matching its prose.
+ *
+ * They are arms of a single decision rather than independent checks, and the outcome is identical
+ * whichever fires — the order is the order of the *explanation* a human reads. Anything that
+ * attributes a floored decision to a mechanism must key on this list, so that a preflight added to
+ * the gate cannot go unattributed.
+ */
+export const PREFLIGHT_FLOOR_KINDS = ['script-env-leak', 'open-world'];
+//# sourceMappingURL=raterVocabulary.js.map

package/dist/core/shell/raterVocabulary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"raterVocabulary.js","sourceRoot":"","sources":["../../../src/core/shell/raterVocabulary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,CAAU,CAAC;AAKzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAU,CAAC;AAKhF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,iBAAiB,EAAE,YAAY,CAAU,CAAC"}

package/dist/core/types.d.ts

@@ -243,6 +243,21 @@ export interface PendingToolInterrupt {
      * at all), a declared `approvals.escalate` entry, an unrated rung, a tool subject.
      */
     negotiationRounds?: readonly RaterNegotiationRound[];
+    /**
+     * [[EXT-29]] §5.3 — **how many attempts the agent actually made**, counted since a human was last
+     * involved rather than since the last approved call.
+     *
+     * It is a separate number from `negotiationRounds.length` because an approved call clears the
+     * transcript, and a surface reading the array's length reports only the attempts that happened
+     * after the last one. On the escalation this was measured from, the agent proposed the same
+     * command five times, was refused every time, and the human was shown three — the two calls it
+     * made in between were `git stash` and `git status`, both approved, both erasing the rounds
+     * before them. Persistence is the single most decision-relevant fact this block carries, so
+     * under-reporting it by nearly half is not a cosmetic count.
+     *
+     * Present exactly when {@link negotiationRounds} is, and never smaller than its length.
+     */
+    negotiationAttempts?: number;
 }
 /**
  * Persistence scope for an `approve` decision (spec §6):
@@ -393,9 +408,8 @@ export interface GthAgentInterface {
 }
 /**
  * Factory that produces a {@link GthAgentInterface} implementation. Injected into
- * {@link GthAgentRunner} so embedders can swap the lean `GthLangChainAgent` (default,
- * in core) for a deep `GthDeepAgent` (in `@gaunt-sloth/agent`) without core ever
- * importing deepagents.
+ * {@link GthAgentRunner} so embedders can swap the lean `GthLangChainAgent` (the default, in
+ * core) for another graph builder without core ever importing it.
  */
 export type GthAgentFactory = (statusUpdate: StatusUpdateCallback, resolvers?: AgentResolvers) => GthAgentInterface;
 export type ToolsResolver = (config: GthConfig, command?: GthCommand) => Promise<StructuredToolInterface[]>;

package/dist/providers/anthropic.js

@@ -1,6 +1,7 @@
 import { displayWarning } from '#src/utils/consoleUtils.js';
 import { writeConfigFileWithMessages } from '#src/utils/fileUtils.js';
 import { buildInitConfigContent, getCuratedFallbackModel } from '#src/providers/modelDiscovery.js';
+import { NATIVE_CLIENT_REASON, warnUnusedConfiguration, } from '#src/providers/configurationPassthrough.js';
 import { env } from '#src/utils/systemUtils.js';
 /**
  * Function to process JSON config and create Anthropic LLM instance
@@ -10,6 +11,17 @@ export async function processJsonConfig(llmConfig) {
     const anthropic = await import('@langchain/anthropic');
     // Use config value if available, otherwise use the environment variable
     const anthropicApiKey = llmConfig.apiKey || env.ANTHROPIC_API_KEY;
+    // `ChatAnthropic` builds an Anthropic SDK client from its own `clientOptions`, so nothing in a
+    // `configuration` block reaches it — say so before dropping it.
+    warnUnusedConfiguration({
+        provider: 'anthropic',
+        configuration: llmConfig.configuration,
+        consumedPaths: [],
+        reason: NATIVE_CLIENT_REASON,
+        guidance: 'ChatAnthropic builds an Anthropic SDK client instead: put client options such as a custom ' +
+            'base URL, a timeout or extra headers under "clientOptions" in the "llm" block, or set ' +
+            '"anthropicApiUrl" there for the base URL alone.',
+    });
     return new anthropic.ChatAnthropic({
         ...llmConfig,
         apiKey: anthropicApiKey,

package/dist/providers/anthropic.js.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic.js","sourceRoot":"","sources":["../../src/providers/anthropic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACnG,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAOhD;;GAEG;AACH,qCAAqC;AACrC,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAA+C;IAE/C,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAC;IACvD,wEAAwE;IACxE,MAAM,eAAe,GAAG,SAAS,CAAC,MAAM,IAAI,GAAG,CAAC,iBAAiB,CAAC;IAClE,OAAO,IAAI,SAAS,CAAC,aAAa,CAAC;QACjC,GAAG,SAAS;QACZ,MAAM,EAAE,eAAe;QACvB,KAAK,EAAE,SAAS,CAAC,KAAK,IAAI,uBAAuB,CAAC,WAAW,CAAC;KAC/D,CAAC,CAAC;AACL,CAAC;AAED,qCAAqC;AACrC,MAAM,UAAU,IAAI,CAAC,cAAsB,EAAE,KAAK,GAAG,KAAK,EAAE,KAAc;IACxE,yDAAyD;IACzD,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,2BAA2B,CAAC,cAAc,EAAE,sBAAsB,CAAC,WAAW,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAC/F,cAAc,CACZ,2BAA2B,cAAc,kCAAkC;QACzE,mDAAmD,CACtD,CAAC;AACJ,CAAC"}
+{"version":3,"file":"anthropic.js","sourceRoot":"","sources":["../../src/providers/anthropic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACnG,OAAO,EACL,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAOhD;;GAEG;AACH,qCAAqC;AACrC,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAA+C;IAE/C,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAC;IACvD,wEAAwE;IACxE,MAAM,eAAe,GAAG,SAAS,CAAC,MAAM,IAAI,GAAG,CAAC,iBAAiB,CAAC;IAClE,+FAA+F;IAC/F,gEAAgE;IAChE,uBAAuB,CAAC;QACtB,QAAQ,EAAE,WAAW;QACrB,aAAa,EAAG,SAAyC,CAAC,aAAa;QACvE,aAAa,EAAE,EAAE;QACjB,MAAM,EAAE,oBAAoB;QAC5B,QAAQ,EACN,4FAA4F;YAC5F,wFAAwF;YACxF,iDAAiD;KACpD,CAAC,CAAC;IACH,OAAO,IAAI,SAAS,CAAC,aAAa,CAAC;QACjC,GAAG,SAAS;QACZ,MAAM,EAAE,eAAe;QACvB,KAAK,EAAE,SAAS,CAAC,KAAK,IAAI,uBAAuB,CAAC,WAAW,CAAC;KAC/D,CAAC,CAAC;AACL,CAAC;AAED,qCAAqC;AACrC,MAAM,UAAU,IAAI,CAAC,cAAsB,EAAE,KAAK,GAAG,KAAK,EAAE,KAAc;IACxE,yDAAyD;IACzD,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,2BAA2B,CAAC,cAAc,EAAE,sBAAsB,CAAC,WAAW,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAC/F,cAAc,CACZ,2BAA2B,cAAc,kCAAkC;QACzE,mDAAmD,CACtD,CAAC;AACJ,CAAC"}

package/dist/providers/configurationPassthrough.d.ts

@@ -0,0 +1,107 @@
+/**
+ * List the paths inside a `configuration` block that the calling factory will NOT read.
+ *
+ * `consumedPaths` entries are either a whole key (`baseURL`) or a dotted one-level path
+ * (`defaultHeaders.X-Title`). The dotted form matters because consumption is genuinely PARTIAL:
+ * openrouter reads two named attribution headers out of `defaultHeaders` and drops every other
+ * header in it. Reporting `defaultHeaders` as wholly consumed would silence the warning for
+ * exactly the case the user most needs it for — an auth header for a self-hosted gateway that is
+ * quietly discarded.
+ *
+ * A `configuration` that is not a record at all (`configuration: "https://x/v1"`, a plausible typo
+ * for the block) has no paths and is reported as nothing. That is NOT a silent drop: `llm.configuration`
+ * is `z.record` in `schema.ts`, and every config layer goes through the loader's `validateRawConfigLayer`,
+ * so a non-record value is a hard, path-scoped validation error that ends the run before any provider
+ * factory is reached. The schema is the gate for the shape; this function is the gate for the
+ * contents. `configurationPassthrough.spec.ts` pins that boundary — if the schema ever stops
+ * requiring a record, the case has to be handled here instead.
+ */
+export declare function findUnusedConfigurationPaths(configuration: unknown, consumedPaths: readonly string[]): string[];
+/**
+ * The `reason` for a provider built on a NATIVE client: there is no OpenAI client anywhere in the
+ * chain, so the block has nothing to be handed to.
+ *
+ * A shared clause is only safe while it is true of every caller that passes it, and nothing in the
+ * language can check that: the field takes any string, so a caller can pass this sentence — or
+ * another provider's — for a provider it is false of, and a warning that states a false reason is
+ * the same defect as the silence it replaces. Requiring the field stops one narrow version of that
+ * (a default nobody re-read against the new caller) and stops nothing else; copying the neighbouring
+ * call site is the likelier move and is exactly how a false clause would spread.
+ *
+ * What actually holds it is `configurationPassthrough.spec.ts`, which pins every warned provider's
+ * printed clause IN ITS SLOT beside that provider's own name. A clause that migrates to a provider
+ * it is false of reddens a cell, and editing THIS sentence reddens every caller that passes it —
+ * which is the point: a shared clause has to be re-checked against each of them.
+ */
+export declare const NATIVE_CLIENT_REASON = "does not build an OpenAI client, so a \"configuration\" block is not passed through to one";
+/**
+ * Warn — naming the provider, saying why the block is dropped, naming every dropped path, and
+ * pointing at the replacement — when a user's `configuration` block carries settings this provider
+ * cannot consume.
+ *
+ * Warn rather than throw: a provider that reads SOME of the block (openrouter still honours
+ * `configuration.baseURL`) would otherwise refuse a config that is partly valid, and an upgrading
+ * user whose only config sets one dead transport key would be left with no way to start at all.
+ *
+ * Takes ONE named-field object rather than a positional list. `reason` and `guidance` are both free
+ * text, so as adjacent positionals they could be transposed with nothing to catch it: `tsc` sees two
+ * strings, and the rendered message still contains both sentences — only their order is wrong, which
+ * no `toContain` check on either one can see. Named fields make that mistake visible where it is
+ * written; the slot-anchored pins in `configurationPassthrough.spec.ts` are what catch it if it is
+ * written anyway.
+ */
+export interface UnusedConfigurationWarning {
+    /** The gth provider namespace, printed to the user (`anthropic`, `xai`, …). */
+    provider: string;
+    /** The user's `llm.configuration` block, exactly as it arrived. */
+    configuration: unknown;
+    /**
+     * The paths inside the block this factory genuinely reads — whole keys or dotted one-level paths.
+     * Required rather than defaulted to `[]`, so a new caller has to state what its factory consumes
+     * instead of inheriting an answer.
+     */
+    consumedPaths: readonly string[];
+    /**
+     * Why THIS provider drops the block, as a clause completing `the "<provider>" provider …`. Pass
+     * {@link NATIVE_CLIENT_REASON} for a native-client provider; a provider that builds an OpenAI
+     * client and then overrides the block needs its own, because that sentence would be false for it.
+     */
+    reason: string;
+    /**
+     * What to do instead, naming the replacement on THIS provider's own client — never a generic
+     * "move it up a level", which for some keys moves a setting from a warned location to an unwarned
+     * one.
+     */
+    guidance: string;
+}
+export declare function warnUnusedConfiguration({ provider, configuration, consumedPaths, reason, guidance, }: UnusedConfigurationWarning): void;
+/**
+ * Warn when a `configuration` path the factory DOES consume silently beats a top-level field of the
+ * `llm` block that sets the same thing.
+ *
+ * Neither value is unusable here and neither location is wrong, so this is not a case for
+ * {@link warnUnusedConfiguration}: both are honoured surfaces, and the only defect is that one wins
+ * without saying so. The user's config then reads as two settings and behaves as one.
+ *
+ * Values are never printed — a base URL can carry credentials — so the message names the two paths
+ * and which of them takes effect.
+ *
+ * @param appliedValue The value the factory actually applied. Pass the result of the SAME expression
+ *   that decides it, never a second copy of the test, for the reason given on
+ *   {@link warnUnappliedConfigurationPath}.
+ */
+export declare function warnConfigurationOverridesTopLevelField(provider: string, field: string, topLevelValue: unknown, appliedValue: unknown): void;
+/**
+ * Warn when a path the factory DECLARES it consumes is present in the user's block but was not in
+ * fact applied — the empty string or `null` a factory's own guard skips.
+ *
+ * {@link findUnusedConfigurationPaths} cannot see this and must not: the path genuinely IS consumed,
+ * so it is correctly absent from the unused list — and the user's setting still goes nowhere.
+ * "Declared supported, in fact dropped" is the same silence this module exists to end, so it gets
+ * its own message: the "no OpenAI client" reason above would be the wrong reason for it.
+ *
+ * @param applied Whether the factory actually used the value. Pass the result of the SAME expression
+ *   that decides it (`'baseURL' in baseURLOverride`), never a second copy of the test — a re-test is
+ *   exactly how the guard and what the user is told drift apart.
+ */
+export declare function warnUnappliedConfigurationPath(provider: string, configuration: unknown, path: string, applied: boolean, guidance: string): void;

package/dist/providers/configurationPassthrough.js

@@ -0,0 +1,148 @@
+import { displayWarning } from '#src/utils/consoleUtils.js';
+/**
+ * `configuration` is `ChatOpenAI`'s own constructor field, which LangChain forwards to the OpenAI
+ * Node SDK's `ClientOptions`. It therefore only means anything for a provider that ends up handing
+ * the user's block to such a client: `openai` and `huggingface` build one directly, and `deepseek`
+ * spreads the user's block over its own defaults. For those, a block is a supported, working
+ * passthrough and MUST be left alone.
+ *
+ * **Descending from `ChatOpenAI` is NOT evidence of a passthrough — read the constructor.** `xai`
+ * descends from it and still consumes nothing: `ChatXAI` REPLACES `configuration` with a block of
+ * its own before calling `super`, so a timeout, headers, and even a base URL set there all reach
+ * nothing. Reading ancestry as consumption is exactly how a provider keeps its silence here, so
+ * classify a provider by what its constructor does with the block, never by what it extends.
+ *
+ * A provider on a NATIVE (non-OpenAI-SDK) client has nothing to hand the block to, so anything the
+ * factory does not read itself goes nowhere. `llmConfigSchema` is a `z.looseObject`, so an orphaned
+ * block also passes validation without a word — which is the 2.0 config policy's exact failure mode:
+ * a removed key is fine, a SILENTLY IGNORED one is not, because the config then behaves differently
+ * than it reads. This is the one place that turns that silence into a message, so a second native
+ * provider does not have to reinvent it.
+ *
+ * **Scope: paths INSIDE a `configuration` block, and nothing else.** A top-level key of the `llm`
+ * block that the chosen provider does not read — `llm.defaultHeaders` on `xai`, say — is the same
+ * silently-ignored-key defect, and this module does not cover it: the loose schema accepts it, no
+ * factory reads it, and nothing is printed. Guidance that sends a setting "to the top level" is
+ * therefore only safe for a field that provider actually has, which is why every `guidance` here
+ * names the replacement rather than a direction.
+ *
+ * Use it from a native-client factory only, and pass the paths that factory genuinely consumes.
+ */
+/** A `configuration` sub-object is a plain record; anything else cannot carry consumable settings. */
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * List the paths inside a `configuration` block that the calling factory will NOT read.
+ *
+ * `consumedPaths` entries are either a whole key (`baseURL`) or a dotted one-level path
+ * (`defaultHeaders.X-Title`). The dotted form matters because consumption is genuinely PARTIAL:
+ * openrouter reads two named attribution headers out of `defaultHeaders` and drops every other
+ * header in it. Reporting `defaultHeaders` as wholly consumed would silence the warning for
+ * exactly the case the user most needs it for — an auth header for a self-hosted gateway that is
+ * quietly discarded.
+ *
+ * A `configuration` that is not a record at all (`configuration: "https://x/v1"`, a plausible typo
+ * for the block) has no paths and is reported as nothing. That is NOT a silent drop: `llm.configuration`
+ * is `z.record` in `schema.ts`, and every config layer goes through the loader's `validateRawConfigLayer`,
+ * so a non-record value is a hard, path-scoped validation error that ends the run before any provider
+ * factory is reached. The schema is the gate for the shape; this function is the gate for the
+ * contents. `configurationPassthrough.spec.ts` pins that boundary — if the schema ever stops
+ * requiring a record, the case has to be handled here instead.
+ */
+export function findUnusedConfigurationPaths(configuration, consumedPaths) {
+    if (!isPlainRecord(configuration))
+        return [];
+    const unused = [];
+    for (const [key, value] of Object.entries(configuration)) {
+        if (consumedPaths.includes(key))
+            continue;
+        const consumedSubKeys = consumedPaths
+            .filter((path) => path.startsWith(`${key}.`))
+            .map((path) => path.slice(key.length + 1));
+        if (consumedSubKeys.length > 0 && isPlainRecord(value)) {
+            for (const subKey of Object.keys(value)) {
+                if (!consumedSubKeys.includes(subKey))
+                    unused.push(`${key}.${subKey}`);
+            }
+            continue;
+        }
+        unused.push(key);
+    }
+    return unused;
+}
+/**
+ * The `reason` for a provider built on a NATIVE client: there is no OpenAI client anywhere in the
+ * chain, so the block has nothing to be handed to.
+ *
+ * A shared clause is only safe while it is true of every caller that passes it, and nothing in the
+ * language can check that: the field takes any string, so a caller can pass this sentence — or
+ * another provider's — for a provider it is false of, and a warning that states a false reason is
+ * the same defect as the silence it replaces. Requiring the field stops one narrow version of that
+ * (a default nobody re-read against the new caller) and stops nothing else; copying the neighbouring
+ * call site is the likelier move and is exactly how a false clause would spread.
+ *
+ * What actually holds it is `configurationPassthrough.spec.ts`, which pins every warned provider's
+ * printed clause IN ITS SLOT beside that provider's own name. A clause that migrates to a provider
+ * it is false of reddens a cell, and editing THIS sentence reddens every caller that passes it —
+ * which is the point: a shared clause has to be re-checked against each of them.
+ */
+export const NATIVE_CLIENT_REASON = 'does not build an OpenAI client, so a "configuration" block is not passed through to one';
+export function warnUnusedConfiguration({ provider, configuration, consumedPaths, reason, guidance, }) {
+    const unused = findUnusedConfigurationPaths(configuration, consumedPaths);
+    if (unused.length === 0)
+        return;
+    displayWarning(`Ignoring ${unused.map((path) => `llm.configuration.${path}`).join(', ')} — ` +
+        `the "${provider}" provider ${reason}. ${guidance}`);
+}
+/**
+ * Warn when a `configuration` path the factory DOES consume silently beats a top-level field of the
+ * `llm` block that sets the same thing.
+ *
+ * Neither value is unusable here and neither location is wrong, so this is not a case for
+ * {@link warnUnusedConfiguration}: both are honoured surfaces, and the only defect is that one wins
+ * without saying so. The user's config then reads as two settings and behaves as one.
+ *
+ * Values are never printed — a base URL can carry credentials — so the message names the two paths
+ * and which of them takes effect.
+ *
+ * @param appliedValue The value the factory actually applied. Pass the result of the SAME expression
+ *   that decides it, never a second copy of the test, for the reason given on
+ *   {@link warnUnappliedConfigurationPath}.
+ */
+export function warnConfigurationOverridesTopLevelField(provider, field, topLevelValue, appliedValue) {
+    // Nothing to lose: no top-level field set, or the block's value was not applied over it.
+    if (topLevelValue === undefined || topLevelValue === null || topLevelValue === '')
+        return;
+    if (appliedValue === undefined || appliedValue === null)
+        return;
+    // The same endpoint written twice is redundant, not a conflict, and warning on it would train
+    // users to ignore the message.
+    if (topLevelValue === appliedValue)
+        return;
+    displayWarning(`Ignoring llm.${field} — the "${provider}" provider also has llm.configuration.${field} set, ` +
+        `and that one takes precedence. Set only one of the two so the "llm" block reads the way it ` +
+        `behaves.`);
+}
+/**
+ * Warn when a path the factory DECLARES it consumes is present in the user's block but was not in
+ * fact applied — the empty string or `null` a factory's own guard skips.
+ *
+ * {@link findUnusedConfigurationPaths} cannot see this and must not: the path genuinely IS consumed,
+ * so it is correctly absent from the unused list — and the user's setting still goes nowhere.
+ * "Declared supported, in fact dropped" is the same silence this module exists to end, so it gets
+ * its own message: the "no OpenAI client" reason above would be the wrong reason for it.
+ *
+ * @param applied Whether the factory actually used the value. Pass the result of the SAME expression
+ *   that decides it (`'baseURL' in baseURLOverride`), never a second copy of the test — a re-test is
+ *   exactly how the guard and what the user is told drift apart.
+ */
+export function warnUnappliedConfigurationPath(provider, configuration, path, applied, guidance) {
+    if (applied)
+        return;
+    if (!isPlainRecord(configuration) || !(path in configuration))
+        return;
+    displayWarning(`Ignoring llm.configuration.${path} — it is set for the "${provider}" provider but carries no ` +
+        `usable value, so it is not applied. ${guidance}`);
+}
+//# sourceMappingURL=configurationPassthrough.js.map

package/dist/providers/configurationPassthrough.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configurationPassthrough.js","sourceRoot":"","sources":["../../src/providers/configurationPassthrough.ts"],"names":[],"mappings":"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"}

package/dist/providers/geminiThinking.d.ts

@@ -48,5 +48,13 @@ export declare function applyGeminiThoughtSummaries<T extends BaseChatModel>(mod
  * no way to tell them apart and prints the thinking as the assistant's answer. Not asking for the
  * summary is the only thing that reliably stops that; nothing is stripped, so the message kept in
  * graph state (and any `thoughtSignature` riding on it) is untouched. Returns the same instance.
+ *
+ * It applies to EVERY model family, including the image/tts ones the enable path skips: those are
+ * precisely where `@langchain/google` sets `includeThoughts: true` itself once a budget or level is
+ * configured, so a shared "does this model produce summaries?" guard would let exactly those
+ * summaries through. What it will not do is INTRODUCE a thinking config where the library built
+ * none — a request that carries no `thinkingConfig` gets no summary anyway (that is the whole
+ * premise of {@link applyGeminiThoughtSummaries}), and adding the field to a model family the
+ * library withholds it from would send something it deliberately did not.
  */
 export declare function disableGeminiThoughtSummaries<T extends BaseChatModel>(model: T): T;

package/dist/providers/geminiThinking.js

@@ -1,8 +1,14 @@
 /**
- * Model families that produce no thought summary to show. `@langchain/google` itself declines to
- * send any thinking config for a 2.5 image model, so injecting one there would send a field the
- * library deliberately withheld; image/tts generations have no reasoning panel to fill either way.
- * Skipping them keeps this change to the models it is about.
+ * Model families to leave alone when ADDING a request for thought summaries. `@langchain/google`
+ * itself declines to send any thinking config for a 2.5 image model, so injecting one there would
+ * send a field the library deliberately withheld; image/tts generations have no reasoning panel to
+ * fill either way. Skipping them keeps the enable path to the models it is about.
+ *
+ * This gates the ENABLE direction only, and it must never gate the disable one. The sentence it
+ * encodes — "we are unsure this model produces a summary, so do not ask for one" — inverts into
+ * "…so let one through" the moment the same test is applied to a leak-prevention override, and
+ * these families are exactly where `@langchain/google` sets `includeThoughts: true` on its own
+ * once a thinking budget is configured.
  */
 function producesThoughtSummaries(model) {
     if (typeof model !== 'string')
@@ -18,6 +24,9 @@ function producesThoughtSummaries(model) {
  * that decision is left exactly as it stands. Returns the same model instance for chaining.
  */
 export function applyGeminiThoughtSummaries(model) {
+    if (!producesThoughtSummaries(model.model)) {
+        return model;
+    }
     return overrideThinkingConfig(model, (thinkingConfig) => 
     // `thinkingConfig` is always PRESENT as a key and may hold `undefined`; an explicit value means
     // the user's budget/level was honoured and must win.
@@ -34,24 +43,35 @@ export function applyGeminiThoughtSummaries(model) {
  * no way to tell them apart and prints the thinking as the assistant's answer. Not asking for the
  * summary is the only thing that reliably stops that; nothing is stripped, so the message kept in
  * graph state (and any `thoughtSignature` riding on it) is untouched. Returns the same instance.
+ *
+ * It applies to EVERY model family, including the image/tts ones the enable path skips: those are
+ * precisely where `@langchain/google` sets `includeThoughts: true` itself once a budget or level is
+ * configured, so a shared "does this model produce summaries?" guard would let exactly those
+ * summaries through. What it will not do is INTRODUCE a thinking config where the library built
+ * none — a request that carries no `thinkingConfig` gets no summary anyway (that is the whole
+ * premise of {@link applyGeminiThoughtSummaries}), and adding the field to a model family the
+ * library withholds it from would send something it deliberately did not.
  */
 export function disableGeminiThoughtSummaries(model) {
-    return overrideThinkingConfig(model, (thinkingConfig) => ({
-        ...(typeof thinkingConfig === 'object' && thinkingConfig !== null ? thinkingConfig : {}),
-        includeThoughts: false,
-    }));
+    return overrideThinkingConfig(model, (thinkingConfig) => thinkingConfig === undefined
+        ? thinkingConfig
+        : {
+            ...(typeof thinkingConfig === 'object' && thinkingConfig !== null ? thinkingConfig : {}),
+            includeThoughts: false,
+        });
 }
 /**
  * Shared plumbing: re-derive `generationConfig.thinkingConfig` on every built request. Models that
- * build no `generationConfig` (every non-Google provider) and model families that produce no thought
- * summary are left completely alone, so this is a no-op wherever it does not apply. Overrides stack:
- * the outermost one sees what the inner ones produced, which is what lets a surface-level decision
- * override the construction-time default.
+ * build no `generationConfig` (every non-Google provider) are left completely alone, so this is a
+ * no-op wherever it does not apply. Which model families to skip is the CALLER's decision, because
+ * it differs by direction — see {@link producesThoughtSummaries}. Overrides stack: the outermost one
+ * sees what the inner ones produced, which is what lets a surface-level decision override the
+ * construction-time default.
  */
 function overrideThinkingConfig(model, next) {
     const holder = model;
     const original = holder.invocationParams;
-    if (typeof original !== 'function' || !producesThoughtSummaries(holder.model)) {
+    if (typeof original !== 'function') {
         return model;
     }
     const bound = original.bind(model);

package/dist/providers/geminiThinking.js.map

@@ -1 +1 @@
-{"version":3,"file":"geminiThinking.js","sourceRoot":"","sources":["../../src/providers/geminiThinking.ts"],"names":[],"mappings":"AAmCA;;;;;GAKG;AACH,SAAS,wBAAwB,CAAC,KAAc;IAC9C,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC3C,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,2BAA2B,CAA0B,KAAQ;IAC3E,OAAO,sBAAsB,CAAC,KAAK,EAAE,CAAC,cAAc,EAAE,EAAE;IACtD,gGAAgG;IAChG,qDAAqD;IACrD,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,cAAc,CAC1E,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,6BAA6B,CAA0B,KAAQ;IAC7E,OAAO,sBAAsB,CAAC,KAAK,EAAE,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;QACxD,GAAG,CAAC,OAAO,cAAc,KAAK,QAAQ,IAAI,cAAc,KAAK,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;QACxF,eAAe,EAAE,KAAK;KACvB,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;;;GAMG;AACH,SAAS,sBAAsB,CAC7B,KAAQ,EACR,IAA2C;IAE3C,MAAM,MAAM,GAAG,KAA8E,CAAC;IAC9F,MAAM,QAAQ,GAAG,MAAM,CAAC,gBAAgB,CAAC;IACzC,IAAI,OAAO,QAAQ,KAAK,UAAU,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9E,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAuB,CAAC;IACzD,MAAM,CAAC,gBAAgB,GAAG,SAAS,kCAAkC,CACnE,OAAiB;QAEjB,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QAC9B,MAAM,gBAAgB,GAAG,MAAM,EAAE,gBAAgB,CAAC;QAClD,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;QAC7D,IAAI,cAAc,KAAK,gBAAgB,CAAC,cAAc,EAAE,CAAC;YACvD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,OAAO,EAAE,GAAG,MAAM,EAAE,gBAAgB,EAAE,EAAE,GAAG,gBAAgB,EAAE,cAAc,EAAE,EAAE,CAAC;IAClF,CAAC,CAAC;IACF,OAAO,KAAK,CAAC;AACf,CAAC"}
+{"version":3,"file":"geminiThinking.js","sourceRoot":"","sources":["../../src/providers/geminiThinking.ts"],"names":[],"mappings":"AAmCA;;;;;;;;;;;GAWG;AACH,SAAS,wBAAwB,CAAC,KAAc;IAC9C,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC3C,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,2BAA2B,CAA0B,KAAQ;IAC3E,IAAI,CAAC,wBAAwB,CAAE,KAAwC,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/E,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,sBAAsB,CAAC,KAAK,EAAE,CAAC,cAAc,EAAE,EAAE;IACtD,gGAAgG;IAChG,qDAAqD;IACrD,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,cAAc,CAC1E,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,6BAA6B,CAA0B,KAAQ;IAC7E,OAAO,sBAAsB,CAAC,KAAK,EAAE,CAAC,cAAc,EAAE,EAAE,CACtD,cAAc,KAAK,SAAS;QAC1B,CAAC,CAAC,cAAc;QAChB,CAAC,CAAC;YACE,GAAG,CAAC,OAAO,cAAc,KAAK,QAAQ,IAAI,cAAc,KAAK,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;YACxF,eAAe,EAAE,KAAK;SACvB,CACN,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,sBAAsB,CAC7B,KAAQ,EACR,IAA2C;IAE3C,MAAM,MAAM,GAAG,KAA8E,CAAC;IAC9F,MAAM,QAAQ,GAAG,MAAM,CAAC,gBAAgB,CAAC;IACzC,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAuB,CAAC;IACzD,MAAM,CAAC,gBAAgB,GAAG,SAAS,kCAAkC,CACnE,OAAiB;QAEjB,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QAC9B,MAAM,gBAAgB,GAAG,MAAM,EAAE,gBAAgB,CAAC;QAClD,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;QAC7D,IAAI,cAAc,KAAK,gBAAgB,CAAC,cAAc,EAAE,CAAC;YACvD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,OAAO,EAAE,GAAG,MAAM,EAAE,gBAAgB,EAAE,EAAE,GAAG,gBAAgB,EAAE,cAAc,EAAE,EAAE,CAAC;IAClF,CAAC,CAAC;IACF,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/providers/google-genai.js

@@ -4,6 +4,7 @@ import { writeConfigFileWithMessages } from '#src/utils/fileUtils.js';
 import { buildInitConfigContent, getCuratedFallbackModel } from '#src/providers/modelDiscovery.js';
 import { applyGeminiToolSchemaSanitizer } from '#src/providers/geminiSchemaSanitizer.js';
 import { applyGeminiThoughtSummaries } from '#src/providers/geminiThinking.js';
+import { NATIVE_CLIENT_REASON, warnUnusedConfiguration, } from '#src/providers/configurationPassthrough.js';
 // Function to process JSON config and create Google GenAI LLM instance
 export async function processJsonConfig(llmConfig) {
     const { ChatGoogle } = await import('@langchain/google/node');
@@ -17,6 +18,16 @@ export async function processJsonConfig(llmConfig) {
     };
     delete configFields.type;
     delete configFields.apiKeyEnvironmentVariable;
+    // `ChatGoogle` is a native client for the Gemini API, so nothing in a `configuration` block
+    // reaches it — say so before dropping it.
+    warnUnusedConfiguration({
+        provider: 'google-genai',
+        configuration: llmConfig.configuration,
+        consumedPaths: [],
+        reason: NATIVE_CLIENT_REASON,
+        guidance: 'ChatGoogle talks to the Gemini API through its own client instead: set "customHeaders", ' +
+            '"endpoint" or "apiVersion" as top-level fields of the "llm" block beside "model".',
+    });
     // GS2-58: normalise every tool's JSON-Schema at the ChatGoogle boundary so Gemini's OpenAPI-3.0
     // subset accepts built-in, custom, and MCP tools alike (see geminiSchemaSanitizer).
     // CFG-33: ask for the thought summaries of the thinking Gemini already does and already bills,

package/dist/providers/google-genai.js.map

@@ -1 +1 @@
-{"version":3,"file":"google-genai.js","sourceRoot":"","sources":["../../src/providers/google-genai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAIhD,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACnG,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAE/E,uEAAuE;AACvE,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAAmF;IAEnF,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,MAAM,CAAC,wBAAwB,CAAC,CAAC;IAC9D,wEAAwE;IACxE,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,IAAI,GAAG,CAAC,cAAc,CAAC;IAC5D,MAAM,YAAY,GAAG;QACnB,GAAG,SAAS;QACZ,MAAM,EAAE,YAAY;QACpB,KAAK,EAAE,SAAS,CAAC,KAAK,IAAI,uBAAuB,CAAC,cAAc,CAAC;QACjE,YAAY,EAAE,KAAc;KAC7B,CAAC;IACF,OAAO,YAAY,CAAC,IAAI,CAAC;IACzB,OAAO,YAAY,CAAC,yBAAyB,CAAC;IAC9C,gGAAgG;IAChG,oFAAoF;IACpF,+FAA+F;IAC/F,6EAA6E;IAC7E,OAAO,2BAA2B,CAAC,8BAA8B,CAAC,IAAI,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;AACnG,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,cAAsB,EAAE,KAAK,GAAG,KAAK,EAAE,KAAc;IACxE,yDAAyD;IACzD,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,2BAA2B,CAAC,cAAc,EAAE,sBAAsB,CAAC,cAAc,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAClG,cAAc,CACZ,2BAA2B,cAAc,qCAAqC;QAC5E,gDAAgD,CACnD,CAAC;AACJ,CAAC"}
+{"version":3,"file":"google-genai.js","sourceRoot":"","sources":["../../src/providers/google-genai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAIhD,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACnG,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAC/E,OAAO,EACL,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,4CAA4C,CAAC;AAEpD,uEAAuE;AACvE,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAAmF;IAEnF,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,MAAM,CAAC,wBAAwB,CAAC,CAAC;IAC9D,wEAAwE;IACxE,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,IAAI,GAAG,CAAC,cAAc,CAAC;IAC5D,MAAM,YAAY,GAAG;QACnB,GAAG,SAAS;QACZ,MAAM,EAAE,YAAY;QACpB,KAAK,EAAE,SAAS,CAAC,KAAK,IAAI,uBAAuB,CAAC,cAAc,CAAC;QACjE,YAAY,EAAE,KAAc;KAC7B,CAAC;IACF,OAAO,YAAY,CAAC,IAAI,CAAC;IACzB,OAAO,YAAY,CAAC,yBAAyB,CAAC;IAC9C,4FAA4F;IAC5F,0CAA0C;IAC1C,uBAAuB,CAAC;QACtB,QAAQ,EAAE,cAAc;QACxB,aAAa,EAAG,SAAyC,CAAC,aAAa;QACvE,aAAa,EAAE,EAAE;QACjB,MAAM,EAAE,oBAAoB;QAC5B,QAAQ,EACN,0FAA0F;YAC1F,mFAAmF;KACtF,CAAC,CAAC;IACH,gGAAgG;IAChG,oFAAoF;IACpF,+FAA+F;IAC/F,6EAA6E;IAC7E,OAAO,2BAA2B,CAAC,8BAA8B,CAAC,IAAI,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;AACnG,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,cAAsB,EAAE,KAAK,GAAG,KAAK,EAAE,KAAc;IACxE,yDAAyD;IACzD,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,2BAA2B,CAAC,cAAc,EAAE,sBAAsB,CAAC,cAAc,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAClG,cAAc,CACZ,2BAA2B,cAAc,qCAAqC;QAC5E,gDAAgD,CACnD,CAAC;AACJ,CAAC"}

package/dist/providers/groq.js

@@ -2,11 +2,23 @@ import { displayWarning } from '#src/utils/consoleUtils.js';
 import { env } from '#src/utils/systemUtils.js';
 import { writeConfigFileWithMessages } from '#src/utils/fileUtils.js';
 import { buildInitConfigContent, getCuratedFallbackModel } from '#src/providers/modelDiscovery.js';
+import { NATIVE_CLIENT_REASON, warnUnusedConfiguration, } from '#src/providers/configurationPassthrough.js';
 // Function to process JSON config and create Groq LLM instance
 export async function processJsonConfig(llmConfig) {
     const groq = await import('@langchain/groq');
     // Use config value if available, otherwise use the environment variable
     const groqApiKey = llmConfig.apiKey || env.GROQ_API_KEY;
+    // `ChatGroq` builds a Groq SDK client from its own TOP-LEVEL fields, so nothing in a
+    // `configuration` block reaches it — say so before dropping it.
+    warnUnusedConfiguration({
+        provider: 'groq',
+        configuration: llmConfig.configuration,
+        consumedPaths: [],
+        reason: NATIVE_CLIENT_REASON,
+        guidance: 'ChatGroq builds a Groq SDK client from top-level fields of the "llm" block instead: set ' +
+            '"baseUrl" (note the lower-case "url"), "timeout", "defaultHeaders", "defaultQuery", ' +
+            '"httpAgent" or "fetch" beside "model".',
+    });
     return new groq.ChatGroq({
         ...llmConfig,
         apiKey: groqApiKey,

package/dist/providers/groq.js.map

@@ -1 +1 @@
-{"version":3,"file":"groq.js","sourceRoot":"","sources":["../../src/providers/groq.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAIhD,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAEnG,+DAA+D;AAC/D,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,SAAwB;IAC9D,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAC7C,wEAAwE;IACxE,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,IAAI,GAAG,CAAC,YAAY,CAAC;IACxD,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC;QACvB,GAAG,SAAS;QACZ,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,SAAS,CAAC,KAAK,IAAI,uBAAuB,CAAC,MAAM,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,cAAsB,EAAE,KAAK,GAAG,KAAK,EAAE,KAAc;IACxE,yDAAyD;IACzD,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,2BAA2B,CAAC,cAAc,EAAE,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAC1F,cAAc,CACZ,yBAAyB,cAAc,uBAAuB;QAC5D,8CAA8C,CACjD,CAAC;AACJ,CAAC"}
+{"version":3,"file":"groq.js","sourceRoot":"","sources":["../../src/providers/groq.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAIhD,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACnG,OAAO,EACL,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,4CAA4C,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,SAAwB;IAC9D,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAC7C,wEAAwE;IACxE,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,IAAI,GAAG,CAAC,YAAY,CAAC;IACxD,qFAAqF;IACrF,gEAAgE;IAChE,uBAAuB,CAAC;QACtB,QAAQ,EAAE,MAAM;QAChB,aAAa,EAAG,SAAyC,CAAC,aAAa;QACvE,aAAa,EAAE,EAAE;QACjB,MAAM,EAAE,oBAAoB;QAC5B,QAAQ,EACN,0FAA0F;YAC1F,sFAAsF;YACtF,wCAAwC;KAC3C,CAAC,CAAC;IACH,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC;QACvB,GAAG,SAAS;QACZ,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,SAAS,CAAC,KAAK,IAAI,uBAAuB,CAAC,MAAM,CAAC;KAC1D,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,cAAsB,EAAE,KAAK,GAAG,KAAK,EAAE,KAAc;IACxE,yDAAyD;IACzD,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,2BAA2B,CAAC,cAAc,EAAE,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAC1F,cAAc,CACZ,yBAAyB,cAAc,uBAAuB;QAC5D,8CAA8C,CACjD,CAAC;AACJ,CAAC"}