@canonmsg/codex-plugin 0.14.1 → 0.18.0

package/dist/adapter.d.ts

@@ -52,6 +52,7 @@ export declare class CodexConversationAdapter {
     private readonly cwd;
     private readonly codexBin;
     private model;
+    private reasoningEffort;
     private readonly sandbox;
     private readonly legacyApprovalPolicy;
     private readonly codexProfile;
@@ -68,6 +69,7 @@ export declare class CodexConversationAdapter {
         threadId?: string | null;
         codexBin?: string;
         model?: string | null;
+        reasoningEffort?: string | null;
         sandbox?: CodexSandboxMode | null;
         approvalPolicy?: CodexApprovalPolicy | null;
         codexProfile?: string | null;
@@ -79,6 +81,8 @@ export declare class CodexConversationAdapter {
     getThreadId(): string | null;
     clearThreadId(): void;
     setModel(model: string | null): void;
+    /** Sets GPT reasoning effort, applied on the next turn via `-c model_reasoning_effort`. */
+    setReasoningEffort(effort: string | null): void;
     isRunning(): boolean;
     interrupt(): Promise<void>;
     runTurn(prompt: string, onEvent: (event: CodexEvent) => void, onLog?: (line: string) => void, imagePaths?: readonly string[], extraAddDirs?: readonly string[], _options?: CodexRunTurnOptions): Promise<CodexTurnResult>;

package/dist/adapter.js

@@ -5,6 +5,7 @@ export class CodexConversationAdapter {
     cwd;
     codexBin;
     model;
+    reasoningEffort;
     sandbox;
     legacyApprovalPolicy;
     codexProfile;
@@ -21,6 +22,7 @@ export class CodexConversationAdapter {
         this.threadId = opts.threadId ?? null;
         this.codexBin = opts.codexBin ?? 'codex';
         this.model = opts.model ?? null;
+        this.reasoningEffort = opts.reasoningEffort ?? null;
         this.sandbox = opts.sandbox ?? null;
         this.legacyApprovalPolicy = opts.approvalPolicy ?? null;
         this.codexProfile = opts.codexProfile ?? null;
@@ -38,6 +40,10 @@ export class CodexConversationAdapter {
     setModel(model) {
         this.model = model;
     }
+    /** Sets GPT reasoning effort, applied on the next turn via `-c model_reasoning_effort`. */
+    setReasoningEffort(effort) {
+        this.reasoningEffort = effort && effort.trim() ? effort.trim() : null;
+    }
     isRunning() {
         return this.child !== null;
     }
@@ -177,6 +183,9 @@ export class CodexConversationAdapter {
             for (const configOverride of this.configOverrides) {
                 args.push('-c', configOverride);
             }
+            if (this.reasoningEffort) {
+                args.push('-c', `model_reasoning_effort="${this.reasoningEffort}"`);
+            }
             for (const addDir of this.buildAddDirs(extraAddDirs)) {
                 args.push('--add-dir', addDir);
             }
@@ -219,6 +228,9 @@ export class CodexConversationAdapter {
         for (const configOverride of this.configOverrides) {
             args.push('-c', configOverride);
         }
+        if (this.reasoningEffort) {
+            args.push('-c', `model_reasoning_effort="${this.reasoningEffort}"`);
+        }
         if (execMode.fullAuto) {
             args.push('--full-auto');
         }

package/dist/app-server-adapter.d.ts

@@ -3,6 +3,7 @@ export declare class CodexAppServerAdapter {
     private readonly cwd;
     private readonly codexBin;
     private model;
+    private reasoningEffort;
     private readonly sandbox;
     private readonly legacyApprovalPolicy;
     private readonly addDirs;
@@ -32,6 +33,7 @@ export declare class CodexAppServerAdapter {
         threadId?: string | null;
         codexBin?: string;
         model?: string | null;
+        reasoningEffort?: string | null;
         sandbox?: CodexSandboxMode | null;
         approvalPolicy?: CodexApprovalPolicy | null;
         addDirs?: string[];
@@ -42,6 +44,15 @@ export declare class CodexAppServerAdapter {
     getThreadId(): string | null;
     clearThreadId(): void;
     setModel(model: string | null): void;
+    /**
+     * Sets GPT reasoning effort, applied via model_reasoning_effort. The config
+     * payload is only sent on thread/start and thread/resume (not per turn/start),
+     * so a mid-session change must force a re-resume to take effect on the next
+     * turn — mirroring the exec transport, which re-sends `-c model_reasoning_effort`
+     * every turn. thread/resume reloads the existing thread (excludeTurns), so
+     * conversation context is preserved.
+     */
+    setReasoningEffort(effort: string | null): void;
     isRunning(): boolean;
     interrupt(): Promise<void>;
     close(): void;

package/dist/app-server-adapter.js

@@ -4,6 +4,7 @@ export class CodexAppServerAdapter {
     cwd;
     codexBin;
     model;
+    reasoningEffort;
     sandbox;
     legacyApprovalPolicy;
     addDirs;
@@ -33,6 +34,7 @@ export class CodexAppServerAdapter {
         this.threadId = opts.threadId ?? null;
         this.codexBin = opts.codexBin ?? 'codex';
         this.model = opts.model ?? null;
+        this.reasoningEffort = opts.reasoningEffort ?? null;
         this.sandbox = opts.sandbox ?? null;
         this.legacyApprovalPolicy = opts.approvalPolicy ?? null;
         this.addDirs = opts.addDirs ?? [];
@@ -51,6 +53,23 @@ export class CodexAppServerAdapter {
     setModel(model) {
         this.model = model;
     }
+    /**
+     * Sets GPT reasoning effort, applied via model_reasoning_effort. The config
+     * payload is only sent on thread/start and thread/resume (not per turn/start),
+     * so a mid-session change must force a re-resume to take effect on the next
+     * turn — mirroring the exec transport, which re-sends `-c model_reasoning_effort`
+     * every turn. thread/resume reloads the existing thread (excludeTurns), so
+     * conversation context is preserved.
+     */
+    setReasoningEffort(effort) {
+        const next = effort && effort.trim() ? effort.trim() : null;
+        if (next === this.reasoningEffort)
+            return;
+        this.reasoningEffort = next;
+        if (this.threadId && this.loadedThreadId === this.threadId) {
+            this.loadedThreadId = null;
+        }
+    }
     isRunning() {
         return this.currentTurnId !== null || this.currentTurnResolve !== null;
     }
@@ -135,7 +154,7 @@ export class CodexAppServerAdapter {
                             mode: 'plan',
                             settings: {
                                 ...(planModel ? { model: planModel } : {}),
-                                reasoning_effort: null,
+                                reasoning_effort: this.reasoningEffort ?? null,
                                 developer_instructions: null,
                             },
                         },
@@ -170,6 +189,9 @@ export class CodexAppServerAdapter {
                 continue;
             config[key] = parseConfigValue(raw.slice(separator + 1));
         }
+        if (this.reasoningEffort && config.model_reasoning_effort === undefined) {
+            config.model_reasoning_effort = this.reasoningEffort;
+        }
         return Object.keys(config).length > 0 ? { config } : {};
     }
     rememberResolvedModel(result) {
@@ -387,7 +409,14 @@ export class CodexAppServerAdapter {
             if (isRecord(status) && status.type === 'failed') {
                 this.currentErrorText = stringifyPreview(turn?.error);
             }
-            this.currentOnEvent?.({ type: 'turn.completed' });
+            const usage = isRecord(turn?.usage)
+                ? {
+                    ...(typeof turn.usage.input_tokens === 'number' ? { input_tokens: turn.usage.input_tokens } : {}),
+                    ...(typeof turn.usage.cached_input_tokens === 'number' ? { cached_input_tokens: turn.usage.cached_input_tokens } : {}),
+                    ...(typeof turn.usage.output_tokens === 'number' ? { output_tokens: turn.usage.output_tokens } : {}),
+                }
+                : undefined;
+            this.currentOnEvent?.({ type: 'turn.completed', ...(usage ? { usage } : {}) });
             this.resolveCurrentTurn();
             return;
         }

package/dist/app-server-approval.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalNativeRequestMetadata, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalResult, ApprovalRisk } from '@canonmsg/core';
+import type { ApprovalNativeRequestMetadata, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalResult, ApprovalRisk, CanonUnifiedDiff } from '@canonmsg/core';
 /**
  * Mapping for Codex app-server native approval requests.
  *
@@ -20,6 +20,11 @@ export interface CanonCodexApprovalRequest {
     riskLevel: 'normal' | 'destructive';
     native: ApprovalNativeRequestMetadata;
     details: ApprovalRequestDetail[];
+    /**
+     * File-change preview parsed from the native patch payload, when the params
+     * carried something parseable. Already truncated to the shared budgets.
+     */
+    diff?: CanonUnifiedDiff;
 }
 export type CodexApprovalDecision = {
     decision: 'accept';
@@ -28,5 +33,11 @@ export type CodexApprovalDecision = {
 } | {
     decision: 'decline';
 };
+/**
+ * Best-effort conversion of Codex file-approval params into the shared
+ * unified-diff payload, truncated to the standard budgets. Returns undefined
+ * (and logs) when nothing parseable arrived — never throws.
+ */
+export declare function extractCodexApprovalDiff(params: Record<string, unknown>): CanonUnifiedDiff | undefined;
 export declare function mapCodexAppServerApprovalRequest(request: CodexNativeApprovalRequest): CanonCodexApprovalRequest | null;
 export declare function mapCanonApprovalResultToCodexDecision(result: ApprovalResult): CodexApprovalDecision;

package/dist/app-server-approval.js

@@ -1,3 +1,4 @@
+import { truncateUnifiedDiff } from '@canonmsg/core';
 function isRecord(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
@@ -105,6 +106,272 @@ function mapCommandRequest(method, params) {
         ],
     };
 }
+// ── File-change diff extraction ─────────────────────────────────────
+//
+// Codex file approvals may carry the pending change as unified-diff text
+// (`patch`/`diff`) or as structured changes (`changes`/`fileChanges` — array
+// entries or a path-keyed map of apply_patch-style variants). Convert whatever
+// arrives into the shared CanonUnifiedDiff payload so Canon approval cards
+// render the change inline. Extraction is best-effort: unknown shapes yield
+// undefined and must never block the approval itself.
+const DIFF_STATUS_BY_KIND = {
+    add: 'created',
+    added: 'created',
+    create: 'created',
+    created: 'created',
+    new: 'created',
+    delete: 'deleted',
+    deleted: 'deleted',
+    remove: 'deleted',
+    removed: 'deleted',
+    rename: 'renamed',
+    renamed: 'renamed',
+    move: 'renamed',
+    moved: 'renamed',
+    update: 'modified',
+    updated: 'modified',
+    modify: 'modified',
+    modified: 'modified',
+    edit: 'modified',
+    change: 'modified',
+};
+function stripDiffPathPrefix(path) {
+    return path.replace(/^[ab]\//, '');
+}
+function countHunkLines(diffText) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of diffText.split('\n')) {
+        if (line.startsWith('+') && !line.startsWith('+++'))
+            additions += 1;
+        else if (line.startsWith('-') && !line.startsWith('---'))
+            deletions += 1;
+    }
+    return { additions, deletions };
+}
+/** Drop git/unified headers from per-file diff text so only `@@ …` hunks remain. */
+function toHunkText(text) {
+    if (!/^(diff --git |index |--- |\+\+\+ )/m.test(text))
+        return text;
+    const lines = text.split('\n');
+    const start = lines.findIndex((line) => line.startsWith('@@'));
+    return start >= 0 ? lines.slice(start).join('\n') : text;
+}
+function parseUnifiedDiffSection(lines) {
+    let gitOldPath;
+    let gitNewPath;
+    let headerOldPath;
+    let headerNewPath;
+    let created = false;
+    let deleted = false;
+    let renamed = false;
+    let hunkStart = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line.startsWith('@@')) {
+            hunkStart = i;
+            break;
+        }
+        const gitHeader = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
+        if (gitHeader) {
+            gitOldPath = gitHeader[1];
+            gitNewPath = gitHeader[2];
+            continue;
+        }
+        if (line.startsWith('new file mode'))
+            created = true;
+        else if (line.startsWith('deleted file mode'))
+            deleted = true;
+        else if (line.startsWith('rename from ')) {
+            renamed = true;
+            headerOldPath = line.slice('rename from '.length).trim();
+        }
+        else if (line.startsWith('rename to ')) {
+            renamed = true;
+            headerNewPath = line.slice('rename to '.length).trim();
+        }
+        else if (line.startsWith('--- ')) {
+            const source = line.slice(4).trim();
+            if (source === '/dev/null')
+                created = true;
+            else
+                headerOldPath ??= stripDiffPathPrefix(source);
+        }
+        else if (line.startsWith('+++ ')) {
+            const target = line.slice(4).trim();
+            if (target === '/dev/null')
+                deleted = true;
+            else
+                headerNewPath ??= stripDiffPathPrefix(target);
+        }
+    }
+    const oldPath = headerOldPath ?? gitOldPath;
+    const newPath = headerNewPath ?? gitNewPath;
+    const path = (deleted ? oldPath : newPath) ?? newPath ?? oldPath;
+    if (!path || !path.trim())
+        return null;
+    const status = created
+        ? 'created'
+        : deleted
+            ? 'deleted'
+            : renamed || (oldPath && newPath && oldPath !== newPath)
+                ? 'renamed'
+                : 'modified';
+    const diffText = hunkStart >= 0 ? lines.slice(hunkStart).join('\n') : undefined;
+    const counts = diffText ? countHunkLines(diffText) : undefined;
+    return {
+        path,
+        ...(status === 'renamed' && oldPath ? { oldPath } : {}),
+        status,
+        ...(diffText ? { diff: diffText } : {}),
+        ...(counts ? { additions: counts.additions, deletions: counts.deletions } : {}),
+    };
+}
+function splitUnifiedDiffSections(lines) {
+    const sections = [];
+    let current = null;
+    const hasGitHeaders = lines.some((line) => line.startsWith('diff --git '));
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        const startsSection = hasGitHeaders
+            ? line.startsWith('diff --git ')
+            // Bare unified diff: a `--- ` source header immediately followed by `+++ `.
+            : line.startsWith('--- ') && lines[i + 1]?.startsWith('+++ ') === true;
+        if (startsSection) {
+            current = [line];
+            sections.push(current);
+            continue;
+        }
+        if (current)
+            current.push(line);
+    }
+    return sections;
+}
+function parseUnifiedDiffText(text) {
+    if (!/^(diff --git |--- )/m.test(text))
+        return null;
+    const files = splitUnifiedDiffSections(text.split('\n'))
+        .map(parseUnifiedDiffSection)
+        .filter((file) => file !== null);
+    return files.length > 0 ? files : null;
+}
+function readChangeDiffText(record) {
+    for (const key of ['diff', 'unifiedDiff', 'unified_diff', 'patch']) {
+        const value = record[key];
+        // Deliberately not trimmed — leading spaces are significant context lines.
+        if (typeof value === 'string' && value.trim())
+            return value;
+    }
+    return undefined;
+}
+function mapStructuredChangeEntry(entry) {
+    if (!isRecord(entry))
+        return null;
+    const path = readString(entry, ['path', 'filePath', 'file']);
+    if (!path)
+        return null;
+    const kind = readString(entry, ['kind', 'type', 'status', 'action']);
+    const oldPath = readString(entry, ['oldPath', 'old_path', 'movePath', 'move_path', 'from']);
+    let status = (kind ? DIFF_STATUS_BY_KIND[kind.toLowerCase()] : undefined) ?? 'modified';
+    if (status === 'modified' && oldPath && oldPath !== path)
+        status = 'renamed';
+    const rawDiff = readChangeDiffText(entry);
+    const diffText = rawDiff ? toHunkText(rawDiff) : undefined;
+    const counts = diffText ? countHunkLines(diffText) : undefined;
+    return {
+        path,
+        ...(status === 'renamed' && oldPath ? { oldPath } : {}),
+        status,
+        ...(diffText ? { diff: diffText } : {}),
+        ...(counts ? { additions: counts.additions, deletions: counts.deletions } : {}),
+    };
+}
+/** Render created-file content as a single all-additions hunk. */
+function synthesizeCreatedFileHunk(content) {
+    const lines = content.split('\n');
+    // Drop the empty segment a trailing newline leaves behind.
+    if (lines.length > 1 && lines[lines.length - 1] === '')
+        lines.pop();
+    return [`@@ -0,0 +1,${lines.length} @@`, ...lines.map((line) => `+${line}`)].join('\n');
+}
+/** Map one `{ path → apply_patch variant }` entry (add/delete/update shapes). */
+function mapKeyedFileChange(path, value) {
+    const cleanPath = path.trim();
+    if (!cleanPath)
+        return null;
+    if (value === 'delete')
+        return { path: cleanPath, status: 'deleted' };
+    if (!isRecord(value))
+        return null;
+    if ('delete' in value)
+        return { path: cleanPath, status: 'deleted' };
+    if (isRecord(value.add)) {
+        const content = typeof value.add.content === 'string' ? value.add.content : undefined;
+        const diffText = content ? synthesizeCreatedFileHunk(content) : undefined;
+        return {
+            path: cleanPath,
+            status: 'created',
+            ...(diffText ? { diff: diffText, additions: countHunkLines(diffText).additions, deletions: 0 } : {}),
+        };
+    }
+    if (isRecord(value.update)) {
+        const movePath = readString(value.update, ['movePath', 'move_path']);
+        const rawDiff = readChangeDiffText(value.update);
+        const diffText = rawDiff ? toHunkText(rawDiff) : undefined;
+        const counts = diffText ? countHunkLines(diffText) : undefined;
+        const isRename = Boolean(movePath && movePath !== cleanPath);
+        return {
+            path: isRename && movePath ? movePath : cleanPath,
+            ...(isRename ? { oldPath: cleanPath } : {}),
+            status: isRename ? 'renamed' : 'modified',
+            ...(diffText ? { diff: diffText } : {}),
+            ...(counts ? { additions: counts.additions, deletions: counts.deletions } : {}),
+        };
+    }
+    // Flat record fallback: kind/diff fields live on the value itself.
+    return mapStructuredChangeEntry({ path: cleanPath, ...value });
+}
+function extractDiffFiles(params) {
+    for (const key of ['patch', 'diff']) {
+        const value = params[key];
+        if (typeof value === 'string' && value.trim()) {
+            const files = parseUnifiedDiffText(value);
+            if (files)
+                return files;
+        }
+    }
+    const changes = params.changes ?? params.fileChanges;
+    if (Array.isArray(changes)) {
+        const files = changes
+            .map(mapStructuredChangeEntry)
+            .filter((file) => file !== null);
+        return files.length > 0 ? files : null;
+    }
+    if (isRecord(changes)) {
+        const files = Object.entries(changes)
+            .map(([path, value]) => mapKeyedFileChange(path, value))
+            .filter((file) => file !== null);
+        return files.length > 0 ? files : null;
+    }
+    return null;
+}
+/**
+ * Best-effort conversion of Codex file-approval params into the shared
+ * unified-diff payload, truncated to the standard budgets. Returns undefined
+ * (and logs) when nothing parseable arrived — never throws.
+ */
+export function extractCodexApprovalDiff(params) {
+    try {
+        const files = extractDiffFiles(params);
+        if (!files)
+            return undefined;
+        return truncateUnifiedDiff({ files });
+    }
+    catch (error) {
+        console.error('[canon-codex] Failed to parse approval diff; omitting preview:', error instanceof Error ? error.message : error);
+        return undefined;
+    }
+}
 function mapFileRequest(method, params) {
     const path = readString(params, ['path', 'filePath', 'targetPath']);
     const summary = path
@@ -112,6 +379,7 @@ function mapFileRequest(method, params) {
         ?? stringifyPreview(params.changes ?? params.patch ?? params);
     const patch = readString(params, ['patch', 'diff']);
     const destructive = /\b(delete|remove|unlink)\b/i.test(stringifyPreview(params, 1000));
+    const diff = extractCodexApprovalDiff(params);
     return {
         toolName: method === 'applyPatchApproval' ? 'codex.applyPatch' : 'codex.fileChange',
         toolInput: {
@@ -127,6 +395,7 @@ function mapFileRequest(method, params) {
             ...detail('Path', path),
             ...detail('Patch', patch),
         ],
+        ...(diff ? { diff } : {}),
     };
 }
 function mapPermissionRequest(method, params) {

package/dist/control-channel.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Codex host RTDB `/control/{conversationId}/{agentId}` channel wiring.
+ *
+ * Configures the shared `ControlChannelPoller` from `@canonmsg/core` to the
+ * codex host characterization profile (the "codex host profile" describe
+ * block in core's control-poller.test.ts is the contract):
+ *
+ * - Keys: `session` + `signal` (never `primitive`), read sequentially per
+ *   conversation, conversations polled one at a time.
+ * - Cadence: immediate first cycle, then active/idle delays + jitter with
+ *   the activity probe sampled BEFORE the cycle runs.
+ * - Session controls are always consumed once newer (default consume), even
+ *   when no live session applied them; signals are NOT consumed when the
+ *   handler throws (consumeOnError stays false).
+ * - Dedupe is primed eagerly via `poller.baseline([conversationId])` at
+ *   session creation — the second legacy poll site.
+ */
+import { ControlChannelPoller, type ControlChannelRTDB, type ControlHandlerResult, type ControlPollerError, type ControlSessionEvent, type ControlSignalEvent } from '@canonmsg/core';
+export declare const CONTROL_POLL_MS = 2000;
+export declare const IDLE_CONTROL_POLL_MS = 10000;
+export declare const CONTROL_POLL_JITTER_MS = 1000;
+export interface CodexControlChannelInput {
+    /** Scoped RTDB handle from `initRTDBAuth` — never the module-global default. */
+    rtdb: ControlChannelRTDB;
+    agentId: string;
+    /** Live session conversation ids, snapshotted at the start of every cycle. */
+    conversationIds: () => Iterable<string>;
+    /** Sampled before each cycle to choose the active vs idle delay. */
+    hasActiveWork: () => boolean;
+    /**
+     * Applies a newer `/session` control node. The node is always consumed
+     * after the handler resolves; a thrown error leaves it in place (with
+     * dedupe already advanced, so it is never retried).
+     */
+    onSessionControl: (event: ControlSessionEvent) => Promise<ControlHandlerResult> | ControlHandlerResult;
+    /**
+     * Handles a newer `/signal` node. Return `{ consume: false }` to leave the
+     * node in place; thrown errors also leave it (consumeOnError stays false).
+     */
+    onSignal: (event: ControlSignalEvent) => Promise<ControlHandlerResult> | ControlHandlerResult;
+    onError?: (error: ControlPollerError) => void;
+    /** Injectable jitter source (tests). */
+    random?: () => number;
+}
+export declare function createCodexControlPoller(input: CodexControlChannelInput): ControlChannelPoller;

package/dist/control-channel.js

@@ -0,0 +1,48 @@
+/**
+ * Codex host RTDB `/control/{conversationId}/{agentId}` channel wiring.
+ *
+ * Configures the shared `ControlChannelPoller` from `@canonmsg/core` to the
+ * codex host characterization profile (the "codex host profile" describe
+ * block in core's control-poller.test.ts is the contract):
+ *
+ * - Keys: `session` + `signal` (never `primitive`), read sequentially per
+ *   conversation, conversations polled one at a time.
+ * - Cadence: immediate first cycle, then active/idle delays + jitter with
+ *   the activity probe sampled BEFORE the cycle runs.
+ * - Session controls are always consumed once newer (default consume), even
+ *   when no live session applied them; signals are NOT consumed when the
+ *   handler throws (consumeOnError stays false).
+ * - Dedupe is primed eagerly via `poller.baseline([conversationId])` at
+ *   session creation — the second legacy poll site.
+ */
+import { ControlChannelPoller, } from '@canonmsg/core';
+export const CONTROL_POLL_MS = 2_000;
+export const IDLE_CONTROL_POLL_MS = 10_000;
+export const CONTROL_POLL_JITTER_MS = 1_000;
+export function createCodexControlPoller(input) {
+    return new ControlChannelPoller({
+        rtdb: input.rtdb,
+        agentId: input.agentId,
+        conversationIds: input.conversationIds,
+        cadence: {
+            kind: 'adaptive',
+            activeMs: CONTROL_POLL_MS,
+            idleMs: IDLE_CONTROL_POLL_MS,
+            jitterMs: CONTROL_POLL_JITTER_MS,
+            hasActiveWork: input.hasActiveWork,
+            activitySample: 'cycle-start',
+        },
+        pollOnStart: true,
+        conversationConcurrency: 'sequential',
+        handlers: {
+            session: {
+                handle: input.onSessionControl,
+            },
+            signal: {
+                handle: input.onSignal,
+            },
+        },
+        ...(input.onError ? { onError: input.onError } : {}),
+        ...(input.random ? { random: input.random } : {}),
+    });
+}