@kafca/agentdock 0.1.24 → 0.1.25

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-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;

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

@@ -31,7 +31,8 @@ class LocalCoreAcpStore {
         history_count INTEGER NOT NULL DEFAULT 0,
         excerpt TEXT NOT NULL DEFAULT '',
         acp_session_id TEXT,
-        acp_supports_load INTEGER NOT NULL DEFAULT 0
+        acp_supports_load INTEGER NOT NULL DEFAULT 0,
+        agent_mode TEXT NOT NULL DEFAULT 'default'
       );
       CREATE INDEX IF NOT EXISTS idx_threads_workspace_updated ON threads (workspace_id, updated_at DESC);
       CREATE TABLE IF NOT EXISTS messages (
@@ -39,6 +40,7 @@ class LocalCoreAcpStore {
         thread_id TEXT NOT NULL,
         role TEXT NOT NULL,
         content TEXT NOT NULL,
+        tool_call_json TEXT,
         timestamp TEXT NOT NULL,
         kind TEXT NOT NULL,
         seq INTEGER NOT NULL,
@@ -219,14 +221,16 @@ class LocalCoreAcpStore {
       CREATE INDEX IF NOT EXISTS idx_audit_events_task_created ON audit_events (task_id, created_at DESC);
       CREATE INDEX IF NOT EXISTS idx_audit_events_type_created ON audit_events (type, created_at DESC);
     `);
+        this.ensureColumn('messages', 'tool_call_json', 'TEXT');
         this.ensureColumn('scheduled_jobs', 'execution_mode', "TEXT NOT NULL DEFAULT 'same-thread'");
+        this.ensureColumn('threads', 'agent_mode', "TEXT NOT NULL DEFAULT 'default'");
     }
     close() {
         this.db.close();
     }
     listThreadSummaries(workspaceId) {
         const rows = this.db.prepare(`
-      SELECT id, workspace_id, session_id, bridge_session_key, title, agent_type, created_at, updated_at, history_count, excerpt
+      SELECT id, workspace_id, session_id, bridge_session_key, title, agent_type, created_at, updated_at, history_count, excerpt, acp_session_id, acp_supports_load, agent_mode
       FROM threads
       WHERE workspace_id = ?
       ORDER BY updated_at DESC
@@ -249,15 +253,15 @@ class LocalCoreAcpStore {
         const row = this.db.prepare('SELECT COUNT(*) AS total FROM threads WHERE workspace_id = ?').get(workspaceId);
         return Number(row?.total || 0);
     }
-    createThread(workspaceId, title, agentType = desktop_js_1.LOCALCORE_ACP_AGENT_TYPE) {
+    createThread(workspaceId, title, agentType = desktop_js_1.LOCALCORE_ACP_AGENT_TYPE, agentMode = 'default') {
         const sessionId = (0, node_crypto_1.randomUUID)();
         const threadId = (0, workspace_thread_id_js_1.encodeThreadId)(workspaceId, sessionId);
         const now = new Date().toISOString();
         const bridgeSessionKey = `${desktop_js_1.LOCALCORE_ACP_AGENT_TYPE}:${workspaceId}:${sessionId}`;
         this.db.prepare(`
-      INSERT INTO threads (id, workspace_id, session_id, bridge_session_key, title, agent_type, created_at, updated_at, history_count, excerpt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, '')
-    `).run(threadId, workspaceId, sessionId, bridgeSessionKey, title, agentType, now, now);
+      INSERT INTO threads (id, workspace_id, session_id, bridge_session_key, title, agent_type, created_at, updated_at, history_count, excerpt, agent_mode)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, '', ?)
+    `).run(threadId, workspaceId, sessionId, bridgeSessionKey, title, agentType, now, now, agentMode || 'default');
         return {
             id: threadId,
             workspaceId,
@@ -280,7 +284,7 @@ class LocalCoreAcpStore {
             throw new Error(`Thread not found: ${threadId}`);
         }
         const messages = this.db.prepare(`
-      SELECT id, thread_id, role, content, timestamp, kind, seq
+      SELECT id, thread_id, role, content, tool_call_json, timestamp, kind, seq
       FROM messages
       WHERE thread_id = ?
       ORDER BY seq ASC
@@ -300,6 +304,7 @@ class LocalCoreAcpStore {
                 id: message.id,
                 role: message.role,
                 content: message.content,
+                toolCall: parseJson(message.tool_call_json || 'null', null) || undefined,
                 timestamp: message.timestamp,
                 kind: message.kind,
             })),
@@ -314,7 +319,7 @@ class LocalCoreAcpStore {
     deleteThread(threadId) {
         this.db.prepare('DELETE FROM threads WHERE id = ?').run(threadId);
     }
-    appendMessage(threadId, role, content, kind) {
+    appendMessage(threadId, role, content, kind, toolCall) {
         const timestamp = new Date().toISOString();
         const nextSequenceRow = this.db.prepare('SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM messages WHERE thread_id = ?').get(threadId);
         const nextSeq = Number(nextSequenceRow?.next_seq || 0);
@@ -323,9 +328,9 @@ class LocalCoreAcpStore {
         this.db.exec('BEGIN IMMEDIATE');
         try {
             this.db.prepare(`
-        INSERT INTO messages (id, thread_id, role, content, timestamp, kind, seq)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-      `).run(id, threadId, role, content, timestamp, kind, nextSeq);
+        INSERT INTO messages (id, thread_id, role, content, tool_call_json, timestamp, kind, seq)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, timestamp, kind, nextSeq);
             this.db.prepare(`
         UPDATE threads
         SET updated_at = ?, history_count = history_count + 1, excerpt = ?
@@ -339,7 +344,7 @@ class LocalCoreAcpStore {
         }
         return { id, timestamp };
     }
-    upsertMessage(threadId, id, role, content, kind) {
+    upsertMessage(threadId, id, role, content, kind, toolCall) {
         const timestamp = new Date().toISOString();
         const excerpt = (0, workspace_thread_mappers_js_1.normalizeMessageContent)(content);
         const existing = this.db.prepare('SELECT id FROM messages WHERE id = ? AND thread_id = ?').get(id, threadId);
@@ -348,17 +353,17 @@ class LocalCoreAcpStore {
             if (existing) {
                 this.db.prepare(`
           UPDATE messages
-          SET content = ?, timestamp = ?, kind = ?
+          SET content = ?, tool_call_json = ?, timestamp = ?, kind = ?
           WHERE id = ? AND thread_id = ?
-        `).run(content, timestamp, kind, id, threadId);
+        `).run(content, toolCall ? JSON.stringify(toolCall) : null, timestamp, kind, id, threadId);
             }
             else {
                 const nextSequenceRow = this.db.prepare('SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM messages WHERE thread_id = ?').get(threadId);
                 const nextSeq = Number(nextSequenceRow?.next_seq || 0);
                 this.db.prepare(`
-          INSERT INTO messages (id, thread_id, role, content, timestamp, kind, seq)
-          VALUES (?, ?, ?, ?, ?, ?, ?)
-        `).run(id, threadId, role, content, timestamp, kind, nextSeq);
+          INSERT INTO messages (id, thread_id, role, content, tool_call_json, timestamp, kind, seq)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, timestamp, kind, nextSeq);
                 this.db.prepare(`
           UPDATE threads
           SET history_count = history_count + 1
@@ -942,11 +947,18 @@ class LocalCoreAcpStore {
     }
     getThreadRow(threadId) {
         return this.db.prepare(`
-      SELECT id, workspace_id, session_id, bridge_session_key, title, agent_type, created_at, updated_at, history_count, excerpt, acp_session_id, acp_supports_load
+      SELECT id, workspace_id, session_id, bridge_session_key, title, agent_type, created_at, updated_at, history_count, excerpt, acp_session_id, acp_supports_load, agent_mode
       FROM threads
       WHERE id = ?
     `).get(threadId);
     }
+    updateThreadAgentMode(threadId, mode) {
+        this.db.prepare(`
+      UPDATE threads
+      SET agent_mode = ?, updated_at = ?
+      WHERE id = ?
+    `).run(mode, new Date().toISOString(), threadId);
+    }
     updateThreadSession(threadId, sessionId, supportsLoad) {
         this.db.prepare(`
       UPDATE threads