@kafca/agentdock 0.1.23 → 0.1.25

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-turn-coordinator.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreAcpTurnCoordinator = void 0;
 const desktop_js_1 = require("../../../../shared/desktop.js");
+const local_core_acp_progress_js_1 = require("./local-core-acp-progress.js");
+const local_core_acp_permission_lifecycle_js_1 = require("./local-core-acp-permission-lifecycle.js");
 const workspace_acp_permissions_js_1 = require("./workspace-acp-permissions.js");
+const local_core_slash_commands_js_1 = require("./local-core-slash-commands.js");
 class LocalCoreAcpTurnCoordinator {
     options;
     constructor(options) {
@@ -14,7 +17,7 @@ class LocalCoreAcpTurnCoordinator {
         if (!currentTurn || !currentRunId) {
             return;
         }
-        const pending = this.getToolCallsInOrder(currentTurn)
+        const pending = (0, local_core_acp_progress_js_1.getToolCallsInOrder)(currentTurn)
             .filter((toolCall) => !toolCall.emitted);
         if (pending.length === 0) {
             const title = currentTurn.pendingToolCallTitle?.trim();
@@ -25,14 +28,26 @@ class LocalCoreAcpTurnCoordinator {
             currentTurn.pendingToolCallTitle = undefined;
             currentTurn.pendingToolCallId = undefined;
             currentTurn.pendingToolCallDetail = undefined;
-            this.emitProgress(session, currentRunId, `🔧 ${title}`, messageId);
+            this.emitProgress(session, currentRunId, `🔧 ${title}`, messageId, createToolCallPayload({
+                id: currentTurn.activeToolCallKey,
+                name: title,
+                status: 'running',
+                content: '',
+            }));
             return;
         }
         for (const toolCall of pending) {
             toolCall.emitted = true;
-            this.emitProgress(session, currentRunId, `🔧 ${toolCall.title}`, toolCall.messageId);
+            this.emitProgress(session, currentRunId, `🔧 ${toolCall.title}`, toolCall.messageId, createToolCallPayload({
+                id: toolCall.key,
+                name: toolCall.title,
+                status: 'running',
+                input: toolCall.input,
+                detail: toolCall.detail,
+                content: '',
+            }));
         }
-        this.syncLegacyPendingToolCall(currentTurn, this.resolveFallbackToolCall(currentTurn));
+        (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, (0, local_core_acp_progress_js_1.resolveFallbackToolCall)(currentTurn));
     }
     getPendingPermissionRequest(session, detail) {
         const runId = session?.currentRunId;
@@ -80,22 +95,29 @@ class LocalCoreAcpTurnCoordinator {
             });
             return;
         }
-        const options = Array.isArray(payload.params?.options)
-            ? payload.params.options
-                .map((option) => ({
-                optionId: String(option?.optionId || '').trim(),
-                name: String(option?.name || option?.optionId || '').trim(),
-                kind: String(option?.kind || '').trim(),
-                normalizedAction: (0, workspace_acp_permissions_js_1.normalizePermissionOptionAction)({
-                    optionId: option?.optionId,
-                    name: option?.name,
-                    kind: option?.kind,
-                }),
-            }))
-                .filter((option) => option.optionId)
-            : [];
+        const options = (0, local_core_acp_permission_lifecycle_js_1.parsePermissionOptions)(payload.params?.options);
         const toolTitle = (0, workspace_acp_permissions_js_1.formatToolCallContent)(payload.params?.toolCall);
-        const isSchedulerAdd = isSchedulerAddCommand(toolTitle);
+        if ((this.options.getThreadAgentMode?.(session.threadId) || local_core_slash_commands_js_1.DEFAULT_AGENT_MODE) === 'bypassPermissions') {
+            const selected = options.find((option) => option.normalizedAction === 'allow all')
+                || options.find((option) => option.normalizedAction === 'allow')
+                || options.find((option) => option.normalizedAction !== 'deny');
+            this.options.sendRaw(session, {
+                jsonrpc: '2.0',
+                id: payload.id,
+                result: {
+                    outcome: selected
+                        ? {
+                            outcome: 'selected',
+                            optionId: selected.optionId,
+                        }
+                        : {
+                            outcome: 'cancelled',
+                        },
+                },
+            });
+            return;
+        }
+        const isSchedulerAdd = (0, local_core_acp_permission_lifecycle_js_1.isSchedulerAddCommand)(toolTitle);
         if (isSchedulerAdd && session.schedulerJobCreatedByRun.get(currentRunId)) {
             this.options.sendRaw(session, {
                 jsonrpc: '2.0',
@@ -117,45 +139,27 @@ class LocalCoreAcpTurnCoordinator {
             return;
         }
         const buttonRows = (0, workspace_acp_permissions_js_1.toPermissionButtonRows)(options, desktop_js_1.normalizeDesktopBridgeButtonOption);
-        const permissionRequest = {
+        const approvalId = this.options.createApprovalRequest?.((0, local_core_acp_permission_lifecycle_js_1.createPermissionApprovalInput)({
+            threadId: session.threadId,
+            runId: currentRunId,
+            toolTitle,
+            options,
+        }));
+        const permissionRequest = (0, local_core_acp_permission_lifecycle_js_1.createRunningPermissionRequest)({
             requestId: payload.id,
             toolTitle,
-            isSchedulerAdd,
             options,
-        };
-        const approvalId = this.options.createApprovalRequest?.({
-            threadId: session.threadId,
+            approvalId,
+        });
+        (0, local_core_acp_permission_lifecycle_js_1.applyPendingPermissionRequest)({
+            session,
             runId: currentRunId,
-            title: toolTitle ? `Approve ${toolTitle}` : 'Approve agent action',
-            description: toolTitle || 'Agent requested permission before continuing.',
-            command: toolTitle,
-            options,
+            permissionRequest,
+            resolveFallbackToolCall: local_core_acp_progress_js_1.resolveFallbackToolCall,
+            syncLegacyPendingToolCall: local_core_acp_progress_js_1.syncLegacyPendingToolCall,
         });
-        if (approvalId) {
-            permissionRequest.approvalId = approvalId;
-        }
-        session.pendingPermissionByRun.set(currentRunId, permissionRequest);
-        if (session.currentTurn) {
-            session.currentTurn.permission = permissionRequest;
-            if (toolTitle && toolTitle !== 'Permission required before continuing.') {
-                session.currentTurn.pendingToolCallDetail = toolTitle;
-                const toolCall = this.resolveFallbackToolCall(session.currentTurn);
-                if (toolCall) {
-                    toolCall.detail = toolTitle;
-                    this.syncLegacyPendingToolCall(session.currentTurn, toolCall);
-                }
-            }
-        }
         this.options.updateRunStatus(currentRunId, session.threadId, 'awaiting_input');
-        const permissionPrompt = [
-            '等待工具确认',
-            '',
-            toolTitle,
-            '',
-            '请选择一个选项继续执行。',
-            '',
-            '若按钮没有显示，请直接回复：allow all / allow / deny',
-        ].join('\n');
+        const permissionPrompt = (0, local_core_acp_permission_lifecycle_js_1.createPermissionPrompt)(toolTitle);
         this.options.appendMessage(session.threadId, 'assistant', permissionPrompt, 'progress');
         this.options.emitBridge({
             type: 'buttons',
@@ -181,24 +185,16 @@ class LocalCoreAcpTurnCoordinator {
                 if (update.content?.type !== 'text') {
                     return;
                 }
-                currentTurn.assistantText += String(update.content.text || '');
-                if (!currentTurn.previewStarted) {
-                    currentTurn.previewStarted = true;
-                    this.options.emitBridge({
-                        type: 'preview_start',
-                        sessionKey: session.bridgeSessionKey,
-                        replyCtx: currentRunId,
-                        previewHandle: currentTurn.previewHandle,
-                        content: currentTurn.assistantText,
-                    });
+                const projection = (0, local_core_acp_progress_js_1.applyAssistantMessageChunk)(currentTurn, String(update.content.text || ''));
+                if (!projection) {
                     return;
                 }
                 this.options.emitBridge({
-                    type: 'update_message',
+                    type: projection.bridgeType,
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
-                    previewHandle: currentTurn.previewHandle,
-                    content: currentTurn.assistantText,
+                    previewHandle: projection.previewHandle,
+                    content: projection.content,
                 });
                 return;
             }
@@ -207,92 +203,64 @@ class LocalCoreAcpTurnCoordinator {
                 if (update.content?.type !== 'text') {
                     return;
                 }
-                const thoughtChunk = String(update.content.text || '');
-                if (!thoughtChunk) {
+                const projection = (0, local_core_acp_progress_js_1.applyThoughtChunk)(currentTurn, String(update.content.text || ''));
+                if (!projection) {
                     return;
                 }
-                currentTurn.thoughtText += thoughtChunk;
-                const content = `💭 ${currentTurn.thoughtText.trim()}`;
                 if (this.options.upsertMessage) {
-                    this.options.upsertMessage(session.threadId, currentTurn.thoughtMessageId, 'assistant', content, 'progress');
-                }
-                if (!currentTurn.thoughtPreviewStarted) {
-                    currentTurn.thoughtPreviewStarted = true;
-                    this.options.emitBridge({
-                        type: 'preview_start',
-                        sessionKey: session.bridgeSessionKey,
-                        replyCtx: currentRunId,
-                        previewHandle: currentTurn.thoughtPreviewHandle,
-                        content,
-                    });
-                    return;
+                    this.options.upsertMessage(session.threadId, projection.messageId, 'assistant', projection.content, 'progress');
                 }
                 this.options.emitBridge({
-                    type: 'update_message',
+                    type: projection.bridgeType,
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
-                    previewHandle: currentTurn.thoughtPreviewHandle,
-                    content,
+                    previewHandle: projection.previewHandle,
+                    content: projection.content,
                 });
                 return;
             }
             case 'tool_call': {
-                const title = String(update.title || 'Running tool').trim();
-                const nextSequence = (currentTurn.toolCallSequence || 0) + 1;
-                currentTurn.toolCallSequence = nextSequence;
-                const key = this.extractToolCallKey(update) || `sequence:${nextSequence}`;
-                const toolCall = {
-                    key,
-                    title,
-                    messageId: `${currentRunId}-tool-${nextSequence}`,
-                    sequence: nextSequence,
-                    emitted: false,
-                };
-                currentTurn.pendingToolCalls = {
-                    ...(currentTurn.pendingToolCalls || {}),
-                    [key]: toolCall,
-                };
-                currentTurn.pendingToolCallOrder = [
-                    ...(currentTurn.pendingToolCallOrder || []).filter((item) => item !== key),
-                    key,
-                ];
-                currentTurn.activeToolCallKey = key;
-                this.syncLegacyPendingToolCall(currentTurn, toolCall);
+                const toolCall = (0, local_core_acp_progress_js_1.registerPendingToolCall)({ currentTurn, runId: currentRunId, update });
+                (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, toolCall);
                 return;
             }
             case 'tool_call_update': {
                 const title = String(update.title || 'Tool update').trim();
                 const status = String(update.status || '').trim();
-                const content = this.extractToolUpdateContent(update.content);
-                if (isSchedulerAddCommand(title) && /Created scheduler job\b/.test(content)) {
+                const content = (0, local_core_acp_progress_js_1.extractToolUpdateContent)(update.content);
+                if ((0, local_core_acp_permission_lifecycle_js_1.isSchedulerAddCommand)(title) && /Created scheduler job\b/.test(content)) {
                     session.schedulerJobCreatedByRun.set(currentRunId, true);
                 }
-                const toolCall = this.resolveToolCallForUpdate(currentTurn, update);
+                const toolCall = (0, local_core_acp_progress_js_1.resolveToolCallForUpdate)(currentTurn, update);
+                const updateInput = (0, local_core_acp_progress_js_1.extractToolCallInput)(update);
+                if (toolCall && updateInput !== undefined) {
+                    toolCall.input = updateInput;
+                }
                 const toolName = toolCall?.title.trim() || currentTurn.pendingToolCallTitle?.trim();
                 const messageId = toolCall?.messageId || currentTurn.pendingToolCallId;
                 const priorDetail = toolCall ? toolCall.detail?.trim() : currentTurn.pendingToolCallDetail?.trim();
-                if (this.isEmptyRunningToolUpdate(title, status, content)) {
+                if ((0, local_core_acp_progress_js_1.isEmptyRunningToolUpdate)({ title, status, content })) {
                     if (toolCall) {
-                        this.deleteToolCall(currentTurn, toolCall.key);
+                        (0, local_core_acp_progress_js_1.deletePendingToolCall)(currentTurn, toolCall.key);
                     }
                     else {
                         currentTurn.pendingToolCallTitle = undefined;
                         currentTurn.pendingToolCallId = undefined;
                         currentTurn.pendingToolCallDetail = undefined;
                     }
-                    this.syncLegacyPendingToolCall(currentTurn, this.resolveFallbackToolCall(currentTurn));
+                    (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, (0, local_core_acp_progress_js_1.resolveFallbackToolCall)(currentTurn));
                     return;
                 }
-                const displayTitle = this.resolveToolUpdateDisplayTitle(title, status, priorDetail);
-                if (!this.isTerminalToolStatus(status) && displayTitle && !/^tool update$/i.test(displayTitle)) {
+                const displayTitle = (0, local_core_acp_progress_js_1.resolveToolUpdateDisplayTitle)({ title, status, priorDetail });
+                if (!(0, local_core_acp_progress_js_1.isTerminalToolStatus)(status) && displayTitle && !/^tool update$/i.test(displayTitle)) {
                     if (toolCall) {
                         toolCall.detail = displayTitle;
                     }
                     currentTurn.pendingToolCallDetail = displayTitle;
                 }
-                if (this.isTerminalToolStatus(status)) {
+                if ((0, local_core_acp_progress_js_1.isTerminalToolStatus)(status)) {
                     if (toolCall) {
-                        this.deleteToolCall(currentTurn, toolCall.key);
+                        (0, local_core_acp_progress_js_1.deletePendingToolCall)(currentTurn, toolCall.key);
                     }
                     else {
                         currentTurn.pendingToolCallTitle = undefined;
@@ -300,8 +268,16 @@ class LocalCoreAcpTurnCoordinator {
                         currentTurn.pendingToolCallDetail = undefined;
                     }
                 }
-                this.emitProgress(session, currentRunId, this.formatToolProgressMessage(toolName, displayTitle, status, content), messageId);
-                this.syncLegacyPendingToolCall(currentTurn, this.resolveFallbackToolCall(currentTurn));
+                const toolCallPayload = createToolCallPayload({
+                    id: toolCall?.key || currentTurn.activeToolCallKey,
+                    name: toolName || displayTitle || 'Tool update',
+                    status,
+                    input: updateInput === undefined ? toolCall?.input : updateInput,
+                    detail: displayTitle,
+                    content,
+                });
+                this.emitProgress(session, currentRunId, (0, local_core_acp_progress_js_1.formatToolProgressMessage)({ toolName, title: displayTitle, status, content }), messageId, toolCallPayload);
+                (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, (0, local_core_acp_progress_js_1.resolveFallbackToolCall)(currentTurn));
                 return;
             }
             case 'plan': {
@@ -310,11 +286,10 @@ class LocalCoreAcpTurnCoordinator {
                 if (entries.length === 0) {
                     return;
                 }
-                const summary = entries
-                    .map((entry) => String(entry?.content || '').trim())
-                    .filter(Boolean)
-                    .join(' | ');
-                const content = `💭 ${summary}`;
+                const content = (0, local_core_acp_progress_js_1.formatPlanProgress)(entries);
+                if (!content) {
+                    return;
+                }
                 this.options.appendMessage(session.threadId, 'assistant', content, 'progress');
                 this.options.emitBridge({
                     type: 'reply',
@@ -328,12 +303,12 @@ class LocalCoreAcpTurnCoordinator {
                 return;
         }
     }
-    emitProgress(session, currentRunId, content, messageId) {
+    emitProgress(session, currentRunId, content, messageId, toolCall) {
         if (messageId && this.options.upsertMessage) {
-            this.options.upsertMessage(session.threadId, messageId, 'assistant', content, 'progress');
+            this.options.upsertMessage(session.threadId, messageId, 'assistant', content, 'progress', toolCall);
         }
         else {
-            this.options.appendMessage(session.threadId, 'assistant', content, 'progress');
+            this.options.appendMessage(session.threadId, 'assistant', content, 'progress', toolCall);
         }
         this.options.emitBridge({
             type: 'reply',
@@ -341,93 +316,20 @@ class LocalCoreAcpTurnCoordinator {
             replyCtx: currentRunId,
             messageId,
             content,
+            toolCall,
         });
     }
-    extractToolUpdateContent(content) {
-        return Array.isArray(content)
-            ? content
-                .map((entry) => entry?.type === 'content' && entry?.content?.type === 'text'
-                ? String(entry.content.text || '')
-                : '')
-                .filter(Boolean)
-                .join('\n')
-            : '';
-    }
-    formatToolProgressMessage(toolName, title, status, content) {
-        const detail = [title, status, content].filter(Boolean).join(' - ');
-        return toolName ? `🔧 ${toolName}: ${detail || 'Tool update'}` : `🔧 ${detail || 'Tool update'}`;
-    }
-    resolveToolUpdateDisplayTitle(title, status, priorDetail) {
-        if (priorDetail && (this.isTerminalToolStatus(status) || /^tool update$/i.test(title.trim()))) {
-            return priorDetail;
-        }
-        if (this.isTerminalToolStatus(status) && /^tool update$/i.test(title.trim())) {
-            return '';
-        }
-        return title;
-    }
-    isEmptyRunningToolUpdate(title, status, content) {
-        return !content.trim() &&
-            /^running$/i.test(status) &&
-            (!title.trim() || /^tool update$/i.test(title));
-    }
-    isTerminalToolStatus(status) {
-        return /^(completed|failed|error|cancelled|canceled)$/i.test(status.trim());
-    }
-    extractToolCallKey(update) {
-        for (const key of ['toolCallId', 'tool_call_id', 'callId', 'call_id', 'invocationId', 'invocation_id', 'id']) {
-            const value = update[key];
-            if (typeof value === 'string' || typeof value === 'number') {
-                const normalized = String(value).trim();
-                if (normalized) {
-                    return normalized;
-                }
-            }
-        }
-        return '';
-    }
-    resolveToolCallForUpdate(currentTurn, update) {
-        const explicitKey = this.extractToolCallKey(update);
-        if (explicitKey && currentTurn.pendingToolCalls?.[explicitKey]) {
-            currentTurn.activeToolCallKey = explicitKey;
-            return currentTurn.pendingToolCalls[explicitKey];
-        }
-        return this.resolveFallbackToolCall(currentTurn);
-    }
-    resolveFallbackToolCall(currentTurn) {
-        const active = currentTurn.activeToolCallKey
-            ? currentTurn.pendingToolCalls?.[currentTurn.activeToolCallKey]
-            : undefined;
-        if (active) {
-            return active;
-        }
-        const ordered = this.getToolCallsInOrder(currentTurn);
-        return ordered[ordered.length - 1];
-    }
-    getToolCallsInOrder(currentTurn) {
-        const toolCalls = currentTurn.pendingToolCalls || {};
-        const orderedKeys = currentTurn.pendingToolCallOrder || [];
-        return orderedKeys
-            .map((key) => toolCalls[key])
-            .filter((toolCall) => Boolean(toolCall));
-    }
-    deleteToolCall(currentTurn, key) {
-        if (currentTurn.pendingToolCalls) {
-            delete currentTurn.pendingToolCalls[key];
-        }
-        currentTurn.pendingToolCallOrder = (currentTurn.pendingToolCallOrder || []).filter((item) => item !== key);
-        if (currentTurn.activeToolCallKey === key) {
-            currentTurn.activeToolCallKey = undefined;
-        }
-    }
-    syncLegacyPendingToolCall(currentTurn, toolCall) {
-        currentTurn.pendingToolCallTitle = toolCall?.title;
-        currentTurn.pendingToolCallId = toolCall?.messageId;
-        currentTurn.pendingToolCallDetail = toolCall?.detail;
-        currentTurn.activeToolCallKey = toolCall?.key;
-    }
 }
 exports.LocalCoreAcpTurnCoordinator = LocalCoreAcpTurnCoordinator;
-function isSchedulerAddCommand(value) {
-    return /\blac\s+scheduler\s+add\b/.test(String(value || ''));
+function createToolCallPayload(input) {
+    const status = input.status.trim() || 'running';
+    return {
+        id: input.id,
+        name: input.name.trim() || 'Tool call',
+        status,
+        input: input.input,
+        output: input.content,
+        detail: input.detail?.trim() || undefined,
+        label: /^running$/i.test(status) ? '工具调用' : '工具结果',
+    };
 }

package/dist-electron/services/local-ai-core/src/acp/local-core-slash-commands.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_AGENT_MODE = void 0;
+exports.parseSlashCommand = parseSlashCommand;
+exports.normalizeAgentMode = normalizeAgentMode;
+exports.formatAgentMode = formatAgentMode;
+exports.modeHelpText = modeHelpText;
+exports.DEFAULT_AGENT_MODE = 'default';
+const MODE_ALIASES = {
+    auto: 'auto',
+    default: 'default',
+    acceptedits: 'acceptEdits',
+    'accept-edits': 'acceptEdits',
+    accept_edits: 'acceptEdits',
+    dontask: 'dontAsk',
+    "don'task": 'dontAsk',
+    'dont-ask': 'dontAsk',
+    dont_ask: 'dontAsk',
+    plan: 'plan',
+    bypass: 'bypassPermissions',
+    bypasspermissions: 'bypassPermissions',
+    'bypass-permissions': 'bypassPermissions',
+    bypass_permissions: 'bypassPermissions',
+    yolo: 'bypassPermissions',
+};
+const MODE_LABELS = {
+    auto: 'auto',
+    default: 'default',
+    acceptEdits: 'acceptEdits',
+    dontAsk: 'dontAsk',
+    plan: 'plan',
+    bypassPermissions: 'yolo',
+};
+function parseSlashCommand(text) {
+    const normalized = String(text || '').trim();
+    if (!normalized.startsWith('/')) {
+        return null;
+    }
+    const [name = '', ...args] = normalized.slice(1).split(/\s+/);
+    const commandName = name.trim().toLowerCase();
+    if (!commandName) {
+        return null;
+    }
+    return { name: commandName, args };
+}
+function normalizeAgentMode(mode) {
+    const key = String(mode || '').trim().toLowerCase();
+    return MODE_ALIASES[key] || '';
+}
+function formatAgentMode(mode) {
+    const normalized = normalizeAgentMode(mode) || mode || exports.DEFAULT_AGENT_MODE;
+    return MODE_LABELS[normalized] || normalized;
+}
+function modeHelpText(currentMode) {
+    return [
+        `当前模式：${formatAgentMode(currentMode)}`,
+        '可用模式：default, auto, acceptEdits, dontAsk, plan, yolo。',
+        '`/mode yolo` 会跳过工具权限申请；使用 `/mode default` 可恢复默认权限。'
+    ].join('\n');
+}

package/dist-electron/services/local-ai-core/src/acp/workspace-acp-permissions.js

@@ -4,18 +4,9 @@ exports.normalizePermissionAction = normalizePermissionAction;
 exports.normalizePermissionOptionAction = normalizePermissionOptionAction;
 exports.formatToolCallContent = formatToolCallContent;
 exports.toPermissionButtonRows = toPermissionButtonRows;
+const desktop_js_1 = require("../../../../shared/desktop.js");
 function normalizePermissionAction(kind) {
-    const normalized = String(kind || '').trim().toLowerCase();
-    if (isAllowAllPermissionToken(normalized)) {
-        return 'allow all';
-    }
-    if (isAllowPermissionToken(normalized)) {
-        return 'allow';
-    }
-    if (isDenyPermissionToken(normalized)) {
-        return 'deny';
-    }
-    return '';
+    return (0, desktop_js_1.normalizePermissionResponse)(kind) || '';
 }
 function normalizePermissionOptionAction(option) {
     const fields = [
@@ -23,51 +14,17 @@ function normalizePermissionOptionAction(option) {
         option?.name,
         option?.optionId,
     ].map((value) => String(value || '').trim().toLowerCase()).filter(Boolean);
-    if (fields.some(isDenyPermissionToken)) {
+    if (fields.some((field) => normalizePermissionAction(field) === 'deny')) {
         return 'deny';
     }
-    if (fields.some(isAllowAllPermissionToken)) {
+    if (fields.some((field) => normalizePermissionAction(field) === 'allow all')) {
         return 'allow all';
     }
-    if (fields.some(isAllowPermissionToken)) {
+    if (fields.some((field) => normalizePermissionAction(field) === 'allow')) {
         return 'allow';
     }
     return '';
 }
-function isAllowAllPermissionToken(normalized) {
-    if (normalized === 'allow_always' ||
-        normalized === 'allow_all' ||
-        normalized === 'allowall' ||
-        normalized === 'always' ||
-        normalized === 'always_allow' ||
-        normalized === 'alwaysallow' ||
-        normalized.includes('allow_all') ||
-        normalized.includes('allow-always') ||
-        normalized.includes('allow_always') ||
-        normalized.includes('allow always') ||
-        normalized.includes('always allow') ||
-        normalized.includes('allow all') ||
-        normalized.includes('始终允许') ||
-        normalized.includes('永久允许')) {
-        return true;
-    }
-    return false;
-}
-function isAllowPermissionToken(normalized) {
-    if (normalized.startsWith('allow')) {
-        return true;
-    }
-    return false;
-}
-function isDenyPermissionToken(normalized) {
-    if (normalized.startsWith('reject')) {
-        return true;
-    }
-    if (normalized.startsWith('deny')) {
-        return true;
-    }
-    return false;
-}
 function formatToolCallContent(toolCall) {
     if (!toolCall || typeof toolCall !== 'object') {
         return 'Permission required before continuing.';