melchizedek-agents 1.1.0 → 1.3.0

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

@@ -45,6 +45,47 @@ export interface TurnControl {
     stopReason?: TurnStopReason;
     /** Stop the turn. The first reason wins. */
     stop(reason: TurnStopReason): void;
+    /**
+     * Runs a nested dispatch syndicate as its own turn on its own
+     * conversation, under this turn's controls (ADR 0120): set by the turn
+     * runner (lib/runtime/syndicateTurn.ts), read where a nested dispatch
+     * syndicate runs (a delegated call, a dispatch route, a workflow node),
+     * which sit below the turn runner and cannot import it.
+     */
+    nestedDispatch?: (run: NestedDispatchRun) => Promise<NestedDispatchEnd>;
+}
+/** One run of a nested dispatch syndicate (ADR 0120): what it is, where its conversation is filed, and the message. */
+export interface NestedDispatchRun {
+    /** The nested syndicate's config (a SyndicateYamlConfig with a `dispatch:` block). */
+    config: unknown;
+    /** The compile options it loads its routes with (CompileOptions, its nesting chain included). */
+    compile: unknown;
+    /** The entry's name: the nested syndicate as its caller lists it. */
+    name: string;
+    /** The store, and the key its conversation is filed under (already opened by the caller). */
+    sessions: unknown;
+    appName: string;
+    userId: string;
+    sessionId: string;
+    /** The message's parts: the request, or the answer to what waits in it. */
+    parts: unknown[];
+}
+/** How a nested dispatch syndicate's turn ended (ADR 0120). */
+export interface NestedDispatchEnd {
+    status: 'completed' | 'input-required' | 'failed' | 'canceled';
+    /** The route's final text: the nested syndicate's answer. */
+    text: string;
+    /** Its conversation's state writes this run, `temp:` keys aside. */
+    stateDelta: Record<string, unknown>;
+    /** What it waits on, when paused: the request's id, and the request as the turn reports it (a PendingApproval, a PendingInput, a PendingConsent). */
+    interruptId?: string;
+    approval?: unknown;
+    input?: unknown;
+    consent?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
 }
 export interface TurnControlOptions {
     maxLlmCalls?: number;

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

@@ -232,6 +232,15 @@ export declare class ProjectedSessionService implements SessionService {
      * The event lands in the projected session the runtime holds and, through
      * the store, in the real one `get` read. A session `get` did not hand out
      * is the real one, and the store alone applies the event to it.
+     *
+     * A store may answer an append with events of its own: a durable run's
+     * store restoring a checkpoint (lib/runtime/native/checkpoint.ts, ADR 0113)
+     * answers the opening message with the run's stored events, the stored
+     * opening returned in place of the one given. The projected session then
+     * takes, in place of the event given, every event the real session gained,
+     * unprojected: they are the current turn, which is never projected. The
+     * agent loop thereby reads the restored steps, as it would on the store's
+     * own session.
      */
     append(session: EngineSession, event: TurnEvent): Promise<TurnEvent>;
 }

package/dist/lib/session/transcript.js

@@ -340,6 +340,15 @@ export class ProjectedSessionService {
      * The event lands in the projected session the runtime holds and, through
      * the store, in the real one `get` read. A session `get` did not hand out
      * is the real one, and the store alone applies the event to it.
+     *
+     * A store may answer an append with events of its own: a durable run's
+     * store restoring a checkpoint (lib/runtime/native/checkpoint.ts, ADR 0113)
+     * answers the opening message with the run's stored events, the stored
+     * opening returned in place of the one given. The projected session then
+     * takes, in place of the event given, every event the real session gained,
+     * unprojected: they are the current turn, which is never projected. The
+     * agent loop thereby reads the restored steps, as it would on the store's
+     * own session.
      */
     async append(session, event) {
         if (event.partial)
@@ -347,7 +356,17 @@ export class ProjectedSessionService {
         const real = this.stored.get(this.key(session.appName, session.userId, session.id));
         if (!real || real === session)
             return this.own.append(session, event);
+        const before = real.events.length;
+        const at = session.events.length;
         applyEvent(session, event);
-        return this.own.append(real, event);
+        const stored = await this.own.append(real, event);
+        if (stored.id !== event.id) {
+            // The store answered with its own events: they replace the one applied above.
+            if (session.events[at]?.id === event.id)
+                session.events.splice(at, 1);
+            for (const gained of real.events.slice(before))
+                applyEvent(session, gained);
+        }
+        return stored;
     }
 }

package/dist/lib/skills.d.ts

@@ -48,3 +48,21 @@ export interface InstallResult {
 export declare function destinationsFor(opts: InstallOptions): string[];
 /** Copy the suite into every destination. Returns one result per destination. */
 export declare function installSkills(opts?: InstallOptions): InstallResult[];
+/** The markers that delimit the block this installer owns inside AGENTS.md. */
+export declare const AGENTS_MD_BEGIN = "<!-- melchizedek-skills:begin -->";
+export declare const AGENTS_MD_END = "<!-- melchizedek-skills:end -->";
+/** The pointer: where the skills are, and the onboarding entry point. */
+export declare function agentsMdBlock(destinations: string[], projectRoot: string): string;
+export interface AgentsMdResult {
+    path: string;
+    status: 'created' | 'appended' | 'updated' | 'unchanged';
+}
+/**
+ * Write the pointer into `<projectRoot>/AGENTS.md`, the instructions file
+ * Codex and other agents read: create the file when absent, append the block
+ * when the file has none, or replace only the block between the markers.
+ * Nothing outside the markers is ever changed.
+ */
+export declare function writeAgentsMdPointer(projectRoot: string, destinations: string[], opts?: {
+    dryRun?: boolean;
+}): AgentsMdResult;

package/dist/lib/skills.js

@@ -15,7 +15,7 @@
  * A SKILL.md's frontmatter is read by the skills harness's own parser
  * (lib/tools/skills/frontmatter.ts), the one an agent's `skills:` uses.
  */
-import { closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { closeSync, constants as fsConstants, existsSync, fstatSync, ftruncateSync, lstatSync, mkdirSync, openSync, readSync, readdirSync, readFileSync, statSync, writeFileSync, writeSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -162,3 +162,75 @@ export function installSkills(opts = {}) {
     }
     return results;
 }
+// ── The AGENTS.md pointer ────────────────────────────────────────────────────
+/** The markers that delimit the block this installer owns inside AGENTS.md. */
+export const AGENTS_MD_BEGIN = '<!-- melchizedek-skills:begin -->';
+export const AGENTS_MD_END = '<!-- melchizedek-skills:end -->';
+/** The pointer: where the skills are, and the onboarding entry point. */
+export function agentsMdBlock(destinations, projectRoot) {
+    const where = destinations.map((d) => `\`${relative(projectRoot, d) || '.'}/\``).join(' and ');
+    return [
+        AGENTS_MD_BEGIN,
+        '## Melchizedek agent skills',
+        '',
+        `The melchizedek-agents skills are installed in ${where}, one directory per skill with a SKILL.md.`,
+        'To onboard someone, start with `melchizedek-onboard/SKILL.md`, or run `npx melchizedek-setup --auto`.',
+        'Never ask for an API key in chat and never print a value from `.env`: the person types keys into `.env` themselves.',
+        AGENTS_MD_END,
+    ].join('\n');
+}
+/**
+ * Write the pointer into `<projectRoot>/AGENTS.md`, the instructions file
+ * Codex and other agents read: create the file when absent, append the block
+ * when the file has none, or replace only the block between the markers.
+ * Nothing outside the markers is ever changed.
+ */
+export function writeAgentsMdPointer(projectRoot, destinations, opts = {}) {
+    const path = join(resolve(projectRoot), 'AGENTS.md');
+    const block = agentsMdBlock(destinations, resolve(projectRoot));
+    const plan = (text) => {
+        if (text === undefined)
+            return { status: 'created', next: `# AGENTS.md\n\n${block}\n` };
+        const start = text.indexOf(AGENTS_MD_BEGIN);
+        const end = text.indexOf(AGENTS_MD_END);
+        if (start !== -1 && end > start) {
+            const next = text.slice(0, start) + block + text.slice(end + AGENTS_MD_END.length);
+            return { status: next === text ? 'unchanged' : 'updated', next };
+        }
+        return { status: 'appended', next: `${text}${text.endsWith('\n') ? '' : '\n'}\n${block}\n` };
+    };
+    if (opts.dryRun) {
+        // Nothing is written, so a path check is enough to report what would happen.
+        if (existsSync(path) && lstatSync(path).isSymbolicLink())
+            throw new Error(`refusing to write through a symlink: ${path}`);
+        return { path, status: plan(existsSync(path) ? readFileSync(path, 'utf-8') : undefined).status };
+    }
+    // One handle for the read and the write, so the file read is the file written:
+    // created if absent, never followed through a symlink (O_NOFOLLOW).
+    let fd;
+    try {
+        fd = openSync(path, fsConstants.O_RDWR | fsConstants.O_CREAT | (fsConstants.O_NOFOLLOW ?? 0), 0o644);
+    }
+    catch (err) {
+        if (err.code === 'ELOOP')
+            throw new Error(`refusing to write through a symlink: ${path}`);
+        throw err;
+    }
+    let status;
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile())
+            throw new Error(`not a regular file: ${path}`);
+        const existing = stat.size > 0 ? readFileSync(fd, 'utf-8') : undefined;
+        const result = plan(existing);
+        status = result.status;
+        if (status !== 'unchanged') {
+            ftruncateSync(fd, 0);
+            writeSync(fd, result.next, 0);
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+    return { path, status };
+}

package/dist/lib/storage/postgres/index.d.ts

@@ -21,7 +21,7 @@ import type { CredentialStoreOptions } from '../../tools/credentialStore.ts';
 import type { CredentialStore } from '../../tools/auth.ts';
 import type { AuditSink } from '../../observability/audit.ts';
 import type { RlsHardeningStatus } from '../rlsStatus.ts';
-import type { TaskBackend } from '../../tools/taskTools.ts';
+import type { TaskBackend, TaskBackendOptions } from '../../tools/taskTools.ts';
 import type { TurnLock } from '../../a2a/turnLock.ts';
 import type { PostgresTaskStoreOptions } from './taskStore.ts';
 export { PostgresSessionService } from './sessionService.ts';
@@ -73,6 +73,11 @@ export interface PostgresStorageOptions {
      * go to this storage's audit trail.
      */
     credentials?: Omit<CredentialStoreOptions, 'rows' | 'audit'>;
+    /**
+     * The job queue's checkpoints (ADR 0113): the largest one stored, in bytes
+     * of JSON (default 5 MiB), and where a skipped save is logged.
+     */
+    taskQueue?: TaskBackendOptions;
 }
 export interface PostgresStorage {
     pool: Pool;

package/dist/lib/storage/postgres/index.js

@@ -120,7 +120,7 @@ export function postgresStorage(options) {
             reap: () => reapExpiredTasks(pool),
             cancelRequested: () => cancelRequestedTasks(pool, lease),
         },
-        taskQueue: postgresTaskBackend(pool),
+        taskQueue: postgresTaskBackend(pool, options.taskQueue),
         async schemaVersion() {
             try {
                 const r = await pool.query('SELECT max(version) AS v FROM melchizedek_schema_version');

package/dist/lib/storage/postgres/taskQueue.d.ts

@@ -27,8 +27,12 @@
  * survives while the job is running or queued: recover's requeue keeps it,
  * so the next claim resumes from it, and claimNext leaves it; a mutate that
  * moves the job to any other status, or recover failing it, clears it; a
- * deleted row takes it along.
+ * deleted row takes it along. A checkpoint whose JSON is above the cap
+ * (TaskBackendOptions.checkpointMaxBytes, default 5 MiB) is not written:
+ * the column keeps the previous one, the save still reports the claim, and
+ * one line names the job id and the sizes.
  */
 import type { Pool } from 'pg';
-import type { TaskBackend } from '../../tools/taskTools.ts';
-export declare function postgresTaskBackend(pool: Pool): TaskBackend;
+import type { TaskBackend, TaskBackendOptions } from '../../tools/taskTools.ts';
+/** The task backend on `pool`; `options` caps the checkpoint a save stores (TaskBackendOptions). */
+export declare function postgresTaskBackend(pool: Pool, options?: TaskBackendOptions): TaskBackend;

package/dist/lib/storage/postgres/taskQueue.js

@@ -1,4 +1,4 @@
-import { applyFinish, applyInterrupted } from '../../tools/taskTools.js';
+import { applyFinish, applyInterrupted, checkpointJson } from '../../tools/taskTools.js';
 const seqOf = (id) => Number(id.slice(1)) || 0;
 async function loadOwner(db, owner, lock) {
     const head = await db.query(`SELECT next_id FROM melchizedek_task_owners WHERE owner = $1${lock ? ' FOR UPDATE' : ''}`, [owner]);
@@ -21,7 +21,8 @@ async function inTransaction(pool, run) {
         client.release();
     }
 }
-export function postgresTaskBackend(pool) {
+/** The task backend on `pool`; `options` caps the checkpoint a save stores (TaskBackendOptions). */
+export function postgresTaskBackend(pool, options = {}) {
     return {
         read: (owner) => loadOwner(pool, owner, false),
         async mutate(owner, change) {
@@ -82,8 +83,14 @@ export function postgresTaskBackend(pool) {
             return (r.rowCount ?? 0) > 0;
         },
         async saveCheckpoint(worker, job, checkpoint) {
+            const json = checkpointJson(job, checkpoint, options);
+            if (json === null) {
+                // Over the cap: the previous checkpoint is kept; the answer is still whether the claim holds.
+                const held = await pool.query(`SELECT 1 FROM melchizedek_tasks WHERE owner = $1 AND id = $2 AND lease_owner = $3 AND status = 'running'`, [job.owner, job.id, worker.workerId]);
+                return (held.rowCount ?? 0) > 0;
+            }
             const r = await pool.query(`UPDATE melchizedek_tasks SET checkpoint = $4::jsonb, checkpoint_at = NOW()
-          WHERE owner = $1 AND id = $2 AND lease_owner = $3 AND status = 'running'`, [job.owner, job.id, worker.workerId, JSON.stringify(checkpoint)]);
+          WHERE owner = $1 AND id = $2 AND lease_owner = $3 AND status = 'running'`, [job.owner, job.id, worker.workerId, json]);
             return (r.rowCount ?? 0) > 0;
         },
         async loadCheckpoint(job) {

package/dist/lib/syndicateSchema.d.ts

@@ -24,9 +24,12 @@
 import { z } from 'zod';
 import type { SyndicateYamlConfig } from './loadSyndicate.ts';
 export declare const MEMORY_SYSTEMS: readonly ['internal-only', 'session-only', 'long-term'];
-export declare const REASONING_LEVELS: readonly ['none', 'low', 'medium', 'high'];
+export declare const REASONING_LEVELS: readonly ['none', 'low', 'medium', 'high', 'xhigh', 'max'];
 export declare const OUTPUT_MIMES: readonly ['application/json', 'text/plain'];
+export declare const TOOL_CHOICE_MODES: readonly ['auto', 'none', 'required'];
 export declare const SKILL_SCRIPT_MODES: readonly ['none', 'local'];
+/** An `mcp_servers` entry's name: lowercase, bounded, one character class (no backtracking). */
+export declare const MCP_SERVER_NAME: RegExp;
 export declare const agentSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -67,8 +70,10 @@ export declare const agentSchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         high: "high";
         low: "low";
+        max: "max";
         medium: "medium";
         none: "none";
+        xhigh: "xhigh";
     }>, z.ZodObject<{
         budget_tokens: z.ZodNumber;
     }, z.core.$strict>]>>;
@@ -85,6 +90,13 @@ export declare const agentSchema: z.ZodObject<{
             "text/plain": "text/plain";
         }>>;
     }, z.core.$strict>>;
+    tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        auto: "auto";
+        none: "none";
+        required: "required";
+    }>, z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>]>>;
     model_overrides: z.ZodOptional<z.ZodObject<{
         gemini: z.ZodOptional<z.ZodObject<{
             instruction: z.ZodOptional<z.ZodString>;
@@ -121,8 +133,9 @@ export declare const agentSchema: z.ZodObject<{
                 authorization_code: "authorization_code";
                 client_credentials: "client_credentials";
             }>;
+            client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
             authorization_url: z.ZodOptional<z.ZodString>;
-            token_url: z.ZodString;
+            token_url: z.ZodOptional<z.ZodString>;
             client_id: z.ZodOptional<z.ZodString>;
             client_id_env: z.ZodOptional<z.ZodString>;
             client_secret_env: z.ZodOptional<z.ZodString>;
@@ -130,6 +143,38 @@ export declare const agentSchema: z.ZodObject<{
             authorization_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strict>;
     }, z.core.$strict>>;
+    mcp_transport: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        sse: "sse";
+        streamable_http: "streamable_http";
+    }>>;
+    mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+        tools: z.ZodArray<z.ZodString>;
+        auth: z.ZodOptional<z.ZodObject<{
+            oauth2: z.ZodObject<{
+                provider: z.ZodString;
+                grant: z.ZodEnum<{
+                    authorization_code: "authorization_code";
+                    client_credentials: "client_credentials";
+                }>;
+                client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
+                authorization_url: z.ZodOptional<z.ZodString>;
+                token_url: z.ZodOptional<z.ZodString>;
+                client_id: z.ZodOptional<z.ZodString>;
+                client_id_env: z.ZodOptional<z.ZodString>;
+                client_secret_env: z.ZodOptional<z.ZodString>;
+                scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                authorization_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        transport: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            sse: "sse";
+            streamable_http: "streamable_http";
+        }>>;
+    }, z.core.$strict>>>;
     skills: z.ZodOptional<z.ZodObject<{
         dir: z.ZodString;
         scripts: z.ZodOptional<z.ZodEnum<{
@@ -161,8 +206,9 @@ export declare const agentSchema: z.ZodObject<{
                     authorization_code: "authorization_code";
                     client_credentials: "client_credentials";
                 }>;
+                client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
                 authorization_url: z.ZodOptional<z.ZodString>;
-                token_url: z.ZodString;
+                token_url: z.ZodOptional<z.ZodString>;
                 client_id: z.ZodOptional<z.ZodString>;
                 client_id_env: z.ZodOptional<z.ZodString>;
                 client_secret_env: z.ZodOptional<z.ZodString>;
@@ -233,8 +279,10 @@ export declare const subagentSchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         high: "high";
         low: "low";
+        max: "max";
         medium: "medium";
         none: "none";
+        xhigh: "xhigh";
     }>, z.ZodObject<{
         budget_tokens: z.ZodNumber;
     }, z.core.$strict>]>>;
@@ -251,6 +299,13 @@ export declare const subagentSchema: z.ZodObject<{
             "text/plain": "text/plain";
         }>>;
     }, z.core.$strict>>;
+    tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        auto: "auto";
+        none: "none";
+        required: "required";
+    }>, z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>]>>;
     model_overrides: z.ZodOptional<z.ZodObject<{
         gemini: z.ZodOptional<z.ZodObject<{
             instruction: z.ZodOptional<z.ZodString>;
@@ -287,8 +342,9 @@ export declare const subagentSchema: z.ZodObject<{
                 authorization_code: "authorization_code";
                 client_credentials: "client_credentials";
             }>;
+            client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
             authorization_url: z.ZodOptional<z.ZodString>;
-            token_url: z.ZodString;
+            token_url: z.ZodOptional<z.ZodString>;
             client_id: z.ZodOptional<z.ZodString>;
             client_id_env: z.ZodOptional<z.ZodString>;
             client_secret_env: z.ZodOptional<z.ZodString>;
@@ -296,6 +352,38 @@ export declare const subagentSchema: z.ZodObject<{
             authorization_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strict>;
     }, z.core.$strict>>;
+    mcp_transport: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        sse: "sse";
+        streamable_http: "streamable_http";
+    }>>;
+    mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+        tools: z.ZodArray<z.ZodString>;
+        auth: z.ZodOptional<z.ZodObject<{
+            oauth2: z.ZodObject<{
+                provider: z.ZodString;
+                grant: z.ZodEnum<{
+                    authorization_code: "authorization_code";
+                    client_credentials: "client_credentials";
+                }>;
+                client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
+                authorization_url: z.ZodOptional<z.ZodString>;
+                token_url: z.ZodOptional<z.ZodString>;
+                client_id: z.ZodOptional<z.ZodString>;
+                client_id_env: z.ZodOptional<z.ZodString>;
+                client_secret_env: z.ZodOptional<z.ZodString>;
+                scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                authorization_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        transport: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            sse: "sse";
+            streamable_http: "streamable_http";
+        }>>;
+    }, z.core.$strict>>>;
     skills: z.ZodOptional<z.ZodObject<{
         dir: z.ZodString;
         scripts: z.ZodOptional<z.ZodEnum<{
@@ -327,8 +415,9 @@ export declare const subagentSchema: z.ZodObject<{
                     authorization_code: "authorization_code";
                     client_credentials: "client_credentials";
                 }>;
+                client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
                 authorization_url: z.ZodOptional<z.ZodString>;
-                token_url: z.ZodString;
+                token_url: z.ZodOptional<z.ZodString>;
                 client_id: z.ZodOptional<z.ZodString>;
                 client_id_env: z.ZodOptional<z.ZodString>;
                 client_secret_env: z.ZodOptional<z.ZodString>;
@@ -403,8 +492,10 @@ export declare const syndicateSchema: z.ZodObject<{
         reasoning: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
             high: "high";
             low: "low";
+            max: "max";
             medium: "medium";
             none: "none";
+            xhigh: "xhigh";
         }>, z.ZodObject<{
             budget_tokens: z.ZodNumber;
         }, z.core.$strict>]>>;
@@ -421,6 +512,13 @@ export declare const syndicateSchema: z.ZodObject<{
                 "text/plain": "text/plain";
             }>>;
         }, z.core.$strict>>;
+        tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            auto: "auto";
+            none: "none";
+            required: "required";
+        }>, z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>]>>;
         model_overrides: z.ZodOptional<z.ZodObject<{
             gemini: z.ZodOptional<z.ZodObject<{
                 instruction: z.ZodOptional<z.ZodString>;
@@ -457,8 +555,9 @@ export declare const syndicateSchema: z.ZodObject<{
                     authorization_code: "authorization_code";
                     client_credentials: "client_credentials";
                 }>;
+                client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
                 authorization_url: z.ZodOptional<z.ZodString>;
-                token_url: z.ZodString;
+                token_url: z.ZodOptional<z.ZodString>;
                 client_id: z.ZodOptional<z.ZodString>;
                 client_id_env: z.ZodOptional<z.ZodString>;
                 client_secret_env: z.ZodOptional<z.ZodString>;
@@ -466,6 +565,38 @@ export declare const syndicateSchema: z.ZodObject<{
                 authorization_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strict>;
         }, z.core.$strict>>;
+        mcp_transport: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            sse: "sse";
+            streamable_http: "streamable_http";
+        }>>;
+        mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodString;
+            tools: z.ZodArray<z.ZodString>;
+            auth: z.ZodOptional<z.ZodObject<{
+                oauth2: z.ZodObject<{
+                    provider: z.ZodString;
+                    grant: z.ZodEnum<{
+                        authorization_code: "authorization_code";
+                        client_credentials: "client_credentials";
+                    }>;
+                    client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
+                    authorization_url: z.ZodOptional<z.ZodString>;
+                    token_url: z.ZodOptional<z.ZodString>;
+                    client_id: z.ZodOptional<z.ZodString>;
+                    client_id_env: z.ZodOptional<z.ZodString>;
+                    client_secret_env: z.ZodOptional<z.ZodString>;
+                    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    authorization_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            transport: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                sse: "sse";
+                streamable_http: "streamable_http";
+            }>>;
+        }, z.core.$strict>>>;
         skills: z.ZodOptional<z.ZodObject<{
             dir: z.ZodString;
             scripts: z.ZodOptional<z.ZodEnum<{
@@ -497,8 +628,9 @@ export declare const syndicateSchema: z.ZodObject<{
                         authorization_code: "authorization_code";
                         client_credentials: "client_credentials";
                     }>;
+                    client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
                     authorization_url: z.ZodOptional<z.ZodString>;
-                    token_url: z.ZodString;
+                    token_url: z.ZodOptional<z.ZodString>;
                     client_id: z.ZodOptional<z.ZodString>;
                     client_id_env: z.ZodOptional<z.ZodString>;
                     client_secret_env: z.ZodOptional<z.ZodString>;
@@ -563,8 +695,10 @@ export declare const syndicateSchema: z.ZodObject<{
         reasoning: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
             high: "high";
             low: "low";
+            max: "max";
             medium: "medium";
             none: "none";
+            xhigh: "xhigh";
         }>, z.ZodObject<{
             budget_tokens: z.ZodNumber;
         }, z.core.$strict>]>>;
@@ -581,6 +715,13 @@ export declare const syndicateSchema: z.ZodObject<{
                 "text/plain": "text/plain";
             }>>;
         }, z.core.$strict>>;
+        tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            auto: "auto";
+            none: "none";
+            required: "required";
+        }>, z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>]>>;
         model_overrides: z.ZodOptional<z.ZodObject<{
             gemini: z.ZodOptional<z.ZodObject<{
                 instruction: z.ZodOptional<z.ZodString>;
@@ -617,8 +758,9 @@ export declare const syndicateSchema: z.ZodObject<{
                     authorization_code: "authorization_code";
                     client_credentials: "client_credentials";
                 }>;
+                client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
                 authorization_url: z.ZodOptional<z.ZodString>;
-                token_url: z.ZodString;
+                token_url: z.ZodOptional<z.ZodString>;
                 client_id: z.ZodOptional<z.ZodString>;
                 client_id_env: z.ZodOptional<z.ZodString>;
                 client_secret_env: z.ZodOptional<z.ZodString>;
@@ -626,6 +768,38 @@ export declare const syndicateSchema: z.ZodObject<{
                 authorization_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strict>;
         }, z.core.$strict>>;
+        mcp_transport: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            sse: "sse";
+            streamable_http: "streamable_http";
+        }>>;
+        mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodString;
+            tools: z.ZodArray<z.ZodString>;
+            auth: z.ZodOptional<z.ZodObject<{
+                oauth2: z.ZodObject<{
+                    provider: z.ZodString;
+                    grant: z.ZodEnum<{
+                        authorization_code: "authorization_code";
+                        client_credentials: "client_credentials";
+                    }>;
+                    client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
+                    authorization_url: z.ZodOptional<z.ZodString>;
+                    token_url: z.ZodOptional<z.ZodString>;
+                    client_id: z.ZodOptional<z.ZodString>;
+                    client_id_env: z.ZodOptional<z.ZodString>;
+                    client_secret_env: z.ZodOptional<z.ZodString>;
+                    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    authorization_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            transport: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                sse: "sse";
+                streamable_http: "streamable_http";
+            }>>;
+        }, z.core.$strict>>>;
         skills: z.ZodOptional<z.ZodObject<{
             dir: z.ZodString;
             scripts: z.ZodOptional<z.ZodEnum<{
@@ -657,8 +831,9 @@ export declare const syndicateSchema: z.ZodObject<{
                         authorization_code: "authorization_code";
                         client_credentials: "client_credentials";
                     }>;
+                    client_registration: z.ZodOptional<z.ZodLiteral<"dynamic">>;
                     authorization_url: z.ZodOptional<z.ZodString>;
-                    token_url: z.ZodString;
+                    token_url: z.ZodOptional<z.ZodString>;
                     client_id: z.ZodOptional<z.ZodString>;
                     client_id_env: z.ZodOptional<z.ZodString>;
                     client_secret_env: z.ZodOptional<z.ZodString>;