melchizedek-agents 0.19.0 → 0.20.0

package/dist/lib/compileNative.js

@@ -16,7 +16,8 @@
  * runs by shape during the dual period (ADR 0071). A delegated subagent
  * becomes a subagentTool holding its own NativeAgent, which the loop runs as
  * a child loop (lib/runtime/native/delegate.ts, ADR 0074), a nested
- * syndicate as its orchestrator's agent; a remote A2A subagent is the own
+ * syndicate as its orchestrator's agent, a nested workflow syndicate as a
+ * workflowSubagentTool whose call walks the whole graph (ADR 0098); a remote A2A subagent is the own
  * Tool the ADK runtime's FunctionTool wraps (lib/a2a/remoteAgent.ts).
  *
  * EVERY AGENT KEY COMPILES for the native loop: `context:` is handed to
@@ -41,10 +42,13 @@
 import { remoteAgentOwnTool } from './a2a/remoteAgent.js';
 import { compileSpec, compileSubagentSpec } from './compile.js';
 import { providerForModel, resolveAdapter } from './models/registry.js';
-import { subagentTool } from './runtime/native/delegate.js';
+import { subagentTool, workflowSubagentTool } from './runtime/native/delegate.js';
+import { servedThroughShim } from './runtime/native/selfCorrection.js';
 import { unsupportedOnNative } from './runtime/runtimeFlag.js';
 export { UnsupportedOnRuntimeError, unsupportedOnNative } from './runtime/runtimeFlag.js';
 import { instructionToolOf, toolOf, toolsetOf } from './tools/tool.js';
+import { buildWorkflowGraph } from './workflow/graph.js';
+import { refuseUnrunnableNodes, runNativeWorkflow } from './workflow/turn.js';
 /** A resolved tool as the loop holds it: the own Tool, InstructionTool or Toolset behind it, else the object itself. */
 function nativeTool(tool) {
     return toolOf(tool) ?? instructionToolOf(tool) ?? toolsetOf(tool) ?? tool;
@@ -85,6 +89,8 @@ export function compileNative(spec) {
     for (const entry of spec.tools) {
         if (entry.kind === 'agent')
             tools.push(subagentTool(compileNative(entry.agent)));
+        else if (entry.kind === 'workflow')
+            tools.push(workflowSubagentTool(workflowSubagentOf(compileNativeWorkflow(entry.workflow))));
         else if (entry.kind === 'remote')
             tools.push(remoteAgentOwnTool({ name: entry.name, description: entry.description, url: entry.url }));
         else
@@ -145,6 +151,50 @@ export function wireModelOf(spec) {
 export async function compileNativeGraph(config, opts = {}) {
     return compileNative(await compileSpec(config, opts));
 }
+/**
+ * A workflow spec for the native walk: the graph, every agent compiled for
+ * native from the same specs ADK's assembleWorkflow builds its agents from,
+ * and the registry's lookup for tool nodes. A tool node ADK's compile
+ * refuses (an unregistered or long-running tool) is refused here, before
+ * any model call, with ADK's message.
+ */
+export function compileNativeWorkflow(spec) {
+    const graph = buildWorkflowGraph(spec.config);
+    const agents = new Map();
+    for (const { yaml, spec: agentSpec } of spec.agents)
+        agents.set(yaml.name, compileNative(agentSpec));
+    refuseUnrunnableNodes(graph, spec.resolveTool);
+    return { name: spec.name, description: spec.description, graph, agents, resolveTool: spec.resolveTool };
+}
+/**
+ * A nested workflow as the delegated subagent the native loop calls (ADR
+ * 0098): one call walks the whole graph with runNativeWorkflow on the child
+ * session lib/runtime/native/delegate.ts opened, as ADK's AgentTool runs a
+ * Workflow on its own Runner.
+ */
+export function workflowSubagentOf(workflow) {
+    return {
+        name: workflow.name,
+        ...(workflow.description ? { description: workflow.description } : {}),
+        walk: (run) => runNativeWorkflow({
+            graph: workflow.graph,
+            agents: workflow.agents,
+            resolveTool: workflow.resolveTool,
+            sessions: run.sessions,
+            appName: run.appName,
+            userId: run.userId,
+            sessionId: run.sessionId,
+            userParts: run.userParts,
+            adapterFor: run.adapterFor,
+            selfCorrection: run.selfCorrection,
+            stream: false,
+            ...(run.signal ? { signal: run.signal } : {}),
+            ...(run.memory ? { memory: run.memory } : {}),
+            ...(run.log ? { log: run.log } : {}),
+            ...(run.credentials ? { credentials: run.credentials } : {}),
+        }),
+    };
+}
 /** One subagent entry (a dispatch route) for the native loop: compileSubagentSpec, then compileNative. */
 export async function compileNativeSubagent(subCfg, opts = {}) {
     return compileNative(await compileSubagentSpec(subCfg, opts));
@@ -167,8 +217,9 @@ function adapterOf(resolved, model) {
     if (!resolved || typeof resolved !== 'object')
         return resolveAdapter(model);
     const held = resolved;
+    // On ADK a shim declares the toolsDict, the reflection tool included, whatever its adapter (ADR 0097).
     if (isModelAdapter(held.adapter))
-        return held.adapter;
+        return servedThroughShim(held.adapter);
     // On Vertex AI the client authenticates with the platform's credentials, never a key (ADR 0023).
     if (typeof held.apiKey === 'string' && held.apiKey && held.vertexai !== true) {
         return resolveAdapter(model, { apiKey: held.apiKey, keyProvider: providerForModel(model) });
@@ -203,9 +254,14 @@ export function nativeAdapterFor(opts = {}, spec) {
             refuseModelClass(resolved, id, s.name ?? 'the native runtime');
             known.set(id, resolved);
         }
-        for (const entry of s.tools ?? [])
+        for (const entry of s.tools ?? []) {
             if (entry.kind === 'agent')
                 learn(entry.agent);
+            // A nested workflow's agents run under the caller's lookup (ADR 0098).
+            else if (entry.kind === 'workflow')
+                for (const node of entry.workflow.agents)
+                    learn(node.spec);
+        }
     };
     // A workflow's agents share one lookup: every node's spec is learned.
     for (const s of spec === undefined ? [] : Array.isArray(spec) ? spec : [spec])

package/dist/lib/doctor.d.ts

@@ -18,11 +18,15 @@
  * The routing and capability judgments are not re-implemented here: they
  * come from lib/models/gateway.ts and lib/models/capabilities.ts, the same
  * modules the registry and the A2A server use, so the report cannot
- * disagree with what a run would do.
+ * disagree with what a run would do. The runtime line comes from
+ * lib/runtime/runtimeFlag.ts, which a turn reads (ADR 0102); whether
+ * @google/adk is installed is a module resolution, so the doctor never
+ * loads ADK to answer it.
  */
 import type { Platform } from './models/endpoints.ts';
 import type { CapabilityGap, CapabilityReport } from './models/capabilities.ts';
 import type { ProviderId } from './models/providerMap.ts';
+import type { RuntimeName, RuntimeSource } from './runtime/runtimeFlag.ts';
 /**
  * What a file costs to run: `keyless` (all Ollama), a single provider's id
  * when every agent shares one (`gemini`, `anthropic`, `openai`, `xai` — one
@@ -81,8 +85,25 @@ export interface Unlock {
     /** Syndicates this one variable would move from blocked to ready. */
     syndicates: string[];
 }
+/** The runtime a turn would run on here, where that came from, and the optional ADK peer (ADR 0102). */
+export interface DoctorRuntime {
+    /** The runtime in use; undefined when MELCHIZEDEK_RUNTIME holds a value no turn accepts (`problem` says so). */
+    runtime?: RuntimeName;
+    /** Where it came from: MELCHIZEDEK_RUNTIME, or the default (a turn's own option is the caller's, not the environment's). */
+    source?: RuntimeSource;
+    /** @google/adk: whether it resolves from here, its version, and whether the runtime in use needs it. */
+    adk: {
+        installed: boolean;
+        version?: string;
+        needed: boolean;
+    };
+    /** Why no turn would run as configured, if none would. */
+    problem?: string;
+}
 export interface DoctorResult {
     agentsDir: string;
+    /** The runtime in use and whether @google/adk is installed. */
+    runtime: DoctorRuntime;
     syndicates: DoctorSyndicate[];
     unlocks: Unlock[];
     gateway: {
@@ -110,6 +131,12 @@ export interface DoctorEndpoint {
     /** Cloud platforms are tested against mocks only (ADR 0023). */
     liveVerified: boolean;
 }
+/**
+ * The runtime a turn would run on under this environment (lib/runtime/
+ * runtimeFlag.ts), where that came from, and whether @google/adk resolves.
+ * `adk` without the package is a problem: every turn would fail.
+ */
+export declare function runtimeReport(env?: NodeJS.ProcessEnv, adkResolvable?: (module: string) => boolean): DoctorRuntime;
 /** One row per provider that is not on its vendor's public API with an env key. */
 export declare function endpointRows(): DoctorEndpoint[];
 export declare const CONSOLE_URLS: Record<ProviderId, string>;

package/dist/lib/doctor.js

@@ -18,7 +18,10 @@
  * The routing and capability judgments are not re-implemented here: they
  * come from lib/models/gateway.ts and lib/models/capabilities.ts, the same
  * modules the registry and the A2A server use, so the report cannot
- * disagree with what a run would do.
+ * disagree with what a run would do. The runtime line comes from
+ * lib/runtime/runtimeFlag.ts, which a turn reads (ADR 0102); whether
+ * @google/adk is installed is a module resolution, so the doctor never
+ * loads ADK to answer it.
  */
 import fs from 'node:fs';
 import path from 'node:path';
@@ -30,6 +33,7 @@ import { CAPABILITY_LABELS, capabilityGaps, describeCapabilities } from './model
 import { credentialSource, endpointFromEnv, endpointLabel, endpointProblems, PLATFORM_SDK, PLATFORMS_FOR } from './models/endpoints.js';
 import { GATEWAY_ENV, GATEWAY_KEY_ENV, GATEWAYS, gatewayConfig, gatewayProblem, gatewayUsable, } from './models/gateway.js';
 import { PROVIDERS } from './models/providerMap.js';
+import { describeRuntime } from './runtime/runtimeFlag.js';
 function resolvable(module) {
     try {
         createRequire(import.meta.url).resolve(module);
@@ -39,6 +43,52 @@ function resolvable(module) {
         return false;
     }
 }
+/** The installed version of a package that resolves from here, read from its package.json (its exports map may hide it). */
+function installedVersion(module) {
+    try {
+        let dir = path.dirname(createRequire(import.meta.url).resolve(module));
+        for (let i = 0; i < 8; i++) {
+            const file = path.join(dir, 'package.json');
+            if (fs.existsSync(file)) {
+                const pkg = JSON.parse(fs.readFileSync(file, 'utf8'));
+                if (pkg.name === module)
+                    return pkg.version;
+            }
+            const up = path.dirname(dir);
+            if (up === dir)
+                break;
+            dir = up;
+        }
+    }
+    catch {
+        // Not resolvable, or unreadable: no version to report.
+    }
+    return undefined;
+}
+/** The ADK peer, as an install command names it. */
+const ADK_PEER = '@google/adk';
+/**
+ * The runtime a turn would run on under this environment (lib/runtime/
+ * runtimeFlag.ts), where that came from, and whether @google/adk resolves.
+ * `adk` without the package is a problem: every turn would fail.
+ */
+export function runtimeReport(env = process.env, adkResolvable = resolvable) {
+    const installed = adkResolvable(ADK_PEER);
+    const adk = { installed, ...(installed && installedVersion(ADK_PEER) ? { version: installedVersion(ADK_PEER) } : {}) };
+    let chosen;
+    try {
+        chosen = describeRuntime(undefined, env);
+    }
+    catch (err) {
+        return { adk: { ...adk, needed: false }, problem: err instanceof Error ? err.message : String(err) };
+    }
+    const needed = chosen.runtime === 'adk';
+    return {
+        ...chosen,
+        adk: { ...adk, needed },
+        ...(needed && !installed ? { problem: `MELCHIZEDEK_RUNTIME=adk needs ${ADK_PEER}, which is not installed: npm install ${ADK_PEER}@~2.2.0, or unset MELCHIZEDEK_RUNTIME to run on native` } : {}),
+    };
+}
 /** One row per provider that is not on its vendor's public API with an env key. */
 export function endpointRows() {
     const rows = [];
@@ -381,7 +431,7 @@ export function runDoctor(options = {}) {
     for (const s of syndicates)
         counts[s.verdict.state]++;
     flagMemoryNamespaces(syndicates);
-    return { agentsDir, syndicates, unlocks, gateway, endpoints: endpointRows(), counts };
+    return { agentsDir, runtime: runtimeReport(), syndicates, unlocks, gateway, endpoints: endpointRows(), counts };
 }
 // ── Rendering ────────────────────────────────────────────────────────────────
 const ANSI = {
@@ -417,6 +467,17 @@ export function renderDoctor(result, opts = {}) {
             : `${c.green}${text}${c.reset}`;
     lines.push(`${c.bold}melchizedek doctor${c.reset} ${c.dim}· ${result.agentsDir}${c.reset}`);
     lines.push('');
+    // The runtime a turn would run on, where that came from, and the ADK peer (ADR 0102).
+    if (result.runtime) {
+        const rt = result.runtime;
+        const adk = rt.adk.installed
+            ? `${ADK_PEER} ${rt.adk.version ?? ''}`.trimEnd() + ' installed'
+            : `${ADK_PEER} not installed${rt.adk.needed ? '' : ' (needed only for MELCHIZEDEK_RUNTIME=adk)'}`;
+        const source = rt.source === 'default' ? 'the default' : rt.source;
+        lines.push(rt.problem
+            ? `runtime     ${c.red}✗${c.reset} ${rt.runtime ? `${rt.runtime} ${c.dim}(${source})${c.reset} · ` : ''}${c.red}${rt.problem}${c.reset}`
+            : `runtime     ${c.green}✓${c.reset} ${rt.runtime} ${c.dim}(${source})${c.reset} · ${c.dim}${adk}${c.reset}`);
+    }
     // Provider line: what is funded, and how. Each provider is probed with an
     // id of its own prefix, so the line names ITS key (a fallthrough once put
     // xAI's key beside Moonshot).

package/dist/lib/index.d.ts

@@ -14,6 +14,10 @@
 export { loadSyndicate, loadSyndicateFromRegistry, parseCliBindings, validateRegistryConfig, } from './loadSyndicate.ts';
 export type { AgentYamlConfig, LoadSyndicateOptions, SubagentYamlConfig, SyndicateYamlConfig, VariableMap, } from './loadSyndicate.ts';
 export { runSyndicateTurn, ingestTurnMemory } from './runtime/syndicateTurn.ts';
+export { DEFAULT_RUNTIME, describeRuntime, AdkNotInstalledError, adkInstalled } from './runtime/syndicateTurn.ts';
+export type { RuntimeName, RuntimeSource } from './runtime/syndicateTurn.ts';
+export { InProcessSessionService } from './runtime/sessions.ts';
+export { asAdkSessionService, asSessionService } from './runtime/adkSessionBridge.ts';
 export { approvalResponsePart, pendingApproval, APPROVAL_REQUEST } from './runtime/approvals.ts';
 export type { PendingApproval } from './runtime/approvals.ts';
 export type { DrainedRun, MessagePart, TurnUsage, RouteDecision, SyndicateTurnOptions, SyndicateTurnResult, TraceOptions, TurnEvents, TurnStage, } from './runtime/syndicateTurn.ts';

package/dist/lib/index.js

@@ -15,6 +15,11 @@
 export { loadSyndicate, loadSyndicateFromRegistry, parseCliBindings, validateRegistryConfig, } from './loadSyndicate.js';
 // ── Run it ──────────────────────────────────────────────────────────────────
 export { runSyndicateTurn, ingestTurnMemory } from './runtime/syndicateTurn.js';
+// The runtime in use (native by default since 0.20.0) and the optional ADK peer (ADR 0102).
+export { DEFAULT_RUNTIME, describeRuntime, AdkNotInstalledError, adkInstalled } from './runtime/syndicateTurn.js';
+// An in-process session store that needs no ADK; runSyndicateTurn takes it through asAdkSessionService.
+export { InProcessSessionService } from './runtime/sessions.js';
+export { asAdkSessionService, asSessionService } from './runtime/adkSessionBridge.js';
 export { approvalResponsePart, pendingApproval, APPROVAL_REQUEST } from './runtime/approvals.js';
 export { compileGraph, compileSubagent } from './compile.js';
 export { compileWorkflow, isWorkflowSyndicate, describeInput } from './workflow.js';

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

@@ -11,12 +11,13 @@
  * and the contract adapter table live here; registry.ts imports them for
  * resolveModel and for its own resolveAdapter.
  *
- * GEMINI (ADR 0068): `adapterResolver(adkGemini)` takes the factory for the
- * temporary AdkGeminiAdapter from its caller. registry.ts passes one, so its
- * resolveAdapter keeps ADR 0060's default (`adk` until gate G3). The resolver
- * exported here has none: a Gemini id gets the engine's GeminiAdapter unless
- * `adk` is asked for, by the option or by GEMINI_ADAPTER=adk, which throws
- * and names the entry that has it.
+ * GEMINI (ADR 0068, ADR 0100): a Gemini id gets the engine's GeminiAdapter
+ * unless `adk` is asked for, by the option or by GEMINI_ADAPTER=adk.
+ * `adapterResolver(adkGemini)` takes the factory for the temporary
+ * AdkGeminiAdapter from its caller: registry.ts passes one, so `adk` works
+ * there for one release (with @google/adk installed). The resolver exported
+ * here has none, so asking it for `adk` throws and names the entry that has
+ * it.
  */
 import type { ModelAdapter } from './contract.ts';
 import type { ProviderEndpoint } from './endpoints.ts';
@@ -75,8 +76,9 @@ export interface ResolveAdapterOptions {
     endpoint?: Partial<ProviderEndpoint>;
     /**
      * Which Gemini adapter a Gemini id gets. Default: GEMINI_ADAPTER, else
-     * `adk` through `melchizedek-agents/models/registry` and `engine` through
-     * `melchizedek-agents/model`, which has no `adk`.
+     * `engine` (since 0.20.0, ADR 0100). `adk` is available for one release
+     * through `melchizedek-agents/models/registry` with @google/adk installed;
+     * `melchizedek-agents/model` has no `adk`.
      */
     gemini?: GeminiAdapterChoice;
 }
@@ -89,9 +91,9 @@ export interface AdapterResolver {
     resolveAdapterWithFallback(modelId: string, fallbackId: string | undefined, options?: ResolveAdapterOptions, fallbackOptions?: FallbackAdapterOptions): ModelAdapter;
 }
 /**
- * A resolver over the one prefix table. With `adkGemini`, a Gemini id gets
- * AdkGeminiAdapter unless `engine` is asked for (ADR 0060). Without it, a
- * Gemini id gets GeminiAdapter, and asking for `adk` throws (ADR 0068).
+ * A resolver over the one prefix table. A Gemini id gets GeminiAdapter
+ * unless `adk` is asked for (ADR 0100). With `adkGemini`, `adk` gets
+ * AdkGeminiAdapter (ADR 0060); without it, asking for `adk` throws (ADR 0068).
  */
 export declare function adapterResolver(adkGemini?: AdkGeminiFactory): AdapterResolver;
 /**

package/dist/lib/models/adapterResolver.js

@@ -11,12 +11,13 @@
  * and the contract adapter table live here; registry.ts imports them for
  * resolveModel and for its own resolveAdapter.
  *
- * GEMINI (ADR 0068): `adapterResolver(adkGemini)` takes the factory for the
- * temporary AdkGeminiAdapter from its caller. registry.ts passes one, so its
- * resolveAdapter keeps ADR 0060's default (`adk` until gate G3). The resolver
- * exported here has none: a Gemini id gets the engine's GeminiAdapter unless
- * `adk` is asked for, by the option or by GEMINI_ADAPTER=adk, which throws
- * and names the entry that has it.
+ * GEMINI (ADR 0068, ADR 0100): a Gemini id gets the engine's GeminiAdapter
+ * unless `adk` is asked for, by the option or by GEMINI_ADAPTER=adk.
+ * `adapterResolver(adkGemini)` takes the factory for the temporary
+ * AdkGeminiAdapter from its caller: registry.ts passes one, so `adk` works
+ * there for one release (with @google/adk installed). The resolver exported
+ * here has none, so asking it for `adk` throws and names the entry that has
+ * it.
  */
 import { ClaudeAdapter } from './claudeAdapter.js';
 import { mergeEndpoint } from './endpoints.js';
@@ -78,9 +79,9 @@ const CONTRACT_ADAPTER = {
     moonshot: (r) => new KimiAdapter({ model: r.model, apiKey: r.apiKey, baseUrl: r.endpoint?.baseURL }),
 };
 /**
- * A resolver over the one prefix table. With `adkGemini`, a Gemini id gets
- * AdkGeminiAdapter unless `engine` is asked for (ADR 0060). Without it, a
- * Gemini id gets GeminiAdapter, and asking for `adk` throws (ADR 0068).
+ * A resolver over the one prefix table. A Gemini id gets GeminiAdapter
+ * unless `adk` is asked for (ADR 0100). With `adkGemini`, `adk` gets
+ * AdkGeminiAdapter (ADR 0060); without it, asking for `adk` throws (ADR 0068).
  */
 export function adapterResolver(adkGemini) {
     const geminiFor = (r, choice) => {
@@ -99,7 +100,7 @@ export function adapterResolver(adkGemini) {
         if (route.transport === 'gateway')
             return new GatewayAdapter({ model: modelId });
         if (route.provider === 'gemini') {
-            return geminiFor(route, options.gemini ?? geminiAdapterSetting() ?? (adkGemini ? 'adk' : 'engine'));
+            return geminiFor(route, options.gemini ?? geminiAdapterSetting() ?? 'engine');
         }
         return CONTRACT_ADAPTER[route.provider](route);
     }

package/dist/lib/models/adkGeminiAdapter.js

@@ -71,6 +71,7 @@ import { errorText } from './errorResponse.js';
 import { GEMINI_PROVIDER } from './geminiState.js';
 import { llmResponseToModelResponse, modelRequestToLlmRequest, nativeToolsWithoutGeminiTool } from './genaiMapping.js';
 import { TracedGemini } from './tracedGemini.js';
+import { requireAdk } from '../adkPeer.js';
 import { classifyError, errorStatus } from './retry.js';
 import { setLlmSpanAttribute } from '../observability/tracer.js';
 /** The prefix of a call id ADK (or the engine after it) made: such an id never goes on the wire. */
@@ -85,6 +86,7 @@ export class AdkGeminiAdapter {
     #connection;
     #warned = new Set();
     constructor(options) {
+        requireAdk('GEMINI_ADAPTER=adk (AdkGeminiAdapter, which runs ADK\'s Gemini)');
         this.model = options.model;
         this.#apiKey = nonEmpty(options.apiKey);
         this.#endpoint = options.endpoint;

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

@@ -51,7 +51,7 @@
  * is charged and traced on its own, as today. A FallbackAdapter behind one
  * shim would make a redirected call one span and one charge.
  */
-import { BaseLlm } from '@google/adk';
+import { BaseLlm } from '../adkPeer.ts';
 import type { BaseLlmConnection, BaseLlmType, LlmRequest, LlmResponse } from '@google/adk';
 import type { ModelAdapter, ModelRequest, ModelResponse } from './contract.ts';
 import type { ModelRequestOptions } from './genaiMapping.ts';

package/dist/lib/models/adkShim.js

@@ -51,7 +51,7 @@
  * is charged and traced on its own, as today. A FallbackAdapter behind one
  * shim would make a redirected call one span and one charge.
  */
-import { BaseLlm } from '@google/adk';
+import { BaseLlm } from '../adkPeer.js';
 import { llmRequestToModelRequest, modelResponseToLlmResponse } from './genaiMapping.js';
 import { traceLlmGeneration } from '../observability/tracer.js';
 import { currentTurnSignal } from '../runtime/turnControl.js';

package/dist/lib/models/capabilities.js

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

package/dist/lib/models/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/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/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

@@ -49,7 +49,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 +64,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 +84,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

@@ -48,7 +48,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 +67,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 +80,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);
@@ -330,6 +332,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 +395,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 +479,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