melchizedek-agents 0.20.0 → 1.0.0

package/dist/lib/models/genaiMapping.js

@@ -1,16 +1,15 @@
 /**
- * lib/models/genaiMapping.ts — @google/genai `Content`, and ADK's LlmRequest
- * and LlmResponse, to and from the engine's model contract
+ * lib/models/genaiMapping.ts — @google/genai `Content`, and the genai-shaped
+ * LlmRequest and LlmResponse, to and from the engine's model contract
  * (lib/models/contract.ts, ADR 0048).
  *
  * WHY this file exists:
- *   The ADK runtime holds and stores @google/genai `Content`: the history of
- *   an LlmRequest, and the `content` of every stored event. The native
- *   runtime and every adapter on the contract speak `Message` and `Part`.
- *   This module converts between the two, so the native runtime can read a
- *   session ADK stored, and an adapter can move onto the contract while ADK
- *   still runs: its ADK class maps the LlmRequest in and each ModelResponse
- *   out. It is pure (no I/O, clock or randomness) and never mutates its
+ *   Every stored event's `content` is @google/genai `Content`, the shape ADK
+ *   wrote and the engine keeps (ADR 0045's fixed shapes). The native loop
+ *   and every adapter on the contract speak `Message` and `Part`. This
+ *   module converts between the two, so the loop reads a session ADK stored
+ *   before 1.0.0 as it reads its own, and stores each answer in the same
+ *   shape (modelResponseToLlmResponse). It is pure (no I/O, clock or randomness) and never mutates its
  *   input; leaf values (args, results, payloads) are shared, not copied.
  *   The contract stays a leaf: only this module names @google/*.
  *   wiki/models/model-contract.md ("From genai Content") is the spec.
@@ -63,7 +62,8 @@
  *   genai bytes cannot tell the two apart.
  *
  *   Ids. A ToolCallPart always has an id. A genai call without one (Gemini
- *   returns none, and ADK strips its own `adk-` ids from every request) gets
+ *   returns none, and the engine strips its own `adk-` ids from every
+ *   request, as ADK did) gets
  *   `genai-noid-<content>-<part>`, from its position, and a result without
  *   one takes the id of the latest open minted call of the same name, else
  *   one of its own (it then answers no call in the history). Back, a minted
@@ -91,27 +91,24 @@
  * true`; usage in Gemini's meanings (usageToMetadata); error as `errorCode`
  * and `errorMessage`, key-shaped text scrubbed, with `retryable` and
  * `status` as customMetadata['error.retryable'] and ['error.status']
- * (withRetryVerdict, lib/models/errorResponse.ts), the only place
- * FallbackLlm reads whether a fallback may answer; finishReason as
+ * (withRetryVerdict, lib/models/errorResponse.ts); finishReason as
  * Gemini's, except that an error whose code is one of Gemini's finish
- * reasons (the Gemini adapters keep it verbatim: MALFORMED_FUNCTION_CALL,
- * RECITATION, ...) gets that reason itself, as ADK's Gemini reports both, so
- * self-correction retries a malformed call and the stored event reads the
- * same on either runtime (ADR 0088); grounding as the `webSearchQueries` and
+ * reasons (the Gemini adapter keeps it verbatim: MALFORMED_FUNCTION_CALL,
+ * RECITATION, ...) gets that reason itself, as ADK's Gemini reported both,
+ * so self-correction retries a malformed call and the stored event reads as
+ * one ADK stored (ADR 0088); grounding as the `webSearchQueries` and
  * `groundingChunks[].web` that lib/grounding.ts reads. Not carried, since
  * an LlmResponse has no field for them: `cacheWriteTokens`, a citation's
  * span and cited text, and which native tool ran a query.
  *
- * THE REVERSE: a contract adapter over an ADK BaseLlm (lib/models/
- * adkGeminiAdapter.ts, the wrapper over ADK's Gemini) maps the ModelRequest
- * it is given to an LlmRequest, and each LlmResponse back.
+ * THE REVERSE: a ModelRequest as a genai-shaped LlmRequest, and each
+ * LlmResponse back, for a caller that holds a genai-speaking model.
  *
- *   modelRequestToLlmRequest builds the LlmRequest ADK's path builds for a
- *   Gemini model: the system prompt as `systemInstruction`; the messages as
+ *   modelRequestToLlmRequest builds the genai-shaped request for a Gemini
+ *   model: the system prompt as `systemInstruction`; the messages as
  *   above; client tools as `functionDeclarations` with the lowercase schema
  *   in `parametersJsonSchema`, and in `toolsDict` as declaration-only
- *   entries, where llmRequestToModelRequest and the ADK-path adapters read
- *   them; native tools as Gemini's tool objects, in the request's order;
+ *   entries, where llmRequestToModelRequest reads them; native tools as Gemini's tool objects, in the request's order;
  *   toolChoice and strict as the function-calling mode, sent only beside
  *   declarations; the output schema as `responseJsonSchema`, and
  *   `outputFormat: 'json'` without one as `responseMimeType:
@@ -120,7 +117,7 @@
  *   it; sampling; the signal as `config.abortSignal`. What does not come
  *   back the same through llmRequestToModelRequest: `google_search` reads as
  *   `web_search`; `x_search` and `collections_search` are left out (Gemini
- *   has no tool for them, and ADK adds their sentinels only for xAI); `auto`
+ *   has no tool for them, and they go only to xAI); `auto`
  *   reads as absent, and a choice without tools is not sent; one strict tool
  *   makes every tool strict, and strict is lost beside a forced choice; a
  *   level a model renders as a budget or another word reads back as that
@@ -144,10 +141,13 @@
  *   display only (the caller yields it as a partial).
  *
  * USAGE MEANINGS. usageToMetadata and usageFromMetadata use Gemini's: its
- * `candidatesTokenCount` excludes the thinking in `thoughtsTokenCount`. The
- * ADK-path GPT and chat-completions adapters write `candidatesTokenCount`
- * with reasoning included, so usageFromMetadata on an event they stored
- * counts that reasoning twice in `outputTokens`.
+ * `candidatesTokenCount` excludes the thinking in `thoughtsTokenCount`.
+ * Every adapter's final is stored and charged through usageToMetadata, so
+ * this is the ledger's one meaning for every provider (ADR 0107).
+ * Events the GPT and chat-completions adapters stored under ADK (before
+ * 1.0.0) carry `candidatesTokenCount` with reasoning included, so
+ * usageFromMetadata on such an event counts that reasoning twice in
+ * `outputTokens`.
  */
 import { FinishReason, FunctionCallingConfigMode } from '@google/genai';
 import { ERROR_RETRYABLE_KEY, ERROR_STATUS_KEY, errorText, withRetryVerdict } from './errorResponse.js';
@@ -555,7 +555,7 @@ export function samplingOf(config) {
         sampling.stop = [...config.stopSequences];
     return Object.keys(sampling).length > 0 ? sampling : undefined;
 }
-/** An ADK LlmRequest as a ModelRequest (see the header for what is not mapped). */
+/** A genai-shaped LlmRequest as a ModelRequest (see the header for what is not mapped). */
 export function llmRequestToModelRequest(llmRequest, options = {}) {
     const model = options.model ?? llmRequest.model;
     if (!model)
@@ -662,8 +662,8 @@ export const TOO_DEEP_ARGUMENTS = `[arguments nested deeper than ${MAX_VALUE_DEP
 /**
  * One part of a model's answer as the contract allows it (lib/models/
  * contract.ts), or undefined to drop it. The contract binds an adapter, and
- * a model's answer is untrusted input to the runtime that stores it, so the
- * runtimes hold an adapter to it here rather than store a part no reader
+ * a model's answer is untrusted input to the loop that stores it, so the
+ * loop holds an adapter to it here rather than store a part no reader
  * expects (WS5-5, wiki/operations/native-loop-security.md):
  *   - a part that is not an object, of no known kind, or a tool result (an
  *     answer holds none) is dropped;
@@ -713,8 +713,8 @@ function contractOutputPart(part) {
 /**
  * `response` with each part held to the contract (contractOutputPart): the
  * same object when every part already is, else a copy with the parts
- * checked. Used by modelResponseToLlmResponse (the ADK shim's mapping) and
- * by the native step, so both runtimes read and store the same answer. A
+ * checked. Used by modelResponseToLlmResponse and by the native step, so the
+ * step reads the same answer it stores. A
  * response that is not an object is returned as it is: the caller fails on
  * it as on any adapter that broke the contract.
  */
@@ -728,7 +728,7 @@ export function contractModelResponse(response) {
         return response;
     return { ...response, parts: checked.filter((p) => p !== undefined) };
 }
-/** A ModelResponse as the LlmResponse ADK expects from a model (see the header). */
+/** A ModelResponse as a genai-shaped LlmResponse, the shape a stored model event is made from (see the header). */
 export function modelResponseToLlmResponse(unchecked) {
     const response = contractModelResponse(unchecked);
     const parts = partsToGenai(response.parts);
@@ -744,8 +744,8 @@ export function modelResponseToLlmResponse(unchecked) {
         ...(groundingMetadata ? { groundingMetadata } : {}),
         turnComplete: true,
     };
-    // FallbackLlm reads the verdict from customMetadata alone (ADR 0044): an
-    // error without it would be passed on, never answered by the fallback.
+    // A reader of this shape takes the verdict from customMetadata alone
+    // (ADR 0044): an error without it reads as not retryable.
     if (!response.error)
         return llmResponse;
     const { retryable, status } = response.error;
@@ -766,9 +766,9 @@ export function nativeToolsWithoutGeminiTool(tools = []) {
 /**
  * A toolsDict entry that only declares. `_getDeclaration()` gives the
  * declaration with its lowercase schema as `parameters`, where
- * llmRequestToModelRequest (contractToolDeclaration) and the ADK-path
- * adapters (toolDeclarationFor) read it. It is never run: ADK's Gemini sends
- * `config.tools`, and nothing calls a tool out of a request.
+ * llmRequestToModelRequest (contractToolDeclaration) reads it. It is never
+ * run: a Gemini request sends `config.tools`, and nothing calls a tool out
+ * of a request.
  */
 function declaredTool({ name, description, parameters }) {
     return { name, description, isLongRunning: false, _getDeclaration: () => ({ name, description, parameters }) };
@@ -792,7 +792,7 @@ function toolConfigOf(request) {
                     : undefined;
     return mode ? { functionCallingConfig: { mode } } : undefined;
 }
-/** A ModelRequest as the LlmRequest ADK's path builds for a Gemini model (see the header for what does not come back the same). */
+/** A ModelRequest as the genai-shaped request for a Gemini model (see the header for what does not come back the same). */
 export function modelRequestToLlmRequest(request) {
     const config = {};
     if (request.system)
@@ -895,7 +895,7 @@ function outputPartsOf(parts, model) {
         return out;
     return out.map((p) => (isSignatureState(p.providerState) && p.providerState.model === undefined ? { ...p, providerState: { ...p.providerState, model } } : p));
 }
-/** An ADK error code as the contract's error, with the verdict the adapter stamped (withRetryVerdict). `STOP` is no error. */
+/** A genai-shaped error code as the contract's error, with the verdict the adapter stamped (withRetryVerdict). `STOP` is no error. */
 function errorOf(response) {
     const code = response.errorCode;
     if (!code || code === 'STOP')

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

@@ -6,11 +6,9 @@
  * WHY this file exists:
  *   OpenAI's Responses API is where OpenAI exposes reasoning summaries and
  *   its first-class `web_search` tool, and xAI's Agent Tools API speaks the
- *   same wire. GptLlm and GrokLlm translated ADK's LlmRequest to it
- *   directly. This module is that translation on the contract: it reads a
- *   ModelRequest and yields ModelResponses, with no ADK in the path, so the
- *   native runtime (ADR 0045) can call it. GptLlm and GrokLlm (gptLlm.ts,
- *   grokLlm.ts) are now the ADK shim (lib/models/adkShim.ts) around it.
+ *   same wire. This module is the translation on the contract: it reads a
+ *   ModelRequest and yields ModelResponses, and the native loop (ADR 0045)
+ *   calls it directly.
  *
  * THE MAPPING is the OpenAI Responses table of wiki/models/model-contract.md
  * (and its xAI table for the subclass). In short:
@@ -40,8 +38,9 @@
  *
  * BEYOND THE CONTRACT: the server-side tool calls a response reports, with
  * their arguments and sources, have no contract field. responsesServerTools()
- * returns them for a final this adapter yielded, so GptLlm can put them on the
- * ADK event's customMetadata where the ledger reads them (ADR 0056).
+ * returns them for a final this adapter yielded (ADR 0056); the native step
+ * writes them on the stored final's customMetadata
+ * (`responses.server_tool_calls`), where the ledger counts them.
  */
 import type { FinalModelResponse, ModelAdapter, ModelRequest, ModelResponse, NativeTool, PartialModelResponse, ReasoningSetting, Usage } from './contract.ts';
 import type { ProviderEndpoint } from './endpoints.ts';
@@ -72,7 +71,7 @@ export interface ResponsesInput {
  * loop only (currentTurnStart). An assistant message that replays keeps the
  * model's order of text and calls, so each run of reasoning items is
  * followed by the item it preceded; one that does not puts its calls before
- * its text, as the ADK path always built it.
+ * its text, as ADK always built it.
  */
 export declare function responsesInput(request: Pick<ModelRequest, 'system' | 'messages'>, replay?: ReasoningReplay): ResponsesInput;
 /** The request's client-side tools as Responses function tools; a strict one sends the strict form of its schema. */
@@ -120,9 +119,10 @@ export interface ResponsesServerTools {
 /**
  * The server-side tool calls and counters behind a final response a
  * Responses adapter yielded, or undefined when it reported none. The
- * contract has no field for them (only their queries, as grounding); GptLlm
- * writes them on the ADK event's customMetadata, where the ledger counts
- * them (lib/observability/tracer.ts, serverToolEvents).
+ * contract has no field for them (only their queries, as grounding). The
+ * native step (lib/runtime/native/step.ts, withServerTools) writes them on
+ * the stored final's customMetadata, and the root span counts them from
+ * there (lib/observability/tracer.ts, serverToolEvents).
  */
 export declare function responsesServerTools(response: ModelResponse): ResponsesServerTools | undefined;
 /**

package/dist/lib/models/gptAdapter.js

@@ -6,11 +6,9 @@
  * WHY this file exists:
  *   OpenAI's Responses API is where OpenAI exposes reasoning summaries and
  *   its first-class `web_search` tool, and xAI's Agent Tools API speaks the
- *   same wire. GptLlm and GrokLlm translated ADK's LlmRequest to it
- *   directly. This module is that translation on the contract: it reads a
- *   ModelRequest and yields ModelResponses, with no ADK in the path, so the
- *   native runtime (ADR 0045) can call it. GptLlm and GrokLlm (gptLlm.ts,
- *   grokLlm.ts) are now the ADK shim (lib/models/adkShim.ts) around it.
+ *   same wire. This module is the translation on the contract: it reads a
+ *   ModelRequest and yields ModelResponses, and the native loop (ADR 0045)
+ *   calls it directly.
  *
  * THE MAPPING is the OpenAI Responses table of wiki/models/model-contract.md
  * (and its xAI table for the subclass). In short:
@@ -40,8 +38,9 @@
  *
  * BEYOND THE CONTRACT: the server-side tool calls a response reports, with
  * their arguments and sources, have no contract field. responsesServerTools()
- * returns them for a final this adapter yielded, so GptLlm can put them on the
- * ADK event's customMetadata where the ledger reads them (ADR 0056).
+ * returns them for a final this adapter yielded (ADR 0056); the native step
+ * writes them on the stored final's customMetadata
+ * (`responses.server_tool_calls`), where the ledger counts them.
  */
 import { endpointFromEnv, entraTokenSource, nativeSearchOn, platformModel } from './endpoints.js';
 import { errorDecision, errorText, statusDecision } from './errorResponse.js';
@@ -69,8 +68,8 @@ function resultJson(part) {
 }
 /** A user-turn blob as an input content item, or why it is left out. */
 function blobItem(part) {
-    // The genai mapping types an untyped part as octet-stream; the ADK path
-    // sent an untyped image as PNG, and the provider reads the bytes.
+    // The genai mapping types an untyped part as octet-stream; an untyped
+    // image goes as PNG, as ADK sent it, and the provider reads the bytes.
     const mimeType = !part.mimeType || part.mimeType === 'application/octet-stream' ? 'image/png' : part.mimeType;
     if (part.url !== undefined && !/^https:\/\//i.test(part.url))
         return 'URL scheme';
@@ -95,7 +94,7 @@ function replayedItems(part, replay) {
  * loop only (currentTurnStart). An assistant message that replays keeps the
  * model's order of text and calls, so each run of reasoning items is
  * followed by the item it preceded; one that does not puts its calls before
- * its text, as the ADK path always built it.
+ * its text, as ADK always built it.
  */
 export function responsesInput(request, replay) {
     const system = request.system ? [request.system] : [];
@@ -243,9 +242,10 @@ const SERVER_TOOLS = new WeakMap();
 /**
  * The server-side tool calls and counters behind a final response a
  * Responses adapter yielded, or undefined when it reported none. The
- * contract has no field for them (only their queries, as grounding); GptLlm
- * writes them on the ADK event's customMetadata, where the ledger counts
- * them (lib/observability/tracer.ts, serverToolEvents).
+ * contract has no field for them (only their queries, as grounding). The
+ * native step (lib/runtime/native/step.ts, withServerTools) writes them on
+ * the stored final's customMetadata, and the root span counts them from
+ * there (lib/observability/tracer.ts, serverToolEvents).
  */
 export function responsesServerTools(response) {
     return response.partial ? undefined : SERVER_TOOLS.get(response);

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

@@ -8,8 +8,8 @@
  *   Kimi K3 (July 2026) is the strongest open-weight model on the public
  *   coding and research boards, and Moonshot serves it first-party with
  *   tool calling, strict structured output and vision, so it earns a
- *   direct adapter rather than only the gateway path. Under ADK it runs
- *   behind KimiLlm (lib/models/kimiLlm.ts), which any `kimi-*` id routes to.
+ *   direct adapter rather than only the gateway path; any `kimi-*` id
+ *   resolves to it (resolveAdapter, lib/models/adapterResolver.ts).
  *
  * WHY the chat-completions base (lib/models/chatCompletionsAdapter.ts):
  *   Moonshot's API is OpenAI Chat Completions at https://api.moonshot.ai/v1
@@ -26,7 +26,8 @@
  *      .cn console serves mainland China) and put it in .env as
  *      MOONSHOT_API_KEY.
  *   2. Set model: "kimi-k3" (or any kimi-* id) in your YAML.
- *   registerAvailableProviders() registers this adapter when the key is set.
+ *   The adapter is available when the key is set (logProviderStatuses()
+ *   reports it).
  *   Optional: MOONSHOT_BASE_URL for a proxy that speaks the same dialect.
  *
  * THE FAMILY (platform.moonshot.ai › Model list, October 2026; USD per 1M tokens):
@@ -67,9 +68,7 @@
  *   goes as its Kimi word (`medium` → `high`, a budget → the level that
  *   covers it), `none` as `low` since K3 cannot switch thinking off, and a
  *   request with none pins DEFAULT_KIMI_REASONING_EFFORT (lib/config.ts).
- *   `max` has no contract level: an agent that needs it writes the older
- *   spelling `generateContentConfig.reasoningEffort: max`, which the ADK
- *   path carries beside the contract (ChatCompletionsRequest.olderSpelling).
+ *   `max` has no contract level, so no request sends it.
  *   K2.x models take no reasoning_effort: a `thinking: { type }` switch
  *   instead, so `none` (or a budget of 0) sends `disabled` and any other
  *   setting sends nothing. K2.7 Code (and its highspeed variant) cannot
@@ -153,5 +152,5 @@ export declare class KimiAdapter extends ChatCompletionsAdapter {
     protected missingRequirement(): ChatFailure | undefined;
     protected httpError(status: number, detail: string, model: string): ChatFailure;
     /** The reasoning controls, per generation (see the header). */
-    protected reasoningFields(model: string, setting: ReasoningSetting | undefined, olderWord: string | undefined): Record<string, unknown>;
+    protected reasoningFields(model: string, setting: ReasoningSetting | undefined): Record<string, unknown>;
 }

package/dist/lib/models/kimiAdapter.js

@@ -8,8 +8,8 @@
  *   Kimi K3 (July 2026) is the strongest open-weight model on the public
  *   coding and research boards, and Moonshot serves it first-party with
  *   tool calling, strict structured output and vision, so it earns a
- *   direct adapter rather than only the gateway path. Under ADK it runs
- *   behind KimiLlm (lib/models/kimiLlm.ts), which any `kimi-*` id routes to.
+ *   direct adapter rather than only the gateway path; any `kimi-*` id
+ *   resolves to it (resolveAdapter, lib/models/adapterResolver.ts).
  *
  * WHY the chat-completions base (lib/models/chatCompletionsAdapter.ts):
  *   Moonshot's API is OpenAI Chat Completions at https://api.moonshot.ai/v1
@@ -26,7 +26,8 @@
  *      .cn console serves mainland China) and put it in .env as
  *      MOONSHOT_API_KEY.
  *   2. Set model: "kimi-k3" (or any kimi-* id) in your YAML.
- *   registerAvailableProviders() registers this adapter when the key is set.
+ *   The adapter is available when the key is set (logProviderStatuses()
+ *   reports it).
  *   Optional: MOONSHOT_BASE_URL for a proxy that speaks the same dialect.
  *
  * THE FAMILY (platform.moonshot.ai › Model list, October 2026; USD per 1M tokens):
@@ -67,9 +68,7 @@
  *   goes as its Kimi word (`medium` → `high`, a budget → the level that
  *   covers it), `none` as `low` since K3 cannot switch thinking off, and a
  *   request with none pins DEFAULT_KIMI_REASONING_EFFORT (lib/config.ts).
- *   `max` has no contract level: an agent that needs it writes the older
- *   spelling `generateContentConfig.reasoningEffort: max`, which the ADK
- *   path carries beside the contract (ChatCompletionsRequest.olderSpelling).
+ *   `max` has no contract level, so no request sends it.
  *   K2.x models take no reasoning_effort: a `thinking: { type }` switch
  *   instead, so `none` (or a budget of 0) sends `disabled` and any other
  *   setting sends nothing. K2.7 Code (and its highspeed variant) cannot
@@ -188,10 +187,8 @@ export class KimiAdapter extends ChatCompletionsAdapter {
         };
     }
     /** The reasoning controls, per generation (see the header). */
-    reasoningFields(model, setting, olderWord) {
+    reasoningFields(model, setting) {
         if (isKimiK3(model)) {
-            if (olderWord !== undefined)
-                return { reasoning_effort: olderWord };
             if (setting === undefined)
                 return { reasoning_effort: DEFAULT_KIMI_REASONING_EFFORT };
             const word = reasoningConfig(model, setting).reasoningEffort;

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

@@ -11,8 +11,8 @@
  *   local inference. The chat-completions translation is the shared base
  *   (lib/models/chatCompletionsAdapter.ts); this adapter supplies Ollama's
  *   endpoint, its wire model name and its error wording.
- *   Under ADK it runs behind OllamaLlm (lib/models/ollamaLlm.ts), which any
- *   agent with model: "ollama/<model>" routes to.
+ *   Any agent with model: "ollama/<model>" resolves to it (resolveAdapter,
+ *   lib/models/adapterResolver.ts).
  *
  * HOW TO ENABLE:
  *   1. Install Ollama (https://ollama.com — macOS: brew install ollama)
@@ -21,7 +21,7 @@
  *        ollama pull qwen3.5:9b      # the default recommendation
  *        ollama pull qwen3.5:4b      # lighter; teaching and small machines
  *   3. Set model: "ollama/qwen3.5:9b" in your YAML. No API key needed —
- *      registerAvailableProviders() registers this provider unconditionally.
+ *      the provider is always available (logProviderStatuses() reports it).
  *   Optional: OLLAMA_BASE_URL in .env overrides the default endpoint
  *   (http://localhost:11434/v1 — Ollama's OpenAI-compatible API).
  *

package/dist/lib/models/ollamaAdapter.js

@@ -11,8 +11,8 @@
  *   local inference. The chat-completions translation is the shared base
  *   (lib/models/chatCompletionsAdapter.ts); this adapter supplies Ollama's
  *   endpoint, its wire model name and its error wording.
- *   Under ADK it runs behind OllamaLlm (lib/models/ollamaLlm.ts), which any
- *   agent with model: "ollama/<model>" routes to.
+ *   Any agent with model: "ollama/<model>" resolves to it (resolveAdapter,
+ *   lib/models/adapterResolver.ts).
  *
  * HOW TO ENABLE:
  *   1. Install Ollama (https://ollama.com — macOS: brew install ollama)
@@ -21,7 +21,7 @@
  *        ollama pull qwen3.5:9b      # the default recommendation
  *        ollama pull qwen3.5:4b      # lighter; teaching and small machines
  *   3. Set model: "ollama/qwen3.5:9b" in your YAML. No API key needed —
- *      registerAvailableProviders() registers this provider unconditionally.
+ *      the provider is always available (logProviderStatuses() reports it).
  *   Optional: OLLAMA_BASE_URL in .env overrides the default endpoint
  *   (http://localhost:11434/v1 — Ollama's OpenAI-compatible API).
  *

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

@@ -3,14 +3,15 @@
  * (as declared in an agent YAML) to its provider.
  *
  * WHY a leaf module:
- *   Both the LLM registry (lib/models/registry.ts) and the web-search
- *   abstraction (lib/tools/webSearchTool.ts) need this mapping; keeping it
+ *   The adapter resolver (lib/models/adapterResolver.ts, through
+ *   lib/models/registry.ts) and the server-side tools' per-provider routing
+ *   (lib/runtime/native/request.ts) both need this mapping; keeping it
  *   dependency-free avoids an import cycle between adapters and tools.
  *
  * Model-name conventions (see DOCUMENTATION.md §7):
  *   claude-*   → anthropic     gpt-* / o<digit>* → openai
  *   grok-*     → xai           ollama/<model>    → ollama (local, keyless)
- *   kimi-*     → moonshot      everything else   → gemini (the ADK-native default)
+ *   kimi-*     → moonshot      everything else   → gemini (the default)
  */
 export type ProviderId = 'gemini' | 'anthropic' | 'openai' | 'xai' | 'moonshot' | 'ollama';
 interface ProviderInfo {
@@ -20,8 +21,8 @@ interface ProviderInfo {
     label: string;
 }
 export declare const PROVIDERS: Record<ProviderId, ProviderInfo>;
-/** Maps a model id to its provider. Unknown ids default to gemini — the
- *  ADK-native provider — matching the LLMRegistry's fallback behavior. */
+/** Maps a model id to its provider. Unknown ids default to gemini, as
+ *  resolveAdapter does: a typo in a claude- id becomes a Gemini call. */
 export declare function providerForModel(model: string): ProviderId;
 /** True when the provider's key is present (always true for local Ollama). */
 export declare function providerKeyPresent(provider: ProviderId): boolean;

package/dist/lib/models/providerMap.js

@@ -3,14 +3,15 @@
  * (as declared in an agent YAML) to its provider.
  *
  * WHY a leaf module:
- *   Both the LLM registry (lib/models/registry.ts) and the web-search
- *   abstraction (lib/tools/webSearchTool.ts) need this mapping; keeping it
+ *   The adapter resolver (lib/models/adapterResolver.ts, through
+ *   lib/models/registry.ts) and the server-side tools' per-provider routing
+ *   (lib/runtime/native/request.ts) both need this mapping; keeping it
  *   dependency-free avoids an import cycle between adapters and tools.
  *
  * Model-name conventions (see DOCUMENTATION.md §7):
  *   claude-*   → anthropic     gpt-* / o<digit>* → openai
  *   grok-*     → xai           ollama/<model>    → ollama (local, keyless)
- *   kimi-*     → moonshot      everything else   → gemini (the ADK-native default)
+ *   kimi-*     → moonshot      everything else   → gemini (the default)
  */
 export const PROVIDERS = {
     gemini: { keyEnv: 'GOOGLE_GENAI_API_KEY', label: 'Google Gemini' },
@@ -20,8 +21,8 @@ export const PROVIDERS = {
     moonshot: { keyEnv: 'MOONSHOT_API_KEY', label: 'Moonshot Kimi' },
     ollama: { keyEnv: null, label: 'Ollama (local)' },
 };
-/** Maps a model id to its provider. Unknown ids default to gemini — the
- *  ADK-native provider — matching the LLMRegistry's fallback behavior. */
+/** Maps a model id to its provider. Unknown ids default to gemini, as
+ *  resolveAdapter does: a typo in a claude- id becomes a Gemini call. */
 export function providerForModel(model) {
     if (/^ollama\//.test(model))
         return 'ollama';

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

@@ -5,8 +5,9 @@
  * WHY: some providers want back, on the next request of a tool loop, state
  * only they can read: Anthropic's signed `thinking` and `redacted_thinking`
  * blocks, OpenAI's and xAI's reasoning items, Moonshot's reasoning_content.
- * ADK's request is built from each event's `content` alone (event metadata
- * never reaches it), and @google/genai serializes a part field by field, so
+ * A request is built from each event's `content` alone (event metadata
+ * never reaches it, as with ADK), and @google/genai serializes a part field
+ * by field, so
  * the state rides as one extra field on a part the model actually produced:
  *
  *     { functionCall: {...}, providerState: { provider, kind, payload } }

package/dist/lib/models/providerState.js

@@ -5,8 +5,9 @@
  * WHY: some providers want back, on the next request of a tool loop, state
  * only they can read: Anthropic's signed `thinking` and `redacted_thinking`
  * blocks, OpenAI's and xAI's reasoning items, Moonshot's reasoning_content.
- * ADK's request is built from each event's `content` alone (event metadata
- * never reaches it), and @google/genai serializes a part field by field, so
+ * A request is built from each event's `content` alone (event metadata
+ * never reaches it, as with ADK), and @google/genai serializes a part field
+ * by field, so
  * the state rides as one extra field on a part the model actually produced:
  *
  *     { functionCall: {...}, providerState: { provider, kind, payload } }

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

@@ -5,7 +5,7 @@
  * WHY HERE: the compiler maps an agent's `reasoning:` key through this, and
  * a model adapter on the contract (lib/models/geminiAdapter.ts) maps a
  * ModelRequest's `reasoning` the same way. Keeping it out of lib/compile.ts
- * keeps ADK out of an adapter's imports. lib/compile.ts re-exports both
+ * keeps the compiler out of an adapter's imports. lib/compile.ts re-exports both
  * names, so existing imports keep working.
  */
 import type { ReasoningLevel, ReasoningSetting } from './contract.ts';