@gaunt-sloth/core 2.0.0-alpha.8 → 2.0.0-beta.0

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/geminiSchemaSanitizer.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @packageDocumentation
+ * GS2-58 — systemic Gemini tool-schema sanitizer at the `@langchain/google` provider boundary.
+ *
+ * Google Gemini's function-declaration schema is a SELECT SUBSET of OpenAPI 3.0. `@langchain/google`'s
+ * own `removeAdditionalProperties` strips only `additionalProperties`, so every other JSON-Schema-draft
+ * keyword the subset does not declare (`exclusiveMinimum`/`exclusiveMaximum`/`multipleOf`, `$defs`,
+ * `patternProperties`, `const`, `$ref`, `allOf`/`oneOf`/`not`, …) is passed straight to the wire, and
+ * Gemini 400s at tool-declaration send time — before any tool runs.
+ *
+ * This is the DURABLE fix (GS2-58, fix-cycle 1): rather than a denylist that is always one unknown
+ * keyword behind, {@link sanitizeGeminiToolSchema} is an ALLOWLIST — it keeps ONLY the fields the
+ * installed Gemini `Schema` type declares and drops everything else, so a future keyword in ANY tool
+ * (built-in, custom, or MCP — including schemas gaunt-sloth does not author) cannot re-break Gemini.
+ *
+ * The allowlist ({@link GEMINI_SUPPORTED_SCHEMA_KEYWORDS}) is derived DIRECTLY from the authoritative
+ * in-repo type — the `Gemini.Tools.Schema` interface in
+ * `node_modules/@langchain/google/dist/chat_models/api-types.d.{ts,cts}` (a `FunctionDeclaration`'s
+ * `parameters?: Schema`), "a select subset of an OpenAPI 3.0 schema object". Keeping it aligned with
+ * that type (not a remembered list) is what prevents a stale allowlist silently over-stripping.
+ *
+ * Scope is the google/gemini provider path ONLY: {@link applyGeminiToolSchemaSanitizer} is wired into
+ * the `google-genai` and `vertexai` presets' `processJsonConfig`. It leaves OpenAI/Anthropic/Ollama
+ * wiring untouched, and does not weaken the GS2-56/57 build-time denylist guard (that test still runs;
+ * this transform runs ahead of the wire send, so a sanitized tool is what Gemini sees).
+ */
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+/**
+ * The EXACT set of schema keywords Gemini's function-declaration schema accepts, transcribed field-
+ * for-field from the `Gemini.Tools.Schema` interface in
+ * `@langchain/google/dist/chat_models/api-types.d.ts`. Anything not in this set is dropped (allowlist).
+ *
+ * Note `anyOf` IS supported (unions / nullable) and MUST survive — only `allOf`/`oneOf`/`not` are
+ * absent from the type and therefore dropped. `exclusiveMinimum`/`exclusiveMaximum` are NOT in the type
+ * either; they are handled specially by rewriting them to `minimum`/`maximum` (see {@link sanitizeNode})
+ * before the allowlist filter runs.
+ */
+export declare const GEMINI_SUPPORTED_SCHEMA_KEYWORDS: ReadonlySet<string>;
+/**
+ * Pure, recursive normaliser: returns a cleaned DEEP COPY of a JSON-Schema containing only keywords
+ * Gemini's function-declaration `Schema` accepts, so its OpenAPI-3.0 subset accepts the tool. At each
+ * node the SAFE composition keywords are first RESOLVED into supported equivalents
+ * ({@link resolveComposition}: `const` → `enum`, clean `allOf` → shallow merge) and only then does the
+ * allowlist drop the rest. Does not mutate the input. `anyOf` unions survive; `$ref`/`oneOf`/`not` are
+ * dropped (see {@link resolveComposition} for why the last three are deferred, not resolved).
+ */
+export declare function sanitizeGeminiToolSchema<T = unknown>(schema: T): T;
+/**
+ * Wire the sanitizer into a ChatGoogle model at the tool-binding boundary. Overrides the instance's
+ * `bindTools` so every tool passed to it — built-in, custom, or MCP, via `createAgent`/`createDeepAgent`
+ * which both call `model.bindTools(tools)` — is sanitized before it reaches `@langchain/google`'s
+ * Gemini converter. Provider-scoped: only the google-genai/vertexai presets call this, so no other
+ * provider's tools are affected. Returns the same model instance for convenient chaining.
+ */
+export declare function applyGeminiToolSchemaSanitizer<T extends BaseChatModel>(model: T): T;

package/dist/providers/geminiSchemaSanitizer.js

@@ -0,0 +1,347 @@
+import { toJsonSchema } from '@langchain/core/utils/json_schema';
+import { isInteropZodSchema } from '@langchain/core/utils/types';
+import { isSerializableSchema } from '@langchain/core/utils/standard_schema';
+/**
+ * The EXACT set of schema keywords Gemini's function-declaration schema accepts, transcribed field-
+ * for-field from the `Gemini.Tools.Schema` interface in
+ * `@langchain/google/dist/chat_models/api-types.d.ts`. Anything not in this set is dropped (allowlist).
+ *
+ * Note `anyOf` IS supported (unions / nullable) and MUST survive — only `allOf`/`oneOf`/`not` are
+ * absent from the type and therefore dropped. `exclusiveMinimum`/`exclusiveMaximum` are NOT in the type
+ * either; they are handled specially by rewriting them to `minimum`/`maximum` (see {@link sanitizeNode})
+ * before the allowlist filter runs.
+ */
+export const GEMINI_SUPPORTED_SCHEMA_KEYWORDS = new Set([
+    'anyOf',
+    'default',
+    'description',
+    'enum',
+    'example',
+    'format',
+    'items',
+    'maxItems',
+    'maxLength',
+    'maxProperties',
+    'maximum',
+    'minItems',
+    'minLength',
+    'minProperties',
+    'minimum',
+    'nullable',
+    'pattern',
+    'properties',
+    'propertyOrdering',
+    'required',
+    'title',
+    'type',
+]);
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Deep-clone a literal (JSON-schema data) value so the returned schema never aliases the input. */
+function cloneLiteral(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    try {
+        return structuredClone(value);
+    }
+    catch {
+        // Non-cloneable (functions/symbols) never appear in JSON-schema data; keep the reference.
+        return value;
+    }
+}
+/** Structural equality by JSON serialisation. Used only for CONSERVATIVE conflict detection during
+ * an `allOf` merge: a false "not equal" (e.g. key-order differences) merely makes the merge abort to
+ * the safe drop, never produces an unsound merge — so a best-effort compare is sufficient here. */
+function jsonEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+/**
+ * A `const` is resolved to `enum` ONLY when its value is a SCALAR (string / number / boolean / null).
+ * An object- or array-valued `const` is deliberately NOT resolved: synthesising an object/array-valued
+ * `enum` is a plausible-but-unverified Gemini 400 path, so we leave it to fall through to the safe
+ * allowlist drop (typeless `{}`) — exactly the prior GS2-58 behaviour, never widened.
+ */
+function isScalarConst(value) {
+    return (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean');
+}
+/** Infer the Gemini `type` for a SCALAR `const` value when the schema declares none. Numbers map to
+ * the general `number` (integer vs number is not "obvious" from a literal); `null` yields no type. */
+function inferTypeFromConst(value) {
+    switch (typeof value) {
+        case 'string':
+            return 'string';
+        case 'boolean':
+            return 'boolean';
+        case 'number':
+            return 'number';
+        default:
+            return undefined; // null (the only other scalar reaching here) → no type
+    }
+}
+/**
+ * Attempt a shallow merge of `node.allOf` (a list of subschemas) into the parent node. Gemini has no
+ * `allOf`, so GS2-58 simply drops it — losing any content carried only by the branches. When every
+ * branch is a plain-object subschema that merges CLEANLY, we fold it in instead:
+ *  - `properties` are unioned (a property name appearing in the parent or two branches with DIFFERENT
+ *    schemas is a conflict → abort);
+ *  - `required` arrays are unioned;
+ *  - any other (scalar) keyword is copied, but a key already set — on the parent or an earlier branch —
+ *    to a DIFFERENT value is a conflict → abort.
+ * On ANY conflict, or if a branch is not a plain object (a boolean subschema `true`/`false`), returns
+ * `null` so the caller leaves `allOf` in place for the allowlist to drop — the safe GS2-58 behaviour,
+ * never a guessed merge. Note a branch carrying an UNRESOLVED keyword (e.g. `{ $ref: '#/…' }`) is still
+ * a plain object, so the merge PROCEEDS: the other branches merge and the `$ref` is copied onto the
+ * parent, where the allowlist then drops it — still safe, and higher-fidelity than dropping every
+ * branch. Returns a fresh object (never mutates `node`) with `allOf` removed on success.
+ */
+function mergeAllOf(node) {
+    const branches = node.allOf;
+    if (!Array.isArray(branches) || branches.length === 0)
+        return null;
+    if (!branches.every(isPlainObject))
+        return null;
+    const acc = { ...node };
+    delete acc.allOf;
+    const props = isPlainObject(acc.properties) ? { ...acc.properties } : {};
+    let sawProps = isPlainObject(acc.properties);
+    const required = new Set(Array.isArray(acc.required) ? acc.required : []);
+    let sawRequired = Array.isArray(acc.required);
+    for (const branch of branches) {
+        for (const [key, value] of Object.entries(branch)) {
+            if (key === 'properties') {
+                if (!isPlainObject(value))
+                    return null;
+                for (const [name, sub] of Object.entries(value)) {
+                    if (name in props && !jsonEqual(props[name], sub))
+                        return null; // conflicting property
+                    props[name] = sub;
+                }
+                sawProps = true;
+            }
+            else if (key === 'required') {
+                if (Array.isArray(value))
+                    for (const r of value)
+                        required.add(r);
+                sawRequired = true;
+            }
+            else {
+                // scalar / other keyword: parent and every branch must agree on it.
+                if (key in acc && !jsonEqual(acc[key], value))
+                    return null;
+                acc[key] = value;
+            }
+        }
+    }
+    if (sawProps)
+        acc.properties = props;
+    if (sawRequired)
+        acc.required = [...required];
+    return acc;
+}
+/**
+ * Resolve the SAFE structural-composition keywords Gemini rejects into supported equivalents, BEFORE
+ * {@link sanitizeNode}'s allowlist drops the rest. Its output feeds the same allowlist + `exclusive*`
+ * rewrite pass, so merged-in `properties`/`items`/`anyOf` are still recursed and a merged-in
+ * `exclusiveMinimum` is still rewritten. A strict NO-OP (returns the input node) when the node carries
+ * none of the handled keywords, so clean schemas pass through byte-identical.
+ *
+ * Implemented (high-fidelity, no external context needed):
+ *  - SCALAR `const` → `enum: [value]` (+ infer `type` from the value when the node declares none).
+ *    Gemini has no `const` but supports `enum`; a single-value `enum` is an exact model of `const`.
+ *    Presence (`'const' in node`), not truthiness, so `const: 0 / false / '' / null` resolve too.
+ *    An OBJECT/ARRAY-valued `const` is NOT resolved (see {@link isScalarConst}) — it falls through to
+ *    the safe allowlist drop (typeless `{}`), never widening into an unverified object-`enum` 400 path.
+ *  - `allOf` of plain-object branches → shallow-merged when clean (see {@link mergeAllOf}); otherwise
+ *    left for the allowlist to drop.
+ *
+ * Deliberately NOT resolved — kept as the safe GS2-58 drop (see the GS2-68 characterization tests):
+ *  - `oneOf` / `not`: `oneOf` is XOR, semantically distinct from `anyOf`'s OR, so remapping it would
+ *    silently change a tool's contract; `not` has no Gemini equivalent. Both are dropped.
+ *  - `$ref` / `$defs` / `definitions`: inlining a same-document `$ref` is only sound when fully self-
+ *    contained AND cycle-guarded, and is NEAR-ZERO in practice — `@langchain/mcp-adapters` dereferences
+ *    `$ref` and merges `allOf` UPSTREAM before tools reach this boundary, and gaunt-sloth's own zod
+ *    tools inline+type their schemas. No live path authors a bare `$ref` here, so this is DEFERRED
+ *    (GS2-68): a `$ref`-only property still sanitizes to a typeless `{}` — non-400 and callable, just
+ *    without type fidelity. A raw non-adapter tool that needs it should dereference upstream, not here.
+ */
+function resolveComposition(node) {
+    let out = node;
+    if ('const' in node && !('enum' in node) && isScalarConst(node.const)) {
+        if (out === node)
+            out = { ...node };
+        out.enum = [cloneLiteral(node.const)];
+        if (!('type' in out)) {
+            const inferred = inferTypeFromConst(node.const);
+            if (inferred)
+                out.type = inferred;
+        }
+    }
+    if (Array.isArray(out.allOf)) {
+        const merged = mergeAllOf(out);
+        if (merged)
+            out = merged;
+        // else: leave `allOf` in place → the allowlist drops it (safe GS2-58 behaviour).
+    }
+    return out;
+}
+/**
+ * Recursively normalise one schema node to Gemini's supported subset:
+ *  - rewrite `exclusiveMinimum`→`minimum` / `exclusiveMaximum`→`maximum` (Gemini has no exclusive
+ *    bound), keeping the TIGHTER bound when an inclusive one is also present;
+ *  - keep ONLY {@link GEMINI_SUPPORTED_SCHEMA_KEYWORDS}; drop everything else;
+ *  - recurse ONLY through real subschema positions — `properties` (map), `items` (schema or tuple),
+ *    and `anyOf` (array of schemas). Literal-data positions (`enum`, `default`, `example`, `required`,
+ *    `propertyOrdering`) are copied verbatim, so a keyword that merely appears as DATA is untouched.
+ */
+function sanitizeNode(node) {
+    if (Array.isArray(node)) {
+        return node.map(sanitizeNode);
+    }
+    if (!isPlainObject(node)) {
+        return node;
+    }
+    // Resolve the safe composition keywords (const → enum, clean allOf → shallow merge) BEFORE the
+    // allowlist drop, so their content survives; the allowlist below then still guarantees no
+    // unsupported keyword escapes. `resolved` is `node` itself when nothing needed resolving.
+    const resolved = resolveComposition(node);
+    const out = {};
+    for (const [key, value] of Object.entries(resolved)) {
+        // Allowlist: silently drop any keyword Gemini's Schema type does not declare (this is where
+        // $defs / definitions / patternProperties / const / multipleOf / $ref / allOf / oneOf / not /
+        // additionalProperties / $schema / exclusive* are removed).
+        if (!GEMINI_SUPPORTED_SCHEMA_KEYWORDS.has(key)) {
+            continue;
+        }
+        if (key === 'properties' && isPlainObject(value)) {
+            const mapped = {};
+            for (const [name, sub] of Object.entries(value)) {
+                mapped[name] = sanitizeNode(sub);
+            }
+            out[key] = mapped;
+        }
+        else if (key === 'items') {
+            out[key] = Array.isArray(value) ? value.map(sanitizeNode) : sanitizeNode(value);
+        }
+        else if (key === 'anyOf' && Array.isArray(value)) {
+            out[key] = value.map(sanitizeNode);
+        }
+        else {
+            // Supported scalar / literal-data keyword (type, enum, required, description, default, …).
+            out[key] = cloneLiteral(value);
+        }
+    }
+    // exclusive* → inclusive of the SAME value. Gemini has no exclusive bound; args are hints, so the
+    // loosening is accepted. When both an exclusive and an inclusive bound are present, keep the TIGHTER
+    // one (higher lower-bound / lower upper-bound) rather than letting the exclusive value clobber it.
+    // Read from `resolved` so a bound merged in from an `allOf` branch is rewritten too.
+    const exclusiveMinimum = resolved.exclusiveMinimum;
+    if (typeof exclusiveMinimum === 'number') {
+        out.minimum =
+            typeof out.minimum === 'number' ? Math.max(out.minimum, exclusiveMinimum) : exclusiveMinimum;
+    }
+    const exclusiveMaximum = resolved.exclusiveMaximum;
+    if (typeof exclusiveMaximum === 'number') {
+        out.maximum =
+            typeof out.maximum === 'number' ? Math.min(out.maximum, exclusiveMaximum) : exclusiveMaximum;
+    }
+    return out;
+}
+/**
+ * Pure, recursive normaliser: returns a cleaned DEEP COPY of a JSON-Schema containing only keywords
+ * Gemini's function-declaration `Schema` accepts, so its OpenAPI-3.0 subset accepts the tool. At each
+ * node the SAFE composition keywords are first RESOLVED into supported equivalents
+ * ({@link resolveComposition}: `const` → `enum`, clean `allOf` → shallow merge) and only then does the
+ * allowlist drop the rest. Does not mutate the input. `anyOf` unions survive; `$ref`/`oneOf`/`not` are
+ * dropped (see {@link resolveComposition} for why the last three are deferred, not resolved).
+ */
+export function sanitizeGeminiToolSchema(schema) {
+    return sanitizeNode(schema);
+}
+/**
+ * The SINGLE normalization pass. Converts a schema to JSON (zod → JSON via the same `@langchain/core`
+ * converter `@langchain/google` uses internally) and runs the allowlist. Every tool-shape branch in
+ * {@link sanitizeToolForGemini} routes its schema(s) through here — so no branch can filter
+ * inconsistently, and a future tool format is covered the moment it calls this.
+ */
+function normalizeSchema(rawSchema) {
+    const jsonSchema = isInteropZodSchema(rawSchema) || isSerializableSchema(rawSchema)
+        ? toJsonSchema(rawSchema)
+        : rawSchema;
+    return sanitizeGeminiToolSchema(jsonSchema);
+}
+/** Build a shallow copy of a tool that preserves its prototype (so it stays a recognisable
+ * LangChain tool) while overriding one own property (its schema) with the normalized value. */
+function cloneWithOverride(source, key, value) {
+    const clone = Object.assign(Object.create(Object.getPrototypeOf(source)), source);
+    Object.defineProperty(clone, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+    });
+    return clone;
+}
+/**
+ * Normalise one tool's argument schema for Gemini. Handles the three shapes that reach a ChatGoogle
+ * model's `bindTools`: a LangChain structured tool (`.schema`, zod or JSON), an OpenAI-format tool
+ * (`.function.parameters`), and a Gemini-native `functionDeclarations` tool. Every schema position in
+ * every branch is passed through the SINGLE {@link normalizeSchema} pass; anything else is untouched.
+ */
+function sanitizeToolForGemini(tool) {
+    if (!tool || typeof tool !== 'object') {
+        return tool;
+    }
+    const record = tool;
+    // LangChain structured tool / StructuredToolParams — its arg schema is `.schema` (zod or JSON).
+    if ('schema' in record && record.schema != null) {
+        return cloneWithOverride(tool, 'schema', normalizeSchema(record.schema));
+    }
+    // OpenAI-format tool: { type: 'function', function: { parameters } }.
+    const fn = record.function;
+    if (fn && typeof fn === 'object' && 'parameters' in fn) {
+        const fnRecord = fn;
+        return {
+            ...record,
+            function: { ...fnRecord, parameters: normalizeSchema(fnRecord.parameters) },
+        };
+    }
+    // Gemini-native tool: { functionDeclarations: [{ parameters }, …] }.
+    if (Array.isArray(record.functionDeclarations)) {
+        return {
+            ...record,
+            functionDeclarations: record.functionDeclarations.map((decl) => {
+                if (decl && typeof decl === 'object' && 'parameters' in decl) {
+                    const declRecord = decl;
+                    return { ...declRecord, parameters: normalizeSchema(declRecord.parameters) };
+                }
+                return decl;
+            }),
+        };
+    }
+    return tool;
+}
+/**
+ * Wire the sanitizer into a ChatGoogle model at the tool-binding boundary. Overrides the instance's
+ * `bindTools` so every tool passed to it — built-in, custom, or MCP, via `createAgent`/`createDeepAgent`
+ * which both call `model.bindTools(tools)` — is sanitized before it reaches `@langchain/google`'s
+ * Gemini converter. Provider-scoped: only the google-genai/vertexai presets call this, so no other
+ * provider's tools are affected. Returns the same model instance for convenient chaining.
+ */
+export function applyGeminiToolSchemaSanitizer(model) {
+    const holder = model;
+    const original = holder.bindTools;
+    if (typeof original !== 'function') {
+        return model;
+    }
+    const bound = original.bind(model);
+    holder.bindTools = function sanitizedBindTools(tools, kwargs) {
+        const nextTools = Array.isArray(tools) ? tools.map(sanitizeToolForGemini) : tools;
+        return bound(nextTools, kwargs);
+    };
+    return model;
+}
+//# sourceMappingURL=geminiSchemaSanitizer.js.map

package/dist/providers/geminiSchemaSanitizer.js.map

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

package/dist/providers/geminiThinking.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @packageDocumentation
+ * CFG-33 — ask Gemini to RETURN the thinking it is already doing.
+ *
+ * Two knobs are easy to conflate. The thinking BUDGET is what costs money, and Gemini thinks by
+ * default — those tokens are billed whether or not anyone sees them. Thought SUMMARIES
+ * (`thinkingConfig.includeThoughts`, default off) decide only whether any of that is returned. So
+ * without this, gaunt-sloth pays for reasoning on every Gemini turn and throws it away unseen, and
+ * the `/reasoning` panel is empty.
+ *
+ * Hence the rule here: wherever thinking is enabled, show it. This never changes the budget, and it
+ * is not opt-in — a knob belongs on the thing that actually costs (`thinkingBudget` /
+ * `thinkingLevel` / `reasoningEffort` in the `llm` config), never on whether the user may see what
+ * they have already paid for. Setting the budget to zero or minimal turns thinking off, and this
+ * respects that: there are then no thoughts to show.
+ *
+ * Why an `invocationParams` override rather than a constructor field: `@langchain/google` derives
+ * `generationConfig.thinkingConfig` from the budget/level fields on every call and does not read a
+ * `thinkingConfig` passed to the constructor, so the ONLY way to add `includeThoughts` without also
+ * pinning a budget is at the built params. Overriding the instance method (the shape
+ * {@link applyGeminiToolSchemaSanitizer} already uses for `bindTools`) keeps working through
+ * `bindTools`, which returns a `RunnableBinding` around this same instance.
+ *
+ * Gemini returns a thought summary as a content BLOCK marked `thought: true`, not in
+ * `additional_kwargs`; `#src/core/reasoningBlocks.js` is the half of this fix that reads it. That
+ * block is typed `text`, exactly like an answer block, so a surface that does NOT route content
+ * through gsloth's own reasoning bridge cannot tell thinking from answer — which is what
+ * {@link disableGeminiThoughtSummaries} is for.
+ */
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+/**
+ * Wire thought summaries into a `ChatGoogle` model. Overrides the instance's `invocationParams` so
+ * that `generationConfig.thinkingConfig.includeThoughts` is set — but ONLY when the library derived
+ * no thinking config at all, which is the "user configured nothing, the API default budget applies"
+ * case. When the user DID configure a budget or level, `@langchain/google` has already decided
+ * `includeThoughts` from it (true when thinking is on, false when they asked for none/minimal) and
+ * that decision is left exactly as it stands. Returns the same model instance for chaining.
+ */
+export declare function applyGeminiThoughtSummaries<T extends BaseChatModel>(model: T): T;
+/**
+ * The inverse, for a surface that must not receive thought summaries at all: keep whatever thinking
+ * budget or level applies and force `includeThoughts: false`, so the model still thinks and only the
+ * summary is withheld. Never express this as a zero/minimal budget — that turns THINKING off, which
+ * is a different and much larger change, and the coercion differs between the 2.5 and 3.x presets.
+ *
+ * This exists because a consumer outside {@link GthAbstractAgent} routes content blocks by `type`,
+ * and Gemini's thought summary is typed `text` exactly like an answer block — so a third party has
+ * 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;