melchizedek-agents 0.19.0 → 1.0.0

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/claudeLlm.js

@@ -33,7 +33,7 @@
  * replayed within the tool loop, structured output, images, web search) is
  * described in its header and in wiki/models/claude-adapter.md.
  */
-import { LLMRegistry } from '@google/adk';
+import { requireAdk } from '../adkPeer.js';
 import { AdkShim } from './adkShim.js';
 import { ClaudeAdapter, anthropicTools } from './claudeAdapter.js';
 import { claudeReasoningFromConfig } from './claudeModels.js';
@@ -83,5 +83,5 @@ export class ClaudeLlm extends AdkShim {
  *   message about which provider is active.
  */
 export function registerClaudeLlm() {
-    LLMRegistry.register(ClaudeLlm);
+    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(ClaudeLlm);
 }

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);

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

@@ -4,12 +4,12 @@
  * implements and the native runtime calls (ADR 0045, ADR 0048).
  *
  * WHY this file exists:
- *   The ADK runtime speaks @google/genai `Content`, which is Gemini's wire
- *   format. It has no slot for another provider's reasoning state, spells
- *   schemas in Gemini's uppercase dialect, carries server-side tools as
- *   sentinel tool objects, and surfaces failures as a throw on one path and
- *   a yielded `errorCode` on another. The native runtime owns its loop, so it
- *   owns this format instead. Each adapter translates it to its provider's
+ *   ADK spoke @google/genai `Content`, which is Gemini's wire format. It
+ *   has no slot for another provider's reasoning state, spells schemas in
+ *   Gemini's uppercase dialect, carried server-side tools as sentinel tool
+ *   objects, and surfaced failures as a throw on one path and a yielded
+ *   `errorCode` on another. The native runtime owns its loop, so it owns
+ *   this format instead. Each adapter translates it to its provider's
  *   wire; wiki/models/model-contract.md is the field-by-field spec, with the
  *   mapping for every provider.
  *
@@ -290,9 +290,9 @@ type SetupErrorCode = 'MISSING_API_KEY' | 'ENDPOINT_MISCONFIGURED' | 'SDK_NOT_IN
 /** The chat-completions failures, under the provider's id (the gateway names the upstream provider). */
 type ChatErrorCode = `${'MOONSHOT' | 'OLLAMA' | 'GEMINI' | 'ANTHROPIC' | 'OPENAI' | 'XAI'}_${'MAX_TOKENS' | 'EMPTY_RESPONSE' | 'UNREACHABLE'}` | 'MOONSHOT_MISSING_KEY' | 'MOONSHOT_HTTP_ERROR' | 'OLLAMA_HTTP_ERROR' | 'GATEWAY_NOT_CONFIGURED' | 'GATEWAY_KEY_MISSING' | 'GATEWAY_HTTP_ERROR';
 /**
- * Gemini's codes: ADK's adapter reports a candidate's finish reason, or the
- * prompt's block reason, as the code itself. GEMINI_ERROR is a failed call,
- * which ADK throws and the contract reports.
+ * Gemini's codes: a candidate's finish reason, or the prompt's block reason,
+ * is the code itself, as ADK's adapter reported it. GEMINI_ERROR is a failed
+ * call, which ADK threw and the contract reports.
  */
 type GeminiErrorCode = 'GEMINI_ERROR' | 'MAX_TOKENS' | 'SAFETY' | 'RECITATION' | 'LANGUAGE' | 'OTHER' | 'BLOCKLIST' | 'PROHIBITED_CONTENT' | 'SPII' | 'MALFORMED_FUNCTION_CALL' | 'IMAGE_SAFETY' | 'UNEXPECTED_TOOL_CALL' | 'TOO_MANY_TOOL_CALLS' | 'IMAGE_PROHIBITED_CONTENT' | 'NO_IMAGE' | 'IMAGE_RECITATION' | 'IMAGE_OTHER' | 'MODEL_ARMOR' | 'JAILBREAK' | 'UNKNOWN_ERROR';
 /**
@@ -302,8 +302,8 @@ type GeminiErrorCode = 'GEMINI_ERROR' | 'MAX_TOKENS' | 'SAFETY' | 'RECITATION' |
  */
 type TurnControlErrorCode = 'STEP_LIMIT' | 'DEADLINE_EXCEEDED' | 'CANCELED';
 /**
- * The codes the engine's adapters report, kept verbatim from what they emit
- * under ADK so a caller matching on a code keeps working. An adapter the
+ * The codes the engine's adapters report, kept verbatim from what they
+ * emitted under ADK so a caller matching on a code keeps working. An adapter the
  * engine does not ship may report its own; the engine's adapters use only
  * these, and adding one is a change to wiki/models/model-contract.md.
  */

package/dist/lib/models/contract.js

@@ -4,12 +4,12 @@
  * implements and the native runtime calls (ADR 0045, ADR 0048).
  *
  * WHY this file exists:
- *   The ADK runtime speaks @google/genai `Content`, which is Gemini's wire
- *   format. It has no slot for another provider's reasoning state, spells
- *   schemas in Gemini's uppercase dialect, carries server-side tools as
- *   sentinel tool objects, and surfaces failures as a throw on one path and
- *   a yielded `errorCode` on another. The native runtime owns its loop, so it
- *   owns this format instead. Each adapter translates it to its provider's
+ *   ADK spoke @google/genai `Content`, which is Gemini's wire format. It
+ *   has no slot for another provider's reasoning state, spells schemas in
+ *   Gemini's uppercase dialect, carried server-side tools as sentinel tool
+ *   objects, and surfaced failures as a throw on one path and a yielded
+ *   `errorCode` on another. The native runtime owns its loop, so it owns
+ *   this format instead. Each adapter translates it to its provider's
  *   wire; wiki/models/model-contract.md is the field-by-field spec, with the
  *   mapping for every provider.
  *

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

@@ -1,16 +1,17 @@
 /**
- * lib/models/errorResponse.ts — an ADK adapter's error response, saying
- * whether another attempt or another model may succeed.
+ * lib/models/errorResponse.ts — what a failed provider call says about
+ * trying again, and the genai-shaped error response that carries it.
  *
- * WHY: every adapter but Gemini reports a failed provider call as a yielded
- * LlmResponse carrying `errorCode`, never a throw. FallbackLlm
- * (lib/models/fallback.ts, ADR 0044) must tell a provider-side failure from
- * the request's own error without parsing a message, so an adapter's catch
- * site builds that response here, with the retry policy's verdict in its
- * customMetadata (Claude, GPT and Grok, and the chat-completions base for
- * Kimi, Ollama and the gateway). A
- * response without the verdict is read as not retryable: passed on, never
- * redirected.
+ * WHY: an adapter reports a failed provider call as a final response with
+ * `error`, never a throw, and the fallback (FallbackAdapter,
+ * lib/models/fallbackAdapter.ts, ADR 0044) must tell a provider-side
+ * failure from the request's own error without parsing a message. The
+ * adapters' catch sites (Claude, GPT and Grok, and the chat-completions base
+ * for Kimi, Ollama and the gateway) take the verdict and the scrubbed text
+ * from here (errorDecision, statusDecision, errorText). A genai-shaped
+ * LlmResponse (lib/models/genaiMapping.ts) carries the same verdict in its
+ * customMetadata (withRetryVerdict). A response without the verdict is read
+ * as not retryable: passed on, never redirected.
  *
  *   'error.retryable'  true when lib/models/retry.ts classifies the failure
  *                      retryable (408/409/425/429/5xx, a connection reset);
@@ -22,7 +23,7 @@
  * leaves the adapter, so an error never carries a key into a session, the
  * ledger or a log.
  */
-import type { LlmResponse } from '@google/adk';
+import type { LlmResponse } from './genaiMapping.ts';
 import type { RetryDecision } from './retry.ts';
 /** customMetadata key: whether another attempt or model may succeed. */
 export declare const ERROR_RETRYABLE_KEY = "error.retryable";
@@ -40,11 +41,3 @@ export declare function statusDecision(status: number): RetryDecision;
  * the adapter's own; customMetadata it already carries is kept.
  */
 export declare function withRetryVerdict(response: LlmResponse, decision: RetryDecision): LlmResponse;
-/**
- * The error response for a caught provider error: `errorCode`, the message
- * (the error's own text unless the adapter words it), and the verdict from
- * classifyError.
- */
-export declare function providerErrorResponse(err: unknown, errorCode: string, errorMessage?: string): LlmResponse;
-/** True when a response is an error its adapter marked retryable: a provider-side failure. */
-export declare function isRetryableErrorResponse(response: LlmResponse): boolean;

package/dist/lib/models/errorResponse.js

@@ -34,15 +34,3 @@ export function withRetryVerdict(response, decision) {
         },
     };
 }
-/**
- * The error response for a caught provider error: `errorCode`, the message
- * (the error's own text unless the adapter words it), and the verdict from
- * classifyError.
- */
-export function providerErrorResponse(err, errorCode, errorMessage = errorText(err)) {
-    return withRetryVerdict({ errorCode, errorMessage }, errorDecision(err));
-}
-/** True when a response is an error its adapter marked retryable: a provider-side failure. */
-export function isRetryableErrorResponse(response) {
-    return !!response.errorCode && response.customMetadata?.[ERROR_RETRYABLE_KEY] === true;
-}

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

@@ -31,7 +31,7 @@
  *     closes it. Its state is lib/models/circuitBreaker.ts, which the
  *     contract-level wrapper (lib/models/fallbackAdapter.ts) shares.
  */
-import { BaseLlm } from '@google/adk';
+import { BaseLlm } from '../adkPeer.ts';
 import type { BaseLlmConnection, LlmRequest, LlmResponse } from '@google/adk';
 export { circuitOpen, resetCircuits } from './circuitBreaker.ts';
 /** A provider-side failure: worth counting against the provider and worth a fallback. A cancellation never is. */

package/dist/lib/models/fallback.js

@@ -31,7 +31,7 @@
  *     closes it. Its state is lib/models/circuitBreaker.ts, which the
  *     contract-level wrapper (lib/models/fallbackAdapter.ts) shares.
  */
-import { BaseLlm } from '@google/adk';
+import { BaseLlm } from '../adkPeer.js';
 import { errorDecision, errorText, isRetryableErrorResponse } from './errorResponse.js';
 import { providerForModel } from './providerMap.js';
 import { circuitOpen, recordFailure, recordSuccess } from './circuitBreaker.js';

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

@@ -2,11 +2,10 @@
  * lib/models/fallbackAdapter.ts — `fallback_model:` and the per-provider
  * circuit breaker (ADR 0044) on the engine's own model contract (ADR 0048).
  *
- * WHY: FallbackLlm (lib/models/fallback.ts) wraps two ADK BaseLlm adapters
- * and reads a failure from a throw. On the contract a failure is a final
- * response with `error` set, never a throw, and `error.retryable` already
- * says whether another model may succeed. This wrapper is the same rule set
- * read from that: one ModelAdapter around a primary and a fallback adapter.
+ * WHY: on the contract a failure is a final response with `error` set,
+ * never a throw, and `error.retryable` already says whether another model
+ * may succeed. This wrapper is ADR 0044's rule set read from that: one
+ * ModelAdapter around a primary and a fallback adapter.
  *
  * THE RULES (ADR 0044, unchanged):
  *   - Only a provider-side failure counts and redirects: `error.retryable`
@@ -19,9 +18,9 @@
  *     was yielded and the failed final holds no parts. A call that failed
  *     midway is passed on, never replayed on another model.
  *   - The breaker (lib/models/circuitBreaker.ts) is keyed on the primary's
- *     `provider` and shared with FallbackLlm, so a provider tripped on one
- *     path is skipped on the other. While it is open the primary is not
- *     called. A success closes it; the fallback's own outcome is not counted.
+ *     `provider` and shared by every wrapped agent in the process, so a
+ *     provider tripped for one agent is skipped for the others. While it is
+ *     open the primary is not called. A success closes it; the fallback's own outcome is not counted.
  *
  * THE FALLBACK'S REQUEST: the caller's request with `model` rewritten to the
  * fallback's id. `reasoning` goes unchanged, and the fallback adapter maps it

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

@@ -8,7 +8,7 @@
  *   (lib/models/gateway.ts owns that decision). It extends the
  *   chat-completions base (lib/models/chatCompletionsAdapter.ts) the way
  *   Ollama does, because chat completions is the one dialect every gateway
- *   serves. Under ADK it runs behind GatewayLlm (lib/models/gatewayLlm.ts).
+ *   serves.
  *
  * WHAT STAYS TRUE THROUGH THE GATEWAY:
  *   - Attribution. `provider` is the YAML id's provider (anthropic, openai,

package/dist/lib/models/gatewayAdapter.js

@@ -8,7 +8,7 @@
  *   (lib/models/gateway.ts owns that decision). It extends the
  *   chat-completions base (lib/models/chatCompletionsAdapter.ts) the way
  *   Ollama does, because chat completions is the one dialect every gateway
- *   serves. Under ADK it runs behind GatewayLlm (lib/models/gatewayLlm.ts).
+ *   serves.
  *
  * WHAT STAYS TRUE THROUGH THE GATEWAY:
  *   - Attribution. `provider` is the YAML id's provider (anthropic, openai,

package/dist/lib/models/gatewayLlm.js

@@ -16,7 +16,7 @@
  * carry the SAME supportedModels instances as the direct adapter it stands
  * in for (see gatewayClassFor below, and its use in registry.ts).
  */
-import { LLMRegistry } from '@google/adk';
+import { requireAdk } from '../adkPeer.js';
 import { GatewayAdapter } from './gatewayAdapter.js';
 import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.js';
 export class GatewayLlm extends OpenAiCompatibleLlm {
@@ -40,5 +40,5 @@ export function gatewayClassFor(patterns) {
 }
 /** Registers a gateway stand-in for the given patterns. */
 export function registerGatewayLlm(patterns) {
-    LLMRegistry.register(gatewayClassFor(patterns));
+    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(gatewayClassFor(patterns));
 }

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

@@ -3,12 +3,11 @@
  * contract (lib/models/contract.ts, ADR 0048), on @google/genai directly.
  *
  * WHY this file exists:
- *   Gemini runs today through ADK's own Gemini class, wrapped as
- *   TracedGemini (lib/models/tracedGemini.ts). The native runtime (ADR 0045)
- *   needs Gemini as a contract ModelAdapter that shapes its own requests,
- *   aggregates its own stream and reports its own failures, with no ADK in
- *   the path. This is that adapter. resolveAdapter (lib/models/registry.ts)
- *   returns it only when asked (GEMINI_ADAPTER=engine) until gate G3.
+ *   The native loop (ADR 0045) needs Gemini as a contract ModelAdapter that
+ *   shapes its own requests, aggregates its own stream and reports its own
+ *   failures. This is that adapter, and the only Gemini adapter:
+ *   resolveAdapter (lib/models/adapterResolver.ts) returns it for every
+ *   Gemini id (ADR 0100, ADR 0107).
  *
  * THE MAPPING is the Gemini table of wiki/models/model-contract.md;
  * wiki/models/gemini-adapter.md records the choices made inside it:
@@ -49,7 +48,7 @@
 import type { GenerateContentParameters, GenerateContentResponse, GoogleGenAIOptions, Part as WirePart } from '@google/genai';
 import type { ModelAdapter, ModelRequest, ModelResponse } from './contract.ts';
 import type { ProviderEndpoint } from './endpoints.ts';
-import { GEMINI_PROVIDER, THOUGHT_SIGNATURE_KIND } from './geminiState.ts';
+import { CARRIED_PARTS_KIND, GEMINI_PROVIDER, PLACEHOLDER_THOUGHT_SIGNATURE, THOUGHT_SIGNATURE_KIND } from './geminiState.ts';
 /**
  * The provider id this adapter reports and writes its state under, and the
  * providerState kind for a Gemini thought signature (ADR 0046). Defined once
@@ -64,9 +63,11 @@ export declare const ENGINE_CALL_ID_PREFIX = "adk-";
 /**
  * The providerState kind for Gemini parts the contract has no type for
  * (code execution and server-side tool invocations), carried whole on the
- * next output part (ADR 0065). The payload is a `CarriedParts`.
+ * next output part (ADR 0065). The payload is a `CarriedParts`. Defined in
+ * lib/models/geminiState.ts, so the genai mapping writes them back out as
+ * the parts they were when an event is stored (ADR 0100).
  */
-export declare const CARRIED_PARTS_KIND = "carried_parts";
+export { CARRIED_PARTS_KIND };
 /** The payload of a `carried_parts` state. */
 export interface CarriedParts {
     /** The genai parts that came before the output part, as Gemini sent them. */
@@ -82,7 +83,7 @@ export interface CarriedParts {
  * (default PLACEHOLDER_SIGNATURES_BY_DEFAULT, off) until the G3 live run
  * confirms it (ADR 0065).
  */
-export declare const PLACEHOLDER_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+export { PLACEHOLDER_THOUGHT_SIGNATURE };
 /** Off: no placeholder signature is sent unless the adapter is built to send it. */
 export declare const PLACEHOLDER_SIGNATURES_BY_DEFAULT = false;
 /** The part of the @google/genai client this adapter calls. `GoogleGenAI` satisfies it. */

package/dist/lib/models/geminiAdapter.js

@@ -3,12 +3,11 @@
  * contract (lib/models/contract.ts, ADR 0048), on @google/genai directly.
  *
  * WHY this file exists:
- *   Gemini runs today through ADK's own Gemini class, wrapped as
- *   TracedGemini (lib/models/tracedGemini.ts). The native runtime (ADR 0045)
- *   needs Gemini as a contract ModelAdapter that shapes its own requests,
- *   aggregates its own stream and reports its own failures, with no ADK in
- *   the path. This is that adapter. resolveAdapter (lib/models/registry.ts)
- *   returns it only when asked (GEMINI_ADAPTER=engine) until gate G3.
+ *   The native loop (ADR 0045) needs Gemini as a contract ModelAdapter that
+ *   shapes its own requests, aggregates its own stream and reports its own
+ *   failures. This is that adapter, and the only Gemini adapter:
+ *   resolveAdapter (lib/models/adapterResolver.ts) returns it for every
+ *   Gemini id (ADR 0100, ADR 0107).
  *
  * THE MAPPING is the Gemini table of wiki/models/model-contract.md;
  * wiki/models/gemini-adapter.md records the choices made inside it:
@@ -48,7 +47,7 @@
  */
 import { FunctionCallingConfigMode, GoogleGenAI } from '@google/genai';
 import { endpointFromEnv, endpointProblems, platformModel } from './endpoints.js';
-import { GEMINI_PROVIDER, MINTED_CALL_ID_PREFIX, THOUGHT_SIGNATURE_KIND } from './geminiState.js';
+import { CARRIED_PARTS_KIND, GEMINI_PROVIDER, GENAI_PART_KIND, MINTED_CALL_ID_PREFIX, PLACEHOLDER_THOUGHT_SIGNATURE, THOUGHT_SIGNATURE_KIND, isCarriedWirePart, } from './geminiState.js';
 import { currentTurnStart, providerStateOf } from './providerState.js';
 import { classifyError, errorStatus, retryUntilFirstYield } from './retry.js';
 import { reasoningConfig } from './reasoning.js';
@@ -67,9 +66,11 @@ export const ENGINE_CALL_ID_PREFIX = 'adk-';
 /**
  * The providerState kind for Gemini parts the contract has no type for
  * (code execution and server-side tool invocations), carried whole on the
- * next output part (ADR 0065). The payload is a `CarriedParts`.
+ * next output part (ADR 0065). The payload is a `CarriedParts`. Defined in
+ * lib/models/geminiState.ts, so the genai mapping writes them back out as
+ * the parts they were when an event is stored (ADR 0100).
  */
-export const CARRIED_PARTS_KIND = 'carried_parts';
+export { CARRIED_PARTS_KIND };
 /**
  * The thought signature Gemini documents for a function call that has no
  * real one: a call another provider or model made earlier in the current
@@ -78,7 +79,7 @@ export const CARRIED_PARTS_KIND = 'carried_parts';
  * (default PLACEHOLDER_SIGNATURES_BY_DEFAULT, off) until the G3 live run
  * confirms it (ADR 0065).
  */
-export const PLACEHOLDER_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+export { PLACEHOLDER_THOUGHT_SIGNATURE };
 /** Off: no placeholder signature is sent unless the adapter is built to send it. */
 export const PLACEHOLDER_SIGNATURES_BY_DEFAULT = false;
 const defaultClientFactory = (options) => new GoogleGenAI(options);
@@ -100,8 +101,8 @@ export class GeminiAdapter {
         this.#placeholderSignatures = options.placeholderSignatures ?? PLACEHOLDER_SIGNATURES_BY_DEFAULT;
     }
     async *generate(request) {
-        // The request's signal alone: the caller (the ADK shim, the native loop)
-        // passes the turn's (ADR 0053).
+        // The request's signal alone: the caller (the native loop) passes the
+        // turn's (ADR 0053).
         const signal = request.signal;
         const model = request.model || this.model;
         const reply = new ReplyBuilder(model, request.messages.length);
@@ -275,8 +276,8 @@ function buildRequest(request, options) {
     const native = tools.length > (declared ? 1 : 0);
     let toolConfig = toolConfigFor(request);
     // Native tools beside function declarations: the response carries the
-    // server-side invocations, as the ADK path asks on every Gemini agent
-    // (lib/compile.ts). The SDK refuses the flag for Vertex AI.
+    // server-side invocations, as ADK asked on every Gemini agent. The SDK
+    // refuses the flag for Vertex AI.
     if (declared && native && options.geminiApi)
         toolConfig = { ...toolConfig, includeServerSideToolInvocations: true };
     if (toolConfig)
@@ -330,6 +331,18 @@ function assistantToWire(message, replay, model) {
             carried = signature ?? carried;
             continue;
         }
+        // A carried part read back from a stored event (the mapping's genai_part):
+        // itself, verbatim, within its turn; outside it, nothing (ADR 0065, ADR 0100).
+        const stored = storedCarriedPart(part);
+        if (stored) {
+            if (!replay)
+                continue;
+            if (carried && !stored.thoughtSignature)
+                stored.thoughtSignature = carried;
+            carried = undefined;
+            out.push(stored);
+            continue;
+        }
         const before = replay ? carriedPartsOf(part, model) : [];
         if (before.length && carried) {
             if (!before[0].thoughtSignature)
@@ -381,6 +394,15 @@ function carriedPartsOf(part, model) {
         return own && typeof thoughtSignature === 'string' && thoughtSignature ? { ...rest, thoughtSignature } : { ...rest };
     });
 }
+/**
+ * A copy of the code execution or server-side invocation part a stored
+ * event held, as the genai mapping reads it back (`genai_part` state on its
+ * text projection), or undefined for any other part.
+ */
+function storedCarriedPart(part) {
+    const payload = providerStateOf(part, GEMINI_PROVIDER, GENAI_PART_KIND)?.payload;
+    return isPlainObject(payload) && isCarriedWirePart(payload) ? { ...payload } : undefined;
+}
 /**
  * Gemini 3 rejects a current-turn step whose first function call has no
  * signature (a call another provider or model made). With placeholder
@@ -456,7 +478,7 @@ function finishReasonOf(reason) {
  * turn: code execution, and a server-side tool invocation.
  */
 function isCarried(part) {
-    return part.executableCode !== undefined || part.codeExecutionResult !== undefined || part.toolCall !== undefined || part.toolResponse !== undefined;
+    return isCarriedWirePart(part);
 }
 /**
  * Folds Gemini's responses (one, or a stream's chunks) into the contract's

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

@@ -3,20 +3,41 @@
  * written under (ADR 0046), and the prefix of a call id the genai mapping
  * mints, in one place.
  *
- * WHY: three modules write or replay a Gemini `thoughtSignature` as
- * `providerState`: the genai mapping (lib/models/genaiMapping.ts), the
- * engine's own Gemini adapter (lib/models/geminiAdapter.ts) and the wrapper
- * over ADK's Gemini (lib/models/adkGeminiAdapter.ts). A reader replays only
- * the provider and kind it wrote (`providerStateOf`), so the three must spell
- * them the same. Each re-exports these names where they were exported before.
+ * WHY: two modules write or replay a Gemini `thoughtSignature` as
+ * `providerState`: the genai mapping (lib/models/genaiMapping.ts) and the
+ * engine's Gemini adapter (lib/models/geminiAdapter.ts). A reader replays
+ * only the provider and kind it wrote (`providerStateOf`), so the two must
+ * spell them the same. Each re-exports these names where they were exported
+ * before.
  *
- * A leaf with no imports, so the Gemini adapter takes the ids without the
- * mapping, whose import graph names ADK's types.
+ * A leaf with no imports, so a module takes the ids without the mapping and
+ * its @google/genai import graph.
  */
 /** The provider id the Gemini adapters report, and write their state under (lib/models/providerMap.ts). */
 export declare const GEMINI_PROVIDER = "gemini";
 /** The providerState kind for a Gemini thought signature; the payload is the signature. */
 export declare const THOUGHT_SIGNATURE_KIND = "thought_signature";
+/**
+ * The thought signature Gemini documents for a function call that has no
+ * real one. Gemini 3 rejects a current-turn function call without a
+ * signature; this value passes its validator (ADR 0065).
+ */
+export declare const PLACEHOLDER_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+/**
+ * The providerState kind the Gemini adapter writes for the Gemini parts the
+ * contract has no type for (code execution, server-side invocations),
+ * carried whole on the next output part (ADR 0065). The payload is
+ * `{ before: <the genai parts>, signature?: <the part's own signature> }`.
+ * The genai mapping writes them back out as the parts they were (ADR 0100).
+ */
+export declare const CARRIED_PARTS_KIND = "carried_parts";
+/**
+ * The providerState kind the genai mapping writes for a genai part the
+ * contract cannot hold exactly; the payload is the part, verbatim.
+ */
+export declare const GENAI_PART_KIND = "genai_part";
+/** A Gemini part the contract has no type for and Gemini wants back within the turn: code execution, a server-side invocation. */
+export declare function isCarriedWirePart(part: unknown): boolean;
 /**
  * The prefix of an id the genai mapping (lib/models/genaiMapping.ts) made
  * for a call or result that had none. Such an id never goes on the wire: the

package/dist/lib/models/geminiState.js

@@ -3,20 +3,46 @@
  * written under (ADR 0046), and the prefix of a call id the genai mapping
  * mints, in one place.
  *
- * WHY: three modules write or replay a Gemini `thoughtSignature` as
- * `providerState`: the genai mapping (lib/models/genaiMapping.ts), the
- * engine's own Gemini adapter (lib/models/geminiAdapter.ts) and the wrapper
- * over ADK's Gemini (lib/models/adkGeminiAdapter.ts). A reader replays only
- * the provider and kind it wrote (`providerStateOf`), so the three must spell
- * them the same. Each re-exports these names where they were exported before.
+ * WHY: two modules write or replay a Gemini `thoughtSignature` as
+ * `providerState`: the genai mapping (lib/models/genaiMapping.ts) and the
+ * engine's Gemini adapter (lib/models/geminiAdapter.ts). A reader replays
+ * only the provider and kind it wrote (`providerStateOf`), so the two must
+ * spell them the same. Each re-exports these names where they were exported
+ * before.
  *
- * A leaf with no imports, so the Gemini adapter takes the ids without the
- * mapping, whose import graph names ADK's types.
+ * A leaf with no imports, so a module takes the ids without the mapping and
+ * its @google/genai import graph.
  */
 /** The provider id the Gemini adapters report, and write their state under (lib/models/providerMap.ts). */
 export const GEMINI_PROVIDER = 'gemini';
 /** The providerState kind for a Gemini thought signature; the payload is the signature. */
 export const THOUGHT_SIGNATURE_KIND = 'thought_signature';
+/**
+ * The thought signature Gemini documents for a function call that has no
+ * real one. Gemini 3 rejects a current-turn function call without a
+ * signature; this value passes its validator (ADR 0065).
+ */
+export const PLACEHOLDER_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+/**
+ * The providerState kind the Gemini adapter writes for the Gemini parts the
+ * contract has no type for (code execution, server-side invocations),
+ * carried whole on the next output part (ADR 0065). The payload is
+ * `{ before: <the genai parts>, signature?: <the part's own signature> }`.
+ * The genai mapping writes them back out as the parts they were (ADR 0100).
+ */
+export const CARRIED_PARTS_KIND = 'carried_parts';
+/**
+ * The providerState kind the genai mapping writes for a genai part the
+ * contract cannot hold exactly; the payload is the part, verbatim.
+ */
+export const GENAI_PART_KIND = 'genai_part';
+/** A Gemini part the contract has no type for and Gemini wants back within the turn: code execution, a server-side invocation. */
+export function isCarriedWirePart(part) {
+    if (typeof part !== 'object' || part === null)
+        return false;
+    const p = part;
+    return p.executableCode !== undefined || p.codeExecutionResult !== undefined || p.toolCall !== undefined || p.toolResponse !== undefined;
+}
 /**
  * The prefix of an id the genai mapping (lib/models/genaiMapping.ts) made
  * for a call or result that had none. Such an id never goes on the wire: the