@kafca/agentdock 0.1.7

package/dist-electron/shared/desktop.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEDULER_PROTOCOL_INSTRUCTION = exports.LOCALCORE_ACP_AGENT_TYPE = exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES = exports.DESKTOP_PROVIDER_THINKING_OPTIONS = exports.DESKTOP_PROVIDER_PRESET_OPTIONS = exports.DESKTOP_PLATFORM_TYPE_OPTIONS = exports.DESKTOP_AGENT_TYPE_OPTIONS = exports.DESKTOP_LARK_SDK_PACKAGE = exports.DESKTOP_CLAUDECODE_ACP_PACKAGE = exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL = exports.DEFAULT_DESKTOP_OPENCODE_MODEL = exports.DEFAULT_DESKTOP_AGENT_TYPE = void 0;
+exports.deriveDesktopRuntimePhase = deriveDesktopRuntimePhase;
+exports.deriveDesktopRuntimeRoles = deriveDesktopRuntimeRoles;
+exports.normalizeDesktopPlatformType = normalizeDesktopPlatformType;
+exports.wrapUserMessageWithSchedulerProtocol = wrapUserMessageWithSchedulerProtocol;
+exports.getDefaultDesktopAgentModel = getDefaultDesktopAgentModel;
+exports.normalizeDesktopAgentModel = normalizeDesktopAgentModel;
+exports.normalizePermissionResponse = normalizePermissionResponse;
+exports.isPermissionButtonOption = isPermissionButtonOption;
+exports.normalizeDesktopBridgeButtonOption = normalizeDesktopBridgeButtonOption;
+exports.supportsInteractivePermission = supportsInteractivePermission;
+exports.isAcpAgentType = isAcpAgentType;
+exports.DEFAULT_DESKTOP_AGENT_TYPE = 'opencode';
+exports.DEFAULT_DESKTOP_OPENCODE_MODEL = 'opencode/minimax-m2.5-free';
+exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL = '';
+exports.DESKTOP_CLAUDECODE_ACP_PACKAGE = '@agentclientprotocol/claude-agent-acp';
+exports.DESKTOP_LARK_SDK_PACKAGE = '@larksuiteoapi/node-sdk';
+exports.DESKTOP_AGENT_TYPE_OPTIONS = [
+    'opencode',
+    'codex',
+    'claudecode',
+    'cursor',
+    'gemini',
+    'qoder',
+    'iflow',
+    'localcore-acp',
+];
+exports.DESKTOP_PLATFORM_TYPE_OPTIONS = [
+    'telegram',
+    'feishu',
+    'lark',
+    'discord',
+    'slack',
+    'dingtalk',
+    'wecom',
+    'weixin',
+    'qq',
+    'qqbot',
+    'line',
+];
+exports.DESKTOP_PROVIDER_PRESET_OPTIONS = [
+    'openai',
+    'openrouter',
+    'anthropic',
+    'minimax',
+    'zhipuai',
+    'deepseek',
+    'siliconflow',
+    'moonshot',
+    'ollama',
+];
+exports.DESKTOP_PROVIDER_THINKING_OPTIONS = ['', 'enabled', 'disabled'];
+exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES = ['opencode', 'claudecode', 'acp', 'localcore-acp'];
+exports.LOCALCORE_ACP_AGENT_TYPE = 'localcore-acp';
+exports.SCHEDULER_PROTOCOL_INSTRUCTION = [
+    '[Scheduler Tools]',
+    'If the user asks to create, view, edit, delete, or manually run a scheduled task for this conversation, use the Bash tool to run the local scheduler CLI.',
+    'Use these commands:',
+    'lac scheduler add --cron "<5-field cron>" --message "<exact message to send>" --desc "<short label>" [--execution-mode same-thread|side-thread]',
+    'lac scheduler list',
+    'lac scheduler list --thread',
+    'lac scheduler info <job-id>',
+    'lac scheduler edit <job-id> [--cron "<5-field cron>"] [--message "<exact message>"] [--desc "<short label>"] [--enabled true|false] [--execution-mode same-thread|side-thread]',
+    'lac scheduler del <job-id>',
+    'lac scheduler run <job-id>',
+    'Environment variables LOCAL_AI_WORKSPACE_ID, LOCAL_AI_THREAD_ID, LOCAL_AI_PLATFORM, LOCAL_AI_CHAT_ID, and LOCAL_AI_PLATFORM_USER_ID are already set when available.',
+    'Prefer relying on those variables instead of inventing your own route or creating session-only cron jobs.',
+    'By default, `lac scheduler list` shows all scheduled tasks in the current workspace. Use `lac scheduler list --thread` to show only the current conversation thread.',
+    'Use `--execution-mode same-thread` to reuse the current thread, or `--execution-mode side-thread` to run in a dedicated scheduled thread.',
+    'Only use the scheduler CLI when the user explicitly asks for scheduled automation.',
+    '[/Scheduler Tools]',
+].join('\n');
+const PERMISSION_RESPONSE_MAP = {
+    allow: 'allow',
+    deny: 'deny',
+    'allow all': 'allow all',
+    allowall: 'allow all',
+    'perm:allow': 'allow',
+    'perm:deny': 'deny',
+    'perm:allow_all': 'allow all',
+};
+function deriveDesktopRuntimePhase(service) {
+    if (service.status === 'starting') {
+        return 'starting';
+    }
+    return 'api_ready';
+}
+function deriveDesktopRuntimeRoles(service) {
+    return {
+        conversation: {
+            status: 'running',
+            label: 'Local AI Core',
+        },
+        platformGateway: {
+            status: service.status,
+            label: 'Native Platform Gateway',
+            service,
+        },
+    };
+}
+function normalizeDesktopPlatformType(platformType) {
+    const normalized = String(platformType || '').trim().toLowerCase();
+    if (normalized === 'feishu') {
+        return 'lark';
+    }
+    return normalized;
+}
+function wrapUserMessageWithSchedulerProtocol(content, extraBlocks = []) {
+    return [
+        exports.SCHEDULER_PROTOCOL_INSTRUCTION,
+        ...extraBlocks.flatMap((block) => (block ? ['', block] : [])),
+        '',
+        '[User Message]',
+        content,
+        '[/User Message]',
+    ].join('\n');
+}
+function getDefaultDesktopAgentModel(agentType) {
+    switch (String(agentType || '').trim().toLowerCase()) {
+        case 'opencode':
+            return exports.DEFAULT_DESKTOP_OPENCODE_MODEL;
+        case 'claudecode':
+            return exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL;
+        default:
+            return '';
+    }
+}
+function normalizeDesktopAgentModel(agentType, model) {
+    const normalizedType = String(agentType || '').trim().toLowerCase();
+    const normalizedModel = String(model || '').trim();
+    if (!normalizedType) {
+        return normalizedModel;
+    }
+    if (normalizedType === 'opencode') {
+        return normalizedModel || exports.DEFAULT_DESKTOP_OPENCODE_MODEL;
+    }
+    if (normalizedType === 'claudecode' && normalizedModel.startsWith('opencode/')) {
+        return '';
+    }
+    return normalizedModel;
+}
+function normalizePermissionResponse(input) {
+    if (!input) {
+        return null;
+    }
+    return PERMISSION_RESPONSE_MAP[String(input).trim().toLowerCase()] || null;
+}
+function isPermissionButtonOption(option) {
+    return Boolean(normalizePermissionResponse(option?.data));
+}
+function normalizeDesktopBridgeButtonOption(input) {
+    if (!input || typeof input !== 'object') {
+        return null;
+    }
+    const record = input;
+    const rawText = typeof record.text === 'string'
+        ? record.text
+        : typeof record.Text === 'string'
+            ? record.Text
+            : '';
+    const rawData = typeof record.data === 'string'
+        ? record.data
+        : typeof record.Data === 'string'
+            ? record.Data
+            : '';
+    if (!rawText || !rawData) {
+        return null;
+    }
+    const permissionResponse = normalizePermissionResponse(rawData);
+    if (permissionResponse) {
+        return {
+            text: permissionResponse,
+            data: permissionResponse,
+        };
+    }
+    return {
+        text: rawText,
+        data: rawData,
+    };
+}
+function supportsInteractivePermission(agentType) {
+    if (!agentType) {
+        return false;
+    }
+    return exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES.includes(String(agentType).trim().toLowerCase());
+}
+function isAcpAgentType(agentType) {
+    const normalized = String(agentType || '').trim().toLowerCase();
+    return normalized === 'acp'
+        || normalized === 'opencode'
+        || normalized === 'claudecode'
+        || normalized === exports.LOCALCORE_ACP_AGENT_TYPE;
+}

package/dist-electron/src/api/client.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = exports.ApiError = void 0;
+const DEFAULT_API_BASE = '/api/v1';
+class ApiClient {
+    token = '';
+    baseUrl = DEFAULT_API_BASE;
+    setToken(token) {
+        this.token = token;
+    }
+    setBaseUrl(baseUrl) {
+        const trimmed = baseUrl.trim();
+        if (!trimmed) {
+            this.baseUrl = DEFAULT_API_BASE;
+            return;
+        }
+        this.baseUrl = trimmed.endsWith('/api/v1')
+            ? trimmed
+            : `${trimmed.replace(/\/+$/, '')}/api/v1`;
+    }
+    getToken() {
+        return this.token;
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    headers() {
+        const h = { 'Content-Type': 'application/json' };
+        if (this.token)
+            h['Authorization'] = `Bearer ${this.token}`;
+        return h;
+    }
+    async request(method, path, body, params) {
+        let url = this.resolveUrl(path);
+        if (params) {
+            const qs = new URLSearchParams(params).toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        const res = await fetch(url, {
+            method,
+            headers: this.headers(),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const json = await res.json();
+        if (!json.ok) {
+            throw new ApiError(json.error || 'Unknown error', res.status);
+        }
+        return json.data;
+    }
+    get(path, params) { return this.request('GET', path, undefined, params); }
+    post(path, body) { return this.request('POST', path, body); }
+    patch(path, body) { return this.request('PATCH', path, body); }
+    delete(path) { return this.request('DELETE', path); }
+    resolveUrl(path) {
+        const normalizedPath = path.replace(/^\/+/, '');
+        if (this.baseUrl.startsWith('http://') || this.baseUrl.startsWith('https://')) {
+            return new URL(normalizedPath, `${this.baseUrl}/`).toString();
+        }
+        return `${this.baseUrl}/${normalizedPath}`.replace(/([^:]\/)\/+/g, '$1');
+    }
+}
+class ApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}
+exports.ApiError = ApiError;
+exports.api = new ApiClient();
+exports.default = exports.api;

package/dist-electron/src/api/sessions.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessage = exports.switchSession = exports.deleteSession = exports.renameSession = exports.createSession = exports.getSession = exports.listSessions = void 0;
+const client_1 = __importDefault(require("./client"));
+const listSessions = (project) => client_1.default.get(`/projects/${project}/sessions`);
+exports.listSessions = listSessions;
+const getSession = (project, id, historyLimit) => client_1.default.get(`/projects/${project}/sessions/${id}`, historyLimit ? { history_limit: String(historyLimit) } : undefined);
+exports.getSession = getSession;
+const createSession = (project, body) => client_1.default.post(`/projects/${project}/sessions`, body);
+exports.createSession = createSession;
+const renameSession = (project, id, body) => client_1.default.patch(`/projects/${project}/sessions/${id}`, body);
+exports.renameSession = renameSession;
+const deleteSession = (project, id) => client_1.default.delete(`/projects/${project}/sessions/${id}`);
+exports.deleteSession = deleteSession;
+const switchSession = (project, body) => client_1.default.post(`/projects/${project}/sessions/switch`, body);
+exports.switchSession = switchSession;
+const sendMessage = (project, body) => client_1.default.post(`/projects/${project}/send`, body);
+exports.sendMessage = sendMessage;

package/dist-electron/src/lib/session-utils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionLabel = sessionLabel;
+exports.sessionMatchesSearch = sessionMatchesSearch;
+exports.sortSessionsByLiveAndUpdated = sortSessionsByLiveAndUpdated;
+exports.timeAgo = timeAgo;
+function sessionLabel(session) {
+    return session.name || session.user_name || session.chat_name || `Session ${session.id.slice(0, 8)}`;
+}
+function sessionMatchesSearch(session, query) {
+    if (!query) {
+        return true;
+    }
+    const haystack = [
+        sessionLabel(session),
+        session.session_key,
+        session.last_message?.content || '',
+        session.user_name || '',
+        session.chat_name || '',
+    ]
+        .join(' ')
+        .toLowerCase();
+    return haystack.includes(query);
+}
+function sortSessionsByLiveAndUpdated(items) {
+    return [...items].sort((a, b) => {
+        if (a.live !== b.live) {
+            return a.live ? -1 : 1;
+        }
+        return (b.updated_at || b.created_at || '').localeCompare(a.updated_at || a.created_at || '');
+    });
+}
+function timeAgo(iso, justNowLabel = 'just now') {
+    if (!iso) {
+        return '';
+    }
+    const diff = Date.now() - new Date(iso).getTime();
+    const mins = Math.floor(diff / 60000);
+    if (mins < 1) {
+        return justNowLabel;
+    }
+    if (mins < 60) {
+        return `${mins}m`;
+    }
+    const hours = Math.floor(mins / 60);
+    if (hours < 24) {
+        return `${hours}h`;
+    }
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}

package/dist-electron/src/pages/Threads/thread-chat-model.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertSessionGroup = exports.ASSISTANT_REPLY_TIMEOUT_MS = void 0;
+exports.isInternalProgressMessage = isInternalProgressMessage;
+exports.isAwaitingInputMessage = isAwaitingInputMessage;
+exports.extractVisibleMessageContent = extractVisibleMessageContent;
+exports.sessionMatchesDesktop = sessionMatchesDesktop;
+exports.toMessages = toMessages;
+exports.toMessagesFromThread = toMessagesFromThread;
+exports.toChatThreadSummary = toChatThreadSummary;
+exports.toCoreChatThreadSummary = toCoreChatThreadSummary;
+exports.sortChatThreadsByLiveAndUpdated = sortChatThreadsByLiveAndUpdated;
+exports.chatThreadMatchesSearch = chatThreadMatchesSearch;
+exports.sortChatMessages = sortChatMessages;
+exports.formatMessageTimestamp = formatMessageTimestamp;
+exports.formatRuntimePhase = formatRuntimePhase;
+exports.sessionProjectFromKey = sessionProjectFromKey;
+exports.normalizeBridgeActionRows = normalizeBridgeActionRows;
+exports.upsertThreadGroup = upsertThreadGroup;
+exports.upsertThreadInGroup = upsertThreadInGroup;
+exports.isPermissionActionRow = isPermissionActionRow;
+exports.formatTaskHint = formatTaskHint;
+exports.isTaskRunningState = isTaskRunningState;
+exports.isTaskInputLocked = isTaskInputLocked;
+exports.canStreamingPromoteTaskState = canStreamingPromoteTaskState;
+const desktop_1 = require("../../../shared/desktop");
+const session_utils_1 = require("@/lib/session-utils");
+exports.ASSISTANT_REPLY_TIMEOUT_MS = 90000;
+function isInternalProgressMessage(content) {
+    if (!content) {
+        return false;
+    }
+    return (content.startsWith('💭 ') ||
+        content.startsWith('🔧 ') ||
+        content.startsWith('📤 ') ||
+        content.startsWith('⏳ '));
+}
+function isAwaitingInputMessage(content) {
+    if (!content) {
+        return false;
+    }
+    const normalized = content.replace(/\s+/g, ' ').trim();
+    return (/^Agent 提问(?:\s*\(\d+\/\d+\))?/i.test(normalized) ||
+        normalized.includes('请回复选项编号') ||
+        normalized.includes('直接输入你的回答') ||
+        normalized.includes('等待你的回复') ||
+        normalized.includes('请直接回复') ||
+        normalized.includes('请输入你的回答'));
+}
+function extractVisibleMessageContent(content) {
+    if (!content) {
+        return '';
+    }
+    const match = content.match(/\[User Message\]\s*([\s\S]*?)\s*\[\/User Message\]/);
+    if (!match) {
+        return content;
+    }
+    return match[1] || '';
+}
+function sessionMatchesDesktop(session) {
+    return session.platform === 'desktop' || session.session_key.startsWith('desktop:');
+}
+function toMessages(history) {
+    return history.map((message, index) => ({
+        id: `${index}-${message.timestamp || message.role}`,
+        role: message.role === 'user' ? 'user' : 'assistant',
+        content: message.role === 'user' ? extractVisibleMessageContent(message.content) : message.content,
+        kind: message.kind === 'progress' ? 'progress' : 'final',
+        order: index,
+        timestamp: message.timestamp,
+    }));
+}
+function toMessagesFromThread(history) {
+    return history.map((message, index) => ({
+        id: message.id || `${index}-${message.timestamp || message.role}`,
+        role: message.role === 'user' ? 'user' : 'assistant',
+        content: message.role === 'user' ? extractVisibleMessageContent(message.content) : message.content,
+        kind: message.kind === 'progress'
+            ? 'progress'
+            : message.kind === 'system'
+                ? 'progress'
+                : 'final',
+        order: index,
+        timestamp: message.timestamp,
+    }));
+}
+function toChatThreadSummary(project, session) {
+    return {
+        id: session.id,
+        project,
+        name: (0, session_utils_1.sessionLabel)(session),
+        live: session.live,
+        createdAt: session.created_at,
+        updatedAt: session.updated_at,
+        excerpt: extractVisibleMessageContent(session.last_message?.content || ''),
+        agentType: session.agent_type,
+        bridgeSessionKey: session.session_key,
+    };
+}
+function toCoreChatThreadSummary(thread) {
+    return {
+        id: thread.id,
+        project: thread.workspaceId,
+        name: thread.title,
+        live: thread.live,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+        excerpt: extractVisibleMessageContent(thread.excerpt),
+        agentType: thread.agentType,
+        bridgeSessionKey: thread.bridgeSessionKey,
+    };
+}
+function sortChatThreadsByLiveAndUpdated(items) {
+    return [...items].sort((a, b) => {
+        if (a.live !== b.live) {
+            return a.live ? -1 : 1;
+        }
+        return (b.updatedAt || b.createdAt || '').localeCompare(a.updatedAt || a.createdAt || '');
+    });
+}
+function chatThreadMatchesSearch(thread, query) {
+    if (!query) {
+        return true;
+    }
+    const haystack = [thread.name, thread.excerpt, thread.bridgeSessionKey || ''].join(' ').toLowerCase();
+    return haystack.includes(query);
+}
+function sortChatMessages(messages) {
+    return [...messages].sort((a, b) => {
+        const aTime = a.timestamp ? new Date(a.timestamp).getTime() : Number.NaN;
+        const bTime = b.timestamp ? new Date(b.timestamp).getTime() : Number.NaN;
+        const aHasTime = Number.isFinite(aTime);
+        const bHasTime = Number.isFinite(bTime);
+        if (aHasTime && bHasTime && aTime !== bTime) {
+            return aTime - bTime;
+        }
+        if (a.order !== b.order) {
+            return a.order - b.order;
+        }
+        return a.id.localeCompare(b.id);
+    });
+}
+function formatMessageTimestamp(timestamp) {
+    if (!timestamp) {
+        return '';
+    }
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) {
+        return '';
+    }
+    return new Intl.DateTimeFormat(undefined, {
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    }).format(date);
+}
+function formatRuntimePhase(phase) {
+    switch (phase) {
+        case 'starting':
+            return '启动中';
+        case 'api_ready':
+            return '服务就绪';
+        case 'error':
+            return '运行异常';
+        default:
+            return '未启动';
+    }
+}
+function sessionProjectFromKey(sessionKey) {
+    if (!sessionKey?.startsWith('desktop:')) {
+        return '';
+    }
+    const [, project = ''] = sessionKey.split(':');
+    return project;
+}
+function normalizeBridgeActionRows(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return input
+        .map((row) => {
+        if (!Array.isArray(row)) {
+            return [];
+        }
+        return row
+            .map((button) => (0, desktop_1.normalizeDesktopBridgeButtonOption)(button))
+            .filter((button) => Boolean(button));
+    })
+        .filter((row) => row.length > 0);
+}
+function upsertThreadGroup(groups, project, sessions) {
+    const next = groups.filter((group) => group.project !== project);
+    next.push({ project, sessions });
+    return next.sort((a, b) => a.project.localeCompare(b.project));
+}
+exports.upsertSessionGroup = upsertThreadGroup;
+function upsertThreadInGroup(groups, project, thread) {
+    const current = groups.find((group) => group.project === project)?.sessions || [];
+    const nextSessions = sortChatThreadsByLiveAndUpdated([
+        thread,
+        ...current.filter((item) => item.id !== thread.id),
+    ]);
+    return upsertThreadGroup(groups, project, nextSessions);
+}
+function isPermissionActionRow(rows) {
+    return rows.some((row) => row.some((action) => (0, desktop_1.isPermissionButtonOption)(action)));
+}
+function formatTaskHint(taskState, typing) {
+    if (taskState === 'stopping') {
+        return 'Stopping current task…';
+    }
+    if (taskState === 'error') {
+        return '';
+    }
+    if (taskState === 'awaiting_input') {
+        return 'Agent is waiting for your reply.';
+    }
+    if (taskState === 'permission_submitted') {
+        return 'Permission sent. Waiting for the agent to continue…';
+    }
+    if (taskState === 'awaiting_permission') {
+        return 'Waiting for your permission response.';
+    }
+    if (typing) {
+        return 'Agent is typing…';
+    }
+    if (taskState === 'running') {
+        return 'Task is running…';
+    }
+    return '';
+}
+function isTaskRunningState(taskState) {
+    return (taskState === 'running' ||
+        taskState === 'awaiting_permission' ||
+        taskState === 'permission_submitted' ||
+        taskState === 'stopping');
+}
+function isTaskInputLocked(taskState) {
+    return taskState !== 'idle' && taskState !== 'awaiting_input' && taskState !== 'error';
+}
+function canStreamingPromoteTaskState(taskState) {
+    return taskState !== 'awaiting_input' &&
+        taskState !== 'awaiting_permission' &&
+        taskState !== 'permission_submitted' &&
+        taskState !== 'stopping';
+}

package/dist-electron/src/pages/Threads/thread-chat-model.test.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const thread_chat_model_1 = require("./thread-chat-model");
+function createPermissionActions() {
+    return [[
+            { text: 'Allow', data: 'allow' },
+            { text: 'Deny', data: 'deny' },
+        ]];
+}
+function createMessage(overrides) {
+    return {
+        id: 'message',
+        role: 'assistant',
+        content: 'Permission required',
+        order: 0,
+        ...overrides,
+    };
+}
+(0, node_test_1.default)('getLatestInteractivePermissionMessage returns the latest actionable permission prompt', () => {
+    const messages = [
+        createMessage({
+            id: 'older-permission',
+            order: 1,
+            actionMode: 'permission',
+            actionInteractive: true,
+            actions: createPermissionActions(),
+        }),
+        createMessage({
+            id: 'generic-buttons',
+            order: 2,
+            actionMode: 'generic',
+            actionInteractive: true,
+            actions: createPermissionActions(),
+        }),
+        createMessage({
+            id: 'latest-permission',
+            order: 3,
+            actionMode: 'permission',
+            actionInteractive: true,
+            actions: createPermissionActions(),
+        }),
+    ];
+    const prompt = (0, thread_chat_model_1.getLatestInteractivePermissionMessage)(messages);
+    strict_1.default.ok(prompt);
+    strict_1.default.equal(prompt.id, 'latest-permission');
+});
+(0, node_test_1.default)('getLatestInteractivePermissionMessage ignores submitted or non-interactive prompts', () => {
+    const messages = [
+        createMessage({
+            id: 'submitted-permission',
+            order: 1,
+            actionMode: 'permission',
+            actionInteractive: true,
+            actions: [],
+            actionStatus: 'Permission sent',
+        }),
+        createMessage({
+            id: 'unsupported-permission',
+            order: 2,
+            actionMode: 'permission',
+            actionInteractive: false,
+            actions: createPermissionActions(),
+        }),
+    ];
+    strict_1.default.equal((0, thread_chat_model_1.getLatestInteractivePermissionMessage)(messages), undefined);
+});
+(0, node_test_1.default)('taskStateAfterTypingStop keeps awaiting_permission prompts visible', () => {
+    strict_1.default.equal((0, thread_chat_model_1.taskStateAfterTypingStop)('awaiting_permission'), 'awaiting_permission');
+    strict_1.default.equal((0, thread_chat_model_1.taskStateAfterTypingStop)('running'), 'idle');
+    strict_1.default.equal((0, thread_chat_model_1.taskStateAfterTypingStop)('permission_submitted'), 'idle');
+});

package/dist-electron/src/pages/Threads/thread-chat-permission.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPendingPermissionRequest = toPendingPermissionRequest;
+function toPendingPermissionRequest(message) {
+    if (!message.id ||
+        message.role !== 'assistant' ||
+        message.actionMode !== 'permission' ||
+        !message.actionInteractive ||
+        !message.content) {
+        return null;
+    }
+    const actions = message.actions?.filter((row) => row.length > 0) || [];
+    if (actions.length === 0) {
+        return null;
+    }
+    return {
+        id: message.id,
+        content: message.content,
+        actions,
+        actionReplyCtx: message.actionReplyCtx,
+        actionPending: message.actionPending,
+        actionStatus: message.actionStatus,
+        actionMode: 'permission',
+        actionInteractive: true,
+    };
+}