@undefineds.co/linx 0.3.5 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@undefineds.co/linx",
-  "version": "0.3.5",
+  "version": "0.3.8",
   "private": false,
   "type": "module",
   "bin": {
@@ -12,17 +12,23 @@
     "test": "yarn build && node --test --test-concurrency=1 test/**/*.test.mjs"
   },
   "dependencies": {
-    "@inrupt/solid-client-authn-node": "^4.0.0",
-    "@mariozechner/pi-coding-agent": "^0.73.1",
-    "@sinclair/typebox": "^0.34.49",
-    "@undefineds.co/models": "0.2.38",
+    "@inrupt/solid-client-authn-node": "^3.1.1",
+    "@earendil-works/pi-agent-core": "0.78.0",
+    "@earendil-works/pi-ai": "0.78.0",
+    "@earendil-works/pi-coding-agent": "0.78.0",
+    "@earendil-works/pi-tui": "0.78.0",
+    "@undefineds.co/drizzle-solid": "^0.3.14",
+    "@undefineds.co/models": "0.2.39",
     "@zed-industries/codex-acp": "0.14.0",
-    "n3": "^2.0.3",
-    "yargs": "^18.0.0"
+    "n3": "^1.26.0",
+    "pi-web-access": "^0.10.7",
+    "ws": "^8.20.0",
+    "typebox": "^1.1.38",
+    "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@types/node": "^25.9.1",
-    "typescript": "^6.0.3"
+    "@types/node": "^24.10.1",
+    "typescript": "^5.6.2"
   },
   "files": [
     "dist",

package/vendor/agent-runtime/dist/agent-runtime.d.ts

@@ -0,0 +1,137 @@
+import type { AgentParticipantRole, AgentTurnTrigger } from './turn-controller.js';
+type MaybePromise<T> = T | Promise<T>;
+export type AgentRuntimeTurnStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+export type AgentRuntimeMessageRole = 'system' | 'user' | 'assistant' | 'tool';
+export type AgentRuntimeMessageSource = 'user' | 'primary-agent' | 'secretary' | 'tool' | 'system';
+export interface AgentRuntimeMessage {
+    role: AgentRuntimeMessageRole;
+    content: string;
+    source?: AgentRuntimeMessageSource;
+    createdAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentRuntimeBackendConfig {
+    backend?: string;
+    model?: string;
+    credentialSource?: string;
+    runtime?: string;
+    transport?: string;
+    endpoint?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentRuntimeSkillSnapshot {
+    id: string;
+    name?: string;
+    version?: string;
+    source?: string;
+    checksum?: string;
+    loadPolicy?: string;
+    enabled?: boolean;
+}
+export interface AgentRuntimeConfig {
+    agent: string;
+    role: AgentParticipantRole;
+    model: string;
+    label?: string;
+    runtime?: AgentRuntimeBackendConfig;
+    skills?: AgentRuntimeSkillSnapshot[];
+    authorityPolicy?: Record<string, unknown>;
+    toolPolicy?: Record<string, unknown>;
+    systemPrompt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentRuntimeConfigOverrides {
+    model?: string;
+    runtime?: Partial<AgentRuntimeBackendConfig>;
+    skills?: AgentRuntimeSkillSnapshot[];
+    authorityPolicy?: Record<string, unknown>;
+    toolPolicy?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentRuntimeConfigSnapshot {
+    agent: string;
+    role: AgentParticipantRole;
+    model: string;
+    label?: string;
+    runtime?: AgentRuntimeBackendConfig;
+    credentialSource?: string;
+    skills?: AgentRuntimeSkillSnapshot[];
+    authorityPolicy?: Record<string, unknown>;
+    toolPolicy?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    source?: string;
+    createdAt: string;
+}
+export interface AgentRuntimeCompletionRequest {
+    agent: AgentRuntimeConfig;
+    model: string;
+    messages: AgentRuntimeMessage[];
+    signal?: AbortSignal;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentRuntimeCompletionResult {
+    content: string;
+    reasoningContent?: string;
+    finishReason?: string | null;
+    usage?: Record<string, unknown>;
+    raw?: unknown;
+}
+export type AgentRuntimeComplete = (request: AgentRuntimeCompletionRequest) => MaybePromise<AgentRuntimeCompletionResult>;
+export interface AgentRuntimeRunRecord {
+    id: string;
+    agent: string;
+    role: AgentParticipantRole;
+    model: string;
+    runtime?: AgentRuntimeBackendConfig;
+    trigger?: AgentTurnTrigger | string;
+    input?: string;
+    status: AgentRuntimeTurnStatus;
+    output?: string;
+    error?: string;
+    startedAt: string;
+    completedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentRuntimeRunStepRecord {
+    id: string;
+    run: string;
+    stepType: string;
+    message?: string;
+    data?: Record<string, unknown>;
+    createdAt: string;
+}
+export interface AgentRuntimeTurnInput {
+    trigger?: AgentTurnTrigger | string;
+    input?: string;
+    messages: AgentRuntimeMessage[];
+    signal?: AbortSignal;
+    metadata?: Record<string, unknown>;
+    now?: () => Date;
+    randomId?: string;
+}
+export interface AgentRuntimeTurnResult {
+    run: AgentRuntimeRunRecord;
+    steps: AgentRuntimeRunStepRecord[];
+    content: string;
+    reasoningContent?: string;
+    finishReason?: string | null;
+    usage?: Record<string, unknown>;
+    raw?: unknown;
+}
+export interface AgentRuntime {
+    readonly config: AgentRuntimeConfig;
+    runTurn(input: AgentRuntimeTurnInput): Promise<AgentRuntimeTurnResult>;
+}
+export declare class AgentRuntimeTurnError extends Error {
+    readonly run: AgentRuntimeRunRecord;
+    readonly steps: AgentRuntimeRunStepRecord[];
+    readonly cause?: unknown | undefined;
+    constructor(message: string, run: AgentRuntimeRunRecord, steps: AgentRuntimeRunStepRecord[], cause?: unknown | undefined);
+}
+export declare function createAgentRuntime(config: AgentRuntimeConfig, complete: AgentRuntimeComplete): AgentRuntime;
+export declare function resolveAgentRuntimeConfig(defaults: AgentRuntimeConfig, overrides?: AgentRuntimeConfigOverrides): AgentRuntimeConfig;
+export declare function createAgentRuntimeConfigSnapshot(config: AgentRuntimeConfig, input?: {
+    createdAt?: string | Date;
+    source?: string;
+}): AgentRuntimeConfigSnapshot;
+export {};

package/vendor/agent-runtime/dist/agent-runtime.js

@@ -0,0 +1,211 @@
+export class AgentRuntimeTurnError extends Error {
+    run;
+    steps;
+    cause;
+    constructor(message, run, steps, cause) {
+        super(message);
+        this.run = run;
+        this.steps = steps;
+        this.cause = cause;
+        this.name = 'AgentRuntimeTurnError';
+    }
+}
+export function createAgentRuntime(config, complete) {
+    return new ConfiguredAgentRuntime(config, complete);
+}
+export function resolveAgentRuntimeConfig(defaults, overrides = {}) {
+    const runtime = resolveAgentRuntimeBackendConfig(defaults.runtime, overrides.runtime, overrides.model);
+    const model = normalizeRuntimeConfigString(overrides.model)
+        ?? normalizeRuntimeConfigString(overrides.runtime?.model)
+        ?? normalizeRuntimeConfigString(runtime?.model)
+        ?? defaults.model;
+    return {
+        ...defaults,
+        model,
+        ...(runtime ? { runtime: { ...runtime, model } } : {}),
+        ...(overrides.skills ? { skills: cloneSkillSnapshots(overrides.skills) } : {}),
+        ...(overrides.authorityPolicy ? { authorityPolicy: { ...overrides.authorityPolicy } } : {}),
+        ...(overrides.toolPolicy ? { toolPolicy: { ...overrides.toolPolicy } } : {}),
+        metadata: mergeRuntimeMetadata(defaults.metadata, overrides.metadata),
+    };
+}
+export function createAgentRuntimeConfigSnapshot(config, input = {}) {
+    const createdAt = input.createdAt instanceof Date
+        ? input.createdAt.toISOString()
+        : typeof input.createdAt === 'string' && input.createdAt.trim().length > 0
+            ? input.createdAt
+            : new Date().toISOString();
+    return omitUndefined({
+        agent: config.agent,
+        role: config.role,
+        model: config.model,
+        label: config.label,
+        runtime: config.runtime ? { ...config.runtime } : undefined,
+        credentialSource: config.runtime?.credentialSource,
+        skills: config.skills ? cloneSkillSnapshots(config.skills) : undefined,
+        authorityPolicy: config.authorityPolicy ? { ...config.authorityPolicy } : undefined,
+        toolPolicy: config.toolPolicy ? { ...config.toolPolicy } : undefined,
+        metadata: config.metadata ? { ...config.metadata } : undefined,
+        source: input.source,
+        createdAt,
+    });
+}
+class ConfiguredAgentRuntime {
+    config;
+    complete;
+    constructor(config, complete) {
+        this.config = config;
+        this.complete = complete;
+    }
+    async runTurn(input) {
+        const now = input.now ?? (() => new Date());
+        const run = createRunRecord(this.config, input, now);
+        const steps = [];
+        const nextStep = createStepFactory(run.id, now);
+        steps.push(nextStep('run.created', 'Runtime turn created', {
+            agent: this.config.agent,
+            role: this.config.role,
+            model: this.config.model,
+            runtime: this.config.runtime,
+            runtimeSnapshot: run.metadata?.runtimeSnapshot,
+            trigger: input.trigger,
+        }));
+        const messages = buildRuntimeMessages(this.config, input.messages);
+        steps.push(nextStep('runtime.input.prepared', 'Runtime input prepared', {
+            messageCount: messages.length,
+            input: input.input,
+        }));
+        try {
+            const result = await this.complete({
+                agent: this.config,
+                model: this.config.model,
+                messages,
+                signal: input.signal,
+                metadata: {
+                    ...(this.config.runtime ? { runtime: this.config.runtime } : {}),
+                    ...this.config.metadata,
+                    ...input.metadata,
+                },
+            });
+            const completedAt = now().toISOString();
+            const content = result.content ?? '';
+            run.status = 'completed';
+            run.output = content;
+            run.completedAt = completedAt;
+            steps.push(nextStep('runtime.output.completed', 'Runtime output completed', {
+                finishReason: result.finishReason,
+                outputLength: content.length,
+                usage: result.usage,
+            }));
+            return {
+                run,
+                steps,
+                content,
+                reasoningContent: result.reasoningContent,
+                finishReason: result.finishReason,
+                usage: result.usage,
+                raw: result.raw,
+            };
+        }
+        catch (cause) {
+            const message = cause instanceof Error ? cause.message : String(cause);
+            const completedAt = now().toISOString();
+            run.status = 'failed';
+            run.error = message;
+            run.completedAt = completedAt;
+            steps.push(nextStep('runtime.error', message, {
+                error: message,
+            }));
+            throw new AgentRuntimeTurnError(message, run, steps, cause);
+        }
+    }
+}
+function buildRuntimeMessages(config, messages) {
+    const systemPrompt = config.systemPrompt?.trim();
+    if (!systemPrompt) {
+        return messages;
+    }
+    return [
+        {
+            role: 'system',
+            source: 'system',
+            content: systemPrompt,
+        },
+        ...messages,
+    ];
+}
+function createRunRecord(config, input, now) {
+    const startedAt = now().toISOString();
+    const runtimeSnapshot = createAgentRuntimeConfigSnapshot(config, {
+        createdAt: startedAt,
+        source: 'agent-runtime.run',
+    });
+    return {
+        id: createRuntimeRecordId('run', input.randomId),
+        agent: config.agent,
+        role: config.role,
+        model: config.model,
+        ...(config.runtime ? { runtime: config.runtime } : {}),
+        trigger: input.trigger,
+        input: input.input,
+        status: 'running',
+        startedAt,
+        metadata: {
+            ...(config.runtime ? { runtime: config.runtime } : {}),
+            ...config.metadata,
+            ...input.metadata,
+            ...(config.label ? { label: config.label } : {}),
+            runtimeSnapshot,
+        },
+    };
+}
+function resolveAgentRuntimeBackendConfig(defaults, overrides, modelOverride) {
+    if (!defaults && !overrides && !modelOverride) {
+        return undefined;
+    }
+    const metadata = mergeRuntimeMetadata(defaults?.metadata, overrides?.metadata);
+    return {
+        ...defaults,
+        ...overrides,
+        ...(normalizeRuntimeConfigString(modelOverride) ? { model: normalizeRuntimeConfigString(modelOverride) } : {}),
+        ...(metadata ? { metadata } : {}),
+    };
+}
+function mergeRuntimeMetadata(defaults, overrides) {
+    if (!defaults && !overrides) {
+        return undefined;
+    }
+    return {
+        ...defaults,
+        ...overrides,
+    };
+}
+function cloneSkillSnapshots(skills) {
+    return skills.map((skill) => ({ ...skill }));
+}
+function omitUndefined(record) {
+    return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+function normalizeRuntimeConfigString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function createStepFactory(run, now) {
+    let sequence = 0;
+    return (stepType, message, data) => {
+        sequence += 1;
+        return {
+            id: `${run}-step-${String(sequence).padStart(4, '0')}`,
+            run,
+            stepType,
+            ...(message ? { message } : {}),
+            ...(data ? { data } : {}),
+            createdAt: now().toISOString(),
+        };
+    };
+}
+function createRuntimeRecordId(prefix, randomId) {
+    const suffix = randomId?.trim()
+        || globalThis.crypto?.randomUUID?.()
+        || Math.random().toString(36).slice(2, 10).padEnd(8, '0');
+    return `${prefix}_${suffix}`;
+}

package/vendor/agent-runtime/dist/auto-mode.d.ts

@@ -1,9 +1,11 @@
-export type AutoModeBackend = 'codex' | 'claude' | 'codebuddy';
-export type AutoModeMode = 'manual' | 'smart' | 'auto';
+export type AutoModeBackend = 'linx' | 'codex' | 'claude' | 'codebuddy';
+export type AutoModeWorkerBackend = AutoModeBackend;
+export type AutoModeMode = 'off' | 'auto';
+export type LegacyAutoModeMode = AutoModeMode | 'manual' | 'smart';
 export type AutoModeSessionStatus = 'running' | 'completed' | 'failed';
 export type AutoModeOutputStream = 'stdout' | 'stderr' | 'system';
-export type AutoModeCredentialSource = 'cloud';
-export type AutoModeResolvedCredentialSource = 'cloud';
+export type AutoModeCredentialSource = 'cloud' | 'local';
+export type AutoModeResolvedCredentialSource = 'cloud' | 'local';
 type LegacyAutoModeCredentialSource = AutoModeCredentialSource | 'auto' | 'local';
 export type AutoModeApprovalSource = 'local' | 'remote' | 'hybrid';
 export type AutoModeRuntime = 'local';
@@ -32,7 +34,8 @@ export interface AutoModeSessionRecord {
     backend: AutoModeBackend;
     runtime: AutoModeRuntime;
     transport?: AutoModeTransport;
-    mode: AutoModeMode;
+    mode: LegacyAutoModeMode;
+    autoEnabled?: boolean;
     goalMode?: boolean;
     cwd: string;
     model?: string;
@@ -50,21 +53,39 @@ export interface AutoModeSessionRecord {
     signal?: string | null;
     error?: string;
     backendSessionId?: string;
+    metadata?: Record<string, unknown>;
     archiveDir: string;
     eventsFile: string;
 }
 export type AutoModeApprovalRequestKind = 'command-approval' | 'file-change-approval' | 'permissions-approval' | 'codex-approval';
 export type AutoModeInteractionRequestKind = AutoModeApprovalRequestKind | 'user-input';
-export type AutoModeApprovalDecision = 'accept' | 'accept_for_session' | 'decline' | 'cancel';
+export type AutoModeApprovalDecision = 'accept' | 'accept_for_session' | 'accept_always' | 'decline' | 'cancel';
 export type AutoModeSecretaryApprovalDecision = 'accept' | 'decline' | 'cancel';
-export type AutoModeApprovalOptionKind = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always' | (string & {});
+export type AutoModeApprovalOptionKind = 'allow_once' | 'allow_for_session' | 'allow_always' | 'reject_once' | 'reject_always' | (string & {});
 export type AutoModeApprovalRisk = 'low' | 'medium' | 'high';
+export type AutoModeGrantScope = 'session' | 'durable';
 export interface AutoModeApprovalOption {
     optionId: string;
     label: string;
     kind?: AutoModeApprovalOptionKind;
     description?: string;
 }
+export type AutoModeStoredApprovalStatus = 'pending' | 'approved' | 'rejected' | (string & {});
+export interface AutoModeApprovalDecisionReason {
+    source?: string;
+    decision?: AutoModeApprovalDecision;
+    note?: string;
+    selectedOptionId?: string;
+    selectedLabel?: string;
+}
+export interface BuildAutoModeApprovalDecisionReasonOptions {
+    source?: string;
+    decision?: AutoModeApprovalDecision;
+    note?: string;
+    selectedOption?: AutoModeApprovalOption;
+    selectedOptionId?: string;
+    selectedLabel?: string;
+}
 interface AutoModeInteractionRequestBase {
     kind: AutoModeInteractionRequestKind;
     message: string;
@@ -138,7 +159,8 @@ export declare function autoModeApprovalToolName(request: AutoModeApprovalReques
 export declare function autoModeApprovalRisk(request: AutoModeApprovalRequest): AutoModeApprovalRisk;
 export declare function autoModeApprovalRequestMessage(request: AutoModeApprovalRequest): string;
 export interface ParseAutoModeSecretaryRecommendationOptions {
-    mode: AutoModeMode;
+    mode: LegacyAutoModeMode;
+    autoEnabled?: boolean;
     request: AutoModeInteractionRequest;
     defaultReactionWindowMs?: number;
 }
@@ -192,7 +214,8 @@ export interface AutoModeThreadMetadata extends Record<string, unknown> {
     backend: AutoModeBackend;
     runtime: AutoModeRuntime;
     transport?: AutoModeTransport;
-    mode: AutoModeMode;
+    mode: LegacyAutoModeMode;
+    autoEnabled?: boolean;
     goalMode?: boolean;
     cwd: string;
     model?: string;
@@ -202,6 +225,31 @@ export interface AutoModeThreadMetadata extends Record<string, unknown> {
     status: AutoModeSessionStatus;
     backendSessionId?: string;
 }
+export type AutoModeCommandTargetRole = 'control-command' | 'peer-command';
+export type AutoModeAutoControl = {
+    action: 'status';
+} | {
+    action: 'set';
+    enabled: boolean;
+    initialInput?: string;
+};
+export interface AutoModeControlCommandRoute {
+    kind: 'control-command';
+    targetRole: 'control-command';
+    command: 'auto' | (string & {});
+    text: string;
+    auto?: AutoModeAutoControl;
+}
+export interface AutoModePeerCommandRoute {
+    kind: 'peer-command';
+    targetRole: 'peer-command';
+    command: 'goal' | (string & {});
+    text: string;
+    secretaryBehavior?: {
+        goalMode?: boolean;
+    };
+}
+export type AutoModeCommandRoute = AutoModeControlCommandRoute | AutoModePeerCommandRoute;
 export type AutoModeTranscriptMessageRole = 'user' | 'assistant' | 'system';
 export type AutoModeTranscriptMessageSource = 'user' | 'primary-agent' | 'secretary' | 'tool' | 'system';
 export interface AutoModeTranscriptMessage {
@@ -219,6 +267,8 @@ export interface AutoModeArchiveRelativePaths {
     sessionFile: string;
     eventsFile: string;
 }
+export declare function resolveAutoModeCommandRoute(input: string | null | undefined): AutoModeCommandRoute | null;
+export declare function resolveAutoModePeerCommand(input: string | null | undefined): AutoModePeerCommandRoute | null;
 export declare const AUTO_MODE_HOME_DIRNAME = "auto-mode";
 export declare const AUTO_MODE_SESSIONS_DIRNAME = "sessions";
 export declare const AUTO_MODE_SESSION_FILE_NAME = "session.json";
@@ -226,9 +276,21 @@ export declare const AUTO_MODE_EVENTS_FILE_NAME = "events.jsonl";
 export declare function normalizeAutoModeUserInputQuestion(value: unknown, fallbackId?: string): AutoModeUserInputQuestion | null;
 export declare function resolveAutoModeQuestionAnswer(question: AutoModeUserInputQuestion, answer: string): string[];
 export declare function normalizeAutoModeApprovalOptions(value: unknown): AutoModeApprovalOption[];
+export declare function parseAutoModeApprovalOptions(value: unknown): AutoModeApprovalOption[];
+export declare function encodeAutoModeApprovalOptions(options: AutoModeApprovalOption[] | undefined): string | undefined;
+export declare function buildAutoModeApprovalDecisionReason(options: AutoModeApprovalDecision | BuildAutoModeApprovalDecisionReasonOptions, note?: string): string;
+export declare function parseAutoModeApprovalDecisionReason(value: unknown): AutoModeApprovalDecisionReason | null;
+export declare function autoModeApprovalDecisionForOption(option: AutoModeApprovalOption): AutoModeApprovalDecision;
+export declare function autoModeApprovalDecisionForStoredApproval(input: {
+    status: AutoModeStoredApprovalStatus | undefined;
+    reason?: unknown;
+    approvalOptions?: unknown;
+}): AutoModeApprovalDecision | null;
+export declare function shouldMaterializeAutoModeGrant(decision: AutoModeApprovalDecision | null | undefined): boolean;
+export declare function autoModeGrantScopeForDecision(decision: AutoModeApprovalDecision | null | undefined): AutoModeGrantScope | null;
 export declare function createAutoModeSessionId(options?: CreateAutoModeSessionIdOptions): string;
-export declare function normalizeAutoModeCredentialSource(_source?: LegacyAutoModeCredentialSource | null): AutoModeCredentialSource;
-export declare function shouldAttemptCloudCredentialProbe(_requestedSource: LegacyAutoModeCredentialSource, _localAuthStatus: AutoModeAuthStatus): boolean;
+export declare function normalizeAutoModeCredentialSource(source?: LegacyAutoModeCredentialSource | null): AutoModeCredentialSource;
+export declare function shouldAttemptCloudCredentialProbe(requestedSource: LegacyAutoModeCredentialSource, _localAuthStatus: AutoModeAuthStatus): boolean;
 export declare function formatAutoModeAutoFallbackMessage(localMessage: string, detail: string): string;
 export declare function resolveAutoModeCredentialSourceResolution(input: {
     requestedSource?: LegacyAutoModeCredentialSource | null;
@@ -237,11 +299,13 @@ export declare function resolveAutoModeCredentialSourceResolution(input: {
     defaultLocalMessage?: string;
 }): AutoModeCredentialSourceResolution;
 export declare function resolveAutoModeAutoApprovalDecision(input: {
-    mode: AutoModeMode;
+    mode: LegacyAutoModeMode;
+    autoEnabled?: boolean;
     request: AutoModeApprovalRequest;
 }): AutoModeApprovalDecision | null;
 export declare function createFallbackAutoModeSecretaryRecommendation(input: {
-    mode: AutoModeMode;
+    mode: LegacyAutoModeMode;
+    autoEnabled?: boolean;
     request: AutoModeInteractionRequest;
 }): AutoModeSecretaryRecommendation | null;
 export declare function parseAutoModeSecretaryRecommendation(text: string, options: ParseAutoModeSecretaryRecommendationOptions): AutoModeSecretaryRecommendation | null;
@@ -260,6 +324,7 @@ export declare function isTrustedAutoModeCommand(command: string | null | undefi
 export declare function normalizeCodexAppServerInteractionRequest(message: Record<string, unknown>): AutoModeInteractionRequest | null;
 export declare function resolveAutoModeInteractionAutoResponse(input: {
     mode: AutoModeMode;
+    autoEnabled?: boolean;
     request: AutoModeInteractionRequest;
 }): unknown | null;
 export declare function buildCodexApprovalResponse(request: AutoModeApprovalRequest, decision: AutoModeApprovalDecision): unknown;