melchizedek-agents 1.0.0 → 1.0.2

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

@@ -1,79 +0,0 @@
-/**
- * lib/models/claudeLlm.ts — Anthropic Claude for the ADK LLMRegistry: the
- * Claude adapter on the engine's contract (lib/models/claudeAdapter.ts)
- * behind the ADK shim (lib/models/adkShim.ts).
- *
- * WHY this file exists:
- *   ADK's TypeScript line ships only Gemini models, but it takes any BaseLlm
- *   subclass registered with LLMRegistry, keyed by model-name patterns, so
- *   once registered every LlmAgent with model: "claude-*" routes here. The
- *   translation to the Messages API lives in ClaudeAdapter, which reads a
- *   ModelRequest and yields ModelResponses (ADR 0048). This class is the
- *   shim around it: the shim maps ADK's LlmRequest in and each response
- *   back, charges the turn and opens the llm.request span (ADR 0053).
- *
- * HOW TO ENABLE:
- *   1. Install the Anthropic SDK:
- *        npm install @anthropic-ai/sdk
- *   2. Add your API key to .env:
- *        ANTHROPIC_API_KEY=sk-ant-...
- *   3. registerAvailableProviders() (lib/models/registry.ts) registers this
- *      class automatically when the key is set.
- *   4. Set model: "claude-sonnet-4-6" (or any claude-* id) in your YAML.
- *
- * WHAT THIS CLASS ADDS TO THE SHIM: the agent's older reasoning spelling.
- *   The compiler writes `reasoning:` as generateContentConfig.thinkingConfig
- *   and reasoningEffort (ADR 0047), and an agent may set those directly. The
- *   contract's `reasoning` cannot say all of what ADR 0049 reads from them
- *   (the effort words `xhigh` and `max`, `minimal` as `low`, the budget rows
- *   reading the budget alone), so this class hands the adapter that reading
- *   as `claudeReasoning` (ADR 0055). Everything else is the shim's mapping.
- *
- * What the adapter does (thinking by model generation, signed blocks
- * replayed within the tool loop, structured output, images, web search) is
- * described in its header and in wiki/models/claude-adapter.md.
- */
-import type { LlmRequest } from '@google/adk';
-import { AdkShim } from './adkShim.ts';
-import type { ClaudeModelRequest } from './claudeAdapter.ts';
-import type { ProviderEndpoint } from './endpoints.ts';
-import type { ModelRequestOptions } from './genaiMapping.ts';
-export { THINKING_STATE_KIND } from './claudeAdapter.ts';
-/**
- * The tool definitions ClaudeLlm sends for an LlmRequest's toolsDict, before
- * the platform is known: client tools with lowercase schemas, and the
- * web_search sentinel as Anthropic's native server tool (AnthropicTool, from
- * anthropicTools in lib/models/claudeAdapter.ts).
- */
-export declare function buildAnthropicTools(llmRequest: LlmRequest): any[];
-export declare class ClaudeLlm extends AdkShim {
-    /**
-     * Regex patterns that map model name strings to this provider.
-     * Any model: "claude-*" in a YAML config will route here after registration.
-     */
-    static readonly supportedModels: Array<string | RegExp>;
-    /**
-     * `apiKey`: a caller's own key, which wins over the endpoint's and
-     * ANTHROPIC_API_KEY. `endpoint` (ADR 0023): where the request goes —
-     * Anthropic's API (or a proxy at its base URL), Bedrock, or Vertex AI.
-     * Default: the environment's (`ANTHROPIC_PLATFORM`).
-     */
-    constructor({ model, apiKey, endpoint }: {
-        model: string;
-        apiKey?: string;
-        endpoint?: ProviderEndpoint;
-    });
-    /** The shim's ModelRequest, with the agent's older reasoning spelling read as ADR 0049 reads it (ADR 0055). */
-    protected toModelRequest(llmRequest: LlmRequest, options: ModelRequestOptions): ClaudeModelRequest;
-}
-/**
- * Registers ClaudeLlm with the ADK LLMRegistry.
- *
- * WHY a separate function instead of auto-registering at import time:
- *   Auto-registration at module load would cause every consumer of this file
- *   to unconditionally register Claude, even if ANTHROPIC_API_KEY is absent.
- *   By making registration explicit, registerAvailableProviders() can
- *   conditionally call this only when the key is present, and log a clear
- *   message about which provider is active.
- */
-export declare function registerClaudeLlm(): void;

package/dist/lib/models/claudeLlm.js

@@ -1,87 +0,0 @@
-/**
- * lib/models/claudeLlm.ts — Anthropic Claude for the ADK LLMRegistry: the
- * Claude adapter on the engine's contract (lib/models/claudeAdapter.ts)
- * behind the ADK shim (lib/models/adkShim.ts).
- *
- * WHY this file exists:
- *   ADK's TypeScript line ships only Gemini models, but it takes any BaseLlm
- *   subclass registered with LLMRegistry, keyed by model-name patterns, so
- *   once registered every LlmAgent with model: "claude-*" routes here. The
- *   translation to the Messages API lives in ClaudeAdapter, which reads a
- *   ModelRequest and yields ModelResponses (ADR 0048). This class is the
- *   shim around it: the shim maps ADK's LlmRequest in and each response
- *   back, charges the turn and opens the llm.request span (ADR 0053).
- *
- * HOW TO ENABLE:
- *   1. Install the Anthropic SDK:
- *        npm install @anthropic-ai/sdk
- *   2. Add your API key to .env:
- *        ANTHROPIC_API_KEY=sk-ant-...
- *   3. registerAvailableProviders() (lib/models/registry.ts) registers this
- *      class automatically when the key is set.
- *   4. Set model: "claude-sonnet-4-6" (or any claude-* id) in your YAML.
- *
- * WHAT THIS CLASS ADDS TO THE SHIM: the agent's older reasoning spelling.
- *   The compiler writes `reasoning:` as generateContentConfig.thinkingConfig
- *   and reasoningEffort (ADR 0047), and an agent may set those directly. The
- *   contract's `reasoning` cannot say all of what ADR 0049 reads from them
- *   (the effort words `xhigh` and `max`, `minimal` as `low`, the budget rows
- *   reading the budget alone), so this class hands the adapter that reading
- *   as `claudeReasoning` (ADR 0055). Everything else is the shim's mapping.
- *
- * What the adapter does (thinking by model generation, signed blocks
- * replayed within the tool loop, structured output, images, web search) is
- * described in its header and in wiki/models/claude-adapter.md.
- */
-import { requireAdk } from '../adkPeer.js';
-import { AdkShim } from './adkShim.js';
-import { ClaudeAdapter, anthropicTools } from './claudeAdapter.js';
-import { claudeReasoningFromConfig } from './claudeModels.js';
-import { llmRequestToModelRequest } from './genaiMapping.js';
-export { THINKING_STATE_KIND } from './claudeAdapter.js';
-/**
- * The tool definitions ClaudeLlm sends for an LlmRequest's toolsDict, before
- * the platform is known: client tools with lowercase schemas, and the
- * web_search sentinel as Anthropic's native server tool (AnthropicTool, from
- * anthropicTools in lib/models/claudeAdapter.ts).
- */
-export function buildAnthropicTools(llmRequest) {
-    return anthropicTools(llmRequestToModelRequest(llmRequest));
-}
-export class ClaudeLlm extends AdkShim {
-    /**
-     * Regex patterns that map model name strings to this provider.
-     * Any model: "claude-*" in a YAML config will route here after registration.
-     */
-    static supportedModels = [/^claude-.+/];
-    /**
-     * `apiKey`: a caller's own key, which wins over the endpoint's and
-     * ANTHROPIC_API_KEY. `endpoint` (ADR 0023): where the request goes —
-     * Anthropic's API (or a proxy at its base URL), Bedrock, or Vertex AI.
-     * Default: the environment's (`ANTHROPIC_PLATFORM`).
-     */
-    constructor({ model, apiKey, endpoint }) {
-        super(new ClaudeAdapter({ model, apiKey, endpoint }), { model });
-    }
-    /** The shim's ModelRequest, with the agent's older reasoning spelling read as ADR 0049 reads it (ADR 0055). */
-    toModelRequest(llmRequest, options) {
-        return {
-            ...super.toModelRequest(llmRequest, options),
-            claudeReasoning: claudeReasoningFromConfig((llmRequest.config ?? {})),
-        };
-    }
-}
-// ── Registration helper ───────────────────────────────────────────────────────
-/**
- * Registers ClaudeLlm with the ADK LLMRegistry.
- *
- * WHY a separate function instead of auto-registering at import time:
- *   Auto-registration at module load would cause every consumer of this file
- *   to unconditionally register Claude, even if ANTHROPIC_API_KEY is absent.
- *   By making registration explicit, registerAvailableProviders() can
- *   conditionally call this only when the key is present, and log a clear
- *   message about which provider is active.
- */
-export function registerClaudeLlm() {
-    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(ClaudeLlm);
-}

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

@@ -1,48 +0,0 @@
-/**
- * lib/models/fallback.ts — a fallback model and a per-provider circuit
- * breaker for an agent that declares `fallback_model:` (ADR 0044).
- *
- * WHY: lib/models/retry.ts makes one call survive a blip. It does nothing for
- * an outage: every turn on a provider that is down spends its retries and
- * fails. An agent that names a fallback model now answers from it instead,
- * and a provider that keeps failing is skipped for a cooldown rather than
- * tried on every turn.
- *
- * TWO WAYS A PRIMARY FAILS: Gemini throws; the other adapters yield an
- * error response (`errorCode`) whose customMetadata['error.retryable'] carries
- * retry.ts's verdict (lib/models/errorResponse.ts). Both are read here by
- * the same rules.
- *
- * THE RULES:
- *   - Only provider-side failures count: what retry.ts classifies retryable
- *     (408/409/425/429/5xx, connection resets) once the adapter's own retries
- *     are spent. A 4xx is the request's fault and is thrown, or its error
- *     response passed on, as it is; a canceled turn is never counted or
- *     redirected.
- *   - The fallback runs only if the primary produced nothing yet: a stream
- *     that failed midway is thrown, or its error passed on, never replayed
- *     on another model. A redirected error response is never yielded.
- *   - Only a call that yielded content and no error counts as a success.
- *   - The breaker is per provider, shared by every agent in the process:
- *     MODEL_BREAKER_THRESHOLD consecutive failures (default 5; 0 disables)
- *     open it for MODEL_BREAKER_COOLDOWN_MS (default 30 s). While open, a
- *     wrapped agent goes straight to its fallback; after the cooldown calls
- *     go through again, the next failure reopens it at once, and a success
- *     closes it. Its state is lib/models/circuitBreaker.ts, which the
- *     contract-level wrapper (lib/models/fallbackAdapter.ts) shares.
- */
-import { BaseLlm } from '../adkPeer.ts';
-import type { BaseLlmConnection, LlmRequest, LlmResponse } from '@google/adk';
-export { circuitOpen, resetCircuits } from './circuitBreaker.ts';
-/** A provider-side failure: worth counting against the provider and worth a fallback. A cancellation never is. */
-export declare function isProviderFailure(err: unknown): boolean;
-export declare class FallbackLlm extends BaseLlm {
-    readonly primary: BaseLlm;
-    readonly fallback: BaseLlm;
-    private readonly log;
-    private readonly primaryProvider;
-    constructor(primary: BaseLlm, fallback: BaseLlm, log?: (m: string) => void);
-    generateContentAsync(llmRequest: LlmRequest, stream?: boolean, abortSignal?: AbortSignal): AsyncGenerator<LlmResponse, void>;
-    private onFallback;
-    connect(llmRequest: LlmRequest): Promise<BaseLlmConnection>;
-}

package/dist/lib/models/fallback.js

@@ -1,116 +0,0 @@
-/**
- * lib/models/fallback.ts — a fallback model and a per-provider circuit
- * breaker for an agent that declares `fallback_model:` (ADR 0044).
- *
- * WHY: lib/models/retry.ts makes one call survive a blip. It does nothing for
- * an outage: every turn on a provider that is down spends its retries and
- * fails. An agent that names a fallback model now answers from it instead,
- * and a provider that keeps failing is skipped for a cooldown rather than
- * tried on every turn.
- *
- * TWO WAYS A PRIMARY FAILS: Gemini throws; the other adapters yield an
- * error response (`errorCode`) whose customMetadata['error.retryable'] carries
- * retry.ts's verdict (lib/models/errorResponse.ts). Both are read here by
- * the same rules.
- *
- * THE RULES:
- *   - Only provider-side failures count: what retry.ts classifies retryable
- *     (408/409/425/429/5xx, connection resets) once the adapter's own retries
- *     are spent. A 4xx is the request's fault and is thrown, or its error
- *     response passed on, as it is; a canceled turn is never counted or
- *     redirected.
- *   - The fallback runs only if the primary produced nothing yet: a stream
- *     that failed midway is thrown, or its error passed on, never replayed
- *     on another model. A redirected error response is never yielded.
- *   - Only a call that yielded content and no error counts as a success.
- *   - The breaker is per provider, shared by every agent in the process:
- *     MODEL_BREAKER_THRESHOLD consecutive failures (default 5; 0 disables)
- *     open it for MODEL_BREAKER_COOLDOWN_MS (default 30 s). While open, a
- *     wrapped agent goes straight to its fallback; after the cooldown calls
- *     go through again, the next failure reopens it at once, and a success
- *     closes it. Its state is lib/models/circuitBreaker.ts, which the
- *     contract-level wrapper (lib/models/fallbackAdapter.ts) shares.
- */
-import { BaseLlm } from '../adkPeer.js';
-import { errorDecision, errorText, isRetryableErrorResponse } from './errorResponse.js';
-import { providerForModel } from './providerMap.js';
-import { circuitOpen, recordFailure, recordSuccess } from './circuitBreaker.js';
-import { currentTurnSignal } from '../runtime/turnControl.js';
-// The breaker's state lives in lib/models/circuitBreaker.ts, shared with the
-// contract-level FallbackAdapter. Re-exported so existing imports keep working.
-export { circuitOpen, resetCircuits } from './circuitBreaker.js';
-/** A provider-side failure: worth counting against the provider and worth a fallback. A cancellation never is. */
-export function isProviderFailure(err) {
-    return errorDecision(err).retryable;
-}
-/** A response that carries something the model produced. */
-function hasContent(response) {
-    return (response.content?.parts?.length ?? 0) > 0;
-}
-/** The turn was canceled: by the signal ADK passes, or the turn's own. */
-function canceled(abortSignal) {
-    return !!abortSignal?.aborted || !!currentTurnSignal()?.aborted;
-}
-export class FallbackLlm extends BaseLlm {
-    primary;
-    fallback;
-    log;
-    primaryProvider;
-    constructor(primary, fallback, log = (m) => console.warn(m)) {
-        super({ model: primary.model });
-        this.primary = primary;
-        this.fallback = fallback;
-        this.log = log;
-        this.primaryProvider = providerForModel(primary.model);
-    }
-    async *generateContentAsync(llmRequest, stream, abortSignal) {
-        if (circuitOpen(this.primaryProvider)) {
-            yield* this.onFallback(llmRequest, stream, abortSignal, `${this.primaryProvider} circuit is open`);
-            return;
-        }
-        let yielded = false;
-        let answered = false;
-        let errored = false;
-        let redirect;
-        try {
-            for await (const r of this.primary.generateContentAsync(llmRequest, stream, abortSignal)) {
-                if (r.errorCode) {
-                    errored = true;
-                    if (!canceled(abortSignal) && isRetryableErrorResponse(r)) {
-                        recordFailure(this.primaryProvider);
-                        if (!yielded && !hasContent(r)) {
-                            // Leaving the loop closes the primary's call before the fallback's opens.
-                            redirect = `${this.primary.model} failed (${r.errorCode}: ${String(r.errorMessage ?? '').slice(0, 120)})`;
-                            break;
-                        }
-                    }
-                }
-                else if (hasContent(r)) {
-                    answered = true;
-                }
-                yielded = true;
-                yield r;
-            }
-            if (answered && !errored)
-                recordSuccess(this.primaryProvider);
-        }
-        catch (err) {
-            if (canceled(abortSignal) || !isProviderFailure(err))
-                throw err;
-            recordFailure(this.primaryProvider);
-            if (yielded)
-                throw err;
-            redirect = `${this.primary.model} failed (${errorText(err).slice(0, 120)})`;
-        }
-        if (redirect)
-            yield* this.onFallback(llmRequest, stream, abortSignal, redirect);
-    }
-    async *onFallback(llmRequest, stream, abortSignal, why) {
-        this.log(`[models] ${why}; answering from ${this.fallback.model}.`);
-        const request = { ...llmRequest, model: this.fallback.model };
-        yield* this.fallback.generateContentAsync(request, stream, abortSignal);
-    }
-    connect(llmRequest) {
-        return this.primary.connect(llmRequest);
-    }
-}

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

@@ -1,36 +0,0 @@
-/**
- * lib/models/gatewayLlm.ts — the one-key fallback, as an ADK BaseLlm.
- *
- * WHY this file exists:
- *   The transport's work is GatewayAdapter (lib/models/gatewayAdapter.ts),
- *   on the engine's own model contract: any cloud model id through a hosted
- *   gateway's chat-completions endpoint when the provider's direct key is
- *   absent (lib/models/gateway.ts owns that decision), attributed to the
- *   upstream provider, with every native tool dropped and reported. 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).
- *   The constructor is what it was before the adapter moved onto the
- *   contract, so lib/models/registry.ts and every caller are unchanged.
- *
- * Registration: LLMRegistry keys on regex OBJECTS, so a gateway class must
- * carry the SAME supportedModels instances as the direct adapter it stands
- * in for (see gatewayClassFor below, and its use in registry.ts).
- */
-import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.ts';
-export declare class GatewayLlm extends OpenAiCompatibleLlm {
-    /** Never registered directly — see gatewayClassFor(). */
-    static readonly supportedModels: Array<string | RegExp>;
-    /** The gateway (MODEL_GATEWAY and its key) is read from the environment when constructed. */
-    constructor({ model }: {
-        model: string;
-    });
-}
-/**
- * A GatewayLlm subclass that answers for the given model patterns. Pass the
- * direct adapter's OWN `supportedModels` array so the registry entry
- * REPLACES that adapter's (the dict is keyed by regex object) rather than
- * adding a second, shadowed match.
- */
-export declare function gatewayClassFor(patterns: Array<string | RegExp>): typeof GatewayLlm;
-/** Registers a gateway stand-in for the given patterns. */
-export declare function registerGatewayLlm(patterns: Array<string | RegExp>): void;

package/dist/lib/models/gatewayLlm.js

@@ -1,44 +0,0 @@
-/**
- * lib/models/gatewayLlm.ts — the one-key fallback, as an ADK BaseLlm.
- *
- * WHY this file exists:
- *   The transport's work is GatewayAdapter (lib/models/gatewayAdapter.ts),
- *   on the engine's own model contract: any cloud model id through a hosted
- *   gateway's chat-completions endpoint when the provider's direct key is
- *   absent (lib/models/gateway.ts owns that decision), attributed to the
- *   upstream provider, with every native tool dropped and reported. 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).
- *   The constructor is what it was before the adapter moved onto the
- *   contract, so lib/models/registry.ts and every caller are unchanged.
- *
- * Registration: LLMRegistry keys on regex OBJECTS, so a gateway class must
- * carry the SAME supportedModels instances as the direct adapter it stands
- * in for (see gatewayClassFor below, and its use in registry.ts).
- */
-import { requireAdk } from '../adkPeer.js';
-import { GatewayAdapter } from './gatewayAdapter.js';
-import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.js';
-export class GatewayLlm extends OpenAiCompatibleLlm {
-    /** Never registered directly — see gatewayClassFor(). */
-    static supportedModels = [];
-    /** The gateway (MODEL_GATEWAY and its key) is read from the environment when constructed. */
-    constructor({ model }) {
-        super(new GatewayAdapter({ model }), { model });
-    }
-}
-/**
- * A GatewayLlm subclass that answers for the given model patterns. Pass the
- * direct adapter's OWN `supportedModels` array so the registry entry
- * REPLACES that adapter's (the dict is keyed by regex object) rather than
- * adding a second, shadowed match.
- */
-export function gatewayClassFor(patterns) {
-    return class GatewayLlmFor extends GatewayLlm {
-        static supportedModels = patterns;
-    };
-}
-/** Registers a gateway stand-in for the given patterns. */
-export function registerGatewayLlm(patterns) {
-    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(gatewayClassFor(patterns));
-}

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

@@ -1,99 +0,0 @@
-/**
- * lib/models/gptLlm.ts — OpenAI GPT for ADK's LLMRegistry: the ADK shim
- * (lib/models/adkShim.ts) around GptAdapter (lib/models/gptAdapter.ts).
- *
- * WHY this file exists:
- *   Model optionality: any agent YAML with model: "gpt-*" (or an o-series id
- *   like "o4-mini") routes here after registration. The Responses API
- *   translation lives in GptAdapter, on the engine's own model contract
- *   (ADR 0048), so the native runtime can call it without ADK. GptLlm is
- *   what ADK registers and calls: the shim maps ADK's LlmRequest to a
- *   ModelRequest, charges the turn and opens the llm.request span once
- *   (ADR 0053), and maps each ModelResponse back. GrokLlm subclasses it.
- *
- * HOW TO ENABLE:
- *   1. Install the SDK (already in package.json):  npm install
- *   2. Add your API key to .env:  OPENAI_API_KEY=sk-...
- *   3. Set model: "gpt-5-mini" (or any gpt-* / o-series id) in your YAML.
- *   registerAvailableProviders() registers this adapter when the key is set.
- *
- * WHAT IT KEEPS FROM THE ADK PATH (ADR 0056), beyond the shim's mapping:
- *   - Usage in the Responses meaning: `candidatesTokenCount` is
- *     `output_tokens`, reasoning included, so llm.tokens.output, the turn's
- *     token charge and the ledger count what they always counted for GPT and
- *     Grok. (The shim's mapping writes Gemini's meaning, reasoning excluded.)
- *   - The server-side tool calls (web_search, x_search…) as
- *     customMetadata['responses.server_tool_calls'] and the vendor's counters
- *     as ['responses.server_tool_usage'], which the root span turns into
- *     ToolCall events so adk_turns.tool_calls counts a searched answer.
- *   - groundingMetadata from the adapter's grounding, so the A2A server
- *     lists the answer's web sources, as it does for Gemini (owner's
- *     decision, 2026-10-08).
- *
- * The LlmRequest builders below (buildResponsesInput, buildResponsesTools)
- * are the adapter's own, run on the LlmRequest mapped to the contract.
- */
-import type { LlmRequest, LlmResponse } from '@google/adk';
-import { AdkShim } from './adkShim.ts';
-import type { ModelResponse } from './contract.ts';
-import type { ProviderEndpoint } from './endpoints.ts';
-import { GptAdapter } from './gptAdapter.ts';
-import type { GptAdapterOptions, ReasoningReplay } from './gptAdapter.ts';
-export { REASONING_STATE_KIND, extractServerToolCalls, serverToolUsage, streamEventDelta, } from './gptAdapter.ts';
-export type { ServerToolCall } from './gptAdapter.ts';
-/**
- * ADK Contents → Responses API `input` items + `instructions` string: the
- * LlmRequest mapped to the contract (lib/models/genaiMapping.ts), then
- * GptAdapter's responsesInput. With `replay`, that provider's reasoning items
- * for that model are sent back before their part's item, within the current
- * turn's tool loop only (ADR 0050).
- */
-export declare function buildResponsesInput(llmRequest: LlmRequest, replay?: ReasoningReplay): {
-    instructions: string | undefined;
-    input: any[];
-};
-/**
- * ADK toolsDict (+ the native-tool sentinels) → Responses API tool
- * definitions: the function tools, then the vendor's native tools, the
- * request's model choosing the vendor (xAI's filters ride only on grok ids).
- */
-export declare function buildResponsesTools(llmRequest: LlmRequest): any[];
-/** GptLlm's constructor options: the adapter's (ADR 0023 for `endpoint`). */
-export type GptLlmOptions = GptAdapterOptions;
-export declare class GptLlm extends AdkShim {
-    /** gpt-* and o-series ids route here after registration. */
-    static readonly supportedModels: Array<string | RegExp>;
-    readonly adapter: GptAdapter;
-    /** The adapter a class builds for its options: GptAdapter here, GrokAdapter in GrokLlm. */
-    protected static createAdapter(options: GptLlmOptions): GptAdapter;
-    /**
-     * `endpoint` (ADR 0023): OpenAI's API (or a proxy at its base URL) or Azure
-     * OpenAI. Default: the environment's (`OPENAI_PLATFORM`).
-     */
-    constructor(options: {
-        model: string;
-        apiKey?: string;
-        endpoint?: ProviderEndpoint;
-    });
-    /**
-     * The shim's mapping, with the Responses usage meaning and the server-side
-     * tool record the ADK path has always carried, and the grounding the
-     * mapping writes (see the header, ADR 0056).
-     */
-    protected toLlmResponse(response: ModelResponse): LlmResponse;
-    /** The `reasoning` field this model sends for an LlmRequest's config (ADR 0047), as the adapter maps it. */
-    protected reasoningParam(llmRequest?: LlmRequest): Record<string, unknown> | undefined;
-    /**
-     * A Responses reply (non-delta) as the LlmResponses ADK sees: the reasoning
-     * summaries as one thought partial (unless `skipThoughts`), then the final,
-     * through the adapter's finalOf and this class's mapping.
-     */
-    protected mapFinalResponse(response: any, opts?: {
-        skipThoughts?: boolean;
-    }): Generator<LlmResponse>;
-}
-/**
- * Registers GptLlm with the ADK LLMRegistry. Called by
- * registerAvailableProviders() when OPENAI_API_KEY is present.
- */
-export declare function registerGptLlm(): void;

package/dist/lib/models/gptLlm.js

@@ -1,129 +0,0 @@
-/**
- * lib/models/gptLlm.ts — OpenAI GPT for ADK's LLMRegistry: the ADK shim
- * (lib/models/adkShim.ts) around GptAdapter (lib/models/gptAdapter.ts).
- *
- * WHY this file exists:
- *   Model optionality: any agent YAML with model: "gpt-*" (or an o-series id
- *   like "o4-mini") routes here after registration. The Responses API
- *   translation lives in GptAdapter, on the engine's own model contract
- *   (ADR 0048), so the native runtime can call it without ADK. GptLlm is
- *   what ADK registers and calls: the shim maps ADK's LlmRequest to a
- *   ModelRequest, charges the turn and opens the llm.request span once
- *   (ADR 0053), and maps each ModelResponse back. GrokLlm subclasses it.
- *
- * HOW TO ENABLE:
- *   1. Install the SDK (already in package.json):  npm install
- *   2. Add your API key to .env:  OPENAI_API_KEY=sk-...
- *   3. Set model: "gpt-5-mini" (or any gpt-* / o-series id) in your YAML.
- *   registerAvailableProviders() registers this adapter when the key is set.
- *
- * WHAT IT KEEPS FROM THE ADK PATH (ADR 0056), beyond the shim's mapping:
- *   - Usage in the Responses meaning: `candidatesTokenCount` is
- *     `output_tokens`, reasoning included, so llm.tokens.output, the turn's
- *     token charge and the ledger count what they always counted for GPT and
- *     Grok. (The shim's mapping writes Gemini's meaning, reasoning excluded.)
- *   - The server-side tool calls (web_search, x_search…) as
- *     customMetadata['responses.server_tool_calls'] and the vendor's counters
- *     as ['responses.server_tool_usage'], which the root span turns into
- *     ToolCall events so adk_turns.tool_calls counts a searched answer.
- *   - groundingMetadata from the adapter's grounding, so the A2A server
- *     lists the answer's web sources, as it does for Gemini (owner's
- *     decision, 2026-10-08).
- *
- * The LlmRequest builders below (buildResponsesInput, buildResponsesTools)
- * are the adapter's own, run on the LlmRequest mapped to the contract.
- */
-import { requireAdk } from '../adkPeer.js';
-import { AdkShim } from './adkShim.js';
-import { llmRequestToModelRequest, reasoningOf } from './genaiMapping.js';
-import { GptAdapter, responsesFunctionTools, responsesInput, responsesServerTools } from './gptAdapter.js';
-import { GrokAdapter } from './grokAdapter.js';
-import { providerForModel } from './providerMap.js';
-export { REASONING_STATE_KIND, extractServerToolCalls, serverToolUsage, streamEventDelta, } from './gptAdapter.js';
-// ── The LlmRequest builders (the adapter's, on the mapped request) ───────────
-/** The ModelRequest an LlmRequest maps to, for the request's own model id. */
-function toModelRequest(llmRequest) {
-    return llmRequestToModelRequest(llmRequest, { model: llmRequest.model || 'unknown' });
-}
-/**
- * ADK Contents → Responses API `input` items + `instructions` string: the
- * LlmRequest mapped to the contract (lib/models/genaiMapping.ts), then
- * GptAdapter's responsesInput. With `replay`, that provider's reasoning items
- * for that model are sent back before their part's item, within the current
- * turn's tool loop only (ADR 0050).
- */
-export function buildResponsesInput(llmRequest, replay) {
-    const { instructions, input } = responsesInput(toModelRequest(llmRequest), replay);
-    return { instructions, input };
-}
-/**
- * ADK toolsDict (+ the native-tool sentinels) → Responses API tool
- * definitions: the function tools, then the vendor's native tools, the
- * request's model choosing the vendor (xAI's filters ride only on grok ids).
- */
-export function buildResponsesTools(llmRequest) {
-    const request = toModelRequest(llmRequest);
-    const adapter = providerForModel(request.model) === 'xai' ? new GrokAdapter({ model: request.model }) : new GptAdapter({ model: request.model });
-    return [...responsesFunctionTools(request), ...adapter.nativeToolPlan(request).tools];
-}
-export class GptLlm extends AdkShim {
-    /** gpt-* and o-series ids route here after registration. */
-    static supportedModels = [/^gpt-.+/, /^o[0-9].*/];
-    /** The adapter a class builds for its options: GptAdapter here, GrokAdapter in GrokLlm. */
-    static createAdapter(options) {
-        return new GptAdapter(options);
-    }
-    /**
-     * `endpoint` (ADR 0023): OpenAI's API (or a proxy at its base URL) or Azure
-     * OpenAI. Default: the environment's (`OPENAI_PLATFORM`).
-     */
-    constructor(options) {
-        super(new.target.createAdapter(options), { model: options.model });
-    }
-    /**
-     * The shim's mapping, with the Responses usage meaning and the server-side
-     * tool record the ADK path has always carried, and the grounding the
-     * mapping writes (see the header, ADR 0056).
-     */
-    toLlmResponse(response) {
-        const mapped = super.toLlmResponse(response);
-        if (response.partial)
-            return mapped;
-        const out = { ...mapped };
-        if (response.usage && out.usageMetadata) {
-            out.usageMetadata = { ...out.usageMetadata, candidatesTokenCount: response.usage.outputTokens };
-        }
-        const tools = responsesServerTools(response);
-        if (tools) {
-            out.customMetadata = {
-                ...out.customMetadata,
-                ...(tools.calls.length > 0 ? { 'responses.server_tool_calls': tools.calls } : {}),
-                ...(Object.keys(tools.usage).length > 0 ? { 'responses.server_tool_usage': tools.usage } : {}),
-            };
-        }
-        return out;
-    }
-    /** The `reasoning` field this model sends for an LlmRequest's config (ADR 0047), as the adapter maps it. */
-    reasoningParam(llmRequest) {
-        return this.adapter.reasoningParam(reasoningOf(llmRequest?.config));
-    }
-    /**
-     * A Responses reply (non-delta) as the LlmResponses ADK sees: the reasoning
-     * summaries as one thought partial (unless `skipThoughts`), then the final,
-     * through the adapter's finalOf and this class's mapping.
-     */
-    *mapFinalResponse(response, opts = {}) {
-        const { thinking, final } = this.adapter.finalOf(response, this.model, opts);
-        if (thinking)
-            yield this.toLlmResponse(thinking);
-        yield this.toLlmResponse(final);
-    }
-}
-// ── Registration helper ───────────────────────────────────────────────────────
-/**
- * Registers GptLlm with the ADK LLMRegistry. Called by
- * registerAvailableProviders() when OPENAI_API_KEY is present.
- */
-export function registerGptLlm() {
-    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(GptLlm);
-}