@foxden-app/foxclaw 0.11.1 → 0.13.0

package/dist/codex_app/activity.js

@@ -0,0 +1,418 @@
+export function normalizeTurnActivityEvent(notification) {
+    switch (notification.method) {
+        case 'item/started':
+            return normalizeStartedEvent(notification.params);
+        case 'item/agentMessage/delta':
+            return normalizeAgentDeltaEvent(notification.params);
+        case 'item/plan/delta':
+            return normalizePlanDeltaEvent(notification.params);
+        case 'item/completed':
+            return normalizeCompletedEvent(notification.params);
+        case 'turn/plan/updated':
+            return normalizePlanUpdatedEvent(notification.params);
+        case 'codex/event/exec_command_begin':
+            return normalizeToolEvent(notification.params, 'tool_started');
+        case 'codex/event/exec_command_end':
+            return normalizeToolEvent(notification.params, 'tool_completed');
+        case 'turn/completed': {
+            const turnId = extractTurnId(notification.params);
+            if (!turnId)
+                return null;
+            return {
+                kind: 'turn_completed',
+                turnId,
+                state: 'completed',
+            };
+        }
+        case 'turn/interrupted':
+        case 'turn/aborted': {
+            const turnId = extractTurnId(notification.params);
+            if (!turnId)
+                return null;
+            return {
+                kind: 'turn_completed',
+                turnId,
+                state: 'interrupted',
+            };
+        }
+        default:
+            return null;
+    }
+}
+function normalizeStartedEvent(params) {
+    const turnId = extractTurnId(params);
+    if (!turnId)
+        return null;
+    const item = params?.item;
+    const itemType = normalizeEventItemType(item);
+    if (itemType === 'reasoning') {
+        return {
+            kind: 'reasoning_started',
+            turnId,
+            state: 'thinking',
+        };
+    }
+    const toolEvent = normalizeThreadItemToolEvent(params, 'tool_started');
+    if (toolEvent) {
+        return toolEvent;
+    }
+    if (!isRelayableTextItemType(itemType)) {
+        return null;
+    }
+    const itemId = extractItemId(item);
+    if (!itemId)
+        return null;
+    const phase = itemType === 'plan' ? 'commentary' : extractAgentPhase(item);
+    return {
+        kind: 'agent_message_started',
+        turnId,
+        itemId,
+        phase,
+        outputKind: outputKindForItemType(itemType, phase, false),
+        isPlan: itemType === 'plan',
+    };
+}
+function normalizeAgentDeltaEvent(params) {
+    const turnId = extractTurnId(params);
+    const delta = extractAgentDeltaText(params);
+    const itemId = extractItemId(params);
+    if (!turnId || !delta || !itemId) {
+        return null;
+    }
+    const phase = extractAgentPhase(params);
+    return {
+        kind: 'agent_message_delta',
+        turnId,
+        itemId,
+        delta,
+        outputKind: classifyAgentOutput(phase, false),
+    };
+}
+function normalizePlanDeltaEvent(params) {
+    const turnId = extractTurnId(params);
+    const delta = extractAgentDeltaText(params);
+    const itemId = extractItemId(params);
+    if (!turnId || !delta || !itemId) {
+        return null;
+    }
+    return {
+        kind: 'agent_message_delta',
+        turnId,
+        itemId,
+        delta,
+        outputKind: 'commentary',
+        isPlan: true,
+    };
+}
+function normalizeCompletedEvent(params) {
+    const turnId = extractTurnId(params);
+    if (!turnId)
+        return null;
+    const item = params?.item;
+    const itemType = normalizeEventItemType(item);
+    if (itemType === 'reasoning') {
+        return {
+            kind: 'reasoning_completed',
+            turnId,
+            state: 'thinking',
+        };
+    }
+    const toolEvent = normalizeThreadItemToolEvent(params, 'tool_completed');
+    if (toolEvent) {
+        return toolEvent;
+    }
+    if (!isRelayableTextItemType(itemType)) {
+        return null;
+    }
+    const itemId = extractItemId(item);
+    if (!itemId)
+        return null;
+    const phase = itemType === 'plan' ? 'commentary' : extractAgentPhase(item);
+    return {
+        kind: 'agent_message_completed',
+        turnId,
+        itemId,
+        phase,
+        text: extractCompletedAgentText(params),
+        outputKind: outputKindForItemType(itemType, phase, true),
+        isPlan: itemType === 'plan',
+    };
+}
+function normalizePlanUpdatedEvent(params) {
+    const turnId = extractTurnId(params);
+    if (!turnId) {
+        return null;
+    }
+    const text = formatPlanUpdateText(params);
+    if (!text) {
+        return null;
+    }
+    return {
+        kind: 'agent_message_completed',
+        turnId,
+        itemId: `${turnId}:plan`,
+        phase: 'commentary',
+        text,
+        outputKind: 'commentary',
+        isPlan: true,
+    };
+}
+function normalizeToolEvent(params, kind) {
+    const exec = extractRawExecCommandEvent(params);
+    if (!exec) {
+        return null;
+    }
+    return {
+        kind,
+        turnId: exec.turnId,
+        exec,
+        state: inferToolActivityState(exec),
+    };
+}
+function normalizeThreadItemToolEvent(params, kind) {
+    const turnId = extractTurnId(params);
+    const item = params?.item;
+    const itemId = extractItemId(item);
+    const itemType = normalizeEventItemType(item);
+    if (!turnId || !itemId || !itemType) {
+        return null;
+    }
+    let command = [];
+    let cwd = null;
+    let parsedCmd = [];
+    switch (itemType) {
+        case 'commandexecution':
+            command = typeof item.command === 'string' ? [item.command] : [];
+            cwd = typeof item.cwd === 'string' ? item.cwd : null;
+            parsedCmd = normalizeCommandActions(item.commandActions);
+            break;
+        case 'filechange':
+            parsedCmd = normalizeFileChanges(item.changes);
+            break;
+        case 'websearch':
+            parsedCmd = [{
+                    type: 'search',
+                    query: typeof item.query === 'string' ? item.query : '',
+                    path: null,
+                }];
+            break;
+        case 'imageview':
+            parsedCmd = [{ type: 'read', path: typeof item.path === 'string' ? item.path : null }];
+            break;
+        case 'mcptoolcall':
+            command = [`MCP ${String(item.server ?? 'server')}/${String(item.tool ?? 'tool')}`];
+            break;
+        case 'dynamictoolcall':
+            command = [`Tool ${item.namespace ? `${String(item.namespace)}/` : ''}${String(item.tool ?? 'tool')}`];
+            break;
+        case 'collabagenttoolcall':
+            command = [`Agent ${String(item.tool ?? 'operation')}`];
+            break;
+        case 'imagegeneration':
+            command = ['Image generation'];
+            break;
+        default:
+            return null;
+    }
+    const exec = {
+        callId: itemId,
+        turnId,
+        command,
+        cwd,
+        parsedCmd,
+    };
+    return {
+        kind,
+        turnId,
+        exec,
+        state: inferToolActivityState(exec),
+    };
+}
+function normalizeCommandActions(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => {
+        const type = typeof entry?.type === 'string' ? entry.type : '';
+        if (type === 'listFiles') {
+            return { ...entry, type: 'list_files' };
+        }
+        return entry;
+    });
+}
+function normalizeFileChanges(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => ({
+        type: 'apply_patch',
+        path: typeof entry?.path === 'string' ? entry.path : null,
+    }));
+}
+export function classifyAgentOutput(phase, completed) {
+    if (!phase) {
+        return completed ? 'final_answer' : 'commentary';
+    }
+    const normalized = phase.replace(/[^a-z]/gi, '').toLowerCase();
+    if (normalized === 'final' || normalized === 'finalanswer' || normalized === 'answer' || normalized === 'response') {
+        return 'final_answer';
+    }
+    return 'commentary';
+}
+export function inferToolActivityState(event) {
+    const parsedTypes = (event.parsedCmd ?? [])
+        .map((entry) => (typeof entry?.type === 'string' ? entry.type : ''))
+        .filter(Boolean);
+    if (parsedTypes.includes('search')) {
+        return 'searching';
+    }
+    if (parsedTypes.includes('read') || parsedTypes.includes('list_files')) {
+        return 'reading';
+    }
+    if (parsedTypes.some(type => ['write', 'edit', 'apply_patch', 'move', 'copy', 'delete', 'mkdir'].includes(type))) {
+        return 'editing';
+    }
+    return 'running_command';
+}
+function extractRawExecCommandEvent(params) {
+    const msg = params?.msg;
+    if (!msg || typeof msg !== 'object') {
+        return null;
+    }
+    const callId = typeof msg.call_id === 'string' ? msg.call_id : null;
+    const turnId = typeof msg.turn_id === 'string' ? msg.turn_id : null;
+    if (!callId || !turnId) {
+        return null;
+    }
+    return {
+        callId,
+        turnId,
+        command: Array.isArray(msg.command) ? msg.command.map((entry) => String(entry)) : [],
+        cwd: msg.cwd ? String(msg.cwd) : null,
+        parsedCmd: Array.isArray(msg.parsed_cmd) ? msg.parsed_cmd : [],
+    };
+}
+function extractTurnId(params) {
+    const candidates = [
+        params?.turnId,
+        params?.turn_id,
+        params?.turn?.id,
+        params?.turn?.turnId,
+        params?.item?.turnId,
+        params?.item?.turn_id,
+    ];
+    for (const candidate of candidates) {
+        if (candidate !== null && candidate !== undefined && String(candidate).trim()) {
+            return String(candidate);
+        }
+    }
+    return null;
+}
+function extractItemId(value) {
+    const candidates = [
+        value?.itemId,
+        value?.item_id,
+        value?.id,
+        value?.item?.id,
+    ];
+    for (const candidate of candidates) {
+        if (candidate !== null && candidate !== undefined && String(candidate).trim()) {
+            return String(candidate);
+        }
+    }
+    return null;
+}
+function extractAgentPhase(value) {
+    const phase = value?.phase ?? value?.item?.phase ?? null;
+    return typeof phase === 'string' && phase.trim() ? phase : null;
+}
+function extractAgentDeltaText(params) {
+    const candidates = [
+        params?.delta,
+        params?.textDelta,
+        params?.contentDelta,
+        params?.text,
+    ];
+    for (const candidate of candidates) {
+        const text = extractTextCandidate(candidate);
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+function extractCompletedAgentText(params) {
+    const itemType = normalizeEventItemType(params?.item ?? params);
+    if (!isRelayableTextItemType(itemType)) {
+        return null;
+    }
+    const item = params?.item ?? params;
+    const directText = extractTextCandidate(item?.text)
+        ?? extractTextCandidate(item?.content)
+        ?? extractTextCandidate(item?.value);
+    if (directText !== null) {
+        return directText;
+    }
+    return '';
+}
+function isRelayableTextItemType(itemType) {
+    return itemType === 'agentmessage' || itemType === 'assistantmessage' || itemType === 'plan';
+}
+function outputKindForItemType(itemType, phase, completed) {
+    if (itemType === 'plan') {
+        return 'commentary';
+    }
+    return classifyAgentOutput(phase, completed);
+}
+function formatPlanUpdateText(params) {
+    const lines = [];
+    const explanation = extractTextCandidate(params?.explanation);
+    if (explanation) {
+        lines.push(explanation);
+    }
+    const plan = Array.isArray(params?.plan) ? params.plan : [];
+    for (const entry of plan) {
+        const step = extractTextCandidate(entry?.step);
+        if (!step) {
+            continue;
+        }
+        const status = typeof entry?.status === 'string' && entry.status ? ` [${entry.status}]` : '';
+        lines.push(`- ${step}${status}`);
+    }
+    return lines.join('\n').trim() || null;
+}
+function normalizeEventItemType(value) {
+    const raw = value?.type ?? value?.itemType ?? value?.item_type ?? value?.kind;
+    if (typeof raw !== 'string') {
+        return null;
+    }
+    return raw.replace(/[^a-z]/gi, '').toLowerCase();
+}
+function extractTextCandidate(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    for (const key of ['text', 'delta', 'content', 'value']) {
+        const candidate = value[key];
+        if (typeof candidate === 'string') {
+            return candidate;
+        }
+    }
+    for (const key of ['parts', 'segments', 'content']) {
+        const candidate = value[key];
+        if (!Array.isArray(candidate)) {
+            continue;
+        }
+        const text = candidate
+            .map((entry) => extractTextCandidate(entry))
+            .filter((entry) => entry !== null)
+            .join('');
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}

package/dist/codex_app/adapter.d.ts

@@ -1,6 +1,6 @@
 import type { IEngineAdapter, EngineModel, EngineTurnRequest, EngineTurnExecution } from '../core/engine_spi.js';
 import type { CodexAppClient } from './client.js';
-import type { SandboxModeValue } from '../types.js';
+import type { SandboxModeValue, ApprovalPolicyValue } from '../types.js';
 export declare class CodexEngineAdapter implements IEngineAdapter {
     private readonly client;
     readonly id: string;
@@ -12,7 +12,7 @@ export declare class CodexEngineAdapter implements IEngineAdapter {
         id?: string;
         name?: string;
         defaultModel?: string | undefined;
-        defaultApprovalPolicy?: string;
+        defaultApprovalPolicy?: ApprovalPolicyValue;
         defaultSandboxMode?: SandboxModeValue;
     });
     listModels(): Promise<EngineModel[]>;

package/dist/codex_app/adapter.js

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'node:events';
-import { normalizeTurnActivityEvent } from '../controller/activity.js';
-import { buildAttachmentPrompt } from '../telegram/media.js';
+import { normalizeTurnActivityEvent } from './activity.js';
+import { buildAttachmentPrompt } from '../core/attachment_files.js';
+import { resolveAccessMode } from '../core/access.js';
 export class CodexEngineAdapter {
     client;
     id;
@@ -24,15 +25,8 @@ export class CodexEngineAdapter {
                 name: m.displayName || m.id,
                 description: m.description,
                 isDefault: m.isDefault || m.id === this.defaultModel,
+                supportedReasoningEfforts: m.supportedReasoningEfforts,
             }));
-            if (!list.some((m) => m.id === 'gpt-6-sol')) {
-                list.push({
-                    id: 'gpt-6-sol',
-                    name: 'GPT-6-Sol',
-                    description: 'Next-generation flagship model with deep reasoning',
-                    isDefault: false,
-                });
-            }
             return list;
         }
         catch {
@@ -41,9 +35,11 @@ export class CodexEngineAdapter {
     }
     executeTurn(request) {
         const emitter = new EventEmitter();
+        const access = resolveAccessMode({ defaultApprovalPolicy: this.defaultApprovalPolicy, defaultSandboxMode: this.defaultSandboxMode }, { accessPreset: request.accessPreset ?? 'default' });
         let threadId = request.threadId;
         let turnId = null;
         let cancelled = false;
+        const earlyNotifications = [];
         let promptText = request.prompt;
         if (request.stagedAttachments && request.stagedAttachments.length > 0 && !request.prompt.includes('Telegram attachments:')) {
             promptText = buildAttachmentPrompt(request.prompt, request.stagedAttachments);
@@ -58,6 +54,16 @@ export class CodexEngineAdapter {
             }
         };
         const onNotification = (msg) => {
+            if (cancelled || finalResult || turnError)
+                return;
+            if (threadId && msg.params?.threadId && msg.params.threadId !== threadId)
+                return;
+            if (!turnId) {
+                earlyNotifications.push(msg);
+                if (earlyNotifications.length > 1000)
+                    earlyNotifications.shift();
+                return;
+            }
             try {
                 const ev = normalizeTurnActivityEvent(msg);
                 if (!ev)
@@ -100,6 +106,7 @@ export class CodexEngineAdapter {
         };
         const cleanup = () => {
             this.client.off('notification', onNotification);
+            earlyNotifications.length = 0;
         };
         this.client.on('notification', onNotification);
         const effectiveModel = request.model && request.model !== 'default'
@@ -111,8 +118,8 @@ export class CodexEngineAdapter {
                     const session = await this.client.startThread({
                         cwd: request.cwd,
                         model: effectiveModel,
-                        approvalPolicy: this.defaultApprovalPolicy,
-                        sandboxMode: this.defaultSandboxMode,
+                        approvalPolicy: access.approvalPolicy,
+                        sandboxMode: access.sandboxMode,
                     });
                     threadId = session.thread.threadId;
                 }
@@ -121,7 +128,8 @@ export class CodexEngineAdapter {
                         await this.client.resumeThread({
                             threadId,
                             cwd: request.cwd,
-                            approvalPolicy: this.defaultApprovalPolicy,
+                            approvalPolicy: access.approvalPolicy,
+                            sandboxMode: access.sandboxMode,
                         });
                     }
                     catch {
@@ -135,6 +143,7 @@ export class CodexEngineAdapter {
                 if (!threadId) {
                     throw new Error('Failed to resolve or create Codex thread for turn');
                 }
+                emitter.emit('conversation', threadId);
                 let turn;
                 try {
                     turn = await this.client.startTurn({
@@ -145,8 +154,8 @@ export class CodexEngineAdapter {
                         effort: request.effort ?? null,
                         serviceTier: request.serviceTier ?? undefined,
                         collaborationMode: null,
-                        approvalPolicy: this.defaultApprovalPolicy,
-                        sandboxMode: this.defaultSandboxMode,
+                        approvalPolicy: access.approvalPolicy,
+                        sandboxMode: access.sandboxMode,
                     });
                 }
                 catch (turnErr) {
@@ -155,13 +164,20 @@ export class CodexEngineAdapter {
                         errMsg.includes('No thread') ||
                         errMsg.includes('stale') ||
                         errMsg.includes('invalid thread')) {
+                        if (cancelled)
+                            throw turnErr;
                         const session = await this.client.startThread({
                             cwd: request.cwd,
                             model: effectiveModel,
-                            approvalPolicy: this.defaultApprovalPolicy,
-                            sandboxMode: this.defaultSandboxMode,
+                            approvalPolicy: access.approvalPolicy,
+                            sandboxMode: access.sandboxMode,
                         });
                         threadId = session.thread.threadId;
+                        if (cancelled) {
+                            cleanup();
+                            return;
+                        }
+                        emitter.emit('conversation', threadId);
                         turn = await this.client.startTurn({
                             threadId,
                             input: [{ type: 'text', text: promptText, text_elements: [] }],
@@ -170,8 +186,8 @@ export class CodexEngineAdapter {
                             effort: request.effort ?? null,
                             serviceTier: request.serviceTier ?? undefined,
                             collaborationMode: null,
-                            approvalPolicy: this.defaultApprovalPolicy,
-                            sandboxMode: this.defaultSandboxMode,
+                            approvalPolicy: access.approvalPolicy,
+                            sandboxMode: access.sandboxMode,
                         });
                     }
                     else {
@@ -179,6 +195,8 @@ export class CodexEngineAdapter {
                     }
                 }
                 turnId = turn.id;
+                for (const notification of earlyNotifications.splice(0))
+                    onNotification(notification);
             }
             catch (err) {
                 cleanup();
@@ -187,14 +205,26 @@ export class CodexEngineAdapter {
                 resolveWaiters(null);
             }
         };
-        void run();
+        const running = run();
+        let cancelling;
         return {
-            turnId: turnId ?? undefined,
+            get turnId() { return turnId ?? undefined; },
             cancel: () => {
-                cancelled = true;
-                if (threadId && turnId) {
-                    void this.client.interruptTurn(threadId, turnId).catch(() => { });
-                }
+                if (finalResult)
+                    return Promise.resolve();
+                cancelling ??= (async () => {
+                    cancelled = true;
+                    await running;
+                    if (finalResult)
+                        return;
+                    if (threadId && turnId)
+                        await this.client.interruptTurn(threadId, turnId);
+                    cleanup();
+                    finalResult = { kind: 'result', status: 'INTERRUPTED', response: accumulatedResponse, conversationId: threadId };
+                    emitter.emit('result', finalResult);
+                    resolveWaiters(finalResult);
+                })();
+                return cancelling.catch(error => { cancelling = undefined; throw error; });
             },
             waitForResult: async () => {
                 if (finalResult)

package/dist/codex_app/backend_ui.d.ts

@@ -0,0 +1,4 @@
+import type { BackendUi, BackendUiHost } from '../core/backend_ui.js';
+import type { BridgeSessionCore } from '../controller/controller.js';
+/** Native Codex controls own their RPC subscriptions; execution remains owned by the orchestrator. */
+export declare function createCodexBackendUi(core: BridgeSessionCore, host: BackendUiHost, fallback: BackendUi): BackendUi;

package/dist/codex_app/backend_ui.js

@@ -0,0 +1,48 @@
+const nativeCallbacks = /^(thread:|auth:|settings:|setup:|nav:|approval:|ui:|mcpel:|login:|config:|voice:)/;
+const pendingCallbacks = /^(approval:|ui:|mcpel:|login:)/;
+const commands = new Set(['threads', 'open', 'auth', 'login_device', 'login_cancel', 'logout', 'permissions', 'access',
+    'skills', 'skill', 'skill_enable', 'skill_disable', 'hooks', 'plugins', 'plugin', 'plugin_skill', 'apps', 'features',
+    'config', 'requirements', 'provider', 'mcp', 'mcp_reload', 'mcp_login', 'mcp_resource', 'approve', 'deny', 'answer', 'mcpel']);
+/** Native Codex controls own their RPC subscriptions; execution remains owned by the orchestrator. */
+export function createCodexBackendUi(core, host, fallback) {
+    return {
+        ...fallback,
+        ownsCallback: data => nativeCallbacks.test(data) || data.startsWith('codex:'),
+        getPendingApprovals: () => core.getPendingApprovalCount(),
+        stop: () => core.stopControlPlane(),
+        handleCustomInbound: async (event, locale) => {
+            if (core.hasPendingInteraction(event.scopeId)) {
+                await core.dispatchBackendCommand(event);
+                return true;
+            }
+            return await fallback.handleCustomInbound?.(event, locale) ?? false;
+        },
+        handleCustomCommand: async (scopeId, command, args, locale, event) => {
+            if (!commands.has(command))
+                return await fallback.handleCustomCommand?.(scopeId, command, args, locale, event) ?? false;
+            if (['open', 'logout'].includes(command) && host.hasActiveTurn(scopeId)) {
+                await host.sendMessage(scopeId, locale === 'zh' ? '请先结束当前任务。' : 'Finish the active task first.');
+                return true;
+            }
+            const inbound = event ?? { scopeId, chatId: scopeId, topicId: null, chatType: 'private', userId: 'system',
+                messageId: 0, text: `/${command} ${args}`, attachments: [], entities: [], replyToBot: false };
+            await core.dispatchBackendCommand(inbound);
+            host.syncCurrentBackendSettings(scopeId);
+            return true;
+        },
+        handleCustomCallback: async (scopeId, data, locale, messageId, event) => {
+            if (!nativeCallbacks.test(data) || !event)
+                return await fallback.handleCustomCallback?.(scopeId, data, locale, messageId, event) ?? false;
+            if (!pendingCallbacks.test(data) && host.getBackendDescriptorForScope(scopeId).engineType !== 'codex')
+                return true;
+            if (data.startsWith('thread:') && host.hasActiveTurn(scopeId)) {
+                await host.sendMessage(scopeId, locale === 'zh' ? '请先结束当前任务。' : 'Finish the active task first.');
+                return true;
+            }
+            await core.handleCallback(event);
+            if (!pendingCallbacks.test(data))
+                host.syncCurrentBackendSettings(scopeId);
+            return true;
+        },
+    };
+}

package/dist/codex_app/client.js

@@ -284,18 +284,6 @@ export class CodexAppClient extends EventEmitter {
             models.push(...rows.map(mapModel));
             cursor = typeof result.nextCursor === 'string' ? result.nextCursor : null;
         } while (cursor);
-        if (!models.some((m) => m.id === 'gpt-6-sol' || m.model === 'gpt-6-sol')) {
-            models.push({
-                id: 'gpt-6-sol',
-                model: 'gpt-6-sol',
-                displayName: 'GPT-6-Sol',
-                description: 'Next-generation flagship model with deep reasoning',
-                isDefault: false,
-                supportedReasoningEfforts: ['low', 'medium', 'high', 'xhigh', 'max'],
-                defaultReasoningEffort: 'medium',
-                serviceTiers: [],
-            });
-        }
         return models;
     }
     async readAccount(refreshToken = false) {