@kafca/agentdock 0.1.29 → 0.1.30

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAssistantMessageChunk = applyAssistantMessageChunk;
 exports.applyThoughtChunk = applyThoughtChunk;
+exports.closeThoughtSegment = closeThoughtSegment;
 exports.registerPendingToolCall = registerPendingToolCall;
 exports.resolveToolCallForUpdate = resolveToolCallForUpdate;
 exports.resolveFallbackToolCall = resolveFallbackToolCall;
@@ -16,6 +17,8 @@ exports.isTerminalToolStatus = isTerminalToolStatus;
 exports.formatPlanProgress = formatPlanProgress;
 exports.extractToolCallKey = extractToolCallKey;
 exports.extractToolCallInput = extractToolCallInput;
+exports.recordToolObservation = recordToolObservation;
+exports.stripObservedToolTranscriptsFromAssistantText = stripObservedToolTranscriptsFromAssistantText;
 function applyAssistantMessageChunk(currentTurn, text) {
     if (!text) {
         return null;
@@ -41,8 +44,12 @@ function applyThoughtChunk(currentTurn, text) {
     if (!text) {
         return null;
     }
-    currentTurn.thoughtText = mergeStreamingText(currentTurn.thoughtText, text);
+    const projection = mergeThoughtSegment(currentTurn.thoughtText, text);
+    currentTurn.thoughtText = projection.fullText;
     const content = currentTurn.thoughtText.trim();
+    if (!content) {
+        return null;
+    }
     if (!currentTurn.thoughtPreviewStarted) {
         currentTurn.thoughtPreviewStarted = true;
         return {
@@ -61,23 +68,67 @@ function applyThoughtChunk(currentTurn, text) {
         bridgeKind: 'thought',
     };
 }
-function mergeStreamingText(current, next) {
+function closeThoughtSegment(currentTurn) {
+    const thoughtText = currentTurn.thoughtText || '';
+    if (!thoughtText.trim()) {
+        return;
+    }
+    const nextSequence = (currentTurn.thoughtSequence || 1) + 1;
+    const runId = currentTurn.runId || 'thought';
+    currentTurn.thoughtSequence = nextSequence;
+    currentTurn.thoughtText = '';
+    currentTurn.thoughtPreviewStarted = false;
+    currentTurn.thoughtMessageId = `${runId}-thought-${nextSequence}`;
+    currentTurn.thoughtPreviewHandle = `${runId}-thought-preview-${nextSequence}`;
+}
+function mergeThoughtSegment(current, next) {
     if (!current) {
-        return next;
+        return { fullText: next, segmentText: next };
     }
     if (next.startsWith(current)) {
-        return next;
+        return {
+            fullText: next,
+            segmentText: next.slice(current.length),
+        };
     }
     if (current.endsWith(next)) {
-        return current;
+        return {
+            fullText: current,
+            segmentText: '',
+        };
     }
     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);
+            const suffix = next.slice(size);
+            return {
+                fullText: current + suffix,
+                segmentText: suffix,
+            };
         }
     }
-    return current + next;
+    return {
+        fullText: appendThoughtPiece(current, next),
+        segmentText: next,
+    };
+}
+function appendThoughtPiece(current, next) {
+    if (!current.trim()) {
+        return next;
+    }
+    if (!next.trim()) {
+        return current;
+    }
+    if (/^[,.;:!?，。；：！？、）】》]/.test(next.trimStart())) {
+        return current.trimEnd() + next.trimStart();
+    }
+    if (/^[-/]/.test(next.trimStart()) || /[-/][A-Za-z0-9]*$/.test(current.trimEnd())) {
+        return current.trimEnd() + next.trimStart();
+    }
+    if (/\s$/.test(current) || /^\s/.test(next)) {
+        return current + next;
+    }
+    return `${current.trimEnd()} ${next.trimStart()}`;
 }
 function registerPendingToolCall(input) {
     const title = String(input.update.title || 'Running tool').trim();
@@ -203,3 +254,184 @@ function extractToolCallInput(update) {
     }
     return undefined;
 }
+function recordToolObservation(currentTurn, observation) {
+    const normalized = {
+        ...observation,
+        name: observation.name?.trim() || undefined,
+        title: observation.title?.trim() || undefined,
+        status: observation.status?.trim() || undefined,
+        outputText: observation.outputText?.trim() || undefined,
+    };
+    if (!normalized.name && !normalized.title && normalized.input === undefined && !normalized.outputText) {
+        return;
+    }
+    currentTurn.toolObservations = [
+        ...(currentTurn.toolObservations || []),
+        normalized,
+    ];
+}
+function stripObservedToolTranscriptsFromAssistantText(text, observations) {
+    let remaining = String(text || '');
+    const knownObservations = observations || [];
+    for (let guard = 0; guard < knownObservations.length; guard += 1) {
+        const stripped = stripOneObservedToolTranscriptPrefix(remaining, knownObservations);
+        if (stripped === remaining) {
+            break;
+        }
+        remaining = stripped;
+    }
+    return remaining.trim();
+}
+function stripOneObservedToolTranscriptPrefix(text, observations) {
+    const trimmedStart = text.replace(/^\s+/, '');
+    if (!trimmedStart) {
+        return text;
+    }
+    const matchingEvidence = observations
+        .map((observation) => createToolObservationEvidence(observation))
+        .find((evidence) => matchesObservedToolTranscriptPrefix(trimmedStart, evidence));
+    if (!matchingEvidence) {
+        return text;
+    }
+    const boundary = findToolTranscriptPrefixBoundary(trimmedStart, matchingEvidence);
+    if (boundary <= 0) {
+        return text;
+    }
+    return trimmedStart.slice(boundary);
+}
+function createToolObservationEvidence(observation) {
+    const serializedInput = serializeObservationValue(observation.input);
+    const serializedOutput = observation.outputText || '';
+    const structuredValues = collectStructuredStringValues(serializedOutput);
+    return {
+        toolNames: uniqueNonEmpty([
+            observation.name,
+            observation.title,
+        ].map((value) => normalizeEvidencePhrase(value || ''))),
+        urls: uniqueNonEmpty([
+            ...extractUrls(serializedInput),
+            ...extractUrls(serializedOutput),
+        ]),
+        phrases: uniqueNonEmpty([
+            ...structuredValues,
+            observation.title,
+            serializedInput.length <= 300 ? serializedInput : '',
+        ].map((value) => normalizeEvidencePhrase(value || '')).filter((value) => value.length >= 12)),
+    };
+}
+function matchesObservedToolTranscriptPrefix(text, evidence) {
+    const prefix = text.slice(0, 3000);
+    const normalizedPrefix = normalizeEvidencePhrase(prefix);
+    const hasToolName = evidence.toolNames.some((name) => name && normalizedPrefix.includes(name));
+    const urlMatches = evidence.urls.filter((url) => prefix.includes(url)).length;
+    const phraseMatches = evidence.phrases.filter((phrase) => normalizedPrefix.includes(phrase)).length;
+    if (hasToolName && (urlMatches > 0 || phraseMatches > 0)) {
+        return true;
+    }
+    return urlMatches > 0 && phraseMatches > 0;
+}
+function findToolTranscriptPrefixBoundary(text, evidence) {
+    const lines = text.split(/\n/);
+    const firstContentLine = lines.find((line) => line.trim());
+    if (!firstContentLine || !isTranscriptStartLine(firstContentLine, evidence)) {
+        return 0;
+    }
+    let offset = 0;
+    let seenEvidence = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] || '';
+        const lineWithNewlineLength = line.length + (index < lines.length - 1 ? 1 : 0);
+        if (lineContainsObservationEvidence(line, evidence)) {
+            seenEvidence = true;
+        }
+        if (seenEvidence && index > 0 && line.trim() && !isStructuredTranscriptLine(line, evidence)) {
+            return offset;
+        }
+        offset += lineWithNewlineLength;
+    }
+    return 0;
+}
+function isTranscriptStartLine(line, evidence) {
+    const trimmed = line.trim();
+    return lineContainsObservationEvidence(line, evidence) &&
+        (/^(```|\{|\[|\*\*[^*]+\*\*|#+\s)/.test(trimmed) || /^[A-Za-z0-9_.-]+:/.test(trimmed));
+}
+function isStructuredTranscriptLine(line, evidence) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return true;
+    }
+    if (lineContainsObservationEvidence(line, evidence)) {
+        return true;
+    }
+    return /^(```|\{|\}|\[|\]|".+":|\*\*[^*]+:\*\*|\*[^*]+\*|#+\s)/.test(trimmed) ||
+        /[:：]\s*$/.test(trimmed) ||
+        /[{}\[\]"]/g.test(trimmed) ||
+        /^[A-Za-z0-9_.-]+:/.test(trimmed);
+}
+function lineContainsObservationEvidence(line, evidence) {
+    const normalizedLine = normalizeEvidencePhrase(line);
+    return evidence.toolNames.some((name) => name && normalizedLine.includes(name)) ||
+        evidence.urls.some((url) => line.includes(url)) ||
+        evidence.phrases.some((phrase) => phrase && normalizedLine.includes(phrase));
+}
+function serializeObservationValue(value) {
+    if (value == null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function collectStructuredStringValues(text) {
+    const values = [];
+    try {
+        collectStringValues(JSON.parse(text), values);
+    }
+    catch {
+        const matches = text.matchAll(/"(title|description|url|name|summary)"\s*:\s*"([^"]{12,})"/gi);
+        for (const match of matches) {
+            values.push(match[2] || '');
+        }
+    }
+    return values;
+}
+function collectStringValues(value, values) {
+    if (typeof value === 'string') {
+        values.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectStringValues(item, values);
+        }
+        return;
+    }
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+    for (const entry of Object.values(value)) {
+        collectStringValues(entry, values);
+    }
+}
+function extractUrls(text) {
+    return [...text.matchAll(/https?:\/\/[^\s"'`<>),\]}]+/g)]
+        .map((match) => match[0])
+        .filter(Boolean);
+}
+function normalizeEvidencePhrase(value) {
+    return String(value || '')
+        .replace(/\\[nrt]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function uniqueNonEmpty(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}

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

@@ -194,14 +194,18 @@ class LocalCoreAcpSessionCoordinator {
     }
     buildSessionMeta(threadId, permissionModeOverride = '') {
         const mode = this.resolveLaunchPermissionMode(threadId, permissionModeOverride);
-        if (!mode) {
-            return undefined;
-        }
         return {
             claudeCode: {
-                options: {
-                    permissionMode: mode,
-                },
+                emitRawSDKMessages: [
+                    { type: 'system', subtype: 'local_command_output' },
+                ],
+                ...(mode
+                    ? {
+                        options: {
+                            permissionMode: mode,
+                        },
+                    }
+                    : {}),
             },
         };
     }

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

@@ -35,6 +35,7 @@ class LocalCoreAcpTransport {
             loadReplayMode: false,
             pendingPermissionByRun: new Map(),
             schedulerJobCreatedByRun: new Map(),
+            pendingRawAssistantProgressChunks: [],
             closed: false,
             closeReason: null,
             promptPromise: null,

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

@@ -11,6 +11,11 @@ class LocalCoreAcpTurnCoordinator {
     constructor(options) {
         this.options = options;
     }
+    closePendingThoughtSegment(session) {
+        const currentTurn = session.currentTurn;
+        if (currentTurn)
+            (0, local_core_acp_progress_js_1.closeThoughtSegment)(currentTurn);
+    }
     flushPendingToolCall(session) {
         const currentTurn = session.currentTurn;
         const currentRunId = session.currentRunId;
@@ -97,6 +102,7 @@ class LocalCoreAcpTurnCoordinator {
         }
         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);
+        this.closePendingThoughtSegment(session);
         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')
@@ -172,7 +178,14 @@ class LocalCoreAcpTurnCoordinator {
         });
     }
     handleAgentNotification(session, payload) {
-        if (session.loadReplayMode || payload.method !== 'session/update') {
+        if (session.loadReplayMode) {
+            return;
+        }
+        if (payload.method === '_claude/sdkMessage') {
+            this.handleClaudeSdkMessage(session, payload.params?.message);
+            return;
+        }
+        if (payload.method !== 'session/update') {
             return;
         }
         const update = payload.params?.update;
@@ -183,10 +196,25 @@ class LocalCoreAcpTurnCoordinator {
         }
         switch (String(update.sessionUpdate || '')) {
             case 'agent_message_chunk': {
+                this.closePendingThoughtSegment(session);
                 this.flushPendingToolCall(session);
                 if (update.content?.type !== 'text') {
                     return;
                 }
+                if (isToolScopedAssistantUpdate(update) || consumeRawAssistantProgressChunk(session, String(update.content.text || ''))) {
+                    const content = String(update.content.text || '').trim();
+                    if (content) {
+                        this.options.appendMessage(session.threadId, 'assistant', content, 'progress', undefined, 'tool');
+                        this.options.emitBridge({
+                            type: 'reply',
+                            sessionKey: session.bridgeSessionKey,
+                            replyCtx: currentRunId,
+                            bridgeKind: 'tool',
+                            content,
+                        });
+                    }
+                    return;
+                }
                 const projection = (0, local_core_acp_progress_js_1.applyAssistantMessageChunk)(currentTurn, String(update.content.text || ''));
                 if (!projection) {
                     return;
@@ -202,7 +230,6 @@ class LocalCoreAcpTurnCoordinator {
                 return;
             }
             case 'agent_thought_chunk': {
-                this.flushPendingToolCall(session);
                 if (update.content?.type !== 'text') {
                     return;
                 }
@@ -224,11 +251,18 @@ class LocalCoreAcpTurnCoordinator {
                 return;
             }
             case 'tool_call': {
+                this.closePendingThoughtSegment(session);
                 const toolCall = (0, local_core_acp_progress_js_1.registerPendingToolCall)({ currentTurn, runId: currentRunId, update });
+                (0, local_core_acp_progress_js_1.recordToolObservation)(currentTurn, {
+                    name: toolCall.title,
+                    title: toolCall.title,
+                    input: toolCall.input,
+                });
                 (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, toolCall);
                 return;
             }
             case 'tool_call_update': {
+                this.closePendingThoughtSegment(session);
                 const title = String(update.title || 'Tool update').trim();
                 const status = String(update.status || '').trim();
                 const content = (0, local_core_acp_progress_js_1.extractToolUpdateContent)(update.content);
@@ -280,11 +314,19 @@ class LocalCoreAcpTurnCoordinator {
                     detail: displayTitle,
                     content,
                 });
+                (0, local_core_acp_progress_js_1.recordToolObservation)(currentTurn, {
+                    name: toolName || displayTitle || title,
+                    title: displayTitle || title,
+                    status,
+                    input: updateInput === undefined ? toolCall?.input : updateInput,
+                    outputText: 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': {
+                this.closePendingThoughtSegment(session);
                 this.flushPendingToolCall(session);
                 const entries = Array.isArray(update.entries) ? update.entries : [];
                 if (entries.length === 0) {
@@ -308,6 +350,19 @@ class LocalCoreAcpTurnCoordinator {
                 return;
         }
     }
+    handleClaudeSdkMessage(session, message) {
+        if (!session.currentTurn || message?.type !== 'system' || message?.subtype !== 'local_command_output') {
+            return;
+        }
+        const content = typeof message.content === 'string' ? message.content : '';
+        if (!content) {
+            return;
+        }
+        session.pendingRawAssistantProgressChunks = [
+            ...(session.pendingRawAssistantProgressChunks || []),
+            content,
+        ];
+    }
     emitProgress(session, currentRunId, content, messageId, toolCall) {
         if (messageId && this.options.upsertMessage) {
             this.options.upsertMessage(session.threadId, messageId, 'assistant', content, 'progress', toolCall, toolCall ? 'tool' : undefined);
@@ -327,6 +382,28 @@ class LocalCoreAcpTurnCoordinator {
     }
 }
 exports.LocalCoreAcpTurnCoordinator = LocalCoreAcpTurnCoordinator;
+function isToolScopedAssistantUpdate(update) {
+    const meta = update._meta;
+    if (!meta || typeof meta !== 'object') {
+        return false;
+    }
+    const claudeCode = meta.claudeCode;
+    if (!claudeCode || typeof claudeCode !== 'object') {
+        return false;
+    }
+    const parentToolUseId = claudeCode.parentToolUseId;
+    return typeof parentToolUseId === 'string' && parentToolUseId.trim().length > 0;
+}
+function consumeRawAssistantProgressChunk(session, text) {
+    const pending = session.pendingRawAssistantProgressChunks || [];
+    const index = pending.findIndex((candidate) => candidate === text);
+    if (index < 0) {
+        return false;
+    }
+    pending.splice(index, 1);
+    session.pendingRawAssistantProgressChunks = pending;
+    return true;
+}
 function createToolCallPayload(input) {
     const status = input.status.trim() || 'running';
     return {

package/dist-electron/services/local-ai-core/src/channel/lark/runtime-state.js

@@ -188,7 +188,7 @@ function takePendingLarkThoughtRender(turn) {
 }
 function getLarkRenderedMessageId(turn, rendered) {
     if (rendered.isFinal) {
-        return turn.finalMessageId || turn.replyMessageId;
+        return undefined;
     }
     return turn.progressMessageIds[rendered.key];
 }

package/dist-electron/services/local-ai-core/src/channel/weixin/local-core-weixin-gateway.js

@@ -1058,6 +1058,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             previewText: '',
             finalText: '',
             thinkingSteps: [],
+            pendingThoughtText: undefined,
             statusLines: [],
             buttonRows: [],
             lastSentAt: 0,
@@ -1077,6 +1078,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             turn.previewText = '';
             turn.finalText = '';
             turn.thinkingSteps = [];
+            turn.pendingThoughtText = undefined;
             turn.statusLines = [];
             turn.buttonRows = [];
             return;
@@ -1087,12 +1089,15 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         }
         if (event.type === 'preview_start' || event.type === 'update_message') {
             if (bridgeKind === 'thought') {
-                this.pushUnique(turn.thinkingSteps, content);
+                turn.pendingThoughtText = content;
                 return;
             }
             turn.previewText = content;
             return;
         }
+        if (bridgeKind !== 'thought') {
+            this.flushPendingThought(turn);
+        }
         if (event.type === 'status') {
             if (content) {
                 this.pushUnique(turn.statusLines, content);
@@ -1148,6 +1153,13 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         }
         return sections.join('\n\n').trim();
     }
+    flushPendingThought(turn) {
+        const text = String(turn.pendingThoughtText || '').trim();
+        if (!text)
+            return;
+        this.pushUnique(turn.thinkingSteps, text);
+        turn.pendingThoughtText = undefined;
+    }
     isTerminalBridgeMessage(event, rendered) {
         if (event.type === 'buttons')
             return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kafca/agentdock",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "type": "module",
   "main": "dist-electron/electron/main.js",
   "bin": {

package/dist/renderer/assets/projects-CJUs2vaq.js

@@ -1 +0,0 @@
-import{z as t}from"./index-DvAYflFj.js";const e=()=>t.get("/projects"),r=o=>t.get(`/projects/${o}`);export{r as g,e as l};