melchizedek-agents 0.19.0 → 1.0.0

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

@@ -1,22 +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): `adapterResolver(adkGemini)` takes the factory for the
- * temporary AdkGeminiAdapter from its caller. registry.ts passes one, so its
- * resolveAdapter keeps ADR 0060's default (`adk` until gate G3). The resolver
- * exported here has none: a Gemini id gets the engine's GeminiAdapter unless
- * `adk` is asked for, by the option or by GEMINI_ADAPTER=adk, which throws
- * and names the entry that has it.
+ * 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';
@@ -50,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 {
     /**
@@ -74,32 +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
-     * `adk` through `melchizedek-agents/models/registry` and `engine` through
-     * `melchizedek-agents/model`, which 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. With `adkGemini`, a Gemini id gets
- * AdkGeminiAdapter unless `engine` is asked for (ADR 0060). Without it, a
- * Gemini id gets GeminiAdapter, and asking for `adk` throws (ADR 0068).
- */
-export declare function adapterResolver(adkGemini?: AdkGeminiFactory): AdapterResolver;
+/** 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,22 +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): `adapterResolver(adkGemini)` takes the factory for the
- * temporary AdkGeminiAdapter from its caller. registry.ts passes one, so its
- * resolveAdapter keeps ADR 0060's default (`adk` until gate G3). The resolver
- * exported here has none: a Gemini id gets the engine's GeminiAdapter unless
- * `adk` is asked for, by the option or by GEMINI_ADAPTER=adk, which throws
- * and names the entry that has it.
+ * 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';
@@ -60,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 = {
@@ -77,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. With `adkGemini`, a Gemini id gets
- * AdkGeminiAdapter unless `engine` is asked for (ADR 0060). Without it, a
- * Gemini id gets GeminiAdapter, and asking for `adk` throws (ADR 0068).
- */
-export function adapterResolver(adkGemini) {
+/** 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);
@@ -99,7 +93,7 @@ export function adapterResolver(adkGemini) {
         if (route.transport === 'gateway')
             return new GatewayAdapter({ model: modelId });
         if (route.provider === 'gemini') {
-            return geminiFor(route, options.gemini ?? geminiAdapterSetting() ?? (adkGemini ? 'adk' : 'engine'));
+            return geminiFor(route, options.gemini ?? geminiAdapterSetting() ?? 'engine');
         }
         return CONTRACT_ADAPTER[route.provider](route);
     }
@@ -112,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)
@@ -132,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/adkGeminiAdapter.js

@@ -71,6 +71,7 @@ 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. */
@@ -85,6 +86,7 @@ export class AdkGeminiAdapter {
     #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;

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

@@ -51,7 +51,7 @@
  * 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 '@google/adk';
+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';

package/dist/lib/models/adkShim.js

@@ -51,7 +51,7 @@
  * 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 '@google/adk';
+import { BaseLlm } from '../adkPeer.js';
 import { llmRequestToModelRequest, modelResponseToLlmResponse } from './genaiMapping.js';
 import { traceLlmGeneration } from '../observability/tracer.js';
 import { currentTurnSignal } from '../runtime/turnControl.js';

package/dist/lib/models/capabilities.js

@@ -108,8 +108,11 @@ export function capabilitySummary(agentName, r) {
 //
 // `evidence: 'test'` cells are asserted against the real outgoing request body
 // in tests/capabilityMatrix.test.ts, so changing an adapter without changing
-// its row fails a test. `evidence: 'adk'` cells are ADK's own Gemini adapter,
-// which this repo does not build requests for.
+// its row fails a test. Every cell is `test`. The Gemini row is the engine's
+// own GeminiAdapter (lib/models/geminiAdapter.ts), asserted on the real
+// @google/genai client over a stubbed fetch (gate G3, ADR 0100). `'adk'`
+// (a cell taken on trust from ADK's own Gemini) stays in the type because the
+// type is published (`melchizedek-agents/models/*`); no cell uses it.
 export const CAPABILITIES = [
     'delegation',
     'memory_tools',
@@ -132,18 +135,18 @@ const ok = (evidence = 'test', note) => note ? { support: 'supported', note, evi
 const degraded = (note) => ({ support: 'degraded', note, evidence: 'test' });
 const unsupported = (note) => ({ support: 'unsupported', note, evidence: 'test' });
 const nativeSearch = (row) => SERVER_SIDE_TOOLS.web_search.includes(row)
-    ? ok(row === 'gemini' ? 'adk' : 'test')
+    ? ok()
     : unsupported('no native search on this path; the web_search sentinel is dropped (use web_extract)');
 const responsesReasoningNote = (ids) => `encrypted reasoning items are replayed verbatim within the turn's tool loop, with store: false (ADR 0050); ${ids}`;
 const CHAT_THINKING_NOTE = "reasoning: is the lever, sent as reasoning_effort in the model's word, a thinking budget as the level that covers it (ADR 0047); the reasoning is not carried between tool steps, so the model re-reasons each step";
 export const CAPABILITY_MATRIX = {
     gemini: {
-        delegation: ok('adk'),
-        memory_tools: ok('adk'),
-        structured_output: ok('adk'),
-        thinking_with_tools: ok('adk'),
-        streaming: ok('adk'),
-        vision: ok('adk'),
+        delegation: ok(),
+        memory_tools: ok(),
+        structured_output: ok(),
+        thinking_with_tools: ok(),
+        streaming: ok(),
+        vision: ok(),
         native_search: nativeSearch('gemini'),
     },
     anthropic: {
@@ -286,7 +289,7 @@ export function renderCapabilityMatrix() {
         lines.push(`| ${CAPABILITY_LABELS[cap]} | ${cells.join(' | ')} |`);
     }
     lines.push('');
-    lines.push('✓ supported · ◐ degraded · ✗ unsupported. Gemini cells are ADK\'s own adapter; every other cell is asserted against the request the adapter sends.');
+    lines.push('✓ supported · ◐ degraded · ✗ unsupported. Every cell is asserted against the request the adapter sends; the Gemini column is the engine\'s own Gemini adapter.');
     lines.push('');
     notes.forEach((n, i) => lines.push(`${i + 1}. ${n}`));
     lines.push('');

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;