melchizedek-agents 0.19.0 → 1.0.0

package/README.md

@@ -1,8 +1,8 @@
 # melchizedek-agents
 
-A multi-model, multi-agent orchestration framework built on the Google Agent Development Kit (ADK). Agent hierarchies, prompts, models, tools, and delegation rules are declared in YAML files called **Syndicates**; the engine in `lib/` runs whatever you put in `config/agents/`.
+A multi-model, multi-agent orchestration framework with its own agent loop, model contract, tools, sessions and workflow engine. Agent hierarchies, prompts, models, tools, and delegation rules are declared in YAML files called **Syndicates**; the engine in `lib/` runs whatever you put in `config/agents/`.
 
-Gemini runs natively, Claude runs via a bundled adapter, GPT, Grok, and Kimi route to their providers, and open-weight models run locally through Ollama with no API key. A subagent can also pick up tools at runtime from a Model Context Protocol (MCP) server.
+Gemini, Claude, GPT, Grok, and Kimi each run on the engine's own adapter for their provider's API, and open-weight models run locally through Ollama with no API key. A subagent can also pick up tools at runtime from a Model Context Protocol (MCP) server.
 
 > Companion repository for the curriculum at [lyceumagents.com/curriculum](https://lyceumagents.com/curriculum/). The framework works standalone or alongside the course.
 
@@ -60,7 +60,7 @@ Test the providers you have keys for:
 
 ```bash
 npm run demo:models     # one prompt to every available provider, with token/latency traces
-npm run demo:direct     # a single ADK call without syndicate orchestration
+npm run demo:direct     # a single model call without syndicate orchestration
 ```
 
 ---
@@ -73,14 +73,15 @@ Install into your existing project:
 npm install melchizedek-agents
 ```
 
+The package has no Google ADK dependency: 1.0.0 removed ADK, and every turn runs on the engine's own agent loop. Upgrading from 0.x: read the 1.0.0 "Breaking — read before upgrading" section of [`CHANGELOG.md`](./CHANGELOG.md).
+
 Define your agents in `./config/agents/mine.yaml`, then run turns programmatically:
 
 ```typescript
-import { InMemorySessionService } from '@google/adk';
-import { loadSyndicate, registerAvailableProviders, runSyndicateTurn } from 'melchizedek-agents';
+import { InProcessSessionService, loadSyndicate, logProviderStatuses, runSyndicateTurn } from 'melchizedek-agents';
 
-// 1. Register a provider for every key that is set
-registerAvailableProviders();
+// 1. Report which providers have a key set
+logProviderStatuses(console.log);
 
 // 2. Load and validate syndicate YAML from ./config/agents/
 const config = loadSyndicate('mine.yaml');
@@ -92,7 +93,7 @@ const result = await runSyndicateTurn({
   appName: 'my-app',
   userId: 'user-42',
   sessionId: 'conversation-7', // same id, same conversation
-  sessionService: new InMemorySessionService(),
+  sessionService: new InProcessSessionService(),
   events: {
     onProgress: (line) => console.log('…', line)
   },
@@ -101,7 +102,7 @@ const result = await runSyndicateTurn({
 console.log(result.status, result.text);
 ```
 
-`runSyndicateTurn` is the same runtime the server, CLI, and eval harness use. It runs on Google ADK by default; `runtime: 'native'` (or `MELCHIZEDEK_RUNTIME=native`) runs a single-agent, delegating, plan-dispatch or workflow syndicate on the engine's own loop and scheduler instead. To read syndicates from somewhere else, pass `loadSyndicate(file, { agentsDir })` or set `MELCHIZEDEK_AGENTS_DIR`. To serve inside your own Express app, mount `(await createA2AApp({ defaultSyndicate: 'mine.yaml', serverSecret })).app`.
+`runSyndicateTurn` is the same runtime the server, CLI, and eval harness use. It runs every syndicate on the engine's own agent loop and, for a workflow, its own scheduler (the `native` runtime, the only one). `MELCHIZEDEK_RUNTIME=adk` is an error that names 1.0.0; `npx melchizedek-doctor` prints the runtime in use (ADR 0107). To read syndicates from somewhere else, pass `loadSyndicate(file, { agentsDir })` or set `MELCHIZEDEK_AGENTS_DIR`. To serve inside your own Express app, mount `(await createA2AApp({ defaultSyndicate: 'mine.yaml', serverSecret })).app`.
 
 The example syndicates ship inside the package at `node_modules/melchizedek-agents/config/agents/examples/`; copy one out as a starting point.
 
@@ -118,11 +119,7 @@ registerGuard(myGuardInstance);
 
 ### The Model Adapters Alone
 
-`melchizedek-agents/model` is the engine's model layer on its own: one message format for every provider, an adapter per provider, `resolveAdapter` over the same model-id prefixes the YAML uses, and `FallbackAdapter`. It loads no `@google/adk`, so a project that only calls models can leave ADK out. npm 7 and later install peer dependencies by default; skip them with:
-
-```bash
-npm install melchizedek-agents --legacy-peer-deps
-```
+`melchizedek-agents/model` is the engine's model layer on its own: one message format for every provider, an adapter per provider, `resolveAdapter` over the same model-id prefixes the YAML uses, and `FallbackAdapter`. The peers (redis, the cloud SDKs) are optional.
 
 ```typescript
 import { ClaudeAdapter, OllamaAdapter, resolveAdapter } from 'melchizedek-agents/model';
@@ -152,7 +149,7 @@ console.log(await ask(new OllamaAdapter({ model: 'ollama/qwen3:8b' }), 'What is
 const adapter = resolveAdapter('ollama/qwen3:8b');
 ```
 
-A Gemini id resolves to the engine's `GeminiAdapter` here. The ADK-backed Gemini adapter, the ADK shims and `resolveModel` stay under `melchizedek-agents/models/*`, which need ADK.
+A Gemini id resolves to the engine's `GeminiAdapter` here, on `@google/genai`.
 
 ### CLI & Server Utilities
 

package/config/agents/examples/image_production.yaml

@@ -2,8 +2,8 @@
 syndicate_name: "Multi-Modal Image Production Workflow"
 memory_system: "session-only"
 
-# WHY generate_image and inspect_image are FunctionTools, not subagents:
-#   AgentTool converts all subagent traffic to plain text, so binary inlineData
+# WHY generate_image and inspect_image are tools, not subagents:
+#   A subagent call carries only text, so binary inlineData
 #   (image bytes) is silently dropped in either direction. generateImageTool
 #   calls @google/genai directly, captures inlineData, writes the file to disk,
 #   and returns the saved path; inspectImageTool reads that file back and runs

package/config/agents/syndicateSchema.yaml

@@ -4,8 +4,14 @@
 # ============================================================
 #
 # This file documents ALL available properties for a syndicate
-# YAML definition. Every property name maps 1:1 to its ADK
-# counterpart so there is zero translation confusion.
+# YAML definition. The agent fields keep the spelling of their
+# Google ADK counterparts (LlmAgent, GenerateContentConfig), so a file
+# written for ADK reads unchanged.
+#
+# Runtime (ADR 0107): the engine's own agent loop (the NATIVE runtime)
+# runs every key below; 1.0.0 removed Google ADK, and nothing here
+# needs it. A "Maps to:" line names the ADK field a key is spelled
+# after: a spelling, not something ADK builds.
 #
 # It is an annotated EXAMPLE. The enforced contract is
 # lib/syndicateSchema.ts: every load validates against it and a
@@ -14,15 +20,16 @@
 # syndicate.schema.json (npm run schema:gen), is what the modeline
 # above points an editor at — add the same line to your own file.
 #
-# ADK source references:
-#   LlmAgentConfig      → @google/adk :: agents/llm_agent.d.ts
-#   BaseAgentConfig     → @google/adk :: agents/base_agent.d.ts
+# Where the spellings come from (a reference, not a dependency):
+#   LlmAgentConfig      → Google ADK 2.2 :: agents/llm_agent.d.ts
+#   BaseAgentConfig     → Google ADK 2.2 :: agents/base_agent.d.ts
 #   GenerateContentConfig → @google/genai :: GenerateContentConfig
 #
 # Legend:
 #   [required]  Must be provided
 #   [optional]  Can be omitted
-#   ⚠           Note or constraint from ADK internals
+#   ⚠           Note or constraint the engine enforces (most were
+#               ADK's first)
 # ============================================================
 
 # ── Syndicate metadata ──────────────────────────────────────
@@ -46,9 +53,9 @@ syndicate_name: "My Syndicate"
 variables:
   my_variable: "default_value"
 
-# [optional] Self-correction, ON by default (ADK's reflect-and-retry
-# plugins, ADR 0034). model_errors: retries of a model reply ADK marks
-# malformed (default 2). tool_errors: retries of a tool that threw, with
+# [optional] Self-correction, ON by default: ADK's reflect-and-retry
+# behaviour, which the native loop ports (ADR 0034, ADR 0075). model_errors: retries of a model
+# reply the runtime marks malformed (default 2). tool_errors: retries of a tool that threw, with
 # reflection guidance to the model (default 3). 0 turns either off. Every
 # retry is a model call under max_steps.
 # retries:
@@ -93,12 +100,13 @@ memory_extraction_model: "gemini-3.8-flash"
 #   so it can be logged, traced, and streamed to a waiting user as
 #   "[STATUS] Routed to <Name> — <reason>".
 #
-# ⚠ The orchestrator MUST be a leaf when using this: ADK refuses to combine
-#   outputSchema with AgentTool delegation on one agent (see critic.yaml).
+# ⚠ The orchestrator is a leaf in this mode: it gets no subagent tools on
+#   any provider, because outputSchema and subagent delegation do not
+#   combine on one agent (ADK refused it too; see examples/critic.yaml).
 #   Pair the schema with generateContentConfig.responseMimeType:
 #   "application/json".
-# ⚠ A2A-only — scripts/syndicate_chat.ts compiles every syndicate in
-#   DELEGATE mode (same limitation as yaml_reference).
+# Every surface runs it the same way: the A2A server and
+# scripts/syndicate_chat.ts both run turns through runSyndicateTurn.
 #
 # Contract and fail-static rules: lib/dispatch.ts. Worked examples:
 # examples/research.yaml, templates/support_triage.yaml.
@@ -129,8 +137,10 @@ dispatch:
 # [optional] Switches this syndicate to a WORKFLOW: the agents below are
 # the nodes of a graph, and `edges` says what runs after what. Nothing
 # delegates, nothing classifies; the orchestrator is a node like any
-# other. Cannot be combined with `dispatch`. Contract: lib/workflow.ts;
-# worked example: examples/pipeline.yaml (ADR 0030).
+# other. Cannot be combined with `dispatch`. Contract: lib/workflow.ts
+# (the block's types and checks) and lib/workflow/ (the engine's own
+# scheduler, which walks the graph); worked example:
+# examples/pipeline.yaml (ADR 0030).
 #
 #   - A chain is a list. `START` opens at least one chain. A name is an
 #     agent or a declared node; a list of names fans out (after one
@@ -142,8 +152,17 @@ dispatch:
 #     unless its YAML sets includeContents, sees nothing else.
 #   - `ask_user` pauses the turn (input-required); the next message is
 #     the answer, and the node outputs { reply, input }.
-#   - require_approval, skills.scripts: local and a2a_agent_url are not
-#     supported inside a workflow yet.
+#   - require_approval, and skills.scripts: local (each script run), on a
+#     node's agent pause that node, and the walk, until a person decides
+#     (ADR 0098, ADR 0106); neither is allowed on an agent a map runs. a2a_agent_url is
+#     not supported inside a workflow yet.
+#   - A yaml_reference to a workflow syndicate runs its whole graph as the
+#     node, on its own session (ADR 0106).
+#   - A route may lead back to an earlier node (a loop). max_steps bounds
+#     the model calls in it; a turn also starts at
+#     most 20 × max_steps node runs (at least 100), so a loop of tool nodes
+#     that never stops routing back fails the turn NODE_RUN_LIMIT
+#     (ADR 0105). Raise max_steps to raise it.
 # workflow:
 #   edges:
 #     - [START, OrchestratorName, { article: [MySubagent, Other], default: Other }]
@@ -154,11 +173,15 @@ dispatch:
 #     Each:    { map: "MySubagent", max_parallel: 4 }   # one run per list item
 #     Lookup:  { tool: "web_extract" }             # a registry tool as a node
 #     Review:  { retry: { max_attempts: 2, initial_delay: 1 }, timeout: 120 }
+#     # retry also takes max_delay, backoff_factor, jitter (0 = none) and
+#     # exceptions: [NodeTimeoutError] (retry only on these error names).
+#     # A map node takes neither retry nor timeout: set them on its agent.
 #     Confirm: { ask_user: "Publish? Reply yes, or say what to change." }
 #   max_concurrency: 4
 
 # ── Orchestrator ────────────────────────────────────────────
-# Maps to: new LlmAgent({ ... }) — the root agent passed to InMemoryRunner.
+# The turn's root agent: the native loop runs it. Maps to: new
+# LlmAgent({ ... }), the root agent of ADK's Runner.
 
 orchestrator:
 
@@ -176,7 +199,7 @@ orchestrator:
 
   # [required] The model to use. The id's prefix names the provider and the
   # framework routes accordingly (lib/models/registry.ts):
-  #   gemini-*  → Google Gemini (ADK-native)
+  #   gemini-*  → Google Gemini (GEMINI_API_KEY; the engine's adapter)
   #   claude-*  → Anthropic     (ANTHROPIC_API_KEY)
   #   gpt-* /o* → OpenAI        (OPENAI_API_KEY)
   #   grok-*    → xAI           (XAI_API_KEY)
@@ -240,8 +263,9 @@ orchestrator:
   # stderr are each cut at 20,000 characters, with a line saying so.
   # Maps to: tools[] (a toolset) and instruction (the appended index)
 
-  # [optional] Few-shot exchanges added to every request's instruction
-  # (ADK's ExampleTool; the model never calls it). Up to 20.
+  # [optional] Few-shot exchanges added to every request's instruction,
+  # as ADK's ExampleTool added them (the model never calls it).
+  # Up to 20.
   # examples:
   #   - input: "Is it going to rain in Lyon tomorrow?"
   #     output: "Yes: 4 mm expected between 14:00 and 18:00."
@@ -330,9 +354,12 @@ orchestrator:
   reasoning: medium
 
   # ── generateContentConfig ─────────────────────────────────
-  # Maps to: generateContentConfig on LlmAgent (→ GenerateContentConfig)
+  # The model request's settings, in @google/genai's GenerateContentConfig
+  # spelling; every provider adapter reads the fields it supports.
+  # Maps to: generateContentConfig on LlmAgent
   # ⚠ Do NOT set tools here — use the top-level `tools:` field. Set
-  #   reasoning with the `reasoning:` key above, not thinkingConfig.
+  #   reasoning with the `reasoning:` key above (the preferred spelling,
+  #   read the same way by every provider), not thinkingConfig.
 
   generateContentConfig:
 
@@ -384,7 +411,7 @@ orchestrator:
         threshold: "BLOCK_MEDIUM_AND_ABOVE"
 
     # ── Thinking config: the older spelling of `reasoning:` ─
-    # Provider-specific: Gemini and Claude read thinkingConfig, the
+    # Prefer `reasoning:` in a new file. Provider-specific: Gemini and Claude read thinkingConfig, the
     # chat-completions and Responses providers read reasoningEffort, and
     # later Claude models read reasoningEffort first (ADR 0049).
     # Still accepted, but not together with `reasoning:` (a load error).
@@ -396,8 +423,10 @@ orchestrator:
     # reasoningEffort: "medium"
 
 # ── Subagents ───────────────────────────────────────────────
-# Each entry maps to: new LlmAgent({ ... }) wrapped in AgentTool
-# and passed to the orchestrator's tools[].
+# Each entry is an agent the orchestrator calls as a tool (DELEGATE),
+# a route (dispatch) or a node (workflow); the native loop runs it.
+# Maps to: new LlmAgent({ ... }) wrapped in AgentTool and passed to the
+# orchestrator's tools[].
 
 subagents:
 

package/dist/lib/a2a/app.d.ts

@@ -27,18 +27,23 @@
  * durable when Supabase is configured. Run one replica, or put sticky
  * routing in front, until the task store is durable.
  *
- * Stores (ADR 0080): `storage` takes a session store and a memory service
- * with either face, the engine's or ADK's. In-process sessions are the
- * engine's InProcessSessionService. A `resolveModel` may still return an ADK
- * model instance: its type is CompileOptions'.
+ * Stores (ADR 0080, ADR 0107): `storage` takes the engine's SessionService
+ * and MemoryService. In-process sessions are the engine's
+ * InProcessSessionService. A `resolveModel` returns a model id or a
+ * ModelAdapter: its type is CompileOptions'.
+ *
+ * MELCHIZEDEK_RUNTIME and GEMINI_ADAPTER are read before anything else:
+ * `adk`, the runtime 1.0.0 removed, stops the server at startup
+ * (RuntimeRemovedError), and so does GEMINI_ADAPTER=adk, the removed ADK
+ * Gemini adapter (geminiAdapterSetting, lib/models/adapterResolver.ts).
  */
 import type { Express, Request, RequestHandler } from 'express';
 import type { Store } from 'express-rate-limit';
 import type { AgentCard } from '@a2a-js/sdk';
 import type { TaskStore } from '@a2a-js/sdk/server';
 import type { CompileOptions } from '../compile.ts';
-import type { EitherSessionService } from '../runtime/adkSessionBridge.ts';
-import type { EitherMemoryService } from '../runtime/adkMemoryBridge.ts';
+import type { SessionService } from '../runtime/sessions.ts';
+import type { MemoryService } from '../runtime/memoryService.ts';
 import type { SyndicateYamlConfig } from '../loadSyndicate.ts';
 import type { ProviderEndpoint, ProviderId } from '../models/registry.ts';
 import type { TurnLock } from './turnLock.ts';
@@ -88,10 +93,10 @@ export interface A2AAppOptions {
      * agent id (default: in-process).
      */
     storage?: {
-        /** The engine's SessionService or ADK's BaseSessionService (ADR 0080). */
-        sessionService: EitherSessionService;
-        /** The engine's MemoryService or ADK's BaseMemoryService. */
-        memoryService?: EitherMemoryService;
+        /** The engine's SessionService (ADR 0080, ADR 0107). */
+        sessionService: SessionService;
+        /** The engine's MemoryService. */
+        memoryService?: MemoryService;
         taskStore?: (agentId: string) => TaskStore;
         /** Erase everything stored for a scope (DELETE /memory). Without it the route answers 501. */
         erase?: (scopeKey: string, options: {
@@ -268,8 +273,8 @@ export interface A2AAppOptions {
      * Model resolution per request. Default: lib/models/registry.ts with the
      * caller's X-API-Key scoped to its X-Provider. Override to route through
      * your own gateway or credential store. Returns what
-     * CompileOptions.resolveModel returns: a model id, or a model instance
-     * (an ADK BaseLlm while the ADK runtime ships).
+     * CompileOptions.resolveModel returns: a model id, or a ModelAdapter
+     * (lib/models/contract.ts).
      */
     resolveModel?: (modelName: string | undefined, ctx: A2AContext) => ResolvedModel;
     /** Bindings applied at every config load (e.g. current_date). */

package/dist/lib/a2a/app.js

@@ -27,10 +27,15 @@
  * durable when Supabase is configured. Run one replica, or put sticky
  * routing in front, until the task store is durable.
  *
- * Stores (ADR 0080): `storage` takes a session store and a memory service
- * with either face, the engine's or ADK's. In-process sessions are the
- * engine's InProcessSessionService. A `resolveModel` may still return an ADK
- * model instance: its type is CompileOptions'.
+ * Stores (ADR 0080, ADR 0107): `storage` takes the engine's SessionService
+ * and MemoryService. In-process sessions are the engine's
+ * InProcessSessionService. A `resolveModel` returns a model id or a
+ * ModelAdapter: its type is CompileOptions'.
+ *
+ * MELCHIZEDEK_RUNTIME and GEMINI_ADAPTER are read before anything else:
+ * `adk`, the runtime 1.0.0 removed, stops the server at startup
+ * (RuntimeRemovedError), and so does GEMINI_ADAPTER=adk, the removed ADK
+ * Gemini adapter (geminiAdapterSetting, lib/models/adapterResolver.ts).
  */
 import express from 'express';
 import rateLimit, { ipKeyGenerator } from 'express-rate-limit';
@@ -40,6 +45,8 @@ import { DefaultRequestHandler, InMemoryTaskStore } from '@a2a-js/sdk/server';
 import { duplicateInterfacesForLegacy } from '@a2a-js/sdk/compat/v0_3';
 import { agentCardHandler, jsonRpcHandler, restHandler } from '@a2a-js/sdk/server/express';
 import { InProcessSessionService } from '../runtime/sessions.js';
+import { runtimeSetting } from '../runtime/runtimeFlag.js';
+import { geminiAdapterSetting } from '../models/adapterResolver.js';
 import { loadSyndicate, loadSyndicateFromRegistry } from '../loadSyndicate.js';
 import { providerForModel, resolveModel } from '../models/registry.js';
 import { createSupabaseServices, hasSupabaseCredentials } from '../persistence/supabaseProvider.js';
@@ -250,6 +257,9 @@ export function memoryAppName(cfg) {
     return cfg.memory_namespace || A2A_APP_NAME;
 }
 export async function createA2AApp(options) {
+    // A deployment still configured for the removed adk runtime fails here, naming 1.0.0 (ADR 0107).
+    runtimeSetting();
+    geminiAdapterSetting();
     const log = options.log ?? ((m) => console.log(`[A2A] ${m}`));
     const warn = options.warn ?? ((m) => console.warn(`[A2A] ⚠ ${m}`));
     const bindings = options.bindings ?? (() => ({
@@ -393,8 +403,8 @@ export async function createA2AApp(options) {
         const mode = cfg.memory_system;
         const sessionService = mode === 'internal-only' || !durableSessions ? internalSessions : durableSessions;
         // Pinned to the syndicate's namespace (ADR 0020), so every agent the
-        // turn reaches — including AgentTool children, which run under their own
-        // ADK app name — recalls and stores in the root syndicate's memory.
+        // turn reaches — including subagents, which run under their own app
+        // name — recalls and stores in the root syndicate's memory.
         const memory = mode === 'long-term' && memoryService ? namespacedMemoryService(memoryService, memoryAppName(cfg)) : undefined;
         if (memory)
             warnMemoryFlow(cfg);

package/dist/lib/a2a/executor.d.ts

@@ -9,19 +9,16 @@
  * the reply. Every turn semantic — dispatch, delegation, relay fallback,
  * guards, the step cap — is the runtime's.
  *
- * Its stores are the engine's (ADR 0080): it takes a session store and a
- * memory service with either face, the engine's or ADK's, reads a session
- * through the engine's SessionService, and hands the turn runner the faces
- * its fixed signature names through the bridges
- * (lib/runtime/adkSessionBridge.ts, lib/runtime/adkMemoryBridge.ts).
+ * Its stores are the engine's (ADR 0080, ADR 0107): a SessionService and a
+ * MemoryService, which it reads and hands the turn runner as they are.
  */
 import { AsyncLocalStorage } from 'node:async_hooks';
 import type { AgentExecutor, ExecutionEventBus, RequestContext } from '@a2a-js/sdk/server';
 import type { CompileOptions } from '../compile.ts';
 import type { SyndicateYamlConfig } from '../loadSyndicate.ts';
 import type { TurnLock } from './turnLock.ts';
-import type { EitherSessionService } from '../runtime/adkSessionBridge.ts';
-import type { EitherMemoryService } from '../runtime/adkMemoryBridge.ts';
+import type { MemoryService } from '../runtime/memoryService.ts';
+import type { SessionService } from '../runtime/sessions.ts';
 import type { PendingApproval } from '../runtime/approvals.ts';
 import type { MessagePart, SyndicateTurnResult } from '../runtime/syndicateTurn.ts';
 import type { ToolCredentials } from '../tools/oauthConsent.ts';
@@ -102,10 +99,10 @@ export declare function a2aPartsToMessage(rawParts: unknown[]): {
 };
 export interface ExecutorOptions {
     config: SyndicateYamlConfig;
-    /** The conversation store: the engine's SessionService or ADK's BaseSessionService. */
-    sessionService: EitherSessionService;
-    /** Long-term memory: the engine's MemoryService or ADK's BaseMemoryService. */
-    memoryService?: EitherMemoryService;
+    /** The conversation store: the engine's SessionService. */
+    sessionService: SessionService;
+    /** Long-term memory: the engine's MemoryService. */
+    memoryService?: MemoryService;
     /** Builds the per-request model resolver from the caller's context (BYOK). */
     compileFor: (ctx: A2AContext) => CompileOptions;
     /** Wall-clock budget per task in ms; 0 or undefined = none. */
@@ -200,10 +197,9 @@ export declare function answerStream(eventBus: ExecutionEventBus, taskId: string
 export declare class SyndicateExecutor implements AgentExecutor {
     private readonly opts;
     private configHash;
-    /** The store as the engine reads it. */
+    /** The conversation store. */
     private readonly sessions;
-    /** The faces the turn runner's fixed signature names (ADR 0045 item 4). */
-    private readonly turnSessions;
+    /** Long-term memory, when the syndicate has it. */
     private readonly turnMemory;
     constructor(opts: ExecutorOptions);
     /** Provenance stamp for every turn this executor serves (lineage.ts). */

package/dist/lib/a2a/executor.js

@@ -9,11 +9,8 @@
  * the reply. Every turn semantic — dispatch, delegation, relay fallback,
  * guards, the step cap — is the runtime's.
  *
- * Its stores are the engine's (ADR 0080): it takes a session store and a
- * memory service with either face, the engine's or ADK's, reads a session
- * through the engine's SessionService, and hands the turn runner the faces
- * its fixed signature names through the bridges
- * (lib/runtime/adkSessionBridge.ts, lib/runtime/adkMemoryBridge.ts).
+ * Its stores are the engine's (ADR 0080, ADR 0107): a SessionService and a
+ * MemoryService, which it reads and hands the turn runner as they are.
  */
 import { createHash, randomUUID } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -23,8 +20,6 @@ import { nestedLoader } from '../loadSyndicate.js';
 import { configDigest } from '../observability/lineage.js';
 import { turnLockKey } from './turnLock.js';
 import { ingestTurnMemory, runSyndicateTurn } from '../runtime/syndicateTurn.js';
-import { asAdkSessionService, asSessionService } from '../runtime/adkSessionBridge.js';
-import { asAdkMemoryService } from '../runtime/adkMemoryBridge.js';
 import { approvalResponsePart, describeApproval, pendingApproval } from '../runtime/approvals.js';
 import { declaresApprovals } from '../compile.js';
 import { describeInput } from '../runtime/syndicateTurn.js';
@@ -417,16 +412,14 @@ export function answerStream(eventBus, taskId, contextId) {
 export class SyndicateExecutor {
     opts;
     configHash;
-    /** The store as the engine reads it. */
+    /** The conversation store. */
     sessions;
-    /** The faces the turn runner's fixed signature names (ADR 0045 item 4). */
-    turnSessions;
+    /** Long-term memory, when the syndicate has it. */
     turnMemory;
     constructor(opts) {
         this.opts = opts;
-        this.sessions = asSessionService(opts.sessionService);
-        this.turnSessions = asAdkSessionService(opts.sessionService);
-        this.turnMemory = opts.memoryService ? asAdkMemoryService(opts.memoryService) : undefined;
+        this.sessions = opts.sessionService;
+        this.turnMemory = opts.memoryService;
     }
     /** Provenance stamp for every turn this executor serves (lineage.ts). */
     configHashFor() {
@@ -582,9 +575,8 @@ export class SyndicateExecutor {
             // answer, or the request is repeated without spending a model call.
             if (declaresApprovals(config)) {
                 const session = await this.sessions.get({ appName, userId, sessionId: contextId });
-                // The stored Event JSON either way (ADR 0052): pendingApproval still
-                // names ADK's Event, which a TurnEvent reaches only through a cast.
-                const pending = pendingApproval((session?.events ?? []));
+                // The stored Event JSON (ADR 0052), read as TurnEvents.
+                const pending = pendingApproval(session?.events ?? []);
                 if (pending) {
                     const answer = approvalAnswer(rawParts, pending);
                     if (!answer) {
@@ -603,7 +595,7 @@ export class SyndicateExecutor {
                 appName,
                 userId,
                 sessionId: contextId,
-                sessionService: this.turnSessions,
+                sessionService: this.sessions,
                 memoryService: this.turnMemory,
                 compile: this.opts.compileFor(ctx),
                 signal: slot.signal,
@@ -672,7 +664,7 @@ export class SyndicateExecutor {
                 try {
                     await ingestTurnMemory({
                         memoryService: this.turnMemory,
-                        sessionService: this.turnSessions,
+                        sessionService: this.sessions,
                         appName,
                         userId,
                         sessionId: contextId,

package/dist/lib/a2a/remoteAgent.d.ts

@@ -12,9 +12,8 @@
  *
  * Built on the official A2A SDK client with its v0.3 compatibility layer on,
  * so a remote agent may speak A2A 1.0 (e.g. Microsoft Foundry) or 0.3 (most
- * other platforms today); the card decides. The client does not depend on
- * ADK, and the tool is the engine's own (remoteAgentOwnTool); the ADK
- * runtime receives it through toFunctionTool (remoteAgentTool).
+ * other platforms today); the card decides. The tool is the engine's own
+ * (remoteAgentOwnTool, also exported as remoteAgentTool).
  *
  * Security:
  *   - Every URL — the card and the endpoint the card names — passes the
@@ -29,7 +28,6 @@
  */
 import type { AgentCard, Message, Task } from '@a2a-js/sdk';
 import type { Client } from '@a2a-js/sdk/client';
-import type { FunctionTool } from '@google/adk';
 import type { Tool } from '../tools/tool.ts';
 export interface RemoteAnswer {
     state: string;
@@ -91,16 +89,11 @@ export interface RemoteAgentToolParams {
 /**
  * The subagent as an own Tool (lib/tools/tool.ts, ADR 0062) with AgentTool's
  * contract (one `request` string), so an orchestrator delegates to it
- * exactly as to a local subagent, on either runtime. The remote
+ * exactly as to a local subagent. The remote
  * conversation is keyed by the local session (`ctx.sessionId`), and the call
  * aborts with the turn (`ctx.signal`). Failures come back as readable text,
  * never as a throw into the runner.
  */
 export declare function remoteAgentOwnTool(params: RemoteAgentToolParams): Tool;
-/**
- * The remote agent tool as the ADK runtime runs it: the FunctionTool
- * toFunctionTool (lib/tools/adkTool.ts) makes of remoteAgentOwnTool, which
- * declares the same parameters the hand-built FunctionTool declared and
- * carries the own Tool for toolOf().
- */
-export declare function remoteAgentTool(params: RemoteAgentToolParams): FunctionTool;
+/** The remote agent tool, as registerTool and an agent's tools take it: remoteAgentOwnTool's own Tool. */
+export declare function remoteAgentTool(params: RemoteAgentToolParams): Tool;

package/dist/lib/a2a/remoteAgent.js

@@ -12,9 +12,8 @@
  *
  * Built on the official A2A SDK client with its v0.3 compatibility layer on,
  * so a remote agent may speak A2A 1.0 (e.g. Microsoft Foundry) or 0.3 (most
- * other platforms today); the card decides. The client does not depend on
- * ADK, and the tool is the engine's own (remoteAgentOwnTool); the ADK
- * runtime receives it through toFunctionTool (remoteAgentTool).
+ * other platforms today); the card decides. The tool is the engine's own
+ * (remoteAgentOwnTool, also exported as remoteAgentTool).
  *
  * Security:
  *   - Every URL — the card and the endpoint the card names — passes the
@@ -32,7 +31,6 @@ import { Role, TaskState } from '@a2a-js/sdk';
 import { ClientFactory, DefaultAgentCardResolver, JsonRpcTransportFactory, RestTransportFactory } from '@a2a-js/sdk/client';
 import { checkHost } from '../net/addressGuard.js';
 import { currentTurnSignal } from '../runtime/turnControl.js';
-import { toFunctionTool } from '../tools/adkTool.js';
 const FETCH_TIMEOUT_MS = 30_000;
 const POLL_INTERVAL_MS = 1_500;
 const DEFAULT_TASK_TIMEOUT_MS = 10 * 60 * 1000;
@@ -238,7 +236,7 @@ export function remoteToolOutput(name, answer) {
 /**
  * The subagent as an own Tool (lib/tools/tool.ts, ADR 0062) with AgentTool's
  * contract (one `request` string), so an orchestrator delegates to it
- * exactly as to a local subagent, on either runtime. The remote
+ * exactly as to a local subagent. The remote
  * conversation is keyed by the local session (`ctx.sessionId`), and the call
  * aborts with the turn (`ctx.signal`). Failures come back as readable text,
  * never as a throw into the runner.
@@ -274,12 +272,7 @@ export function remoteAgentOwnTool(params) {
         },
     };
 }
-/**
- * The remote agent tool as the ADK runtime runs it: the FunctionTool
- * toFunctionTool (lib/tools/adkTool.ts) makes of remoteAgentOwnTool, which
- * declares the same parameters the hand-built FunctionTool declared and
- * carries the own Tool for toolOf().
- */
+/** The remote agent tool, as registerTool and an agent's tools take it: remoteAgentOwnTool's own Tool. */
 export function remoteAgentTool(params) {
-    return toFunctionTool(remoteAgentOwnTool(params));
+    return remoteAgentOwnTool(params);
 }