@geminilight/mindos 0.6.28 → 0.6.30

package/app/hooks/useAskModal.ts

@@ -8,13 +8,19 @@ import { useSyncExternalStore, useCallback } from 'react';
  * No external dependencies (no zustand needed).
  */
 
+export interface AcpAgentSelection {
+  id: string;
+  name: string;
+}
+
 interface AskModalState {
   open: boolean;
   initialMessage: string;
   source: 'user' | 'guide' | 'guide-next';  // who triggered the open
+  acpAgent: AcpAgentSelection | null;
 }
 
-let state: AskModalState = { open: false, initialMessage: '', source: 'user' };
+let state: AskModalState = { open: false, initialMessage: '', source: 'user', acpAgent: null };
 const listeners = new Set<() => void>();
 
 function emit() { listeners.forEach(l => l()); }
@@ -24,13 +30,13 @@ function subscribe(listener: () => void) {
 }
 function getSnapshot() { return state; }
 
-export function openAskModal(message = '', source: AskModalState['source'] = 'user') {
-  state = { open: true, initialMessage: message, source };
+export function openAskModal(message = '', source: AskModalState['source'] = 'user', acpAgent: AcpAgentSelection | null = null) {
+  state = { open: true, initialMessage: message, source, acpAgent };
   emit();
 }
 
 export function closeAskModal() {
-  state = { open: false, initialMessage: '', source: 'user' };
+  state = { open: false, initialMessage: '', source: 'user', acpAgent: null };
   emit();
 }
 
@@ -40,7 +46,8 @@ export function useAskModal() {
     open: snap.open,
     initialMessage: snap.initialMessage,
     source: snap.source,
-    openWith: useCallback((message: string, source: AskModalState['source'] = 'user') => openAskModal(message, source), []),
+    acpAgent: snap.acpAgent,
+    openWith: useCallback((message: string, source: AskModalState['source'] = 'user', acpAgent: AcpAgentSelection | null = null) => openAskModal(message, source, acpAgent), []),
     close: useCallback(() => closeAskModal(), []),
   };
 }

package/app/hooks/useAskPanel.ts

@@ -2,7 +2,7 @@
 
 import { useState, useEffect, useCallback } from 'react';
 import { RIGHT_ASK_DEFAULT_WIDTH, RIGHT_ASK_MIN_WIDTH, RIGHT_ASK_MAX_WIDTH } from '@/components/RightAskPanel';
-import { useAskModal } from './useAskModal';
+import { useAskModal, type AcpAgentSelection } from './useAskModal';
 
 export interface AskPanelState {
   askPanelOpen: boolean;
@@ -12,6 +12,7 @@ export interface AskPanelState {
   desktopAskPopupOpen: boolean;
   askInitialMessage: string;
   askOpenSource: 'user' | 'guide' | 'guide-next';
+  askAcpAgent: AcpAgentSelection | null;
   toggleAskPanel: () => void;
   closeAskPanel: () => void;
   closeDesktopAskPopup: () => void;
@@ -33,6 +34,7 @@ export function useAskPanel(): AskPanelState {
   const [askInitialMessage, setAskInitialMessage] = useState('');
   const [askMaximized, setAskMaximized] = useState(false);
   const [askOpenSource, setAskOpenSource] = useState<'user' | 'guide' | 'guide-next'>('user');
+  const [askAcpAgent, setAskAcpAgent] = useState<AcpAgentSelection | null>(null);
 
   const askModal = useAskModal();
 
@@ -62,6 +64,7 @@ export function useAskPanel(): AskPanelState {
     if (askModal.open) {
       setAskInitialMessage(askModal.initialMessage);
       setAskOpenSource(askModal.source);
+      setAskAcpAgent(askModal.acpAgent);
       if (askMode === 'popup') {
         setDesktopAskPopupOpen(true);
       } else {
@@ -69,17 +72,17 @@ export function useAskPanel(): AskPanelState {
       }
       askModal.close();
     }
-  }, [askModal.open, askModal.initialMessage, askModal.source, askModal.close, askMode]);
+  }, [askModal.open, askModal.initialMessage, askModal.source, askModal.acpAgent, askModal.close, askMode]);
 
   const toggleAskPanel = useCallback(() => {
     if (askMode === 'popup') {
       setDesktopAskPopupOpen(v => {
-        if (!v) { setAskInitialMessage(''); setAskOpenSource('user'); }
+        if (!v) { setAskInitialMessage(''); setAskOpenSource('user'); setAskAcpAgent(null); }
         return !v;
       });
     } else {
       setAskPanelOpen(v => {
-        if (!v) { setAskInitialMessage(''); setAskOpenSource('user'); }
+        if (!v) { setAskInitialMessage(''); setAskOpenSource('user'); setAskAcpAgent(null); }
         return !v;
       });
     }
@@ -114,7 +117,7 @@ export function useAskPanel(): AskPanelState {
 
   return {
     askPanelOpen, askPanelWidth, askMaximized, askMode, desktopAskPopupOpen,
-    askInitialMessage, askOpenSource,
+    askInitialMessage, askOpenSource, askAcpAgent,
     toggleAskPanel, closeAskPanel, closeDesktopAskPopup,
     handleAskWidthChange, handleAskWidthCommit, handleAskModeSwitch, toggleAskMaximized,
   };

package/app/hooks/useAskSession.ts

@@ -21,7 +21,10 @@ export function sessionTitle(s: ChatSession): string {
   const firstUser = s.messages.find((m) => m.role === 'user');
   if (!firstUser) return '(empty session)';
   const line = firstUser.content.replace(/\s+/g, ' ').trim();
-  return line.length > 42 ? `${line.slice(0, 42)}...` : line;
+  if (!line && firstUser.images && firstUser.images.length > 0) {
+    return `[${firstUser.images.length} image${firstUser.images.length > 1 ? 's' : ''}]`;
+  }
+  return line.length > 42 ? `${line.slice(0, 42)}...` : line || '(empty session)';
 }
 
 async function fetchSessions(): Promise<ChatSession[]> {
@@ -38,10 +41,24 @@ async function fetchSessions(): Promise<ChatSession[]> {
 
 async function upsertSession(session: ChatSession): Promise<void> {
   try {
+    // Strip base64 image data before persisting (images are session-only, not stored)
+    const stripped: ChatSession = {
+      ...session,
+      messages: session.messages.map(m => {
+        if (!m.images || m.images.length === 0) return m;
+        return {
+          ...m,
+          images: m.images.map(img => ({
+            ...img,
+            data: '', // Strip base64 data — images are ephemeral
+          })),
+        };
+      }),
+    };
     await fetch('/api/ask-sessions', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ session }),
+      body: JSON.stringify({ session: stripped }),
     });
   } catch {
     // ignore persistence errors

package/app/hooks/useDelegationHistory.ts

@@ -0,0 +1,49 @@
+'use client';
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import type { DelegationRecord } from '@/lib/a2a/types';
+
+interface DelegationHistory {
+  delegations: DelegationRecord[];
+  loading: boolean;
+  refresh: () => void;
+}
+
+const POLL_INTERVAL_MS = 5_000;
+
+export function useDelegationHistory(active: boolean): DelegationHistory {
+  const [delegations, setDelegations] = useState<DelegationRecord[]>([]);
+  const [loading, setLoading] = useState(false);
+  const mountedRef = useRef(true);
+
+  const fetchHistory = useCallback(async () => {
+    setLoading(true);
+    try {
+      const res = await fetch('/api/a2a/delegations');
+      if (!res.ok) return;
+      const data = await res.json();
+      if (mountedRef.current) {
+        setDelegations(data.delegations ?? []);
+      }
+    } catch {
+      // silently ignore fetch errors
+    } finally {
+      if (mountedRef.current) setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => { mountedRef.current = false; };
+  }, []);
+
+  // Fetch on mount and poll while active
+  useEffect(() => {
+    if (!active) return;
+    fetchHistory();
+    const id = setInterval(fetchHistory, POLL_INTERVAL_MS);
+    return () => clearInterval(id);
+  }, [active, fetchHistory]);
+
+  return { delegations, loading, refresh: fetchHistory };
+}

package/app/hooks/useImageUpload.ts

@@ -0,0 +1,152 @@
+'use client';
+
+import { useState, useCallback } from 'react';
+import type { ImagePart, ImageMimeType } from '@/lib/types';
+
+const ALLOWED_IMAGE_TYPES: Set<string> = new Set([
+  'image/png', 'image/jpeg', 'image/gif', 'image/webp',
+]);
+
+const MAX_IMAGE_SIZE = 5 * 1024 * 1024; // 5MB per image
+const MAX_IMAGES = 4;
+const MAX_DIMENSION = 1920; // Compress to this max width/height
+
+function isImageMimeType(type: string): type is ImageMimeType {
+  return ALLOWED_IMAGE_TYPES.has(type);
+}
+
+/** Compress image to JPEG if over size/dimension limits */
+async function compressImage(file: File): Promise<{ data: string; mimeType: ImageMimeType }> {
+  const mimeType = file.type as ImageMimeType;
+
+  // If small enough, use as-is (skip canvas compression to preserve GIF animation)
+  if (file.size <= MAX_IMAGE_SIZE) {
+    const buffer = await file.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return { data: btoa(binary), mimeType };
+  }
+
+  // Compress via canvas
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      let { width, height } = img;
+      if (width > MAX_DIMENSION || height > MAX_DIMENSION) {
+        const ratio = Math.min(MAX_DIMENSION / width, MAX_DIMENSION / height);
+        width = Math.round(width * ratio);
+        height = Math.round(height * ratio);
+      }
+      const canvas = document.createElement('canvas');
+      canvas.width = width;
+      canvas.height = height;
+      const ctx = canvas.getContext('2d');
+      if (!ctx) { reject(new Error('Canvas not supported')); return; }
+      ctx.drawImage(img, 0, 0, width, height);
+      const dataUrl = canvas.toDataURL('image/jpeg', 0.85);
+      const base64 = dataUrl.split(',')[1];
+      resolve({ data: base64, mimeType: 'image/jpeg' });
+      URL.revokeObjectURL(img.src);
+    };
+    img.onerror = () => { reject(new Error('Failed to load image')); URL.revokeObjectURL(img.src); };
+    img.src = URL.createObjectURL(file);
+  });
+}
+
+/** Convert clipboard/DataTransfer items to File[] */
+function extractImageFiles(items: DataTransferItemList | DataTransferItem[]): File[] {
+  const files: File[] = [];
+  const list = Array.from(items);
+  for (const item of list) {
+    if (item.kind === 'file' && ALLOWED_IMAGE_TYPES.has(item.type)) {
+      const file = item.getAsFile();
+      if (file) files.push(file);
+    }
+  }
+  return files;
+}
+
+export function useImageUpload() {
+  const [images, setImages] = useState<ImagePart[]>([]);
+  const [imageError, setImageError] = useState('');
+
+  const addImages = useCallback(async (files: File[]) => {
+    setImageError('');
+    const toProcess = files.slice(0, MAX_IMAGES);
+
+    const results: ImagePart[] = [];
+    for (const file of toProcess) {
+      if (!isImageMimeType(file.type)) {
+        setImageError(`Unsupported image type: ${file.type}`);
+        continue;
+      }
+      try {
+        const { data, mimeType } = await compressImage(file);
+        results.push({ type: 'image', data, mimeType });
+      } catch {
+        setImageError(`Failed to process image: ${file.name}`);
+      }
+    }
+
+    setImages(prev => {
+      const merged = [...prev, ...results];
+      if (merged.length > MAX_IMAGES) {
+        setImageError(`Maximum ${MAX_IMAGES} images allowed`);
+        return merged.slice(0, MAX_IMAGES);
+      }
+      return merged;
+    });
+  }, []);
+
+  /** Handle paste event — returns true if images were found */
+  const handlePaste = useCallback(async (e: ClipboardEvent | React.ClipboardEvent): Promise<boolean> => {
+    const items = e.clipboardData?.items;
+    if (!items) return false;
+    const files = extractImageFiles(items);
+    if (files.length === 0) return false;
+    await addImages(files);
+    return true;
+  }, [addImages]);
+
+  /** Handle drop event */
+  const handleDrop = useCallback(async (e: DragEvent | React.DragEvent) => {
+    const items = e.dataTransfer?.items;
+    if (!items) return;
+    const files = extractImageFiles(items);
+    if (files.length > 0) {
+      e.preventDefault();
+      await addImages(files);
+    }
+  }, [addImages]);
+
+  /** Handle file input change */
+  const handleFileSelect = useCallback(async (files: FileList | null) => {
+    if (!files) return;
+    const imageFiles = Array.from(files).filter(f => isImageMimeType(f.type));
+    await addImages(imageFiles);
+  }, [addImages]);
+
+  const removeImage = useCallback((idx: number) => {
+    setImages(prev => prev.filter((_, i) => i !== idx));
+  }, []);
+
+  const clearImages = useCallback(() => {
+    setImages([]);
+    setImageError('');
+  }, []);
+
+  return {
+    images,
+    imageError,
+    addImages,
+    handlePaste,
+    handleDrop,
+    handleFileSelect,
+    removeImage,
+    clearImages,
+  };
+}

package/app/lib/a2a/client.ts

@@ -10,6 +10,7 @@ import type {
   JsonRpcRequest,
   JsonRpcResponse,
   SendMessageParams,
+  DelegationRecord,
 } from './types';
 
 /* ── Constants ─────────────────────────────────────────────────────────── */
@@ -22,6 +23,20 @@ const CARD_CACHE_TTL_MS = 5 * 60 * 1000; // 5 min
 
 const registry = new Map<string, RemoteAgent>();
 
+/* ── Delegation History ────────────────────────────────────────────────── */
+
+const delegationHistory: DelegationRecord[] = [];
+
+/** Get all delegation history records */
+export function getDelegationHistory(): DelegationRecord[] {
+  return [...delegationHistory];
+}
+
+/** Clear all delegation history records */
+export function clearDelegationHistory(): void {
+  delegationHistory.length = 0;
+}
+
 /** Derive a stable ID from a URL (includes protocol to avoid collisions) */
 function urlToId(url: string): string {
   try {
@@ -152,6 +167,19 @@ export async function delegateTask(
   if (!agent) throw new Error(`Agent not found: ${agentId}`);
   if (!agent.reachable) throw new Error(`Agent not reachable: ${agent.card.name}`);
 
+  const record: DelegationRecord = {
+    id: `del-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    agentId,
+    agentName: agent.card.name,
+    message,
+    status: 'pending',
+    startedAt: new Date().toISOString(),
+    completedAt: null,
+    result: null,
+    error: null,
+  };
+  delegationHistory.push(record);
+
   const params: SendMessageParams = {
     message: {
       role: 'ROLE_USER',
@@ -160,13 +188,29 @@ export async function delegateTask(
     configuration: { blocking: true },
   };
 
-  const response = await jsonRpcCall(agent.endpoint, 'SendMessage', params, token);
+  try {
+    const response = await jsonRpcCall(agent.endpoint, 'SendMessage', params, token);
 
-  if (response.error) {
-    throw new Error(`A2A error [${response.error.code}]: ${response.error.message}`);
-  }
+    if (response.error) {
+      record.status = 'failed';
+      record.completedAt = new Date().toISOString();
+      record.error = `A2A error [${response.error.code}]: ${response.error.message}`;
+      throw new Error(record.error);
+    }
 
-  return response.result as A2ATask;
+    const task = response.result as A2ATask;
+    record.status = 'completed';
+    record.completedAt = new Date().toISOString();
+    record.result = task.artifacts?.[0]?.parts?.[0]?.text ?? null;
+    return task;
+  } catch (err) {
+    if (record.status === 'pending') {
+      record.status = 'failed';
+      record.completedAt = new Date().toISOString();
+      record.error = (err as Error).message;
+    }
+    throw err;
+  }
 }
 
 /**

package/app/lib/a2a/orchestrator.ts

@@ -5,7 +5,6 @@
 
 import { randomUUID } from 'crypto';
 import type {
-  RemoteAgent,
   SubTask,
   OrchestrationPlan,
   ExecutionStrategy,

package/app/lib/a2a/task-handler.ts

@@ -200,18 +200,18 @@ export function handleGetTask(params: GetTaskParams): A2ATask | null {
   return tasks.get(params.id) ?? null;
 }
 
-export function handleCancelTask(params: CancelTaskParams): A2ATask | null {
+export function handleCancelTask(params: CancelTaskParams): { task: A2ATask | null; reason: 'not_found' | 'not_cancelable' | 'ok' } {
   const task = tasks.get(params.id);
-  if (!task) return null;
+  if (!task) return { task: null, reason: 'not_found' };
 
   const terminalStates: TaskState[] = ['TASK_STATE_COMPLETED', 'TASK_STATE_FAILED', 'TASK_STATE_CANCELED', 'TASK_STATE_REJECTED'];
-  if (terminalStates.includes(task.status.state)) return null; // not cancelable
+  if (terminalStates.includes(task.status.state)) return { task: null, reason: 'not_cancelable' };
 
   task.status = {
     state: 'TASK_STATE_CANCELED',
     timestamp: new Date().toISOString(),
   };
-  return task;
+  return { task, reason: 'ok' };
 }
 
 /* ── Helpers ───────────────────────────────────────────────────────────── */

package/app/lib/a2a/types.ts

@@ -210,3 +210,18 @@ export interface SkillMatch {
   skillName: string;
   confidence: number;
 }
+
+/* ── Delegation History (Phase 3 UI) ─────────────────────────────────── */
+
+/** A recorded delegation attempt for the history log */
+export interface DelegationRecord {
+  id: string;
+  agentId: string;
+  agentName: string;
+  message: string;
+  status: 'pending' | 'completed' | 'failed';
+  startedAt: string;
+  completedAt: string | null;
+  result: string | null;
+  error: string | null;
+}

package/app/lib/acp/acp-tools.ts

@@ -0,0 +1,95 @@
+/**
+ * ACP Agent Tools — Expose ACP capabilities as tools
+ * for the MindOS built-in agent to discover and invoke ACP agents.
+ */
+
+import { Type, type Static } from '@sinclair/typebox';
+import type { AgentTool } from '@mariozechner/pi-agent-core';
+import { getAcpAgents, findAcpAgent } from './registry';
+import { createSessionFromEntry, prompt, closeSession } from './session';
+import { getMindRoot } from '../fs';
+
+function textResult(text: string) {
+  return { content: [{ type: 'text' as const, text }], details: {} };
+}
+
+/* ── Parameter Schemas ─────────────────────────────────────────────────── */
+
+const ListAcpAgentsParams = Type.Object({
+  tag: Type.Optional(Type.String({ description: 'Optional tag to filter agents by (e.g. "coding", "search")' })),
+});
+
+const CallAcpAgentParams = Type.Object({
+  agent_id: Type.String({ description: 'ID of the ACP agent from the registry (from list_acp_agents)' }),
+  message: Type.String({ description: 'Natural language message to send to the ACP agent' }),
+});
+
+/* ── Tool Implementations ──────────────────────────────────────────────── */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const acpTools: AgentTool<any>[] = [
+  {
+    name: 'list_acp_agents',
+    label: 'List ACP Agents',
+    description: 'List available ACP (Agent Client Protocol) agents from the public registry. These are local subprocess-based agents like Gemini CLI, Claude, Copilot, etc. Optionally filter by tag.',
+    parameters: ListAcpAgentsParams,
+    execute: async (_id: string, params: Static<typeof ListAcpAgentsParams>) => {
+      try {
+        let agents = await getAcpAgents();
+
+        if (params.tag) {
+          const tag = params.tag.toLowerCase();
+          agents = agents.filter(a =>
+            a.tags?.some(t => t.toLowerCase().includes(tag))
+          );
+        }
+
+        if (agents.length === 0) {
+          return textResult(
+            params.tag
+              ? `No ACP agents found with tag "${params.tag}". Try list_acp_agents without a tag filter.`
+              : 'No ACP agents found in the registry. The registry may be unavailable.'
+          );
+        }
+
+        const lines = agents.map(a => {
+          const tags = a.tags?.join(', ') || 'none';
+          return `- **${a.name}** (id: \`${a.id}\`, transport: ${a.transport})\n  ${a.description}\n  Tags: ${tags}`;
+        });
+
+        return textResult(`Available ACP agents (${agents.length}):\n\n${lines.join('\n\n')}`);
+      } catch (err) {
+        return textResult(`Failed to list ACP agents: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'call_acp_agent',
+    label: 'Call ACP Agent',
+    description: 'Spawn an ACP agent, send it a message, and return the result. The agent runs as a local subprocess. Use list_acp_agents first to see available agents.',
+    parameters: CallAcpAgentParams,
+    execute: async (_id: string, params: Static<typeof CallAcpAgentParams>) => {
+      try {
+        const entry = await findAcpAgent(params.agent_id);
+        if (!entry) {
+          return textResult(`ACP agent not found: ${params.agent_id}. Use list_acp_agents to see available agents.`);
+        }
+
+        const cwd = getMindRoot();
+        const session = await createSessionFromEntry(entry, { cwd });
+
+        try {
+          const response = await prompt(session.id, params.message);
+          return textResult(
+            `**${entry.name}** responded:\n\n${response.text || '(empty response)'}`
+          );
+        } finally {
+          await closeSession(session.id).catch(() => {});
+        }
+      } catch (err) {
+        return textResult(`ACP call failed: ${(err as Error).message}`);
+      }
+    },
+  },
+];