melchizedek-agents 0.20.0 → 1.0.1

package/dist/lib/model.js

@@ -1,24 +1,18 @@
 /**
  * lib/model.ts — the `melchizedek-agents/model` entry: the engine's model
- * layer on its own, with no @google/adk (ADR 0068).
+ * layer on its own (ADR 0068).
  *
  * What it holds: the model contract's types (ADR 0048), every provider's
  * contract adapter, resolveAdapter and resolveAdapterWithFallback over the
  * one prefix table (ADR 0060), FallbackAdapter and the circuit breaker's
  * helpers (ADR 0044). A consumer can call any model through it without
- * installing ADK, the peer dependency the rest of the package needs.
+ * loading the compiler or the runtime.
  *
- * What it leaves out, because each loads ADK: AdkGeminiAdapter, the ADK
- * shims (ClaudeLlm, GptLlm and the rest), TracedGemini, resolveModel and
- * registerAvailableProviders. They stay at `melchizedek-agents/models/*`.
+ * Gemini: resolveAdapter returns the engine's GeminiAdapter for a Gemini id;
+ * GEMINI_ADAPTER=adk throws, naming 1.0.0 (ADR 0107).
  *
- * Gemini: resolveAdapter here returns the engine's GeminiAdapter for a
- * Gemini id. Asking for `adk` (the option, or GEMINI_ADAPTER=adk) throws and
- * names `melchizedek-agents/models/registry`, whose resolveAdapter keeps
- * ADR 0060's default until gate G3.
- *
- * tests/packageSurface.test.ts walks this module's runtime import graph and
- * fails if any module in it names @google/adk.
+ * tests/packageSurface.test.ts walks this module's runtime import graph:
+ * @google/* appears in it only in the Gemini adapter and the genai mapping.
  */
 // ── Resolve an adapter by model id ──────────────────────────────────────────
 export { resolveAdapter, resolveAdapterWithFallback, geminiAdapterSetting } from './models/adapterResolver.js';

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

@@ -1,23 +1,18 @@
 /**
  * lib/models/adapterResolver.ts — one model id to one ModelAdapter on the
- * engine's own contract (ADR 0048, ADR 0060), with no @google/adk in its
- * import graph.
+ * engine's own contract (ADR 0048, ADR 0060, ADR 0107).
  *
- * WHY its own module: lib/models/registry.ts imports ADK (it registers the
- * ADK classes and builds TracedGemini), so the `melchizedek-agents/model`
- * entry (lib/model.ts) cannot load it. The routing step both paths share
- * (routeFor: the provider from the prefix table, the caller's endpoint merged
- * over the environment's, the transport from planTransport), the BYOK scoping
- * and the contract adapter table live here; registry.ts imports them for
- * resolveModel and for its own resolveAdapter.
+ * The routing step (routeFor: the provider from the prefix table, the
+ * caller's endpoint merged over the environment's, the transport from
+ * planTransport), the BYOK scoping and the contract adapter table live
+ * here. lib/models/registry.ts re-exports the resolver and builds
+ * resolveModel on it; `melchizedek-agents/model` (lib/model.ts) exports it
+ * with no compiler or runtime in its import graph (ADR 0068).
  *
- * GEMINI (ADR 0068, ADR 0100): a Gemini id gets the engine's GeminiAdapter
- * unless `adk` is asked for, by the option or by GEMINI_ADAPTER=adk.
- * `adapterResolver(adkGemini)` takes the factory for the temporary
- * AdkGeminiAdapter from its caller: registry.ts passes one, so `adk` works
- * there for one release (with @google/adk installed). The resolver exported
- * here has none, so asking it for `adk` throws and names the entry that has
- * it.
+ * GEMINI (ADR 0100, ADR 0107): a Gemini id gets the engine's GeminiAdapter.
+ * GEMINI_ADAPTER=engine, or the `gemini: 'engine'` option, is accepted and
+ * changes nothing; `adk`, the ADK Gemini adapter that 1.0.0 removed, throws
+ * an error naming the release.
  */
 import type { ModelAdapter } from './contract.ts';
 import type { ProviderEndpoint } from './endpoints.ts';
@@ -51,14 +46,9 @@ export declare function routeFor(model: string, apiKey: string | undefined, endp
 export declare function scopedKey(model: string, apiKey: string | undefined, keyProvider: ProviderId): string | undefined;
 /** A provider name as the A2A X-Provider header gives it; anything unknown reads as gemini. */
 export declare function normalizeProvider(provider?: string): ProviderId;
-/**
- * Which adapter serves a Gemini id on the contract path: `adk`, the temporary
- * AdkGeminiAdapter over ADK's Gemini (lib/models/adkGeminiAdapter.ts), or
- * `engine`, the engine's own GeminiAdapter on @google/genai
- * (lib/models/geminiAdapter.ts).
- */
-export type GeminiAdapterChoice = 'adk' | 'engine';
-/** GEMINI_ADAPTER as set (`adk` or `engine`), or undefined when unset. Any other value is a configuration error. */
+/** Which adapter serves a Gemini id: the engine's GeminiAdapter (lib/models/geminiAdapter.ts), the only one since 1.0.0. */
+export type GeminiAdapterChoice = 'engine';
+/** GEMINI_ADAPTER as set (`engine`), or undefined when unset. `adk` throws, naming 1.0.0; any other value is a configuration error. */
 export declare function geminiAdapterSetting(env?: NodeJS.ProcessEnv): GeminiAdapterChoice | undefined;
 export interface ResolveAdapterOptions {
     /**
@@ -75,33 +65,24 @@ export interface ResolveAdapterOptions {
     /** Where requests go (ADR 0023), merged over the environment's endpoint for the model's provider. */
     endpoint?: Partial<ProviderEndpoint>;
     /**
-     * Which Gemini adapter a Gemini id gets. Default: GEMINI_ADAPTER, else
-     * `engine` (since 0.20.0, ADR 0100). `adk` is available for one release
-     * through `melchizedek-agents/models/registry` with @google/adk installed;
-     * `melchizedek-agents/model` has no `adk`.
+     * Which Gemini adapter a Gemini id gets: `engine`, the only one (ADR 0107).
+     * GEMINI_ADAPTER is still read, so `adk` there throws.
      */
     gemini?: GeminiAdapterChoice;
 }
 /** What a direct route's adapter is built from. */
 export type AdapterRoute = Pick<Route, 'model' | 'apiKey' | 'endpoint'>;
-/** Builds the temporary AdkGeminiAdapter; only lib/models/registry.ts supplies one. */
-export type AdkGeminiFactory = (route: AdapterRoute) => ModelAdapter;
 export interface AdapterResolver {
     resolveAdapter(modelId: string, options?: ResolveAdapterOptions): ModelAdapter;
     resolveAdapterWithFallback(modelId: string, fallbackId: string | undefined, options?: ResolveAdapterOptions, fallbackOptions?: FallbackAdapterOptions): ModelAdapter;
 }
-/**
- * A resolver over the one prefix table. A Gemini id gets GeminiAdapter
- * unless `adk` is asked for (ADR 0100). With `adkGemini`, `adk` gets
- * AdkGeminiAdapter (ADR 0060); without it, asking for `adk` throws (ADR 0068).
- */
-export declare function adapterResolver(adkGemini?: AdkGeminiFactory): AdapterResolver;
+/** A resolver over the one prefix table. A Gemini id gets GeminiAdapter (ADR 0100, ADR 0107). */
+export declare function adapterResolver(): AdapterResolver;
 /**
  * Resolves a model id to the engine's own ModelAdapter (ADR 0048), from the
- * prefix table and the transport rule resolveModel uses, with no ADK: the
- * provider's adapter when its key (env, BYOK or endpoint) is present, the
- * gateway's when it is absent and MODEL_GATEWAY is set. A Gemini id gets
- * GeminiAdapter (ADR 0068). The adapter opens no span and charges nothing:
+ * prefix table and the transport rule: the provider's adapter when its key
+ * (env, BYOK or endpoint) is present, the gateway's when it is absent and
+ * MODEL_GATEWAY is set. A Gemini id gets GeminiAdapter. The adapter opens no span and charges nothing:
  * its caller does (ADR 0053).
  */
 export declare function resolveAdapter(modelId: string, options?: ResolveAdapterOptions): ModelAdapter;

package/dist/lib/models/adapterResolver.js

@@ -1,23 +1,18 @@
 /**
  * lib/models/adapterResolver.ts — one model id to one ModelAdapter on the
- * engine's own contract (ADR 0048, ADR 0060), with no @google/adk in its
- * import graph.
+ * engine's own contract (ADR 0048, ADR 0060, ADR 0107).
  *
- * WHY its own module: lib/models/registry.ts imports ADK (it registers the
- * ADK classes and builds TracedGemini), so the `melchizedek-agents/model`
- * entry (lib/model.ts) cannot load it. The routing step both paths share
- * (routeFor: the provider from the prefix table, the caller's endpoint merged
- * over the environment's, the transport from planTransport), the BYOK scoping
- * and the contract adapter table live here; registry.ts imports them for
- * resolveModel and for its own resolveAdapter.
+ * The routing step (routeFor: the provider from the prefix table, the
+ * caller's endpoint merged over the environment's, the transport from
+ * planTransport), the BYOK scoping and the contract adapter table live
+ * here. lib/models/registry.ts re-exports the resolver and builds
+ * resolveModel on it; `melchizedek-agents/model` (lib/model.ts) exports it
+ * with no compiler or runtime in its import graph (ADR 0068).
  *
- * GEMINI (ADR 0068, ADR 0100): a Gemini id gets the engine's GeminiAdapter
- * unless `adk` is asked for, by the option or by GEMINI_ADAPTER=adk.
- * `adapterResolver(adkGemini)` takes the factory for the temporary
- * AdkGeminiAdapter from its caller: registry.ts passes one, so `adk` works
- * there for one release (with @google/adk installed). The resolver exported
- * here has none, so asking it for `adk` throws and names the entry that has
- * it.
+ * GEMINI (ADR 0100, ADR 0107): a Gemini id gets the engine's GeminiAdapter.
+ * GEMINI_ADAPTER=engine, or the `gemini: 'engine'` option, is accepted and
+ * changes nothing; `adk`, the ADK Gemini adapter that 1.0.0 removed, throws
+ * an error naming the release.
  */
 import { ClaudeAdapter } from './claudeAdapter.js';
 import { mergeEndpoint } from './endpoints.js';
@@ -61,14 +56,21 @@ export function normalizeProvider(provider) {
     }
     return 'gemini';
 }
-/** GEMINI_ADAPTER as set (`adk` or `engine`), or undefined when unset. Any other value is a configuration error. */
+/** The error for GEMINI_ADAPTER=adk, or the `gemini: 'adk'` option: the ADK Gemini adapter left in 1.0.0. */
+function adkGeminiRemoved(source) {
+    return new Error(`${source} asks for the ADK Gemini adapter, which was removed in melchizedek-agents 1.0.0 (ADR 0107): ` +
+        `every Gemini id runs on the engine's GeminiAdapter. Unset ${source} (or set it to "engine").`);
+}
+/** GEMINI_ADAPTER as set (`engine`), or undefined when unset. `adk` throws, naming 1.0.0; any other value is a configuration error. */
 export function geminiAdapterSetting(env = process.env) {
     const raw = env.GEMINI_ADAPTER?.trim().toLowerCase();
     if (!raw)
         return undefined;
-    if (raw === 'adk' || raw === 'engine')
+    if (raw === 'engine')
         return raw;
-    throw new Error('GEMINI_ADAPTER must be "adk" or "engine".');
+    if (raw === 'adk')
+        throw adkGeminiRemoved('GEMINI_ADAPTER');
+    throw new Error('GEMINI_ADAPTER must be "engine" (the only Gemini adapter since 1.0.0).');
 }
 /** Each non-Gemini provider's contract adapter for a direct route. */
 const CONTRACT_ADAPTER = {
@@ -78,21 +80,12 @@ const CONTRACT_ADAPTER = {
     xai: (r) => new GrokAdapter({ model: r.model, apiKey: r.apiKey }),
     moonshot: (r) => new KimiAdapter({ model: r.model, apiKey: r.apiKey, baseUrl: r.endpoint?.baseURL }),
 };
-/**
- * A resolver over the one prefix table. A Gemini id gets GeminiAdapter
- * unless `adk` is asked for (ADR 0100). With `adkGemini`, `adk` gets
- * AdkGeminiAdapter (ADR 0060); without it, asking for `adk` throws (ADR 0068).
- */
-export function adapterResolver(adkGemini) {
+/** A resolver over the one prefix table. A Gemini id gets GeminiAdapter (ADR 0100, ADR 0107). */
+export function adapterResolver() {
     const geminiFor = (r, choice) => {
-        const route = { model: r.model, apiKey: r.apiKey, endpoint: r.endpoint };
-        if (choice === 'engine')
-            return new GeminiAdapter(route);
-        if (!adkGemini) {
-            throw new Error('The ADK Gemini adapter is not available from melchizedek-agents/model, which loads no @google/adk. ' +
-                'Use gemini: "engine" (or unset GEMINI_ADAPTER), or resolve through melchizedek-agents/models/registry.');
-        }
-        return adkGemini(route);
+        if (choice !== 'engine')
+            throw adkGeminiRemoved(`The gemini option ("${choice}")`);
+        return new GeminiAdapter({ model: r.model, apiKey: r.apiKey, endpoint: r.endpoint });
     };
     function resolveAdapter(modelId, options = {}) {
         const keyProvider = options.keyProvider === undefined ? providerForModel(modelId) : normalizeProvider(options.keyProvider);
@@ -113,17 +106,16 @@ export function adapterResolver(adkGemini) {
     }
     return { resolveAdapter, resolveAdapterWithFallback };
 }
-const ADK_FREE = adapterResolver();
+const RESOLVER = adapterResolver();
 /**
  * Resolves a model id to the engine's own ModelAdapter (ADR 0048), from the
- * prefix table and the transport rule resolveModel uses, with no ADK: the
- * provider's adapter when its key (env, BYOK or endpoint) is present, the
- * gateway's when it is absent and MODEL_GATEWAY is set. A Gemini id gets
- * GeminiAdapter (ADR 0068). The adapter opens no span and charges nothing:
+ * prefix table and the transport rule: the provider's adapter when its key
+ * (env, BYOK or endpoint) is present, the gateway's when it is absent and
+ * MODEL_GATEWAY is set. A Gemini id gets GeminiAdapter. The adapter opens no span and charges nothing:
  * its caller does (ADR 0053).
  */
 export function resolveAdapter(modelId, options = {}) {
-    return ADK_FREE.resolveAdapter(modelId, options);
+    return RESOLVER.resolveAdapter(modelId, options);
 }
 /**
  * An agent's model and its `fallback_model:`: a FallbackAdapter (ADR 0044)
@@ -133,5 +125,5 @@ export function resolveAdapter(modelId, options = {}) {
  * server env.
  */
 export function resolveAdapterWithFallback(modelId, fallbackId, options = {}, fallbackOptions = {}) {
-    return ADK_FREE.resolveAdapterWithFallback(modelId, fallbackId, options, fallbackOptions);
+    return RESOLVER.resolveAdapterWithFallback(modelId, fallbackId, options, fallbackOptions);
 }

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

@@ -11,9 +11,7 @@
  *   is a small subclass supplying the endpoint, the auth headers, the wire
  *   model name, its reasoning field, the tool choices it honours and its
  *   error wording (lib/models/ollamaAdapter.ts, kimiAdapter.ts,
- *   gatewayAdapter.ts). There is no ADK here: under ADK each adapter runs
- *   behind its shim class (OllamaLlm, KimiLlm, GatewayLlm, through
- *   OpenAiCompatibleLlm in lib/models/openAiCompatibleLlm.ts, ADR 0057).
+ *   gatewayAdapter.ts; ADR 0057).
  *   wiki/models/model-contract.md ("Chat completions") is the mapping spec.
  *
  * WHAT THE BASE PROVIDES (uniformly, for every subclass):
@@ -21,8 +19,8 @@
  *     message first; user text and inline images (data URIs; a URL blob is
  *     not sent); assistant text and tool_calls; one `tool` message per tool
  *     result, its content the result's JSON in the genai envelope ({ result }
- *     for a non-object, { error } for a failure), so the wire is what the ADK
- *     path sent. Thinking is never sent.
+ *     for a non-object, { error } for a failure), the wire ADK sent.
+ *     Thinking is never sent.
  *   - Tools as function tools, the schema as written (lowercase JSON Schema),
  *     its strict form with `strict: true` when the declaration asks.
  *     `toolChoice: 'none'` sends no tools; `required` and a named tool go as
@@ -57,24 +55,6 @@
  *     llm.retries, llm.retry_without_thinking, and the search and drop marks.
  */
 import type { ModelAdapter, ModelRequest, ModelResponse, ReasoningSetting, ToolChoiceMode, Usage } from './contract.ts';
-/**
- * What an agent's older generateContentConfig spelling asks of a
- * chat-completions provider that the contract has no field for (ADR 0047;
- * "What the contract leaves out" in wiki/models/model-contract.md). Only the
- * ADK shim around these adapters sets it, from the LlmRequest, so an agent
- * keeps it on the ADK runtime; the native runtime never sets it.
- */
-export interface OlderSpelling {
-    /**
-     * An effort word that is not a contract level, such as Kimi K3's `max`,
-     * sent as `reasoning_effort` as written, in place of `reasoning`'s word.
-     */
-    reasoningEffort?: string;
-}
-/** A ModelRequest, plus what the ADK path carries beside the contract. */
-export interface ChatCompletionsRequest extends ModelRequest {
-    olderSpelling?: OlderSpelling;
-}
 type ChatContentPart = {
     type: 'text';
     text: string;
@@ -116,9 +96,9 @@ export interface ChatFailure {
 /** The providerState kind an opted-in adapter writes: an assistant message's reasoning_content. */
 export declare const REASONING_CONTENT_KIND = "reasoning_content";
 /**
- * The prefix of a call id the engine made when the provider returned none.
- * ADK uses it for its own ids and leaves such ids out of the requests it
- * builds, so on the ADK path the stored history reads as it did.
+ * The prefix of a call id the engine made when the provider returned none:
+ * ADK's prefix for its own ids, kept so sessions ADK wrote and sessions the
+ * engine writes read alike.
  */
 export declare const ENGINE_CALL_ID_PREFIX = "adk-";
 /**
@@ -210,13 +190,12 @@ export declare abstract class ChatCompletionsAdapter implements ModelAdapter {
     /**
      * The body fields for the request's reasoning. Default: `reasoning_effort`
      * as the effort word ADR 0047 gives this model (lib/models/reasoning.ts),
-     * the field every chat-completions provider and gateway reads; the older
-     * spelling's word as written when the ADK path carries one; nothing when
-     * neither is set.
+     * the field every chat-completions provider and gateway reads; nothing
+     * when the request sets no reasoning.
      */
-    protected reasoningFields(model: string, setting: ReasoningSetting | undefined, olderWord: string | undefined): Record<string, unknown>;
+    protected reasoningFields(model: string, setting: ReasoningSetting | undefined): Record<string, unknown>;
     /** Provider-specific body fields, merged last. */
-    protected extraBodyFields(_request: ChatCompletionsRequest): Record<string, unknown>;
+    protected extraBodyFields(_request: ModelRequest): Record<string, unknown>;
     /**
      * Body fields enabling the provider's NATIVE web search, or null when the
      * provider has none (the base then drops the tool, marks the span and
@@ -270,9 +249,9 @@ export declare abstract class ChatCompletionsAdapter implements ModelAdapter {
      * usage, so budgets and the ledger still count it. A request that already
      * asks for no reasoning is not retried.
      */
-    generate(request: ChatCompletionsRequest): AsyncGenerator<ModelResponse, void>;
+    generate(request: ModelRequest): AsyncGenerator<ModelResponse, void>;
     /** The chat messages this adapter sends for a request, the system message first. */
-    messagesFor(request: ChatCompletionsRequest): ChatMessage[];
+    messagesFor(request: ModelRequest): ChatMessage[];
     /** The function tools this adapter sends for a request: none under `toolChoice: 'none'`. */
     toolsFor(request: ModelRequest): Array<Record<string, unknown>>;
 }

package/dist/lib/models/chatCompletionsAdapter.js

@@ -11,9 +11,7 @@
  *   is a small subclass supplying the endpoint, the auth headers, the wire
  *   model name, its reasoning field, the tool choices it honours and its
  *   error wording (lib/models/ollamaAdapter.ts, kimiAdapter.ts,
- *   gatewayAdapter.ts). There is no ADK here: under ADK each adapter runs
- *   behind its shim class (OllamaLlm, KimiLlm, GatewayLlm, through
- *   OpenAiCompatibleLlm in lib/models/openAiCompatibleLlm.ts, ADR 0057).
+ *   gatewayAdapter.ts; ADR 0057).
  *   wiki/models/model-contract.md ("Chat completions") is the mapping spec.
  *
  * WHAT THE BASE PROVIDES (uniformly, for every subclass):
@@ -21,8 +19,8 @@
  *     message first; user text and inline images (data URIs; a URL blob is
  *     not sent); assistant text and tool_calls; one `tool` message per tool
  *     result, its content the result's JSON in the genai envelope ({ result }
- *     for a non-object, { error } for a failure), so the wire is what the ADK
- *     path sent. Thinking is never sent.
+ *     for a non-object, { error } for a failure), the wire ADK sent.
+ *     Thinking is never sent.
  *   - Tools as function tools, the schema as written (lowercase JSON Schema),
  *     its strict form with `strict: true` when the declaration asks.
  *     `toolChoice: 'none'` sends no tools; `required` and a named tool go as
@@ -66,9 +64,9 @@ import { currentTurnSignal } from '../runtime/turnControl.js';
 /** The providerState kind an opted-in adapter writes: an assistant message's reasoning_content. */
 export const REASONING_CONTENT_KIND = 'reasoning_content';
 /**
- * The prefix of a call id the engine made when the provider returned none.
- * ADK uses it for its own ids and leaves such ids out of the requests it
- * builds, so on the ADK path the stored history reads as it did.
+ * The prefix of a call id the engine made when the provider returned none:
+ * ADK's prefix for its own ids, kept so sessions ADK wrote and sessions the
+ * engine writes read alike.
  */
 export const ENGINE_CALL_ID_PREFIX = 'adk-';
 // ── <think> blocks ───────────────────────────────────────────────────────────
@@ -203,7 +201,7 @@ export function sumUsage(a, b) {
 export function reasonsNotAtAll(setting) {
     return setting === 'none' || (typeof setting === 'object' && setting !== null && setting.budget_tokens <= 0);
 }
-/** A tool result as the tool message's content: the genai envelope, so the wire is what the ADK path sent. */
+/** A tool result as the tool message's content: the genai envelope, the wire ADK sent. */
 function resultContent(part) {
     const response = part.isError ? { error: part.result } : isPlainObject(part.result) ? part.result : { result: part.result };
     return JSON.stringify(response);
@@ -329,12 +327,11 @@ export class ChatCompletionsAdapter {
     /**
      * The body fields for the request's reasoning. Default: `reasoning_effort`
      * as the effort word ADR 0047 gives this model (lib/models/reasoning.ts),
-     * the field every chat-completions provider and gateway reads; the older
-     * spelling's word as written when the ADK path carries one; nothing when
-     * neither is set.
+     * the field every chat-completions provider and gateway reads; nothing
+     * when the request sets no reasoning.
      */
-    reasoningFields(model, setting, olderWord) {
-        const word = olderWord ?? (setting !== undefined ? reasoningConfig(model, setting).reasoningEffort : undefined);
+    reasoningFields(model, setting) {
+        const word = setting !== undefined ? reasoningConfig(model, setting).reasoningEffort : undefined;
         return word !== undefined ? { reasoning_effort: word } : {};
     }
     /** Provider-specific body fields, merged last. */
@@ -437,9 +434,7 @@ export class ChatCompletionsAdapter {
             return;
         setLlmSpanAttribute('llm.retry_without_thinking', held.error?.code ?? true);
         this.#warnOnce('retry', `⚠ ${model} thought without answering (${held.error?.code}); retrying once with thinking off.`);
-        // The older spelling's effort word would ask for thinking again.
-        const { olderSpelling: _older, ...rest } = request;
-        const retry = { ...rest, reasoning: 'none' };
+        const retry = { ...request, reasoning: 'none' };
         for await (const response of this.#attempt(retry, model)) {
             if (response.partial) {
                 yield response;
@@ -672,7 +667,7 @@ export class ChatCompletionsAdapter {
             ...(sampling.topP !== undefined ? { top_p: sampling.topP } : {}),
             ...(sampling.maxOutputTokens !== undefined ? { max_tokens: sampling.maxOutputTokens } : {}),
             ...(sampling.stop?.length ? { stop: [...sampling.stop] } : {}),
-            ...this.reasoningFields(model, request.reasoning, request.olderSpelling?.reasoningEffort),
+            ...this.reasoningFields(model, request.reasoning),
             ...(tools.length > 0 ? { tools } : {}),
             ...(tools.length > 0 ? this.#toolChoice(choice, model, request.reasoning) : {}),
             ...this.#responseFormat(request),

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

@@ -3,11 +3,11 @@
  * `fallback_model:` (ADR 0044).
  *
  * WHY its own module:
- *   Two wrappers answer a failing provider from an agent's fallback model:
- *   FallbackLlm (lib/models/fallback.ts) around two ADK BaseLlm adapters,
- *   and FallbackAdapter (lib/models/fallbackAdapter.ts) around two adapters
- *   on the engine's own contract (ADR 0048). Both read and write the circuits
- *   here, so a provider tripped on one path is skipped on the other.
+ *   FallbackAdapter (lib/models/fallbackAdapter.ts) answers a failing
+ *   provider from an agent's fallback model, around two adapters on the
+ *   engine's own contract (ADR 0048), and the native loop's own fallback
+ *   step does the same. Both read and write the circuits here, so a provider
+ *   tripped on one path is skipped on the other.
  *
  * THE RULES:
  *   - One circuit per provider id (lib/models/providerMap.ts), shared by

package/dist/lib/models/circuitBreaker.js

@@ -3,11 +3,11 @@
  * `fallback_model:` (ADR 0044).
  *
  * WHY its own module:
- *   Two wrappers answer a failing provider from an agent's fallback model:
- *   FallbackLlm (lib/models/fallback.ts) around two ADK BaseLlm adapters,
- *   and FallbackAdapter (lib/models/fallbackAdapter.ts) around two adapters
- *   on the engine's own contract (ADR 0048). Both read and write the circuits
- *   here, so a provider tripped on one path is skipped on the other.
+ *   FallbackAdapter (lib/models/fallbackAdapter.ts) answers a failing
+ *   provider from an agent's fallback model, around two adapters on the
+ *   engine's own contract (ADR 0048), and the native loop's own fallback
+ *   step does the same. Both read and write the circuits here, so a provider
+ *   tripped on one path is skipped on the other.
  *
  * THE RULES:
  *   - One circuit per provider id (lib/models/providerMap.ts), shared by

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

@@ -4,11 +4,9 @@
  *
  * WHY this file exists:
  *   Claude's translation reads a ModelRequest and yields ModelResponses, so
- *   the native runtime (ADR 0045) can call it with no ADK in the path. On
- *   the ADK path, ClaudeLlm (lib/models/claudeLlm.ts) is this adapter behind
- *   the ADK shim (lib/models/adkShim.ts, ADR 0053): the shim charges the
- *   turn and opens the llm.request span, and this adapter only decorates
- *   that span with setLlmSpanAttribute.
+ *   the native loop (ADR 0045) calls it directly: the loop charges the turn
+ *   and opens the llm.request span (ADR 0053), and this adapter only
+ *   decorates that span with setLlmSpanAttribute.
  *
  * THE MAPPING is the Anthropic table of wiki/models/model-contract.md;
  * wiki/models/claude-adapter.md records the choices made inside it:
@@ -22,15 +20,13 @@
  *     the part they preceded as providerState (ADR 0046), and are replayed
  *     before that part within the current turn's tool loop, for this model
  *     only.
- *   - A tool result's content is the JSON of the result in the shape the ADK
- *     path stores it (`{ result }` for a value that is not an object,
- *     `{ error }` for a failure), so both runtimes send the same bytes
- *     (ADR 0055).
- *   - ClaudeLlm adds `claudeReasoning`, the older reasoning spelling read as
- *     ADR 0049 reads it, which this adapter reads in place of `reasoning`
- *     (ClaudeModelRequest, ADR 0055). The native runtime never sets it.
+ *   - A tool result's content is the JSON of the result in the shape the
+ *     stored events keep it (`{ result }` for a value that is not an object,
+ *     `{ error }` for a failure), the bytes ADK sent (ADR 0055).
+ *   - Reasoning is the contract's `reasoning`, read by claudeReasoningOf
+ *     (ADR 0049).
  *   - `outputFormat: 'json'` sends nothing: the Messages API has no JSON
- *     mode without a schema, and ClaudeLlm never sent one for
+ *     mode without a schema, and ADK's Claude path never sent one for
  *     `responseMimeType` alone (ADR 0061). The prompt asks for the JSON.
  *
  * THE ADAPTER RULES (contract.ts header) as this adapter keeps them:
@@ -45,25 +41,12 @@
  */
 import type { JsonSchema, ModelAdapter, ModelRequest, ModelResponse } from './contract.ts';
 import type { ProviderEndpoint } from './endpoints.ts';
-import type { ClaudeReasoning } from './claudeModels.ts';
 /** The provider id this adapter reports and writes its state under (lib/models/providerMap.ts). */
 export declare const ANTHROPIC_PROVIDER = "anthropic";
 /** The providerState kind this adapter writes: the signed blocks that preceded a part. */
 export declare const THINKING_STATE_KIND = "thinking_blocks";
 /** Name of the tool that carries an outputSchema answer where output_config.format is not used. */
 export declare const STRUCTURED_OUTPUT_TOOL = "structured_output";
-/**
- * A ModelRequest as the ADK path's ClaudeLlm hands it to this adapter
- * (ADR 0055). `claudeReasoning` is the agent's older reasoning spelling
- * (generateContentConfig.reasoningEffort and thinkingConfig.thinkingBudget)
- * read as ADR 0049 reads it, which `reasoning` cannot say in full: the effort
- * words `xhigh` and `max`, `minimal` as `low`, and the budget rows' reading
- * of the budget alone. When set it is read in place of `reasoning`. The
- * native runtime never sets it.
- */
-export interface ClaudeModelRequest extends ModelRequest {
-    claudeReasoning?: ClaudeReasoning;
-}
 /** A tool definition as the Messages API takes it: a client tool, or Anthropic's web search server tool. */
 export type AnthropicTool = {
     name: string;

package/dist/lib/models/claudeAdapter.js

@@ -4,11 +4,9 @@
  *
  * WHY this file exists:
  *   Claude's translation reads a ModelRequest and yields ModelResponses, so
- *   the native runtime (ADR 0045) can call it with no ADK in the path. On
- *   the ADK path, ClaudeLlm (lib/models/claudeLlm.ts) is this adapter behind
- *   the ADK shim (lib/models/adkShim.ts, ADR 0053): the shim charges the
- *   turn and opens the llm.request span, and this adapter only decorates
- *   that span with setLlmSpanAttribute.
+ *   the native loop (ADR 0045) calls it directly: the loop charges the turn
+ *   and opens the llm.request span (ADR 0053), and this adapter only
+ *   decorates that span with setLlmSpanAttribute.
  *
  * THE MAPPING is the Anthropic table of wiki/models/model-contract.md;
  * wiki/models/claude-adapter.md records the choices made inside it:
@@ -22,15 +20,13 @@
  *     the part they preceded as providerState (ADR 0046), and are replayed
  *     before that part within the current turn's tool loop, for this model
  *     only.
- *   - A tool result's content is the JSON of the result in the shape the ADK
- *     path stores it (`{ result }` for a value that is not an object,
- *     `{ error }` for a failure), so both runtimes send the same bytes
- *     (ADR 0055).
- *   - ClaudeLlm adds `claudeReasoning`, the older reasoning spelling read as
- *     ADR 0049 reads it, which this adapter reads in place of `reasoning`
- *     (ClaudeModelRequest, ADR 0055). The native runtime never sets it.
+ *   - A tool result's content is the JSON of the result in the shape the
+ *     stored events keep it (`{ result }` for a value that is not an object,
+ *     `{ error }` for a failure), the bytes ADK sent (ADR 0055).
+ *   - Reasoning is the contract's `reasoning`, read by claudeReasoningOf
+ *     (ADR 0049).
  *   - `outputFormat: 'json'` sends nothing: the Messages API has no JSON
- *     mode without a schema, and ClaudeLlm never sent one for
+ *     mode without a schema, and ADK's Claude path never sent one for
  *     `responseMimeType` alone (ADR 0061). The prompt asks for the JSON.
  *
  * THE ADAPTER RULES (contract.ts header) as this adapter keeps them:
@@ -150,7 +146,7 @@ export function anthropicTools(request) {
         tools.push(WEB_SEARCH_TOOL);
     return tools;
 }
-/** A tool result's content: the JSON of the result in the shape the ADK path stores it. */
+/** A tool result's content: the JSON of the result in the shape the stored events keep it (ADR 0055). */
 function toolResultBlock(part) {
     const response = part.isError ? { error: part.result } : isPlainObject(part.result) ? part.result : { result: part.result };
     return {
@@ -278,7 +274,7 @@ export class ClaudeAdapter {
     async #build(request, model, endpoint) {
         // ── The request surface this model takes (ADR 0049) ──────────────────────
         const gen = claudeGeneration(model);
-        const reasoning = request.claudeReasoning ?? claudeReasoningOf(request.reasoning);
+        const reasoning = claudeReasoningOf(request.reasoning);
         // Adaptive generations: thinking, effort and drop_block from the table.
         // Budget generations keep the budget path below.
         const plan = gen.thinking === 'adaptive' ? adaptiveThinkingFor(gen, reasoning) : undefined;

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

@@ -20,8 +20,8 @@
  *
  * How hard a request asks Claude to think reaches the table as one
  * `ClaudeReasoning`: from the contract's `reasoning` (claudeReasoningOf),
- * or, on the ADK path, from the agent's generateContentConfig as ADR 0049
- * reads it (claudeReasoningFromConfig, ADR 0055).
+ * or from the agent's generateContentConfig as ADR 0049 reads it
+ * (claudeReasoningFromConfig, ADR 0055).
  */
 import type { ReasoningSetting } from './contract.ts';
 import type { Platform } from './endpoints.ts';
@@ -83,8 +83,8 @@ export declare function claudeReasoningOf(setting: ReasoningSetting | undefined)
  * The older spelling in an agent's generateContentConfig, read as ADR 0049
  * reads it: the effort word first (`xhigh` and `max` pass through,
  * `minimal` is `low`), else the thinking budget rounded up to a level; and
- * the thinking budget as given, which is all the budget rows read. The ADK
- * path's ClaudeLlm hands the adapter this (ADR 0055).
+ * the thinking budget as given, which is all the budget rows read
+ * (ADR 0055).
  */
 export declare function claudeReasoningFromConfig(cfg: Record<string, any>): ClaudeReasoning;
 /** The beta that lets a request set `thinking.block_binding`. */

package/dist/lib/models/claudeModels.js

@@ -20,8 +20,8 @@
  *
  * How hard a request asks Claude to think reaches the table as one
  * `ClaudeReasoning`: from the contract's `reasoning` (claudeReasoningOf),
- * or, on the ADK path, from the agent's generateContentConfig as ADR 0049
- * reads it (claudeReasoningFromConfig, ADR 0055).
+ * or from the agent's generateContentConfig as ADR 0049 reads it
+ * (claudeReasoningFromConfig, ADR 0055).
  */
 import { REASONING_BUDGETS } from './reasoning.js';
 const BUDGET = {
@@ -163,8 +163,8 @@ export function claudeReasoningOf(setting) {
  * The older spelling in an agent's generateContentConfig, read as ADR 0049
  * reads it: the effort word first (`xhigh` and `max` pass through,
  * `minimal` is `low`), else the thinking budget rounded up to a level; and
- * the thinking budget as given, which is all the budget rows read. The ADK
- * path's ClaudeLlm hands the adapter this (ADR 0055).
+ * the thinking budget as given, which is all the budget rows read
+ * (ADR 0055).
  */
 export function claudeReasoningFromConfig(cfg) {
     const effort = requestedEffort(cfg);