@adhdev/daemon-core 0.9.76-rc.8 → 0.9.76

package/src/mesh/mesh-events.ts

@@ -1,61 +1,192 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
-import { getMeshByRepo } from '../config/mesh-config.js';
+import { getMesh, getMeshByRepo } from '../config/mesh-config.js';
 import { LOG } from '../logging/logger.js';
 
+// ---------------------------------------------------------------------------
+// MCP coordinator pending-event queue
+// ---------------------------------------------------------------------------
+// When a mesh event fires but no CLI coordinator session is registered (e.g.
+// the coordinator is Claude Code running via MCP), we buffer the event here.
+// The MCP server drains this queue on every mesh_status / mesh_send_task poll.
+// ---------------------------------------------------------------------------
+
+export interface PendingMeshCoordinatorEvent {
+    event: string;
+    meshId: string;
+    nodeLabel: string;
+    metadataEvent: Record<string, unknown>;
+    queuedAt: number;
+}
+
+const MAX_PENDING_EVENTS = 50;
+const pendingMeshCoordinatorEvents: PendingMeshCoordinatorEvent[] = [];
+
+/** Drain and return all pending coordinator events, clearing the queue. */
+export function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[] {
+    return pendingMeshCoordinatorEvents.splice(0);
+}
+
+function readNonEmptyString(value: unknown): string {
+    return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+
+const MESH_COORDINATOR_EVENTS = new Set([
+    'agent:generating_completed',
+    'agent:waiting_approval',
+    'agent:stopped',
+    'monitor:long_generating',
+]);
+
+function isMeshCoordinatorEvent(eventName: unknown): eventName is string {
+    return typeof eventName === 'string' && MESH_COORDINATOR_EVENTS.has(eventName);
+}
+
+function formatCompletionMetadata(event: Record<string, unknown>): string {
+    const parts = [
+        readNonEmptyString(event.targetSessionId) ? `session_id=${readNonEmptyString(event.targetSessionId)}` : '',
+        readNonEmptyString(event.providerType) ? `provider=${readNonEmptyString(event.providerType)}` : '',
+        readNonEmptyString(event.providerSessionId) ? `provider_session_id=${readNonEmptyString(event.providerSessionId)}` : '',
+    ].filter(Boolean);
+    return parts.length > 0 ? ` (${parts.join('; ')})` : '';
+}
+
+function buildMeshSystemMessage(args: {
+    event: string;
+    nodeLabel: string;
+    metadataEvent: Record<string, unknown>;
+}): string {
+    const metadata = formatCompletionMetadata(args.metadataEvent);
+    if (args.event === 'agent:generating_completed') {
+        return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path; use mesh_read_chat once to review its final progress, but do not poll repeatedly.`;
+    }
+    if (args.event === 'agent:waiting_approval') {
+        return `[System] ${args.nodeLabel} is waiting for approval to proceed${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
+    }
+    if (args.event === 'agent:stopped') {
+        return `[System] ${args.nodeLabel} has stopped${metadata}. Use mesh_read_chat once if you need to inspect its last output.`;
+    }
+    if (args.event === 'monitor:long_generating') {
+        return `[System] ${args.nodeLabel} has been generating for a long time${metadata}. Use mesh_read_chat once for a status check, but do not poll repeatedly.`;
+    }
+    return '';
+}
+
+function injectMeshSystemMessage(components: DaemonComponents, args: {
+    meshId: string;
+    sourceInstanceId?: string;
+    nodeLabel: string;
+    event: string;
+    metadataEvent: Record<string, unknown>;
+}) {
+    const coordinatorInstances = components.instanceManager.getByCategory('cli').filter((inst) => {
+        const instState = inst.getState();
+        if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
+        if (args.sourceInstanceId && instState.instanceId === args.sourceInstanceId) return false;
+        return true;
+    });
+
+    if (coordinatorInstances.length === 0) {
+        // No CLI coordinator session found — buffer for MCP-based coordinators.
+        if (pendingMeshCoordinatorEvents.length < MAX_PENDING_EVENTS) {
+            pendingMeshCoordinatorEvents.push({
+                event: args.event,
+                meshId: args.meshId,
+                nodeLabel: args.nodeLabel,
+                metadataEvent: args.metadataEvent,
+                queuedAt: Date.now(),
+            });
+            LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
+        }
+        return { success: true, forwarded: 0 };
+    }
+
+    const messageText = buildMeshSystemMessage({
+        event: args.event,
+        nodeLabel: args.nodeLabel,
+        metadataEvent: args.metadataEvent,
+    });
+    if (!messageText) return { success: false, error: 'unsupported mesh event' };
+
+    for (const coord of coordinatorInstances) {
+        const coordState = coord.getState();
+        LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}`);
+        coord.onEvent('send_message', { input: { text: messageText, textFallback: messageText } });
+    }
+    return { success: true, forwarded: coordinatorInstances.length };
+}
+
+export function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>) {
+    const eventName = readNonEmptyString(payload.event);
+    if (!isMeshCoordinatorEvent(eventName)) {
+        return { success: false, error: 'unsupported mesh event' };
+    }
+    const meshId = readNonEmptyString(payload.meshId);
+    if (!meshId) return { success: false, error: 'meshId required' };
+
+    const nodeId = readNonEmptyString(payload.nodeId);
+    const workspace = readNonEmptyString(payload.workspace);
+    const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : 'Remote agent';
+    return injectMeshSystemMessage(components, {
+        meshId,
+        nodeLabel,
+        event: eventName,
+        metadataEvent: {
+            targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId),
+            providerType: readNonEmptyString(payload.providerType),
+            providerSessionId: readNonEmptyString(payload.providerSessionId),
+        },
+    });
+}
+
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
-        // We only care about agent sub-session completion or waiting approval
-        if (event.event !== 'agent:generating_completed' && event.event !== 'agent:waiting_approval') return;
-        
-        const instanceId = event.instanceId as string;
+        // We only care about lightweight Repo Mesh coordinator control/status hints.
+        if (!isMeshCoordinatorEvent(event.event)) return;
+
+        const instanceId = readNonEmptyString(event.instanceId);
         if (!instanceId) return;
 
-        // Try to find the workspace of the sub-agent
+        // Try to find the workspace and mesh metadata of the sub-agent.
         const sourceInstance = components.instanceManager.getInstance(instanceId);
         if (!sourceInstance || sourceInstance.category !== 'cli') return;
         const state = sourceInstance.getState();
-        const workspace = state.workspace;
+        const workspace = readNonEmptyString(state.workspace);
         if (!workspace) return;
+        const settings = state.settings && typeof state.settings === 'object' ? state.settings as Record<string, unknown> : {};
 
-        // Find the mesh that this workspace belongs to
-        const mesh = getMeshByRepo(workspace);
-        if (!mesh) return;
-
-        // Find the coordinator session(s)
-        const allInstances = components.instanceManager.getByCategory('cli');
-        const coordinatorInstances = allInstances.filter((inst) => {
-            const instState = inst.getState();
-            
-            // The coordinator session was launched with meshCoordinatorFor setting
-            if (instState.settings?.meshCoordinatorFor !== mesh.id) return false;
-            
-            // Exclude the source instance itself (just in case)
-            if (instState.instanceId === instanceId) return false;
-            
-            return true;
-        });
+        // Coordinator sessions must never inject events into themselves.
+        // A coordinator instance carries meshCoordinatorFor but not meshNodeFor/launchedByCoordinator.
+        if (readNonEmptyString(settings.meshCoordinatorFor)) return;
 
-        if (coordinatorInstances.length === 0) return;
+        const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
 
-        // Determine node label
-        const targetNode = mesh.nodes.find((n) => n.workspace === workspace);
-        const nodeLabel = targetNode ? `Node '${targetNode.id}'` : `Agent at ${workspace}`;
+        // Only forward events for sessions that were explicitly launched as mesh-node delegates
+        // (meshNodeFor set by mesh_launch_session) or that carry the launchedByCoordinator flag.
+        // Do NOT fall back to workspace-based mesh lookup: that would pick up coordinator sessions
+        // and any other CLI session that happens to share the same workspace, causing spurious
+        // system-message injection into the coordinator's own conversation.
+        const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
+        if (!isMeshDelegate) return;
 
-        // Construct a system message in English
-        let messageText = '';
-        if (event.event === 'agent:generating_completed') {
-            messageText = `[System] ${nodeLabel} has completed its task and is now idle. You may use mesh_read_chat to review its progress.`;
-        } else if (event.event === 'agent:waiting_approval') {
-            messageText = `[System] ${nodeLabel} is waiting for approval to proceed. You may use mesh_read_chat and mesh_approve to handle it.`;
-        }
+        const mesh = meshIdFromRuntime ? getMesh(meshIdFromRuntime) : getMeshByRepo(workspace);
+        const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
+        if (!meshId) return;
 
-        if (!messageText) return;
+        // Determine node label. Inline/cloud meshes may be unavailable here, so preserve runtime node id.
+        const targetNode = mesh?.nodes?.find((n: any) => n.workspace === workspace);
+        const runtimeNodeId = readNonEmptyString(settings.meshNodeId);
+        const nodeLabel = targetNode
+            ? `Node '${targetNode.id}'`
+            : runtimeNodeId
+                ? `Node '${runtimeNodeId}'`
+                : `Agent at ${workspace}`;
 
-        // Inject the message into the coordinator sessions
-        for (const coord of coordinatorInstances) {
-            const coordState = coord.getState();
-            LOG.info('MeshEvents', `Forwarding event from ${workspace} to coordinator ${coordState.instanceId}`);
-            coord.onEvent('send_message', { input: { text: messageText, textFallback: messageText } });
-        }
+        injectMeshSystemMessage(components, {
+            meshId,
+            sourceInstanceId: instanceId,
+            nodeLabel,
+            event: event.event,
+            metadataEvent: event,
+        });
     });
 }

package/src/providers/acp-provider-instance.ts

@@ -48,7 +48,7 @@ import {
 } from '@agentclientprotocol/sdk';
 import type { ProviderModule, ContentBlock, InputEnvelope, ToolCallInfo, ToolCallContent as TCC, ToolKind, ToolCallStatus as TCS } from './contracts.js';
 import { normalizeContent, flattenContent, normalizeInputEnvelope } from './contracts.js';
-import { assertProviderSupportsDeclaredInput } from './provider-input-support.js';
+import { assertProviderSupportsDeclaredInput, getEffectiveMessageInputSupport } from './provider-input-support.js';
 import type { ProviderInstance, ProviderState, AcpProviderState, ProviderErrorReason, ProviderEvent, InstanceContext, SessionModalState } from './provider-instance.js';
 import { StatusMonitor } from './status-monitor.js';
 import { buildLegacyModelModeSummaryMetadata } from './summary-metadata.js';
@@ -121,6 +121,41 @@ function appendPromptText(promptParts: ContentBlock[], text: string | undefined)
     promptParts.push({ type: 'text', text: normalized });
 }
 
+function getUriDisplayName(uri: string | undefined, fallback: string): string {
+    if (!uri) return fallback;
+    try {
+        const pathname = uri.startsWith('file://') ? new URL(uri).pathname : uri;
+        return pathname.split(/[\\/]/).filter(Boolean).pop() || fallback;
+    } catch {
+        return uri.split(/[\\/]/).filter(Boolean).pop() || fallback;
+    }
+}
+
+function appendResourceLink(
+    promptParts: ContentBlock[],
+    uri: string,
+    fallbackName: string,
+    mimeType?: string,
+    description?: string,
+    metadata?: Pick<Extract<ContentBlock, { type: 'resource_link' }>, 'title' | 'size' | 'annotations'> & { name?: string },
+): void {
+    promptParts.push({
+        type: 'resource_link',
+        uri,
+        name: metadata?.name || getUriDisplayName(uri, fallbackName),
+        ...(metadata?.title ? { title: metadata.title } : {}),
+        ...(mimeType ? { mimeType } : {}),
+        ...(description ? { description } : {}),
+        ...(typeof metadata?.size === 'number' ? { size: metadata.size } : {}),
+        ...(metadata?.annotations ? { annotations: metadata.annotations } : {}),
+    });
+}
+
+function appendMediaFallbackText(promptParts: ContentBlock[], label: string, details: Array<string | undefined>): void {
+    const normalizedDetails = details.map((value) => typeof value === 'string' ? value.trim() : '').filter(Boolean);
+    appendPromptText(promptParts, `[${[label, ...normalizedDetails].join(': ')}]`);
+}
+
 export function buildAcpPromptParts(input: InputEnvelope, agentCapabilities?: Record<string, any>): ContentBlock[] {
     const caps = getPromptCapabilityFlags(agentCapabilities);
     const promptParts: ContentBlock[] = [];
@@ -132,59 +167,82 @@ export function buildAcpPromptParts(input: InputEnvelope, agentCapabilities?: Re
         }
 
         if (part.type === 'image') {
-            if (!caps.image) {
-                throw new Error('ACP agent does not support input type: image');
-            }
-            if (!part.data) {
-                throw new Error('ACP image input requires inline image data');
+            if (caps.image && part.data) {
+                promptParts.push({
+                    type: 'image',
+                    data: part.data,
+                    mimeType: part.mimeType,
+                    ...(part.uri ? { uri: part.uri } : {}),
+                    ...(part.alt ? { alt: part.alt } : {}),
+                });
+                if (part.alt) appendPromptText(promptParts, part.alt);
+            } else if (part.uri) {
+                appendResourceLink(promptParts, part.uri, 'image', part.mimeType, part.alt);
+                if (part.alt) appendPromptText(promptParts, part.alt);
+            } else {
+                appendMediaFallbackText(promptParts, 'Image attachment', [part.alt, part.mimeType]);
             }
-            promptParts.push({
-                type: 'image',
-                data: part.data,
-                mimeType: part.mimeType,
-                ...(part.uri ? { uri: part.uri } : {}),
-            });
             continue;
         }
 
         if (part.type === 'audio') {
-            if (!caps.audio) {
-                throw new Error('ACP agent does not support input type: audio');
-            }
-            if (!part.data) {
-                throw new Error('ACP audio input requires inline audio data');
+            if (caps.audio && part.data) {
+                promptParts.push({
+                    type: 'audio',
+                    data: part.data,
+                    mimeType: part.mimeType,
+                    ...(part.uri ? { uri: part.uri } : {}),
+                    ...(part.transcript ? { transcript: part.transcript } : {}),
+                });
+                if (part.transcript) appendPromptText(promptParts, part.transcript);
+            } else if (part.uri) {
+                appendResourceLink(promptParts, part.uri, 'audio', part.mimeType, part.transcript);
+                if (part.transcript) appendPromptText(promptParts, part.transcript);
+            } else {
+                appendMediaFallbackText(promptParts, 'Audio attachment', [part.transcript, part.mimeType]);
             }
-            promptParts.push({
-                type: 'audio',
-                data: part.data,
-                mimeType: part.mimeType,
-            });
             continue;
         }
 
         if (part.type === 'resource') {
-            if (!caps.embeddedContext) {
-                throw new Error('ACP agent does not support input type: resource');
-            }
-            if (part.text) {
+            if (caps.embeddedContext && part.text) {
                 promptParts.push({
                     type: 'resource',
                     resource: { uri: part.uri, text: part.text, mimeType: part.mimeType ?? null },
                 });
                 continue;
             }
-            if (part.data) {
+            if (caps.embeddedContext && part.data) {
                 promptParts.push({
                     type: 'resource',
                     resource: { uri: part.uri, blob: part.data, mimeType: part.mimeType ?? null },
                 });
                 continue;
             }
-            throw new Error('ACP resource input requires embedded text or binary data');
+            appendResourceLink(promptParts, part.uri, part.name || 'resource', part.mimeType, part.text);
+            if (part.text) appendPromptText(promptParts, part.text);
+            continue;
+        }
+
+        if (part.type === 'resource_link') {
+            appendResourceLink(promptParts, part.uri, part.name, part.mimeType, part.description, {
+                name: part.name,
+                ...(part.title ? { title: part.title } : {}),
+                ...(typeof part.size === 'number' ? { size: part.size } : {}),
+                ...(part.annotations ? { annotations: part.annotations } : {}),
+            });
+            continue;
         }
 
         if (part.type === 'video') {
-            throw new Error('ACP agent does not support input type: video');
+            // ACP v0.16 prompt capabilities do not advertise native video input. Preserve meaning by
+            // sending a linked resource when possible, plus transcript/descriptive text when present.
+            if (part.uri) {
+                appendResourceLink(promptParts, part.uri, 'video', part.mimeType, part.transcript);
+                if (part.transcript) appendPromptText(promptParts, part.transcript);
+            } else {
+                appendMediaFallbackText(promptParts, 'Video attachment', [part.transcript, part.mimeType]);
+            }
         }
     }
 
@@ -346,6 +404,7 @@ export class AcpProviderInstance implements ProviderInstance {
             lastUpdated: Date.now(),
             settings: this.settings,
             pendingEvents: this.flushEvents(),
+            messageInput: getEffectiveMessageInputSupport(this.provider, this.agentCapabilities),
  // ACP-specific: expose available models/modes for dashboard
             acpConfigOptions: this.configOptions,
             acpModes: this.availableModes,
@@ -962,6 +1021,7 @@ export class AcpProviderInstance implements ProviderInstance {
                         data: b.data,
                         mimeType: b.mimeType,
                         ...(b.uri ? { uri: b.uri } : {}),
+                        ...(b.alt ? { alt: b.alt } : {}),
                     };
                 }
                 if (b.type === 'audio') {
@@ -969,14 +1029,31 @@ export class AcpProviderInstance implements ProviderInstance {
                         type: 'audio',
                         data: b.data,
                         mimeType: b.mimeType,
+                        ...(b.uri ? { uri: b.uri } : {}),
+                        ...(b.transcript ? { transcript: b.transcript } : {}),
                     };
                 }
+                if (b.type === 'video') {
+                    return b.uri
+                        ? {
+                            type: 'resource_link',
+                            uri: b.uri,
+                            name: path.basename(b.uri),
+                            mimeType: b.mimeType,
+                            ...(b.transcript ? { description: b.transcript } : {}),
+                        }
+                        : { type: 'text', text: b.transcript || `[Video attachment: ${b.mimeType}]` };
+                }
                 if (b.type === 'resource_link') {
                     return {
                         type: 'resource_link',
                         uri: b.uri,
                         name: b.name,
+                        ...(b.title ? { title: b.title } : {}),
+                        ...(b.description ? { description: b.description } : {}),
                         ...(b.mimeType ? { mimeType: b.mimeType } : {}),
+                        ...(typeof b.size === 'number' ? { size: b.size } : {}),
+                        ...(b.annotations ? { annotations: b.annotations } : {}),
                     };
                 }
                 if (b.type === 'resource') return { type: 'resource', resource: b.resource };
@@ -1056,7 +1133,7 @@ export class AcpProviderInstance implements ProviderInstance {
 
         switch (update.sessionUpdate) {
             case 'agent_message_chunk': {
-                const content = update.content;
+                const content: any = update.content;
                 if (content.type === 'text') {
                     this.partialContent += content.text;
                 } else if (content.type === 'image') {
@@ -1071,6 +1148,17 @@ export class AcpProviderInstance implements ProviderInstance {
                         type: 'audio',
                         data: content.data,
                         mimeType: content.mimeType,
+                        ...(content.uri ? { uri: content.uri } : {}),
+                        ...(content.transcript ? { transcript: content.transcript } : {}),
+                    });
+                } else if (content.type === 'video') {
+                    this.partialBlocks.push({
+                        type: 'video',
+                        data: content.data,
+                        mimeType: content.mimeType,
+                        ...(content.uri ? { uri: content.uri } : {}),
+                        ...(content.transcript ? { transcript: content.transcript } : {}),
+                        ...(content.posterUri ? { posterUri: content.posterUri } : {}),
                     });
                 } else if (content.type === 'resource_link') {
                     this.partialBlocks.push({