melchizedek-agents 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -6,6 +6,22 @@ the starter pack and the templates), not the repo's full history.
 
 ## Unreleased
 
+## 1.0.1 — 2026-10-08
+
+### Fixed
+
+- **The published package carries only this release's build.** `npm run
+  build` (which `npm pack` and `npm publish` run) now empties `dist/`
+  before compiling. 1.0.0 was packed from a checkout whose `dist/` still
+  held files from older builds, so its tarball carried 40 stale modules the
+  1.0.0 source no longer has (among them `models/adkShim`, the ADK
+  `*Llm` classes, `models/tracedGemini`, `models/fallback`,
+  `tools/adkTool`, `tools/webSearchTool`, `runtime/adkSessionBridge`).
+  The `./models/*` and `./tools/*` export patterns made them importable,
+  and they load `@google/adk`, which 1.0.0 removed. Everything 1.0.0
+  documents was built from its own source; only those extra files were
+  wrong. Use 1.0.1; 1.0.0 is deprecated.
+
 ## 1.0.0 — 2026-10-08
 
 Release 1.0.0: Google ADK is gone (ADR 0107). Every turn runs on the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melchizedek-agents",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A multi-model, multi-agent orchestration framework — YAML-defined syndicates on the engine's own agent loop, Supabase or Postgres session persistence, pgvector long-term memory. Companion repo to the lyceumagents.com curriculum.",
   "type": "module",
   "license": "MIT",
@@ -72,7 +72,7 @@
     "skills"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json",
     "prepack": "npm run build",
     "prepare": "npm run build",
     "prepublishOnly": "npm test",

package/dist/lib/adkPeer.d.ts

@@ -1,63 +0,0 @@
-/**
- * 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

@@ -1,240 +0,0 @@
-/**
- * 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();

package/dist/lib/compileAdk.d.ts

@@ -1,32 +0,0 @@
-/**
- * lib/compileAdk.ts — an AgentSpec as the ADK runtime runs it: today's
- * LlmAgent (ADR 0045, ADR 0073).
- *
- * WHY this file exists:
- *   lib/compile.ts turns a YAML agent into a runtime-neutral AgentSpec: its
- *   tools resolved and gated, its instruction with the skills index, its
- *   model resolved once and its generateContentConfig built for that model.
- *   This file adds what only ADK's LlmAgent takes: the model wrapped in a
- *   FallbackLlm for `fallback_model:`, each delegated subagent as an
- *   AgentTool (a nested workflow's whole Workflow too; a remote one as its
- *   A2A tool), Gemini's code executor, the
- *   context compactor, task mode and a workflow node's settings. Every field
- *   reaches LlmAgent as compileGraph and compileSubagent always passed it, so
- *   the ADK runtime runs the agent it ran before the split.
- *   lib/compileNative.ts builds the native loop's agent from the same spec.
- *
- * Imports from lib/compile.ts are types only. A nested workflow's Workflow
- * comes from lib/workflow.ts (assembleWorkflow, ADR 0098), which imports
- * lib/compile.ts; every use of either is inside a function, so the modules
- * load in any order.
- */
-import type { LlmAgent } from '@google/adk';
-import type { AgentSpec, CompileOptions } from './compile.ts';
-import { DEFAULT_KEEP_RECENT_EVENTS } from './runtime/native/compaction.ts';
-/** Events kept verbatim after a compaction summary when `context:` names none: the native compactor's default. */
-export { DEFAULT_KEEP_RECENT_EVENTS };
-/**
- * The LlmAgent for `spec`. `extra` is spread last: a workflow node's
- * settings (CompileOptions.nodeConfig), which compileSubagent passes.
- */
-export declare function compileAdk(spec: AgentSpec, opts?: CompileOptions, extra?: Record<string, unknown>): LlmAgent;

package/dist/lib/compileAdk.js

@@ -1,142 +0,0 @@
-/**
- * lib/compileAdk.ts — an AgentSpec as the ADK runtime runs it: today's
- * LlmAgent (ADR 0045, ADR 0073).
- *
- * WHY this file exists:
- *   lib/compile.ts turns a YAML agent into a runtime-neutral AgentSpec: its
- *   tools resolved and gated, its instruction with the skills index, its
- *   model resolved once and its generateContentConfig built for that model.
- *   This file adds what only ADK's LlmAgent takes: the model wrapped in a
- *   FallbackLlm for `fallback_model:`, each delegated subagent as an
- *   AgentTool (a nested workflow's whole Workflow too; a remote one as its
- *   A2A tool), Gemini's code executor, the
- *   context compactor, task mode and a workflow node's settings. Every field
- *   reaches LlmAgent as compileGraph and compileSubagent always passed it, so
- *   the ADK runtime runs the agent it ran before the split.
- *   lib/compileNative.ts builds the native loop's agent from the same spec.
- *
- * Imports from lib/compile.ts are types only. A nested workflow's Workflow
- * comes from lib/workflow.ts (assembleWorkflow, ADR 0098), which imports
- * lib/compile.ts; every use of either is inside a function, so the modules
- * load in any order.
- */
-import { BaseLlm, adk, requireAdk } from './adkPeer.js';
-import { remoteAgentTool } from './a2a/remoteAgent.js';
-import { assembleWorkflow } from './workflow.js';
-import { FallbackLlm } from './models/fallback.js';
-import { resolveModel as resolveRegistryModel } from './models/registry.js';
-import { onLogLevel } from './runtime/logging.js';
-import { DEFAULT_KEEP_RECENT_EVENTS } from './runtime/native/compaction.js';
-/**
- * ADK's logger follows the engine's level (lib/runtime/logging.ts, ADR
- * 0080), so a surface sets one level and never names ADK to quiet it.
- */
-if (adk) {
-    const { LogLevel: Level, setLogLevel } = adk;
-    const levels = { debug: Level.DEBUG, info: Level.INFO, warn: Level.WARN, error: Level.ERROR };
-    onLogLevel((level) => setLogLevel(levels[level]));
-}
-/** What compileAdk builds needs @google/adk; without it, this names the package (ADR 0102). */
-const FEATURE = 'Compiling an agent for the ADK runtime (MELCHIZEDEK_RUNTIME=adk, compileGraph, compileSubagent)';
-/** Events kept verbatim after a compaction summary when `context:` names none: the native compactor's default. */
-export { DEFAULT_KEEP_RECENT_EVENTS };
-/**
- * The LlmAgent fields a YAML agent may set beyond model, instruction, tools
- * and schemas. The schema reference (config/agents/syndicateSchema.yaml)
- * documents each as mapping 1:1 to its ADK counterpart. Only fields the YAML
- * sets are passed, so ADK's defaults stay in force otherwise.
- */
-function passthroughFields(spec) {
-    const out = {};
-    if (spec.includeContents !== undefined)
-        out.includeContents = spec.includeContents;
-    if (spec.outputKey !== undefined)
-        out.outputKey = spec.outputKey;
-    if (spec.globalInstruction !== undefined)
-        out.globalInstruction = spec.globalInstruction;
-    if (spec.disallowTransferToParent !== undefined)
-        out.disallowTransferToParent = spec.disallowTransferToParent;
-    if (spec.disallowTransferToPeers !== undefined)
-        out.disallowTransferToPeers = spec.disallowTransferToPeers;
-    return out;
-}
-/**
- * The LlmAgent fields the engine builds from YAML rather than passing
- * through (ADR 0033): `code_execution: gemini` (Gemini's server-side
- * sandbox runs the model's Python; nothing runs on this host), `context:`
- * (ADK's token-based compactor with an LLM summarizer, so a long
- * conversation is summarized instead of overflowing the window), and
- * `mode: task` (the agent works until it calls finish_task; on a workflow
- * node, its arguments become the node's output).
- */
-function executionFields(cfg, opts) {
-    const { BuiltInCodeExecutor, LLMRegistry, LlmSummarizer, TokenBasedContextCompactor } = requireAdk(FEATURE);
-    const out = {};
-    if (cfg.codeExecution === 'gemini')
-        out.codeExecutor = new BuiltInCodeExecutor();
-    if (cfg.mode)
-        out.mode = cfg.mode;
-    if (cfg.context) {
-        const resolve = opts.resolveModel ?? ((m) => m);
-        const summaryModel = resolve(cfg.context.summary_model ?? cfg.model);
-        const llm = typeof summaryModel === 'string' || !summaryModel ? LLMRegistry.newLlm(String(summaryModel ?? cfg.model)) : summaryModel;
-        out.contextCompactors = [
-            new TokenBasedContextCompactor({
-                tokenThreshold: cfg.context.compact_after_tokens,
-                eventRetentionSize: cfg.context.keep_recent_events ?? DEFAULT_KEEP_RECENT_EVENTS,
-                summarizer: new LlmSummarizer({ llm }),
-            }),
-        ];
-    }
-    return out;
-}
-/**
- * An agent with `fallback_model:` gets its model wrapped (lib/models/fallback.ts):
- * the fallback answers a provider-side failure, and a provider that keeps
- * failing is skipped for a cooldown. A model id string is resolved to its
- * adapter first, so the wrapper always holds two adapters.
- */
-function withFallback(primary, fallbackId, opts) {
-    if (!fallbackId)
-        return primary;
-    const resolve = opts.resolveModel ?? ((m) => m);
-    const asLlm = (m) => (m instanceof BaseLlm ? m : resolveRegistryModel(String(m)));
-    return new FallbackLlm(asLlm(primary), asLlm(resolve(fallbackId)), opts.log ?? ((m) => console.warn(m)));
-}
-/** The spec's tools as LlmAgent takes them: a delegated subagent (a nested workflow's Workflow included) as an AgentTool, a remote one as its A2A tool. */
-function adkTools(spec, opts) {
-    const { AgentTool } = requireAdk(FEATURE);
-    return spec.tools.map((entry) => {
-        switch (entry.kind) {
-            case 'tool':
-                return entry.tool;
-            case 'agent':
-                return new AgentTool({ agent: compileAdk(entry.agent, opts) });
-            case 'remote':
-                return remoteAgentTool({ name: entry.name, description: entry.description, url: entry.url });
-            case 'workflow':
-                // ADK's AgentTool runs any node its Runner takes, a Workflow included: the whole graph, its last event's text the answer (ADR 0098).
-                return new AgentTool({ agent: assembleWorkflow(entry.workflow, opts).workflow });
-        }
-    });
-}
-/**
- * The LlmAgent for `spec`. `extra` is spread last: a workflow node's
- * settings (CompileOptions.nodeConfig), which compileSubagent passes.
- */
-export function compileAdk(spec, opts = {}, extra = {}) {
-    const { LlmAgent } = requireAdk(FEATURE);
-    const tools = adkTools(spec, opts);
-    return new LlmAgent({
-        name: spec.name,
-        description: spec.description,
-        model: withFallback(spec.resolvedModel, spec.fallbackModel, opts),
-        instruction: spec.instruction,
-        tools: tools.length > 0 ? tools : undefined,
-        outputSchema: spec.outputSchema,
-        generateContentConfig: spec.generateContentConfig,
-        ...passthroughFields(spec),
-        ...executionFields(spec, opts),
-        ...extra,
-    });
-}

package/dist/lib/models/adkGeminiAdapter.d.ts

@@ -1,90 +0,0 @@
-/**
- * lib/models/adkGeminiAdapter.ts — TEMPORARY: Gemini as a contract
- * ModelAdapter (ADR 0048) over ADK's own Gemini, the TracedGemini path of
- * lib/models/tracedGemini.ts, through the genai mapping (lib/models/genaiMapping.ts).
- *
- * WHY this file exists:
- *   The native loop (ADR 0045) calls ModelAdapters only. The engine's own
- *   Gemini adapter (lib/models/geminiAdapter.ts) calls @google/genai with no
- *   ADK, and waits for its live parity run at gate G3. Until it passes,
- *   Gemini on the native runtime goes through ADK's proven Gemini, wrapped
- *   here, so every provider has a contract adapter before gate G1. Delete
- *   this file once G3 is signed and GeminiAdapter serves every Gemini id
- *   (the plan's G3 risk: "The WS1-8 wrapper over ADK's Gemini stays until
- *   the cells pass"). resolveAdapter (lib/models/registry.ts) returns it for Gemini ids.
- *
- * THE CALL:
- *   1. The ModelRequest becomes an LlmRequest (modelRequestToLlmRequest),
- *      and then what ADK's path does to one before its Gemini sees it:
- *        - system messages joined onto the system prompt, in order, since
- *          Gemini takes no `system` content;
- *        - `adk-` call ids taken off calls and results, as ADK's flow does
- *          before every model call (ids the mapping minted are already off);
- *        - `includeServerSideToolInvocations`, which the compiler sends on
- *          every Gemini agent (lib/compile.ts);
- *        - `includeThoughts` under any reasoning but `none`, the contract's
- *          Gemini table, as GeminiAdapter sends it;
- *        - the platform's wire model (GEMINI_MODEL_MAP), as TracedGemini's own.
- *      The request is copied where ADK writes to it (a blob's display name),
- *      so the caller's history is never changed.
- *   2. TracedGemini.generateWithRetries runs it: ADK's Gemini with the
- *      shared retries, tagging the span that is open around this adapter
- *      (llm.web_search.native, llm.retries, llm.http_status), as it tags its
- *      own. `llm.capability.dropped` marks native tools Gemini has none for.
- *   3. Each LlmResponse comes back through llmResponseToModelResponse,
- *      folded into the contract's stream. A thought signature becomes
- *      providerState naming the request's model. A call Gemini returns
- *      without an id gets the mapping's `genai-noid-<position>-<part>`, or,
- *      streamed, ADK's own `adk-` id; neither goes back on the wire.
- *
- * REPLAY: every Gemini signature in the history goes back on its part, as
- * ADK sends a stored session's, whichever turn or model wrote it.
- * GeminiAdapter replays only the current turn's, for its own model.
- *
- * THE SPAN AND THE CHARGE are the caller's (ADR 0053): this adapter opens no
- * llm.request span and never charges the turn. Behind the ADK shim
- * (lib/models/adkShim.ts) it records the span TracedGemini records today for
- * the same exchange, but for a failed call's code (tests/telemetryLedger.test.ts).
- *
- * THE ADAPTER RULES (contract.ts header) as this adapter keeps them:
- *   - Partials: a streamed call's text and thinking deltas, as ADK's stream
- *     aggregator yields them. A call that does not stream yields its
- *     thinking as one partial before the final.
- *   - One final: every non-partial response ADK yields for the call (its
- *     aggregator flushes the text before each tool call) folds into it, with
- *     the last usage, grounding and finish reason.
- *   - Errors are finals, never throws. ADK's Gemini throws on a failed call:
- *     that is GEMINI_ERROR, `retryable` from lib/models/retry.ts's
- *     classifyError, `status` when the error had one. An error code ADK
- *     yields (a finish or block reason) is the code, not retryable; ADK's
- *     `STOP` is no error. Setup failures are MISSING_API_KEY and
- *     ENDPOINT_MISCONFIGURED, as GeminiAdapter's.
- *   - The abort: `request.signal` (the shim aborts it when the turn stops)
- *     goes on the request config. An aborted call is GEMINI_ERROR, never
- *     retryable, and the iteration ends at once whatever the transport does;
- *     a signal aborted before the call sends nothing.
- *   - Retries: TracedGemini's, only before the first chunk.
- *   - Messages never carry the key in use or anything shaped like a key.
- */
-import type { ModelAdapter, ModelRequest, ModelResponse } from './contract.ts';
-import type { ProviderEndpoint } from './endpoints.ts';
-export interface AdkGeminiAdapterOptions {
-    /** The model id as the YAML names it. */
-    model: string;
-    /**
-     * A Gemini API (AI Studio) key: a caller's own, or one the credentials plug
-     * point returned. It wins over the endpoint's and the environment's, and is
-     * never sent to Vertex AI.
-     */
-    apiKey?: string;
-    /** Where requests go (ADR 0023). Default: `endpointFromEnv('gemini')`, read on the first call. */
-    endpoint?: ProviderEndpoint;
-}
-/** Temporary: ADK's Gemini behind the model contract, until GeminiAdapter passes gate G3. */
-export declare class AdkGeminiAdapter implements ModelAdapter {
-    #private;
-    readonly provider = "gemini";
-    readonly model: string;
-    constructor(options: AdkGeminiAdapterOptions);
-    generate(request: ModelRequest): AsyncGenerator<ModelResponse, void>;
-}