@kafca/agentdock 0.1.23 → 0.1.25

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeThreadMessageInput = normalizeThreadMessageInput;
 exports.createTextMessageInput = createTextMessageInput;
+const index_js_1 = require("../../../../packages/contracts/src/index.js");
 function normalizeThreadMessageInput(input) {
     if (typeof input === 'string') {
         return {
@@ -32,7 +33,13 @@ function isSupportedContentPart(part) {
     if (!part || typeof part !== 'object') {
         return false;
     }
-    const type = String(part.type || '');
+    let type;
+    try {
+        type = (0, index_js_1.normalizeChannelContentPartType)(part.type);
+    }
+    catch {
+        return false;
+    }
     if (type === 'text') {
         return Boolean(String(part.text || ''));
     }
@@ -40,6 +47,10 @@ function isSupportedContentPart(part) {
         const image = part;
         return Boolean(String(image.data || image.uri || ''));
     }
+    if (type === 'file') {
+        const file = part;
+        return Boolean(String(file.data || file.uri || file.path || ''));
+    }
     return false;
 }
 function summarizeContentParts(parts) {
@@ -52,9 +63,19 @@ function summarizeContentParts(parts) {
     if (text) {
         return text;
     }
-    const imageCount = parts.filter((part) => part.type === 'image').length;
-    if (imageCount > 0) {
-        return imageCount === 1 ? '[Image]' : `[${imageCount} images]`;
+    const summaries = parts
+        .map((part) => {
+        if (part.type === 'image') {
+            return part.fileName ? `[Image: ${part.fileName}]` : '[Image]';
+        }
+        if (part.type === 'file') {
+            return part.fileName ? `[File: ${part.fileName}]` : '[File]';
+        }
+        return '';
+    })
+        .filter(Boolean);
+    if (summaries.length > 0) {
+        return summaries.join('\n');
     }
     return '';
 }

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-permission-lifecycle.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePermissionOptions = parsePermissionOptions;
+exports.createRunningPermissionRequest = createRunningPermissionRequest;
+exports.createPermissionApprovalInput = createPermissionApprovalInput;
+exports.createPermissionPrompt = createPermissionPrompt;
+exports.applyPendingPermissionRequest = applyPendingPermissionRequest;
+exports.isSchedulerAddCommand = isSchedulerAddCommand;
+const workspace_acp_permissions_js_1 = require("./workspace-acp-permissions.js");
+function parsePermissionOptions(options) {
+    return Array.isArray(options)
+        ? 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)
+        : [];
+}
+function createRunningPermissionRequest(input) {
+    return {
+        requestId: input.requestId,
+        toolTitle: input.toolTitle,
+        isSchedulerAdd: isSchedulerAddCommand(input.toolTitle),
+        options: input.options,
+        ...(input.approvalId ? { approvalId: input.approvalId } : {}),
+    };
+}
+function createPermissionApprovalInput(input) {
+    return {
+        threadId: input.threadId,
+        runId: input.runId,
+        title: input.toolTitle ? `Approve ${input.toolTitle}` : 'Approve agent action',
+        description: input.toolTitle || 'Agent requested permission before continuing.',
+        command: input.toolTitle,
+        options: input.options,
+    };
+}
+function createPermissionPrompt(toolTitle) {
+    return [
+        '等待工具确认',
+        '',
+        toolTitle,
+        '',
+        '请选择一个选项继续执行。',
+        '',
+        '若按钮没有显示，请直接回复：allow all / allow / deny',
+    ].join('\n');
+}
+function applyPendingPermissionRequest(input) {
+    input.session.pendingPermissionByRun.set(input.runId, input.permissionRequest);
+    const currentTurn = input.session.currentTurn;
+    if (!currentTurn) {
+        return;
+    }
+    currentTurn.permission = input.permissionRequest;
+    const toolTitle = input.permissionRequest.toolTitle;
+    if (!toolTitle || toolTitle === 'Permission required before continuing.') {
+        return;
+    }
+    currentTurn.pendingToolCallDetail = toolTitle;
+    const toolCall = input.resolveFallbackToolCall(currentTurn);
+    if (toolCall) {
+        toolCall.detail = toolTitle;
+        input.syncLegacyPendingToolCall(currentTurn, toolCall);
+    }
+}
+function isSchedulerAddCommand(value) {
+    return /\blac\s+scheduler\s+add\b/.test(String(value || ''));
+}

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

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAssistantMessageChunk = applyAssistantMessageChunk;
+exports.applyThoughtChunk = applyThoughtChunk;
+exports.registerPendingToolCall = registerPendingToolCall;
+exports.resolveToolCallForUpdate = resolveToolCallForUpdate;
+exports.resolveFallbackToolCall = resolveFallbackToolCall;
+exports.getToolCallsInOrder = getToolCallsInOrder;
+exports.deletePendingToolCall = deletePendingToolCall;
+exports.syncLegacyPendingToolCall = syncLegacyPendingToolCall;
+exports.extractToolUpdateContent = extractToolUpdateContent;
+exports.formatToolProgressMessage = formatToolProgressMessage;
+exports.resolveToolUpdateDisplayTitle = resolveToolUpdateDisplayTitle;
+exports.isEmptyRunningToolUpdate = isEmptyRunningToolUpdate;
+exports.isTerminalToolStatus = isTerminalToolStatus;
+exports.formatPlanProgress = formatPlanProgress;
+exports.extractToolCallKey = extractToolCallKey;
+exports.extractToolCallInput = extractToolCallInput;
+function applyAssistantMessageChunk(currentTurn, text) {
+    if (!text) {
+        return null;
+    }
+    currentTurn.assistantText += text;
+    if (!currentTurn.previewStarted) {
+        currentTurn.previewStarted = true;
+        return {
+            bridgeType: 'preview_start',
+            previewHandle: currentTurn.previewHandle,
+            content: currentTurn.assistantText,
+        };
+    }
+    return {
+        bridgeType: 'update_message',
+        previewHandle: currentTurn.previewHandle,
+        content: currentTurn.assistantText,
+    };
+}
+function applyThoughtChunk(currentTurn, text) {
+    if (!text) {
+        return null;
+    }
+    currentTurn.thoughtText = mergeStreamingText(currentTurn.thoughtText, text);
+    const content = `💭 ${currentTurn.thoughtText.trim()}`;
+    if (!currentTurn.thoughtPreviewStarted) {
+        currentTurn.thoughtPreviewStarted = true;
+        return {
+            bridgeType: 'preview_start',
+            previewHandle: currentTurn.thoughtPreviewHandle,
+            messageId: currentTurn.thoughtMessageId,
+            content,
+        };
+    }
+    return {
+        bridgeType: 'update_message',
+        previewHandle: currentTurn.thoughtPreviewHandle,
+        messageId: currentTurn.thoughtMessageId,
+        content,
+    };
+}
+function mergeStreamingText(current, next) {
+    if (!current) {
+        return next;
+    }
+    if (next.startsWith(current)) {
+        return next;
+    }
+    if (current.endsWith(next)) {
+        return current;
+    }
+    const maxOverlap = Math.min(current.length, next.length);
+    for (let size = maxOverlap; size > 0; size -= 1) {
+        if (current.endsWith(next.slice(0, size))) {
+            return current + next.slice(size);
+        }
+    }
+    return current + next;
+}
+function registerPendingToolCall(input) {
+    const title = String(input.update.title || 'Running tool').trim();
+    const nextSequence = (input.currentTurn.toolCallSequence || 0) + 1;
+    input.currentTurn.toolCallSequence = nextSequence;
+    const key = extractToolCallKey(input.update) || `sequence:${nextSequence}`;
+    const toolInput = extractToolCallInput(input.update);
+    const toolCall = {
+        key,
+        title,
+        messageId: `${input.runId}-tool-${nextSequence}`,
+        ...(toolInput === undefined ? {} : { input: toolInput }),
+        sequence: nextSequence,
+        emitted: false,
+    };
+    input.currentTurn.pendingToolCalls = {
+        ...(input.currentTurn.pendingToolCalls || {}),
+        [key]: toolCall,
+    };
+    input.currentTurn.pendingToolCallOrder = [
+        ...(input.currentTurn.pendingToolCallOrder || []).filter((item) => item !== key),
+        key,
+    ];
+    input.currentTurn.activeToolCallKey = key;
+    return toolCall;
+}
+function resolveToolCallForUpdate(currentTurn, update) {
+    const explicitKey = extractToolCallKey(update);
+    if (explicitKey && currentTurn.pendingToolCalls?.[explicitKey]) {
+        currentTurn.activeToolCallKey = explicitKey;
+        return currentTurn.pendingToolCalls[explicitKey];
+    }
+    return resolveFallbackToolCall(currentTurn);
+}
+function resolveFallbackToolCall(currentTurn) {
+    const active = currentTurn.activeToolCallKey
+        ? currentTurn.pendingToolCalls?.[currentTurn.activeToolCallKey]
+        : undefined;
+    if (active) {
+        return active;
+    }
+    const ordered = getToolCallsInOrder(currentTurn);
+    return ordered[ordered.length - 1];
+}
+function getToolCallsInOrder(currentTurn) {
+    const toolCalls = currentTurn.pendingToolCalls || {};
+    const orderedKeys = currentTurn.pendingToolCallOrder || [];
+    return orderedKeys
+        .map((key) => toolCalls[key])
+        .filter((toolCall) => Boolean(toolCall));
+}
+function deletePendingToolCall(currentTurn, key) {
+    if (currentTurn.pendingToolCalls) {
+        delete currentTurn.pendingToolCalls[key];
+    }
+    currentTurn.pendingToolCallOrder = (currentTurn.pendingToolCallOrder || []).filter((item) => item !== key);
+    if (currentTurn.activeToolCallKey === key) {
+        currentTurn.activeToolCallKey = undefined;
+    }
+}
+function syncLegacyPendingToolCall(currentTurn, toolCall) {
+    currentTurn.pendingToolCallTitle = toolCall?.title;
+    currentTurn.pendingToolCallId = toolCall?.messageId;
+    currentTurn.pendingToolCallDetail = toolCall?.detail;
+    currentTurn.activeToolCallKey = toolCall?.key;
+}
+function extractToolUpdateContent(content) {
+    return Array.isArray(content)
+        ? content
+            .map((entry) => entry?.type === 'content' && entry?.content?.type === 'text'
+            ? String(entry.content.text || '')
+            : '')
+            .filter(Boolean)
+            .join('\n')
+        : '';
+}
+function formatToolProgressMessage(input) {
+    const detail = [input.title, input.status, input.content].filter(Boolean).join(' - ');
+    return input.toolName ? `🔧 ${input.toolName}: ${detail || 'Tool update'}` : `🔧 ${detail || 'Tool update'}`;
+}
+function resolveToolUpdateDisplayTitle(input) {
+    const title = input.title.trim();
+    if (input.priorDetail && (isTerminalToolStatus(input.status) || /^tool update$/i.test(title))) {
+        return input.priorDetail;
+    }
+    if (isTerminalToolStatus(input.status) && /^tool update$/i.test(title)) {
+        return '';
+    }
+    return input.title;
+}
+function isEmptyRunningToolUpdate(input) {
+    return !input.content.trim() &&
+        /^running$/i.test(input.status) &&
+        (!input.title.trim() || /^tool update$/i.test(input.title));
+}
+function isTerminalToolStatus(status) {
+    return /^(completed|failed|error|cancelled|canceled)$/i.test(status.trim());
+}
+function formatPlanProgress(entries) {
+    const summary = entries
+        .map((entry) => String(entry?.content || '').trim())
+        .filter(Boolean)
+        .join(' | ');
+    return summary ? `💭 ${summary}` : '';
+}
+function 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 '';
+}
+function extractToolCallInput(update) {
+    for (const key of ['input', 'parameters', 'arguments', 'args', 'rawInput']) {
+        if (Object.prototype.hasOwnProperty.call(update, key)) {
+            return update[key];
+        }
+    }
+    return undefined;
+}

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-response-processor.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreAcpResponseProcessor = void 0;
 const cron_command_detector_js_1 = require("../scheduler/cron-command-detector.js");
+const job_id_js_1 = require("../scheduler/job-id.js");
 class LocalCoreAcpResponseProcessor {
     options;
     constructor(options) {
@@ -82,7 +83,7 @@ class LocalCoreAcpResponseProcessor {
                         scheduleDescription: command.scheduleDescription,
                         message: command.message,
                     });
-                    return `已创建定时任务：${job.description || command.name}，计划 ${command.scheduleDescription}（${command.schedule}），ID: ${job.id}`;
+                    return `已创建定时任务：${job.description || command.name}，计划 ${command.scheduleDescription}（${command.schedule}），ID: ${(0, job_id_js_1.toPublicScheduledJobId)(job.id)}`;
                 }
                 case 'list': {
                     const jobs = await this.options.scheduler.listJobsForThread(threadId);
@@ -91,7 +92,7 @@ class LocalCoreAcpResponseProcessor {
                     }
                     return [
                         '当前对话定时任务：',
-                        ...jobs.map((job) => `- ${job.description || job.id} | ${job.triggerType === 'cron' ? job.cronExpr : job.runAt} | ${job.enabled ? 'enabled' : 'disabled'} | ${job.id}`),
+                        ...jobs.map((job) => `- ${job.description || (0, job_id_js_1.toPublicScheduledJobId)(job.id)} | ${job.triggerType === 'cron' ? job.cronExpr : job.runAt} | ${job.enabled ? 'enabled' : 'disabled'} | ${(0, job_id_js_1.toPublicScheduledJobId)(job.id)}`),
                     ].join('\n');
                 }
                 case 'delete': {

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

@@ -68,6 +68,7 @@ class LocalCoreAcpSessionCoordinator {
                 const created = await this.options.transport.request(session, 'session/new', {
                     cwd: config.workDir,
                     mcpServers: [],
+                    _meta: this.buildSessionMeta(threadId),
                 }, 30000);
                 session.sessionId = String(created.sessionId || created.session_id || created.id || created.session?.sessionId || created.session?.session_id || created.session?.id || '').trim();
                 if (!session.sessionId) {
@@ -82,6 +83,16 @@ class LocalCoreAcpSessionCoordinator {
         }
         return session;
     }
+    async setThreadMode(threadId, mode) {
+        const session = this.sessions.get(threadId);
+        if (!session || session.closed || !session.sessionId) {
+            return;
+        }
+        await this.options.transport.request(session, 'session/set_mode', {
+            sessionId: session.sessionId,
+            modeId: mode,
+        }, 30000);
+    }
     async interruptRun(runId) {
         const threadId = this.options.runThreadMap.get(runId);
         if (!threadId) {
@@ -154,6 +165,10 @@ class LocalCoreAcpSessionCoordinator {
             LOCAL_AI_WORKSPACE_ID: row.workspace_id,
             LOCAL_AI_THREAD_ID: threadId,
         };
+        const workspace = this.options.store.getWorkspaceRegistryEntry(row.workspace_id);
+        if (workspace?.path) {
+            env.LOCAL_AI_WORKSPACE_PATH = workspace.path;
+        }
         if (binding) {
             env.LOCAL_AI_PLATFORM = binding.platform;
             env.LOCAL_AI_ROUTE_TYPE = 'lark_chat';
@@ -167,5 +182,19 @@ class LocalCoreAcpSessionCoordinator {
         }
         return env;
     }
+    buildSessionMeta(threadId) {
+        const row = this.options.store.getThreadRow(threadId);
+        const mode = String(row?.agent_mode || '').trim();
+        if (!mode || mode === 'default') {
+            return undefined;
+        }
+        return {
+            claudeCode: {
+                options: {
+                    permissionMode: mode,
+                },
+            },
+        };
+    }
 }
 exports.LocalCoreAcpSessionCoordinator = LocalCoreAcpSessionCoordinator;