@kbediako/codex-orchestrator 0.1.38 → 0.2.1

package/dist/orchestrator/src/cli/delegationServerCliShell.js

@@ -0,0 +1,52 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+import process from 'node:process';
+import { splitDelegationConfigOverrides } from './config/delegationConfig.js';
+import { startDelegationServer } from './delegationServer.js';
+const DEFAULT_DEPENDENCIES = {
+    startDelegationServer,
+    getCwd: () => process.cwd(),
+    getEnvMode: () => process.env.CODEX_DELEGATE_MODE,
+    warn: (line) => console.warn(line)
+};
+export async function runDelegationServerCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    if (isHelpRequest(params.positionals, params.flags)) {
+        params.printHelp();
+        return;
+    }
+    const repoRoot = readStringFlag(params.flags, 'repo') ?? dependencies.getCwd();
+    const modeFlag = readStringFlag(params.flags, 'mode');
+    const overrideFlag = readStringFlag(params.flags, 'config') ?? readStringFlag(params.flags, 'config-override');
+    const envMode = dependencies.getEnvMode()?.trim();
+    const resolvedMode = modeFlag ?? envMode;
+    let mode;
+    if (resolvedMode) {
+        if (isDelegationMode(resolvedMode)) {
+            mode = resolvedMode;
+        }
+        else {
+            dependencies.warn(`Invalid delegate mode "${resolvedMode}". Falling back to config default.`);
+        }
+    }
+    const configOverrides = overrideFlag
+        ? splitDelegationConfigOverrides(overrideFlag).map((value) => ({
+            source: 'cli',
+            value
+        }))
+        : [];
+    await dependencies.startDelegationServer({ repoRoot, mode, configOverrides });
+}
+function isHelpRequest(positionals, flags) {
+    if (flags['help'] !== undefined) {
+        return true;
+    }
+    const first = positionals[0];
+    return first === 'help' || first === '--help' || first === '-h';
+}
+function readStringFlag(flags, key) {
+    const value = flags[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function isDelegationMode(value) {
+    return value === 'full' || value === 'question_only' || value === 'status_only';
+}

package/dist/orchestrator/src/cli/delegationServerQuestionFlowShell.js

@@ -0,0 +1,228 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import process from 'node:process';
+export const QUESTION_POLL_INTERVAL_MS = 500;
+export const MAX_QUESTION_POLL_WAIT_MS = 10_000;
+export async function handleDelegationServerQuestionEnqueue(input, request, allowedRoots, allowedHosts, expiryFallback, deps) {
+    const parentManifestPath = deps.resolveParentManifestPath(input, allowedRoots);
+    if (!parentManifestPath) {
+        throw new Error('parent_manifest_path is required');
+    }
+    const delegationToken = await resolveDelegationTokenValue(request, allowedRoots, {
+        retryMs: deps.defaultDelegationTokenRetryMs,
+        intervalMs: deps.defaultDelegationTokenRetryIntervalMs
+    }, deps);
+    const childRunId = process.env.CODEX_ORCHESTRATOR_RUN_ID ?? deps.readStringValue(input, 'from_run_id', 'fromRunId') ?? '';
+    if (!delegationToken) {
+        throw new Error('delegation_token missing');
+    }
+    const autoPause = deps.readBooleanValue(input, 'auto_pause', 'autoPause') ?? true;
+    const manifestFromEnv = process.env.CODEX_ORCHESTRATOR_MANIFEST_PATH;
+    const manifestFromInput = deps.readStringValue(input, 'from_manifest_path', 'fromManifestPath');
+    const childManifestPath = manifestFromEnv ?? manifestFromInput;
+    const result = await deps.callControlEndpointWithRetry(parentManifestPath, '/questions/enqueue', {
+        parent_run_id: deps.readStringValue(input, 'parent_run_id', 'parentRunId') ?? '',
+        parent_task_id: deps.readStringValue(input, 'parent_task_id', 'parentTaskId') ?? null,
+        from_run_id: childRunId,
+        from_manifest_path: childManifestPath ?? null,
+        prompt: deps.requireString(deps.readStringValue(input, 'prompt'), 'prompt'),
+        urgency: deps.readStringValue(input, 'urgency') ?? 'med',
+        expires_in_ms: deps.readNumberValue(input, 'expires_in_ms', 'expiresInMs'),
+        auto_pause: autoPause,
+        expiry_fallback: expiryFallback
+    }, {
+        [deps.delegationTokenHeader]: delegationToken,
+        [deps.delegationRunHeader]: childRunId
+    }, {
+        allowedHosts,
+        allowedRoots,
+        retryMs: deps.defaultDelegationTokenRetryMs,
+        retryIntervalMs: deps.defaultDelegationTokenRetryIntervalMs
+    });
+    if (autoPause && manifestFromEnv) {
+        const resolvedManifest = deps.resolveRunManifestPath(manifestFromEnv, allowedRoots, 'manifest_path');
+        await deps.callControlEndpoint(resolvedManifest, '/control/action', {
+            action: 'pause',
+            requested_by: 'delegate',
+            reason: 'awaiting_question_answer'
+        }, undefined, { allowedHosts, allowedRoots });
+    }
+    return {
+        ...result,
+        fallback_action: expiryFallback
+    };
+}
+export async function handleDelegationServerQuestionPoll(input, request, allowedRoots, allowedHosts, expiryFallback, deps) {
+    const parentManifestPath = deps.resolveParentManifestPath(input, allowedRoots);
+    if (!parentManifestPath) {
+        throw new Error('parent_manifest_path is required');
+    }
+    const delegationToken = await resolveDelegationTokenValue(request, allowedRoots, {
+        retryMs: deps.defaultDelegationTokenRetryMs,
+        intervalMs: deps.defaultDelegationTokenRetryIntervalMs
+    }, deps);
+    const childRunId = process.env.CODEX_ORCHESTRATOR_RUN_ID ?? deps.readStringValue(input, 'from_run_id', 'fromRunId') ?? '';
+    if (!delegationToken) {
+        throw new Error('delegation_token missing');
+    }
+    const questionId = deps.requireString(deps.readStringValue(input, 'question_id', 'questionId'), 'question_id');
+    const requestedWaitMs = deps.readNumberValue(input, 'wait_ms', 'waitMs') ?? 0;
+    const waitMs = clampQuestionPollWaitMs(requestedWaitMs);
+    const deadline = Date.now() + waitMs;
+    const maxIterations = waitMs > 0 ? Math.max(1, Math.ceil(waitMs / QUESTION_POLL_INTERVAL_MS)) : 1;
+    for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+        const remainingMs = waitMs > 0 ? Math.max(0, deadline - Date.now()) : null;
+        const timeoutMs = remainingMs === null ? undefined : Math.max(1, Math.min(deps.defaultControlEndpointTimeoutMs, remainingMs));
+        const retryMs = remainingMs === null
+            ? deps.defaultDelegationTokenRetryMs
+            : Math.min(deps.defaultDelegationTokenRetryMs, remainingMs);
+        const record = await deps.callControlEndpointWithRetry(parentManifestPath, `/questions/${questionId}`, null, {
+            [deps.delegationTokenHeader]: delegationToken,
+            [deps.delegationRunHeader]: childRunId
+        }, {
+            allowedHosts,
+            allowedRoots,
+            retryMs,
+            retryIntervalMs: deps.defaultDelegationTokenRetryIntervalMs,
+            ...(timeoutMs !== undefined ? { timeoutMs } : {})
+        });
+        const status = deps.readStringValue(record, 'status');
+        if (status !== 'queued' || waitMs <= 0 || Date.now() >= deadline) {
+            const expiresAt = deps.readStringValue(record, 'expires_at', 'expiresAt');
+            if (status === 'expired') {
+                await applyDelegationQuestionFallback(expiryFallback, allowedHosts, allowedRoots, deps);
+            }
+            return {
+                ...record,
+                expired_at: status === 'expired' ? expiresAt ?? null : null,
+                fallback_action: status === 'expired' ? expiryFallback : null
+            };
+        }
+        await deps.delay(QUESTION_POLL_INTERVAL_MS);
+    }
+    const remainingMs = waitMs > 0 ? Math.max(0, deadline - Date.now()) : null;
+    const timeoutMs = remainingMs === null ? undefined : Math.max(1, Math.min(deps.defaultControlEndpointTimeoutMs, remainingMs));
+    const record = await deps.callControlEndpoint(parentManifestPath, `/questions/${questionId}`, null, {
+        [deps.delegationTokenHeader]: delegationToken,
+        [deps.delegationRunHeader]: childRunId
+    }, {
+        allowedHosts,
+        ...(timeoutMs !== undefined ? { timeoutMs } : {})
+    });
+    return {
+        ...record,
+        expired_at: null,
+        fallback_action: null
+    };
+}
+export async function resolveDelegationTokenValue(request, allowedRoots, options, deps) {
+    const privateToken = request.codex_private?.delegation_token;
+    if (privateToken) {
+        return String(privateToken);
+    }
+    const tokenPath = resolveDelegationTokenPath(allowedRoots, deps);
+    if (!tokenPath) {
+        return null;
+    }
+    const retryMs = options.retryMs ?? 0;
+    const intervalMs = options.intervalMs ?? deps.defaultDelegationTokenRetryIntervalMs;
+    const deadline = Date.now() + retryMs;
+    let token = await readDelegationTokenFile(tokenPath, deps.safeJsonParse);
+    while (!token && Date.now() < deadline) {
+        await deps.delay(intervalMs);
+        token = await readDelegationTokenFile(tokenPath, deps.safeJsonParse);
+    }
+    return token;
+}
+export function clampQuestionPollWaitMs(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        return 0;
+    }
+    return Math.min(value, MAX_QUESTION_POLL_WAIT_MS);
+}
+export async function applyDelegationQuestionFallback(fallback, allowedHosts, allowedRoots, deps) {
+    const manifestPath = process.env.CODEX_ORCHESTRATOR_MANIFEST_PATH;
+    if (!manifestPath) {
+        return;
+    }
+    const shouldResolve = await isDelegationRunAwaitingQuestion(manifestPath, allowedRoots, deps);
+    if (!shouldResolve) {
+        return;
+    }
+    const action = fallback === 'pause' ? 'pause' : fallback === 'resume' ? 'resume' : 'fail';
+    try {
+        await deps.callControlEndpoint(deps.resolveRunManifestPath(manifestPath, allowedRoots, 'manifest_path'), '/control/action', {
+            action,
+            requested_by: 'delegate',
+            reason: 'question_expired'
+        }, undefined, { allowedHosts, allowedRoots });
+    }
+    catch {
+        // ignore
+    }
+}
+async function isDelegationRunAwaitingQuestion(manifestPath, allowedRoots, deps) {
+    try {
+        const resolvedManifest = deps.resolveRunManifestPath(manifestPath, allowedRoots, 'manifest_path');
+        const controlPath = resolve(dirname(resolvedManifest), 'control.json');
+        const raw = await readFile(controlPath, 'utf8');
+        const snapshot = deps.safeJsonParse(raw);
+        const latest = snapshot && snapshot.latest_action && typeof snapshot.latest_action === 'object'
+            ? snapshot.latest_action
+            : null;
+        if (!latest) {
+            return false;
+        }
+        return latest.action === 'pause' && latest.reason === 'awaiting_question_answer';
+    }
+    catch {
+        return false;
+    }
+}
+function resolveDelegationTokenPath(allowedRoots, deps) {
+    const explicit = process.env.CODEX_DELEGATION_TOKEN_PATH?.trim();
+    const manifestPath = process.env.CODEX_ORCHESTRATOR_MANIFEST_PATH?.trim();
+    let runDir = null;
+    if (manifestPath) {
+        try {
+            const resolvedManifest = deps.resolveRunManifestPath(manifestPath, allowedRoots, 'manifest_path');
+            runDir = dirname(resolvedManifest);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (explicit) {
+        if (!runDir && !isAbsolute(explicit)) {
+            return null;
+        }
+        const resolvedToken = runDir && !isAbsolute(explicit) ? resolve(runDir, explicit) : resolve(explicit);
+        if (runDir) {
+            if (!deps.isPathWithinRoots(resolvedToken, [runDir])) {
+                return null;
+            }
+        }
+        else if (allowedRoots && allowedRoots.length > 0 && !deps.isPathWithinRoots(resolvedToken, allowedRoots)) {
+            return null;
+        }
+        return resolvedToken;
+    }
+    if (runDir) {
+        return resolve(runDir, deps.delegationTokenFile);
+    }
+    return null;
+}
+async function readDelegationTokenFile(tokenPath, safeJsonParse) {
+    try {
+        const raw = await readFile(tokenPath, 'utf8');
+        const parsed = safeJsonParse(raw);
+        const tokenValue = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed.token
+            : null;
+        const token = typeof tokenValue === 'string' && tokenValue.trim().length > 0 ? tokenValue.trim() : raw.trim();
+        return token || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/orchestrator/src/cli/delegationServerToolDispatchShell.js

@@ -0,0 +1,411 @@
+const CLOSED_WORLD_READ_ONLY = {
+    readOnlyHint: true,
+    openWorldHint: false
+};
+const CLOSED_WORLD_ADDITIVE_WRITE = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+};
+const CLOSED_WORLD_DESTRUCTIVE_WRITE = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+};
+const OPEN_WORLD_READ_ONLY = {
+    readOnlyHint: true,
+    openWorldHint: true
+};
+const OPEN_WORLD_ADDITIVE_WRITE = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+};
+const OPEN_WORLD_DESTRUCTIVE_WRITE = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true
+};
+const TOOL_METADATA_BY_NAME = {
+    'delegate.spawn': {
+        title: 'Spawn Delegated Run',
+        annotations: OPEN_WORLD_ADDITIVE_WRITE
+    },
+    'delegate.pause': {
+        title: 'Pause Or Resume Run',
+        annotations: CLOSED_WORLD_ADDITIVE_WRITE
+    },
+    'delegate.cancel': {
+        title: 'Cancel Run',
+        annotations: CLOSED_WORLD_DESTRUCTIVE_WRITE
+    },
+    'delegate.status': {
+        title: 'Fetch Run Status',
+        annotations: CLOSED_WORLD_READ_ONLY
+    },
+    'delegate.question.enqueue': {
+        title: 'Enqueue Parent Question',
+        annotations: CLOSED_WORLD_ADDITIVE_WRITE
+    },
+    'delegate.question.poll': {
+        title: 'Poll Parent Question',
+        annotations: CLOSED_WORLD_ADDITIVE_WRITE
+    },
+    'coordinator.status': {
+        title: 'Coordinator Status Bridge',
+        annotations: CLOSED_WORLD_READ_ONLY
+    },
+    'coordinator.pause': {
+        title: 'Coordinator Pause Bridge',
+        annotations: CLOSED_WORLD_ADDITIVE_WRITE
+    },
+    'coordinator.resume': {
+        title: 'Coordinator Resume Bridge',
+        annotations: CLOSED_WORLD_ADDITIVE_WRITE
+    },
+    'coordinator.cancel': {
+        title: 'Coordinator Cancel Bridge',
+        annotations: CLOSED_WORLD_DESTRUCTIVE_WRITE
+    },
+    'github.open_pr': {
+        title: 'Open GitHub Pull Request',
+        annotations: OPEN_WORLD_ADDITIVE_WRITE
+    },
+    'github.comment': {
+        title: 'Create GitHub Comment',
+        annotations: OPEN_WORLD_ADDITIVE_WRITE
+    },
+    'github.review': {
+        title: 'Submit GitHub Review',
+        annotations: OPEN_WORLD_ADDITIVE_WRITE
+    },
+    'github.get_checks': {
+        title: 'Fetch GitHub Checks',
+        annotations: OPEN_WORLD_READ_ONLY
+    },
+    'github.merge': {
+        title: 'Merge GitHub Pull Request',
+        annotations: OPEN_WORLD_DESTRUCTIVE_WRITE
+    }
+};
+export function createDelegationServerRpcHandler(options) {
+    const serverInfo = options.serverInfo ?? { name: 'codex-delegation', version: '0.1.0' };
+    return async (request) => {
+        switch (request.method) {
+            case 'initialize':
+                return {
+                    protocolVersion: options.protocolVersion,
+                    serverInfo,
+                    capabilities: { tools: {} }
+                };
+            case 'tools/list':
+                return { tools: options.tools };
+            case 'tools/call':
+                return await options.handleToolCall(request);
+            default:
+                throw new Error(`Unsupported method: ${request.method}`);
+        }
+    };
+}
+export function buildToolList(options) {
+    const tools = [];
+    const includeFull = options.mode === 'full';
+    const includeQuestionAndGithub = options.mode !== 'status_only';
+    if (includeFull) {
+        tools.push(toolDefinition('delegate.spawn', 'Spawn a delegated run', {
+            type: 'object',
+            properties: {
+                task_id: { type: 'string' },
+                pipeline: { type: 'string' },
+                repo: { type: 'string' },
+                parent_run_id: { type: 'string' },
+                parent_manifest_path: { type: 'string' },
+                env: { type: 'object', additionalProperties: { type: 'string' } },
+                delegate_mode: { type: 'string', enum: ['full', 'question_only', 'status_only'] },
+                start_only: { type: 'boolean' }
+            },
+            required: ['pipeline', 'repo']
+        }));
+        tools.push(toolDefinition('delegate.pause', 'Pause or resume a run', {
+            type: 'object',
+            properties: {
+                manifest_path: { type: 'string' },
+                paused: { type: 'boolean' },
+                intent_id: { type: 'string' },
+                request_id: { type: 'string' },
+                transport: { type: 'string', enum: ['discord', 'telegram'] },
+                actor_id: { type: 'string' },
+                actor_source: { type: 'string' },
+                transport_principal: { type: 'string' },
+                transport_nonce: { type: 'string' },
+                transport_nonce_expires_at: { type: 'string' }
+            },
+            required: ['manifest_path', 'paused']
+        }));
+        tools.push(toolDefinition('delegate.cancel', 'Cancel a run (confirmation required)', {
+            type: 'object',
+            properties: {
+                manifest_path: { type: 'string' },
+                intent_id: { type: 'string' },
+                request_id: { type: 'string' },
+                transport: { type: 'string', enum: ['discord', 'telegram'] },
+                actor_id: { type: 'string' },
+                actor_source: { type: 'string' },
+                transport_principal: { type: 'string' },
+                transport_nonce: { type: 'string' },
+                transport_nonce_expires_at: { type: 'string' }
+            },
+            required: ['manifest_path']
+        }));
+        tools.push(toolDefinition('coordinator.status', 'Experimental coordinator dynamic-tool status bridge', {
+            type: 'object',
+            properties: {
+                manifest_path: { type: 'string' },
+                intent_id: { type: 'string' },
+                request_id: { type: 'string' },
+                ...dynamicToolBridgeSourceSchemaProperties()
+            },
+            required: ['manifest_path']
+        }));
+        tools.push(toolDefinition('coordinator.pause', 'Experimental coordinator dynamic-tool pause bridge', {
+            type: 'object',
+            properties: {
+                manifest_path: { type: 'string' },
+                intent_id: { type: 'string' },
+                request_id: { type: 'string' },
+                transport: { type: 'string', enum: ['discord', 'telegram'] },
+                actor_id: { type: 'string' },
+                actor_source: { type: 'string' },
+                transport_principal: { type: 'string' },
+                transport_nonce: { type: 'string' },
+                transport_nonce_expires_at: { type: 'string' },
+                ...dynamicToolBridgeSourceSchemaProperties()
+            },
+            required: ['manifest_path']
+        }));
+        tools.push(toolDefinition('coordinator.resume', 'Experimental coordinator dynamic-tool resume bridge', {
+            type: 'object',
+            properties: {
+                manifest_path: { type: 'string' },
+                intent_id: { type: 'string' },
+                request_id: { type: 'string' },
+                transport: { type: 'string', enum: ['discord', 'telegram'] },
+                actor_id: { type: 'string' },
+                actor_source: { type: 'string' },
+                transport_principal: { type: 'string' },
+                transport_nonce: { type: 'string' },
+                transport_nonce_expires_at: { type: 'string' },
+                ...dynamicToolBridgeSourceSchemaProperties()
+            },
+            required: ['manifest_path']
+        }));
+        tools.push(toolDefinition('coordinator.cancel', 'Experimental coordinator dynamic-tool cancel bridge', {
+            type: 'object',
+            properties: {
+                manifest_path: { type: 'string' },
+                intent_id: { type: 'string' },
+                request_id: { type: 'string' },
+                transport: { type: 'string', enum: ['discord', 'telegram'] },
+                actor_id: { type: 'string' },
+                actor_source: { type: 'string' },
+                transport_principal: { type: 'string' },
+                transport_nonce: { type: 'string' },
+                transport_nonce_expires_at: { type: 'string' },
+                ...dynamicToolBridgeSourceSchemaProperties()
+            },
+            required: ['manifest_path']
+        }));
+    }
+    tools.push(toolDefinition('delegate.status', 'Fetch run status', {
+        type: 'object',
+        properties: {
+            manifest_path: { type: 'string' },
+            intent_id: { type: 'string' },
+            request_id: { type: 'string' }
+        },
+        required: ['manifest_path']
+    }));
+    if (includeQuestionAndGithub) {
+        tools.push(toolDefinition('delegate.question.enqueue', 'Enqueue a question to the parent run', {
+            type: 'object',
+            properties: {
+                parent_manifest_path: { type: 'string' },
+                parent_run_id: { type: 'string' },
+                parent_task_id: { type: 'string' },
+                from_manifest_path: { type: 'string' },
+                prompt: { type: 'string' },
+                urgency: { type: 'string', enum: ['low', 'med', 'high'] },
+                expires_in_ms: { type: 'number' },
+                auto_pause: { type: 'boolean' }
+            },
+            required: ['parent_manifest_path', 'prompt']
+        }));
+        tools.push(toolDefinition('delegate.question.poll', 'Poll for a question answer', {
+            type: 'object',
+            properties: {
+                parent_manifest_path: { type: 'string' },
+                question_id: { type: 'string' },
+                wait_ms: { type: 'number' }
+            },
+            required: ['parent_manifest_path', 'question_id']
+        }));
+    }
+    if (includeQuestionAndGithub && options.githubEnabled) {
+        if (options.allowedGithubOps.has('open_pr')) {
+            tools.push(toolDefinition('github.open_pr', 'Open a pull request', {
+                type: 'object',
+                properties: {
+                    repo: { type: 'string' },
+                    title: { type: 'string' },
+                    body: { type: 'string' },
+                    base: { type: 'string' },
+                    head: { type: 'string' },
+                    draft: { type: 'boolean' }
+                },
+                required: ['title']
+            }));
+        }
+        if (options.allowedGithubOps.has('comment')) {
+            tools.push(toolDefinition('github.comment', 'Create a PR/issue comment', {
+                type: 'object',
+                properties: {
+                    repo: { type: 'string' },
+                    issue_number: { type: 'number' },
+                    body: { type: 'string' }
+                },
+                required: ['issue_number', 'body']
+            }));
+        }
+        if (options.allowedGithubOps.has('review')) {
+            tools.push(toolDefinition('github.review', 'Submit a PR review', {
+                type: 'object',
+                properties: {
+                    repo: { type: 'string' },
+                    pull_number: { type: 'number' },
+                    event: { type: 'string', enum: ['APPROVE', 'REQUEST_CHANGES', 'COMMENT'] },
+                    body: { type: 'string' }
+                },
+                required: ['pull_number', 'event']
+            }));
+        }
+        if (options.allowedGithubOps.has('get_checks')) {
+            tools.push(toolDefinition('github.get_checks', 'Fetch PR checks', {
+                type: 'object',
+                properties: {
+                    repo: { type: 'string' },
+                    pull_number: { type: 'number' }
+                },
+                required: ['pull_number']
+            }));
+        }
+        if (options.allowedGithubOps.has('merge')) {
+            tools.push(toolDefinition('github.merge', 'Merge a PR', {
+                type: 'object',
+                properties: {
+                    manifest_path: { type: 'string' },
+                    repo: { type: 'string' },
+                    pull_number: { type: 'number' },
+                    method: { type: 'string', enum: ['merge', 'squash', 'rebase'] },
+                    delete_branch: { type: 'boolean' }
+                },
+                required: ['pull_number']
+            }));
+        }
+    }
+    return tools;
+}
+export async function handleDelegationServerToolCall(request, context, deps) {
+    const params = deps.asRecord(request.params);
+    const toolName = deps.readStringValue(params, 'name');
+    if (!toolName) {
+        throw new Error('Invalid tool call: missing name');
+    }
+    const input = deps.asRecord(params.arguments);
+    const delegateModeViolationMessage = deps.getDelegateModeViolationMessage(context.mode, toolName);
+    if (delegateModeViolationMessage) {
+        await deps.reportSecurityViolation('delegate_mode_violation', delegateModeViolationMessage, toolName, context.allowedHosts);
+        throw new Error(context.mode === 'question_only' ? 'delegate_mode_forbidden' : delegateModeViolationMessage);
+    }
+    if (deps.containsSecret(input, 'confirm_nonce') || deps.containsSecret(input, 'confirmNonce')) {
+        await deps.reportSecurityViolation('confirm_nonce_present', 'Model supplied confirm_nonce.', toolName, context.allowedHosts);
+        throw new Error('confirm_nonce must be injected by the runner');
+    }
+    if (deps.containsSecret(input, 'delegation_token') || deps.containsSecret(input, 'delegationToken')) {
+        await deps.reportSecurityViolation('delegation_token_present', 'Model supplied delegation_token.', toolName, context.allowedHosts);
+        throw new Error('delegation_token must be injected by the runner');
+    }
+    switch (toolName) {
+        case 'delegate.status':
+            return wrapResult(await deps.handleDelegateStatus(input, context.allowedRoots, context.allowedHosts));
+        case 'delegate.pause':
+            return wrapResult(await deps.handleDelegatePause(input, context.allowedRoots, context.allowedHosts));
+        case 'delegate.cancel':
+            return wrapResult(await deps.handleDelegateCancel(input, request, context.allowedRoots, context.allowedHosts));
+        case 'delegate.spawn':
+            return wrapResult(await deps.handleDelegateSpawn(input, context.repoRoot, context.allowNested, context.allowedRoots, context.allowedHosts, context.toolProfile));
+        case 'delegate.question.enqueue':
+            return wrapResult(await deps.handleQuestionEnqueue(input, request, context.allowedRoots, context.allowedHosts, context.expiryFallback));
+        case 'delegate.question.poll':
+            return wrapResult(await deps.handleQuestionPoll(input, request, context.allowedRoots, context.allowedHosts, context.expiryFallback));
+        case 'coordinator.status':
+        case 'coordinator.pause':
+        case 'coordinator.resume':
+        case 'coordinator.cancel':
+            return wrapResult(await deps.handleCoordinatorDynamicToolCall(toolName, input, request, context.allowedRoots, context.allowedHosts));
+        case 'github.open_pr':
+        case 'github.comment':
+        case 'github.review':
+        case 'github.get_checks':
+        case 'github.merge':
+            return wrapResult(await deps.handleGithubCall(toolName, input, request, context));
+        default:
+            throw new Error(`Unknown tool: ${toolName}`);
+    }
+}
+function toolDefinition(name, description, inputSchema) {
+    const metadata = TOOL_METADATA_BY_NAME[name];
+    if (!metadata) {
+        return { name, description, inputSchema };
+    }
+    return {
+        name,
+        title: metadata.title,
+        description,
+        inputSchema,
+        annotations: metadata.annotations
+    };
+}
+function dynamicToolBridgeSourceSchemaProperties() {
+    return {
+        source: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                source_id: { type: 'string' },
+                sourceId: { type: 'string' },
+                bridge_source: { type: 'string' },
+                bridgeSource: { type: 'string' }
+            },
+            additionalProperties: true
+        },
+        source_id: { type: 'string' },
+        sourceId: { type: 'string' },
+        bridge_source: { type: 'string' },
+        bridgeSource: { type: 'string' }
+    };
+}
+function wrapResult(payload) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2)
+            }
+        ],
+        isError: false
+    };
+}