@undefineds.co/linx 0.3.4 → 0.3.7

package/dist/lib/pi-adapter/auto-input-controller.js

@@ -0,0 +1,988 @@
+import { createAgentRuntime, resolveAgentRuntimeConfig, runThreadReconcilerCycle, } from '../../../vendor/agent-runtime/dist/index.js';
+import { createRemoteCompletionResult, isRemoteAuthExpiredError } from '../chat-api.js';
+import { DEFAULT_LINX_CLOUD_MODEL_ID } from '../default-model.js';
+import { getDefaultPodDataSession } from '../pod-data-session.js';
+import { resolveRuntimeTarget } from '../runtime-target.js';
+const AUTO_INPUT_DELAY_MS = 50;
+const AUTO_INPUT_IDLE_WATCHDOG_MS = 1_000;
+const DEFAULT_AUTO_INPUT_RECOVERY_DELAYS_MS = [500, 1_500, 3_000];
+const DEFAULT_TRANSIENT_REMOTE_RECOVERY_DELAY_MS = 30_000;
+const DEFAULT_GOAL_MODE_SUPERVISOR_INTERVAL_MS = 10 * 60 * 1000;
+const MAX_CONTEXT_MESSAGES = 16;
+const MAX_CONTEXT_CHARS = 12_000;
+const MAX_GENERATED_INPUT_CHARS = 8_000;
+const MAX_AUTO_INPUT_ATTEMPTS = 2;
+const SECRETARY_AGENT_ID = '__secretary__';
+const SECRETARY_AGENT_LABEL = 'AI Secretary';
+const DEFAULT_SECRETARY_RUNTIME_BACKEND = {
+    backend: 'linx',
+    model: DEFAULT_LINX_CLOUD_MODEL_ID,
+    credentialSource: 'cloud',
+};
+const SECRETARY_SYSTEM_PROMPT = [
+    'You are the LinX AI Secretary running the auto input controller.',
+    'Auto mode is on, so you are taking over the next user input slot for the active backend session.',
+    'Produce only the exact next user message to submit.',
+    'Do not include reasoning, labels, markdown fences, or explanations.',
+    'When the backend asks for ordinary conversational input, a game move, or a next turn you can reasonably infer, answer as the user and keep the session moving.',
+    'For games, including 成语接龙, provide the next valid move directly.',
+    'When goal mode is on, act as a supervisor: send a concise steer only when the current chat peer needs direction, and return empty when no intervention is needed.',
+    'Outside goal mode, return an empty response only for missing credentials, missing authority, unsafe or destructive action, or genuinely unresolvable ambiguity.',
+].join(' ');
+const SECRETARY_RETRY_PREFIX = [
+    'The previous auto-input attempt returned empty.',
+    'Auto mode should not stop for ordinary conversation, games, or backend requests for the next user turn.',
+    'Return empty only for missing credentials, missing authority, unsafe or destructive action, or genuinely unresolvable ambiguity.',
+    'Otherwise write the exact next user input now.',
+].join('\n');
+export function getSecretaryAutoInputController(interactive, runtime, sessionControl) {
+    if (interactive?.__linxAutoInputController) {
+        return interactive.__linxAutoInputController;
+    }
+    const controller = new SecretaryAutoInputControllerImpl(interactive, runtime, sessionControl);
+    if (interactive && typeof interactive === 'object') {
+        interactive.__linxAutoInputController = controller;
+    }
+    return controller;
+}
+class SecretaryAutoInputControllerImpl {
+    interactive;
+    runtime;
+    sessionControl;
+    active = false;
+    running = false;
+    scheduled = null;
+    idleWatchdog = null;
+    recoveryTimer = null;
+    pendingReason = null;
+    generation = 0;
+    unsubscribe = null;
+    recoveryAttempts = 0;
+    pausedAssistantSignature = null;
+    goalModeSupervisedAssistantSignature = null;
+    currentTurnAbortController = null;
+    constructor(interactive, runtime, sessionControl) {
+        this.interactive = interactive;
+        this.runtime = runtime;
+        this.sessionControl = sessionControl;
+    }
+    start(options = {}) {
+        if (this.active) {
+            if (options.scheduleImmediately !== false) {
+                this.schedule('auto-on');
+            }
+            return;
+        }
+        this.active = true;
+        this.generation += 1;
+        this.installRuntimeHooks();
+        this.startIdleWatchdog();
+        if (options.scheduleImmediately !== false) {
+            this.schedule('auto-on');
+        }
+    }
+    stop() {
+        this.active = false;
+        this.generation += 1;
+        this.pendingReason = null;
+        this.abortCurrentTurn();
+        if (this.scheduled) {
+            clearTimeout(this.scheduled);
+            this.scheduled = null;
+        }
+        this.clearRecoveryTimer();
+        this.stopIdleWatchdog();
+        this.recoveryAttempts = 0;
+        this.pausedAssistantSignature = null;
+        this.goalModeSupervisedAssistantSignature = null;
+    }
+    abortCurrentTurn() {
+        this.currentTurnAbortController?.abort();
+        this.currentTurnAbortController = null;
+    }
+    schedule(reason) {
+        if (!this.active) {
+            return;
+        }
+        this.pendingReason = reason;
+        this.clearRecoveryTimer();
+        if (this.scheduled || this.running) {
+            return;
+        }
+        this.scheduled = setTimeout(() => {
+            this.scheduled = null;
+            void this.runOnce();
+        }, AUTO_INPUT_DELAY_MS);
+    }
+    async submit(text, options = {}) {
+        const trimmed = text.trim();
+        if (!trimmed) {
+            return;
+        }
+        if (!this.active) {
+            this.start({ scheduleImmediately: false });
+        }
+        const session = this.interactive?.session;
+        const reason = options.reason ?? 'auto-on';
+        const snapshot = this.sessionControl.ensureControlSession('auto');
+        const backend = normalizeString(this.runtime?.backendCommandRouter?.backend)
+            ?? normalizeString(this.runtime?.backendSessionRef?.backend)
+            ?? normalizeString(this.runtime?.backend);
+        try {
+            const projection = this.sessionControl.recordSecretaryRuntimeIntent({
+                text: trimmed,
+                reason,
+            });
+            const delivery = await deliverProjectedInput(this.interactive, session, trimmed);
+            this.sessionControl.recordAutoInputEvent('delivered', {
+                reason,
+                runtimeProjection: {
+                    targetRole: projectedDeliveryTargetRole(delivery),
+                    source: 'secretary-runtime-intent',
+                    controlDecision: projection,
+                },
+                businessSession: snapshot.businessSession,
+                backend,
+                length: trimmed.length,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.sessionControl.recordAutoInputEvent('failed', {
+                reason,
+                message,
+                businessSession: snapshot.businessSession,
+                backend,
+            });
+            throw error;
+        }
+    }
+    installRuntimeHooks() {
+        if (this.unsubscribe || typeof this.interactive?.session?.subscribe !== 'function') {
+            return;
+        }
+        this.unsubscribe = this.interactive.session.subscribe((event) => {
+            if (!isRecord(event) || event.type !== 'agent_end') {
+                return;
+            }
+            if (isGoalModeActive(this.interactive, this.runtime)) {
+                return;
+            }
+            this.schedule('agent-end');
+        });
+        const originalStop = this.interactive?.stop?.bind(this.interactive);
+        if (typeof originalStop === 'function' && !this.interactive.__linxAutoInputStopPatched) {
+            this.interactive.stop = (...args) => {
+                try {
+                    this.stop();
+                    this.unsubscribe?.();
+                    this.unsubscribe = null;
+                }
+                finally {
+                    originalStop(...args);
+                }
+            };
+            this.interactive.__linxAutoInputStopPatched = true;
+        }
+    }
+    startIdleWatchdog() {
+        if (this.idleWatchdog) {
+            return;
+        }
+        this.idleWatchdog = setInterval(() => {
+            if (!this.active || this.running || this.scheduled || this.recoveryTimer || this.interactive?.__autoEnabled !== true) {
+                return;
+            }
+            const session = this.interactive?.session;
+            if (!session || session.isStreaming === true) {
+                return;
+            }
+            const recentMessages = resolveRecentMessages(this.interactive);
+            const latest = recentMessages.at(-1);
+            if (latest?.role !== 'assistant') {
+                return;
+            }
+            const signature = createAssistantSignature(latest.text);
+            if (signature && signature === this.pausedAssistantSignature) {
+                return;
+            }
+            if (isGoalModeActive(this.interactive, this.runtime)) {
+                if (signature && signature === this.goalModeSupervisedAssistantSignature) {
+                    return;
+                }
+                if (!isGoalModeSupervisorDue(this.interactive, this.runtime)) {
+                    return;
+                }
+                markGoalModeSupervisorChecked(this.interactive, this.runtime);
+                this.goalModeSupervisedAssistantSignature = signature;
+                this.schedule('runtime-idle');
+                return;
+            }
+            this.goalModeSupervisedAssistantSignature = null;
+            this.schedule('runtime-idle');
+        }, AUTO_INPUT_IDLE_WATCHDOG_MS);
+        this.idleWatchdog.unref?.();
+    }
+    stopIdleWatchdog() {
+        if (!this.idleWatchdog) {
+            return;
+        }
+        clearInterval(this.idleWatchdog);
+        this.idleWatchdog = null;
+    }
+    async runOnce() {
+        if (!this.active || this.running || this.interactive?.__autoEnabled !== true) {
+            return;
+        }
+        const session = this.interactive?.session;
+        if (!session || session.isStreaming === true) {
+            return;
+        }
+        this.running = true;
+        const generation = this.generation;
+        const reason = this.pendingReason;
+        this.pendingReason = null;
+        const turnAbortController = new AbortController();
+        this.currentTurnAbortController = turnAbortController;
+        let context = null;
+        try {
+            context = this.buildContext();
+            if (!context || !shouldGenerateNextUserInput(context)) {
+                this.resetRecoveryState();
+                return;
+            }
+            if (resolveAssistantSignature(context) === this.pausedAssistantSignature) {
+                return;
+            }
+            const execution = await this.runThroughThreadReconciler({
+                context,
+                reason,
+                generation,
+                signal: turnAbortController.signal,
+            });
+            context = execution.context;
+            const { reconciliation, scheduler, turn, text, attempts } = execution;
+            if (!this.active || generation !== this.generation || this.interactive?.__autoEnabled !== true) {
+                this.sessionControl.recordAutoInputEvent('failed', {
+                    reason,
+                    message: 'AI Secretary auto input projection was cancelled before delivery',
+                    run: summarizeRuntimeRun(turn.run),
+                    steps: summarizeRuntimeSteps(turn.steps),
+                    businessSession: context.snapshot.businessSession,
+                    backend: context.backend,
+                    reconciler: reconciliation,
+                    scheduler,
+                    attempts,
+                });
+                this.scheduleRecovery('runtime-idle', 'AI Secretary returned empty user input projection', context, generation);
+                return;
+            }
+            if (!text) {
+                if (context.goalMode) {
+                    this.resetRecoveryState();
+                    this.sessionControl.recordAutoInputEvent('skipped', {
+                        reason,
+                        message: 'Goal supervision found no Secretary intervention needed.',
+                        run: summarizeRuntimeRun(turn.run),
+                        steps: summarizeRuntimeSteps(turn.steps),
+                        businessSession: context.snapshot.businessSession,
+                        backend: context.backend,
+                        reconciler: reconciliation,
+                        scheduler,
+                        attempts,
+                    });
+                    return;
+                }
+                this.sessionControl.recordAutoInputEvent('failed', {
+                    reason,
+                    message: 'AI Secretary returned empty user input projection',
+                    run: summarizeRuntimeRun(turn.run),
+                    steps: summarizeRuntimeSteps(turn.steps),
+                    businessSession: context.snapshot.businessSession,
+                    backend: context.backend,
+                    reconciler: reconciliation,
+                    scheduler,
+                    attempts,
+                });
+                this.scheduleRecovery('runtime-idle', 'AI Secretary returned empty user input projection', context, generation);
+                return;
+            }
+            const projection = this.sessionControl.recordSecretaryRuntimeIntent({
+                text,
+                reason,
+            });
+            const delivery = await deliverProjectedInput(this.interactive, session, text);
+            this.resetRecoveryState();
+            this.sessionControl.recordAutoInputEvent('delivered', {
+                reason,
+                runtimeProjection: {
+                    targetRole: projectedDeliveryTargetRole(delivery),
+                    source: 'secretary-runtime-intent',
+                    controlDecision: projection,
+                },
+                run: summarizeRuntimeRun(turn.run),
+                steps: summarizeRuntimeSteps(turn.steps),
+                businessSession: context.snapshot.businessSession,
+                backend: context.backend,
+                reconciler: reconciliation,
+                scheduler,
+                length: text.length,
+                attempts,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.sessionControl.recordAutoInputEvent('failed', {
+                reason,
+                message,
+                run: isAgentRuntimeTurnError(error) ? summarizeRuntimeRun(error.run) : undefined,
+                steps: isAgentRuntimeTurnError(error) ? summarizeRuntimeSteps(error.steps) : undefined,
+            });
+            this.scheduleRecovery('runtime-idle', message, context, generation, error);
+        }
+        finally {
+            this.running = false;
+            if (this.currentTurnAbortController === turnAbortController) {
+                this.currentTurnAbortController = null;
+            }
+            if (this.active && this.pendingReason) {
+                this.schedule(this.pendingReason);
+            }
+        }
+    }
+    buildContext() {
+        const snapshot = this.sessionControl.ensureControlSession('auto');
+        const recentMessages = resolveRecentMessages(this.interactive);
+        if (recentMessages.length === 0) {
+            return null;
+        }
+        return {
+            snapshot,
+            backend: normalizeString(this.runtime?.backendCommandRouter?.backend)
+                ?? normalizeString(this.runtime?.backendSessionRef?.backend)
+                ?? normalizeString(this.runtime?.backend),
+            cwd: normalizeString(this.interactive?.session?.cwd)
+                ?? normalizeString(this.runtime?.cwd)
+                ?? snapshot.businessSession.cwd,
+            model: normalizeString(this.interactive?.session?.model?.id)
+                ?? normalizeString(this.runtime?.model),
+            goalMode: isGoalModeActive(this.interactive, this.runtime),
+            supervisorIntervalMs: resolveGoalModeSupervisorIntervalMs(this.interactive, this.runtime),
+            recentMessages,
+        };
+    }
+    async runThroughThreadReconciler(input) {
+        let context = null;
+        let inputText = '';
+        let wakeError;
+        let turn = null;
+        let text = null;
+        let attempts = 1;
+        const injectedResolver = resolveInjectedResolver(this.runtime);
+        const cycle = await runThreadReconcilerCycle({
+            policy: {
+                kind: 'auto',
+                secretaryAgent: SECRETARY_AGENT_ID,
+            },
+            handleWakeJob: async ({ decisionSummary }) => {
+                try {
+                    const reconciliation = decisionSummary;
+                    context = {
+                        ...input.context,
+                        reconciliation,
+                    };
+                    inputText = renderSecretaryAutoInputContext(context);
+                    const firstTurn = await runSecretaryAutoInputTurn({
+                        runtime: this.runtime,
+                        context,
+                        reason: input.reason,
+                        inputText,
+                        injectedResolver,
+                        reconciliation,
+                        attempt: 1,
+                        signal: input.signal,
+                    });
+                    const firstText = normalizeGeneratedInput(firstTurn.content);
+                    const shouldRetry = !firstText
+                        && this.active
+                        && input.generation === this.generation
+                        && this.interactive?.__autoEnabled === true;
+                    turn = shouldRetry
+                        ? await runSecretaryAutoInputTurn({
+                            runtime: this.runtime,
+                            context,
+                            reason: input.reason,
+                            inputText: renderSecretaryAutoInputRetryContext(inputText),
+                            injectedResolver,
+                            reconciliation,
+                            attempt: 2,
+                            signal: input.signal,
+                        })
+                        : firstTurn;
+                    attempts = shouldRetry ? MAX_AUTO_INPUT_ATTEMPTS : 1;
+                    text = shouldRetry ? normalizeGeneratedInput(turn.content) : firstText;
+                    return {
+                        attempts,
+                        textLength: text?.length ?? 0,
+                        run: turn.run.id,
+                    };
+                }
+                catch (error) {
+                    wakeError = error;
+                    throw error;
+                }
+            },
+            event: createAutoInputThreadEvent(input.context, input.reason),
+            dispatchOptions: {
+                randomId: `auto-${input.reason ?? 'scheduled'}-${Date.now()}`,
+            },
+            onDispatched: (dispatch) => {
+                const reconciliation = dispatch.summary;
+                context = {
+                    ...input.context,
+                    reconciliation,
+                };
+                inputText = renderSecretaryAutoInputContext(context);
+                this.sessionControl.recordAutoInputEvent('requested', {
+                    reason: input.reason,
+                    businessSession: context.snapshot.businessSession,
+                    backend: context.backend,
+                    reconciler: reconciliation,
+                    scheduler: {
+                        wakeRecords: dispatch.wakeRecordSummaries,
+                    },
+                });
+            },
+        });
+        const reconciliation = cycle.summary;
+        const scheduler = cycle.schedulerSummary;
+        if (scheduler.failed.length > 0) {
+            throw wakeError ?? new Error(String(scheduler.failed[0]?.error ?? 'AI Secretary wake job failed'));
+        }
+        if (!turn) {
+            throw new Error('AI Secretary was not awakened for auto input.');
+        }
+        if (!context) {
+            throw new Error('AI Secretary auto input context was not prepared by the Thread Reconciler.');
+        }
+        return {
+            context,
+            reconciliation,
+            scheduler,
+            turn,
+            text,
+            attempts,
+        };
+    }
+    scheduleRecovery(reason, message, context, generation, error) {
+        if (!this.active || generation !== this.generation || this.interactive?.__autoEnabled !== true) {
+            return;
+        }
+        if (!isRecoverableAutoInputFailure(message, error)) {
+            this.pauseOnAssistant(context, `Auto waiting for user: ${message}`);
+            return;
+        }
+        if (isTransientRemoteAutoInputFailure(message, error)) {
+            this.scheduleTransientRemoteRecovery(reason, message, generation);
+            return;
+        }
+        const recoveryDelaysMs = resolveAutoInputRecoveryDelaysMs();
+        if (this.recoveryAttempts >= recoveryDelaysMs.length) {
+            this.pauseOnAssistant(context, `Auto waiting for user: Secretary could not recover after ${this.recoveryAttempts} restart attempts. ${message}`);
+            return;
+        }
+        const attempt = this.recoveryAttempts + 1;
+        const delayMs = recoveryDelaysMs[this.recoveryAttempts];
+        this.recoveryAttempts = attempt;
+        this.clearRecoveryTimer();
+        this.interactive?.showStatus?.(`Auto recovering: restarting Secretary (${attempt}/${recoveryDelaysMs.length}).`);
+        this.interactive?.ui?.requestRender?.();
+        this.recoveryTimer = setTimeout(() => {
+            this.recoveryTimer = null;
+            if (!this.active || generation !== this.generation || this.interactive?.__autoEnabled !== true) {
+                return;
+            }
+            this.schedule(reason);
+        }, delayMs);
+        this.recoveryTimer.unref?.();
+    }
+    scheduleTransientRemoteRecovery(reason, message, generation) {
+        const attempt = this.recoveryAttempts + 1;
+        const delayMs = resolveTransientRemoteRecoveryDelayMs();
+        this.recoveryAttempts = attempt;
+        this.clearRecoveryTimer();
+        this.interactive?.showStatus?.(`Auto waiting for LinX Cloud: temporarily unavailable. Secretary will retry in ${formatDelay(delayMs)}. ${message}`);
+        this.interactive?.ui?.requestRender?.();
+        this.recoveryTimer = setTimeout(() => {
+            this.recoveryTimer = null;
+            if (!this.active || generation !== this.generation || this.interactive?.__autoEnabled !== true) {
+                return;
+            }
+            this.schedule(reason);
+        }, delayMs);
+        this.recoveryTimer.unref?.();
+    }
+    pauseOnAssistant(context, message) {
+        this.pausedAssistantSignature = context ? resolveAssistantSignature(context) : null;
+        this.clearRecoveryTimer();
+        this.interactive?.showStatus?.(message);
+        this.interactive?.ui?.requestRender?.();
+    }
+    clearRecoveryTimer() {
+        if (!this.recoveryTimer) {
+            return;
+        }
+        clearTimeout(this.recoveryTimer);
+        this.recoveryTimer = null;
+    }
+    resetRecoveryState() {
+        this.recoveryAttempts = 0;
+        this.pausedAssistantSignature = null;
+        this.clearRecoveryTimer();
+    }
+}
+function shouldGenerateNextUserInput(context) {
+    const latest = context.recentMessages.at(-1);
+    return latest?.role === 'assistant';
+}
+function isGoalModeActive(interactive, runtime) {
+    return interactive?.__linxGoalModeEnabled === true || runtime?.goalMode === true;
+}
+function resolveGoalModeSupervisorIntervalMs(interactive, runtime) {
+    const value = Number(interactive?.__linxGoalModeSupervisorIntervalMs
+        ?? runtime?.goalModeSupervisorIntervalMs
+        ?? interactive?.__linxSymphonyWorkerSupervisorIntervalMs
+        ?? runtime?.symphonyWorkerSupervisorIntervalMs
+        ?? DEFAULT_GOAL_MODE_SUPERVISOR_INTERVAL_MS);
+    if (!Number.isFinite(value) || value <= 0) {
+        return DEFAULT_GOAL_MODE_SUPERVISOR_INTERVAL_MS;
+    }
+    return Math.trunc(value);
+}
+function resolveGoalModeSupervisorLastAt(interactive, runtime) {
+    const value = Number(interactive?.__linxGoalModeSupervisorLastAt ?? runtime?.goalModeSupervisorLastAt);
+    return Number.isFinite(value) && value > 0 ? value : 0;
+}
+function markGoalModeSupervisorChecked(interactive, runtime, at = Date.now()) {
+    if (interactive && typeof interactive === 'object') {
+        interactive.__linxGoalModeSupervisorLastAt = at;
+    }
+    if (runtime && typeof runtime === 'object') {
+        runtime.goalModeSupervisorLastAt = at;
+    }
+}
+function isGoalModeSupervisorDue(interactive, runtime) {
+    const now = Date.now();
+    const lastAt = resolveGoalModeSupervisorLastAt(interactive, runtime);
+    if (!lastAt) {
+        markGoalModeSupervisorChecked(interactive, runtime, now);
+        return false;
+    }
+    return now - lastAt >= resolveGoalModeSupervisorIntervalMs(interactive, runtime);
+}
+function createAutoInputThreadEvent(context, reason) {
+    const businessSession = context.snapshot.businessSession;
+    const thread = businessSession.id ?? businessSession.file ?? `cwd:${businessSession.cwd}`;
+    return {
+        type: 'message.appended',
+        thread,
+        chat: businessSession.id ?? businessSession.file,
+        actor: {
+            id: context.backend ?? 'backend-runtime',
+            role: 'primary-agent',
+        },
+        data: {
+            source: 'primary-agent',
+            reason,
+            backend: context.backend,
+            businessSession: businessSession.id,
+        },
+    };
+}
+function resolveInjectedResolver(runtime) {
+    const candidates = [
+        runtime?.sessionControl?.resolveNextUserInput,
+        runtime?.resolveNextUserInput,
+        runtime?.resolveSecretaryNextUserInput,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'function') {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function runSecretaryAutoInputTurn(input) {
+    const startupOverride = resolveAgentRuntimeStartupOverride(input.runtime);
+    const agentConfig = resolveAgentRuntimeConfig({
+        agent: SECRETARY_AGENT_ID,
+        role: 'secretary',
+        model: DEFAULT_LINX_CLOUD_MODEL_ID,
+        label: SECRETARY_AGENT_LABEL,
+        runtime: DEFAULT_SECRETARY_RUNTIME_BACKEND,
+        systemPrompt: SECRETARY_SYSTEM_PROMPT,
+        metadata: {
+            mode: 'auto',
+            backend: input.context.backend,
+            cwd: input.context.cwd,
+            businessSession: input.context.snapshot.businessSession,
+            controlSession: input.context.snapshot.controlSession,
+            reconciler: input.reconciliation,
+        },
+    }, {
+        model: startupOverride?.model ?? input.context.model,
+        runtime: startupOverride,
+    });
+    return createAgentRuntime(agentConfig, async ({ agent, messages, signal }) => {
+        if (input.injectedResolver) {
+            const text = await input.injectedResolver(input.context);
+            return {
+                content: normalizeGeneratedInput(text) ?? '',
+                raw: {
+                    source: 'injected-resolver',
+                },
+            };
+        }
+        return resolveNextUserInputFromSecretaryRuntime(input.runtime, input.context, agent, messages, signal);
+    }).runTurn({
+        input: input.inputText,
+        messages: [{
+                role: 'user',
+                source: 'user',
+                content: input.inputText,
+                metadata: {
+                    businessSession: input.context.snapshot.businessSession,
+                    controlSession: input.context.snapshot.controlSession,
+                    reconciler: input.reconciliation,
+                },
+            }],
+        signal: combineAbortSignals(AbortSignal.timeout(15_000), input.signal),
+        metadata: {
+            reason: input.reason,
+            backend: input.context.backend,
+            attempt: input.attempt,
+            reconciler: input.reconciliation,
+        },
+    });
+}
+function combineAbortSignals(signal, extraSignal) {
+    if (!extraSignal) {
+        return signal;
+    }
+    if (typeof AbortSignal.any === 'function') {
+        return AbortSignal.any([signal, extraSignal]);
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    if (signal.aborted || extraSignal.aborted) {
+        abort();
+        return controller.signal;
+    }
+    signal.addEventListener('abort', abort, { once: true });
+    extraSignal.addEventListener('abort', abort, { once: true });
+    return controller.signal;
+}
+async function resolveNextUserInputFromSecretaryRuntime(runtime, context, agent, messages, signal) {
+    const backend = normalizeString(agent.runtime?.backend) ?? 'linx';
+    if (backend !== 'linx') {
+        throw new SecretaryAutoInputBlockedError(`Secretary runtime backend ${backend} is not supported yet.`);
+    }
+    const session = await resolveSecretaryPodDataSession(runtime);
+    if (!session) {
+        throw new SecretaryAutoInputBlockedError('LinX login is required before Secretary can drive auto input.');
+    }
+    const target = resolveRuntimeTarget({ issuerUrl: session.credentials.url });
+    const model = normalizeString(agent.runtime?.model) ?? agent.model;
+    const result = await createRemoteCompletionResult({
+        runtimeUrl: target.runtimeUrl,
+        authFetch: session.runtimeFetch,
+        model,
+        messages,
+        signal,
+    });
+    return {
+        content: result.content,
+        reasoningContent: result.reasoningContent,
+        finishReason: result.finishReason,
+        usage: result.usage ? { ...result.usage } : undefined,
+        raw: result,
+    };
+}
+async function resolveSecretaryPodDataSession(runtime) {
+    const runtimeSessionGetter = runtime?.getPodDataSession;
+    if (typeof runtimeSessionGetter === 'function') {
+        return runtimeSessionGetter.call(runtime);
+    }
+    return getDefaultPodDataSession();
+}
+function resolveAgentRuntimeStartupOverride(runtime) {
+    const candidates = [
+        runtime?.agentRuntimeConfig,
+        runtime?.agentRuntime,
+    ];
+    for (const candidate of candidates) {
+        if (!isRecord(candidate)) {
+            continue;
+        }
+        const resolved = normalizeAgentRuntimeBackendConfig(candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return undefined;
+}
+function normalizeAgentRuntimeBackendConfig(value) {
+    const backend = normalizeString(value.backend);
+    const model = normalizeString(value.model);
+    const credentialSource = normalizeString(value.credentialSource);
+    const runtime = normalizeString(value.runtime);
+    const transport = normalizeString(value.transport);
+    const endpoint = normalizeString(value.endpoint);
+    const metadata = isRecord(value.metadata) ? { ...value.metadata } : undefined;
+    const resolved = {
+        ...(backend ? { backend } : {}),
+        ...(model ? { model } : {}),
+        ...(credentialSource ? { credentialSource } : {}),
+        ...(runtime ? { runtime } : {}),
+        ...(transport ? { transport } : {}),
+        ...(endpoint ? { endpoint } : {}),
+        ...(metadata ? { metadata } : {}),
+    };
+    return Object.keys(resolved).length > 0 ? resolved : undefined;
+}
+function renderSecretaryAutoInputContext(context) {
+    return [
+        `Backend: ${context.backend ?? 'unknown'}`,
+        `Workspace: ${context.cwd}`,
+        context.model ? `Model: ${context.model}` : null,
+        `Goal mode: ${context.goalMode ? 'on' : 'off'}`,
+        context.goalMode && context.supervisorIntervalMs
+            ? `Supervisor interval: ${context.supervisorIntervalMs}ms`
+            : null,
+        '',
+        'Recent visible conversation:',
+        ...context.recentMessages.map((message) => `[${message.role}] ${message.text}`),
+        '',
+        context.goalMode
+            ? 'Write the next supervisor steer only when useful. Return empty if no intervention is needed.'
+            : 'Write the next user input only.',
+    ].filter((line) => line !== null).join('\n');
+}
+function renderSecretaryAutoInputRetryContext(inputText) {
+    return [
+        SECRETARY_RETRY_PREFIX,
+        '',
+        inputText,
+    ].join('\n');
+}
+function resolveRecentMessages(interactive) {
+    const fromEntries = resolveRecentMessagesFromEntries(interactive?.sessionManager?.getEntries?.()
+        ?? interactive?.session?.sessionManager?.getEntries?.());
+    if (fromEntries.length > 0) {
+        return fromEntries;
+    }
+    return resolveRecentMessagesFromAgentState(interactive?.session?.agent?.state?.messages);
+}
+function resolveRecentMessagesFromEntries(entries) {
+    if (!Array.isArray(entries)) {
+        return [];
+    }
+    return entries
+        .filter((entry) => isRecord(entry) && entry.type === 'message')
+        .map((entry) => normalizeMessage(entry.message))
+        .filter((message) => message !== null)
+        .slice(-MAX_CONTEXT_MESSAGES);
+}
+function resolveRecentMessagesFromAgentState(messages) {
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+    return messages
+        .map((message) => normalizeMessage(message))
+        .filter((message) => message !== null)
+        .slice(-MAX_CONTEXT_MESSAGES);
+}
+function normalizeMessage(message) {
+    if (!isRecord(message)) {
+        return null;
+    }
+    const role = normalizeString(message.role);
+    if (role !== 'user' && role !== 'assistant' && role !== 'system') {
+        return null;
+    }
+    const text = clipText(extractTextContent(message.content), MAX_CONTEXT_CHARS);
+    return text ? { role, text } : null;
+}
+function extractTextContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    return content
+        .map((part) => isRecord(part) && part.type === 'text' && typeof part.text === 'string' ? part.text : '')
+        .filter(Boolean)
+        .join('\n');
+}
+async function deliverAsUserInput(session, text) {
+    if (typeof session?.sendUserMessage === 'function') {
+        await session.sendUserMessage(text, session.isStreaming ? { deliverAs: 'followUp' } : undefined);
+        return;
+    }
+    if (typeof session?.prompt === 'function') {
+        await session.prompt(text, session.isStreaming ? { streamingBehavior: 'followUp' } : undefined);
+        return;
+    }
+    throw new Error('Active LinX session cannot accept user input projection');
+}
+async function deliverProjectedInput(interactive, session, text) {
+    if (text.trim().startsWith('/') && typeof interactive?.__linxHandleProjectedCommand === 'function') {
+        const handled = await interactive.__linxHandleProjectedCommand(text);
+        if (handled === 'peer-command') {
+            return 'peer-command';
+        }
+        if (handled === true) {
+            return 'control-command';
+        }
+    }
+    await deliverAsUserInput(session, text);
+    return 'backend';
+}
+function projectedDeliveryTargetRole(delivery) {
+    if (delivery === 'backend') {
+        return 'user';
+    }
+    return delivery;
+}
+function normalizeGeneratedInput(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const text = clipText(stripWrappingFence(value.trim()), MAX_GENERATED_INPUT_CHARS);
+    return text.length > 0 ? text : null;
+}
+class SecretaryAutoInputBlockedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SecretaryAutoInputBlockedError';
+    }
+}
+function isRecoverableAutoInputFailure(message, error) {
+    if (error instanceof SecretaryAutoInputBlockedError || isRemoteAuthExpiredError(error)) {
+        return false;
+    }
+    const normalized = message.toLowerCase();
+    if (normalized.includes('login is required')
+        || normalized.includes('login expired')
+        || normalized.includes('credential')
+        || normalized.includes('unauthorized')
+        || normalized.includes('permission')
+        || normalized.includes('missing authority')) {
+        return false;
+    }
+    return true;
+}
+function isTransientRemoteAutoInputFailure(message, error) {
+    const status = resolveTransientRemoteFailureStatus(error);
+    if (status !== null) {
+        return true;
+    }
+    const normalized = message.toLowerCase();
+    return normalized.includes('linx cloud is temporarily unavailable')
+        || (normalized.includes('502') && normalized.includes('bad gateway'))
+        || (normalized.includes('503') && normalized.includes('service unavailable'))
+        || (normalized.includes('504') && normalized.includes('gateway timeout'));
+}
+function resolveTransientRemoteFailureStatus(error) {
+    if (typeof error === 'object' && error !== null) {
+        const candidates = [
+            error.status,
+            error.response?.status,
+            error.cause?.status,
+        ];
+        for (const candidate of candidates) {
+            if (candidate === 502 || candidate === 503 || candidate === 504) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+function resolveAutoInputRecoveryDelaysMs() {
+    return parsePositiveIntegerListEnv('LINX_AUTO_INPUT_RECOVERY_DELAYS_MS')
+        ?? [...DEFAULT_AUTO_INPUT_RECOVERY_DELAYS_MS];
+}
+function resolveTransientRemoteRecoveryDelayMs() {
+    return parsePositiveIntegerEnv('LINX_AUTO_INPUT_TRANSIENT_RECOVERY_DELAY_MS')
+        ?? DEFAULT_TRANSIENT_REMOTE_RECOVERY_DELAY_MS;
+}
+function parsePositiveIntegerListEnv(name) {
+    const raw = process.env[name];
+    if (!raw) {
+        return null;
+    }
+    const values = raw.split(',').map((part) => Number(part.trim()));
+    if (values.length === 0 || values.some((value) => !Number.isFinite(value) || value <= 0)) {
+        return null;
+    }
+    return values.map((value) => Math.trunc(value));
+}
+function parsePositiveIntegerEnv(name) {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? Math.trunc(value) : null;
+}
+function formatDelay(delayMs) {
+    if (delayMs < 1_000) {
+        return `${delayMs}ms`;
+    }
+    const seconds = delayMs / 1_000;
+    return Number.isInteger(seconds) ? `${seconds}s` : `${seconds.toFixed(1)}s`;
+}
+function resolveAssistantSignature(context) {
+    const latest = context.recentMessages.at(-1);
+    return latest?.role === 'assistant' ? createAssistantSignature(latest.text) : null;
+}
+function createAssistantSignature(text) {
+    const normalized = text.trim();
+    return normalized ? normalized.slice(-512) : null;
+}
+function stripWrappingFence(value) {
+    const match = value.match(/^```(?:text|markdown|md)?\s*\n([\s\S]*?)\n```$/i);
+    return match?.[1]?.trim() ?? value;
+}
+function clipText(value, maxChars) {
+    return value.length > maxChars ? value.slice(0, maxChars) : value;
+}
+function normalizeString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function summarizeRuntimeRun(run) {
+    return {
+        id: run.id,
+        agent: run.agent,
+        role: run.role,
+        model: run.model,
+        trigger: run.trigger,
+        status: run.status,
+        startedAt: run.startedAt,
+        completedAt: run.completedAt,
+    };
+}
+function summarizeRuntimeSteps(steps) {
+    return steps.map((step) => ({
+        id: step.id,
+        stepType: step.stepType,
+        message: step.message,
+        createdAt: step.createdAt,
+    }));
+}
+function isAgentRuntimeTurnError(error) {
+    return isRecord(error)
+        && isRecord(error.run)
+        && Array.isArray(error.steps);
+}
+//# sourceMappingURL=auto-input-controller.js.map