melchizedek-agents 1.1.0 → 1.3.0

package/dist/lib/compileNative.js

@@ -35,7 +35,7 @@
 import { remoteAgentOwnTool } from './a2a/remoteAgent.js';
 import { compileSpec, compileSubagentSpec, workflowAgentSpecs } from './compile.js';
 import { resolveAdapter } from './models/registry.js';
-import { subagentTool, workflowSubagentTool } from './runtime/native/delegate.js';
+import { nestedDispatchWalk, 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';
@@ -108,6 +108,8 @@ export function compileNative(spec) {
             tools.push(subagentTool(compileNative(entry.agent)));
         else if (entry.kind === 'workflow')
             tools.push(workflowSubagentTool(workflowSubagentOf(compileNativeWorkflow(entry.workflow))));
+        else if (entry.kind === 'dispatch')
+            tools.push(workflowSubagentTool(dispatchSubagentOf(entry.dispatch)));
         else if (entry.kind === 'remote')
             tools.push(remoteAgentOwnTool({ name: entry.name, description: entry.description, url: entry.url }));
         else
@@ -182,6 +184,8 @@ export function compileNativeWorkflow(spec) {
     const workflows = new Map();
     for (const { yaml, workflow } of spec.workflows)
         workflows.set(yaml.name, compileNativeWorkflow(workflow));
+    for (const { yaml, dispatch } of spec.dispatches ?? [])
+        workflows.set(yaml.name, dispatchSubagentOf(dispatch));
     refuseUnrunnableNodes(graph, spec.resolveTool);
     return { name: spec.name, description: spec.description, graph, agents, resolveTool: spec.resolveTool, workflows };
 }
@@ -214,6 +218,19 @@ export function workflowSubagentOf(workflow) {
         }),
     };
 }
+/**
+ * A nested dispatch syndicate as the delegated subagent the native loop
+ * calls, or the node a walk runs (ADR 0120): one call runs it as its own
+ * turn (nestedDispatchWalk) on the child session lib/runtime/native/delegate.ts
+ * (or lib/workflow/turn.ts) opened.
+ */
+export function dispatchSubagentOf(dispatch) {
+    return {
+        name: dispatch.name,
+        ...(dispatch.description ? { description: dispatch.description } : {}),
+        walk: (run) => nestedDispatchWalk({ name: dispatch.name, config: dispatch.config, compile: dispatch.compile }, run),
+    };
+}
 /** 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));

package/dist/lib/dispatch.js

@@ -73,6 +73,8 @@ function matchSubagent(candidate, subagents) {
         return undefined;
     return subagents.find(sub => norm(sub.name) === target);
 }
+/** What a subagent name can look like: one token, linear to test. */
+const ROUTE_SHAPED = /^[A-Za-z0-9_.-]{1,64}$/;
 /**
  * Turn the router's raw output into a route that definitely exists.
  *
@@ -108,7 +110,8 @@ export function resolveRoute(rawOutput, config) {
         parsed = JSON.parse(unfence(rawOutput));
     }
     catch {
-        return defaultResolution(`router output was not JSON: ${rawOutput.trim().slice(0, 80)}`);
+        // The reason reaches the server log: the size, never the text (the router can echo the person).
+        return defaultResolution(`router output was not JSON (${rawOutput.trim().length} chars)`);
     }
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
         return defaultResolution('router output was not a JSON object');
@@ -120,7 +123,8 @@ export function resolveRoute(rawOutput, config) {
     }
     const matched = matchSubagent(rawRoute, subagents);
     if (!matched) {
-        return defaultResolution(`router chose unknown route '${rawRoute}'`);
+        // A route-shaped value is named; anything else is model text and is only measured.
+        return defaultResolution(ROUTE_SHAPED.test(rawRoute) ? `router chose unknown route '${rawRoute}'` : `router chose an unknown route (${rawRoute.length} chars)`);
     }
     const rawReason = record[reasonKey];
     return {

package/dist/lib/doctor.d.ts

@@ -75,6 +75,21 @@ export interface DoctorOAuth {
     set: Record<string, boolean>;
     problems: string[];
 }
+/**
+ * The static credential variables the syndicates send, under the operator's
+ * credential host allowlist (ADR 0122). Present when any syndicate sends one
+ * or MELCHIZEDEK_CREDENTIAL_HOSTS is set. Names and hosts only.
+ */
+export interface DoctorCredentials {
+    /** Whether MELCHIZEDEK_CREDENTIAL_HOSTS is set. */
+    set: boolean;
+    /** Every variable the syndicates send (bearer_env, api_key.env, client_secret_env), sorted. */
+    envs: string[];
+    /** With no allowlist: the variables sent wherever the YAML says, named. Not a --check failure. */
+    warning?: string;
+    /** A malformed allowlist, and each use it refuses (`file: agent · tools · role: why`). A --check failure. */
+    problems: string[];
+}
 export interface DoctorSyndicate {
     /** Path relative to the agents dir, e.g. "examples/council.yaml". */
     file: string;
@@ -106,6 +121,11 @@ export interface DoctorSyndicate {
     };
     /** The tools that need an OAuth grant (ADR 0112), when any do. */
     grants?: DoctorGrant[];
+    /** The static credential variables its tools send (ADR 0122), and what the allowlist refuses; when it sends any. */
+    credentials?: {
+        envs: string[];
+        problems: string[];
+    };
 }
 export interface Unlock {
     env: string;
@@ -141,6 +161,66 @@ export interface DoctorResult {
     counts: Record<VerdictState, number>;
     /** The OAuth setup, when any syndicate declares a grant or its variables are set. */
     oauth?: DoctorOAuth;
+    /** The credential host allowlist (ADR 0122), when any syndicate sends a static credential or it is set. */
+    credentials?: DoctorCredentials;
+    /** How each provider would be reached here: the providers line, as data. */
+    providers: ProviderPath[];
+    /** How the A2A server would authenticate and bill, when any of its variables is set. */
+    serving?: DoctorServing;
+    /** A stored Sign in with ChatGPT credential (ADR 0126), when one is present or its variables are set. */
+    chatgpt?: DoctorChatGpt;
+}
+/**
+ * A Sign in with ChatGPT credential (ADR 0126): where it is, whether it is
+ * signed in and carries OpenAI ids here, and what stops it. Never a token.
+ */
+export interface DoctorChatGpt {
+    file: string;
+    /** False when MELCHIZEDEK_CHATGPT_SIGNIN=off. */
+    enabled: boolean;
+    present: boolean;
+    signedIn: boolean;
+    /** OpenAI ids run on it here (no OPENAI_API_KEY, OpenAI on its own API). */
+    routesOpenAi: boolean;
+    /** Epoch milliseconds the stored access token expires (it refreshes on use). */
+    expiresAt?: number;
+    /** A served configuration on it, or a file that cannot be used. `--check` fails on any. */
+    problems: string[];
+}
+/**
+ * How one provider would be reached under this environment (the doctor's
+ * providers line): funded or not, directly or through the gateway, and on
+ * which platform. `melchizedek-setup --auto` reads its levels from this.
+ */
+export interface ProviderPath {
+    provider: ProviderId;
+    label: string;
+    funded: boolean;
+    transport: 'direct' | 'gateway';
+    /** The gateway id when transport is 'gateway'. */
+    gateway?: string;
+    /** `local` for Ollama; a cloud platform (vertex, bedrock, azure) or `direct` otherwise. */
+    platform: Platform | 'local';
+    keyEnv: string | null;
+    /** `chatgpt-signin` when a stored Sign in with ChatGPT funds the provider instead of its key (ADR 0126). */
+    credential?: 'chatgpt-signin';
+}
+/**
+ * The A2A server's identity and billing settings (scripts/a2a_server.ts),
+ * names and presence only: which `A2A_AUTH` mode, whether the secret and the
+ * mode's own variables are set, and who pays (`A2A_KEY_MODE`).
+ */
+export interface DoctorServing {
+    /** A2A_AUTH as set, or `secret` (the server's default). */
+    auth: string;
+    /** True when A2A_AUTH is set explicitly. */
+    authDeclared: boolean;
+    /** A2A_KEY_MODE as set, or `server`. */
+    keyMode: string;
+    /** Which of the serving variables are set (never their values). */
+    set: Record<string, boolean>;
+    /** What the server would refuse to start on, by variable name. */
+    problems: string[];
 }
 export interface DoctorEndpoint {
     provider: ProviderId;
@@ -166,6 +246,16 @@ export interface DoctorEndpoint {
 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[];
+/** One status per provider, probed with an id of its own prefix (the providers line). */
+export declare function providerPaths(): ProviderPath[];
+/** The serving variables the doctor reports by presence. */
+export declare const SERVING_ENV: readonly ['A2A_AUTH', 'A2A_SERVER_SECRET', 'A2A_CALLERS', 'A2A_JWT_ISSUER', 'A2A_JWT_AUDIENCE', 'A2A_JWT_JWKS_URL', 'A2A_JWT_SECRET', 'A2A_TRUSTED_USER_HEADER', 'A2A_KEY_MODE', 'PUBLIC_URL'];
+/**
+ * How the A2A server would authenticate callers and who would pay, from the
+ * environment; undefined when none of its variables is set. The checks are
+ * the ones scripts/a2a_server.ts stops on, reported by name.
+ */
+export declare function servingReport(env?: NodeJS.ProcessEnv): DoctorServing | undefined;
 export declare const CONSOLE_URLS: Record<ProviderId, string>;
 /**
  * Every syndicate file the loader can see: the root (this deployment's
@@ -194,6 +284,23 @@ export declare function runDoctor(options?: {
     agentsDir?: string;
     scripts?: Record<string, string>;
 }): DoctorResult;
+/**
+ * The Sign in with ChatGPT line (ADR 0126), when a credential file is present
+ * or one of its variables is set. `served`: a serving variable is set, so
+ * this configuration is meant for melchizedek-serve, which refuses to start
+ * while the sign-in is the OpenAI path.
+ */
+export declare function chatGptReport(served: boolean, env?: NodeJS.ProcessEnv): DoctorChatGpt | undefined;
+/**
+ * Why `melchizedek-doctor --check` exits non-zero, one line each; empty when
+ * it passes. A blocked syndicate, a runtime problem, a `MODEL_GATEWAY` that
+ * names no gateway (named with the accepted values only: the value may be a
+ * key pasted into the wrong variable), the OAuth setup's and the credential
+ * allowlist's problems, and each grant whose hosts the OAuth host allowlist
+ * refuses (ADR 0114), and the Sign in with ChatGPT line's problems (ADR 0126).
+ * Names and hosts only, never a value.
+ */
+export declare function checkProblems(result: DoctorResult): string[];
 export declare function renderDoctor(result: DoctorResult, opts?: {
     color?: boolean;
 }): string;

package/dist/lib/doctor.js

@@ -34,10 +34,16 @@ import { credentialSource, endpointFromEnv, endpointLabel, endpointProblems, PLA
 import { GATEWAY_ENV, GATEWAY_KEY_ENV, GATEWAYS, gatewayConfig, gatewayProblem, gatewayUsable, } from './models/gateway.js';
 import { PROVIDERS } from './models/providerMap.js';
 import { describeRuntime } from './runtime/runtimeFlag.js';
+import { CHATGPT_SIGNIN_ENV, CHATGPT_SIGNIN_FILE_ENV, chatGptSignInRoutesOpenAi, chatGptSignInStatus } from './chatgpt/state.js';
 import { agentOAuthGrants, oauthEnvNames } from './tools/oauthTools.js';
 import { grantHostProblems, OAUTH_REDIRECT_URI_ENV, oauthEnvProblems } from './a2a/oauthSetup.js';
 import { CREDENTIAL_KEY_ENV } from './tools/credentialCipher.js';
 import { OAUTH_HOSTS_ENV } from './tools/oauthHosts.js';
+import { CREDENTIAL_HOSTS_ENV, credentialHosts } from './tools/credentialHosts.js';
+import { syndicateCredentialUses } from './tools/credentialUses.js';
+import { credentialHostEnvProblems, unboundCredentialWarning } from './a2a/oauthSetup.js';
+/** The `gateway.id` the doctor reports when `MODEL_GATEWAY` names no known gateway; the value itself is never kept. */
+const UNRECOGNISED_GATEWAY = 'unrecognised';
 function resolvable(module) {
     try {
         createRequire(import.meta.url).resolve(module);
@@ -100,6 +106,70 @@ export function endpointRows() {
     }
     return rows;
 }
+/** One status per provider, probed with an id of its own prefix (the providers line). */
+export function providerPaths() {
+    return Object.keys(PROVIDERS).map((p) => {
+        const r = describeCapabilities(PROBE_ID[p]);
+        return {
+            provider: p,
+            label: PROVIDERS[p].label,
+            funded: r.funded,
+            transport: r.transport,
+            ...(r.gateway ? { gateway: r.gateway } : {}),
+            platform: p === 'ollama' ? 'local' : (r.platform ?? 'direct'),
+            keyEnv: r.keyEnv,
+            ...(p === 'openai' && r.funded && r.transport === 'direct' && chatGptSignInRoutesOpenAi() ? { credential: 'chatgpt-signin' } : {}),
+        };
+    });
+}
+/** The serving variables the doctor reports by presence. */
+export const SERVING_ENV = [
+    'A2A_AUTH',
+    'A2A_SERVER_SECRET',
+    'A2A_CALLERS',
+    'A2A_JWT_ISSUER',
+    'A2A_JWT_AUDIENCE',
+    'A2A_JWT_JWKS_URL',
+    'A2A_JWT_SECRET',
+    'A2A_TRUSTED_USER_HEADER',
+    'A2A_KEY_MODE',
+    'PUBLIC_URL',
+];
+/**
+ * How the A2A server would authenticate callers and who would pay, from the
+ * environment; undefined when none of its variables is set. The checks are
+ * the ones scripts/a2a_server.ts stops on, reported by name.
+ */
+export function servingReport(env = process.env) {
+    const has = (name) => !!env[name]?.trim();
+    const set = Object.fromEntries(SERVING_ENV.map((name) => [name, has(name)]));
+    if (!Object.values(set).some(Boolean))
+        return undefined;
+    // A value outside the known modes is reported as `invalid`, never echoed:
+    // a secret pasted into the wrong variable must not reach the terminal.
+    const rawAuth = (env.A2A_AUTH ?? '').trim().toLowerCase() || 'secret';
+    const rawKeyMode = (env.A2A_KEY_MODE ?? '').trim().toLowerCase() || 'server';
+    const auth = ['secret', 'callers', 'jwt', 'header'].includes(rawAuth) ? rawAuth : 'invalid';
+    const keyMode = rawKeyMode === 'server' || rawKeyMode === 'byok' ? rawKeyMode : 'invalid';
+    const problems = [];
+    if (auth === 'invalid')
+        problems.push('A2A_AUTH must be secret, callers, jwt or header');
+    if (auth === 'callers' && !has('A2A_CALLERS'))
+        problems.push('A2A_AUTH=callers needs A2A_CALLERS');
+    if (auth === 'jwt' && (!has('A2A_JWT_ISSUER') || !has('A2A_JWT_AUDIENCE')))
+        problems.push('A2A_AUTH=jwt needs A2A_JWT_ISSUER and A2A_JWT_AUDIENCE');
+    if (auth === 'jwt' && !has('A2A_JWT_JWKS_URL') && !has('A2A_JWT_SECRET'))
+        problems.push('A2A_AUTH=jwt needs A2A_JWT_JWKS_URL or A2A_JWT_SECRET');
+    if (auth === 'header' && (!has('A2A_TRUSTED_USER_HEADER') || !has('A2A_SERVER_SECRET')))
+        problems.push('A2A_AUTH=header needs A2A_TRUSTED_USER_HEADER and A2A_SERVER_SECRET');
+    if (keyMode !== 'server' && keyMode !== 'byok')
+        problems.push("A2A_KEY_MODE must be 'server' or 'byok'");
+    if (has('PUBLIC_URL') && !has('A2A_AUTH'))
+        problems.push('PUBLIC_URL is set, so A2A_AUTH must be set explicitly (with A2A_SERVED_AGENTS and A2A_TRUST_PROXY)');
+    if (auth === 'secret' && !has('A2A_SERVER_SECRET') && keyMode === 'byok')
+        problems.push('A2A_KEY_MODE=byok without A2A_SERVER_SECRET (or caller tokens) serves unauthenticated, loopback only');
+    return { auth, authDeclared: has('A2A_AUTH'), keyMode, set, problems };
+}
 // ── Where to get a key ───────────────────────────────────────────────────────
 export const CONSOLE_URLS = {
     gemini: 'https://aistudio.google.com',
@@ -305,6 +375,17 @@ export function diagnoseSyndicate(file, agentsDir, scripts) {
         const nestedErrors = [];
         const grants = [];
         walk(config, '', { load, seen: new Set([file, path.basename(file)]), nestedErrors, grants }, rows);
+        // Static credentials and the credential host allowlist (ADR 0122); a nested file that cannot load is reported above.
+        const loadQuiet = (ref) => {
+            try {
+                return load(ref);
+            }
+            catch {
+                return {};
+            }
+        };
+        const credentialEnvs = [...new Set(syndicateCredentialUses([config], loadQuiet).map((u) => u.env))].sort();
+        const credentials = credentialEnvs.length ? { envs: credentialEnvs, problems: credentialHostEnvProblems([config], process.env, loadQuiet) } : undefined;
         const memory = config.memory_system === 'long-term'
             ? {
                 namespace: config.memory_namespace ?? LEGACY_MEMORY_APP_NAME,
@@ -324,6 +405,7 @@ export function diagnoseSyndicate(file, agentsDir, scripts) {
             ...(nestedErrors.length ? { error: nestedErrors.join('\n') } : {}),
             ...(memory ? { memory } : {}),
             ...(grants.length ? { grants } : {}),
+            ...(credentials ? { credentials } : {}),
         };
     }
     catch (err) {
@@ -405,8 +487,9 @@ export function runDoctor(options = {}) {
     const rawGateway = (process.env[GATEWAY_ENV] ?? '').trim();
     const gateway = rawGateway
         ? {
-            id: cfg?.gateway.id ?? rawGateway,
-            label: cfg?.gateway.label ?? rawGateway,
+            // An unrecognised value is never echoed: it may be a key pasted into the wrong variable.
+            id: cfg?.gateway.id ?? UNRECOGNISED_GATEWAY,
+            label: cfg?.gateway.label ?? 'an unrecognised gateway',
             usable: gatewayUsable(),
             ...(gatewayProblem() ? { problem: gatewayProblem() } : {}),
         }
@@ -424,7 +507,68 @@ export function runDoctor(options = {}) {
     const grants = syndicates.flatMap((s) => s.grants ?? []).map((g) => ({ agent: g.agent, tools: g.tools, oauth2: { provider: g.provider, grant: g.grant, token_url: '' } }));
     const set = Object.fromEntries([CREDENTIAL_KEY_ENV, OAUTH_REDIRECT_URI_ENV, OAUTH_HOSTS_ENV].map((name) => [name, !!process.env[name]?.trim()]));
     const oauth = grants.length || Object.values(set).some(Boolean) ? { set, problems: oauthEnvProblems(grants) } : undefined;
-    return { agentsDir, runtime: runtimeReport(), syndicates, unlocks, gateway, endpoints: endpointRows(), counts, ...(oauth ? { oauth } : {}) };
+    // The credential host allowlist (ADR 0122): unbound variables named, refusals listed, names and hosts only.
+    const credentialSet = !!process.env[CREDENTIAL_HOSTS_ENV]?.trim();
+    const envs = [...new Set(syndicates.flatMap((s) => s.credentials?.envs ?? []))].sort();
+    let credentials;
+    if (envs.length || credentialSet) {
+        const problems = [];
+        try {
+            credentialHosts();
+        }
+        catch (err) {
+            problems.push(err instanceof Error ? err.message : `${CREDENTIAL_HOSTS_ENV} is malformed`);
+        }
+        if (!problems.length)
+            for (const s of syndicates)
+                for (const p of s.credentials?.problems ?? [])
+                    problems.push(`${s.file}: ${p}`);
+        const warning = unboundCredentialWarning(envs);
+        credentials = { set: credentialSet, envs, ...(warning ? { warning } : {}), problems };
+    }
+    const serving = servingReport();
+    const chatgpt = chatGptReport(!!serving);
+    return {
+        agentsDir,
+        runtime: runtimeReport(),
+        syndicates,
+        unlocks,
+        gateway,
+        endpoints: endpointRows(),
+        counts,
+        ...(oauth ? { oauth } : {}),
+        ...(credentials ? { credentials } : {}),
+        providers: providerPaths(),
+        ...(serving ? { serving } : {}),
+        ...(chatgpt ? { chatgpt } : {}),
+    };
+}
+/**
+ * The Sign in with ChatGPT line (ADR 0126), when a credential file is present
+ * or one of its variables is set. `served`: a serving variable is set, so
+ * this configuration is meant for melchizedek-serve, which refuses to start
+ * while the sign-in is the OpenAI path.
+ */
+export function chatGptReport(served, env = process.env) {
+    const status = chatGptSignInStatus(env);
+    if (!status.present && !env[CHATGPT_SIGNIN_FILE_ENV]?.trim() && !env[CHATGPT_SIGNIN_ENV]?.trim())
+        return undefined;
+    const routesOpenAi = chatGptSignInRoutesOpenAi(env);
+    const problems = [];
+    if (status.problem)
+        problems.push(status.problem);
+    if (served && routesOpenAi) {
+        problems.push(`Sign in with ChatGPT is local only, and it is the OpenAI path in this served configuration: melchizedek-serve and melchizedek-worker refuse to start. Set OPENAI_API_KEY (or Azure OpenAI), or ${CHATGPT_SIGNIN_ENV}=off for the served process.`);
+    }
+    return {
+        file: status.file,
+        enabled: status.enabled,
+        present: status.present,
+        signedIn: status.signedIn,
+        routesOpenAi,
+        ...(status.expiresAt ? { expiresAt: status.expiresAt } : {}),
+        problems,
+    };
 }
 // ── Rendering ────────────────────────────────────────────────────────────────
 const ANSI = {
@@ -445,6 +589,37 @@ const PROBE_ID = {
     moonshot: 'kimi-x',
     ollama: 'ollama/x',
 };
+/**
+ * Why `melchizedek-doctor --check` exits non-zero, one line each; empty when
+ * it passes. A blocked syndicate, a runtime problem, a `MODEL_GATEWAY` that
+ * names no gateway (named with the accepted values only: the value may be a
+ * key pasted into the wrong variable), the OAuth setup's and the credential
+ * allowlist's problems, and each grant whose hosts the OAuth host allowlist
+ * refuses (ADR 0114), and the Sign in with ChatGPT line's problems (ADR 0126).
+ * Names and hosts only, never a value.
+ */
+export function checkProblems(result) {
+    const problems = [];
+    if (result.counts.blocked > 0)
+        problems.push(`${result.counts.blocked} syndicate(s) blocked`);
+    if (result.runtime.problem)
+        problems.push(result.runtime.problem);
+    if (result.gateway?.id === UNRECOGNISED_GATEWAY) {
+        problems.push(`gateway: ${GATEWAY_ENV} is set to an unrecognised value (not shown); it must be one of: ${Object.keys(GATEWAYS).join(', ')}`);
+    }
+    for (const p of result.oauth?.problems ?? [])
+        problems.push(`oauth: ${p}`);
+    for (const p of result.credentials?.problems ?? [])
+        problems.push(`credentials: ${p}`);
+    for (const p of result.chatgpt?.problems ?? [])
+        problems.push(`chatgpt: ${p}`);
+    for (const s of result.syndicates) {
+        for (const g of s.grants ?? [])
+            for (const p of g.hostProblems ?? [])
+                problems.push(`${s.file}: ${g.agent} · ${g.provider}: ${p}`);
+    }
+    return problems;
+}
 function pad(s, n) {
     return s.length >= n ? s.slice(0, n - 1) + '…' : s.padEnd(n);
 }
@@ -471,11 +646,10 @@ export function renderDoctor(result, opts = {}) {
     // Provider line: what is funded, and how. Each provider is probed with an
     // id of its own prefix, so the line names ITS key (a fallthrough once put
     // xAI's key beside Moonshot).
-    const providerBits = Object.keys(PROVIDERS).map((p) => {
-        const r = describeCapabilities(PROBE_ID[p]);
+    const providerBits = (result.providers ?? providerPaths()).map((r) => {
         const mark = !r.funded ? `${c.red}✗${c.reset}` : r.transport === 'gateway' ? `${c.yellow}◇${c.reset}` : `${c.green}✓${c.reset}`;
-        const how = !r.funded ? `${c.dim}${r.keyEnv} not set${c.reset}` : r.transport === 'gateway' ? `${c.dim}via gateway:${r.gateway}${c.reset}` : p === 'ollama' ? `${c.dim}local${c.reset}` : `${c.dim}${r.platform ?? 'direct'}${c.reset}`;
-        return `${mark} ${PROVIDERS[p].label} ${how}`;
+        const how = !r.funded ? `${c.dim}${r.keyEnv} not set${c.reset}` : r.transport === 'gateway' ? `${c.dim}via gateway:${r.gateway}${c.reset}` : r.platform === 'local' ? `${c.dim}local${c.reset}` : r.credential === 'chatgpt-signin' ? `${c.dim}ChatGPT sign-in, local only${c.reset}` : `${c.dim}${r.platform}${c.reset}`;
+        return `${mark} ${r.label} ${how}`;
     });
     lines.push('providers   ' + providerBits.join('   '));
     for (const e of result.endpoints ?? []) {
@@ -490,6 +664,32 @@ export function renderDoctor(result, opts = {}) {
             ? `gateway     ${c.red}✗${c.reset} ${result.gateway.problem}`
             : `gateway     ${c.yellow}◇${c.reset} ${result.gateway.label} fills in for any provider whose direct key is absent ${c.dim}(native search is lost on that path)${c.reset}`);
     }
+    if (result.serving) {
+        // Names only: the A2A identity mode, who pays, and what the server would refuse.
+        const sv = result.serving;
+        const mark = sv.problems.length ? `${c.red}✗${c.reset}` : `${c.green}✓${c.reset}`;
+        const set = Object.entries(sv.set).filter(([, on]) => on).map(([name]) => name).join(', ');
+        lines.push(`serving     ${mark} A2A_AUTH=${sv.auth}${sv.authDeclared ? '' : ' (default)'} · A2A_KEY_MODE=${sv.keyMode} ${c.dim}· set: ${set || 'none'}${c.reset}`);
+        for (const p of sv.problems)
+            lines.push(`            ${c.red}✗ ${p}${c.reset}`);
+    }
+    if (result.chatgpt) {
+        // Presence and the file's path, never a token (ADR 0126).
+        const g = result.chatgpt;
+        const mark = g.problems.length ? `${c.red}✗${c.reset}` : g.routesOpenAi ? `${c.green}✓${c.reset}` : `${c.dim}·${c.reset}`;
+        const state = !g.enabled
+            ? `${CHATGPT_SIGNIN_ENV}=off, ignored`
+            : !g.present
+                ? 'not signed in'
+                : !g.signedIn
+                    ? 'signed out (run melchizedek-setup --chatgpt-signin)'
+                    : g.routesOpenAi
+                        ? 'signed in · carries OpenAI ids · local only'
+                        : 'signed in · not used (OPENAI_API_KEY or another OpenAI endpoint wins)';
+        lines.push(`chatgpt     ${mark} ${state} ${c.dim}· ${g.file}${c.reset}`);
+        for (const p of g.problems)
+            lines.push(`            ${c.red}✗ ${p}${c.reset}`);
+    }
     if (result.oauth) {
         // Names only: which variables are set, never their values (ADR 0114).
         const set = Object.entries(result.oauth.set).map(([name, on]) => `${name} ${on ? 'set' : 'unset'}`).join(' · ');
@@ -498,6 +698,16 @@ export function renderDoctor(result, opts = {}) {
         for (const p of result.oauth.problems)
             lines.push(`            ${c.red}✗ ${p}${c.reset}`);
     }
+    if (result.credentials) {
+        // Names only: which variables are sent, never their values (ADR 0122).
+        const cr = result.credentials;
+        const mark = cr.problems.length ? `${c.red}✗${c.reset}` : cr.warning ? `${c.yellow}⚠${c.reset}` : `${c.green}✓${c.reset}`;
+        lines.push(`credentials ${mark} ${c.dim}${CREDENTIAL_HOSTS_ENV} ${cr.set ? 'set' : 'unset'}${cr.envs.length ? ` · sent: ${cr.envs.join(', ')}` : ''}${c.reset}`);
+        if (cr.warning)
+            lines.push(`            ${c.yellow}⚠ ${cr.warning}${c.reset}`);
+        for (const p of cr.problems)
+            lines.push(`            ${c.red}✗ ${p}${c.reset}`);
+    }
     lines.push('');
     // The table: one line per syndicate (name, verdict, run command), then
     // one indented line per agent.

package/dist/lib/loadSyndicate.d.ts

@@ -3,6 +3,8 @@ export type { DispatchConfig } from './dispatch.ts';
 import type { SkillsConfig } from './tools/skillToolset.ts';
 import type { OpenApiConfig } from './tools/openapiTools.ts';
 import type { McpAuthConfig } from './tools/oauthTools.ts';
+import type { McpTransportKind } from './tools/mcpTransports.ts';
+import type { McpServerConfig } from './tools/mcpToolFactory.ts';
 import type { ContextConfig, ExampleConfig } from './compile.ts';
 export type { OpenApiConfig } from './tools/openapiTools.ts';
 export type { SkillsConfig } from './tools/skillToolset.ts';
@@ -129,6 +131,15 @@ export interface AgentYamlConfig {
         schema?: Record<string, unknown>;
         mime?: 'application/json' | 'text/plain';
     };
+    /**
+     * Which tools the model may call (v2, ADR 0117): `auto`, `none`,
+     * `required`, or `{ name }` for one tool. Replaces
+     * generateContentConfig.toolConfig.functionCallingConfig; folded into it
+     * by the loader (lib/agentDialect.ts toEngineAgent).
+     */
+    tool_choice?: 'auto' | 'none' | 'required' | {
+        name: string;
+    };
     /**
      * Per-provider instruction (v2), keyed by provider id (lib/models/providerMap.ts):
      * `instruction` replaces the agent's instruction, `instruction_append` is
@@ -144,6 +155,10 @@ export interface AgentYamlConfig {
     mcp_tools?: string[];
     /** The OAuth grant the MCP server takes (ADR 0112): each user's, or the server's own. */
     mcp_auth?: McpAuthConfig;
+    /** How mcp_server_url is reached: auto (the default), streamable_http or sse (ADR 0124). */
+    mcp_transport?: McpTransportKind;
+    /** Several MCP servers, each with its tools, grant and transport (ADR 0124). Not with mcp_server_url. */
+    mcp_servers?: McpServerConfig[];
     /** Answers when `model` fails provider-side, or its provider's circuit is open (ADR 0044). */
     fallback_model?: string;
     /**