melchizedek-agents 0.19.0 → 1.0.0

package/dist/lib/compileNative.d.ts

@@ -1,84 +1,98 @@
 /**
- * lib/compileNative.ts — an AgentSpec as the native runtime runs it: the
- * NativeAgent the agent loop takes (ADR 0045, ADR 0073).
+ * lib/compileNative.ts — an AgentSpec as the runtime runs it: the
+ * NativeAgent the agent loop takes (ADR 0045, ADR 0073, ADR 0107).
  *
  * WHY this file exists:
- *   lib/compile.ts turns a YAML agent into a runtime-neutral AgentSpec, and
- *   lib/compileAdk.ts builds ADK's LlmAgent from it. This file builds the
- *   native loop's agent from the same spec (lib/runtime/native/request.ts,
- *   NativeAgent), so both runtimes run the agent the YAML describes, with
- *   the same tools, instruction and config. tests/compile.test.ts compiles
- *   one spec both ways and requires the same first request.
+ *   lib/compile.ts turns a YAML agent into an AgentSpec. This file builds
+ *   the loop's agent from it (lib/runtime/native/request.ts, NativeAgent),
+ *   with the tools, instruction and config the YAML describes.
  *
- * TOOLS: each resolved tool is handed to the loop as the own Tool or
- * InstructionTool behind it (lib/tools/tool.ts), else as itself: an MCP
- * tool, the skills toolset, a gated registry FunctionTool, which the loop
- * runs by shape during the dual period (ADR 0071). A delegated subagent
- * becomes a subagentTool holding its own NativeAgent, which the loop runs as
- * a child loop (lib/runtime/native/delegate.ts, ADR 0074), a nested
- * syndicate as its orchestrator's agent; a remote A2A subagent is the own
- * Tool the ADK runtime's FunctionTool wraps (lib/a2a/remoteAgent.ts).
+ * TOOLS: each resolved tool is handed to the loop as the own Tool,
+ * InstructionTool or Toolset it is (lib/tools/tool.ts). A delegated
+ * subagent becomes a subagentTool holding its own NativeAgent, which the
+ * loop runs as a child loop (lib/runtime/native/delegate.ts, ADR 0074), a
+ * nested syndicate as its orchestrator's agent, a nested workflow syndicate
+ * as a workflowSubagentTool whose call walks the whole graph (ADR 0098); a
+ * remote A2A subagent is its own Tool (lib/a2a/remoteAgent.ts).
  *
- * EVERY AGENT KEY COMPILES for the native loop: `context:` is handed to
- * the loop, which compacts as ADK does (lib/runtime/native/compaction.ts,
- * WS2-9); `mode: task` and `code_execution: gemini` pass through, the
- * request declaring finish_task (lib/runtime/native/taskMode.ts) and asking
- * Gemini for its code-execution tool (lib/runtime/native/request.ts). What
- * native does not run yet (workflows, resuming an approval or a
- * question, a caller's agent transform) is refused by the turn runner
- * (lib/runtime/nativeTurn.ts), which owns those choices.
+ * EVERY AGENT KEY COMPILES: `context:` is handed to the loop, which
+ * compacts (lib/runtime/native/compaction.ts); `mode: task` and
+ * `code_execution: gemini` pass through, the request declaring finish_task
+ * (lib/runtime/native/taskMode.ts) and asking Gemini for its
+ * code-execution tool (lib/runtime/native/request.ts). What the runtime
+ * does not run is refused by the turn runner (lib/runtime/nativeTurn.ts).
  *
  * THE MODEL: the loop calls a model through its contract adapter. A
- * resolver may return an id, a contract adapter, an ADK shim (which carries
- * one) or ADK's Gemini (TracedGemini), whose key reaches the registry's
- * Gemini adapter. Any other ADK model class has no adapter behind it, so
- * compileNative and nativeAdapterFor refuse it with UnsupportedOnRuntimeError
- * before any model call, naming adkShim as the way to run it on native,
- * rather than run the registry's model for that id in its place (ADR 0088).
- * ADK classes are told apart by ADK's own Symbol.for marks, so this file
- * imports nothing from ADK.
+ * resolver returns an id, a ModelAdapter or undefined. Anything else is
+ * refused with UnsupportedOnRuntimeError by compileNative and
+ * nativeAdapterFor before any model call, rather than run the registry's
+ * model for that id in its place (ADR 0088, ADR 0107): an ADK model class (a
+ * resolver written for 0.x) has no adapter behind it, and a plain
+ * `{ model, apiKey }` object would run on the operator's env key, not the
+ * caller's. ADK classes are told apart by ADK's own Symbol.for marks, so
+ * this file imports nothing from ADK.
  */
-import type { AgentSpec, CompileOptions } from './compile.ts';
+import type { AgentSpec, CompileOptions, WorkflowSpec } from './compile.ts';
 import type { SubagentYamlConfig, SyndicateYamlConfig } from './loadSyndicate.ts';
 import type { ModelAdapter } from './models/contract.ts';
+import type { WorkflowSubagent } from './runtime/native/delegate.ts';
 import type { NativeAgent } from './runtime/native/request.ts';
 export { UnsupportedOnRuntimeError, unsupportedOnNative } from './runtime/runtimeFlag.ts';
+import type { WorkflowGraph } from './workflow/graph.ts';
 /**
- * The class name of an ADK model the native runtime cannot run, else
- * undefined: an ADK BaseLlm that is neither ADK's Gemini (TracedGemini
- * included) nor a shim carrying a contract adapter (lib/models/adkShim.ts).
+ * The class name of an ADK model the runtime cannot run, else undefined:
+ * any ADK BaseLlm (ADR 0107; the ADK runtime that ran one left in 1.0.0).
  */
 export declare function unrunnableModelClass(resolved: unknown): string | undefined;
 /**
  * The NativeAgent for `spec`. Throws when no model id is known, and
- * UnsupportedOnRuntimeError when the resolver returned an ADK model class
- * the loop cannot call (see the header).
+ * UnsupportedOnRuntimeError when the resolver returned anything but an id,
+ * a ModelAdapter or undefined (see the header).
  */
 export declare function compileNative(spec: AgentSpec): NativeAgent;
 /**
- * The model id a request is sent under, as ADK's LlmAgent sends it: the id
- * of the model object the resolver returned (an ADK model or a contract
- * adapter carries its own), else the id the resolver returned, else the
- * spec's. A resolver may answer a YAML id with a model under another id (a
- * gateway stand-in, a caller's alias); the adapter, the span and the
- * circuit breaker then see that id on both runtimes.
+ * The model id a request is sent under: the id of the adapter the resolver
+ * returned, else the id the resolver returned, else the spec's. A resolver
+ * may answer a YAML id with a model under another id (a gateway stand-in, a
+ * caller's alias); the adapter, the span and the circuit breaker then see
+ * that id.
  */
 export declare function wireModelOf(spec: Pick<AgentSpec, 'modelId' | 'resolvedModel'>): string | undefined;
 /** A syndicate's orchestrator for the native loop: compileSpec, then compileNative. */
 export declare function compileNativeGraph(config: SyndicateYamlConfig, opts?: CompileOptions): Promise<NativeAgent>;
+/** A workflow syndicate for the native walk (lib/workflow/turn.ts): its graph, every agent by YAML name, and the tool nodes' lookup. */
+export interface NativeWorkflow {
+    name: string;
+    description: string;
+    graph: WorkflowGraph;
+    agents: Map<string, NativeAgent>;
+    resolveTool: (name: string) => unknown;
+    /** The nodes that are a nested workflow syndicate, each compiled the same way, by YAML name (ADR 0106). */
+    workflows: Map<string, NativeWorkflow>;
+}
+/**
+ * A workflow spec for the walk: the graph, every agent compiled from its
+ * spec, and the registry's lookup for tool nodes. An unregistered or
+ * long-running tool node is refused here, before any model call.
+ */
+export declare function compileNativeWorkflow(spec: WorkflowSpec): NativeWorkflow;
+/**
+ * A nested workflow as the delegated subagent the native loop calls (ADR
+ * 0098): one call walks the whole graph with runNativeWorkflow on the child
+ * session lib/runtime/native/delegate.ts opened.
+ */
+export declare function workflowSubagentOf(workflow: NativeWorkflow): WorkflowSubagent;
 /** One subagent entry (a dispatch route) for the native loop: compileSubagentSpec, then compileNative. */
 export declare function compileNativeSubagent(subCfg: SubagentYamlConfig, opts?: CompileOptions): Promise<NativeAgent>;
 /** What nativeAdapterFor reads from a spec: its model resolution, the other ids it calls, and its delegated subagents. */
 type NativeModelSpec = Pick<AgentSpec, 'modelId' | 'resolvedModel'> & Partial<Pick<AgentSpec, 'name' | 'fallbackModel' | 'context' | 'tools'>>;
 /**
- * The loop's `adapterFor` under the same model resolution the ADK runtime
- * uses: the leaf adapter behind what CompileOptions.resolveModel returns
- * (an ADK shim carries its contract adapter, so a caller's BYOK key on a
- * shimmed provider reaches the call), else resolveAdapter for the id
+ * The loop's `adapterFor`: the adapter CompileOptions.resolveModel returns
+ * (so a caller's BYOK key reaches the call), else resolveAdapter for the id
  * (lib/models/registry.ts). The spec's own resolution, and each delegated
  * subagent's, is reused for the id its agent runs under (wireModelOf).
  * Each agent's `fallback_model:` and compaction `summary_model` are
- * resolved here, as compileAdk resolves them at compile time, so a model
+ * resolved here, at compile time, so a model
  * class native cannot run is refused before any model call; any other id
  * is resolved when first asked for. Each is kept.
  */

package/dist/lib/compileNative.js

@@ -1,83 +1,104 @@
 /**
- * lib/compileNative.ts — an AgentSpec as the native runtime runs it: the
- * NativeAgent the agent loop takes (ADR 0045, ADR 0073).
+ * lib/compileNative.ts — an AgentSpec as the runtime runs it: the
+ * NativeAgent the agent loop takes (ADR 0045, ADR 0073, ADR 0107).
  *
  * WHY this file exists:
- *   lib/compile.ts turns a YAML agent into a runtime-neutral AgentSpec, and
- *   lib/compileAdk.ts builds ADK's LlmAgent from it. This file builds the
- *   native loop's agent from the same spec (lib/runtime/native/request.ts,
- *   NativeAgent), so both runtimes run the agent the YAML describes, with
- *   the same tools, instruction and config. tests/compile.test.ts compiles
- *   one spec both ways and requires the same first request.
+ *   lib/compile.ts turns a YAML agent into an AgentSpec. This file builds
+ *   the loop's agent from it (lib/runtime/native/request.ts, NativeAgent),
+ *   with the tools, instruction and config the YAML describes.
  *
- * TOOLS: each resolved tool is handed to the loop as the own Tool or
- * InstructionTool behind it (lib/tools/tool.ts), else as itself: an MCP
- * tool, the skills toolset, a gated registry FunctionTool, which the loop
- * runs by shape during the dual period (ADR 0071). A delegated subagent
- * becomes a subagentTool holding its own NativeAgent, which the loop runs as
- * a child loop (lib/runtime/native/delegate.ts, ADR 0074), a nested
- * syndicate as its orchestrator's agent; a remote A2A subagent is the own
- * Tool the ADK runtime's FunctionTool wraps (lib/a2a/remoteAgent.ts).
+ * TOOLS: each resolved tool is handed to the loop as the own Tool,
+ * InstructionTool or Toolset it is (lib/tools/tool.ts). A delegated
+ * subagent becomes a subagentTool holding its own NativeAgent, which the
+ * loop runs as a child loop (lib/runtime/native/delegate.ts, ADR 0074), a
+ * nested syndicate as its orchestrator's agent, a nested workflow syndicate
+ * as a workflowSubagentTool whose call walks the whole graph (ADR 0098); a
+ * remote A2A subagent is its own Tool (lib/a2a/remoteAgent.ts).
  *
- * EVERY AGENT KEY COMPILES for the native loop: `context:` is handed to
- * the loop, which compacts as ADK does (lib/runtime/native/compaction.ts,
- * WS2-9); `mode: task` and `code_execution: gemini` pass through, the
- * request declaring finish_task (lib/runtime/native/taskMode.ts) and asking
- * Gemini for its code-execution tool (lib/runtime/native/request.ts). What
- * native does not run yet (workflows, resuming an approval or a
- * question, a caller's agent transform) is refused by the turn runner
- * (lib/runtime/nativeTurn.ts), which owns those choices.
+ * EVERY AGENT KEY COMPILES: `context:` is handed to the loop, which
+ * compacts (lib/runtime/native/compaction.ts); `mode: task` and
+ * `code_execution: gemini` pass through, the request declaring finish_task
+ * (lib/runtime/native/taskMode.ts) and asking Gemini for its
+ * code-execution tool (lib/runtime/native/request.ts). What the runtime
+ * does not run is refused by the turn runner (lib/runtime/nativeTurn.ts).
  *
  * THE MODEL: the loop calls a model through its contract adapter. A
- * resolver may return an id, a contract adapter, an ADK shim (which carries
- * one) or ADK's Gemini (TracedGemini), whose key reaches the registry's
- * Gemini adapter. Any other ADK model class has no adapter behind it, so
- * compileNative and nativeAdapterFor refuse it with UnsupportedOnRuntimeError
- * before any model call, naming adkShim as the way to run it on native,
- * rather than run the registry's model for that id in its place (ADR 0088).
- * ADK classes are told apart by ADK's own Symbol.for marks, so this file
- * imports nothing from ADK.
+ * resolver returns an id, a ModelAdapter or undefined. Anything else is
+ * refused with UnsupportedOnRuntimeError by compileNative and
+ * nativeAdapterFor before any model call, rather than run the registry's
+ * model for that id in its place (ADR 0088, ADR 0107): an ADK model class (a
+ * resolver written for 0.x) has no adapter behind it, and a plain
+ * `{ model, apiKey }` object would run on the operator's env key, not the
+ * caller's. ADK classes are told apart by ADK's own Symbol.for marks, so
+ * this file imports nothing from ADK.
  */
 import { remoteAgentOwnTool } from './a2a/remoteAgent.js';
-import { compileSpec, compileSubagentSpec } from './compile.js';
-import { providerForModel, resolveAdapter } from './models/registry.js';
-import { subagentTool } from './runtime/native/delegate.js';
+import { compileSpec, compileSubagentSpec, workflowAgentSpecs } from './compile.js';
+import { resolveAdapter } from './models/registry.js';
+import { subagentTool, workflowSubagentTool } from './runtime/native/delegate.js';
 import { unsupportedOnNative } from './runtime/runtimeFlag.js';
 export { UnsupportedOnRuntimeError, unsupportedOnNative } from './runtime/runtimeFlag.js';
 import { instructionToolOf, toolOf, toolsetOf } from './tools/tool.js';
-/** A resolved tool as the loop holds it: the own Tool, InstructionTool or Toolset behind it, else the object itself. */
+import { buildWorkflowGraph } from './workflow/graph.js';
+import { refuseUnrunnableNodes, runNativeWorkflow } from './workflow/turn.js';
+/**
+ * A resolved tool as the loop holds it: the own Tool, InstructionTool or
+ * Toolset behind it, else the object itself. An ADK tool (anything with
+ * runAsync) is refused, naming 1.0.0 and defineTool, as registerTool
+ * refuses one.
+ */
 function nativeTool(tool) {
+    if (!!tool && typeof tool === 'object' && 'runAsync' in tool) {
+        const name = String(tool.name ?? '<unnamed>');
+        throw new Error(`compile: '${name}' is an ADK tool, which melchizedek-agents 1.0.0 no longer runs (ADR 0107); define it with defineTool (melchizedek-agents) instead`);
+    }
     return toolOf(tool) ?? instructionToolOf(tool) ?? toolsetOf(tool) ?? tool;
 }
-/** ADK's own marks on its model classes (BaseLlm, Gemini), registered with Symbol.for so they hold across copies of ADK. */
+/** ADK's own mark on its model classes, registered with Symbol.for so it holds across copies of ADK. */
 const ADK_BASE_MODEL = Symbol.for('google.adk.baseModel');
-const ADK_GEMINI_MODEL = Symbol.for('google.adk.geminiModel');
 const marked = (value, mark) => !!value && typeof value === 'object' && value[mark] === true;
 /**
- * The class name of an ADK model the native runtime cannot run, else
- * undefined: an ADK BaseLlm that is neither ADK's Gemini (TracedGemini
- * included) nor a shim carrying a contract adapter (lib/models/adkShim.ts).
+ * The class name of an ADK model the runtime cannot run, else undefined:
+ * any ADK BaseLlm (ADR 0107; the ADK runtime that ran one left in 1.0.0).
  */
 export function unrunnableModelClass(resolved) {
-    if (!marked(resolved, ADK_BASE_MODEL) || marked(resolved, ADK_GEMINI_MODEL))
-        return undefined;
-    if (isModelAdapter(resolved.adapter))
+    if (!marked(resolved, ADK_BASE_MODEL))
         return undefined;
     const name = resolved.constructor?.name;
     return typeof name === 'string' && name ? name : 'BaseLlm';
 }
-/** Throws UnsupportedOnRuntimeError when `resolved` is an ADK model class native cannot run (see the header). */
+/**
+ * Throws UnsupportedOnRuntimeError when `resolved` is not a model id, a
+ * ModelAdapter or undefined: an ADK model class native cannot run, or any
+ * other value, such as a plain `{ model, apiKey }` object, which would
+ * otherwise run on the operator's env key in place of the caller's (see the
+ * header).
+ */
 function refuseModelClass(resolved, modelId, where) {
+    const forId = modelId ? ` for '${modelId}'` : '';
     const name = unrunnableModelClass(resolved);
-    if (!name)
+    if (name) {
+        throw unsupportedOnNative(`the ADK model class ${name} that resolveModel returned${forId}, which has no contract adapter behind it ` +
+            `(ADK model classes left in 1.0.0; return a model id or a ModelAdapter from melchizedek-agents/model)`, where);
+    }
+    if (resolved === undefined || typeof resolved === 'string' || isModelAdapter(resolved))
         return;
-    throw unsupportedOnNative(`the ADK model class ${name} that resolveModel returned${modelId ? ` for '${modelId}'` : ''}, which has no contract adapter behind it ` +
-        `(return the ModelAdapter itself, or adkShim(adapter) from melchizedek-agents/models/adkShim, to run it on native)`, where);
+    throw unsupportedOnNative(`the ${describeResolved(resolved)} that resolveModel returned${forId} (melchizedek-agents 1.0.0 accepts only a model id, a ModelAdapter or undefined; ` +
+        `return a model id or a ModelAdapter (e.g. new ClaudeAdapter({ model, apiKey })) from melchizedek-agents/model)`, where);
+}
+/** What a resolver returned, named for a refusal: its type, never its contents (a key may be among them). */
+function describeResolved(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value !== 'object')
+        return `${typeof value} value`;
+    const ctor = value.constructor?.name;
+    return typeof ctor === 'string' && ctor && ctor !== 'Object' ? `${ctor} instance` : 'plain object';
 }
 /**
  * The NativeAgent for `spec`. Throws when no model id is known, and
- * UnsupportedOnRuntimeError when the resolver returned an ADK model class
- * the loop cannot call (see the header).
+ * UnsupportedOnRuntimeError when the resolver returned anything but an id,
+ * a ModelAdapter or undefined (see the header).
  */
 export function compileNative(spec) {
     refuseModelClass(spec.resolvedModel, spec.model ?? spec.modelId, spec.name);
@@ -85,6 +106,8 @@ export function compileNative(spec) {
     for (const entry of spec.tools) {
         if (entry.kind === 'agent')
             tools.push(subagentTool(compileNative(entry.agent)));
+        else if (entry.kind === 'workflow')
+            tools.push(workflowSubagentTool(workflowSubagentOf(compileNativeWorkflow(entry.workflow))));
         else if (entry.kind === 'remote')
             tools.push(remoteAgentOwnTool({ name: entry.name, description: entry.description, url: entry.url }));
         else
@@ -125,12 +148,11 @@ export function compileNative(spec) {
     return agent;
 }
 /**
- * The model id a request is sent under, as ADK's LlmAgent sends it: the id
- * of the model object the resolver returned (an ADK model or a contract
- * adapter carries its own), else the id the resolver returned, else the
- * spec's. A resolver may answer a YAML id with a model under another id (a
- * gateway stand-in, a caller's alias); the adapter, the span and the
- * circuit breaker then see that id on both runtimes.
+ * The model id a request is sent under: the id of the adapter the resolver
+ * returned, else the id the resolver returned, else the spec's. A resolver
+ * may answer a YAML id with a model under another id (a gateway stand-in, a
+ * caller's alias); the adapter, the span and the circuit breaker then see
+ * that id.
  */
 export function wireModelOf(spec) {
     const resolved = spec.resolvedModel;
@@ -145,6 +167,51 @@ export function wireModelOf(spec) {
 export async function compileNativeGraph(config, opts = {}) {
     return compileNative(await compileSpec(config, opts));
 }
+/**
+ * A workflow spec for the walk: the graph, every agent compiled from its
+ * spec, and the registry's lookup for tool nodes. An unregistered or
+ * long-running tool node is refused here, before any model call.
+ */
+export function compileNativeWorkflow(spec) {
+    const graph = buildWorkflowGraph(spec.config);
+    const agents = new Map();
+    for (const { yaml, spec: agentSpec } of spec.agents)
+        agents.set(yaml.name, compileNative(agentSpec));
+    const workflows = new Map();
+    for (const { yaml, workflow } of spec.workflows)
+        workflows.set(yaml.name, compileNativeWorkflow(workflow));
+    refuseUnrunnableNodes(graph, spec.resolveTool);
+    return { name: spec.name, description: spec.description, graph, agents, resolveTool: spec.resolveTool, workflows };
+}
+/**
+ * A nested workflow as the delegated subagent the native loop calls (ADR
+ * 0098): one call walks the whole graph with runNativeWorkflow on the child
+ * session lib/runtime/native/delegate.ts opened.
+ */
+export function workflowSubagentOf(workflow) {
+    return {
+        name: workflow.name,
+        ...(workflow.description ? { description: workflow.description } : {}),
+        walk: (run) => runNativeWorkflow({
+            graph: workflow.graph,
+            agents: workflow.agents,
+            resolveTool: workflow.resolveTool,
+            workflows: workflow.workflows,
+            sessions: run.sessions,
+            appName: run.appName,
+            userId: run.userId,
+            sessionId: run.sessionId,
+            userParts: run.userParts,
+            adapterFor: run.adapterFor,
+            selfCorrection: run.selfCorrection,
+            stream: false,
+            ...(run.signal ? { signal: run.signal } : {}),
+            ...(run.memory ? { memory: run.memory } : {}),
+            ...(run.log ? { log: run.log } : {}),
+            ...(run.credentials ? { credentials: run.credentials } : {}),
+        }),
+    };
+}
 /** One subagent entry (a dispatch route) for the native loop: compileSubagentSpec, then compileNative. */
 export async function compileNativeSubagent(subCfg, opts = {}) {
     return compileNative(await compileSubagentSpec(subCfg, opts));
@@ -153,37 +220,23 @@ function isModelAdapter(value) {
     return !!value && typeof value === 'object' && typeof value.generate === 'function' && typeof value.model === 'string';
 }
 /**
- * The contract adapter behind what a resolver returned: an ADK shim's own
- * adapter; for an ADK class that is not a shim (TracedGemini, ADK's Gemini)
- * the registry's adapter under the key the instance carries, so a caller's
- * BYOK key still pays for the call; else the registry's for the id.
+ * The contract adapter behind what a resolver returned: the adapter itself,
+ * else the registry's for the id (`model` when the resolver returned
+ * undefined or an empty id). Anything else is refused (refuseModelClass).
  */
 function adapterOf(resolved, model) {
     if (isModelAdapter(resolved))
         return resolved;
     refuseModelClass(resolved, model, 'the native runtime');
-    if (typeof resolved === 'string')
-        return resolveAdapter(resolved || model);
-    if (!resolved || typeof resolved !== 'object')
-        return resolveAdapter(model);
-    const held = resolved;
-    if (isModelAdapter(held.adapter))
-        return held.adapter;
-    // On Vertex AI the client authenticates with the platform's credentials, never a key (ADR 0023).
-    if (typeof held.apiKey === 'string' && held.apiKey && held.vertexai !== true) {
-        return resolveAdapter(model, { apiKey: held.apiKey, keyProvider: providerForModel(model) });
-    }
-    return resolveAdapter(model);
+    return resolveAdapter(resolved || model);
 }
 /**
- * The loop's `adapterFor` under the same model resolution the ADK runtime
- * uses: the leaf adapter behind what CompileOptions.resolveModel returns
- * (an ADK shim carries its contract adapter, so a caller's BYOK key on a
- * shimmed provider reaches the call), else resolveAdapter for the id
+ * The loop's `adapterFor`: the adapter CompileOptions.resolveModel returns
+ * (so a caller's BYOK key reaches the call), else resolveAdapter for the id
  * (lib/models/registry.ts). The spec's own resolution, and each delegated
  * subagent's, is reused for the id its agent runs under (wireModelOf).
  * Each agent's `fallback_model:` and compaction `summary_model` are
- * resolved here, as compileAdk resolves them at compile time, so a model
+ * resolved here, at compile time, so a model
  * class native cannot run is refused before any model call; any other id
  * is resolved when first asked for. Each is kept.
  */
@@ -203,9 +256,14 @@ export function nativeAdapterFor(opts = {}, spec) {
             refuseModelClass(resolved, id, s.name ?? 'the native runtime');
             known.set(id, resolved);
         }
-        for (const entry of s.tools ?? [])
+        for (const entry of s.tools ?? []) {
             if (entry.kind === 'agent')
                 learn(entry.agent);
+            // A nested workflow's agents run under the caller's lookup (ADR 0098).
+            else if (entry.kind === 'workflow')
+                for (const node of workflowAgentSpecs(entry.workflow))
+                    learn(node);
+        }
     };
     // A workflow's agents share one lookup: every node's spec is learned.
     for (const s of spec === undefined ? [] : Array.isArray(spec) ? spec : [spec])

package/dist/lib/config.d.ts

@@ -33,20 +33,20 @@ export declare const DEFAULT_GEMINI_MODEL = "gemini-3.5-flash-lite";
  * Default Claude model used by the A2A server when a claude-* model is
  * requested but no specific identifier is provided.
  *
- * Requires ANTHROPIC_API_KEY to be set. The ClaudeLlm provider in
- * lib/models/claudeLlm.ts handles routing automatically via LLMRegistry.
+ * Requires ANTHROPIC_API_KEY to be set. A claude-* id resolves to
+ * ClaudeAdapter (lib/models/claudeAdapter.ts) through resolveAdapter.
  */
 export declare const DEFAULT_CLAUDE_MODEL = "claude-sonnet-4-6";
 /**
  * Default OpenAI model used when a gpt-* model is requested but no specific
  * identifier is provided. Requires OPENAI_API_KEY. gpt-5-mini is the
  * lightweight reasoning tier — enough for subagent work, and it exposes
- * reasoning summaries via the Responses API (lib/models/gptLlm.ts).
+ * reasoning summaries via the Responses API (lib/models/gptAdapter.ts).
  */
 export declare const DEFAULT_GPT_MODEL = "gpt-5-mini";
 /**
  * Default xAI model used when a grok-* model is requested but no specific
- * identifier is provided. Requires XAI_API_KEY (lib/models/grokLlm.ts).
+ * identifier is provided. Requires XAI_API_KEY (lib/models/grokAdapter.ts).
  * grok-4.7 is a reasoning model (reasoning cannot be disabled); it returns
  * reasoning summaries, which the adapter surfaces as thinking.
  */
@@ -63,7 +63,7 @@ export declare const DEFAULT_GROK_REASONING_EFFORT = "medium";
 /**
  * Default Moonshot model used when a kimi-* model is requested but no
  * specific identifier is provided. Requires MOONSHOT_API_KEY
- * (lib/models/kimiLlm.ts). kimi-k3 is the flagship, priced like a mid-tier
+ * (lib/models/kimiAdapter.ts). kimi-k3 is the flagship, priced like a mid-tier
  * closed model ($3 / $15, Claude Sonnet 4.6's price; Sonnet 5.5 is cheaper);
  * kimi-k2.6 is the general tier at a quarter of that (the family table and
  * the cost note are in the adapter's header).
@@ -85,7 +85,7 @@ export declare const DEFAULT_KIMI_REASONING_EFFORT = "high";
  */
 export declare const DEFAULT_MAX_STEPS = 50;
 /**
- * Default open-weight model, served locally by Ollama (lib/models/ollamaLlm.ts).
+ * Default open-weight model, served locally by Ollama (lib/models/ollamaAdapter.ts).
  * qwen3:8b is the smallest pulled model that supports tool calling — the
  * floor capability for syndicate delegation. Vision work uses ollama/qwen3-vl:8b.
  */

package/dist/lib/config.js

@@ -34,20 +34,20 @@ export const DEFAULT_GEMINI_MODEL = 'gemini-3.5-flash-lite';
  * Default Claude model used by the A2A server when a claude-* model is
  * requested but no specific identifier is provided.
  *
- * Requires ANTHROPIC_API_KEY to be set. The ClaudeLlm provider in
- * lib/models/claudeLlm.ts handles routing automatically via LLMRegistry.
+ * Requires ANTHROPIC_API_KEY to be set. A claude-* id resolves to
+ * ClaudeAdapter (lib/models/claudeAdapter.ts) through resolveAdapter.
  */
 export const DEFAULT_CLAUDE_MODEL = 'claude-sonnet-4-6';
 /**
  * Default OpenAI model used when a gpt-* model is requested but no specific
  * identifier is provided. Requires OPENAI_API_KEY. gpt-5-mini is the
  * lightweight reasoning tier — enough for subagent work, and it exposes
- * reasoning summaries via the Responses API (lib/models/gptLlm.ts).
+ * reasoning summaries via the Responses API (lib/models/gptAdapter.ts).
  */
 export const DEFAULT_GPT_MODEL = 'gpt-5-mini';
 /**
  * Default xAI model used when a grok-* model is requested but no specific
- * identifier is provided. Requires XAI_API_KEY (lib/models/grokLlm.ts).
+ * identifier is provided. Requires XAI_API_KEY (lib/models/grokAdapter.ts).
  * grok-4.7 is a reasoning model (reasoning cannot be disabled); it returns
  * reasoning summaries, which the adapter surfaces as thinking.
  */
@@ -64,7 +64,7 @@ export const DEFAULT_GROK_REASONING_EFFORT = 'medium';
 /**
  * Default Moonshot model used when a kimi-* model is requested but no
  * specific identifier is provided. Requires MOONSHOT_API_KEY
- * (lib/models/kimiLlm.ts). kimi-k3 is the flagship, priced like a mid-tier
+ * (lib/models/kimiAdapter.ts). kimi-k3 is the flagship, priced like a mid-tier
  * closed model ($3 / $15, Claude Sonnet 4.6's price; Sonnet 5.5 is cheaper);
  * kimi-k2.6 is the general tier at a quarter of that (the family table and
  * the cost note are in the adapter's header).
@@ -86,7 +86,7 @@ export const DEFAULT_KIMI_REASONING_EFFORT = 'high';
  */
 export const DEFAULT_MAX_STEPS = 50;
 /**
- * Default open-weight model, served locally by Ollama (lib/models/ollamaLlm.ts).
+ * Default open-weight model, served locally by Ollama (lib/models/ollamaAdapter.ts).
  * qwen3:8b is the smallest pulled model that supports tool calling — the
  * floor capability for syndicate delegation. Vision work uses ollama/qwen3-vl:8b.
  */

package/dist/lib/doctor.d.ts

@@ -18,11 +18,14 @@
  * The routing and capability judgments are not re-implemented here: they
  * come from lib/models/gateway.ts and lib/models/capabilities.ts, the same
  * modules the registry and the A2A server use, so the report cannot
- * disagree with what a run would do.
+ * disagree with what a run would do. The runtime line comes from
+ * lib/runtime/runtimeFlag.ts, which a turn reads (ADR 0107): a leftover
+ * MELCHIZEDEK_RUNTIME=adk is a problem.
  */
 import type { Platform } from './models/endpoints.ts';
 import type { CapabilityGap, CapabilityReport } from './models/capabilities.ts';
 import type { ProviderId } from './models/providerMap.ts';
+import type { RuntimeName, RuntimeSource } from './runtime/runtimeFlag.ts';
 /**
  * What a file costs to run: `keyless` (all Ollama), a single provider's id
  * when every agent shares one (`gemini`, `anthropic`, `openai`, `xai` — one
@@ -81,8 +84,19 @@ export interface Unlock {
     /** Syndicates this one variable would move from blocked to ready. */
     syndicates: string[];
 }
+/** The runtime a turn would run on here, and where that came from (ADR 0107). */
+export interface DoctorRuntime {
+    /** The runtime in use; undefined when MELCHIZEDEK_RUNTIME holds a value no turn accepts (`problem` says so). */
+    runtime?: RuntimeName;
+    /** Where it came from: MELCHIZEDEK_RUNTIME, or the default (a turn's own option is the caller's, not the environment's). */
+    source?: RuntimeSource;
+    /** Why no turn would run as configured, if none would. */
+    problem?: string;
+}
 export interface DoctorResult {
     agentsDir: string;
+    /** The runtime in use. */
+    runtime: DoctorRuntime;
     syndicates: DoctorSyndicate[];
     unlocks: Unlock[];
     gateway: {
@@ -110,6 +124,13 @@ export interface DoctorEndpoint {
     /** Cloud platforms are tested against mocks only (ADR 0023). */
     liveVerified: boolean;
 }
+/**
+ * The runtime a turn would run on under this environment (lib/runtime/
+ * runtimeFlag.ts), and where that came from. MELCHIZEDEK_RUNTIME=adk is a
+ * problem: every turn, and the server's startup, would fail
+ * (RuntimeRemovedError, ADR 0107).
+ */
+export declare function runtimeReport(env?: NodeJS.ProcessEnv): DoctorRuntime;
 /** One row per provider that is not on its vendor's public API with an env key. */
 export declare function endpointRows(): DoctorEndpoint[];
 export declare const CONSOLE_URLS: Record<ProviderId, string>;