melchizedek-agents 0.18.0 → 0.19.0

package/dist/lib/model.d.ts

@@ -0,0 +1,47 @@
+/**
+ * lib/model.ts — the `melchizedek-agents/model` entry: the engine's model
+ * layer on its own, with no @google/adk (ADR 0068).
+ *
+ * What it holds: the model contract's types (ADR 0048), every provider's
+ * contract adapter, resolveAdapter and resolveAdapterWithFallback over the
+ * one prefix table (ADR 0060), FallbackAdapter and the circuit breaker's
+ * helpers (ADR 0044). A consumer can call any model through it without
+ * installing ADK, the peer dependency the rest of the package needs.
+ *
+ * What it leaves out, because each loads ADK: AdkGeminiAdapter, the ADK
+ * shims (ClaudeLlm, GptLlm and the rest), TracedGemini, resolveModel and
+ * registerAvailableProviders. They stay at `melchizedek-agents/models/*`.
+ *
+ * Gemini: resolveAdapter here returns the engine's GeminiAdapter for a
+ * Gemini id. Asking for `adk` (the option, or GEMINI_ADAPTER=adk) throws and
+ * names `melchizedek-agents/models/registry`, whose resolveAdapter keeps
+ * ADR 0060's default until gate G3.
+ *
+ * tests/packageSurface.test.ts walks this module's runtime import graph and
+ * fails if any module in it names @google/adk.
+ */
+export type * from './models/contract.ts';
+export { resolveAdapter, resolveAdapterWithFallback, geminiAdapterSetting } from './models/adapterResolver.ts';
+export type { GeminiAdapterChoice, ResolveAdapterOptions } from './models/adapterResolver.ts';
+export { PROVIDERS, providerForModel, providerKeyPresent } from './models/providerMap.ts';
+export type { ProviderId } from './models/providerMap.ts';
+export type { Platform, ProviderEndpoint } from './models/endpoints.ts';
+export { ClaudeAdapter } from './models/claudeAdapter.ts';
+export type { ClaudeAdapterOptions } from './models/claudeAdapter.ts';
+export { GptAdapter } from './models/gptAdapter.ts';
+export type { GptAdapterOptions } from './models/gptAdapter.ts';
+export { GrokAdapter } from './models/grokAdapter.ts';
+export type { GrokAdapterOptions } from './models/grokAdapter.ts';
+export { ChatCompletionsAdapter } from './models/chatCompletionsAdapter.ts';
+export type { ChatCompletionsAdapterOptions } from './models/chatCompletionsAdapter.ts';
+export { KimiAdapter } from './models/kimiAdapter.ts';
+export type { KimiAdapterOptions } from './models/kimiAdapter.ts';
+export { OllamaAdapter } from './models/ollamaAdapter.ts';
+export type { OllamaAdapterOptions } from './models/ollamaAdapter.ts';
+export { GatewayAdapter } from './models/gatewayAdapter.ts';
+export type { GatewayAdapterOptions } from './models/gatewayAdapter.ts';
+export { GeminiAdapter } from './models/geminiAdapter.ts';
+export type { GeminiAdapterOptions } from './models/geminiAdapter.ts';
+export { FallbackAdapter, isProviderError } from './models/fallbackAdapter.ts';
+export type { FallbackAdapterOptions } from './models/fallbackAdapter.ts';
+export { breakerSettings, circuitOpen, recordFailure, recordSuccess, resetCircuits } from './models/circuitBreaker.ts';

package/dist/lib/model.js

@@ -0,0 +1,37 @@
+/**
+ * lib/model.ts — the `melchizedek-agents/model` entry: the engine's model
+ * layer on its own, with no @google/adk (ADR 0068).
+ *
+ * What it holds: the model contract's types (ADR 0048), every provider's
+ * contract adapter, resolveAdapter and resolveAdapterWithFallback over the
+ * one prefix table (ADR 0060), FallbackAdapter and the circuit breaker's
+ * helpers (ADR 0044). A consumer can call any model through it without
+ * installing ADK, the peer dependency the rest of the package needs.
+ *
+ * What it leaves out, because each loads ADK: AdkGeminiAdapter, the ADK
+ * shims (ClaudeLlm, GptLlm and the rest), TracedGemini, resolveModel and
+ * registerAvailableProviders. They stay at `melchizedek-agents/models/*`.
+ *
+ * Gemini: resolveAdapter here returns the engine's GeminiAdapter for a
+ * Gemini id. Asking for `adk` (the option, or GEMINI_ADAPTER=adk) throws and
+ * names `melchizedek-agents/models/registry`, whose resolveAdapter keeps
+ * ADR 0060's default until gate G3.
+ *
+ * tests/packageSurface.test.ts walks this module's runtime import graph and
+ * fails if any module in it names @google/adk.
+ */
+// ── Resolve an adapter by model id ──────────────────────────────────────────
+export { resolveAdapter, resolveAdapterWithFallback, geminiAdapterSetting } from './models/adapterResolver.js';
+export { PROVIDERS, providerForModel, providerKeyPresent } from './models/providerMap.js';
+// ── The adapters ────────────────────────────────────────────────────────────
+export { ClaudeAdapter } from './models/claudeAdapter.js';
+export { GptAdapter } from './models/gptAdapter.js';
+export { GrokAdapter } from './models/grokAdapter.js';
+export { ChatCompletionsAdapter } from './models/chatCompletionsAdapter.js';
+export { KimiAdapter } from './models/kimiAdapter.js';
+export { OllamaAdapter } from './models/ollamaAdapter.js';
+export { GatewayAdapter } from './models/gatewayAdapter.js';
+export { GeminiAdapter } from './models/geminiAdapter.js';
+// ── Fallback and the circuit breaker ────────────────────────────────────────
+export { FallbackAdapter, isProviderError } from './models/fallbackAdapter.js';
+export { breakerSettings, circuitOpen, recordFailure, recordSuccess, resetCircuits } from './models/circuitBreaker.js';

package/dist/lib/models/adapterResolver.d.ts

@@ -0,0 +1,113 @@
+/**
+ * lib/models/adapterResolver.ts — one model id to one ModelAdapter on the
+ * engine's own contract (ADR 0048, ADR 0060), with no @google/adk in its
+ * import graph.
+ *
+ * WHY its own module: lib/models/registry.ts imports ADK (it registers the
+ * ADK classes and builds TracedGemini), so the `melchizedek-agents/model`
+ * entry (lib/model.ts) cannot load it. The routing step both paths share
+ * (routeFor: the provider from the prefix table, the caller's endpoint merged
+ * over the environment's, the transport from planTransport), the BYOK scoping
+ * and the contract adapter table live here; registry.ts imports them for
+ * resolveModel and for its own resolveAdapter.
+ *
+ * GEMINI (ADR 0068): `adapterResolver(adkGemini)` takes the factory for the
+ * temporary AdkGeminiAdapter from its caller. registry.ts passes one, so its
+ * resolveAdapter keeps ADR 0060's default (`adk` until gate G3). The resolver
+ * exported here has none: a Gemini id gets the engine's GeminiAdapter unless
+ * `adk` is asked for, by the option or by GEMINI_ADAPTER=adk, which throws
+ * and names the entry that has it.
+ */
+import type { ModelAdapter } from './contract.ts';
+import type { ProviderEndpoint } from './endpoints.ts';
+import type { FallbackAdapterOptions } from './fallbackAdapter.ts';
+import type { ProviderId } from './providerMap.ts';
+/** Where one model id goes: its provider, its transport, and what the caller injects. */
+export interface Route {
+    provider: ProviderId;
+    model: string;
+    transport: 'direct' | 'gateway';
+    /** A caller's own key for this provider, already scoped to it. */
+    apiKey?: string;
+    /** The caller's endpoint merged over the environment's (ADR 0023). */
+    endpoint?: ProviderEndpoint;
+}
+/**
+ * The fallback rule (lib/models/gateway.ts): the direct adapter whenever the
+ * provider's key — from env, or the caller's own BYOK key or endpoint — is
+ * present; the gateway stand-in only when it is absent and a gateway is
+ * configured. The gateway key is server env only, never a request header.
+ */
+export declare function routeFor(model: string, apiKey: string | undefined, endpoint: Partial<ProviderEndpoint> | undefined): Route;
+/**
+ * BYOK is scoped to the CALLER'S provider: the key a client sends
+ * authenticates that client's own provider (typically Gemini). Passing it to
+ * a different provider's adapter would override the server's env key
+ * (adapters prefer a passed key), fail auth, and hand the key to another
+ * vendor — e.g. a Gemini key sent to xAI. Cross-provider models therefore
+ * resolve keys from server env.
+ */
+export declare function scopedKey(model: string, apiKey: string | undefined, keyProvider: ProviderId): string | undefined;
+/** A provider name as the A2A X-Provider header gives it; anything unknown reads as gemini. */
+export declare function normalizeProvider(provider?: string): ProviderId;
+/**
+ * Which adapter serves a Gemini id on the contract path: `adk`, the temporary
+ * AdkGeminiAdapter over ADK's Gemini (lib/models/adkGeminiAdapter.ts), or
+ * `engine`, the engine's own GeminiAdapter on @google/genai
+ * (lib/models/geminiAdapter.ts).
+ */
+export type GeminiAdapterChoice = 'adk' | 'engine';
+/** GEMINI_ADAPTER as set (`adk` or `engine`), or undefined when unset. Any other value is a configuration error. */
+export declare function geminiAdapterSetting(env?: NodeJS.ProcessEnv): GeminiAdapterChoice | undefined;
+export interface ResolveAdapterOptions {
+    /**
+     * A caller's own API key (BYOK). It authenticates `keyProvider`'s models
+     * only, and wins over the endpoint's and the environment's key there.
+     */
+    apiKey?: string;
+    /**
+     * The provider `apiKey` belongs to (a provider id; anything else reads as
+     * gemini, as the A2A X-Provider header does). Default: the model's own.
+     * A model of another provider resolves its key from server env.
+     */
+    keyProvider?: string;
+    /** Where requests go (ADR 0023), merged over the environment's endpoint for the model's provider. */
+    endpoint?: Partial<ProviderEndpoint>;
+    /**
+     * Which Gemini adapter a Gemini id gets. Default: GEMINI_ADAPTER, else
+     * `adk` through `melchizedek-agents/models/registry` and `engine` through
+     * `melchizedek-agents/model`, which has no `adk`.
+     */
+    gemini?: GeminiAdapterChoice;
+}
+/** What a direct route's adapter is built from. */
+export type AdapterRoute = Pick<Route, 'model' | 'apiKey' | 'endpoint'>;
+/** Builds the temporary AdkGeminiAdapter; only lib/models/registry.ts supplies one. */
+export type AdkGeminiFactory = (route: AdapterRoute) => ModelAdapter;
+export interface AdapterResolver {
+    resolveAdapter(modelId: string, options?: ResolveAdapterOptions): ModelAdapter;
+    resolveAdapterWithFallback(modelId: string, fallbackId: string | undefined, options?: ResolveAdapterOptions, fallbackOptions?: FallbackAdapterOptions): ModelAdapter;
+}
+/**
+ * A resolver over the one prefix table. With `adkGemini`, a Gemini id gets
+ * AdkGeminiAdapter unless `engine` is asked for (ADR 0060). Without it, a
+ * Gemini id gets GeminiAdapter, and asking for `adk` throws (ADR 0068).
+ */
+export declare function adapterResolver(adkGemini?: AdkGeminiFactory): AdapterResolver;
+/**
+ * Resolves a model id to the engine's own ModelAdapter (ADR 0048), from the
+ * prefix table and the transport rule resolveModel uses, with no ADK: the
+ * provider's adapter when its key (env, BYOK or endpoint) is present, the
+ * gateway's when it is absent and MODEL_GATEWAY is set. A Gemini id gets
+ * GeminiAdapter (ADR 0068). The adapter opens no span and charges nothing:
+ * its caller does (ADR 0053).
+ */
+export declare function resolveAdapter(modelId: string, options?: ResolveAdapterOptions): ModelAdapter;
+/**
+ * An agent's model and its `fallback_model:`: a FallbackAdapter (ADR 0044)
+ * around resolveAdapter's two adapters, or the primary alone. The caller's
+ * key stays with its own provider: unless `keyProvider` says otherwise it
+ * belongs to the primary's, so a fallback on another provider resolves from
+ * server env.
+ */
+export declare function resolveAdapterWithFallback(modelId: string, fallbackId: string | undefined, options?: ResolveAdapterOptions, fallbackOptions?: FallbackAdapterOptions): ModelAdapter;

package/dist/lib/models/adapterResolver.js

@@ -0,0 +1,136 @@
+/**
+ * lib/models/adapterResolver.ts — one model id to one ModelAdapter on the
+ * engine's own contract (ADR 0048, ADR 0060), with no @google/adk in its
+ * import graph.
+ *
+ * WHY its own module: lib/models/registry.ts imports ADK (it registers the
+ * ADK classes and builds TracedGemini), so the `melchizedek-agents/model`
+ * entry (lib/model.ts) cannot load it. The routing step both paths share
+ * (routeFor: the provider from the prefix table, the caller's endpoint merged
+ * over the environment's, the transport from planTransport), the BYOK scoping
+ * and the contract adapter table live here; registry.ts imports them for
+ * resolveModel and for its own resolveAdapter.
+ *
+ * GEMINI (ADR 0068): `adapterResolver(adkGemini)` takes the factory for the
+ * temporary AdkGeminiAdapter from its caller. registry.ts passes one, so its
+ * resolveAdapter keeps ADR 0060's default (`adk` until gate G3). The resolver
+ * exported here has none: a Gemini id gets the engine's GeminiAdapter unless
+ * `adk` is asked for, by the option or by GEMINI_ADAPTER=adk, which throws
+ * and names the entry that has it.
+ */
+import { ClaudeAdapter } from './claudeAdapter.js';
+import { mergeEndpoint } from './endpoints.js';
+import { FallbackAdapter } from './fallbackAdapter.js';
+import { planTransport } from './gateway.js';
+import { GatewayAdapter } from './gatewayAdapter.js';
+import { GeminiAdapter } from './geminiAdapter.js';
+import { GptAdapter } from './gptAdapter.js';
+import { GrokAdapter } from './grokAdapter.js';
+import { KimiAdapter } from './kimiAdapter.js';
+import { OllamaAdapter } from './ollamaAdapter.js';
+import { providerForModel } from './providerMap.js';
+/**
+ * The fallback rule (lib/models/gateway.ts): the direct adapter whenever the
+ * provider's key — from env, or the caller's own BYOK key or endpoint — is
+ * present; the gateway stand-in only when it is absent and a gateway is
+ * configured. The gateway key is server env only, never a request header.
+ */
+export function routeFor(model, apiKey, endpoint) {
+    const provider = providerForModel(model);
+    const merged = endpoint ? mergeEndpoint(provider, endpoint) : undefined;
+    const { transport } = planTransport(model, { callerKey: !!apiKey || !!merged });
+    return { provider, model, transport, ...(apiKey ? { apiKey } : {}), ...(merged ? { endpoint: merged } : {}) };
+}
+/**
+ * BYOK is scoped to the CALLER'S provider: the key a client sends
+ * authenticates that client's own provider (typically Gemini). Passing it to
+ * a different provider's adapter would override the server's env key
+ * (adapters prefer a passed key), fail auth, and hand the key to another
+ * vendor — e.g. a Gemini key sent to xAI. Cross-provider models therefore
+ * resolve keys from server env.
+ */
+export function scopedKey(model, apiKey, keyProvider) {
+    return providerForModel(model) === keyProvider ? apiKey : undefined;
+}
+/** A provider name as the A2A X-Provider header gives it; anything unknown reads as gemini. */
+export function normalizeProvider(provider) {
+    const p = provider?.toLowerCase();
+    if (p === 'ollama' || p === 'anthropic' || p === 'openai' || p === 'xai' || p === 'moonshot') {
+        return p;
+    }
+    return 'gemini';
+}
+/** GEMINI_ADAPTER as set (`adk` or `engine`), or undefined when unset. Any other value is a configuration error. */
+export function geminiAdapterSetting(env = process.env) {
+    const raw = env.GEMINI_ADAPTER?.trim().toLowerCase();
+    if (!raw)
+        return undefined;
+    if (raw === 'adk' || raw === 'engine')
+        return raw;
+    throw new Error('GEMINI_ADAPTER must be "adk" or "engine".');
+}
+/** Each non-Gemini provider's contract adapter for a direct route. */
+const CONTRACT_ADAPTER = {
+    ollama: (r) => new OllamaAdapter({ model: r.model }),
+    anthropic: (r) => new ClaudeAdapter({ model: r.model, apiKey: r.apiKey, endpoint: r.endpoint }),
+    openai: (r) => new GptAdapter({ model: r.model, apiKey: r.apiKey, endpoint: r.endpoint }),
+    xai: (r) => new GrokAdapter({ model: r.model, apiKey: r.apiKey }),
+    moonshot: (r) => new KimiAdapter({ model: r.model, apiKey: r.apiKey, baseUrl: r.endpoint?.baseURL }),
+};
+/**
+ * A resolver over the one prefix table. With `adkGemini`, a Gemini id gets
+ * AdkGeminiAdapter unless `engine` is asked for (ADR 0060). Without it, a
+ * Gemini id gets GeminiAdapter, and asking for `adk` throws (ADR 0068).
+ */
+export function adapterResolver(adkGemini) {
+    const geminiFor = (r, choice) => {
+        const route = { model: r.model, apiKey: r.apiKey, endpoint: r.endpoint };
+        if (choice === 'engine')
+            return new GeminiAdapter(route);
+        if (!adkGemini) {
+            throw new Error('The ADK Gemini adapter is not available from melchizedek-agents/model, which loads no @google/adk. ' +
+                'Use gemini: "engine" (or unset GEMINI_ADAPTER), or resolve through melchizedek-agents/models/registry.');
+        }
+        return adkGemini(route);
+    };
+    function resolveAdapter(modelId, options = {}) {
+        const keyProvider = options.keyProvider === undefined ? providerForModel(modelId) : normalizeProvider(options.keyProvider);
+        const route = routeFor(modelId, scopedKey(modelId, options.apiKey, keyProvider), options.endpoint);
+        if (route.transport === 'gateway')
+            return new GatewayAdapter({ model: modelId });
+        if (route.provider === 'gemini') {
+            return geminiFor(route, options.gemini ?? geminiAdapterSetting() ?? (adkGemini ? 'adk' : 'engine'));
+        }
+        return CONTRACT_ADAPTER[route.provider](route);
+    }
+    function resolveAdapterWithFallback(modelId, fallbackId, options = {}, fallbackOptions = {}) {
+        const scoped = { ...options, keyProvider: options.keyProvider ?? providerForModel(modelId) };
+        const primary = resolveAdapter(modelId, scoped);
+        if (!fallbackId)
+            return primary;
+        return new FallbackAdapter(primary, resolveAdapter(fallbackId, scoped), fallbackOptions);
+    }
+    return { resolveAdapter, resolveAdapterWithFallback };
+}
+const ADK_FREE = adapterResolver();
+/**
+ * Resolves a model id to the engine's own ModelAdapter (ADR 0048), from the
+ * prefix table and the transport rule resolveModel uses, with no ADK: the
+ * provider's adapter when its key (env, BYOK or endpoint) is present, the
+ * gateway's when it is absent and MODEL_GATEWAY is set. A Gemini id gets
+ * GeminiAdapter (ADR 0068). The adapter opens no span and charges nothing:
+ * its caller does (ADR 0053).
+ */
+export function resolveAdapter(modelId, options = {}) {
+    return ADK_FREE.resolveAdapter(modelId, options);
+}
+/**
+ * An agent's model and its `fallback_model:`: a FallbackAdapter (ADR 0044)
+ * around resolveAdapter's two adapters, or the primary alone. The caller's
+ * key stays with its own provider: unless `keyProvider` says otherwise it
+ * belongs to the primary's, so a fallback on another provider resolves from
+ * server env.
+ */
+export function resolveAdapterWithFallback(modelId, fallbackId, options = {}, fallbackOptions = {}) {
+    return ADK_FREE.resolveAdapterWithFallback(modelId, fallbackId, options, fallbackOptions);
+}

package/dist/lib/models/adkGeminiAdapter.d.ts

@@ -0,0 +1,90 @@
+/**
+ * lib/models/adkGeminiAdapter.ts — TEMPORARY: Gemini as a contract
+ * ModelAdapter (ADR 0048) over ADK's own Gemini, the TracedGemini path of
+ * lib/models/tracedGemini.ts, through the genai mapping (lib/models/genaiMapping.ts).
+ *
+ * WHY this file exists:
+ *   The native loop (ADR 0045) calls ModelAdapters only. The engine's own
+ *   Gemini adapter (lib/models/geminiAdapter.ts) calls @google/genai with no
+ *   ADK, and waits for its live parity run at gate G3. Until it passes,
+ *   Gemini on the native runtime goes through ADK's proven Gemini, wrapped
+ *   here, so every provider has a contract adapter before gate G1. Delete
+ *   this file once G3 is signed and GeminiAdapter serves every Gemini id
+ *   (the plan's G3 risk: "The WS1-8 wrapper over ADK's Gemini stays until
+ *   the cells pass"). resolveAdapter (lib/models/registry.ts) returns it for Gemini ids.
+ *
+ * THE CALL:
+ *   1. The ModelRequest becomes an LlmRequest (modelRequestToLlmRequest),
+ *      and then what ADK's path does to one before its Gemini sees it:
+ *        - system messages joined onto the system prompt, in order, since
+ *          Gemini takes no `system` content;
+ *        - `adk-` call ids taken off calls and results, as ADK's flow does
+ *          before every model call (ids the mapping minted are already off);
+ *        - `includeServerSideToolInvocations`, which the compiler sends on
+ *          every Gemini agent (lib/compile.ts);
+ *        - `includeThoughts` under any reasoning but `none`, the contract's
+ *          Gemini table, as GeminiAdapter sends it;
+ *        - the platform's wire model (GEMINI_MODEL_MAP), as TracedGemini's own.
+ *      The request is copied where ADK writes to it (a blob's display name),
+ *      so the caller's history is never changed.
+ *   2. TracedGemini.generateWithRetries runs it: ADK's Gemini with the
+ *      shared retries, tagging the span that is open around this adapter
+ *      (llm.web_search.native, llm.retries, llm.http_status), as it tags its
+ *      own. `llm.capability.dropped` marks native tools Gemini has none for.
+ *   3. Each LlmResponse comes back through llmResponseToModelResponse,
+ *      folded into the contract's stream. A thought signature becomes
+ *      providerState naming the request's model. A call Gemini returns
+ *      without an id gets the mapping's `genai-noid-<position>-<part>`, or,
+ *      streamed, ADK's own `adk-` id; neither goes back on the wire.
+ *
+ * REPLAY: every Gemini signature in the history goes back on its part, as
+ * ADK sends a stored session's, whichever turn or model wrote it.
+ * GeminiAdapter replays only the current turn's, for its own model.
+ *
+ * THE SPAN AND THE CHARGE are the caller's (ADR 0053): this adapter opens no
+ * llm.request span and never charges the turn. Behind the ADK shim
+ * (lib/models/adkShim.ts) it records the span TracedGemini records today for
+ * the same exchange, but for a failed call's code (tests/telemetryLedger.test.ts).
+ *
+ * THE ADAPTER RULES (contract.ts header) as this adapter keeps them:
+ *   - Partials: a streamed call's text and thinking deltas, as ADK's stream
+ *     aggregator yields them. A call that does not stream yields its
+ *     thinking as one partial before the final.
+ *   - One final: every non-partial response ADK yields for the call (its
+ *     aggregator flushes the text before each tool call) folds into it, with
+ *     the last usage, grounding and finish reason.
+ *   - Errors are finals, never throws. ADK's Gemini throws on a failed call:
+ *     that is GEMINI_ERROR, `retryable` from lib/models/retry.ts's
+ *     classifyError, `status` when the error had one. An error code ADK
+ *     yields (a finish or block reason) is the code, not retryable; ADK's
+ *     `STOP` is no error. Setup failures are MISSING_API_KEY and
+ *     ENDPOINT_MISCONFIGURED, as GeminiAdapter's.
+ *   - The abort: `request.signal` (the shim aborts it when the turn stops)
+ *     goes on the request config. An aborted call is GEMINI_ERROR, never
+ *     retryable, and the iteration ends at once whatever the transport does;
+ *     a signal aborted before the call sends nothing.
+ *   - Retries: TracedGemini's, only before the first chunk.
+ *   - Messages never carry the key in use or anything shaped like a key.
+ */
+import type { ModelAdapter, ModelRequest, ModelResponse } from './contract.ts';
+import type { ProviderEndpoint } from './endpoints.ts';
+export interface AdkGeminiAdapterOptions {
+    /** The model id as the YAML names it. */
+    model: string;
+    /**
+     * A Gemini API (AI Studio) key: a caller's own, or one the credentials plug
+     * point returned. It wins over the endpoint's and the environment's, and is
+     * never sent to Vertex AI.
+     */
+    apiKey?: string;
+    /** Where requests go (ADR 0023). Default: `endpointFromEnv('gemini')`, read on the first call. */
+    endpoint?: ProviderEndpoint;
+}
+/** Temporary: ADK's Gemini behind the model contract, until GeminiAdapter passes gate G3. */
+export declare class AdkGeminiAdapter implements ModelAdapter {
+    #private;
+    readonly provider = "gemini";
+    readonly model: string;
+    constructor(options: AdkGeminiAdapterOptions);
+    generate(request: ModelRequest): AsyncGenerator<ModelResponse, void>;
+}