melchizedek-agents 1.0.0 → 1.0.2

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

@@ -1,50 +0,0 @@
-/**
- * lib/models/grokLlm.ts — xAI Grok for ADK's LLMRegistry: GptLlm (the ADK
- * shim around a Responses adapter) built on GrokAdapter
- * (lib/models/grokAdapter.ts).
- *
- * WHY this file exists:
- *   Model optionality is a primary driver of this framework: the agent YAML
- *   declares `model`, and the registry routes it to the right provider.
- *   xAI's Agent Tools API is wire-compatible with OpenAI's Responses API, so
- *   GrokAdapter extends GptAdapter and overrides only the vendor hooks
- *   (endpoint, key, timeout, reasoning effort, native tools), and GrokLlm
- *   extends GptLlm, which keeps the ADK path's usage meaning and
- *   server-side tool record (ADR 0056). Grok gets:
- *     - native web_search (server-side, with source citations)
- *     - x_search (live X posts) and collections_search (hosted document
- *       stores via the file_search wire shape — see collectionsSearchTool.ts)
- *     - reasoning summaries surfaced as { thought: true } THINKING output
- *     - reasoning carried across a tool loop on grok-4.5, 4.6 and 4.7
- *       (encrypted reasoning items as providerState, store: false — ADR 0050)
- *     - SSE streaming (ADK RunConfig streamingMode: SSE → partial deltas)
- *     - structured outputs (YAML outputSchema → text.format json_schema)
- *     - function tools with call_id round-tripping, lowercase schemas
- *
- * HOW TO ENABLE:
- *   1. Add your API key to .env as XAI_API_KEY (console.x.ai — paid).
- *   2. Set model: "grok-4.7" (or any grok-* id) in your YAML.
- *   registerAvailableProviders() registers this adapter when the key is set.
- *   grok-4.5, 4.6 and 4.7 requests carry reasoning effort 'medium' unless the
- *   agent sets `reasoning:` — DEFAULT_GROK_REASONING_EFFORT (lib/config.ts).
- *
- * API-DRIFT NOTE: every xAI-specific choice is confined to GrokAdapter's
- * overrides, so upstream drift stays a one-file fix. xAI's Responses endpoint
- * reports the serving backend in the response `model` field (e.g.
- * "grok-4.3"), which may differ from the requested id; invalid ids are
- * rejected with "Model not found".
- */
-import { GptLlm } from './gptLlm.ts';
-import type { GptLlmOptions } from './gptLlm.ts';
-import { GrokAdapter } from './grokAdapter.ts';
-export { DEFAULT_GROK_TIMEOUT_MS, grokTimeoutMs } from './grokAdapter.ts';
-export declare class GrokLlm extends GptLlm {
-    /** Any model: "grok-*" in a YAML config routes here after registration. */
-    static readonly supportedModels: Array<string | RegExp>;
-    protected static createAdapter(options: GptLlmOptions): GrokAdapter;
-}
-/**
- * Registers GrokLlm with the ADK LLMRegistry. Called by
- * registerAvailableProviders() when XAI_API_KEY is present.
- */
-export declare function registerGrokLlm(): void;

package/dist/lib/models/grokLlm.js

@@ -1,56 +0,0 @@
-/**
- * lib/models/grokLlm.ts — xAI Grok for ADK's LLMRegistry: GptLlm (the ADK
- * shim around a Responses adapter) built on GrokAdapter
- * (lib/models/grokAdapter.ts).
- *
- * WHY this file exists:
- *   Model optionality is a primary driver of this framework: the agent YAML
- *   declares `model`, and the registry routes it to the right provider.
- *   xAI's Agent Tools API is wire-compatible with OpenAI's Responses API, so
- *   GrokAdapter extends GptAdapter and overrides only the vendor hooks
- *   (endpoint, key, timeout, reasoning effort, native tools), and GrokLlm
- *   extends GptLlm, which keeps the ADK path's usage meaning and
- *   server-side tool record (ADR 0056). Grok gets:
- *     - native web_search (server-side, with source citations)
- *     - x_search (live X posts) and collections_search (hosted document
- *       stores via the file_search wire shape — see collectionsSearchTool.ts)
- *     - reasoning summaries surfaced as { thought: true } THINKING output
- *     - reasoning carried across a tool loop on grok-4.5, 4.6 and 4.7
- *       (encrypted reasoning items as providerState, store: false — ADR 0050)
- *     - SSE streaming (ADK RunConfig streamingMode: SSE → partial deltas)
- *     - structured outputs (YAML outputSchema → text.format json_schema)
- *     - function tools with call_id round-tripping, lowercase schemas
- *
- * HOW TO ENABLE:
- *   1. Add your API key to .env as XAI_API_KEY (console.x.ai — paid).
- *   2. Set model: "grok-4.7" (or any grok-* id) in your YAML.
- *   registerAvailableProviders() registers this adapter when the key is set.
- *   grok-4.5, 4.6 and 4.7 requests carry reasoning effort 'medium' unless the
- *   agent sets `reasoning:` — DEFAULT_GROK_REASONING_EFFORT (lib/config.ts).
- *
- * API-DRIFT NOTE: every xAI-specific choice is confined to GrokAdapter's
- * overrides, so upstream drift stays a one-file fix. xAI's Responses endpoint
- * reports the serving backend in the response `model` field (e.g.
- * "grok-4.3"), which may differ from the requested id; invalid ids are
- * rejected with "Model not found".
- */
-import { requireAdk } from '../adkPeer.js';
-import { GptLlm } from './gptLlm.js';
-import { GrokAdapter } from './grokAdapter.js';
-export { DEFAULT_GROK_TIMEOUT_MS, grokTimeoutMs } from './grokAdapter.js';
-// ── GrokLlm ───────────────────────────────────────────────────────────────────
-export class GrokLlm extends GptLlm {
-    /** Any model: "grok-*" in a YAML config routes here after registration. */
-    static supportedModels = [/^grok-.+/];
-    static createAdapter(options) {
-        return new GrokAdapter(options);
-    }
-}
-// ── Registration helper ───────────────────────────────────────────────────────
-/**
- * Registers GrokLlm with the ADK LLMRegistry. Called by
- * registerAvailableProviders() when XAI_API_KEY is present.
- */
-export function registerGrokLlm() {
-    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(GrokLlm);
-}

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

@@ -1,31 +0,0 @@
-/**
- * lib/models/kimiLlm.ts — Moonshot AI (Kimi), as an ADK BaseLlm for the
- * LLMRegistry.
- *
- * WHY this file exists:
- *   The provider's work is KimiAdapter (lib/models/kimiAdapter.ts), on the
- *   engine's own model contract; its header covers the family, cost, the
- *   reasoning controls per generation, and reasoning_content on tool loops
- *   (ADR 0046). ADK still runs every turn, so this class runs the adapter
- *   under ADK: it is the chat-completions shim
- *   (lib/models/openAiCompatibleLlm.ts, ADR 0057), registered for any
- *   `kimi-*` id when MOONSHOT_API_KEY is set. The constructor and
- *   supportedModels are what they were before the adapter moved onto the
- *   contract, so lib/models/registry.ts and every caller are unchanged. On
- *   this path an agent's older spelling `reasoningEffort: max` still reaches
- *   K3, which the contract has no level for.
- */
-import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.ts';
-export { MOONSHOT_BASE_URL, isKimiK3, wantsReasoningReplay } from './kimiAdapter.ts';
-export declare class KimiLlm extends OpenAiCompatibleLlm {
-    /** Any model: "kimi-*" in a YAML config routes here after registration. */
-    static readonly supportedModels: Array<string | RegExp>;
-    /** `apiKey` defaults to MOONSHOT_API_KEY; `baseUrl` to MOONSHOT_BASE_URL, else https://api.moonshot.ai/v1. */
-    constructor({ model, apiKey, baseUrl }: {
-        model: string;
-        apiKey?: string;
-        baseUrl?: string;
-    });
-}
-/** Registers KimiLlm with the ADK LLMRegistry (called when MOONSHOT_API_KEY is set). */
-export declare function registerKimiLlm(): void;

package/dist/lib/models/kimiLlm.js

@@ -1,35 +0,0 @@
-/**
- * lib/models/kimiLlm.ts — Moonshot AI (Kimi), as an ADK BaseLlm for the
- * LLMRegistry.
- *
- * WHY this file exists:
- *   The provider's work is KimiAdapter (lib/models/kimiAdapter.ts), on the
- *   engine's own model contract; its header covers the family, cost, the
- *   reasoning controls per generation, and reasoning_content on tool loops
- *   (ADR 0046). ADK still runs every turn, so this class runs the adapter
- *   under ADK: it is the chat-completions shim
- *   (lib/models/openAiCompatibleLlm.ts, ADR 0057), registered for any
- *   `kimi-*` id when MOONSHOT_API_KEY is set. The constructor and
- *   supportedModels are what they were before the adapter moved onto the
- *   contract, so lib/models/registry.ts and every caller are unchanged. On
- *   this path an agent's older spelling `reasoningEffort: max` still reaches
- *   K3, which the contract has no level for.
- */
-import { requireAdk } from '../adkPeer.js';
-import { KimiAdapter } from './kimiAdapter.js';
-import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.js';
-export { MOONSHOT_BASE_URL, isKimiK3, wantsReasoningReplay } from './kimiAdapter.js';
-// ── KimiLlm ───────────────────────────────────────────────────────────────────
-export class KimiLlm extends OpenAiCompatibleLlm {
-    /** Any model: "kimi-*" in a YAML config routes here after registration. */
-    static supportedModels = [/^kimi-.+/];
-    /** `apiKey` defaults to MOONSHOT_API_KEY; `baseUrl` to MOONSHOT_BASE_URL, else https://api.moonshot.ai/v1. */
-    constructor({ model, apiKey, baseUrl }) {
-        super(new KimiAdapter({ model, apiKey, baseUrl }), { model });
-    }
-}
-// ── Registration helper ───────────────────────────────────────────────────────
-/** Registers KimiLlm with the ADK LLMRegistry (called when MOONSHOT_API_KEY is set). */
-export function registerKimiLlm() {
-    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(KimiLlm);
-}

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

@@ -1,37 +0,0 @@
-/**
- * lib/models/ollamaLlm.ts — open-weight / local models served by Ollama, as
- * an ADK BaseLlm for the LLMRegistry.
- *
- * WHY this file exists:
- *   The provider's work is OllamaAdapter (lib/models/ollamaAdapter.ts), on
- *   the engine's own model contract; its header says how to install Ollama,
- *   which model to pull, and what a local model cannot do. ADK still runs
- *   every turn, so this class runs the adapter under ADK: it is the
- *   chat-completions shim (lib/models/openAiCompatibleLlm.ts, ADR 0057),
- *   registered for any `ollama/<model>` id. The constructor and
- *   supportedModels are what they were before the adapter moved onto the
- *   contract, so lib/models/registry.ts and every caller are unchanged.
- */
-import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.ts';
-export declare class OllamaLlm extends OpenAiCompatibleLlm {
-    /**
-     * Model ids namespaced "ollama/<model>" route here after registration,
-     * e.g. model: "ollama/qwen3:8b" in a syndicate YAML.
-     */
-    static readonly supportedModels: Array<string | RegExp>;
-    /** `baseUrl` defaults to OLLAMA_BASE_URL, else http://localhost:11434/v1. */
-    constructor({ model, baseUrl }: {
-        model: string;
-        baseUrl?: string;
-    });
-}
-/**
- * Registers OllamaLlm with the ADK LLMRegistry.
- *
- * Unlike registerClaudeLlm(), this needs no key gate — a local provider has
- * no credential to check. Registration is still explicit (not at import
- * time) so entrypoints stay in control of which providers are active.
- * If Ollama isn't running, agents fail at call time with a clear
- * OLLAMA_UNREACHABLE message that says how to start it.
- */
-export declare function registerOllamaLlm(): void;

package/dist/lib/models/ollamaLlm.js

@@ -1,42 +0,0 @@
-/**
- * lib/models/ollamaLlm.ts — open-weight / local models served by Ollama, as
- * an ADK BaseLlm for the LLMRegistry.
- *
- * WHY this file exists:
- *   The provider's work is OllamaAdapter (lib/models/ollamaAdapter.ts), on
- *   the engine's own model contract; its header says how to install Ollama,
- *   which model to pull, and what a local model cannot do. ADK still runs
- *   every turn, so this class runs the adapter under ADK: it is the
- *   chat-completions shim (lib/models/openAiCompatibleLlm.ts, ADR 0057),
- *   registered for any `ollama/<model>` id. The constructor and
- *   supportedModels are what they were before the adapter moved onto the
- *   contract, so lib/models/registry.ts and every caller are unchanged.
- */
-import { requireAdk } from '../adkPeer.js';
-import { OllamaAdapter } from './ollamaAdapter.js';
-import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.js';
-// ── OllamaLlm ─────────────────────────────────────────────────────────────────
-export class OllamaLlm extends OpenAiCompatibleLlm {
-    /**
-     * Model ids namespaced "ollama/<model>" route here after registration,
-     * e.g. model: "ollama/qwen3:8b" in a syndicate YAML.
-     */
-    static supportedModels = [/^ollama\/.+/];
-    /** `baseUrl` defaults to OLLAMA_BASE_URL, else http://localhost:11434/v1. */
-    constructor({ model, baseUrl }) {
-        super(new OllamaAdapter({ model, baseUrl }), { model });
-    }
-}
-// ── Registration helper ───────────────────────────────────────────────────────
-/**
- * Registers OllamaLlm with the ADK LLMRegistry.
- *
- * Unlike registerClaudeLlm(), this needs no key gate — a local provider has
- * no credential to check. Registration is still explicit (not at import
- * time) so entrypoints stay in control of which providers are active.
- * If Ollama isn't running, agents fail at call time with a clear
- * OLLAMA_UNREACHABLE message that says how to start it.
- */
-export function registerOllamaLlm() {
-    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(OllamaLlm);
-}

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

@@ -1,96 +0,0 @@
-/**
- * lib/models/openAiCompatibleLlm.ts — the ADK shim base for every
- * chat-completions adapter (Ollama, Kimi, the gateway).
- *
- * WHY this file exists:
- *   The chat-completions translation lives on the engine's own model
- *   contract, in lib/models/chatCompletionsAdapter.ts and one adapter per
- *   provider (ollamaAdapter.ts, kimiAdapter.ts, gatewayAdapter.ts). ADK
- *   still runs every turn (ADR 0045), so each adapter runs behind an ADK
- *   BaseLlm: OllamaLlm, KimiLlm and GatewayLlm, subclasses of this class,
- *   which is an AdkShim (lib/models/adkShim.ts, ADR 0053). The shim charges
- *   the turn, opens the llm.request span and maps the request and responses;
- *   the adapter does the provider's work.
- *
- * WHAT THIS CLASS ADDS TO THE SHIM (ADR 0057): the ADK path stays what it
- * was before the adapters moved onto the contract.
- *   - The request: an agent's older generateContentConfig spelling that the
- *     contract leaves out rides beside it (olderSpellingOf): an effort word
- *     that is no contract level (Kimi K3's `max`). JSON mode without a
- *     schema is the contract's `outputFormat` (ADR 0061).
- *   - The response: the final keeps the shape these classes always yielded,
- *     which the ledger and FallbackLlm read. usageMetadata counts the
- *     reasoning inside candidatesTokenCount, as the provider's
- *     completion_tokens does, so llm.tokens.output and the turn's charge are
- *     unchanged (the shim's default is Gemini's meaning, which excludes it).
- *     finishReason is set only for a reply cut short (MAX_TOKENS); a final
- *     with no parts keeps its empty content; an HTTP failure keeps its
- *     top-level `status` and `retryable` beside the verdict in
- *     customMetadata.
- *
- * A /chat/completions provider of your own is a ChatCompletionsAdapter
- * subclass (the endpoint, headers, wire name, reasoning field and error
- * wording), run under ADK as `adkShim(adapter)` or as a subclass of this
- * class.
- */
-import type { GenerateContentConfig } from '@google/genai';
-import type { LlmRequest, LlmResponse } from '@google/adk';
-import { AdkShim } from './adkShim.ts';
-import type { AdkShimOptions } from './adkShim.ts';
-import type { ModelResponse, Usage } from './contract.ts';
-import type { ModelRequestOptions } from './genaiMapping.ts';
-import type { ChatCompletionsAdapter, ChatCompletionsRequest, ChatMessage, OlderSpelling } from './chatCompletionsAdapter.ts';
-export { REASONING_CONTENT_KIND, splitThinkBlocks, ThinkStreamSplitter } from './chatCompletionsAdapter.ts';
-/**
- * What a generateContentConfig asks of a chat-completions provider that the
- * contract has no field for, or undefined when it asks nothing more:
- * `reasoningEffort` when it is a word no ReasoningSetting carries (`max`,
- * `xhigh`), sent as written. JSON mode without a schema is no longer here:
- * the genai mapping reads it as `outputFormat: 'json'` (ADR 0061).
- */
-export declare function olderSpellingOf(config: GenerateContentConfig | undefined): OlderSpelling | undefined;
-/**
- * Usage as the chat-completions classes have always reported it on the ADK
- * path: candidatesTokenCount is the provider's completion_tokens, reasoning
- * included, and thoughtsTokenCount the reasoning part of it.
- */
-export declare function chatUsageMetadata(usage: Usage): NonNullable<LlmResponse['usageMetadata']>;
-export declare abstract class OpenAiCompatibleLlm extends AdkShim {
-    readonly adapter: ChatCompletionsAdapter;
-    constructor(adapter: ChatCompletionsAdapter, options?: AdkShimOptions);
-    /** Provider id for telemetry: the adapter's (a gateway reports the upstream provider). */
-    protected providerId(): string;
-    /** How the request reaches the provider: 'direct' or 'gateway:<id>' (llm.transport). */
-    protected transport(): string;
-    /** The chat messages the adapter sends for this LlmRequest. */
-    protected buildMessages(llmRequest: LlmRequest): ChatMessage[];
-    /** The function tools the adapter sends for this LlmRequest (lowercase schemas). */
-    protected buildTools(llmRequest: LlmRequest): unknown[];
-    /** The genai mapping's request, with the older spelling the contract leaves out. */
-    protected toModelRequest(llmRequest: LlmRequest, options: ModelRequestOptions): ChatCompletionsRequest;
-    /** The genai mapping's response, in the shape these classes have always yielded (see the header). */
-    protected toLlmResponse(response: ModelResponse): LlmResponse;
-}
-/**
- * Stamps an HTTP error response with its numeric status and whether that
- * status is transient, and the same verdict in customMetadata
- * ('error.retryable', 'error.status'), where FallbackLlm reads it
- * (lib/models/errorResponse.ts). The chat-completions shims take these
- * fields from their adapter's error final instead (toLlmResponse).
- */
-export declare function withHttpStatus(resp: LlmResponse, status: number): LlmResponse;
-type GenaiUsage = NonNullable<ReturnType<typeof mapUsage>>;
-/** Two genai usage records summed, field by field. */
-export declare function addUsage(a: GenaiUsage | undefined, b: GenaiUsage | undefined): GenaiUsage | undefined;
-/**
- * OpenAI-style usage → GenAI usageMetadata in the ADK-path meaning
- * (completion_tokens, reasoning included, as candidatesTokenCount), or
- * undefined when absent. The contract's meaning is chatUsage in
- * lib/models/chatCompletionsAdapter.ts.
- */
-export declare function mapUsage(usage: any): {
-    promptTokenCount?: number;
-    candidatesTokenCount?: number;
-    thoughtsTokenCount?: number;
-    totalTokenCount?: number;
-} | undefined;

package/dist/lib/models/openAiCompatibleLlm.js

@@ -1,156 +0,0 @@
-/**
- * lib/models/openAiCompatibleLlm.ts — the ADK shim base for every
- * chat-completions adapter (Ollama, Kimi, the gateway).
- *
- * WHY this file exists:
- *   The chat-completions translation lives on the engine's own model
- *   contract, in lib/models/chatCompletionsAdapter.ts and one adapter per
- *   provider (ollamaAdapter.ts, kimiAdapter.ts, gatewayAdapter.ts). ADK
- *   still runs every turn (ADR 0045), so each adapter runs behind an ADK
- *   BaseLlm: OllamaLlm, KimiLlm and GatewayLlm, subclasses of this class,
- *   which is an AdkShim (lib/models/adkShim.ts, ADR 0053). The shim charges
- *   the turn, opens the llm.request span and maps the request and responses;
- *   the adapter does the provider's work.
- *
- * WHAT THIS CLASS ADDS TO THE SHIM (ADR 0057): the ADK path stays what it
- * was before the adapters moved onto the contract.
- *   - The request: an agent's older generateContentConfig spelling that the
- *     contract leaves out rides beside it (olderSpellingOf): an effort word
- *     that is no contract level (Kimi K3's `max`). JSON mode without a
- *     schema is the contract's `outputFormat` (ADR 0061).
- *   - The response: the final keeps the shape these classes always yielded,
- *     which the ledger and FallbackLlm read. usageMetadata counts the
- *     reasoning inside candidatesTokenCount, as the provider's
- *     completion_tokens does, so llm.tokens.output and the turn's charge are
- *     unchanged (the shim's default is Gemini's meaning, which excludes it).
- *     finishReason is set only for a reply cut short (MAX_TOKENS); a final
- *     with no parts keeps its empty content; an HTTP failure keeps its
- *     top-level `status` and `retryable` beside the verdict in
- *     customMetadata.
- *
- * A /chat/completions provider of your own is a ChatCompletionsAdapter
- * subclass (the endpoint, headers, wire name, reasoning field and error
- * wording), run under ADK as `adkShim(adapter)` or as a subclass of this
- * class.
- */
-import { FinishReason } from '@google/genai';
-import { AdkShim } from './adkShim.js';
-import { setLlmSpanAttribute } from '../observability/tracer.js';
-import { isRetryableStatus } from './retry.js';
-import { statusDecision, withRetryVerdict } from './errorResponse.js';
-export { REASONING_CONTENT_KIND, splitThinkBlocks, ThinkStreamSplitter } from './chatCompletionsAdapter.js';
-/** The effort words a contract ReasoningSetting carries (genaiMapping's reasoningOf); any other rides as the older spelling. */
-const CONTRACT_EFFORT_WORDS = new Set(['none', 'minimal', 'low', 'medium', 'high']);
-/**
- * What a generateContentConfig asks of a chat-completions provider that the
- * contract has no field for, or undefined when it asks nothing more:
- * `reasoningEffort` when it is a word no ReasoningSetting carries (`max`,
- * `xhigh`), sent as written. JSON mode without a schema is no longer here:
- * the genai mapping reads it as `outputFormat: 'json'` (ADR 0061).
- */
-export function olderSpellingOf(config) {
-    const cfg = (config ?? {});
-    const out = {};
-    const effort = cfg.reasoningEffort;
-    if (typeof effort === 'string' && !CONTRACT_EFFORT_WORDS.has(effort))
-        out.reasoningEffort = effort;
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-/**
- * Usage as the chat-completions classes have always reported it on the ADK
- * path: candidatesTokenCount is the provider's completion_tokens, reasoning
- * included, and thoughtsTokenCount the reasoning part of it.
- */
-export function chatUsageMetadata(usage) {
-    return {
-        promptTokenCount: usage.inputTokens,
-        candidatesTokenCount: usage.outputTokens,
-        ...(usage.thinkingTokens !== undefined ? { thoughtsTokenCount: usage.thinkingTokens } : {}),
-        totalTokenCount: usage.inputTokens + usage.outputTokens,
-    };
-}
-// ── OpenAiCompatibleLlm ──────────────────────────────────────────────────────
-export class OpenAiCompatibleLlm extends AdkShim {
-    constructor(adapter, options = {}) {
-        super(adapter, options);
-    }
-    /** Provider id for telemetry: the adapter's (a gateway reports the upstream provider). */
-    providerId() {
-        return this.adapter.provider;
-    }
-    /** How the request reaches the provider: 'direct' or 'gateway:<id>' (llm.transport). */
-    transport() {
-        return this.adapter.transport();
-    }
-    /** The chat messages the adapter sends for this LlmRequest. */
-    buildMessages(llmRequest) {
-        return this.adapter.messagesFor(this.toModelRequest(llmRequest, { model: this.model }));
-    }
-    /** The function tools the adapter sends for this LlmRequest (lowercase schemas). */
-    buildTools(llmRequest) {
-        return this.adapter.toolsFor(this.toModelRequest(llmRequest, { model: this.model }));
-    }
-    /** The genai mapping's request, with the older spelling the contract leaves out. */
-    toModelRequest(llmRequest, options) {
-        const request = super.toModelRequest(llmRequest, options);
-        const olderSpelling = olderSpellingOf(llmRequest.config);
-        return olderSpelling ? { ...request, olderSpelling } : request;
-    }
-    /** The genai mapping's response, in the shape these classes have always yielded (see the header). */
-    toLlmResponse(response) {
-        const mapped = super.toLlmResponse(response);
-        if (response.partial)
-            return mapped;
-        const { finishReason: _finish, usageMetadata: _usage, ...rest } = mapped;
-        const error = response.error;
-        return {
-            ...(error ? {} : { content: { role: 'model', parts: [] } }),
-            ...rest,
-            ...(!error && response.finishReason === 'max_tokens' ? { finishReason: FinishReason.MAX_TOKENS } : {}),
-            ...(response.usage ? { usageMetadata: chatUsageMetadata(response.usage) } : {}),
-            ...(error?.status !== undefined ? { status: error.status, retryable: error.retryable } : {}),
-        };
-    }
-}
-// ── Kept for callers of the ADK-path helpers ─────────────────────────────────
-/**
- * Stamps an HTTP error response with its numeric status and whether that
- * status is transient, and the same verdict in customMetadata
- * ('error.retryable', 'error.status'), where FallbackLlm reads it
- * (lib/models/errorResponse.ts). The chat-completions shims take these
- * fields from their adapter's error final instead (toLlmResponse).
- */
-export function withHttpStatus(resp, status) {
-    setLlmSpanAttribute('llm.http_status', status);
-    return { ...withRetryVerdict(resp, statusDecision(status)), status, retryable: isRetryableStatus(status) };
-}
-/** Two genai usage records summed, field by field. */
-export function addUsage(a, b) {
-    if (!a)
-        return b;
-    if (!b)
-        return a;
-    const out = {};
-    for (const k of ['promptTokenCount', 'candidatesTokenCount', 'thoughtsTokenCount', 'totalTokenCount']) {
-        if (a[k] !== undefined || b[k] !== undefined)
-            out[k] = (a[k] ?? 0) + (b[k] ?? 0);
-    }
-    return out;
-}
-/**
- * OpenAI-style usage → GenAI usageMetadata in the ADK-path meaning
- * (completion_tokens, reasoning included, as candidatesTokenCount), or
- * undefined when absent. The contract's meaning is chatUsage in
- * lib/models/chatCompletionsAdapter.ts.
- */
-export function mapUsage(usage) {
-    if (!usage || typeof usage !== 'object')
-        return undefined;
-    const reasoning = usage.completion_tokens_details?.reasoning_tokens;
-    return {
-        ...(usage.prompt_tokens !== undefined ? { promptTokenCount: usage.prompt_tokens } : {}),
-        ...(usage.completion_tokens !== undefined ? { candidatesTokenCount: usage.completion_tokens } : {}),
-        ...(reasoning !== undefined ? { thoughtsTokenCount: reasoning } : {}),
-        ...(usage.total_tokens !== undefined ? { totalTokenCount: usage.total_tokens } : {}),
-    };
-}

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

@@ -1,41 +0,0 @@
-/**
- * lib/models/tracedGemini.ts — ADK's built-in Gemini, wrapped so Gemini calls
- * emit the same per-request llm.request spans (tokens, latency) as every other
- * provider, and get the shared transient-failure retries (lib/models/retry.ts).
- *
- * WHY its own module: two modules use it. lib/models/registry.ts registers it
- * for every Gemini id on the ADK path and builds it in resolveModel, and the
- * temporary AdkGeminiAdapter (lib/models/adkGeminiAdapter.ts) runs its calls
- * through generateWithRetries. registry.ts also builds that adapter in
- * resolveAdapter, so the class living in registry.ts would be an ESM import
- * cycle. registry.ts re-exports it, so `TracedGemini` imports from there keep
- * working.
- */
-import { Gemini } from '../adkPeer.ts';
-import type { GeminiParams, LlmRequest, LlmResponse } from '@google/adk';
-import type { ProviderEndpoint } from './endpoints.ts';
-export declare class TracedGemini extends Gemini {
-    #private;
-    static readonly supportedModels: Array<string | RegExp>;
-    /**
-     * The Gemini platform (ADR 0023) applies to every construction, the
-     * LLMRegistry's included: on Vertex AI the client authenticates with
-     * Google Application Default Credentials for the configured project and
-     * location, and an AI Studio key (the environment's or a caller's) is not
-     * sent. `endpoint` overrides the environment's (the credentials plug point).
-     */
-    constructor(params?: GeminiParams & {
-        endpoint?: ProviderEndpoint;
-    });
-    generateContentAsync(llmRequest: LlmRequest, stream?: boolean, abortSignal?: AbortSignal): AsyncGenerator<LlmResponse, void>;
-    /**
-     * One call through ADK's Gemini with the shared retries, tagging whatever
-     * llm.request span is active (llm.web_search.native for Gemini grounding,
-     * llm.retries, llm.http_status). generateContentAsync opens that span
-     * around it; AdkGeminiAdapter (lib/models/adkGeminiAdapter.ts) runs it
-     * inside the span its own caller opens (ADR 0053). A failed call throws,
-     * as ADK's Gemini does. The abort signal is forwarded so a canceled turn stops the
-     * request in flight (ADK's Gemini puts it on the genai request config).
-     */
-    generateWithRetries(llmRequest: LlmRequest, stream?: boolean, abortSignal?: AbortSignal): AsyncGenerator<LlmResponse, void>;
-}

package/dist/lib/models/tracedGemini.js

@@ -1,98 +0,0 @@
-/**
- * lib/models/tracedGemini.ts — ADK's built-in Gemini, wrapped so Gemini calls
- * emit the same per-request llm.request spans (tokens, latency) as every other
- * provider, and get the shared transient-failure retries (lib/models/retry.ts).
- *
- * WHY its own module: two modules use it. lib/models/registry.ts registers it
- * for every Gemini id on the ADK path and builds it in resolveModel, and the
- * temporary AdkGeminiAdapter (lib/models/adkGeminiAdapter.ts) runs its calls
- * through generateWithRetries. registry.ts also builds that adapter in
- * resolveAdapter, so the class living in registry.ts would be an ESM import
- * cycle. registry.ts re-exports it, so `TracedGemini` imports from there keep
- * working.
- */
-import { Gemini } from '../adkPeer.js';
-import { endpointFromEnv, platformModel } from './endpoints.js';
-import { llmRequestToModelRequest } from './genaiMapping.js';
-import { errorStatus, retryUntilFirstYield } from './retry.js';
-import { setLlmSpanAttribute, traceLlmGeneration } from '../observability/tracer.js';
-import { currentTurnSignal } from '../runtime/turnControl.js';
-export class TracedGemini extends Gemini {
-    // CRITICAL: reuse Gemini's exact regex instances. The LLMRegistry dict is
-    // keyed by the regex OBJECT — registering the same instances REPLACES the
-    // built-in Gemini entries instead of adding shadowed duplicates.
-    static supportedModels = Gemini.supportedModels;
-    /**
-     * The Gemini platform (ADR 0023) applies to every construction, the
-     * LLMRegistry's included: on Vertex AI the client authenticates with
-     * Google Application Default Credentials for the configured project and
-     * location, and an AI Studio key (the environment's or a caller's) is not
-     * sent. `endpoint` overrides the environment's (the credentials plug point).
-     */
-    constructor(params = {}) {
-        const { endpoint: given, ...rest } = params;
-        const e = given ?? endpointFromEnv('gemini');
-        const model = rest.model ? platformModel(e, rest.model) : rest.model;
-        super(e.platform === 'vertex'
-            ? { ...rest, model, apiKey: e.apiKey, vertexai: true, project: e.project, location: e.location }
-            : { ...rest, model, ...(e.apiKey && !rest.apiKey ? { apiKey: e.apiKey } : {}) });
-        this.#vertex = e.platform === 'vertex';
-    }
-    /** True when the client runs on Vertex AI (ADR 0023). */
-    #vertex;
-    async *generateContentAsync(llmRequest, stream, abortSignal) {
-        yield* traceLlmGeneration({
-            provider: 'gemini',
-            model: this.model,
-            request: () => llmRequestToModelRequest(llmRequest, { model: llmRequest.model || this.model, stream }),
-        }, this.generateWithRetries(llmRequest, stream, abortSignal ?? currentTurnSignal()));
-    }
-    /**
-     * One call through ADK's Gemini with the shared retries, tagging whatever
-     * llm.request span is active (llm.web_search.native for Gemini grounding,
-     * llm.retries, llm.http_status). generateContentAsync opens that span
-     * around it; AdkGeminiAdapter (lib/models/adkGeminiAdapter.ts) runs it
-     * inside the span its own caller opens (ADR 0053). A failed call throws,
-     * as ADK's Gemini does. The abort signal is forwarded so a canceled turn stops the
-     * request in flight (ADK's Gemini puts it on the genai request config).
-     */
-    async *generateWithRetries(llmRequest, stream, abortSignal) {
-        // The compiler asks every agent's config for includeServerSideToolInvocations
-        // (lib/compile.ts), which the Gemini API needs beside function
-        // declarations. @google/genai refuses it on Vertex AI before any request
-        // is sent ("only supported in Gemini Developer API mode"), so on Vertex
-        // it is left off, and the call goes out as it did before the flag.
-        const toolConfig = llmRequest.config?.toolConfig;
-        if (this.#vertex && toolConfig && 'includeServerSideToolInvocations' in toolConfig) {
-            const { includeServerSideToolInvocations: _vertexRefuses, ...kept } = toolConfig;
-            llmRequest.config = { ...llmRequest.config, toolConfig: kept };
-        }
-        const hasGrounding = (llmRequest.config?.tools ?? []).some((t) => t && (t.googleSearch || t.googleSearchRetrieval));
-        if (hasGrounding)
-            setLlmSpanAttribute('llm.web_search.native', true);
-        // Retries live here, not in genai's own httpOptions.retryOptions: that
-        // hook (p-retry 4, client-level only) ignores the abort signal — it
-        // sleeps and re-sends after a canceled turn — honours no Retry-After,
-        // does not retry Node's "fetch failed" resets, and replaces a 4xx's
-        // error body (e.g. "API key not valid") with a bare statusText. Wrapping
-        // the call keeps genai's ApiError intact and applies the same policy as
-        // every other adapter. A retry is only made while nothing has been
-        // yielded, so a stream that fails mid-reply is surfaced, not replayed.
-        // ADK's request preprocessing is idempotent, so re-sending the same
-        // llmRequest is safe. The registry class, resolveModel()'s per-request
-        // instances and AdkGeminiAdapter's are all TracedGemini, so all get this.
-        try {
-            yield* retryUntilFirstYield(() => super.generateContentAsync(llmRequest, stream, abortSignal), {
-                signal: abortSignal,
-                onRetry: ({ retries }) => setLlmSpanAttribute('llm.retries', retries),
-            });
-        }
-        catch (err) {
-            // genai's ApiError carries the status; put it where the ledger reads.
-            const status = errorStatus(err);
-            if (status !== undefined)
-                setLlmSpanAttribute('llm.http_status', status);
-            throw err;
-        }
-    }
-}