@jini-ai/agent-runtime 0.3.10 → 0.4.0

package/dist/providers/google-messages.d.ts

@@ -247,19 +247,38 @@ export interface GoogleStreamState {
     finishReason: string | null;
     usage: Record<string, unknown> | null;
 }
-export declare function applyGoogleUsage(state: GoogleStreamState, data: Record<string, unknown>, onEvent: (event: GoogleTurnEvent) => void): void;
+export declare function applyGoogleUsage({ state, data, onEvent }: {
+    state: GoogleStreamState;
+    data: Record<string, unknown>;
+    onEvent: (event: GoogleTurnEvent) => void;
+}): void;
 /** Checks `data.promptFeedback` for a documented block reason and, if present, emits the `error` event for it (the caller emits `end` — see `processGoogleFrame`). Returns whether the frame loop should stop. */
-export declare function handleGoogleBlockedPrompt(data: Record<string, unknown>, onEvent: (event: GoogleTurnEvent) => void): boolean;
+export declare function handleGoogleBlockedPrompt({ data, onEvent }: {
+    data: Record<string, unknown>;
+    onEvent: (event: GoogleTurnEvent) => void;
+}): boolean;
 /**
  * Feeds one text part through the role-marker guard and emits the safe portion. Returns `'break'`
  * once the guard flags contamination (the caller ends the turn immediately), otherwise
  * `'continue'` — same contract as `anthropic-messages.ts#handleAnthropicTextDelta`.
  */
-export declare function handleGoogleTextPart(state: GoogleStreamState, text: string, onEvent: (event: GoogleTurnEvent) => void): 'continue' | 'break';
+export declare function handleGoogleTextPart({ state, text, onEvent }: {
+    state: GoogleStreamState;
+    text: string;
+    onEvent: (event: GoogleTurnEvent) => void;
+}): 'continue' | 'break';
 /** `rawPart.functionCall` must already be confirmed a record by the caller. Reads `thoughtSignature` off `rawPart` (a sibling of `functionCall`, not a member of it) — see `GoogleFunctionCallPart.thoughtSignature`'s doc for why only a non-empty string is carried. */
-export declare function handleGoogleFunctionCallPart(state: GoogleStreamState, rawPart: Record<string, unknown>, onEvent: (event: GoogleTurnEvent) => void): void;
+export declare function handleGoogleFunctionCallPart({ state, rawPart, onEvent }: {
+    state: GoogleStreamState;
+    rawPart: Record<string, unknown>;
+    onEvent: (event: GoogleTurnEvent) => void;
+}): void;
 /** Dispatches one part between the text and function-call handlers above. Returns `'break'` once a text part contaminates the guard, else `'continue'`. */
-export declare function processGoogleRawPart(state: GoogleStreamState, rawPart: unknown, onEvent: (event: GoogleTurnEvent) => void): 'continue' | 'break';
+export declare function processGoogleRawPart({ state, rawPart, onEvent }: {
+    state: GoogleStreamState;
+    rawPart: unknown;
+    onEvent: (event: GoogleTurnEvent) => void;
+}): 'continue' | 'break';
 /** One frame's dispatch outcome — `'end'` carries the reason `runSingleGoogleRequest`'s loop passes to `emitEnd`, matching `anthropic-messages.ts#AnthropicFrameOutcome`'s identical split (the low-level handlers below only ever *report* why to stop; only the loop itself calls `emitEnd`, keeping that call in exactly one place). */
 export type GoogleFrameOutcome = {
     readonly action: 'continue';
@@ -274,7 +293,11 @@ export type GoogleFrameOutcome = {
  * nesting-penalized top-level `if`s into one function call plus one outcome check — see
  * `runSingleGoogleRequest`'s loop below.
  */
-export declare function processGoogleFrame(state: GoogleStreamState, data: Record<string, unknown>, onEvent: (event: GoogleTurnEvent) => void): GoogleFrameOutcome;
+export declare function processGoogleFrame({ state, data, onEvent }: {
+    state: GoogleStreamState;
+    data: Record<string, unknown>;
+    onEvent: (event: GoogleTurnEvent) => void;
+}): GoogleFrameOutcome;
 /**
  * Decides why the tool loop should stop after one request, or returns `null` when it should
  * instead proceed to execute the pending tool calls. Pure — no events, no I/O — mirrors
@@ -283,9 +306,16 @@ export declare function processGoogleFrame(state: GoogleStreamState, data: Recor
  * `finishReason` comparison (see module doc, point 2, for why Gemini's `finishReason` enum cannot
  * be used here).
  */
-export declare function googleLoopExitReason(outcome: SingleRequestOutcome, toolTurns: number, maxToolTurns: number): GoogleTurnEndReason | null;
+export declare function googleLoopExitReason({ outcome, toolTurns, maxToolTurns }: {
+    outcome: SingleRequestOutcome;
+    toolTurns: number;
+    maxToolTurns: number;
+}): GoogleTurnEndReason | null;
 /** Builds the `model`-role `Content`'s `parts` recording the pending tool calls — text (if any) followed by one `functionCall` part per call, each with its `thoughtSignature` spread back on as a sibling field, in the same shape the response delivered it and only when the response actually carried one (a `functionCall` part with no signature is legal; one with an empty-string signature is not). */
-export declare function buildGoogleAssistantParts(text: string, toolCalls: readonly GoogleToolCall[]): GooglePart[];
+export declare function buildGoogleAssistantParts({ text, toolCalls }: {
+    text: string;
+    toolCalls: readonly GoogleToolCall[];
+}): GooglePart[];
 export interface GoogleToolExecutionOutcome {
     readonly functionResponseParts: GooglePart[];
     readonly followUpParts: GooglePart[];
@@ -297,13 +327,17 @@ export interface GoogleToolExecutionOutcome {
  * functionResponse" section for why images travel this way instead of a separate follow-up
  * message (unlike `openai-chat.ts`/`azure-chat.ts`).
  */
-export declare function executeGoogleToolCalls(executeTool: GoogleToolExecutor, calls: readonly GoogleToolCall[], onEvent: (event: GoogleTurnEvent) => void): Promise<GoogleToolExecutionOutcome>;
+export declare function executeGoogleToolCalls({ executeTool, calls, onEvent }: {
+    executeTool: GoogleToolExecutor;
+    calls: readonly GoogleToolCall[];
+    onEvent: (event: GoogleTurnEvent) => void;
+}): Promise<GoogleToolExecutionOutcome>;
 /**
  * Runs a full Gemini `streamGenerateContent` turn, including the
  * tool-execution loop when `options.executeTool` is supplied and the model
  * requests a function call. See `anthropic-messages.ts#runAnthropicToolTurn`'s
  * doc for the shared event-stream/`ended`-flag contract this mirrors.
  */
-export declare function runGoogleToolTurn(options: GoogleTurnOptions): Promise<GoogleTurnResult>;
+export declare function runGoogleToolTurn(requiredArgs: Pick<GoogleTurnOptions, "apiKey" | "model" | "contents" | "onEvent">, optionalArgs?: Omit<GoogleTurnOptions, "apiKey" | "model" | "contents" | "onEvent">): Promise<GoogleTurnResult>;
 export {};
 //# sourceMappingURL=google-messages.d.ts.map

package/dist/providers/google-messages.js

@@ -1,3 +1,4 @@
+import { redactSecrets } from '@jini-ai/core';
 /**
  * @module providers/google-messages
  *
@@ -94,7 +95,7 @@
  * tool-loop body and its test file's multi-tool-call image test).
  */
 import { createRoleMarkerGuard } from '../role-marker-guard.js';
-import { defaultDnsLookup, pinnedFetch, redactSecrets, validateBaseUrlResolved } from './connection-guard.js';
+import { defaultDnsLookup, pinnedFetch, validateBaseUrlResolved } from './connection-guard.js';
 import { googleStreamGenerateContentUrl } from './google.js';
 import { decodeSseStream } from './sse-decode.js';
 import { createTurnEndGuard } from './turn-end-guard.js';
@@ -117,7 +118,7 @@ function isRecord(value) {
  * parity correction and a real hardening.
  */
 function googleRequestUrl(baseUrl, model) {
-    return googleStreamGenerateContentUrl(baseUrl ?? DEFAULT_GOOGLE_BASE_URL, model);
+    return googleStreamGenerateContentUrl({ baseUrl: baseUrl ?? DEFAULT_GOOGLE_BASE_URL, model: model });
 }
 function googleHeaders(options) {
     return {
@@ -150,7 +151,7 @@ function extractGoogleErrorDetail(rawText) {
     }
     return rawText.trim().slice(0, 500);
 }
-export function applyGoogleUsage(state, data, onEvent) {
+export function applyGoogleUsage({ state, data, onEvent }) {
     if (!isRecord(data.usageMetadata))
         return;
     state.usage = data.usageMetadata;
@@ -162,7 +163,7 @@ function firstGoogleCandidate(data) {
     return candidates[0];
 }
 /** Checks `data.promptFeedback` for a documented block reason and, if present, emits the `error` event for it (the caller emits `end` — see `processGoogleFrame`). Returns whether the frame loop should stop. */
-export function handleGoogleBlockedPrompt(data, onEvent) {
+export function handleGoogleBlockedPrompt({ data, onEvent }) {
     if (!isRecord(data.promptFeedback) || typeof data.promptFeedback.blockReason !== 'string')
         return false;
     onEvent({ type: 'error', message: `prompt blocked: ${data.promptFeedback.blockReason}`, code: data.promptFeedback.blockReason });
@@ -177,8 +178,8 @@ function googleCandidateParts(candidate) {
  * once the guard flags contamination (the caller ends the turn immediately), otherwise
  * `'continue'` — same contract as `anthropic-messages.ts#handleAnthropicTextDelta`.
  */
-export function handleGoogleTextPart(state, text, onEvent) {
-    const safe = state.guard.feedText(text);
+export function handleGoogleTextPart({ state, text, onEvent }) {
+    const safe = state.guard.feedText({ text: text });
     if (safe.length > 0) {
         state.fullText += safe;
         onEvent({ type: 'text_delta', delta: safe });
@@ -191,7 +192,7 @@ export function handleGoogleTextPart(state, text, onEvent) {
     return 'break';
 }
 /** `rawPart.functionCall` must already be confirmed a record by the caller. Reads `thoughtSignature` off `rawPart` (a sibling of `functionCall`, not a member of it) — see `GoogleFunctionCallPart.thoughtSignature`'s doc for why only a non-empty string is carried. */
-export function handleGoogleFunctionCallPart(state, rawPart, onEvent) {
+export function handleGoogleFunctionCallPart({ state, rawPart, onEvent }) {
     const fc = rawPart.functionCall;
     const name = typeof fc.name === 'string' ? fc.name : null;
     if (!name)
@@ -203,21 +204,21 @@ export function handleGoogleFunctionCallPart(state, rawPart, onEvent) {
     onEvent({ type: 'tool_use', id: call.id, name: call.name, input: call.input });
 }
 /** Dispatches one part between the text and function-call handlers above. Returns `'break'` once a text part contaminates the guard, else `'continue'`. */
-export function processGoogleRawPart(state, rawPart, onEvent) {
+export function processGoogleRawPart({ state, rawPart, onEvent }) {
     if (!isRecord(rawPart))
         return 'continue';
     if (typeof rawPart.text === 'string' && rawPart.text.length > 0) {
-        return handleGoogleTextPart(state, rawPart.text, onEvent);
+        return handleGoogleTextPart({ state: state, text: rawPart.text, onEvent: onEvent });
     }
     if (isRecord(rawPart.functionCall)) {
-        handleGoogleFunctionCallPart(state, rawPart, onEvent);
+        handleGoogleFunctionCallPart({ state: state, rawPart: rawPart, onEvent: onEvent });
     }
     return 'continue';
 }
 /** Dispatches one candidate's `parts` array, one part at a time, via `processGoogleRawPart`. Returns `'break'` once a text part contaminates the guard. */
 function processGoogleParts(state, parts, onEvent) {
     for (const rawPart of parts) {
-        if (processGoogleRawPart(state, rawPart, onEvent) === 'break')
+        if (processGoogleRawPart({ state: state, rawPart: rawPart, onEvent: onEvent }) === 'break')
             return 'break';
     }
     return 'continue';
@@ -229,11 +230,11 @@ function processGoogleParts(state, parts, onEvent) {
  * nesting-penalized top-level `if`s into one function call plus one outcome check — see
  * `runSingleGoogleRequest`'s loop below.
  */
-export function processGoogleFrame(state, data, onEvent) {
-    applyGoogleUsage(state, data, onEvent);
+export function processGoogleFrame({ state, data, onEvent }) {
+    applyGoogleUsage({ state: state, data: data, onEvent: onEvent });
     const rawCandidate = firstGoogleCandidate(data);
     if (!rawCandidate) {
-        return handleGoogleBlockedPrompt(data, onEvent) ? { action: 'end', reason: 'error' } : { action: 'continue' };
+        return handleGoogleBlockedPrompt({ data: data, onEvent: onEvent }) ? { action: 'end', reason: 'error' } : { action: 'continue' };
     }
     if (!isRecord(rawCandidate))
         return { action: 'continue' };
@@ -253,7 +254,7 @@ export function processGoogleFrame(state, data, onEvent) {
  */
 async function openGoogleResponseStream(options, contents, emitEnd) {
     const { onEvent } = options;
-    const baseUrlCheck = await validateBaseUrlResolved(options.baseUrl ?? DEFAULT_GOOGLE_BASE_URL, options.dnsLookup ?? defaultDnsLookup);
+    const baseUrlCheck = await validateBaseUrlResolved({ baseUrl: options.baseUrl ?? DEFAULT_GOOGLE_BASE_URL, lookup: options.dnsLookup ?? defaultDnsLookup });
     if (baseUrlCheck.error) {
         onEvent({ type: 'error', message: baseUrlCheck.error });
         emitEnd('error');
@@ -261,17 +262,17 @@ async function openGoogleResponseStream(options, contents, emitEnd) {
     }
     let response;
     try {
-        response = await (options.fetchImpl ?? pinnedFetch)(googleRequestUrl(options.baseUrl, options.model), {
-            method: 'POST',
-            headers: googleHeaders(options),
-            body: JSON.stringify(googleRequestBody(options, contents)),
-            redirect: 'error',
-            ...(options.signal ? { signal: options.signal } : {}),
-        }, baseUrlCheck.pinnedAddress);
+        response = await (options.fetchImpl ?? pinnedFetch)({ url: googleRequestUrl(options.baseUrl, options.model), init: {
+                method: 'POST',
+                headers: googleHeaders(options),
+                body: JSON.stringify(googleRequestBody(options, contents)),
+                redirect: 'error',
+                ...(options.signal ? { signal: options.signal } : {}),
+            }, pinnedAddress: baseUrlCheck.pinnedAddress });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        onEvent({ type: 'error', message: redactSecrets(message, [options.apiKey]) });
+        onEvent({ type: 'error', message: redactSecrets({ input: message }, { exactSecrets: [options.apiKey] }) });
         emitEnd('error');
         return null;
     }
@@ -279,7 +280,7 @@ async function openGoogleResponseStream(options, contents, emitEnd) {
         const rawText = await response.text();
         onEvent({
             type: 'error',
-            message: redactSecrets(extractGoogleErrorDetail(rawText), [options.apiKey]),
+            message: redactSecrets({ input: extractGoogleErrorDetail(rawText) }, { exactSecrets: [options.apiKey] }),
             code: String(response.status),
         });
         emitEnd('error');
@@ -301,13 +302,13 @@ async function runSingleGoogleRequest(options, contents, emitEnd) {
     }
     onEvent({ type: 'status', label: 'requesting' });
     const state = {
-        guard: createRoleMarkerGuard('google-turn'),
+        guard: createRoleMarkerGuard({ messageId: 'google-turn' }),
         toolCalls: [],
         fullText: '',
         finishReason: null,
         usage: null,
     };
-    frameLoop: for await (const frame of decodeSseStream(body)) {
+    frameLoop: for await (const frame of decodeSseStream({ source: body })) {
         // No re-check of an "ended" flag at the top of this loop: the only way this loop calls
         // `emitEnd` is the `outcome.action === 'end'` branch below, immediately followed by
         // `break frameLoop` — same reachability proof as
@@ -321,7 +322,7 @@ async function runSingleGoogleRequest(options, contents, emitEnd) {
         }
         if (!isRecord(data))
             continue;
-        const outcome = processGoogleFrame(state, data, onEvent);
+        const outcome = processGoogleFrame({ state: state, data: data, onEvent: onEvent });
         if (outcome.action === 'end') {
             emitEnd(outcome.reason);
             break frameLoop;
@@ -415,7 +416,7 @@ function splitGoogleToolResultContent(content) {
  * `finishReason` comparison (see module doc, point 2, for why Gemini's `finishReason` enum cannot
  * be used here).
  */
-export function googleLoopExitReason(outcome, toolTurns, maxToolTurns) {
+export function googleLoopExitReason({ outcome, toolTurns, maxToolTurns }) {
     if (outcome.toolCalls.length === 0)
         return 'stop';
     if (toolTurns >= maxToolTurns)
@@ -423,7 +424,7 @@ export function googleLoopExitReason(outcome, toolTurns, maxToolTurns) {
     return null;
 }
 /** Builds the `model`-role `Content`'s `parts` recording the pending tool calls — text (if any) followed by one `functionCall` part per call, each with its `thoughtSignature` spread back on as a sibling field, in the same shape the response delivered it and only when the response actually carried one (a `functionCall` part with no signature is legal; one with an empty-string signature is not). */
-export function buildGoogleAssistantParts(text, toolCalls) {
+export function buildGoogleAssistantParts({ text, toolCalls }) {
     return [
         ...(text ? [{ text }] : []),
         ...toolCalls.map((call) => ({
@@ -439,7 +440,7 @@ export function buildGoogleAssistantParts(text, toolCalls) {
  * functionResponse" section for why images travel this way instead of a separate follow-up
  * message (unlike `openai-chat.ts`/`azure-chat.ts`).
  */
-export async function executeGoogleToolCalls(executeTool, calls, onEvent) {
+export async function executeGoogleToolCalls({ executeTool, calls, onEvent }) {
     const functionResponseParts = [];
     const followUpParts = [];
     for (const call of calls) {
@@ -468,7 +469,8 @@ export async function executeGoogleToolCalls(executeTool, calls, onEvent) {
  * requests a function call. See `anthropic-messages.ts#runAnthropicToolTurn`'s
  * doc for the shared event-stream/`ended`-flag contract this mirrors.
  */
-export async function runGoogleToolTurn(options) {
+export async function runGoogleToolTurn(requiredArgs, optionalArgs = {}) {
+    const options = { ...optionalArgs, ...requiredArgs };
     const maxToolTurns = options.maxToolTurns ?? DEFAULT_MAX_TOOL_TURNS;
     const executeTool = options.executeTool;
     const endGuard = createTurnEndGuard(options.onEvent, (reason) => ({ type: 'end', reason }));
@@ -481,7 +483,7 @@ export async function runGoogleToolTurn(options) {
         lastFinishReason = outcome.finishReason;
         if (endGuard.hasEnded())
             break;
-        const exitReason = googleLoopExitReason(outcome, toolTurns, maxToolTurns);
+        const exitReason = googleLoopExitReason({ outcome: outcome, toolTurns: toolTurns, maxToolTurns: maxToolTurns });
         if (exitReason) {
             emitEnd(exitReason);
             break;
@@ -494,8 +496,8 @@ export async function runGoogleToolTurn(options) {
             break;
         }
         toolTurns += 1;
-        const modelParts = buildGoogleAssistantParts(outcome.text, outcome.toolCalls);
-        const { functionResponseParts, followUpParts } = await executeGoogleToolCalls(executeTool, outcome.toolCalls, options.onEvent);
+        const modelParts = buildGoogleAssistantParts({ text: outcome.text, toolCalls: outcome.toolCalls });
+        const { functionResponseParts, followUpParts } = await executeGoogleToolCalls({ executeTool: executeTool, calls: outcome.toolCalls, onEvent: options.onEvent });
         contents = [
             ...contents,
             { role: 'model', parts: modelParts },

package/dist/providers/google-schema.d.ts

@@ -0,0 +1,26 @@
+import type { ProviderToolDescriptor } from './tool-turn-types.js';
+/** Converts JSON Schema into Gemini's restricted schema dialect. Unsupported constraints are guidance only; hosts must still validate tool input. Reference expansion defaults to four hops. Time and space are proportional to the expanded schema tree; this bound limits reference hops, not ordinary object nesting. */
+export declare function sanitizeGoogleSchema({ schema }: {
+    schema: unknown;
+}, { defs, maxRefDepth }?: {
+    defs?: Readonly<Record<string, unknown>>;
+    maxRefDepth?: number;
+}): unknown;
+/** Produces the schema actually placed on a Gemini function declaration, including required node types and array items. */
+export declare function googleParametersOf({ descriptor }: {
+    descriptor: ProviderToolDescriptor;
+}, { maxRefDepth }?: {
+    maxRefDepth?: number;
+}): Record<string, unknown>;
+/** Finds numeric enum fields through object properties. Array, union and reference traversal are outside this conversion's current scope. */
+export declare function findNumericEnumPaths({ schema }: {
+    schema: unknown;
+}, { prefix }?: {
+    prefix?: readonly string[];
+}): string[];
+/** Reverses Gemini's numeric enum stringification without mutating the incoming tool argument. Paths use dot-separated property names. */
+export declare function coerceNumericEnumStringsToNumbers({ input, paths }: {
+    input: unknown;
+    paths: readonly string[];
+}): unknown;
+//# sourceMappingURL=google-schema.d.ts.map

package/dist/providers/google-schema.js

@@ -0,0 +1,253 @@
+function inputSchemaOf(descriptor) {
+    return descriptor.inputSchema && typeof descriptor.inputSchema === "object"
+        ? descriptor.inputSchema
+        : { type: "object", additionalProperties: false, required: [], properties: {} };
+}
+const GOOGLE_SUPPORTED_SCHEMA_KEYS = new Set([
+    "type",
+    "format",
+    "title",
+    "description",
+    "nullable",
+    "default",
+    "items",
+    "minItems",
+    "maxItems",
+    "enum",
+    "properties",
+    "propertyOrdering",
+    "required",
+    "minProperties",
+    "maxProperties",
+    "minimum",
+    "maximum",
+    "minLength",
+    "maxLength",
+    "pattern",
+    "example",
+    "anyOf",
+]);
+const MAX_GOOGLE_REF_DEPTH = 4;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function inferGoogleTypeFromLiteral(value) {
+    if (typeof value === "boolean")
+        return "boolean";
+    if (typeof value === "number")
+        return Number.isInteger(value) ? "integer" : "number";
+    return "string";
+}
+function collapseGoogleTypeArray(members) {
+    const names = members.filter((member) => typeof member === "string");
+    const nullable = names.includes("null");
+    const nonNull = names.filter((name) => name !== "null");
+    return { type: nonNull[0] ?? "string", nullable };
+}
+function resolveGoogleRef(ref, defs) {
+    const prefix = "#/$defs/";
+    if (!ref.startsWith(prefix))
+        return { type: "object" };
+    return defs[ref.slice(prefix.length)] ?? { type: "object" };
+}
+function terminalGoogleRefStub(resolved) {
+    const type = isRecord(resolved) && typeof resolved.type === "string" ? resolved.type : "object";
+    const originalDescription = isRecord(resolved) && typeof resolved.description === "string" ? `${resolved.description} ` : "";
+    return { type, description: `${originalDescription}(further nesting simplified for Gemini compatibility)` };
+}
+function enforceGoogleSchemaShape(node) {
+    const usesAnyOf = Array.isArray(node.anyOf) && node.anyOf.length > 0;
+    if (!usesAnyOf && typeof node.type !== "string")
+        node.type = "object";
+    if (node.type === "array" && !isRecord(node.items)) {
+        node.items = { type: "string", description: "Contents simplified for Gemini compatibility." };
+    }
+    return node;
+}
+function isGoogleIgnoredSchemaKey(key) {
+    return key === "$defs" || key === "$ref" || key === "oneOf";
+}
+function isGoogleTypeArrayKey(key, value) {
+    return key === "type" && Array.isArray(value);
+}
+function isGoogleNullableEnumKey(key, value) {
+    return key === "enum" && Array.isArray(value) && value.includes(null);
+}
+function applyGoogleSchemaEnum(result, value) {
+    result.enum = value.filter((member) => member !== null);
+}
+function isGooglePropertiesKey(key, value) {
+    return key === "properties" && isRecord(value);
+}
+function isGoogleSchemaPositionKey(key) {
+    return key === "items" || key === "anyOf";
+}
+function applyGoogleSchemaTypeArray(result, value) {
+    const collapsed = collapseGoogleTypeArray(value);
+    result.type = collapsed.type;
+    return collapsed.nullable ? { inferredNullable: true } : {};
+}
+function sanitizeGoogleSchemaValuePositionValue(value, defs, remainingRefDepth) {
+    return Array.isArray(value)
+        ? value.map((member) => sanitizeGoogleSubschema(member, defs, remainingRefDepth))
+        : sanitizeGoogleSubschema(value, defs, remainingRefDepth);
+}
+function applyGoogleSchemaEntry(result, key, value, localDefs, remainingRefDepth) {
+    if (isGoogleIgnoredSchemaKey(key))
+        return {};
+    if (key === "const") {
+        result.enum = [value];
+        return { hasConst: true, constValue: value };
+    }
+    if (isGoogleTypeArrayKey(key, value))
+        return applyGoogleSchemaTypeArray(result, value);
+    if (isGoogleNullableEnumKey(key, value)) {
+        applyGoogleSchemaEnum(result, value);
+        return {};
+    }
+    if (!GOOGLE_SUPPORTED_SCHEMA_KEYS.has(key))
+        return {};
+    if (isGooglePropertiesKey(key, value)) {
+        result.properties = Object.fromEntries(Object.entries(value).map(([name, propSchema]) => [name, sanitizeGoogleSubschema(propSchema, localDefs, remainingRefDepth)]));
+        return {};
+    }
+    if (isGoogleSchemaPositionKey(key)) {
+        result[key] = sanitizeGoogleSchemaValuePositionValue(value, localDefs, remainingRefDepth);
+        return {};
+    }
+    result[key] = sanitizeGoogleSchemaValue(value, localDefs, remainingRefDepth);
+    return {};
+}
+function mergeGoogleOneOf(schema, result, defs, remainingRefDepth) {
+    if (!Array.isArray(schema.oneOf))
+        return undefined;
+    const merged = [...(Array.isArray(result.anyOf) ? result.anyOf : []), ...schema.oneOf];
+    return merged.map((member) => sanitizeGoogleSubschema(member, defs, remainingRefDepth));
+}
+function buildGoogleSchemaResult(schema, localDefs, remainingRefDepth) {
+    const result = {};
+    let constValue;
+    let hasConst = false;
+    let inferredNullable = false;
+    for (const [key, value] of Object.entries(schema)) {
+        const effect = applyGoogleSchemaEntry(result, key, value, localDefs, remainingRefDepth);
+        if (effect.hasConst) {
+            hasConst = true;
+            constValue = effect.constValue;
+        }
+        if (effect.inferredNullable)
+            inferredNullable = true;
+    }
+    const mergedOneOf = mergeGoogleOneOf(schema, result, localDefs, remainingRefDepth);
+    if (mergedOneOf)
+        result.anyOf = mergedOneOf;
+    return { result, hasConst, constValue, inferredNullable };
+}
+function sanitizeGoogleSchemaValueRef(ref, localDefs, remainingRefDepth) {
+    const resolved = resolveGoogleRef(ref, localDefs);
+    if (remainingRefDepth <= 0)
+        return enforceGoogleSchemaShape(terminalGoogleRefStub(resolved));
+    return sanitizeGoogleSchemaValue(resolved, localDefs, remainingRefDepth - 1);
+}
+function hasGoogleNumericEnumValues(schema) {
+    return Array.isArray(schema.enum) && schema.enum.length > 0 && schema.enum.every((member) => typeof member === "number");
+}
+function applyGoogleNumericEnumStringification(schema, result) {
+    if (!hasGoogleNumericEnumValues(schema))
+        return;
+    result.enum = schema.enum.map((member) => String(member));
+    result.type = "string";
+}
+function applyGoogleConstTypeInference(result, hasConst, constValue) {
+    if (!hasConst || result.type !== undefined)
+        return;
+    result.type = inferGoogleTypeFromLiteral(constValue);
+}
+function sanitizeGoogleSchemaValue(schema, defs = {}, remainingRefDepth = MAX_GOOGLE_REF_DEPTH) {
+    if (Array.isArray(schema))
+        return schema.map((entry) => sanitizeGoogleSchemaValue(entry, defs, remainingRefDepth));
+    if (!isRecord(schema))
+        return schema;
+    const localDefs = isRecord(schema.$defs) ? { ...defs, ...schema.$defs } : defs;
+    if (typeof schema.$ref === "string")
+        return sanitizeGoogleSchemaValueRef(schema.$ref, localDefs, remainingRefDepth);
+    const { result, hasConst, constValue, inferredNullable } = buildGoogleSchemaResult(schema, localDefs, remainingRefDepth);
+    if (inferredNullable)
+        result.nullable = true;
+    applyGoogleConstTypeInference(result, hasConst, constValue);
+    applyGoogleNumericEnumStringification(schema, result);
+    return result;
+}
+function sanitizeGoogleSubschema(value, defs, depth) {
+    const sanitized = sanitizeGoogleSchemaValue(value, defs, depth);
+    return isRecord(sanitized) ? enforceGoogleSchemaShape(sanitized) : sanitized;
+}
+function googleParametersOfValue(descriptor, maxRefDepth = MAX_GOOGLE_REF_DEPTH) {
+    return enforceGoogleSchemaShape(sanitizeGoogleSchemaValue(inputSchemaOf(descriptor), {}, maxRefDepth));
+}
+function isGoogleNumericEnumSchema(schema) {
+    return (schema.type === "integer" || schema.type === "number") && hasGoogleNumericEnumValues(schema);
+}
+function findNumericEnumPathsValue(schema, prefix = []) {
+    if (!isRecord(schema))
+        return [];
+    const paths = [];
+    if (isGoogleNumericEnumSchema(schema))
+        paths.push(prefix.join("."));
+    if (isRecord(schema.properties)) {
+        for (const [name, propSchema] of Object.entries(schema.properties)) {
+            paths.push(...findNumericEnumPathsValue(propSchema, [...prefix, name]));
+        }
+    }
+    return paths;
+}
+function readAtGooglePath(input, segments) {
+    let current = input;
+    for (const segment of segments) {
+        if (!isRecord(current))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function writeAtGooglePath(input, segments, value) {
+    const [head, ...rest] = segments;
+    if (head === undefined)
+        return input;
+    if (rest.length === 0)
+        return { ...input, [head]: value };
+    const child = input[head];
+    if (!isRecord(child))
+        return input;
+    return { ...input, [head]: writeAtGooglePath(child, rest, value) };
+}
+function coerceNumericEnumStringsToNumbersValue(input, paths) {
+    if (paths.length === 0 || !isRecord(input))
+        return input;
+    let result = input;
+    for (const path of paths) {
+        const segments = path.split(".");
+        const current = readAtGooglePath(result, segments);
+        if (typeof current === "string" && current.trim().length > 0 && Number.isFinite(Number(current))) {
+            result = writeAtGooglePath(result, segments, Number(current));
+        }
+    }
+    return result;
+}
+/** Converts JSON Schema into Gemini's restricted schema dialect. Unsupported constraints are guidance only; hosts must still validate tool input. Reference expansion defaults to four hops. Time and space are proportional to the expanded schema tree; this bound limits reference hops, not ordinary object nesting. */
+export function sanitizeGoogleSchema({ schema }, { defs = {}, maxRefDepth = MAX_GOOGLE_REF_DEPTH } = {}) {
+    return sanitizeGoogleSchemaValue(schema, defs, maxRefDepth);
+}
+/** Produces the schema actually placed on a Gemini function declaration, including required node types and array items. */
+export function googleParametersOf({ descriptor }, { maxRefDepth = MAX_GOOGLE_REF_DEPTH } = {}) {
+    return googleParametersOfValue(descriptor, maxRefDepth);
+}
+/** Finds numeric enum fields through object properties. Array, union and reference traversal are outside this conversion's current scope. */
+export function findNumericEnumPaths({ schema }, { prefix = [] } = {}) {
+    return findNumericEnumPathsValue(schema, prefix);
+}
+/** Reverses Gemini's numeric enum stringification without mutating the incoming tool argument. Paths use dot-separated property names. */
+export function coerceNumericEnumStringsToNumbers({ input, paths }) {
+    return coerceNumericEnumStringsToNumbersValue(input, paths);
+}
+//# sourceMappingURL=google-schema.js.map

package/dist/providers/google.d.ts

@@ -6,15 +6,30 @@
  * verbatim.
  */
 /** Strips any trailing `/v1`/`/v1beta` API-version segment and trailing slashes from a configured base URL. */
-export declare function googleGenerativeLanguageBaseUrl(baseUrl: string): string;
+export declare function googleGenerativeLanguageBaseUrl({ baseUrl }: {
+    baseUrl: string;
+}): string;
 /** Strips the `models/` prefix Google's API sometimes includes in a model id. */
-export declare function normalizeGoogleModelId(model: string): string;
+export declare function normalizeGoogleModelId({ model }: {
+    model: string;
+}): string;
 /** URL-encodes a normalized model id for use as a path segment. */
-export declare function googleModelPathSegment(model: string): string;
+export declare function googleModelPathSegment({ model }: {
+    model: string;
+}): string;
 /** Builds the non-streaming `generateContent` endpoint URL for a model. */
-export declare function googleGenerateContentUrl(baseUrl: string, model: string): string;
+export declare function googleGenerateContentUrl({ baseUrl, model }: {
+    baseUrl: string;
+    model: string;
+}): string;
 /** Builds the SSE-streaming `streamGenerateContent` endpoint URL for a model. */
-export declare function googleStreamGenerateContentUrl(baseUrl: string, model: string): string;
+export declare function googleStreamGenerateContentUrl({ baseUrl, model }: {
+    baseUrl: string;
+    model: string;
+}): string;
 /** Builds the model-catalog listing endpoint URL, with the API key attached as a query param. */
-export declare function googleProviderModelsUrl(baseUrl: string, apiKey: string): string;
+export declare function googleProviderModelsUrl({ baseUrl, apiKey }: {
+    baseUrl: string;
+    apiKey: string;
+}): string;
 //# sourceMappingURL=google.d.ts.map