melchizedek-agents 1.0.0 → 1.0.2

package/dist/lib/runtime/adkMemoryBridge.d.ts

@@ -1,46 +0,0 @@
-/**
- * lib/runtime/adkMemoryBridge.ts — one memory service, either runtime
- * (ADR 0059, ADR 0080).
- *
- * WHY this file exists:
- *   Until ADK leaves at 1.0, the ADK runtime and ingestTurnMemory call ADK's
- *   BaseMemoryService methods (searchMemory, addSessionToMemory), and the
- *   native runtime the engine's MemoryService (lib/runtime/memoryService.ts:
- *   search, ingest). The engine's service implements both (ADR 0059 item 1),
- *   so it passes through here unchanged, and so does a consumer's ADK
- *   service. A service that implements only the engine's interface gets
- *   ADK's face from MemoryServiceForAdk: ADK's two methods hand their
- *   arguments to the engine's, as the engine's own service does.
- *
- *   The bridge is applied at the seam, where a surface hands its service to
- *   the turn runner; the A2A server keeps the service it was given for its
- *   by-name checks (verifyEmbeddingDimensions, pruneExpired,
- *   deleteUserMemory), and the bridge forwards those too.
- *
- * This module imports ADK's types only, and loads nothing at run time.
- */
-import type { BaseMemoryService, SearchMemoryRequest, SearchMemoryResponse, Session as AdkSession } from '@google/adk';
-import type { MemoryService } from './memoryService.ts';
-/** ADK's memory service, named here so a surface never imports ADK for the type. */
-export type AdkMemoryService = BaseMemoryService;
-/** A memory service with either face: what a surface takes from its caller. */
-export type EitherMemoryService = MemoryService | BaseMemoryService;
-/** The engine's two methods. */
-export declare function isMemoryService(value: unknown): value is MemoryService;
-/** ADK's two methods. A duck check, so a service built against another copy of ADK still counts. */
-export declare function isAdkMemoryService(value: unknown): value is BaseMemoryService;
-/** ADK's BaseMemoryService over an engine MemoryService. */
-export declare class MemoryServiceForAdk implements BaseMemoryService {
-    readonly service: MemoryService;
-    readonly deleteUserMemory?: (userKey: string) => Promise<number>;
-    readonly pruneExpired?: (namespace: string, days: number) => Promise<number | null>;
-    readonly verifyEmbeddingDimensions?: () => Promise<void>;
-    constructor(service: MemoryService);
-    /** The extraction rules and model ingestTurnMemory passes, as the engine's service takes them. */
-    addSessionToMemory(session: AdkSession, extractionRules?: string, options?: {
-        extractionModel?: string;
-    }): Promise<void>;
-    searchMemory(request: SearchMemoryRequest): Promise<SearchMemoryResponse>;
-}
-/** The service as the ADK runtime takes it: itself when it already has ADK's face. */
-export declare function asAdkMemoryService(service: EitherMemoryService): BaseMemoryService;

package/dist/lib/runtime/adkMemoryBridge.js

@@ -1,68 +0,0 @@
-/**
- * lib/runtime/adkMemoryBridge.ts — one memory service, either runtime
- * (ADR 0059, ADR 0080).
- *
- * WHY this file exists:
- *   Until ADK leaves at 1.0, the ADK runtime and ingestTurnMemory call ADK's
- *   BaseMemoryService methods (searchMemory, addSessionToMemory), and the
- *   native runtime the engine's MemoryService (lib/runtime/memoryService.ts:
- *   search, ingest). The engine's service implements both (ADR 0059 item 1),
- *   so it passes through here unchanged, and so does a consumer's ADK
- *   service. A service that implements only the engine's interface gets
- *   ADK's face from MemoryServiceForAdk: ADK's two methods hand their
- *   arguments to the engine's, as the engine's own service does.
- *
- *   The bridge is applied at the seam, where a surface hands its service to
- *   the turn runner; the A2A server keeps the service it was given for its
- *   by-name checks (verifyEmbeddingDimensions, pruneExpired,
- *   deleteUserMemory), and the bridge forwards those too.
- *
- * This module imports ADK's types only, and loads nothing at run time.
- */
-/** The engine's two methods. */
-export function isMemoryService(value) {
-    const v = value;
-    return typeof v === 'object' && v !== null && typeof v.ingest === 'function' && typeof v.search === 'function';
-}
-/** ADK's two methods. A duck check, so a service built against another copy of ADK still counts. */
-export function isAdkMemoryService(value) {
-    const v = value;
-    return (typeof v === 'object' && v !== null &&
-        typeof v.addSessionToMemory === 'function' && typeof v.searchMemory === 'function');
-}
-/** ADK's BaseMemoryService over an engine MemoryService. */
-export class MemoryServiceForAdk {
-    service;
-    deleteUserMemory;
-    pruneExpired;
-    verifyEmbeddingDimensions;
-    constructor(service) {
-        this.service = service;
-        // The optional extras, only when the service has them: the A2A server
-        // checks for each by name.
-        if (service.deleteUserMemory)
-            this.deleteUserMemory = (userKey) => service.deleteUserMemory(userKey);
-        if (service.pruneExpired)
-            this.pruneExpired = (namespace, days) => service.pruneExpired(namespace, days);
-        if (service.verifyEmbeddingDimensions)
-            this.verifyEmbeddingDimensions = () => service.verifyEmbeddingDimensions();
-    }
-    /** The extraction rules and model ingestTurnMemory passes, as the engine's service takes them. */
-    async addSessionToMemory(session, extractionRules, options) {
-        await this.service.ingest(session, {
-            ...(extractionRules !== undefined ? { extractionRules } : {}),
-            ...(options?.extractionModel !== undefined ? { extractionModel: options.extractionModel } : {}),
-        });
-    }
-    async searchMemory(request) {
-        return (await this.service.search({ appName: request.appName, userId: request.userId, query: request.query }));
-    }
-}
-/** The service as the ADK runtime takes it: itself when it already has ADK's face. */
-export function asAdkMemoryService(service) {
-    if (isAdkMemoryService(service))
-        return service;
-    if (isMemoryService(service))
-        return new MemoryServiceForAdk(service);
-    throw new TypeError('Not a memory service: it implements neither MemoryService nor ADK\'s BaseMemoryService.');
-}

package/dist/lib/runtime/adkSessionBridge.d.ts

@@ -1,78 +0,0 @@
-/**
- * lib/runtime/adkSessionBridge.ts — one session store, either runtime
- * (ADR 0045, ADR 0052, ADR 0058).
- *
- * WHY this file exists:
- *   Until ADK leaves at 1.0, the ADK runtime asks for ADK's
- *   BaseSessionService and the native runtime for the engine's
- *   SessionService (lib/runtime/sessions.ts). The durable stores and the
- *   transcript projection implement both, so they need no bridge. A store
- *   that implements only one of them gets the other here:
- *   - SessionServiceForAdk: the ADK runtime on an engine store, such as
- *     InProcessSessionService.
- *   - AdkSessionServiceForEngine: the engine's interface on an ADK store,
- *     such as ADK's InMemorySessionService, with the interface's meaning
- *     where ADK's store has another (sessions.ts, "ONE MEANING ACROSS
- *     STORES").
- *   asAdkSessionService and asSessionService hand a store back as it is
- *   when it already implements the face asked for, and a bridge back as the
- *   store it wraps, so a store bridged one way and then back is itself.
- *   A surface that takes a store from its caller (the A2A executor and app,
- *   the REPL) types it as EitherSessionService and asks for the face it
- *   needs here (ADR 0080).
- *
- * APPEND: each face keeps its own runtime's rules for the caller's session.
- *   The ADK face applies an event to the runner's session through ADK's
- *   base service, write-order check and all, exactly as the durable stores
- *   do, and the store records it on a copy. The engine face applies it
- *   through applyEvent, which never changes the caller's event, and hands
- *   ADK's store a copy.
- *
- * This module loads ADK at run time, so it is not one of the engine's leaf
- * modules (tests/events.test.ts names those).
- */
-import { BaseSessionService } from '../adkPeer.ts';
-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 { TurnEvent } from './events.ts';
-import type { CreateSessionRequest, GetSessionOptions, ListSessionsRequest, ListSessionsResult, Session, SessionKey, SessionService } from './sessions.ts';
-/** ADK's session service, named here so a surface never imports ADK for the type (ADR 0080). */
-export type AdkSessionService = BaseSessionService;
-/** A session store with either face: what a surface takes from its caller. */
-export type EitherSessionService = SessionService | BaseSessionService;
-/** Every method the engine's interface names. */
-export declare function isSessionService(value: unknown): value is SessionService;
-/**
- * Every method ADK's runner and services call. A duck check rather than
- * instanceof, so a store built against another copy of ADK still counts.
- */
-export declare function isAdkSessionService(value: unknown): value is BaseSessionService;
-/** ADK's BaseSessionService over an engine SessionService. */
-export declare class SessionServiceForAdk extends BaseSessionService {
-    readonly service: SessionService;
-    constructor(service: SessionService);
-    createSession(request: AdkCreateSessionRequest): Promise<AdkSession>;
-    getSession(request: AdkGetSessionRequest): Promise<AdkSession | undefined>;
-    listSessions(request: AdkListSessionsRequest): Promise<AdkListSessionsResponse>;
-    deleteSession(request: AdkDeleteSessionRequest): Promise<void>;
-    appendEvent({ session, event }: {
-        session: AdkSession;
-        event: AdkEvent;
-    }): Promise<AdkEvent>;
-}
-/** The engine's SessionService over an ADK BaseSessionService. */
-export declare class AdkSessionServiceForEngine implements SessionService {
-    readonly service: BaseSessionService;
-    constructor(service: BaseSessionService);
-    /** A session that exists comes back unchanged: ADK's own store would reset it. */
-    create(request: CreateSessionRequest): Promise<Session>;
-    /** Reads the whole session and filters it here, so `options` mean what the interface says. */
-    get(key: SessionKey, options?: GetSessionOptions): Promise<Session | undefined>;
-    /** The window goes to ADK's store as an offset; the paging figures are the interface's. */
-    list(request: ListSessionsRequest): Promise<ListSessionsResult>;
-    delete(key: SessionKey): Promise<void>;
-    append(session: Session, event: TurnEvent): Promise<TurnEvent>;
-}
-/** The store as the ADK runtime takes it: itself when it already is one. */
-export declare function asAdkSessionService(service: EitherSessionService): BaseSessionService;
-/** The store as the engine's interface: itself when it already is one. */
-export declare function asSessionService(service: EitherSessionService): SessionService;

package/dist/lib/runtime/adkSessionBridge.js

@@ -1,176 +0,0 @@
-/**
- * lib/runtime/adkSessionBridge.ts — one session store, either runtime
- * (ADR 0045, ADR 0052, ADR 0058).
- *
- * WHY this file exists:
- *   Until ADK leaves at 1.0, the ADK runtime asks for ADK's
- *   BaseSessionService and the native runtime for the engine's
- *   SessionService (lib/runtime/sessions.ts). The durable stores and the
- *   transcript projection implement both, so they need no bridge. A store
- *   that implements only one of them gets the other here:
- *   - SessionServiceForAdk: the ADK runtime on an engine store, such as
- *     InProcessSessionService.
- *   - AdkSessionServiceForEngine: the engine's interface on an ADK store,
- *     such as ADK's InMemorySessionService, with the interface's meaning
- *     where ADK's store has another (sessions.ts, "ONE MEANING ACROSS
- *     STORES").
- *   asAdkSessionService and asSessionService hand a store back as it is
- *   when it already implements the face asked for, and a bridge back as the
- *   store it wraps, so a store bridged one way and then back is itself.
- *   A surface that takes a store from its caller (the A2A executor and app,
- *   the REPL) types it as EitherSessionService and asks for the face it
- *   needs here (ADR 0080).
- *
- * APPEND: each face keeps its own runtime's rules for the caller's session.
- *   The ADK face applies an event to the runner's session through ADK's
- *   base service, write-order check and all, exactly as the durable stores
- *   do, and the store records it on a copy. The engine face applies it
- *   through applyEvent, which never changes the caller's event, and hands
- *   ADK's store a copy.
- *
- * This module loads ADK at run time, so it is not one of the engine's leaf
- * modules (tests/events.test.ts names those).
- */
-import { BaseSessionService } from '../adkPeer.js';
-import { applyEvent, listPage, listWindow, selectEvents, withoutTempKeys } from './sessions.js';
-/** Every method the engine's interface names. */
-export function isSessionService(value) {
-    const v = value;
-    return (typeof v === 'object' && v !== null &&
-        typeof v.create === 'function' && typeof v.get === 'function' && typeof v.list === 'function' &&
-        typeof v.delete === 'function' && typeof v.append === 'function');
-}
-/**
- * Every method ADK's runner and services call. A duck check rather than
- * instanceof, so a store built against another copy of ADK still counts.
- */
-export function isAdkSessionService(value) {
-    const v = value;
-    return (typeof v === 'object' && v !== null &&
-        typeof v.createSession === 'function' && typeof v.getSession === 'function' &&
-        typeof v.listSessions === 'function' && typeof v.deleteSession === 'function' &&
-        typeof v.appendEvent === 'function');
-}
-/**
- * A copy a store may apply an event to without touching the caller's
- * session: applyEvent and ADK's base service change only `state`'s keys,
- * the `events` array and `lastUpdateTime`.
- */
-function shadowOf(session) {
-    return { ...session, state: { ...session.state }, events: [...session.events] };
-}
-/** The key fields only: a request object can carry more. */
-function keyOf(request) {
-    return { appName: request.appName, userId: request.userId, sessionId: request.sessionId };
-}
-// ── The ADK runtime on an engine store ───────────────────────────────────────
-/** ADK's BaseSessionService over an engine SessionService. */
-export class SessionServiceForAdk extends BaseSessionService {
-    service;
-    constructor(service) {
-        super();
-        this.service = service;
-    }
-    async createSession(request) {
-        return (await this.service.create(request));
-    }
-    async getSession(request) {
-        return (await this.service.get(keyOf(request), request.config));
-    }
-    async listSessions(request) {
-        return (await this.service.list(request));
-    }
-    async deleteSession(request) {
-        await this.service.delete(keyOf(request));
-    }
-    async appendEvent({ session, event }) {
-        if (event.partial)
-            return event;
-        // The store applies the event once, to the session as it stood.
-        const before = shadowOf(session);
-        await super.appendEvent({ session, event });
-        session.lastUpdateTime = event.timestamp;
-        await this.service.append(before, event);
-        return event;
-    }
-}
-// ── The engine's interface on an ADK store ───────────────────────────────────
-/** The engine's SessionService over an ADK BaseSessionService. */
-export class AdkSessionServiceForEngine {
-    service;
-    constructor(service) {
-        this.service = service;
-    }
-    /** A session that exists comes back unchanged: ADK's own store would reset it. */
-    async create(request) {
-        if (request.sessionId) {
-            const existing = await this.get({ appName: request.appName, userId: request.userId, sessionId: request.sessionId });
-            if (existing)
-                return existing;
-        }
-        const created = await this.service.createSession({
-            appName: request.appName,
-            userId: request.userId,
-            sessionId: request.sessionId,
-            state: withoutTempKeys(request.state ?? {}),
-        });
-        return created;
-    }
-    /** Reads the whole session and filters it here, so `options` mean what the interface says. */
-    async get(key, options) {
-        const held = (await this.service.getSession(keyOf(key)));
-        if (!held)
-            return undefined;
-        return { ...held, events: selectEvents(held.events, options) };
-    }
-    /** The window goes to ADK's store as an offset; the paging figures are the interface's. */
-    async list(request) {
-        const { offset, limit } = listWindow(request);
-        const listed = await this.service.listSessions({
-            appName: request.appName,
-            userId: request.userId,
-            order: request.order,
-            offset,
-            limit,
-        });
-        return {
-            sessions: listed.sessions.map((s) => ({ ...s, events: [] })),
-            ...listPage(listed.totalItems, request),
-        };
-    }
-    async delete(key) {
-        await this.service.deleteSession(keyOf(key));
-    }
-    async append(session, event) {
-        if (event.partial)
-            return event;
-        // ADK's base service applies an event to the session it is given and
-        // rewrites the event's delta in place, so ADK's store gets copies of
-        // both, and the session as it stood.
-        const before = shadowOf(session);
-        const stored = applyEvent(session, event);
-        await this.service.appendEvent({ session: before, event: structuredClone(stored) });
-        return stored;
-    }
-}
-// ── Either face of a store ───────────────────────────────────────────────────
-/** The store as the ADK runtime takes it: itself when it already is one. */
-export function asAdkSessionService(service) {
-    if (service instanceof AdkSessionServiceForEngine)
-        return service.service;
-    if (isAdkSessionService(service))
-        return service;
-    if (isSessionService(service))
-        return new SessionServiceForAdk(service);
-    throw new TypeError('Not a session service: it implements neither SessionService nor ADK\'s BaseSessionService.');
-}
-/** The store as the engine's interface: itself when it already is one. */
-export function asSessionService(service) {
-    if (service instanceof SessionServiceForAdk)
-        return service.service;
-    if (isSessionService(service))
-        return service;
-    if (isAdkSessionService(service))
-        return new AdkSessionServiceForEngine(service);
-    throw new TypeError('Not a session service: it implements neither SessionService nor ADK\'s BaseSessionService.');
-}

package/dist/lib/tools/adkTool.d.ts

@@ -1,81 +0,0 @@
-/**
- * lib/tools/adkTool.ts — the boundary where an own Tool becomes an ADK tool.
- *
- * WHY this file exists:
- *   Tools are the engine's own (lib/tools/tool.ts, ADR 0051): a name, the
- *   declaration the model receives, and `execute(args, ctx)`. Until 1.0.0
- *   removes ADK (ADR 0045) the ADK runtime runs the same tools, and this
- *   module is the one place that turns a Tool into what ADK consumes: a
- *   FunctionTool whose Gemini-dialect parameters come from the Tool's
- *   declaration, and whose execute hands the Tool a ToolContext read from
- *   ADK's own Context. Nothing else in lib/tools builds an ADK tool from an
- *   own Tool, and tool.ts and toolContract.ts import nothing from ADK.
- *
- *   The ADK runtime behaves as it did when every tool was a FunctionTool:
- *   - the declaration ADK sends is the Tool's, in Gemini's dialect
- *     (toGeminiSchema), so contractToolDeclaration reads the same
- *     parameters through either path;
- *   - a long-running Tool is a long-running FunctionTool, and its pending
- *     (undefined) result is the null response ADK waits on;
- *   - a Tool that requires approval sets FunctionTool's own gate, which
- *     raises `adk_request_confirmation` as lib/compile.ts's gate does;
- *   - a Tool that throws becomes ADK's `Error in tool '<name>': …` response;
- *   - a Tool's `instruction`, and an InstructionTool's, are appended to the
- *     request's system instruction in the tool's processLlmRequest, joined
- *     as ADK's own appendInstructions joins them, at the tool's place in the
- *     agent's list: where ADK's load_memory and preload_memory wrote theirs
- *     (ADR 0059);
- *   - the context reaches the run's memory through ADK's own
- *     `Context.searchMemory`, so a search reads the silo ADK's tools read;
- *   - a NativeToolMarker is the shared sentinel the ADK runtime always ran
- *     for that server-side tool, which carries the same marker (ADR 0062);
- *   - a Tool's `contents` hook adds to the request's history in the tool's
- *     processLlmRequest, where ADK's load_skill_resource added a binary
- *     file (ADR 0083);
- *   - an own Toolset (the skills harness) is a BaseToolset whose getTools
- *     lists the Toolset's tools for ADK's ReadonlyContext, each through
- *     toAdkTool (ADR 0083).
- *
- *   toAdkTool takes any of these and picks the wrapper.
- */
-import { BaseTool, BaseToolset, FunctionTool } from '../adkPeer.ts';
-import type { InstructionTool, NativeToolMarker, Tool, ToolContext, Toolset } from './tool.ts';
-import type { ToolContract } from './toolContract.ts';
-/** The ToolContext for one ADK call; a standalone one outside a run. */
-export declare function adkToolContext(adkContext: unknown): ToolContext;
-/**
- * ADK surface: a FunctionTool that runs `tool`. Its Gemini-dialect
- * parameters derive from the Tool's declaration (for a defineTool contract,
- * from the zod schema), and its execute runs the Tool, which validates its
- * own arguments. Non-Gemini providers keep receiving the schema through
- * schemaNormalize.toLowercaseJsonSchema() at request-build time.
- *
- * Takes a Tool, or a hand-built contract object, which defineTool makes a
- * Tool first. The FunctionTool carries the Tool (toolOf in lib/tools/tool.ts
- * reads it back), so a runtime that resolves names through the registry can
- * run the Tool itself.
- */
-export declare function toFunctionTool(tool: ToolContract<any>): FunctionTool;
-export declare function toFunctionTool(tool: Tool): FunctionTool;
-/**
- * ADK surface for an InstructionTool: a BaseTool that declares no function,
- * so it never enters the request's tools, and appends the InstructionTool's
- * text in processLlmRequest, where ADK's PreloadMemoryTool appended its own.
- * instructionToolOf (lib/tools/tool.ts) reads the InstructionTool back.
- */
-export declare function toAdkInstructionTool(tool: InstructionTool): BaseTool;
-/**
- * ADK surface for a NativeToolMarker: the shared sentinel the ADK runtime
- * has always run for it, which during processLlmRequest leaves itself in
- * the request for the adapter (or adds Gemini's own tool object).
- */
-export declare function toAdkNativeTool(marker: NativeToolMarker): BaseTool;
-/** ADK surface for an own Toolset: a BaseToolset carrying it. */
-export declare function toAdkToolset(toolset: Toolset): BaseToolset;
-/**
- * What the engine holds as a tool, as the ADK runtime consumes it: a Tool
- * or a defineTool contract through toFunctionTool, an InstructionTool
- * through toAdkInstructionTool, a NativeToolMarker through toAdkNativeTool.
- * An ADK tool (one with runAsync) passes through as it is.
- */
-export declare function toAdkTool(tool: Tool | ToolContract<any> | InstructionTool | NativeToolMarker | BaseTool): BaseTool;