melchizedek-agents 0.18.0 → 0.19.0

package/dist/lib/runtime/syndicateTurn.js

@@ -25,10 +25,31 @@
  * subagents, nested syndicates), an optional deadline bounds wall-clock
  * time, and an outer AbortSignal cancels it. All three abort the provider
  * request in flight, not just the loop around it.
+ *
+ * ── Runtimes (ADR 0045, ADR 0073) ─────────────────────────────────────────
+ * Each agent of a turn runs on ADK's Runner (the default) or on the
+ * engine's own agent loop: the turn's `runtime` option, else
+ * MELCHIZEDEK_RUNTIME. Both compile the same AgentSpec (lib/compile.ts),
+ * store the same events and drain through drainAgentStream, so everything
+ * else here is shared. What native does not run yet fails before any model
+ * call, naming the feature (lib/runtime/nativeTurn.ts).
  */
 import { InMemorySessionService, ReflectAndRetryModelPlugin, ReflectAndRetryToolPlugin, Runner, StreamingMode, getFunctionCalls, getFunctionResponses } from '@google/adk';
 import { DEFAULT_MAX_STEPS } from '../config.js';
-import { agentGates, compileGraph, compileSubagent } from '../compile.js';
+import { agentGates, compileGraph, compileSpec, compileSubagent, compileSubagentSpec } from '../compile.js';
+import { compileNative, nativeAdapterFor } from '../compileNative.js';
+import { nativeMemory, refuseOnNative, runNativeAgent } from './nativeTurn.js';
+import { asSessionService } from './adkSessionBridge.js';
+import { resolveTools } from '../toolRegistry.js';
+import { buildWorkflowGraph } from '../workflow/graph.js';
+import { UnsupportedWorkflowResumeError } from '../workflow/resume.js';
+import { refuseUnrunnableNodes, runNativeWorkflow } from '../workflow/turn.js';
+import { SelfCorrection } from './native/selfCorrection.js';
+import { UnsupportedOnRuntimeError, chooseRuntime } from './runtimeFlag.js';
+import { pinnedCredentialStore } from '../tools/auth.js';
+import { credentialResponsePart, describeConsent, pendingConsent } from './credentials.js';
+export { CREDENTIAL_REQUEST, credentialResponsePart, describeConsent, pendingConsent } from './credentials.js';
+export { chooseRuntime, runtimeSetting, DEFAULT_RUNTIME, RUNTIMES, UnsupportedOnRuntimeError } from './runtimeFlag.js';
 import { ROUTE_STEP_SUFFIX, compileWorkflow, describeInput, inputRequestFrom, isWorkflowSyndicate } from '../workflow.js';
 export { describeInput } from '../workflow.js';
 import { isDispatchSyndicate, matchRouteOverride, resolveRoute } from '../dispatch.js';
@@ -44,13 +65,14 @@ export { ASK_USER, pendingQuestion, questionAnswerPart } from './questions.js';
 export { approvalResponsePart, describeApproval, pendingApproval } from './approvals.js';
 import { RemoteA2AAgent, remoteContextId, remoteToolOutput } from '../a2a/remoteAgent.js';
 import { createTurnControl, runWithTurnControl, stopCode, stopMessage } from './turnControl.js';
+import { DEFAULT_MODEL_ERROR_RETRIES, DEFAULT_TOOL_ERROR_RETRIES } from './native/selfCorrection.js';
 const THOUGHTS_PREVIEW_CHARS = 600;
 const CLASSIFIER_PREAMBLE = `RECENT CONVERSATION, oldest first — context for your classification only. `
     + `Never answer it, and never route on it alone; it is here so you can tell a `
     + `follow-up, a redo request, or a challenge to a previous answer apart from small talk.\n`;
 // ── Self-correction (ADR 0034) ───────────────────────────────────────────────
-export const DEFAULT_MODEL_ERROR_RETRIES = 2;
-export const DEFAULT_TOOL_ERROR_RETRIES = 3;
+// The defaults live with the native loop's self-correction, so both runtimes read one pair.
+export { DEFAULT_MODEL_ERROR_RETRIES, DEFAULT_TOOL_ERROR_RETRIES } from './native/selfCorrection.js';
 /**
  * ADK's reflect-and-retry plugins, on by default. The model plugin turns a
  * reply ADK marks malformed (MALFORMED_FUNCTION_CALL) into a retry with
@@ -263,6 +285,7 @@ export async function runSyndicateTurn(opts) {
     // the framework's adapters registered there, Gemini would be ADK's own
     // class, which bypasses traceLlmGeneration: no max_steps, no cancel. A
     // caller that resolves models itself (the A2A server) is left alone.
+    const runtime = chooseRuntime(opts.runtime);
     if (!opts.compile?.resolveModel)
         registerAvailableProviders();
     const control = createTurnControl({
@@ -271,13 +294,34 @@ export async function runSyndicateTurn(opts) {
         signal: opts.signal,
     });
     try {
-        return await runWithTurnControl(control, () => runTurnInner(opts, control));
+        return await runWithTurnControl(control, () => runTurnInner(opts, control, runtime));
     }
     finally {
         control.dispose();
     }
 }
-async function runTurnInner(opts, control) {
+/**
+ * A workflow syndicate for the native runtime: its graph, every agent
+ * compiled for native from the same specs ADK's compileWorkflow builds its
+ * agents from, one adapter lookup that knows every agent's models, and the
+ * registry's lookup for tool nodes. A tool node ADK's compile refuses (an
+ * unregistered or long-running tool) is refused here, before any model
+ * call, with ADK's message.
+ */
+async function compileNativeWorkflow(config, opts) {
+    const graph = buildWorkflowGraph(config);
+    const specs = [];
+    const agents = new Map();
+    for (const sub of [{ description: '', ...config.orchestrator }, ...(config.subagents ?? [])]) {
+        const spec = await compileSubagentSpec(sub, opts);
+        specs.push(spec);
+        agents.set(sub.name, compileNative(spec));
+    }
+    const resolveTool = (name) => resolveTools([name], opts.onUnknownTool)[0];
+    refuseUnrunnableNodes(graph, resolveTool);
+    return { runtime: 'native-workflow', graph, agents, adapterFor: nativeAdapterFor(opts, specs), resolveTool };
+}
+async function runTurnInner(opts, control, runtime) {
     const { config, appName, userId, sessionId, sessionService } = opts;
     const ev = opts.events ?? {};
     // Nested references load from the definition's bundle when it has one
@@ -288,6 +332,17 @@ async function runTurnInner(opts, control) {
     const trace = opts.trace === false ? undefined : opts.trace ?? {};
     let parts = opts.parts.map((p) => (typeof p === 'string' ? { text: p } : p));
     const messageText = parts.map((p) => (typeof p.text === 'string' ? p.text : '')).join('\n');
+    const native = runtime === 'native';
+    // What native does not run yet fails here, before the session is touched.
+    if (native)
+        refuseOnNative(config, { isWorkflow: isWorkflowSyndicate(config), transformAgent: opts.transformAgent });
+    const nativeOf = (spec) => ({ runtime: 'native', agent: compileNative(spec), adapterFor: nativeAdapterFor(compileOpts, spec) });
+    /** The orchestrator (a DELEGATE root, or a dispatch classifier) for the turn's runtime. */
+    const compileRoot = async () => native ? nativeOf(await compileSpec(config, compileOpts)) : { runtime: 'adk', agent: transform(await compileGraph(config, compileOpts)) };
+    /** A dispatch route for the turn's runtime. */
+    const compileRoute = async (routeCfg) => native ? nativeOf(await compileSubagentSpec(routeCfg, compileOpts)) : { runtime: 'adk', agent: transform(await compileSubagent(routeCfg, compileOpts)) };
+    // Native self-correction (ADR 0075): one per turn, from the YAML's retries:, as the ADK path installs retryPlugins.
+    const selfCorrection = native ? new SelfCorrection(config.retries) : undefined;
     const result = {
         status: 'completed',
         text: '',
@@ -338,12 +393,54 @@ async function runTurnInner(opts, control) {
         // The log names the call, not its arguments: they are user content.
         ev.log?.(`✓ Approval ${decision.approved ? 'granted' : 'refused'}: ${resuming.agent} → ${resuming.tool}`);
     }
+    // ── Consent (lib/runtime/credentials.ts, ADR 0085) ────────────────────────
+    // While a call waits for an OAuth grant, the next message resumes it once
+    // the callback has stored the grant; until then it repeats the request and
+    // runs nothing. Only the native loop resumes it: ADK's auth preprocessor
+    // would exchange a code carried in the message, which this engine never
+    // puts there.
+    const credentialStore = opts.toolCredentials ? pinnedCredentialStore(opts.toolCredentials.store, appName) : undefined;
+    const consentPause = (pending) => {
+        result.status = 'input-required';
+        result.consent = pending;
+        result.text = `Authorization needed: ${describeConsent(pending)}. Open the authorization link, then send any message to continue.`;
+        ev.log?.(`⏸ Authorization needed: ${pending.agent} → ${pending.provider}`);
+        return finish();
+    };
+    let granting;
+    if (!decision && !isWorkflowSyndicate(config)) {
+        const open = pendingConsent(existing?.events ?? []);
+        if (open) {
+            if (!native) {
+                throw new UnsupportedOnRuntimeError('resuming an OAuth consent (adk_request_credential)', 'adk', config.syndicate_name || open.agent || 'syndicate');
+            }
+            if (!credentialStore) {
+                result.status = 'failed';
+                result.error = { code: 'CONSENT_UNAVAILABLE', message: `A call waits for a ${open.provider} authorization, but this turn has no credential store.` };
+                return finish();
+            }
+            let granted = false;
+            try {
+                granted = !!open.provider && !!(await credentialStore.get({ appName, userId, provider: open.provider }));
+            }
+            catch {
+                // Expired or unreadable: not granted. The request stands.
+            }
+            if (!granted)
+                return consentPause(open);
+            granting = open;
+            parts = [credentialResponsePart(open.id, open.provider)];
+            ev.log?.(`✓ Authorization granted: ${open.agent} → ${open.provider}`);
+        }
+    }
     // ── Questions (lib/runtime/questions.ts) ───────────────────────────────────
     // While an agent's `ask_user` call is open, a plain-text message is its
     // answer: it becomes that call's response, and the agent that asked
-    // resumes its own tool loop. A workflow's pauses are ADK's own business.
+    // resumes its own tool loop, on either runtime (the native loop reads the
+    // response from its history, as ADK's content processor does; ADR 0079).
+    // A workflow's pauses are ADK's own business.
     let answering;
-    if (!decision && !isWorkflowSyndicate(config)) {
+    if (!decision && !granting && !isWorkflowSyndicate(config)) {
         const question = pendingQuestion(existing?.events ?? []);
         const plainText = parts.length > 0 && parts.every((p) => typeof p.text === 'string');
         if (question && plainText) {
@@ -353,7 +450,21 @@ async function runTurnInner(opts, control) {
         }
     }
     /** The agent a dispatch turn must resume, and the call its interrupted turn holds. */
-    const resumeTarget = resuming ? { agent: resuming.agent, id: resuming.id, why: 'resuming an approval' } : answering ? { ...answering, why: 'answering its question' } : undefined;
+    const resumeTarget = resuming
+        ? { agent: resuming.agent, id: resuming.id, why: 'resuming an approval' }
+        : granting
+            ? { agent: granting.agent, id: granting.id, why: 'resuming after an authorization' }
+            : answering
+                ? { ...answering, why: 'answering its question' }
+                : undefined;
+    /** After the answering run: is a call now waiting for a grant? */
+    const awaitingConsent = async (agentName) => {
+        if (!opts.toolCredentials?.consent || !native)
+            return undefined;
+        const after = await sessionService.getSession({ appName, userId, sessionId });
+        const pending = pendingConsent(after?.events ?? []);
+        return pending && pending.agent === agentName ? pending : undefined;
+    };
     /** After the answering run: is a gated call now waiting? */
     const awaitingApproval = async (agentName) => {
         const after = await sessionService.getSession({ appName, userId, sessionId });
@@ -380,20 +491,64 @@ async function runTurnInner(opts, control) {
     };
     /** Run ONE agent against ONE session, under the turn's controls. */
     const runAgent = async (params) => {
-        const runner = new Runner({
-            agent: params.agent,
-            appName,
-            sessionService: params.sessions,
-            plugins: retryPlugins(config.retries),
-            ...(opts.memoryService ? { memoryService: opts.memoryService } : {}),
-        });
-        let stream = runner.runAsync({
-            userId,
-            sessionId: params.sid,
-            newMessage: { role: 'user', parts: params.userParts },
-            abortSignal: control.signal,
-            ...(opts.streaming ? { runConfig: { streamingMode: StreamingMode.SSE } } : {}),
-        });
+        let stream;
+        if (params.agent.runtime === 'native-workflow') {
+            // The engine's scheduler walks the graph (lib/workflow/turn.ts): the same events, the same drain.
+            stream = runNativeWorkflow({
+                graph: params.agent.graph,
+                agents: params.agent.agents,
+                adapterFor: params.agent.adapterFor,
+                resolveTool: params.agent.resolveTool,
+                sessions: asSessionService(params.sessions),
+                appName,
+                userId,
+                sessionId: params.sid,
+                userParts: params.userParts,
+                signal: control.signal,
+                stream: opts.streaming === true,
+                memory: nativeMemory(opts.memoryService),
+                ...(selfCorrection ? { selfCorrection } : {}),
+                ...(credentialStore ? { credentials: credentialStore } : {}),
+                ...(compileOpts.log ? { log: compileOpts.log } : {}),
+            });
+        }
+        else if (params.agent.runtime === 'native') {
+            // The engine's own loop (lib/runtime/nativeTurn.ts): the same events, the same drain.
+            stream = runNativeAgent({
+                agent: params.agent.agent,
+                adapterFor: params.agent.adapterFor,
+                sessions: params.sessions,
+                appName,
+                userId,
+                sessionId: params.sid,
+                userParts: params.userParts,
+                signal: control.signal,
+                stream: opts.streaming === true,
+                memory: nativeMemory(opts.memoryService),
+                ...(selfCorrection ? { selfCorrection } : {}),
+                // Tool credentials and the consent step (ADR 0072, ADR 0085); the classifier's lane lists no tools.
+                ...(credentialStore ? { credentials: credentialStore } : {}),
+                ...(opts.toolCredentials?.consent && params.stage !== 'classify' ? { consent: opts.toolCredentials.consent } : {}),
+                // The fallback's notice goes where compile's FallbackLlm sends it on ADK.
+                ...(compileOpts.log ? { log: compileOpts.log } : {}),
+            });
+        }
+        else {
+            const runner = new Runner({
+                agent: params.agent.agent,
+                appName,
+                sessionService: params.sessions,
+                plugins: retryPlugins(config.retries),
+                ...(opts.memoryService ? { memoryService: opts.memoryService } : {}),
+            });
+            stream = runner.runAsync({
+                userId,
+                sessionId: params.sid,
+                newMessage: { role: 'user', parts: params.userParts },
+                abortSignal: control.signal,
+                ...(opts.streaming ? { runConfig: { streamingMode: StreamingMode.SSE } } : {}),
+            });
+        }
         if (trace) {
             stream = traceAgentRun(stream, {
                 syndicateName: trace.syndicateName ?? config.syndicate_name ?? appName,
@@ -450,7 +605,7 @@ async function runTurnInner(opts, control) {
                 throw new Error(`Call ${resumeTarget.id} was raised by '${resumeTarget.agent}', which is not a route of this syndicate.`);
             }
             resolution = { route: resumeTarget.agent, reason: resumeTarget.why, fellBack: false, fallbackReason: '', viaOverride: false };
-            decidedBy = resuming ? 'approval' : 'answer';
+            decidedBy = resuming ? 'approval' : granting ? 'consent' : 'answer';
         }
         else if (resolution) {
             ev.log?.(`⇄ Route pinned by override: ${resolution.route}`);
@@ -467,7 +622,7 @@ async function runTurnInner(opts, control) {
             // The classifier reads the SHARED transcript as an input digest and runs
             // in a throwaway in-memory lane, so its JSON verdicts never enter the
             // conversation the next specialist reads.
-            const routerAgent = transform(await compileGraph(config, compileOpts));
+            const routerAgent = await compileRoot();
             const routerSid = `${sessionId}::route`;
             const routerSessions = new InMemorySessionService();
             await routerSessions.createSession({ appName, userId, sessionId: routerSid });
@@ -514,7 +669,7 @@ async function runTurnInner(opts, control) {
             // The route answers directly in the SHARED session, read through a
             // projection: ADK would otherwise render other agents' turns as user
             // speech mixed with their tool payloads (lib/session/transcript.ts).
-            const routeAgent = transform(await compileSubagent(routeCfg, compileOpts));
+            const routeAgent = await compileRoute(routeCfg);
             answer = await runAgent({
                 agent: routeAgent,
                 sid: sessionId,
@@ -525,7 +680,9 @@ async function runTurnInner(opts, control) {
                     ? { rawFrom: (events) => interruptedTurnStart(events, resuming.id) }
                     : answering
                         ? { rawFrom: (events) => turnStartOfCall(events, answering.id) }
-                        : {}),
+                        : granting
+                            ? { rawFrom: (events) => turnStartOfCall(events, granting.id) }
+                            : {}),
                 stage: 'dispatch',
                 route: resolution,
                 publishToolStatus: true,
@@ -543,6 +700,11 @@ async function runTurnInner(opts, control) {
             if (pending)
                 return pause(pending);
         }
+        if (!routeCfg.a2a_agent_url) {
+            const consent = await awaitingConsent(routeCfg.name);
+            if (consent)
+                return consentPause(consent);
+        }
         const askedRoute = asked(answer);
         if (askedRoute)
             return askedRoute;
@@ -558,14 +720,18 @@ async function runTurnInner(opts, control) {
     else if (isWorkflowSyndicate(config)) {
         // ══ WORKFLOW ═════════════════════════════════════════════════════════
         // The syndicate is a graph (lib/workflow.ts): every agent a node, run
-        // by ADK's Workflow in the shared session. A node agent sees only its
-        // input unless its YAML says otherwise, so no projection is needed. An
+        // in the shared session by ADK's Workflow, or on native by the engine's
+        // scheduler (lib/workflow/turn.ts, ADR 0095); both store the same events
+        // and drain through the same reader. A node agent sees only its input
+        // unless its YAML says otherwise, so no projection is needed. An
         // `ask_user` node ends the turn input-required; the next message
         // resumes the graph where it waited.
-        const compiled = await compileWorkflow(config, compileOpts, transform);
+        const workflowAgent = native
+            ? await compileNativeWorkflow(config, compileOpts)
+            : { runtime: 'adk', agent: (await compileWorkflow(config, compileOpts, transform)).workflow };
         try {
             answer = await runAgent({
-                agent: compiled.workflow,
+                agent: workflowAgent,
                 sid: sessionId,
                 userParts: parts,
                 sessions: sessionService,
@@ -582,7 +748,8 @@ async function runTurnInner(opts, control) {
                 throw err;
             result.status = 'failed';
             result.failedStage = 'workflow';
-            result.error = { code: 'NODE_FAILED', message: last.message };
+            // A pause only ADK can resume fails the turn on native rather than walking afresh (ADR 0094, ADR 0095).
+            result.error = { code: last instanceof UnsupportedWorkflowResumeError ? 'RESUME_UNSUPPORTED' : 'NODE_FAILED', message: last.message };
             return finish();
         }
         result.answer = answer;
@@ -612,7 +779,7 @@ async function runTurnInner(opts, control) {
     else {
         // ══ DELEGATE ═════════════════════════════════════════════════════════
         // Subagents are AgentTools; the orchestrator relays the answer it got.
-        const orchestrator = transform(await compileGraph(config, compileOpts));
+        const orchestrator = await compileRoot();
         let drained;
         answer = await runAgent({
             agent: orchestrator,
@@ -636,6 +803,9 @@ async function runTurnInner(opts, control) {
             if (pending)
                 return pause(pending);
         }
+        const consent = await awaitingConsent(config.orchestrator.name);
+        if (consent)
+            return consentPause(consent);
         const askedOrchestrator = asked(answer);
         if (askedOrchestrator)
             return askedOrchestrator;

package/dist/lib/session/supabaseSessionService.d.ts

@@ -1,26 +1,73 @@
+/**
+ * lib/session/supabaseSessionService.ts — sessions through supabase-js
+ * (the REST path ADR 0021 keeps for a transition period), for either
+ * runtime (ADR 0052, ADR 0058).
+ *
+ * One row per conversation in adk_sessions, its events as one JSON array
+ * that every append rewrites whole (the Postgres adapter keeps a row per
+ * event instead, lib/storage/postgres/sessionService.ts). Each event in the
+ * row is passed through trimEventForStorage (lib/session/transcript.ts).
+ *
+ * TWO FACES, ONE STORE:
+ *   The class is the engine's SessionService (create, get, list, delete,
+ *   append) and ADK's BaseSessionService (createSession, getSession, …), so
+ *   the ADK runtime and the native one read and write the same rows. The ADK
+ *   methods call the engine's, except appendEvent, which applies the event
+ *   to the runner's session through ADK's base service (its write-order
+ *   check included), where append uses applyEvent. Both write the row the
+ *   same way. The rules are lib/runtime/sessions.ts's:
+ *   - a create of an existing id returns the conversation unchanged, where
+ *     an upsert would reset it to no events;
+ *   - a list without a user id lists every user's sessions of the app, as
+ *     the Postgres adapter and ADK's own stores do;
+ *   - `afterTimestamp` is strict and filters before `numRecentEvents`
+ *     counts (selectEvents);
+ *   - lastUpdateTime is the appended event's timestamp, which is the clock
+ *     of the process that made the event, just before the append.
+ */
 import { BaseSessionService } from '@google/adk';
-import type { CreateSessionRequest, GetSessionRequest, ListSessionsRequest, ListSessionsResponse, DeleteSessionRequest, Session, Event } from '@google/adk';
+import type { CreateSessionRequest as AdkCreateSessionRequest, DeleteSessionRequest as AdkDeleteSessionRequest, Event as AdkEvent, GetSessionRequest as AdkGetSessionRequest, ListSessionsRequest as AdkListSessionsRequest, ListSessionsResponse as AdkListSessionsResponse, Session as AdkSession } from '@google/adk';
 import type { SupabaseClient } from '@supabase/supabase-js';
-export declare class SupabaseSessionService extends BaseSessionService {
+import type { TurnEvent } from '../runtime/events.ts';
+import type { CreateSessionRequest, GetSessionOptions, ListSessionsRequest, ListSessionsResult, Session, SessionKey, SessionService } from '../runtime/sessions.ts';
+export declare class SupabaseSessionService extends BaseSessionService implements SessionService {
     private supabase;
     constructor(supabaseClient: SupabaseClient);
     private getDbId;
-    createSession(request: CreateSessionRequest): Promise<Session>;
-    getSession(request: GetSessionRequest): Promise<Session | undefined>;
+    private expireAt;
+    create(request: CreateSessionRequest): Promise<Session>;
+    get(key: SessionKey, options?: GetSessionOptions): Promise<Session | undefined>;
     /**
-     * ADK's ListSessions contract carries paging: `limit` with either `page`
-     * (1-based, wins) or `offset` (0-based), plus an optional sort by last
-     * update, and the response must report where in the set the caller is.
-     * The window is pushed down to Postgres via .range(), and `count:
-     * 'exact'` returns the TOTAL matching rows alongside the page — so
-     * totalItems is the real total, not the slice length. With no `limit`,
-     * the whole set is one page, which is what the ADK's own docs specify
-     * ("Page size used. Equals `totalItems` when no limit was requested").
+     * Paging as listWindow and listPage state it. The window is pushed down
+     * to Postgres via .range(), and `count: 'exact'` returns the TOTAL
+     * matching rows alongside the page, so totalItems is the real total, not
+     * the slice length. Every user's sessions when `userId` is absent. By
+     * last update, ties by id, when an order is asked for; in the order the
+     * rows were created otherwise, so a page never depends on how Postgres
+     * happens to scan.
      */
-    listSessions(request: ListSessionsRequest): Promise<ListSessionsResponse>;
-    deleteSession(request: DeleteSessionRequest): Promise<void>;
+    list(request: ListSessionsRequest): Promise<ListSessionsResult>;
+    delete(key: SessionKey): Promise<void>;
+    append(session: Session, event: TurnEvent): Promise<TurnEvent>;
+    /**
+     * The caller's session, as it stands after the event, becomes the row.
+     *
+     * Trim on the SERIALIZED COPY only. The live session keeps thought
+     * signatures and real tool payloads — the agent's own tool loop reads
+     * them back mid-turn — but nothing reads them from the ROW: the
+     * projection drops both on the way into a prompt, and the memory service
+     * walks `part.text` alone. Across 128 live sessions they were ~90% of
+     * every byte stored (73% of it Gemini's `thoughtSignature`), and this
+     * re-uploads the whole array on every event, so those bytes were paid for
+     * again on each one. See trimEventForStorage.
+     */
+    private write;
+    createSession(request: AdkCreateSessionRequest): Promise<AdkSession>;
+    getSession(request: AdkGetSessionRequest): Promise<AdkSession | undefined>;
+    listSessions(request: AdkListSessionsRequest): Promise<AdkListSessionsResponse>;
+    deleteSession(request: AdkDeleteSessionRequest): Promise<void>;
     appendEvent(request: {
-        session: Session;
-        event: Event;
-    }): Promise<Event>;
+        session: AdkSession;
+        event: AdkEvent;
+    }): Promise<AdkEvent>;
 }