melchizedek-agents 0.18.0 → 0.20.0

package/dist/lib/a2a/executor.js

@@ -8,6 +8,12 @@
  * cancellation, the per-server concurrency cap, and memory ingestion after
  * 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).
  */
 import { createHash, randomUUID } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -17,9 +23,12 @@ 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';
+import { describeConsent } from '../runtime/credentials.js';
 export const requestContextStorage = new AsyncLocalStorage();
 /** The app name every A2A session and memory silo is stored under. */
 export const A2A_APP_NAME = 'melchizedek-a2a';
@@ -303,6 +312,39 @@ function publishApprovalRequest(eventBus, taskId, contextId, pending) {
         metadata: undefined,
     }));
 }
+/**
+ * A call waits for an OAuth grant (ADR 0085): the task ends input-required,
+ * naming the provider, with a data part carrying the authorization URL and
+ * its state nonce. The person opens the URL; the server's callback stores
+ * the grant; the next message on the conversation resumes the call. The
+ * part carries no token, code or verifier.
+ */
+function publishConsentRequest(eventBus, taskId, contextId, pending) {
+    const message = statusMessage(taskId, contextId, `Authorization needed: ${describeConsent(pending)}. Open ${pending.authUri} to authorize, then send any message on this conversation to continue.`);
+    message.parts.push({
+        content: {
+            $case: 'data',
+            value: {
+                type: 'consent_request',
+                consent_id: pending.id,
+                agent: pending.agent,
+                provider: pending.provider,
+                authorization_url: pending.authUri,
+                state: pending.state,
+                scopes: pending.scopes,
+            },
+        },
+        metadata: undefined,
+        filename: '',
+        mediaType: 'application/json',
+    });
+    eventBus.publish(AgentEvent.statusUpdate({
+        taskId,
+        contextId,
+        status: { state: TaskState.TASK_STATE_INPUT_REQUIRED, message, timestamp: new Date().toISOString() },
+        metadata: undefined,
+    }));
+}
 /**
  * The caller's answer to the open approval, from the raw A2A parts: a data
  * part `{ approval: { id, approved } }` naming that request, or the text
@@ -375,8 +417,16 @@ export function answerStream(eventBus, taskId, contextId) {
 export class SyndicateExecutor {
     opts;
     configHash;
+    /** The store as the engine reads it. */
+    sessions;
+    /** The faces the turn runner's fixed signature names (ADR 0045 item 4). */
+    turnSessions;
+    turnMemory;
     constructor(opts) {
         this.opts = opts;
+        this.sessions = asSessionService(opts.sessionService);
+        this.turnSessions = asAdkSessionService(opts.sessionService);
+        this.turnMemory = opts.memoryService ? asAdkMemoryService(opts.memoryService) : undefined;
     }
     /** Provenance stamp for every turn this executor serves (lineage.ts). */
     configHashFor() {
@@ -531,8 +581,10 @@ export class SyndicateExecutor {
             // Approvals (ADR 0028): while a gated call waits, a message is its
             // answer, or the request is repeated without spending a model call.
             if (declaresApprovals(config)) {
-                const session = await this.opts.sessionService.getSession({ appName, userId, sessionId: contextId });
-                const pending = pendingApproval(session?.events ?? []);
+                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 ?? []));
                 if (pending) {
                     const answer = approvalAnswer(rawParts, pending);
                     if (!answer) {
@@ -551,11 +603,12 @@ export class SyndicateExecutor {
                 appName,
                 userId,
                 sessionId: contextId,
-                sessionService: this.opts.sessionService,
-                memoryService: this.opts.memoryService,
+                sessionService: this.turnSessions,
+                memoryService: this.turnMemory,
                 compile: this.opts.compileFor(ctx),
                 signal: slot.signal,
                 deadlineMs: this.opts.taskTimeoutMs,
+                ...(this.opts.toolCredentials ? { toolCredentials: this.opts.toolCredentials } : {}),
                 streaming: !!stream,
                 trace: {
                     taskId,
@@ -591,6 +644,12 @@ export class SyndicateExecutor {
                 await report(ctx, 'input-required', 'approval', u);
                 return;
             }
+            if (result.status === 'input-required' && result.consent) {
+                log(`⏸ Task ${short} waiting for ${result.consent.provider} authorization after ${spent}`);
+                publishConsentRequest(eventBus, taskId, contextId, result.consent);
+                await report(ctx, 'input-required', 'consent', u);
+                return;
+            }
             if (result.status === 'input-required' && result.input) {
                 log(`⏸ Task ${short} waiting for input from ${result.input.node} after ${spent}`);
                 publishInputRequest(eventBus, taskId, contextId, result.input);
@@ -609,11 +668,11 @@ export class SyndicateExecutor {
             // Long-term memory: there is no "session end" on a server, so ingest
             // after every completed task. Runs AFTER the final publish, so it never
             // delays the reply, and a failure here never fails the task.
-            if (this.opts.memoryService) {
+            if (this.turnMemory) {
                 try {
                     await ingestTurnMemory({
-                        memoryService: this.opts.memoryService,
-                        sessionService: this.opts.sessionService,
+                        memoryService: this.turnMemory,
+                        sessionService: this.turnSessions,
                         appName,
                         userId,
                         sessionId: contextId,

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

@@ -12,7 +12,9 @@
  *
  * 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. It does not depend on ADK.
+ * 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).
  *
  * Security:
  *   - Every URL — the card and the endpoint the card names — passes the
@@ -27,7 +29,8 @@
  */
 import type { AgentCard, Message, Task } from '@a2a-js/sdk';
 import type { Client } from '@a2a-js/sdk/client';
-import { FunctionTool } from '@google/adk';
+import type { FunctionTool } from '@google/adk';
+import type { Tool } from '../tools/tool.ts';
 export interface RemoteAnswer {
     state: string;
     text: string;
@@ -79,13 +82,25 @@ export declare class RemoteA2AAgent {
 export declare function remoteContextId(localSessionId: string | undefined, subagentName: string): string | undefined;
 /** Render a remote result as the tool output the orchestrator reads. */
 export declare function remoteToolOutput(name: string, answer: RemoteAnswer): string;
-/**
- * The subagent as a tool with AgentTool's contract (one `request` string), so
- * an orchestrator delegates to it exactly as to a local subagent. Failures
- * come back as readable text, never as a throw into the runner.
- */
-export declare function remoteAgentTool(params: {
+/** What a remote agent tool is built from: the subagent's name and description, and where it is served. */
+export interface RemoteAgentToolParams {
     name: string;
     description: string;
     url: string;
-}): FunctionTool;
+}
+/**
+ * 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
+ * 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;

package/dist/lib/a2a/remoteAgent.js

@@ -12,7 +12,9 @@
  *
  * 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. It does not depend on ADK.
+ * 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).
  *
  * Security:
  *   - Every URL — the card and the endpoint the card names — passes the
@@ -28,9 +30,9 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { Role, TaskState } from '@a2a-js/sdk';
 import { ClientFactory, DefaultAgentCardResolver, JsonRpcTransportFactory, RestTransportFactory } from '@a2a-js/sdk/client';
-import { FunctionTool } from '@google/adk';
 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;
@@ -234,29 +236,35 @@ export function remoteToolOutput(name, answer) {
     return `Error: remote agent ${name} ended in state '${answer.state}'${answer.text ? ` — ${answer.text}` : ''}.`;
 }
 /**
- * The subagent as a tool with AgentTool's contract (one `request` string), so
- * an orchestrator delegates to it exactly as to a local subagent. Failures
- * come back as readable text, never as a throw into the runner.
+ * 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
+ * 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 function remoteAgentTool(params) {
+export function remoteAgentOwnTool(params) {
     const client = new RemoteA2AAgent(params.url);
-    return new FunctionTool({
+    const declaration = {
         name: params.name,
         description: params.description || `Remote agent ${params.name}`,
         parameters: {
-            type: 'OBJECT',
-            properties: { request: { type: 'STRING', description: `What to ask ${params.name}.` } },
+            type: 'object',
+            properties: { request: { type: 'string', description: `What to ask ${params.name}.` } },
             required: ['request'],
         },
-        execute: async (input, toolContext) => {
-            const args = (input ?? {});
+    };
+    return {
+        name: params.name,
+        declaration: () => declaration,
+        execute: async (args, ctx) => {
             const request = String(args?.request ?? '').trim();
             if (!request)
                 return `Error: ${params.name} needs a request.`;
             try {
                 const answer = await client.send(request, {
-                    contextId: remoteContextId(toolContext?.invocationContext?.session?.id, params.name),
-                    signal: currentTurnSignal(),
+                    contextId: remoteContextId(ctx?.sessionId, params.name),
+                    signal: ctx?.signal ?? currentTurnSignal(),
                 });
                 return remoteToolOutput(params.name, answer);
             }
@@ -264,5 +272,14 @@ export function remoteAgentTool(params) {
                 return `Error: remote agent ${params.name} could not be reached (${err instanceof Error ? err.message : String(err)}).`;
             }
         },
-    });
+    };
+}
+/**
+ * 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 function remoteAgentTool(params) {
+    return toFunctionTool(remoteAgentOwnTool(params));
 }

package/dist/lib/adkPeer.d.ts

@@ -0,0 +1,63 @@
+/**
+ * lib/adkPeer.ts — @google/adk as an optional peer (ADR 0102).
+ *
+ * WHY this file exists:
+ *   From 0.20.0 the native runtime is the default, and @google/adk is needed
+ *   only for MELCHIZEDEK_RUNTIME=adk and the features only ADK runs. Until
+ *   1.0.0 removes ADK (ADR 0045), the engine's objects still carry an ADK
+ *   face: the tool registry holds FunctionTools that carry their own Tool,
+ *   the model shims are BaseLlm classes that carry their contract adapter,
+ *   and the durable session stores are ADK BaseSessionServices as well as
+ *   the engine's SessionService. Those classes extend ADK's at load time.
+ *
+ *   This module is the one place the package loads ADK. It tries once, when
+ *   it is first imported, and every other module takes ADK's values from
+ *   here, never from '@google/adk' directly (a type-only import is fine):
+ *   - When ADK is installed, each export below IS ADK's own value, so the
+ *     ADK runtime, `instanceof` and ADK's registry behave exactly as before.
+ *   - When it is not, the base classes are stand-ins: they construct as
+ *     ADK's do (a tool's name, a model's id, a toolset's filter) and carry
+ *     ADK's own Symbol.for marks, so the engine reads them as it reads ADK's,
+ *     and every method only ADK calls throws AdkNotInstalledError, which
+ *     names the package. Everything else (`Runner`, `LlmAgent`, the plugins)
+ *     is reached through requireAdk(feature), which throws the same error.
+ *
+ *   A package that is installed but fails to load for another reason (a
+ *   missing dependency of its own, a syntax error) is not "absent": that
+ *   error is rethrown, so nothing hides a broken install.
+ *
+ * The load is a top-level await of a dynamic import: an ES module cannot
+ * load another synchronously, and the exported classes must exist before
+ * any subclass is defined.
+ */
+import type * as AdkModule from '@google/adk';
+/** The package this module loads. */
+export declare const ADK_PACKAGE = "@google/adk";
+/** @google/adk's module namespace, as its types describe it. */
+export type Adk = typeof AdkModule;
+/** ADK's module when it is installed, else undefined. */
+export declare const adk: Adk | undefined;
+/** Whether @google/adk is installed and loaded. */
+export declare function adkInstalled(): boolean;
+/** The installed @google/adk version, read from its package.json, or undefined when it is not installed. */
+export declare function adkVersion(): Promise<string | undefined>;
+/** A feature only ADK runs was used without @google/adk installed. */
+export declare class AdkNotInstalledError extends Error {
+    readonly feature: string;
+    constructor(feature: string);
+}
+/** ADK's module, or AdkNotInstalledError naming `feature` when it is not installed. */
+export declare function requireAdk(feature: string): Adk;
+export declare const BaseTool: Adk['BaseTool'];
+export type BaseTool = AdkModule.BaseTool;
+export declare const FunctionTool: Adk['FunctionTool'];
+export type FunctionTool<TParameters extends AdkModule.ToolInputParameters = undefined> = AdkModule.FunctionTool<TParameters>;
+export declare const BaseToolset: Adk['BaseToolset'];
+export type BaseToolset = AdkModule.BaseToolset;
+export declare const BaseLlm: Adk['BaseLlm'];
+export type BaseLlm = AdkModule.BaseLlm;
+export declare const Gemini: Adk['Gemini'];
+export type Gemini = AdkModule.Gemini;
+export declare const BaseSessionService: Adk['BaseSessionService'];
+export type BaseSessionService = AdkModule.BaseSessionService;
+export declare const GOOGLE_SEARCH: Adk['GOOGLE_SEARCH'];

package/dist/lib/adkPeer.js

@@ -0,0 +1,240 @@
+/**
+ * lib/adkPeer.ts — @google/adk as an optional peer (ADR 0102).
+ *
+ * WHY this file exists:
+ *   From 0.20.0 the native runtime is the default, and @google/adk is needed
+ *   only for MELCHIZEDEK_RUNTIME=adk and the features only ADK runs. Until
+ *   1.0.0 removes ADK (ADR 0045), the engine's objects still carry an ADK
+ *   face: the tool registry holds FunctionTools that carry their own Tool,
+ *   the model shims are BaseLlm classes that carry their contract adapter,
+ *   and the durable session stores are ADK BaseSessionServices as well as
+ *   the engine's SessionService. Those classes extend ADK's at load time.
+ *
+ *   This module is the one place the package loads ADK. It tries once, when
+ *   it is first imported, and every other module takes ADK's values from
+ *   here, never from '@google/adk' directly (a type-only import is fine):
+ *   - When ADK is installed, each export below IS ADK's own value, so the
+ *     ADK runtime, `instanceof` and ADK's registry behave exactly as before.
+ *   - When it is not, the base classes are stand-ins: they construct as
+ *     ADK's do (a tool's name, a model's id, a toolset's filter) and carry
+ *     ADK's own Symbol.for marks, so the engine reads them as it reads ADK's,
+ *     and every method only ADK calls throws AdkNotInstalledError, which
+ *     names the package. Everything else (`Runner`, `LlmAgent`, the plugins)
+ *     is reached through requireAdk(feature), which throws the same error.
+ *
+ *   A package that is installed but fails to load for another reason (a
+ *   missing dependency of its own, a syntax error) is not "absent": that
+ *   error is rethrown, so nothing hides a broken install.
+ *
+ * The load is a top-level await of a dynamic import: an ES module cannot
+ * load another synchronously, and the exported classes must exist before
+ * any subclass is defined.
+ */
+/** The package this module loads. */
+export const ADK_PACKAGE = '@google/adk';
+/** Whether `err` says the package itself could not be found (and not a module it imports). */
+function isMissingPackage(err) {
+    const e = err;
+    if (!e || typeof e !== 'object')
+        return false;
+    if (e.code !== 'ERR_MODULE_NOT_FOUND' && e.code !== 'MODULE_NOT_FOUND')
+        return false;
+    return typeof e.message === 'string' && e.message.includes(`'${ADK_PACKAGE}'`);
+}
+let loaded;
+try {
+    loaded = await import('@google/adk');
+}
+catch (err) {
+    if (!isMissingPackage(err))
+        throw err;
+}
+/** ADK's module when it is installed, else undefined. */
+export const adk = loaded;
+/** Whether @google/adk is installed and loaded. */
+export function adkInstalled() {
+    return loaded !== undefined;
+}
+/** The installed @google/adk version, read from its package.json, or undefined when it is not installed. */
+export async function adkVersion() {
+    if (!loaded)
+        return undefined;
+    try {
+        const { createRequire } = await import('node:module');
+        const require = createRequire(import.meta.url);
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        // The package's exports map hides package.json, so walk up from its entry.
+        let dir = path.dirname(require.resolve(ADK_PACKAGE));
+        for (let i = 0; i < 6; i++) {
+            const file = path.join(dir, 'package.json');
+            if (fs.existsSync(file)) {
+                const pkg = JSON.parse(fs.readFileSync(file, 'utf8'));
+                if (pkg.name === ADK_PACKAGE)
+                    return pkg.version;
+            }
+            dir = path.dirname(dir);
+        }
+    }
+    catch {
+        // Unreadable: the version is unknown, not the package absent.
+    }
+    return undefined;
+}
+/** A feature only ADK runs was used without @google/adk installed. */
+export class AdkNotInstalledError extends Error {
+    feature;
+    constructor(feature) {
+        super(`${feature} needs ${ADK_PACKAGE}, which is not installed. ` +
+            `Install it beside melchizedek-agents (npm install ${ADK_PACKAGE}@~2.2.0), ` +
+            `or run on the native runtime (the default; unset MELCHIZEDEK_RUNTIME or set it to native).`);
+        this.name = 'AdkNotInstalledError';
+        this.feature = feature;
+    }
+}
+/** ADK's module, or AdkNotInstalledError naming `feature` when it is not installed. */
+export function requireAdk(feature) {
+    if (!loaded)
+        throw new AdkNotInstalledError(feature);
+    return loaded;
+}
+// ── Stand-ins for ADK's base classes ─────────────────────────────────────────
+//
+// Each matches the ADK constructor's effect on the instance and ADK's
+// Symbol.for mark, nothing more. They exist only when ADK is not installed.
+const BASE_TOOL = Symbol.for('google.adk.baseTool');
+const IN_MODEL_TOOL = Symbol.for('google.adk.inModelTool');
+const FUNCTION_TOOL = Symbol.for('google.adk.functionTool');
+const BASE_TOOLSET = Symbol.for('google.adk.baseToolset');
+const BASE_MODEL = Symbol.for('google.adk.baseModel');
+const GEMINI_MODEL = Symbol.for('google.adk.geminiModel');
+function adkOnly(what) {
+    throw new AdkNotInstalledError(what);
+}
+class MissingBaseTool {
+    [BASE_TOOL] = true;
+    name;
+    description;
+    isLongRunning;
+    constructor(params) {
+        this.name = params.name;
+        this.description = params.description;
+        this.isLongRunning = params.isLongRunning ?? false;
+    }
+    _getDeclaration() {
+        return undefined;
+    }
+    async checkRequireConfirmation() {
+        return false;
+    }
+    async processLlmRequest(_request) {
+        adkOnly(`The ADK face of the tool '${this.name}'`);
+    }
+    async runAsync(_request) {
+        return adkOnly(`The ADK face of the tool '${this.name}'`);
+    }
+}
+class MissingFunctionTool extends MissingBaseTool {
+    [FUNCTION_TOOL] = true;
+    execute;
+    parameters;
+    requireConfirmation;
+    constructor(options) {
+        const name = options.name ?? options.execute.name;
+        if (!name)
+            throw new Error('Tool name cannot be empty. Either name the `execute` function or provide a `name`.');
+        super({ name, description: options.description, isLongRunning: options.isLongRunning });
+        this.execute = options.execute;
+        this.parameters = options.parameters;
+        this.requireConfirmation = options.requireConfirmation ?? false;
+    }
+}
+class MissingBaseToolset {
+    [BASE_TOOLSET] = true;
+    toolFilter;
+    prefix;
+    constructor(toolFilter, prefix) {
+        this.toolFilter = toolFilter;
+        this.prefix = prefix;
+    }
+    async getTools() {
+        return adkOnly('An ADK toolset');
+    }
+    async close() { }
+}
+class MissingBaseLlm {
+    [BASE_MODEL] = true;
+    model;
+    static supportedModels = [];
+    constructor({ model }) {
+        this.model = model;
+    }
+    generateContentAsync() {
+        return adkOnly(`The ADK face of the model '${this.model}'`);
+    }
+    async connect() {
+        return adkOnly(`The ADK face of the model '${this.model}'`);
+    }
+}
+/**
+ * ADK's Gemini, absent: it holds what a caller gave it (the model, a key,
+ * Vertex AI's settings), as ADK's does, so the native runtime reads it as it
+ * reads TracedGemini (lib/compileNative.ts). Calling it throws.
+ */
+class MissingGemini extends MissingBaseLlm {
+    [GEMINI_MODEL] = true;
+    apiKey;
+    vertexai;
+    project;
+    location;
+    headers;
+    constructor(params) {
+        super({ model: params.model ?? 'gemini-2.5-flash' });
+        if (params.apiKey !== undefined)
+            this.apiKey = params.apiKey;
+        if (params.vertexai !== undefined)
+            this.vertexai = params.vertexai;
+        if (params.project !== undefined)
+            this.project = params.project;
+        if (params.location !== undefined)
+            this.location = params.location;
+        if (params.headers !== undefined)
+            this.headers = params.headers;
+    }
+}
+/**
+ * ADK's session service base, absent. A store that extends it is still the
+ * engine's SessionService; only the ADK face (the base's appendEvent, which
+ * ADK's Runner reaches) needs ADK.
+ */
+class MissingBaseSessionService {
+    async appendEvent(_request) {
+        return adkOnly('The ADK face of a session store');
+    }
+    /** ADK's own: the session when it exists, else a new one, through the store's methods. */
+    async getOrCreateSession(request) {
+        const self = this;
+        if (!request.sessionId)
+            return self.createSession(request);
+        const session = await self.getSession({ appName: request.appName, userId: request.userId, sessionId: request.sessionId });
+        return session ?? self.createSession(request);
+    }
+}
+/** ADK's GOOGLE_SEARCH, absent: an in-model tool named google_search, which the engine reads by ADK's mark. */
+class MissingGoogleSearchTool extends MissingBaseTool {
+    [IN_MODEL_TOOL] = true;
+    constructor() {
+        super({ name: 'google_search', description: 'Google Search Tool' });
+    }
+}
+// ── The values every other module imports ────────────────────────────────────
+//
+// A type of the same name sits beside each value, so `import { BaseTool }`
+// from here serves as both, as it did from '@google/adk'.
+export const BaseTool = loaded?.BaseTool ?? MissingBaseTool;
+export const FunctionTool = loaded?.FunctionTool ?? MissingFunctionTool;
+export const BaseToolset = loaded?.BaseToolset ?? MissingBaseToolset;
+export const BaseLlm = loaded?.BaseLlm ?? MissingBaseLlm;
+export const Gemini = loaded?.Gemini ?? MissingGemini;
+export const BaseSessionService = loaded?.BaseSessionService ?? MissingBaseSessionService;
+export const GOOGLE_SEARCH = loaded?.GOOGLE_SEARCH ?? new MissingGoogleSearchTool();