melchizedek-agents 1.0.0 → 1.0.2

package/dist/lib/models/adkGeminiAdapter.js

@@ -1,369 +0,0 @@
-/**
- * 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 { endpointFromEnv, endpointProblems, platformModel } from './endpoints.js';
-import { errorText } from './errorResponse.js';
-import { GEMINI_PROVIDER } from './geminiState.js';
-import { llmResponseToModelResponse, modelRequestToLlmRequest, nativeToolsWithoutGeminiTool } from './genaiMapping.js';
-import { TracedGemini } from './tracedGemini.js';
-import { requireAdk } from '../adkPeer.js';
-import { classifyError, errorStatus } from './retry.js';
-import { setLlmSpanAttribute } from '../observability/tracer.js';
-/** The prefix of a call id ADK (or the engine after it) made: such an id never goes on the wire. */
-const ADK_CALL_ID_PREFIX = 'adk-';
-// ── The adapter ──────────────────────────────────────────────────────────────
-/** Temporary: ADK's Gemini behind the model contract, until GeminiAdapter passes gate G3. */
-export class AdkGeminiAdapter {
-    provider = GEMINI_PROVIDER;
-    model;
-    #apiKey;
-    #endpoint;
-    #connection;
-    #warned = new Set();
-    constructor(options) {
-        requireAdk('GEMINI_ADAPTER=adk (AdkGeminiAdapter, which runs ADK\'s Gemini)');
-        this.model = options.model;
-        this.#apiKey = nonEmpty(options.apiKey);
-        this.#endpoint = options.endpoint;
-    }
-    async *generate(request) {
-        const { signal } = request;
-        const model = request.model || this.model;
-        const stream = request.stream === true;
-        const named = request.nativeTools ?? [];
-        const searchTool = named.includes('web_search') || !named.includes('google_search') ? 'web_search' : 'google_search';
-        const reply = new Reply({ model, position: request.messages.length, searchTool, stream });
-        if (signal?.aborted) {
-            yield reply.aborted();
-            return;
-        }
-        const connection = this.#connect();
-        if ('code' in connection) {
-            yield { partial: false, parts: [], finishReason: 'error', error: connection };
-            return;
-        }
-        const { gemini, endpoint, secret } = connection;
-        try {
-            const llmRequest = adkRequest(request, model, platformModel(endpoint, model));
-            this.#report(nativeToolsWithoutGeminiTool(named));
-            for await (const response of untilAborted(gemini.generateWithRetries(llmRequest, stream, signal), signal)) {
-                const delta = reply.add(response);
-                if (delta)
-                    yield delta;
-            }
-            const thinking = reply.thinking();
-            if (thinking)
-                yield thinking;
-            yield reply.final();
-        }
-        catch (err) {
-            if (signal?.aborted) {
-                yield reply.aborted();
-                return;
-            }
-            yield reply.failed(err, secret);
-        }
-    }
-    /** Marks the open span with the native tools Gemini has none for, and warns once per tool. */
-    #report(dropped) {
-        if (dropped.length === 0)
-            return;
-        setLlmSpanAttribute('llm.capability.dropped', dropped.join(','));
-        for (const tool of dropped) {
-            if (this.#warned.has(tool))
-                continue;
-            this.#warned.add(tool);
-            console.warn(`⚠ ${tool} is not a Gemini tool; ${this.model} runs without it.`);
-        }
-    }
-    /** ADK's Gemini for this adapter's endpoint, built once; or why it cannot be built. */
-    #connect() {
-        if (this.#connection)
-            return this.#connection;
-        let endpoint;
-        try {
-            endpoint = this.#endpoint ?? endpointFromEnv('gemini');
-        }
-        catch (err) {
-            return setupError('ENDPOINT_MISCONFIGURED', errorText(err));
-        }
-        let secret;
-        if (endpoint.platform === 'vertex') {
-            const problems = endpointProblems('gemini', endpoint);
-            if (problems.length > 0)
-                return setupError('ENDPOINT_MISCONFIGURED', `Gemini on Vertex AI: ${problems.join('; ')}.`);
-        }
-        else if (endpoint.platform === 'direct') {
-            secret = this.#apiKey ?? nonEmpty(endpoint.apiKey) ?? envApiKey();
-            if (!secret) {
-                return setupError('MISSING_API_KEY', 'No Gemini API key: set GOOGLE_GENAI_API_KEY (or GEMINI_API_KEY), or GEMINI_PLATFORM=vertex for Vertex AI.');
-            }
-        }
-        else {
-            return setupError('ENDPOINT_MISCONFIGURED', `Gemini has no ${endpoint.platform} platform; use direct or vertex.`);
-        }
-        try {
-            // TracedGemini applies the platform (ADR 0023): on Vertex AI, Google
-            // Application Default Credentials and no AI Studio key.
-            const gemini = new TracedGemini({ model: this.model, ...(secret ? { apiKey: secret } : {}), endpoint });
-            this.#connection = { gemini, endpoint, secret };
-        }
-        catch (err) {
-            return setupError('ENDPOINT_MISCONFIGURED', `ADK's Gemini failed to build: ${scrub(err, secret)}`);
-        }
-        return this.#connection;
-    }
-}
-// ── The request ──────────────────────────────────────────────────────────────
-/** The LlmRequest ADK's Gemini is handed for this ModelRequest (see the header, THE CALL). */
-function adkRequest(request, model, wireModel) {
-    const extra = [];
-    for (const message of request.messages) {
-        if (message.role === 'system')
-            for (const part of message.parts)
-                if (part.text)
-                    extra.push(part.text);
-    }
-    const llmRequest = modelRequestToLlmRequest({ ...request, model, messages: request.messages.filter((m) => m.role !== 'system') });
-    const config = llmRequest.config ?? {};
-    if (extra.length > 0) {
-        config.systemInstruction = { parts: [...(request.system ? [request.system] : []), ...extra].map((text) => ({ text })) };
-    }
-    config.toolConfig = { ...config.toolConfig, includeServerSideToolInvocations: true };
-    const thinking = config.thinkingConfig;
-    const none = request.reasoning === 'none' || (typeof request.reasoning === 'object' && request.reasoning.budget_tokens <= 0);
-    if (thinking && !none)
-        config.thinkingConfig = { ...thinking, includeThoughts: true };
-    return { ...llmRequest, model: wireModel, contents: llmRequest.contents.map(forAdk), config };
-}
-/**
- * A content as ADK's Gemini may take it: `adk-` ids off calls and results,
- * and every part copied where ADK writes (it clears a blob's display name in
- * place), so a part the history shares (a carried genai part) is never changed.
- */
-function forAdk(content) {
-    return {
-        ...content,
-        parts: (content.parts ?? []).map((part) => {
-            const out = { ...part };
-            if (part.inlineData)
-                out.inlineData = { ...part.inlineData };
-            if (part.fileData)
-                out.fileData = { ...part.fileData };
-            if (part.functionCall)
-                out.functionCall = withoutAdkId(part.functionCall);
-            if (part.functionResponse)
-                out.functionResponse = withoutAdkId(part.functionResponse);
-            return out;
-        }),
-    };
-}
-function withoutAdkId(value) {
-    if (typeof value.id !== 'string' || !value.id.startsWith(ADK_CALL_ID_PREFIX))
-        return { ...value };
-    const { id: _id, ...rest } = value;
-    return rest;
-}
-// ── The response ─────────────────────────────────────────────────────────────
-/** Folds the LlmResponses ADK yields for one call into the contract's deltas and its one final. */
-class Reply {
-    #model;
-    #position;
-    #searchTool;
-    #stream;
-    #parts = [];
-    #thinking = [];
-    #usage;
-    #grounding;
-    #finishReason;
-    #error;
-    constructor(options) {
-        this.#model = options.model;
-        this.#position = options.position;
-        this.#searchTool = options.searchTool;
-        this.#stream = options.stream;
-    }
-    /** Takes one LlmResponse. A streamed partial's deltas come back to be yielded; everything else folds into the final. */
-    add(response) {
-        if (response.usageMetadata)
-            this.#usage = response.usageMetadata;
-        if (response.groundingMetadata)
-            this.#grounding = response.groundingMetadata;
-        if (response.finishReason)
-            this.#finishReason = response.finishReason;
-        if (response.partial === true) {
-            if (!this.#stream)
-                return undefined;
-            const delta = llmResponseToModelResponse(response);
-            return delta.parts.length > 0 ? delta : undefined;
-        }
-        if (response.errorCode) {
-            this.#error = { errorCode: response.errorCode, errorMessage: response.errorMessage, customMetadata: response.customMetadata };
-        }
-        for (const part of response.content?.parts ?? []) {
-            this.#parts.push(part);
-            if (part.thought === true && part.text)
-                this.#thinking.push({ type: 'thinking', text: part.text });
-        }
-        return undefined;
-    }
-    /** The thinking of a call that did not stream, as one partial before its final. */
-    thinking() {
-        return !this.#stream && this.#thinking.length > 0 ? { partial: true, parts: this.#thinking } : undefined;
-    }
-    /** The one final for a call that ran to its end. */
-    final() {
-        return this.#fold(true);
-    }
-    /** The final for a call ADK's Gemini threw on: GEMINI_ERROR, with what arrived before it. */
-    failed(err, secret) {
-        const status = errorStatus(err);
-        return {
-            ...this.#fold(false),
-            finishReason: 'error',
-            error: {
-                code: 'GEMINI_ERROR',
-                message: scrub(err, secret),
-                retryable: classifyError(err).retryable,
-                ...(status !== undefined ? { status } : {}),
-            },
-        };
-    }
-    /** The final for a canceled call: never retryable, so no fallback answers it. */
-    aborted() {
-        return { ...this.#fold(false), finishReason: 'error', error: { code: 'GEMINI_ERROR', message: 'The Gemini request was aborted.', retryable: false } };
-    }
-    /** Everything ADK yielded as one LlmResponse, mapped; with the error it yielded, or (for a throw) without. */
-    #fold(withError) {
-        const folded = {
-            ...(this.#parts.length > 0 ? { content: { role: 'model', parts: this.#parts } } : {}),
-            ...(this.#usage ? { usageMetadata: this.#usage } : {}),
-            ...(this.#grounding ? { groundingMetadata: this.#grounding } : {}),
-            ...(this.#finishReason ? { finishReason: this.#finishReason } : {}),
-            ...(withError ? this.#error : {}),
-        };
-        return llmResponseToModelResponse(folded, { model: this.#model, index: this.#position, searchTool: this.#searchTool });
-    }
-}
-// ── Transport ────────────────────────────────────────────────────────────────
-function abortError() {
-    return Object.assign(new Error('The Gemini request was aborted.'), { name: 'AbortError' });
-}
-/**
- * Iterates `source` until `signal` aborts, and then throws an AbortError at
- * once: the SDK aborts its fetch on the same signal, but a stalled stream or
- * a backoff sleep must not hold the caller. The source is closed in the
- * background.
- */
-async function* untilAborted(source, signal) {
-    if (!signal) {
-        yield* source;
-        return;
-    }
-    let onAbort = () => { };
-    const aborted = new Promise((_, reject) => {
-        onAbort = () => reject(abortError());
-    });
-    aborted.catch(() => { });
-    if (signal.aborted)
-        onAbort();
-    else
-        signal.addEventListener('abort', onAbort, { once: true });
-    let done = false;
-    try {
-        for (;;) {
-            const next = await Promise.race([source.next(), aborted]);
-            if (next.done) {
-                done = true;
-                return;
-            }
-            yield next.value;
-        }
-    }
-    finally {
-        signal.removeEventListener('abort', onAbort);
-        if (!done)
-            source.return(undefined).catch(() => { });
-    }
-}
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function setupError(code, message) {
-    return { code, message, retryable: false };
-}
-function nonEmpty(value) {
-    return value?.trim() || undefined;
-}
-/** The Gemini API key from the environment, in ADK's order. */
-function envApiKey() {
-    return nonEmpty(process.env.GOOGLE_GENAI_API_KEY) ?? nonEmpty(process.env.GOOGLE_API_KEY) ?? nonEmpty(process.env.GEMINI_API_KEY);
-}
-/** An error's text without the key in use, or anything shaped like a key. */
-function scrub(err, secret) {
-    const message = err instanceof Error ? err.message : String(err);
-    return errorText(secret ? message.split(secret).join('[redacted]') : message);
-}

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

@@ -1,111 +0,0 @@
-/**
- * lib/models/adkShim.ts — any ModelAdapter on the engine's own contract
- * (lib/models/contract.ts, ADR 0048) as an ADK BaseLlm, so an adapter can
- * move onto the contract while ADK still runs every turn (ADR 0045).
- *
- * WHY this file exists:
- *   ADK calls `BaseLlm.generateContentAsync(llmRequest, stream, abortSignal)`
- *   and expects LlmResponses back. An adapter on the contract implements
- *   `generate(ModelRequest)` and yields ModelResponses. The shim is the one
- *   class between them: it maps the LlmRequest in and each ModelResponse out
- *   through lib/models/genaiMapping.ts, and does no translation of its own.
- *   The adapter tickets move one adapter at a time behind it, and ADK sees
- *   no change: ClaudeLlm (lib/models/claudeLlm.ts) is the shim around
- *   ClaudeAdapter. A provider's ADK class may extend `toModelRequest` with
- *   what its adapter reads on the ADK path only (ADR 0055).
- *
- * WHAT THE SHIM DOES ONCE, SO NO CONTRACT ADAPTER DOES IT (ADR 0053):
- *   - The turn's charge and the llm.request span. The call goes through
- *     `traceLlmGeneration` (lib/observability/tracer.ts) exactly as every
- *     ADK-path adapter's call does, with the adapter's `provider`, the
- *     shim's model id and the request, here the ModelRequest the shim hands
- *     the adapter (an ADK-path adapter maps its LlmRequest to one for a
- *     failed call's payload). So the step budget, a stopped
- *     turn's refusal (STEP_LIMIT, DEADLINE_EXCEEDED, CANCELED, as the same
- *     LlmResponse), the token charge and the span's attributes are what
- *     GptLlm and the chat-completions adapters produce. A refused
- *     call never reaches the adapter. The adapter decorates the open span
- *     with `setLlmSpanAttribute`, and never opens one of its own.
- *   - The abort signal. The request's `signal` aborts when the turn stops
- *     (`currentTurnSignal()`) or when the signal ADK passes aborts, whichever
- *     comes first; an adapter hands it to its provider call.
- *
- * TWO SEAMS FOR A SUBCLASS, the genai mapping by default:
- *   - `toLlmResponse` (ADR 0056) keeps what an ADK-path adapter wrote beyond
- *     the contract: GptLlm's usage and server-side tool record, and the
- *     chat-completions shims' usage and final shape. It runs inside the
- *     span, so the tracer reads what it returns.
- *   - `toModelRequest` (ADR 0057) carries what an adapter reads beside the
- *     contract: the chat-completions shims' older generateContentConfig
- *     spelling. The span records the request it returns.
- *
- * WHAT IT DOES NOT DO:
- *   - Repair an adapter that breaks the contract. A throw reaches ADK as a
- *     throw (as Gemini's does today), and every response is mapped as it
- *     comes, so a missing final or a response after it passes through.
- *   - Live connections. `connect()` is refused, as on every adapter but
- *     ADK's Gemini: live sessions are outside the contract.
- *
- * ONE SHIM PER LEAF ADAPTER. A fallback pair on the ADK path is
- * `FallbackLlm(shim(primary), shim(fallback))` (ADR 0044), so each model call
- * is charged and traced on its own, as today. A FallbackAdapter behind one
- * shim would make a redirected call one span and one charge.
- */
-import { BaseLlm } from '../adkPeer.ts';
-import type { BaseLlmConnection, BaseLlmType, LlmRequest, LlmResponse } from '@google/adk';
-import type { ModelAdapter, ModelRequest, ModelResponse } from './contract.ts';
-import type { ModelRequestOptions } from './genaiMapping.ts';
-export interface AdkShimOptions {
-    /**
-     * The model id ADK and the span see, and the request's `model`. Default
-     * the adapter's own `model`, which is what an adapter for one YAML id has.
-     */
-    model?: string;
-}
-/** Builds the adapter for a model id: what a registered shim class calls when ADK constructs it. */
-export type ModelAdapterFactory = (model: string) => ModelAdapter;
-export declare class AdkShim extends BaseLlm {
-    /** The adapter every call runs through. */
-    readonly adapter: ModelAdapter;
-    constructor(adapter: ModelAdapter, options?: AdkShimOptions);
-    /**
-     * One model call: charged against the turn and traced as one llm.request
-     * span, then mapped to the contract and back. A call the turn refuses
-     * yields the refusal and never reaches the adapter.
-     */
-    generateContentAsync(llmRequest: LlmRequest, stream?: boolean, abortSignal?: AbortSignal): AsyncGenerator<LlmResponse, void>;
-    /** Runs inside the span: the adapter's setLlmSpanAttribute calls land on it. */
-    private generateInner;
-    /**
-     * The ModelRequest one call hands the adapter: `llmRequestToModelRequest`.
-     * A provider's ADK class may extend it with what its adapter reads on the
-     * ADK path only, an agent setting the contract leaves out: ClaudeLlm's
-     * older reasoning spelling (ADR 0055), and the chat-completions shims'
-     * older generateContentConfig spelling (ADR 0057). It never removes or
-     * rewrites a contract field. The span records what it returns.
-     */
-    protected toModelRequest(llmRequest: LlmRequest, options: ModelRequestOptions): ModelRequest;
-    /**
-     * One ModelResponse as the LlmResponse ADK sees: modelResponseToLlmResponse.
-     * It runs inside the llm.request span, so the tracer reads what it returns.
-     * A subclass that stands in for an ADK-path adapter overrides it to keep
-     * what that adapter wrote beyond the contract (GptLlm, ADR 0056; the
-     * chat-completions shims, ADR 0057).
-     */
-    protected toLlmResponse(response: ModelResponse): LlmResponse;
-    /** Live/bidirectional connections are outside the model contract. Throws to say so. */
-    connect(_llmRequest: LlmRequest): Promise<BaseLlmConnection>;
-}
-/** A shim around `adapter`, under `model` (default the adapter's own id). */
-export declare function adkShim(adapter: ModelAdapter, model?: string): AdkShim;
-/**
- * A shim class ADK's LLMRegistry can register: it answers for
- * `supportedModels` and builds its adapter with `createAdapter(model)` when
- * ADK constructs it for a model id. Pass the direct adapter's own pattern
- * instances, since the registry keys on the pattern object (see
- * lib/models/gatewayLlm.ts), so the shim replaces that entry rather than
- * shadowing it.
- */
-export declare function adkShimClass(supportedModels: Array<string | RegExp>, createAdapter: ModelAdapterFactory): BaseLlmType & (new (params: {
-    model: string;
-}) => AdkShim);

package/dist/lib/models/adkShim.js

@@ -1,136 +0,0 @@
-/**
- * lib/models/adkShim.ts — any ModelAdapter on the engine's own contract
- * (lib/models/contract.ts, ADR 0048) as an ADK BaseLlm, so an adapter can
- * move onto the contract while ADK still runs every turn (ADR 0045).
- *
- * WHY this file exists:
- *   ADK calls `BaseLlm.generateContentAsync(llmRequest, stream, abortSignal)`
- *   and expects LlmResponses back. An adapter on the contract implements
- *   `generate(ModelRequest)` and yields ModelResponses. The shim is the one
- *   class between them: it maps the LlmRequest in and each ModelResponse out
- *   through lib/models/genaiMapping.ts, and does no translation of its own.
- *   The adapter tickets move one adapter at a time behind it, and ADK sees
- *   no change: ClaudeLlm (lib/models/claudeLlm.ts) is the shim around
- *   ClaudeAdapter. A provider's ADK class may extend `toModelRequest` with
- *   what its adapter reads on the ADK path only (ADR 0055).
- *
- * WHAT THE SHIM DOES ONCE, SO NO CONTRACT ADAPTER DOES IT (ADR 0053):
- *   - The turn's charge and the llm.request span. The call goes through
- *     `traceLlmGeneration` (lib/observability/tracer.ts) exactly as every
- *     ADK-path adapter's call does, with the adapter's `provider`, the
- *     shim's model id and the request, here the ModelRequest the shim hands
- *     the adapter (an ADK-path adapter maps its LlmRequest to one for a
- *     failed call's payload). So the step budget, a stopped
- *     turn's refusal (STEP_LIMIT, DEADLINE_EXCEEDED, CANCELED, as the same
- *     LlmResponse), the token charge and the span's attributes are what
- *     GptLlm and the chat-completions adapters produce. A refused
- *     call never reaches the adapter. The adapter decorates the open span
- *     with `setLlmSpanAttribute`, and never opens one of its own.
- *   - The abort signal. The request's `signal` aborts when the turn stops
- *     (`currentTurnSignal()`) or when the signal ADK passes aborts, whichever
- *     comes first; an adapter hands it to its provider call.
- *
- * TWO SEAMS FOR A SUBCLASS, the genai mapping by default:
- *   - `toLlmResponse` (ADR 0056) keeps what an ADK-path adapter wrote beyond
- *     the contract: GptLlm's usage and server-side tool record, and the
- *     chat-completions shims' usage and final shape. It runs inside the
- *     span, so the tracer reads what it returns.
- *   - `toModelRequest` (ADR 0057) carries what an adapter reads beside the
- *     contract: the chat-completions shims' older generateContentConfig
- *     spelling. The span records the request it returns.
- *
- * WHAT IT DOES NOT DO:
- *   - Repair an adapter that breaks the contract. A throw reaches ADK as a
- *     throw (as Gemini's does today), and every response is mapped as it
- *     comes, so a missing final or a response after it passes through.
- *   - Live connections. `connect()` is refused, as on every adapter but
- *     ADK's Gemini: live sessions are outside the contract.
- *
- * ONE SHIM PER LEAF ADAPTER. A fallback pair on the ADK path is
- * `FallbackLlm(shim(primary), shim(fallback))` (ADR 0044), so each model call
- * is charged and traced on its own, as today. A FallbackAdapter behind one
- * shim would make a redirected call one span and one charge.
- */
-import { BaseLlm } from '../adkPeer.js';
-import { llmRequestToModelRequest, modelResponseToLlmResponse } from './genaiMapping.js';
-import { traceLlmGeneration } from '../observability/tracer.js';
-import { currentTurnSignal } from '../runtime/turnControl.js';
-/** One signal that aborts when any of the given ones does; undefined when none is given. */
-function eitherSignal(...candidates) {
-    const signals = [...new Set(candidates.filter((s) => s !== undefined))];
-    return signals.length <= 1 ? signals[0] : AbortSignal.any(signals);
-}
-export class AdkShim extends BaseLlm {
-    /** The adapter every call runs through. */
-    adapter;
-    constructor(adapter, options = {}) {
-        super({ model: options.model ?? adapter.model });
-        this.adapter = adapter;
-    }
-    /**
-     * One model call: charged against the turn and traced as one llm.request
-     * span, then mapped to the contract and back. A call the turn refuses
-     * yields the refusal and never reaches the adapter.
-     */
-    async *generateContentAsync(llmRequest, stream = false, abortSignal) {
-        const signal = eitherSignal(abortSignal, currentTurnSignal(), llmRequest.config?.abortSignal);
-        const request = this.toModelRequest(llmRequest, {
-            model: this.model,
-            stream,
-            ...(signal ? { signal } : {}),
-        });
-        yield* traceLlmGeneration({ provider: this.adapter.provider, model: this.model, request }, this.generateInner(request));
-    }
-    /** Runs inside the span: the adapter's setLlmSpanAttribute calls land on it. */
-    async *generateInner(request) {
-        for await (const response of this.adapter.generate(request)) {
-            yield this.toLlmResponse(response);
-        }
-    }
-    /**
-     * The ModelRequest one call hands the adapter: `llmRequestToModelRequest`.
-     * A provider's ADK class may extend it with what its adapter reads on the
-     * ADK path only, an agent setting the contract leaves out: ClaudeLlm's
-     * older reasoning spelling (ADR 0055), and the chat-completions shims'
-     * older generateContentConfig spelling (ADR 0057). It never removes or
-     * rewrites a contract field. The span records what it returns.
-     */
-    toModelRequest(llmRequest, options) {
-        return llmRequestToModelRequest(llmRequest, options);
-    }
-    /**
-     * One ModelResponse as the LlmResponse ADK sees: modelResponseToLlmResponse.
-     * It runs inside the llm.request span, so the tracer reads what it returns.
-     * A subclass that stands in for an ADK-path adapter overrides it to keep
-     * what that adapter wrote beyond the contract (GptLlm, ADR 0056; the
-     * chat-completions shims, ADR 0057).
-     */
-    toLlmResponse(response) {
-        return modelResponseToLlmResponse(response);
-    }
-    /** Live/bidirectional connections are outside the model contract. Throws to say so. */
-    async connect(_llmRequest) {
-        throw new Error(`${this.model} runs through the ADK shim, which does not support live bidirectional connections ` +
-            '(they are outside the model contract). Use a Gemini model for live/streaming sessions.');
-    }
-}
-/** A shim around `adapter`, under `model` (default the adapter's own id). */
-export function adkShim(adapter, model = adapter.model) {
-    return new AdkShim(adapter, { model });
-}
-/**
- * A shim class ADK's LLMRegistry can register: it answers for
- * `supportedModels` and builds its adapter with `createAdapter(model)` when
- * ADK constructs it for a model id. Pass the direct adapter's own pattern
- * instances, since the registry keys on the pattern object (see
- * lib/models/gatewayLlm.ts), so the shim replaces that entry rather than
- * shadowing it.
- */
-export function adkShimClass(supportedModels, createAdapter) {
-    return class AdkShimFor extends AdkShim {
-        static supportedModels = supportedModels;
-        constructor({ model }) {
-            super(createAdapter(model), { model });
-        }
-    };
-}