melchizedek-agents 0.19.0 → 0.20.0

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

@@ -17,6 +17,27 @@
 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

@@ -17,6 +17,32 @@
 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

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

@@ -152,7 +152,7 @@
 import type { Content, ContentUnion, GenerateContentConfig, GenerateContentResponseUsageMetadata, Part as GenaiPart } from '@google/genai';
 import type { LlmRequest, LlmResponse } from '@google/adk';
 import type { Message, ModelRequest, ModelResponse, NativeTool, Part, ReasoningSetting, Sampling, ToolChoice, Usage } from './contract.ts';
-import { GEMINI_PROVIDER, MINTED_CALL_ID_PREFIX, THOUGHT_SIGNATURE_KIND } from './geminiState.ts';
+import { GEMINI_PROVIDER, GENAI_PART_KIND, MINTED_CALL_ID_PREFIX, THOUGHT_SIGNATURE_KIND } from './geminiState.ts';
 /**
  * The provider id the mapping writes its own state under (only a Gemini
  * adapter replays it), and the providerState kind for a Gemini
@@ -160,8 +160,8 @@ import { GEMINI_PROVIDER, MINTED_CALL_ID_PREFIX, THOUGHT_SIGNATURE_KIND } from '
  * lib/models/geminiState.ts, so the Gemini adapter spells them the same.
  */
 export { GEMINI_PROVIDER, THOUGHT_SIGNATURE_KIND };
-/** providerState kind for a genai part the contract cannot hold exactly; the payload is the part. */
-export declare const GENAI_PART_KIND = "genai_part";
+/** providerState kind for a genai part the contract cannot hold exactly; the payload is the part (defined in lib/models/geminiState.ts). */
+export { GENAI_PART_KIND };
 /** The prefix of an id the mapping made for a call or result that had none (defined in lib/models/geminiState.ts). */
 export { MINTED_CALL_ID_PREFIX };
 /** A conversation as the contract holds it: the system prompt and the messages. */
@@ -193,6 +193,15 @@ export declare function systemText(instruction: ContentUnion | undefined): strin
 export declare function contentsToMessages(contents: readonly Content[], systemInstruction?: ContentUnion): ContractHistory;
 /** One contract part as the genai part it maps to. */
 export declare function partToGenai(part: Part): GenaiPart;
+/**
+ * Contract parts as genai parts. A part the Gemini adapter wrote with
+ * `carried_parts` state (code execution, server-side invocations, ADR 0065)
+ * becomes the genai parts it carries, verbatim, then itself with its own
+ * signature as `thoughtSignature`. An empty text part that only carried them
+ * is left out unless it has a signature. So a stored event holds the parts as
+ * Gemini sent them, as ADK's Gemini stores them (ADR 0100).
+ */
+export declare function partsToGenai(parts: readonly Part[]): GenaiPart[];
 /** One contract message as a genai content. */
 export declare function messageToContent(message: Message): Content;
 /** The inverse of contentsToMessages; the system instruction comes back as a string. */
@@ -240,8 +249,19 @@ export declare function llmRequestToModelRequest(llmRequest: LlmRequest, options
 export declare function usageToMetadata(usage: Usage): GenerateContentResponseUsageMetadata;
 /** Gemini's usageMetadata as contract Usage, or undefined when it counts nothing. */
 export declare function usageFromMetadata(meta: GenerateContentResponseUsageMetadata | undefined): Usage | undefined;
+/** What a call's arguments become when they nest past MAX_VALUE_DEPTH (contractOutputPart). */
+export declare const TOO_DEEP_ARGUMENTS = "[arguments nested deeper than 64 levels were dropped]";
+/**
+ * `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
+ * response that is not an object is returned as it is: the caller fails on
+ * it as on any adapter that broke the contract.
+ */
+export declare function contractModelResponse<R extends ModelResponse>(response: R): R;
 /** A ModelResponse as the LlmResponse ADK expects from a model (see the header). */
-export declare function modelResponseToLlmResponse(response: ModelResponse): LlmResponse;
+export declare function modelResponseToLlmResponse(unchecked: ModelResponse): LlmResponse;
 /** The native tools in `tools` that Gemini has no tool for, each once: modelRequestToLlmRequest leaves them out. */
 export declare function nativeToolsWithoutGeminiTool(tools?: readonly NativeTool[]): NativeTool[];
 /** A ModelRequest as the LlmRequest ADK's path builds for a Gemini model (see the header for what does not come back the same). */

package/dist/lib/models/genaiMapping.js

@@ -151,9 +151,10 @@
  */
 import { FinishReason, FunctionCallingConfigMode } from '@google/genai';
 import { ERROR_RETRYABLE_KEY, ERROR_STATUS_KEY, errorText, withRetryVerdict } from './errorResponse.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, THOUGHT_SIGNATURE_KIND } from './geminiState.js';
 import { reasoningConfig } from './reasoning.js';
 import { contractToolDeclaration, nativeToolOf, toContractJsonSchema } from './schemaNormalize.js';
+import { MAX_VALUE_DEPTH, nestedDeeperThan } from '../runtime/valueDepth.js';
 /**
  * The provider id the mapping writes its own state under (only a Gemini
  * adapter replays it), and the providerState kind for a Gemini
@@ -161,8 +162,8 @@ import { contractToolDeclaration, nativeToolOf, toContractJsonSchema } from './s
  * lib/models/geminiState.ts, so the Gemini adapter spells them the same.
  */
 export { GEMINI_PROVIDER, THOUGHT_SIGNATURE_KIND };
-/** providerState kind for a genai part the contract cannot hold exactly; the payload is the part. */
-export const GENAI_PART_KIND = 'genai_part';
+/** providerState kind for a genai part the contract cannot hold exactly; the payload is the part (defined in lib/models/geminiState.ts). */
+export { GENAI_PART_KIND };
 /** The prefix of an id the mapping made for a call or result that had none (defined in lib/models/geminiState.ts). */
 export { MINTED_CALL_ID_PREFIX };
 const ALLOWED = {
@@ -431,9 +432,39 @@ export function partToGenai(part) {
     }
     return out;
 }
+/**
+ * Contract parts as genai parts. A part the Gemini adapter wrote with
+ * `carried_parts` state (code execution, server-side invocations, ADR 0065)
+ * becomes the genai parts it carries, verbatim, then itself with its own
+ * signature as `thoughtSignature`. An empty text part that only carried them
+ * is left out unless it has a signature. So a stored event holds the parts as
+ * Gemini sent them, as ADK's Gemini stores them (ADR 0100).
+ */
+export function partsToGenai(parts) {
+    const out = [];
+    for (const part of parts) {
+        const state = part.providerState;
+        if (state?.provider !== GEMINI_PROVIDER || state.kind !== CARRIED_PARTS_KIND || !isObject(state.payload)) {
+            out.push(partToGenai(part));
+            continue;
+        }
+        const { before, signature } = state.payload;
+        if (Array.isArray(before))
+            for (const carried of before)
+                if (isObject(carried))
+                    out.push({ ...carried });
+        const { providerState: _carried, ...bare } = part;
+        const own = typeof signature === 'string' && signature ? signature : undefined;
+        if (bare.type === 'text' && !bare.text && !own)
+            continue;
+        const genai = partToGenai(bare);
+        out.push(own ? { ...genai, thoughtSignature: own } : genai);
+    }
+    return out;
+}
 /** One contract message as a genai content. */
 export function messageToContent(message) {
-    return { role: GENAI_ROLE[message.role], parts: message.parts.map(partToGenai) };
+    return { role: GENAI_ROLE[message.role], parts: partsToGenai(message.parts) };
 }
 /** The inverse of contentsToMessages; the system instruction comes back as a string. */
 export function messagesToContents(history) {
@@ -626,9 +657,81 @@ const GEMINI_FINISH_REASONS = new Set(Object.values(FinishReason).filter((r) =>
 function finishReasonOfCode(code) {
     return code !== undefined && GEMINI_FINISH_REASONS.has(code) ? code : undefined;
 }
+/** What a call's arguments become when they nest past MAX_VALUE_DEPTH (contractOutputPart). */
+export const TOO_DEEP_ARGUMENTS = `[arguments nested deeper than ${MAX_VALUE_DEPTH} levels were dropped]`;
+/**
+ * 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
+ * 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;
+ *   - a text or thinking part whose text is not a string is dropped;
+ *   - a tool call's name and id that are not strings become `''` (the
+ *     runtime then mints the id), and its arguments that are not an object
+ *     become `{}` when absent or null, else `{ raw: <value> }`, the
+ *     contract's form for arguments that do not parse;
+ *   - arguments that nest deeper than MAX_VALUE_DEPTH levels (lib/runtime/
+ *     valueDepth.ts) become `{ raw: TOO_DEEP_ARGUMENTS }`: every later
+ *     reader of the session would overflow its stack on them;
+ *   - a blob needs a string mimeType and a string `data` or `url`;
+ *   - a Gemini part carried whole must be an object.
+ * A part the contract allows is returned as it is, so a well-behaved
+ * adapter's answer maps exactly as before.
+ */
+function contractOutputPart(part) {
+    if (!isObject(part))
+        return undefined;
+    const state = part.providerState;
+    if (state?.provider === GEMINI_PROVIDER && state.kind === GENAI_PART_KIND && !isObject(state.payload))
+        return undefined;
+    switch (part.type) {
+        case 'text':
+        case 'thinking':
+            return typeof part.text === 'string' ? part : undefined;
+        case 'toolCall': {
+            const { name, id, args } = part;
+            const tooDeep = nestedDeeperThan(args);
+            if (typeof name === 'string' && typeof id === 'string' && (isObject(args) || Array.isArray(args)) && !tooDeep)
+                return part;
+            const checkedArgs = tooDeep
+                ? { raw: TOO_DEEP_ARGUMENTS }
+                : isObject(args) || Array.isArray(args)
+                    ? args
+                    : args === undefined || args === null
+                        ? {}
+                        : { raw: args };
+            return { ...part, type: 'toolCall', name: typeof name === 'string' ? name : '', id: typeof id === 'string' ? id : '', args: checkedArgs };
+        }
+        case 'blob':
+            return typeof part.mimeType === 'string' && (typeof part.data === 'string' || typeof part.url === 'string') ? part : undefined;
+        default:
+            return undefined;
+    }
+}
+/**
+ * `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
+ * response that is not an object is returned as it is: the caller fails on
+ * it as on any adapter that broke the contract.
+ */
+export function contractModelResponse(response) {
+    if (!isObject(response))
+        return response;
+    const raw = response.parts;
+    const parts = Array.isArray(raw) ? raw : [];
+    const checked = parts.map(contractOutputPart);
+    if (Array.isArray(raw) && checked.every((p, i) => p === parts[i]))
+        return response;
+    return { ...response, parts: checked.filter((p) => p !== undefined) };
+}
 /** A ModelResponse as the LlmResponse ADK expects from a model (see the header). */
-export function modelResponseToLlmResponse(response) {
-    const parts = response.parts.map(partToGenai);
+export function modelResponseToLlmResponse(unchecked) {
+    const response = contractModelResponse(unchecked);
+    const parts = partsToGenai(response.parts);
     if (response.partial)
         return { content: { role: 'model', parts }, partial: true };
     const finishReason = finishReasonOfCode(response.error?.code) ?? FINISH_REASONS[response.finishReason];

package/dist/lib/models/gptLlm.js

@@ -33,7 +33,7 @@
  * The LlmRequest builders below (buildResponsesInput, buildResponsesTools)
  * are the adapter's own, run on the LlmRequest mapped to the contract.
  */
-import { LLMRegistry } from '@google/adk';
+import { requireAdk } from '../adkPeer.js';
 import { AdkShim } from './adkShim.js';
 import { llmRequestToModelRequest, reasoningOf } from './genaiMapping.js';
 import { GptAdapter, responsesFunctionTools, responsesInput, responsesServerTools } from './gptAdapter.js';
@@ -125,5 +125,5 @@ export class GptLlm extends AdkShim {
  * registerAvailableProviders() when OPENAI_API_KEY is present.
  */
 export function registerGptLlm() {
-    LLMRegistry.register(GptLlm);
+    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(GptLlm);
 }

package/dist/lib/models/grokLlm.js

@@ -34,7 +34,7 @@
  * "grok-4.3"), which may differ from the requested id; invalid ids are
  * rejected with "Model not found".
  */
-import { LLMRegistry } from '@google/adk';
+import { requireAdk } from '../adkPeer.js';
 import { GptLlm } from './gptLlm.js';
 import { GrokAdapter } from './grokAdapter.js';
 export { DEFAULT_GROK_TIMEOUT_MS, grokTimeoutMs } from './grokAdapter.js';
@@ -52,5 +52,5 @@ export class GrokLlm extends GptLlm {
  * registerAvailableProviders() when XAI_API_KEY is present.
  */
 export function registerGrokLlm() {
-    LLMRegistry.register(GrokLlm);
+    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(GrokLlm);
 }

package/dist/lib/models/kimiLlm.js

@@ -15,7 +15,7 @@
  *   this path an agent's older spelling `reasoningEffort: max` still reaches
  *   K3, which the contract has no level for.
  */
-import { LLMRegistry } from '@google/adk';
+import { requireAdk } from '../adkPeer.js';
 import { KimiAdapter } from './kimiAdapter.js';
 import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.js';
 export { MOONSHOT_BASE_URL, isKimiK3, wantsReasoningReplay } from './kimiAdapter.js';
@@ -31,5 +31,5 @@ export class KimiLlm extends OpenAiCompatibleLlm {
 // ── Registration helper ───────────────────────────────────────────────────────
 /** Registers KimiLlm with the ADK LLMRegistry (called when MOONSHOT_API_KEY is set). */
 export function registerKimiLlm() {
-    LLMRegistry.register(KimiLlm);
+    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(KimiLlm);
 }

package/dist/lib/models/ollamaLlm.js

@@ -12,7 +12,7 @@
  *   supportedModels are what they were before the adapter moved onto the
  *   contract, so lib/models/registry.ts and every caller are unchanged.
  */
-import { LLMRegistry } from '@google/adk';
+import { requireAdk } from '../adkPeer.js';
 import { OllamaAdapter } from './ollamaAdapter.js';
 import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.js';
 // ── OllamaLlm ─────────────────────────────────────────────────────────────────
@@ -38,5 +38,5 @@ export class OllamaLlm extends OpenAiCompatibleLlm {
  * OLLAMA_UNREACHABLE message that says how to start it.
  */
 export function registerOllamaLlm() {
-    LLMRegistry.register(OllamaLlm);
+    requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(OllamaLlm);
 }

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

@@ -84,6 +84,10 @@ export declare function providerStatuses(): ProviderStatus[];
  * provider whose direct key is ABSENT is served by the gateway stand-in
  * instead (lib/models/gateway.ts — the fallback rule). Returns the
  * per-provider statuses so entrypoints can log which models are routable.
+ *
+ * Without @google/adk installed there is no LLMRegistry to register into:
+ * the native runtime resolves every id through resolveAdapter, so nothing is
+ * registered and the statuses are returned as they are (ADR 0102).
  */
 export declare function registerAvailableProviders(log?: (msg: string) => void): ProviderStatus[];
 export interface ResolveModelOptions {
@@ -109,7 +113,7 @@ export interface ResolveModelOptions {
  * `defaultProvider` (or Gemini).
  */
 export declare function resolveModel(model: string | undefined, options?: ResolveModelOptions): BaseLlm;
-/** GEMINI_ADAPTER (`adk`, the default here, or `engine`). Any other value is a configuration error. */
+/** GEMINI_ADAPTER (`engine`, the default, or `adk`). Any other value is a configuration error. */
 export declare function geminiAdapterChoice(env?: NodeJS.ProcessEnv): GeminiAdapterChoice;
 /**
  * Resolves a model id to the engine's own ModelAdapter (ADR 0048), from the

package/dist/lib/models/registry.js

@@ -40,7 +40,7 @@
  * Register BEFORE constructing any agent: the LLMRegistry caches model→class
  * resolution (LRU), so late registration can be masked by stale cache hits.
  */
-import { Gemini, LLMRegistry } from '@google/adk';
+import { Gemini, adkInstalled, requireAdk } from '../adkPeer.js';
 import { endpointFromEnv, endpointProblems, providerReady } from './endpoints.js';
 import { DEFAULT_CLAUDE_MODEL, DEFAULT_GEMINI_MODEL, DEFAULT_GPT_MODEL, DEFAULT_GROK_MODEL, DEFAULT_KIMI_MODEL, DEFAULT_OLLAMA_MODEL, } from '../config.js';
 import { AdkGeminiAdapter } from './adkGeminiAdapter.js';
@@ -98,7 +98,7 @@ export function providerStatuses() {
     });
 }
 const REGISTRARS = {
-    gemini: () => LLMRegistry.register(TracedGemini),
+    gemini: () => requireAdk("Registering a model class with ADK's LLMRegistry").LLMRegistry.register(TracedGemini),
     anthropic: registerClaudeLlm,
     openai: registerGptLlm,
     xai: registerGrokLlm,
@@ -113,13 +113,13 @@ const REGISTRARS = {
  * are registered at import time — replacing them is how TracedGemini works
  * too.
  */
-const PATTERNS = {
+const PATTERNS = () => ({
     gemini: Gemini.supportedModels,
     anthropic: ClaudeLlm.supportedModels,
     openai: GptLlm.supportedModels,
     xai: GrokLlm.supportedModels,
     moonshot: KimiLlm.supportedModels,
-};
+});
 let providersRegistered = false;
 /**
  * Registers every adapter whose credentials exist into the ADK LLMRegistry
@@ -129,14 +129,18 @@ let providersRegistered = false;
  * provider whose direct key is ABSENT is served by the gateway stand-in
  * instead (lib/models/gateway.ts — the fallback rule). Returns the
  * per-provider statuses so entrypoints can log which models are routable.
+ *
+ * Without @google/adk installed there is no LLMRegistry to register into:
+ * the native runtime resolves every id through resolveAdapter, so nothing is
+ * registered and the statuses are returned as they are (ADR 0102).
  */
 export function registerAvailableProviders(log) {
     const statuses = providerStatuses();
-    if (!providersRegistered) {
+    if (!providersRegistered && adkInstalled()) {
         providersRegistered = true;
         for (const status of statuses) {
             if (status.transport === 'gateway' && status.provider !== 'ollama') {
-                registerGatewayLlm(PATTERNS[status.provider]);
+                registerGatewayLlm(PATTERNS()[status.provider]);
             }
             else if (status.available || status.provider === 'gemini') {
                 REGISTRARS[status.provider]();
@@ -213,16 +217,17 @@ export function resolveModel(model, options = {}) {
     return route.transport === 'gateway' ? new GatewayLlm({ model: resolved }) : ADK_LLM[route.provider](route);
 }
 // ── Contract adapters (the native runtime) ───────────────────────────────────
-/** GEMINI_ADAPTER (`adk`, the default here, or `engine`). Any other value is a configuration error. */
+/** GEMINI_ADAPTER (`engine`, the default, or `adk`). Any other value is a configuration error. */
 export function geminiAdapterChoice(env = process.env) {
-    return geminiAdapterSetting(env) ?? 'adk';
+    return geminiAdapterSetting(env) ?? 'engine';
 }
 /**
  * The contract resolver with the temporary AdkGeminiAdapter (ADR 0060): a
- * Gemini id gets it until gate G3, or the engine's GeminiAdapter when
- * GEMINI_ADAPTER=engine or `{ gemini: 'engine' }` asks for it. The
- * ADK-free resolver in lib/models/adapterResolver.ts, which
- * `melchizedek-agents/model` exports, defaults to GeminiAdapter (ADR 0068).
+ * Gemini id gets the engine's GeminiAdapter (the default since 0.20.0, ADR
+ * 0100), or AdkGeminiAdapter when GEMINI_ADAPTER=adk or `{ gemini: 'adk' }`
+ * asks for it, for one release, which needs @google/adk. The ADK-free
+ * resolver in lib/models/adapterResolver.ts, which `melchizedek-agents/model`
+ * exports, refuses `adk` (ADR 0068).
  */
 const WITH_ADK_GEMINI = adapterResolver((r) => new AdkGeminiAdapter(r));
 /**

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

@@ -11,7 +11,7 @@
  * cycle. registry.ts re-exports it, so `TracedGemini` imports from there keep
  * working.
  */
-import { Gemini } from '@google/adk';
+import { Gemini } from '../adkPeer.ts';
 import type { GeminiParams, LlmRequest, LlmResponse } from '@google/adk';
 import type { ProviderEndpoint } from './endpoints.ts';
 export declare class TracedGemini extends Gemini {

package/dist/lib/models/tracedGemini.js

@@ -11,7 +11,7 @@
  * cycle. registry.ts re-exports it, so `TracedGemini` imports from there keep
  * working.
  */
-import { Gemini } from '@google/adk';
+import { Gemini } from '../adkPeer.js';
 import { endpointFromEnv, platformModel } from './endpoints.js';
 import { llmRequestToModelRequest } from './genaiMapping.js';
 import { errorStatus, retryUntilFirstYield } from './retry.js';

package/dist/lib/runtime/adkSessionBridge.d.ts

@@ -31,7 +31,7 @@
  * This module loads ADK at run time, so it is not one of the engine's leaf
  * modules (tests/events.test.ts names those).
  */
-import { BaseSessionService } from '@google/adk';
+import { BaseSessionService } from '../adkPeer.ts';
 import type { CreateSessionRequest as AdkCreateSessionRequest, DeleteSessionRequest as AdkDeleteSessionRequest, Event as AdkEvent, GetSessionRequest as AdkGetSessionRequest, ListSessionsRequest as AdkListSessionsRequest, ListSessionsResponse as AdkListSessionsResponse, Session as AdkSession } from '@google/adk';
 import type { TurnEvent } from './events.ts';
 import type { CreateSessionRequest, GetSessionOptions, ListSessionsRequest, ListSessionsResult, Session, SessionKey, SessionService } from './sessions.ts';

package/dist/lib/runtime/adkSessionBridge.js

@@ -31,7 +31,7 @@
  * This module loads ADK at run time, so it is not one of the engine's leaf
  * modules (tests/events.test.ts names those).
  */
-import { BaseSessionService } from '@google/adk';
+import { BaseSessionService } from '../adkPeer.js';
 import { applyEvent, listPage, listWindow, selectEvents, withoutTempKeys } from './sessions.js';
 /** Every method the engine's interface names. */
 export function isSessionService(value) {

package/dist/lib/runtime/approvals.d.ts

@@ -29,6 +29,11 @@ export interface PendingApproval {
  * The approval request still waiting for an answer, or undefined. A request
  * the user moved on from (a new text message after it) is not pending: its
  * call never runs.
+ *
+ * In a workflow (ADR 0098) the walk stores each node's input as a user text
+ * turn, so a sibling node's input may follow a gated node's request. The
+ * walk's pause record, stored last, names every interrupt it left open: a
+ * request it names is pending whatever node turns came after it.
  */
 export declare function pendingApproval(events: readonly Event[]): PendingApproval | undefined;
 /** Index of the user message that started the turn holding request `id` (its events are replayed raw on resume). */

package/dist/lib/runtime/approvals.js

@@ -4,15 +4,53 @@ const partsOf = (e) => (e.content?.parts ?? []);
 function hasUserText(e) {
     return e.author === 'user' && partsOf(e).some((p) => typeof p.text === 'string' && p.text.trim() && !p.thought);
 }
+/**
+ * A workflow's pause record (lib/workflow/pause.ts workflowPauseEvent, ADK's
+ * recordInputForResume): no content, every interrupt the walk left open in
+ * `longRunningToolIds`, at the workflow's own path. Its ids, else undefined.
+ */
+function workflowPauseIds(e) {
+    if (e.author === 'user' || partsOf(e).length > 0)
+        return undefined;
+    const path = e.nodeInfo?.path;
+    if (typeof path !== 'string' || !path || path.includes('.'))
+        return undefined;
+    return e.longRunningToolIds?.length ? [...e.longRunningToolIds] : undefined;
+}
+const requestOf = (e, call) => {
+    const original = call.args?.originalFunctionCall ?? {};
+    return {
+        id: call.id,
+        agent: e.author ?? '',
+        tool: String(original.name ?? ''),
+        args: (original.args ?? {}),
+        ...(original.id ? { callId: String(original.id) } : {}),
+    };
+};
 /**
  * The approval request still waiting for an answer, or undefined. A request
  * the user moved on from (a new text message after it) is not pending: its
  * call never runs.
+ *
+ * In a workflow (ADR 0098) the walk stores each node's input as a user text
+ * turn, so a sibling node's input may follow a gated node's request. The
+ * walk's pause record, stored last, names every interrupt it left open: a
+ * request it names is pending whatever node turns came after it.
  */
 export function pendingApproval(events) {
     const answered = new Set();
     for (let i = events.length - 1; i >= 0; i--) {
         const e = events[i];
+        const paused = workflowPauseIds(e);
+        if (paused) {
+            const open = new Set(paused.filter((id) => !answered.has(id)));
+            for (let j = i - 1; j >= 0 && open.size > 0; j--) {
+                const request = partsOf(events[j]).find((p) => p.functionCall?.name === APPROVAL_REQUEST && open.has(p.functionCall.id));
+                if (request)
+                    return requestOf(events[j], request.functionCall);
+            }
+            return undefined;
+        }
         if (hasUserText(e))
             return undefined;
         for (const p of partsOf(e)) {
@@ -23,14 +61,7 @@ export function pendingApproval(events) {
             const call = p.functionCall;
             if (call?.name !== APPROVAL_REQUEST || !call.id || answered.has(call.id))
                 continue;
-            const original = call.args?.originalFunctionCall ?? {};
-            return {
-                id: call.id,
-                agent: e.author ?? '',
-                tool: String(original.name ?? ''),
-                args: (original.args ?? {}),
-                ...(original.id ? { callId: String(original.id) } : {}),
-            };
+            return requestOf(e, call);
         }
     }
     return undefined;

package/dist/lib/runtime/credentials.d.ts

@@ -46,7 +46,9 @@ export declare function consentFrom(author: string | undefined, call: {
 /**
  * The consent request still waiting in a session, or undefined. One that is
  * answered (a function response with its id), or that the person moved past
- * with a text message, is not pending.
+ * with a text message, is not pending. Only an agent asks: a request in an
+ * event the user authored is none, so a forged request never makes the next
+ * message a grant (as pendingQuestion reads ask_user).
  */
 export declare function pendingConsent(events: readonly Event[]): PendingConsent | undefined;
 /**

package/dist/lib/runtime/credentials.js

@@ -27,7 +27,9 @@ export function consentFrom(author, call) {
 /**
  * The consent request still waiting in a session, or undefined. One that is
  * answered (a function response with its id), or that the person moved past
- * with a text message, is not pending.
+ * with a text message, is not pending. Only an agent asks: a request in an
+ * event the user authored is none, so a forged request never makes the next
+ * message a grant (as pendingQuestion reads ask_user).
  */
 export function pendingConsent(events) {
     const answered = new Set();
@@ -39,6 +41,9 @@ export function pendingConsent(events) {
             if (p.functionResponse?.name === CREDENTIAL_REQUEST && p.functionResponse.id)
                 answered.add(p.functionResponse.id);
         }
+        // Only an agent asks: a credential request in an event the user authored is none, as pendingQuestion reads ask_user (WS5-5).
+        if (e.author === 'user')
+            continue;
         for (const p of partsOf(e)) {
             const call = p.functionCall;
             if (call?.name !== CREDENTIAL_REQUEST || !call.id || answered.has(call.id))

package/dist/lib/runtime/native/agentLoop.d.ts

@@ -36,7 +36,11 @@
  *      - a long-running tool (ask_user) that returns nothing answers
  *        nothing; its actions, when it set any, make an event of their own;
  *      - a result that is not an object is wrapped `{ result }`, an array
- *        `{ results }`, as ADK wraps them.
+ *        `{ results }`, as ADK wraps them;
+ *      - a result nested deeper than MAX_VALUE_DEPTH levels answers
+ *        `{ error: TOO_DEEP_RESULT }` instead: every later reader of the
+ *        session would overflow its stack on it (lib/runtime/valueDepth.ts,
+ *        ADR 0101). ADK keeps it.
  *      One call's response is stored as its own event; several are merged
  *      into one, parts in call order and actions merged (ADK's
  *      mergeParallelFunctionResponseEvents). ADK runs the calls one after
@@ -189,6 +193,8 @@ export interface AgentLoopEnd {
  * when it does not validate).
  */
 export declare function saveOutput(agent: Pick<NativeAgent, 'name' | 'outputKey' | 'outputSchema'>, event: TurnEvent): void;
+/** What a tool's result becomes when it nests past MAX_VALUE_DEPTH (ADR 0101). */
+export declare const TOO_DEEP_RESULT: (toolName: string) => string;
 /**
  * Runs `agent` on the session in `ctx` until its answer is final, yielding
  * every event in order: partials as they arrive (never stored), then each