melchizedek-agents 0.20.0 → 1.0.0

package/dist/lib/doctor.js

@@ -19,9 +19,8 @@
  * 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. 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.
+ * lib/runtime/runtimeFlag.ts, which a turn reads (ADR 0107): a leftover
+ * MELCHIZEDEK_RUNTIME=adk is a problem.
  */
 import fs from 'node:fs';
 import path from 'node:path';
@@ -43,51 +42,19 @@ 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.
+ * runtimeFlag.ts), and where that came from. MELCHIZEDEK_RUNTIME=adk is a
+ * problem: every turn, and the server's startup, would fail
+ * (RuntimeRemovedError, ADR 0107).
  */
-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;
+export function runtimeReport(env = process.env) {
     try {
-        chosen = describeRuntime(undefined, env);
+        return describeRuntime(undefined, env);
     }
     catch (err) {
-        return { adk: { ...adk, needed: false }, problem: err instanceof Error ? err.message : String(err) };
+        return { 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() {
@@ -467,16 +434,13 @@ 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).
+    // The runtime a turn would run on, and where that came from (ADR 0107).
     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}`);
+            : `runtime     ${c.green}✓${c.reset} ${rt.runtime} ${c.dim}(${source})${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

package/dist/lib/index.d.ts

@@ -8,23 +8,26 @@
  * modules directly.
  *
  * The run API is plain data in, plain data out: a YAML config and text
- * parts go in, a SyndicateTurnResult comes out. Google ADK runs underneath
- * (a peer dependency) but its types are not part of what you write against.
+ * parts go in, a SyndicateTurnResult comes out. The engine runs every turn
+ * on its own agent loop; sessions and memory are its own interfaces
+ * (SessionService, MemoryService), and nothing here names Google ADK
+ * (ADR 0107).
  */
 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 { DEFAULT_RUNTIME, describeRuntime, RuntimeRemovedError, UnsupportedOnRuntimeError } 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 type { Session, SessionKey, SessionService } from './runtime/sessions.ts';
+export type { MemoryEntry, MemoryIngestOptions, MemorySearchRequest, MemorySearchResult, MemoryService } from './runtime/memoryService.ts';
+export type { TurnEvent } from './runtime/events.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';
-export { compileGraph, compileSubagent } from './compile.ts';
 export type { CompileOptions } from './compile.ts';
-export { compileWorkflow, isWorkflowSyndicate, describeInput } from './workflow.ts';
-export type { WorkflowConfig, WorkflowNodeYaml, EdgeElement, PendingInput, CompiledWorkflow } from './workflow.ts';
+export { isWorkflowSyndicate, describeInput } from './workflow.ts';
+export type { WorkflowConfig, WorkflowNodeYaml, EdgeElement, PendingInput } from './workflow.ts';
 export { createA2AApp, compileAgentCard, currentRequestContext } from './a2a/app.ts';
 export type { A2AApp, A2AAppOptions, RequestIdentity } from './a2a/app.ts';
 export type { A2AContext } from './a2a/executor.ts';
@@ -42,7 +45,7 @@ export { resolveTools, registerTool, registeredToolNames } from './toolRegistry.
 export { registerGuard, resolveGuards } from './guards/index.ts';
 export type { Guard, GuardResult } from './guards/index.ts';
 export { defineTool } from './tools/toolContract.ts';
-export { toFunctionTool } from './tools/adkTool.ts';
+export type { Tool, ToolContext } from './tools/tool.ts';
 export { modelExtractor, geminiEmbedder, openAiCompatibleEmbedder, memoryProvidersFromEnv, } from './memory/providers.ts';
 export type { Embedder, MemoryExtractor } from './memory/providers.ts';
 export { eraseScope } from './memory/erase.ts';
@@ -52,5 +55,5 @@ export { postgresStorage, PostgresSessionService, PostgresTaskStore } from './st
 export type { PostgresStorage, PostgresStorageOptions } from './storage/postgres/index.ts';
 export type { MemoryStore } from './memory/store.ts';
 export { validateSyndicateConfig, syndicateJsonSchema, SyndicateValidationError } from './syndicateSchema.ts';
-export { PROVIDERS, providerForModel, providerKeyPresent, providerStatuses, registerAvailableProviders, resolveModel, describeCapabilities, capabilitySummary, planTransport, gatewayConfig, gatewayProblem, gatewayUsable, GATEWAYS, GatewayLlm, } from './models/registry.ts';
+export { PROVIDERS, providerForModel, providerKeyPresent, providerStatuses, logProviderStatuses, resolveModel, describeCapabilities, capabilitySummary, planTransport, gatewayConfig, gatewayProblem, gatewayUsable, GATEWAYS, } from './models/registry.ts';
 export { loadEnv } from './loadEnv.ts';

package/dist/lib/index.js

@@ -8,21 +8,21 @@
  * modules directly.
  *
  * The run API is plain data in, plain data out: a YAML config and text
- * parts go in, a SyndicateTurnResult comes out. Google ADK runs underneath
- * (a peer dependency) but its types are not part of what you write against.
+ * parts go in, a SyndicateTurnResult comes out. The engine runs every turn
+ * on its own agent loop; sessions and memory are its own interfaces
+ * (SessionService, MemoryService), and nothing here names Google ADK
+ * (ADR 0107).
  */
 // ── Load a syndicate ────────────────────────────────────────────────────────
 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.
+// The runtime in use: native, the only one since 1.0.0 (ADR 0107).
+export { DEFAULT_RUNTIME, describeRuntime, RuntimeRemovedError, UnsupportedOnRuntimeError } from './runtime/syndicateTurn.js';
+// The engine's session and memory interfaces, and the in-process store (ADR 0107).
 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';
+export { isWorkflowSyndicate, describeInput } from './workflow.js';
 // ── Serve it over A2A, or call a remote A2A agent ───────────────────────────
 export { createA2AApp, compileAgentCard, currentRequestContext } from './a2a/app.js';
 export { callerTokens, firstOf, hashCallerToken, jwtIdentity, parseCallers, scopeSegment, sharedSecret, trustedHeader, } from './a2a/identity.js';
@@ -34,7 +34,6 @@ export { RemoteA2AAgent, remoteAgentTool } from './a2a/remoteAgent.js';
 export { resolveTools, registerTool, registeredToolNames } from './toolRegistry.js';
 export { registerGuard, resolveGuards } from './guards/index.js';
 export { defineTool } from './tools/toolContract.js';
-export { toFunctionTool } from './tools/adkTool.js';
 // ── Memory ──────────────────────────────────────────────────────────────────
 export { modelExtractor, geminiEmbedder, openAiCompatibleEmbedder, memoryProvidersFromEnv, } from './memory/providers.js';
 export { eraseScope } from './memory/erase.js';
@@ -44,8 +43,8 @@ export { postgresStorage, PostgresSessionService, PostgresTaskStore } from './st
 // ── Validation ──────────────────────────────────────────────────────────────
 export { validateSyndicateConfig, syndicateJsonSchema, SyndicateValidationError } from './syndicateSchema.js';
 // ── Models ──────────────────────────────────────────────────────────────────
-export { PROVIDERS, providerForModel, providerKeyPresent, providerStatuses, registerAvailableProviders, resolveModel, 
+export { PROVIDERS, providerForModel, providerKeyPresent, providerStatuses, logProviderStatuses, resolveModel, 
 // Listed as root exports in the 0.12.0 changelog but shipped only as a
 // subpath until 0.16.0.
-describeCapabilities, capabilitySummary, planTransport, gatewayConfig, gatewayProblem, gatewayUsable, GATEWAYS, GatewayLlm, } from './models/registry.js';
+describeCapabilities, capabilitySummary, planTransport, gatewayConfig, gatewayProblem, gatewayUsable, GATEWAYS, } from './models/registry.js';
 export { loadEnv } from './loadEnv.js';

package/dist/lib/loadSyndicate.d.ts

@@ -50,7 +50,7 @@ export interface GenerateContentConfig {
     reasoningEffort?: string;
 }
 /**
- * Maps to LlmAgentConfig (+ BaseAgentConfig) from @google/adk.
+ * Mirrors LlmAgentConfig (+ BaseAgentConfig) from Google ADK 2.2, whose names the YAML keeps.
  */
 export interface AgentYamlConfig {
     /** Unique agent name. Must be a valid JS identifier. Cannot be "user". */
@@ -214,7 +214,7 @@ export interface SyndicateYamlConfig {
     memory_extraction_model?: string;
     /** Days facts in this syndicate's namespace are kept (needs memory_namespace). */
     memory_retention_days?: number;
-    /** Optional hard technical limit for maximum ADK runner loops (LLM -> Tool cycles). */
+    /** Optional hard limit on the turn's model calls, subagents included (LLM -> Tool cycles). */
     max_steps?: number;
     /**
      * The nested `yaml_reference:` syndicates this one reaches, raw, keyed by
@@ -286,7 +286,7 @@ export declare function parseCliBindings(argv: string[]): VariableMap;
  * The A2A server used to read `config.guards` directly, which meant guards were
  * honoured on exactly ONE composition: a top-level syndicate. Compose the same
  * syndicate as a sub-agent — `yaml_reference:`, the repo's own idiom, already
- * used across the shipped templates — and `compileSubagent` loads the nested config, `compileGraph` never
+ * used across the shipped templates — and the compiler loads the nested config but never
  * looks at `guards`, and the server only ever consults the PARENT's list. The
  * nested syndicate's `guards: [science]` was dropped with no warning, because
  * `resolveGuards`' unknown-name path cannot fire on a list nobody read.

package/dist/lib/loadSyndicate.js

@@ -197,7 +197,7 @@ const SHIPPED_DIRS = ['examples', 'templates'];
  * The A2A server used to read `config.guards` directly, which meant guards were
  * honoured on exactly ONE composition: a top-level syndicate. Compose the same
  * syndicate as a sub-agent — `yaml_reference:`, the repo's own idiom, already
- * used across the shipped templates — and `compileSubagent` loads the nested config, `compileGraph` never
+ * used across the shipped templates — and the compiler loads the nested config but never
  * looks at `guards`, and the server only ever consults the PARENT's list. The
  * nested syndicate's `guards: [science]` was dropped with no warning, because
  * `resolveGuards`' unknown-name path cannot fire on a list nobody read.
@@ -345,7 +345,7 @@ export function validateRegistryConfig(config) {
     // A nested (yaml_reference) or remote (a2a_agent_url) agent brings its own
     // model and instruction.
     if (!config.name || (!config.yaml_reference && !config.a2a_agent_url && (!config.model || !config.instruction))) {
-        throw new Error(`[Validation Error] Configuration fails validation against ADK LlmAgentConfig specifications.`);
+        throw new Error(`[Validation Error] Configuration fails validation against the syndicate schema: an agent needs a name, and a model and an instruction unless it is a yaml_reference or an a2a_agent_url.`);
     }
 }
 /**

package/dist/lib/memory/erase.d.ts

@@ -2,7 +2,7 @@
  * lib/memory/erase.ts — erase a scope from every store (ADR 0020 item 7).
  *
  * One call to `melchizedek_erase_scope` (db/migrations/0002_erase_scope.sql),
- * which deletes memory facts, sessions (with the per-subagent rows ADK writes
+ * which deletes memory facts, sessions (with the per-subagent rows kept
  * beside them), the ledger's turns, spans, payloads, verdicts and labels, the
  * scope's durable A2A tasks for those conversations, its memory ingestion
  * markers, (without a namespace) its task tools' list and jobs

package/dist/lib/memory/erase.js

@@ -2,7 +2,7 @@
  * lib/memory/erase.ts — erase a scope from every store (ADR 0020 item 7).
  *
  * One call to `melchizedek_erase_scope` (db/migrations/0002_erase_scope.sql),
- * which deletes memory facts, sessions (with the per-subagent rows ADK writes
+ * which deletes memory facts, sessions (with the per-subagent rows kept
  * beside them), the ledger's turns, spans, payloads, verdicts and labels, the
  * scope's durable A2A tasks for those conversations, its memory ingestion
  * markers, (without a namespace) its task tools' list and jobs

package/dist/lib/memory/namespace.d.ts

@@ -2,24 +2,22 @@
  * lib/memory/namespace.ts — memory always resolves to the ROOT syndicate's
  * namespace (ADR 0020 item 3).
  *
- * WHY: ADK runs each DELEGATE subagent (AgentTool) as its own Runner under
- * `appName = <the subagent's name>`, and its memory tools search with that
- * name. Facts are written under the root syndicate's namespace, so a
- * `load_memory` declared on a subagent searched `<SubAgent>/<user>`, found
- * nothing, and said so without error. Wrapping the service the runtime hands
- * to ADK pins every search and ingestion to one namespace, whatever app
- * name the caller carries.
+ * WHY: a DELEGATE subagent runs on its own session row under
+ * `appName = <the subagent's name>`, and its memory tools search with the
+ * session's app name. Facts are written under the root syndicate's
+ * namespace, so a `load_memory` declared on a subagent would search
+ * `<SubAgent>/<user>`, find nothing, and say so without error. Wrapping the
+ * service the runtime receives pins every search and ingestion to one
+ * namespace, whatever app name the caller carries.
  *
- * The pin covers both interfaces a service may implement: ADK's
- * (`searchMemory`, `addSessionToMemory`) and the engine's MemoryService
- * (`search`, `ingest`, lib/runtime/memoryService.ts, ADR 0059). Every other
- * member, erase and retention included, passes through unchanged: they name
- * their key or namespace themselves.
+ * The pin covers the engine's MemoryService (`search`, `ingest`,
+ * lib/runtime/memoryService.ts, ADR 0059). Every other member, erase and
+ * retention included, passes through unchanged: they name their key or
+ * namespace themselves.
  */
-import type { BaseMemoryService } from '@google/adk';
 import type { MemoryService } from '../runtime/memoryService.ts';
 /** A memory service whose every read and write uses `namespace` as the app name. */
-export declare function namespacedMemoryService<T extends BaseMemoryService | MemoryService>(base: T, namespace: string): T;
+export declare function namespacedMemoryService<T extends MemoryService>(base: T, namespace: string): T;
 /** The server-wide name memory falls back to when a syndicate declares none. */
 export declare const LEGACY_MEMORY_APP_NAME = "melchizedek-a2a";
 /**

package/dist/lib/memory/namespace.js

@@ -2,25 +2,24 @@
  * lib/memory/namespace.ts — memory always resolves to the ROOT syndicate's
  * namespace (ADR 0020 item 3).
  *
- * WHY: ADK runs each DELEGATE subagent (AgentTool) as its own Runner under
- * `appName = <the subagent's name>`, and its memory tools search with that
- * name. Facts are written under the root syndicate's namespace, so a
- * `load_memory` declared on a subagent searched `<SubAgent>/<user>`, found
- * nothing, and said so without error. Wrapping the service the runtime hands
- * to ADK pins every search and ingestion to one namespace, whatever app
- * name the caller carries.
+ * WHY: a DELEGATE subagent runs on its own session row under
+ * `appName = <the subagent's name>`, and its memory tools search with the
+ * session's app name. Facts are written under the root syndicate's
+ * namespace, so a `load_memory` declared on a subagent would search
+ * `<SubAgent>/<user>`, find nothing, and say so without error. Wrapping the
+ * service the runtime receives pins every search and ingestion to one
+ * namespace, whatever app name the caller carries.
  *
- * The pin covers both interfaces a service may implement: ADK's
- * (`searchMemory`, `addSessionToMemory`) and the engine's MemoryService
- * (`search`, `ingest`, lib/runtime/memoryService.ts, ADR 0059). Every other
- * member, erase and retention included, passes through unchanged: they name
- * their key or namespace themselves.
+ * The pin covers the engine's MemoryService (`search`, `ingest`,
+ * lib/runtime/memoryService.ts, ADR 0059). Every other member, erase and
+ * retention included, passes through unchanged: they name their key or
+ * namespace themselves.
  */
 import { randomBytes } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-/** The four methods whose first argument carries the app name the pin replaces. */
-const PINNED = new Set(['searchMemory', 'addSessionToMemory', 'search', 'ingest']);
+/** The methods whose first argument carries the app name the pin replaces. */
+const PINNED = new Set(['search', 'ingest']);
 /** A memory service whose every read and write uses `namespace` as the app name. */
 export function namespacedMemoryService(base, namespace) {
     if (!namespace)

package/dist/lib/memory/providers.d.ts

@@ -29,7 +29,7 @@
  * dimension needs a re-embed, not just a new variable.
  */
 import type { ProviderEndpoint } from '../models/endpoints.ts';
-import type { LlmRequest, LlmResponse } from '@google/adk';
+import type { ModelAdapter } from '../models/contract.ts';
 export interface MemoryExtractor {
     /** The model id, for logs and the ledger. */
     readonly model: string;
@@ -51,14 +51,13 @@ export interface ModelExtractorOptions {
     temperature?: number;
     maxOutputTokens?: number;
     /** Test seam: produce the adapter. Default lib/models/registry.ts resolveModel. */
-    resolve?: (model: string, apiKey?: string) => {
-        generateContentAsync(req: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void>;
-    };
+    resolve?: (model: string, apiKey?: string) => ModelAdapter;
 }
 /**
  * Extraction on any model id. The key passed here reaches only a model of
  * the matching provider (resolveModel's BYOK rule); other providers read
- * their own key from the environment, exactly like an agent would.
+ * their own key from the environment, exactly like an agent would. The call
+ * is traced as one `llm.request` (traceLlmGeneration), as every model call is.
  */
 export declare function modelExtractor(opts?: ModelExtractorOptions): MemoryExtractor;
 export declare function geminiEmbedder(opts: {

package/dist/lib/memory/providers.js

@@ -31,15 +31,17 @@
 import { endpointFromEnv } from '../models/endpoints.js';
 import { GoogleGenAI } from '@google/genai';
 import { trace, SpanStatusCode } from '@opentelemetry/api';
+import { llmRequestToModelRequest, modelResponseToLlmResponse } from '../models/genaiMapping.js';
 import { EMBEDDING_DIMENSIONS, EMBEDDING_MODEL, MEMORY_EXTRACTION_MODEL } from '../config.js';
 import { providerForModel } from '../models/providerMap.js';
 import { resolveModel } from '../models/registry.js';
-import { initializeTracing } from '../observability/tracer.js';
+import { initializeTracing, traceLlmGeneration } from '../observability/tracer.js';
 import { trimTrailingSlashes } from '../models/urls.js';
 /**
  * Extraction on any model id. The key passed here reaches only a model of
  * the matching provider (resolveModel's BYOK rule); other providers read
- * their own key from the environment, exactly like an agent would.
+ * their own key from the environment, exactly like an agent would. The call
+ * is traced as one `llm.request` (traceLlmGeneration), as every model call is.
  */
 export function modelExtractor(opts = {}) {
     const model = opts.model ?? MEMORY_EXTRACTION_MODEL;
@@ -48,16 +50,20 @@ export function modelExtractor(opts = {}) {
     return {
         model,
         async extract(prompt) {
-            const llm = resolve(model, opts.apiKey);
-            const request = {
+            const adapter = resolve(model, opts.apiKey);
+            const llmRequest = {
                 model,
                 contents: [{ role: 'user', parts: [{ text: prompt }] }],
                 config: { temperature: opts.temperature ?? 0.1, maxOutputTokens: opts.maxOutputTokens ?? 4096 },
-                liveConnectConfig: {},
                 toolsDict: {},
             };
+            const request = llmRequestToModelRequest(llmRequest, { model, stream: false });
+            async function* inner() {
+                for await (const response of adapter.generate(request))
+                    yield modelResponseToLlmResponse(response);
+            }
             let text = '';
-            for await (const response of llm.generateContentAsync(request, false)) {
+            for await (const response of traceLlmGeneration({ provider: adapter.provider, model, request }, inner())) {
                 if (response.errorCode) {
                     throw new Error(`${model}: ${response.errorCode}${response.errorMessage ? ` — ${response.errorMessage}` : ''}`);
                 }

package/dist/lib/memory/supabaseMemoryService.d.ts

@@ -1,18 +1,13 @@
 /**
  * lib/memory/supabaseMemoryService.ts — long-term memory over pgvector
- * (ADR 0020), on the engine's own interface and on ADK's.
+ * (ADR 0020), on the engine's own interface (ADR 0107).
  *
  * The class implements the engine's MemoryService (lib/runtime/memoryService.ts:
  * `ingest`, `search`, and the optional `deleteUserMemory`, `pruneExpired`
- * and `verifyEmbeddingDimensions`, ADR 0052), which the native runtime and
- * the engine's own memory tools (lib/tools/memoryTools.ts) call. It also
- * implements ADK's BaseMemoryService, whose `addSessionToMemory` and
- * `searchMemory` the ADK runtime's Runner, the turn runner's ingestion
- * (ingestTurnMemory) and the A2A server call: each is one line that hands
- * its arguments to `ingest` or `search`, so both runtimes reach the same
- * logic and the same silos (ADR 0059).
+ * and `verifyEmbeddingDimensions`, ADR 0052), which the runtime, the turn
+ * runner's ingestion (ingestTurnMemory), the A2A server and the engine's
+ * memory tools (lib/tools/memoryTools.ts) call (ADR 0059).
  */
-import type { BaseMemoryService, SearchMemoryRequest, SearchMemoryResponse, Session as AdkSession } from '@google/adk';
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { MemoryIngestOptions, MemorySearchRequest, MemorySearchResult, MemoryService } from '../runtime/memoryService.ts';
 import type { Session } from '../runtime/sessions.ts';
@@ -45,7 +40,7 @@ export declare const MEMORY_DEDUP_SIMILARITY = 0.93;
 /**
  * Which of a session's events still need ingesting.
  *
- * The A2A server is stateless, so `addSessionToMemory` runs after EVERY task
+ * The A2A server is stateless, so `ingest` runs after EVERY task
  * with the WHOLE session — an N-turn conversation was being extracted N times
  * over a growing transcript. That produced 13 EPISODE records narrating the
  * same session and one balance stored six ways. A high-water mark per session
@@ -67,7 +62,7 @@ export declare function isSemanticDuplicate(candidate: {
     status: string | null;
     similarity: number;
 }>, threshold?: number): boolean;
-export declare class SupabaseVectorMemoryService implements MemoryService, BaseMemoryService {
+export declare class SupabaseVectorMemoryService implements MemoryService {
     private extractor;
     private embedder;
     private store;
@@ -105,24 +100,14 @@ export declare class SupabaseVectorMemoryService implements MemoryService, BaseM
         /** Builds the extractor for a syndicate's memory_extraction_model. Default: modelExtractor. */
         extractorFor?: (model: string) => MemoryExtractor;
     }, backend: SupabaseClient | MemoryStore);
-    /**
-     * ADK's name for `ingest`, which the ADK runtime and the A2A server call.
-     *
-     * @param extractionRules Optional domain rules appended to the shared
-     *   extraction prompt for THIS consumer only. The prompt is global (the
-     *   patient advocate uses the same one), so anything domain-specific —
-     *   "never store a market quote" — arrives here rather than being edited
-     *   into it. Declared as `memory_extraction_rules` on the served syndicate.
-     */
-    addSessionToMemory(session: AdkSession, extractionRules?: string, options?: {
-        extractionModel?: string;
-    }): Promise<void>;
     /**
      * Distils the session's events not yet ingested into facts filed under
      * `<appName>/<userId>`. Throws when a step fails, leaving those events
      * pending for the next ingestion (ADR 0020 item 6).
      *
-     * @param options.extractionRules The syndicate's `memory_extraction_rules`.
+     * @param options.extractionRules The syndicate's `memory_extraction_rules`:
+     *   domain rules appended to the shared extraction prompt for this
+     *   syndicate only ("never store a market quote").
      * @param options.extractionModel The syndicate's `memory_extraction_model`.
      */
     ingest(session: Session, options?: MemoryIngestOptions): Promise<void>;
@@ -136,12 +121,6 @@ export declare class SupabaseVectorMemoryService implements MemoryService, BaseM
      * `adk_sessions` and must be cleared separately if full erasure is needed.
      */
     deleteUserMemory(userKey: string): Promise<number>;
-    /**
-     * ADK's name for `search`, which ADK's Context.searchMemory calls. The
-     * entries are the same JSON as ADK's MemoryEntry; only genai's types name
-     * a few part fields as enums, hence the cast.
-     */
-    searchMemory(request: SearchMemoryRequest): Promise<SearchMemoryResponse>;
     /** The facts most relevant to the query, from the `<appName>/<userId>` silo only. */
     search(request: MemorySearchRequest): Promise<MemorySearchResult>;
     /**

package/dist/lib/memory/supabaseMemoryService.js

@@ -1,16 +1,12 @@
 /**
  * lib/memory/supabaseMemoryService.ts — long-term memory over pgvector
- * (ADR 0020), on the engine's own interface and on ADK's.
+ * (ADR 0020), on the engine's own interface (ADR 0107).
  *
  * The class implements the engine's MemoryService (lib/runtime/memoryService.ts:
  * `ingest`, `search`, and the optional `deleteUserMemory`, `pruneExpired`
- * and `verifyEmbeddingDimensions`, ADR 0052), which the native runtime and
- * the engine's own memory tools (lib/tools/memoryTools.ts) call. It also
- * implements ADK's BaseMemoryService, whose `addSessionToMemory` and
- * `searchMemory` the ADK runtime's Runner, the turn runner's ingestion
- * (ingestTurnMemory) and the A2A server call: each is one line that hands
- * its arguments to `ingest` or `search`, so both runtimes reach the same
- * logic and the same silos (ADR 0059).
+ * and `verifyEmbeddingDimensions`, ADR 0052), which the runtime, the turn
+ * runner's ingestion (ingestTurnMemory), the A2A server and the engine's
+ * memory tools (lib/tools/memoryTools.ts) call (ADR 0059).
  */
 import { memoryProvidersFromEnv, modelExtractor } from './providers.js';
 import { providerForModel } from '../models/providerMap.js';
@@ -91,7 +87,7 @@ export const MEMORY_DEDUP_SIMILARITY = 0.93;
 /**
  * Which of a session's events still need ingesting.
  *
- * The A2A server is stateless, so `addSessionToMemory` runs after EVERY task
+ * The A2A server is stateless, so `ingest` runs after EVERY task
  * with the WHOLE session — an N-turn conversation was being extracted N times
  * over a growing transcript. That produced 13 EPISODE records narrating the
  * same session and one balance stored six ways. A high-water mark per session
@@ -162,24 +158,14 @@ export class SupabaseVectorMemoryService {
         console.log(`[MemoryService] Initialized — backend: Supabase Vector Search (pgvector), structured records; `
             + `extraction ${this.extractor.model}, embeddings ${this.embedder.provider}/${this.embedder.model} (${this.embedder.dimensions}d)`);
     }
-    /**
-     * ADK's name for `ingest`, which the ADK runtime and the A2A server call.
-     *
-     * @param extractionRules Optional domain rules appended to the shared
-     *   extraction prompt for THIS consumer only. The prompt is global (the
-     *   patient advocate uses the same one), so anything domain-specific —
-     *   "never store a market quote" — arrives here rather than being edited
-     *   into it. Declared as `memory_extraction_rules` on the served syndicate.
-     */
-    async addSessionToMemory(session, extractionRules, options = {}) {
-        return this.ingest(session, { extractionRules, extractionModel: options.extractionModel });
-    }
     /**
      * Distils the session's events not yet ingested into facts filed under
      * `<appName>/<userId>`. Throws when a step fails, leaving those events
      * pending for the next ingestion (ADR 0020 item 6).
      *
-     * @param options.extractionRules The syndicate's `memory_extraction_rules`.
+     * @param options.extractionRules The syndicate's `memory_extraction_rules`:
+     *   domain rules appended to the shared extraction prompt for this
+     *   syndicate only ("never store a market quote").
      * @param options.extractionModel The syndicate's `memory_extraction_model`.
      */
     async ingest(session, options = {}) {
@@ -268,14 +254,6 @@ export class SupabaseVectorMemoryService {
         console.log(`[MemoryService] Deleted ${count} fact(s) for user key: ${userKey}`);
         return count;
     }
-    /**
-     * ADK's name for `search`, which ADK's Context.searchMemory calls. The
-     * entries are the same JSON as ADK's MemoryEntry; only genai's types name
-     * a few part fields as enums, hence the cast.
-     */
-    async searchMemory(request) {
-        return (await this.search(request));
-    }
     /** The facts most relevant to the query, from the `<appName>/<userId>` silo only. */
     async search(request) {
         const query = stripHarnessBlocks(request.query) || request.query;

package/dist/lib/model.d.ts

@@ -1,24 +1,18 @@
 /**
  * lib/model.ts — the `melchizedek-agents/model` entry: the engine's model
- * layer on its own, with no @google/adk (ADR 0068).
+ * layer on its own (ADR 0068).
  *
  * What it holds: the model contract's types (ADR 0048), every provider's
  * contract adapter, resolveAdapter and resolveAdapterWithFallback over the
  * one prefix table (ADR 0060), FallbackAdapter and the circuit breaker's
  * helpers (ADR 0044). A consumer can call any model through it without
- * installing ADK, the peer dependency the rest of the package needs.
+ * loading the compiler or the runtime.
  *
- * What it leaves out, because each loads ADK: AdkGeminiAdapter, the ADK
- * shims (ClaudeLlm, GptLlm and the rest), TracedGemini, resolveModel and
- * registerAvailableProviders. They stay at `melchizedek-agents/models/*`.
+ * Gemini: resolveAdapter returns the engine's GeminiAdapter for a Gemini id;
+ * GEMINI_ADAPTER=adk throws, naming 1.0.0 (ADR 0107).
  *
- * Gemini: resolveAdapter here returns the engine's GeminiAdapter for a
- * Gemini id. Asking for `adk` (the option, or GEMINI_ADAPTER=adk) throws and
- * names `melchizedek-agents/models/registry`, whose resolveAdapter keeps
- * ADR 0060's default until gate G3.
- *
- * tests/packageSurface.test.ts walks this module's runtime import graph and
- * fails if any module in it names @google/adk.
+ * tests/packageSurface.test.ts walks this module's runtime import graph:
+ * @google/* appears in it only in the Gemini adapter and the genai mapping.
  */
 export type * from './models/contract.ts';
 export { resolveAdapter, resolveAdapterWithFallback, geminiAdapterSetting } from './models/adapterResolver.ts';