@geminilight/mindos 0.6.25 → 0.7.0

package/app/components/renderers/workflow/WorkflowRenderer.tsx

@@ -3,6 +3,7 @@
 import { useMemo, useState, useRef, useCallback } from 'react';
 import { Play, SkipForward, RotateCcw, CheckCircle2, Circle, Loader2, AlertCircle, ChevronDown, Sparkles } from 'lucide-react';
 import type { RendererContext } from '@/lib/renderers/registry';
+import { useLocale } from '@/lib/LocaleContext';
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -171,6 +172,7 @@ function StepCard({
   onSkip: () => void;
   canRun: boolean;
 }) {
+  const { t } = useLocale();
   const [expanded, setExpanded] = useState(false);
   const hasBody = step.body.trim().length > 0;
   const hasOutput = step.output.length > 0;
@@ -201,6 +203,7 @@ function StepCard({
               <button
                 onClick={onRun}
                 disabled={!canRun}
+                title={!canRun ? t.hints.workflowStepRunning : undefined}
                 style={{
                   display: 'flex', alignItems: 'center', gap: 4,
                   padding: '3px 10px', borderRadius: 6, fontSize: '0.72rem',
@@ -268,6 +271,7 @@ function StepCard({
 // ─── Main renderer ────────────────────────────────────────────────────────────
 
 export function WorkflowRenderer({ filePath, content }: RendererContext) {
+  const { t } = useLocale();
   const parsed = useMemo(() => parseWorkflow(content), [content]);
   const [steps, setSteps] = useState<WorkflowStep[]>(() => parsed.steps);
   const [running, setRunning] = useState(false);
@@ -357,6 +361,7 @@ export function WorkflowRenderer({ filePath, content }: RendererContext) {
             <button
               onClick={() => runStep(nextPendingIdx)}
               disabled={running}
+              title={running ? t.hints.workflowRunning : undefined}
               style={{
                 display: 'flex', alignItems: 'center', gap: 5,
                 padding: '4px 12px', borderRadius: 7, fontSize: '0.75rem',

package/app/components/settings/AiTab.tsx

@@ -125,6 +125,7 @@ export function AiTab({ data, updateAi, updateAgent, t }: AiTabProps) {
         <button
           type="button"
           disabled={disabled}
+          title={disabled ? t.hints.testInProgressOrNoKey : undefined}
           onClick={() => handleTestKey(providerName)}
           className="inline-flex items-center gap-1.5 px-2.5 py-1 text-xs rounded-lg border border-border text-muted-foreground hover:text-foreground hover:border-foreground/20 transition-colors disabled:opacity-40 disabled:cursor-not-allowed"
         >

package/app/components/settings/KnowledgeTab.tsx

@@ -173,6 +173,7 @@ export function KnowledgeTab({ data, setData, t }: KnowledgeTabProps) {
           <button
             onClick={() => setShowCleanupConfirm(true)}
             disabled={cleaningUp}
+            title={cleaningUp ? t.hints.cleanupInProgress : undefined}
             className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg border border-border text-muted-foreground hover:text-foreground hover:bg-muted transition-colors shrink-0 disabled:opacity-50"
           >
             {cleaningUp ? <Loader2 size={12} className="animate-spin" /> : <Trash2 size={12} />}
@@ -249,6 +250,7 @@ export function KnowledgeTab({ data, setData, t }: KnowledgeTabProps) {
               type="button"
               onClick={handleResetToken}
               disabled={resetting}
+              title={resetting ? t.hints.tokenResetInProgress : undefined}
               className="flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border border-border text-muted-foreground hover:text-foreground hover:bg-muted disabled:opacity-40 disabled:cursor-not-allowed transition-colors"
             >
               <RefreshCw size={12} className={resetting ? 'animate-spin' : ''} />

package/app/components/settings/SyncTab.tsx

@@ -302,6 +302,7 @@ export function SyncTab({ t }: SyncTabProps) {
           type="button"
           onClick={handleSyncNow}
           disabled={syncing}
+          title={syncing ? t.hints.syncInProgress : undefined}
           className="flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border border-border text-muted-foreground hover:text-foreground hover:bg-muted disabled:opacity-40 disabled:cursor-not-allowed transition-colors"
         >
           <RefreshCw size={12} className={syncing ? 'animate-spin' : ''} />
@@ -311,6 +312,7 @@ export function SyncTab({ t }: SyncTabProps) {
           type="button"
           onClick={handleToggle}
           disabled={toggling}
+          title={toggling ? t.hints.toggleInProgress : undefined}
           className={`flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border transition-colors disabled:opacity-40 disabled:cursor-not-allowed ${
             status.enabled
               ? 'border-border text-muted-foreground hover:text-destructive hover:border-destructive/50'

package/app/components/setup/StepDots.tsx

@@ -1,5 +1,7 @@
 'use client';
 
+import { useLocale } from '@/lib/LocaleContext';
+
 export interface StepDotsProps {
   step: number;
   setStep: (s: number) => void;
@@ -8,6 +10,7 @@ export interface StepDotsProps {
 }
 
 export default function StepDots({ step, setStep, stepTitles, disabled }: StepDotsProps) {
+  const { t } = useLocale();
   return (
     <div className="flex items-center gap-2 mb-8" role="navigation" aria-label="Setup steps">
       {stepTitles.map((title: string, i: number) => (
@@ -17,7 +20,8 @@ export default function StepDots({ step, setStep, stepTitles, disabled }: StepDo
             aria-current={i === step ? 'step' : undefined}
             aria-label={title}
             className="flex flex-col items-center gap-1 p-1 -m-1 disabled:cursor-not-allowed disabled:opacity-60"
-            disabled={disabled || i >= step}>
+            disabled={disabled || i >= step}
+            title={(disabled || i >= step) ? t.hints.cannotJumpForward : undefined}>
             <div
               className="w-6 h-6 rounded-full text-xs font-medium flex items-center justify-center transition-colors"
               style={{

package/app/hooks/useA2aRegistry.ts

@@ -0,0 +1,53 @@
+'use client';
+
+import { useState, useCallback } from 'react';
+import type { RemoteAgent } from '@/lib/a2a/types';
+
+interface A2aRegistry {
+  agents: RemoteAgent[];
+  discovering: boolean;
+  error: string | null;
+  discover: (url: string) => Promise<RemoteAgent | null>;
+  refresh: () => void;
+}
+
+export function useA2aRegistry(): A2aRegistry {
+  const [agents, setAgents] = useState<RemoteAgent[]>([]);
+  const [discovering, setDiscovering] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const discover = useCallback(async (url: string): Promise<RemoteAgent | null> => {
+    setDiscovering(true);
+    setError(null);
+    try {
+      const res = await fetch('/api/a2a/discover', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ url }),
+      });
+      const data = await res.json();
+      if (data.agent) {
+        setAgents(prev => {
+          const exists = prev.some(a => a.id === data.agent.id);
+          if (exists) return prev.map(a => a.id === data.agent.id ? data.agent : a);
+          return [...prev, data.agent];
+        });
+        return data.agent as RemoteAgent;
+      }
+      setError(data.error || 'Discovery failed');
+      return null;
+    } catch (err) {
+      setError((err as Error).message);
+      return null;
+    } finally {
+      setDiscovering(false);
+    }
+  }, []);
+
+  const refresh = useCallback(() => {
+    setAgents([]);
+    setError(null);
+  }, []);
+
+  return { agents, discovering, error, discover, refresh };
+}

package/app/hooks/useAskSession.ts

@@ -78,13 +78,19 @@ export function useAskSession(currentFile?: string) {
   const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
   const persistTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
-  /** Load sessions from server, pick the matching one or create fresh. */
+  /** Load sessions from server, pick the matching one or create fresh. Prunes stale empty sessions. */
   const initSessions = useCallback(async () => {
-    const sorted = (await fetchSessions())
+    const all = (await fetchSessions())
       .sort((a, b) => b.updatedAt - a.updatedAt)
       .slice(0, MAX_SESSIONS);
-    setSessions(sorted);
 
+    // Prune any empty sessions that leaked to server (from older versions)
+    const emptyIds = all.filter((s) => s.messages.length === 0).map((s) => s.id);
+    const sorted = emptyIds.length > 0 ? all.filter((s) => !emptyIds.includes(s.id)) : all;
+    if (emptyIds.length > 0) void removeSessions(emptyIds);
+
+    // Always prepend a fresh empty session in memory (never persisted until first message)
+    const fresh = createSession(currentFile);
     const matched = currentFile
       ? sorted.find((sess) => sess.currentFile === currentFile)
       : sorted[0];
@@ -92,20 +98,19 @@ export function useAskSession(currentFile?: string) {
     if (matched) {
       setActiveSessionId(matched.id);
       setMessages(matched.messages);
+      setSessions([...sorted]);
     } else {
-      const fresh = createSession(currentFile);
       setActiveSessionId(fresh.id);
       setMessages([]);
-      const next = [fresh, ...sorted].slice(0, MAX_SESSIONS);
-      setSessions(next);
-      await upsertSession(fresh);
+      // Empty session lives only in memory — no upsertSession call
+      setSessions([fresh, ...sorted].slice(0, MAX_SESSIONS));
     }
   }, [currentFile]);
 
-  /** Persist current session (debounced). */
+  /** Persist current session (debounced). Only persists if session has messages. */
   const persistSession = useCallback(
     (msgs: Message[], sessionId: string | null) => {
-      if (!sessionId) return;
+      if (!sessionId || msgs.length === 0) return;
       let sessionToPersist: ChatSession | null = null;
       setSessions((prev) => {
         const now = Date.now();
@@ -135,35 +140,48 @@ export function useAskSession(currentFile?: string) {
     }
   }, []);
 
-  /** Create a brand-new session. */
+  /** Create a brand-new session (memory only). If current session is already empty, reuse it. */
   const resetSession = useCallback(() => {
-    const fresh = createSession(currentFile);
-    setActiveSessionId(fresh.id);
-    setMessages([]);
     setSessions((prev) => {
-      const next = [fresh, ...prev]
+      const active = prev.find((s) => s.id === activeSessionId);
+      // Already on an empty session — just clear input, don't create another
+      if (active && active.messages.length === 0) return prev;
+
+      const fresh = createSession(currentFile);
+      setActiveSessionId(fresh.id);
+      setMessages([]);
+      // Memory only — no upsertSession call. Will be persisted on first message.
+      return [fresh, ...prev]
         .sort((a, b) => b.updatedAt - a.updatedAt)
         .slice(0, MAX_SESSIONS);
-      void upsertSession(fresh);
-      return next;
     });
-  }, [currentFile]);
+  }, [currentFile, activeSessionId]);
 
-  /** Switch to an existing session. */
+  /** Switch to an existing session. Auto-drops abandoned empty sessions from memory. */
   const loadSession = useCallback(
     (id: string) => {
       const target = sessions.find((s) => s.id === id);
       if (!target) return;
+
+      // Drop the session we're leaving if it's empty (it was never persisted, just remove from memory)
+      const leaving = activeSessionId ? sessions.find((s) => s.id === activeSessionId) : null;
+      if (leaving && leaving.messages.length === 0 && leaving.id !== id) {
+        setSessions((prev) => prev.filter((s) => s.id !== leaving.id));
+      }
+
       setActiveSessionId(target.id);
       setMessages(target.messages);
     },
-    [sessions],
+    [sessions, activeSessionId],
   );
 
-  /** Delete a session. If it's the active one, create fresh. */
+  /** Delete a session. If it's the active one, create fresh (memory only). */
   const deleteSession = useCallback(
     (id: string) => {
-      void removeSession(id);
+      const target = sessions.find((s) => s.id === id);
+      // Only call removeSession if the session has messages (i.e. was persisted)
+      if (target && target.messages.length > 0) void removeSession(id);
+
       const remaining = sessions.filter((s) => s.id !== id);
       setSessions(remaining);
 
@@ -172,21 +190,22 @@ export function useAskSession(currentFile?: string) {
         setActiveSessionId(fresh.id);
         setMessages([]);
         setSessions([fresh, ...remaining].slice(0, MAX_SESSIONS));
-        void upsertSession(fresh);
+        // No upsertSession — memory only
       }
     },
     [activeSessionId, currentFile, sessions],
   );
 
   const clearAllSessions = useCallback(() => {
-    const allIds = sessions.map(s => s.id);
-    void removeSessions(allIds);
+    // Only delete sessions that have messages (were persisted)
+    const persistedIds = sessions.filter(s => s.messages.length > 0).map(s => s.id);
+    if (persistedIds.length > 0) void removeSessions(persistedIds);
 
     const fresh = createSession(currentFile);
     setActiveSessionId(fresh.id);
     setMessages([]);
     setSessions([fresh]);
-    void upsertSession(fresh);
+    // No upsertSession — memory only
   }, [currentFile, sessions]);
 
   return {

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

@@ -0,0 +1,212 @@
+/**
+ * A2A Agent Tools — Expose A2A client capabilities as tools
+ * for the MindOS built-in agent to discover and delegate to external agents.
+ */
+
+import { Type, type Static } from '@sinclair/typebox';
+import type { AgentTool } from '@mariozechner/pi-agent-core';
+import {
+  discoverAgent,
+  discoverAgents,
+  delegateTask,
+  checkRemoteTaskStatus,
+  getDiscoveredAgents,
+} from './client';
+import { createPlan, executePlan } from './orchestrator';
+
+function textResult(text: string) {
+  return { content: [{ type: 'text' as const, text }], details: {} };
+}
+
+/* ── Parameter Schemas ─────────────────────────────────────────────────── */
+
+const DiscoverAgentParams = Type.Object({
+  url: Type.String({ description: 'Base URL of the agent to discover (e.g. http://localhost:3456)' }),
+});
+
+const DiscoverMultipleParams = Type.Object({
+  urls: Type.Array(Type.String(), { description: 'List of base URLs to discover agents from' }),
+});
+
+const DelegateParams = Type.Object({
+  agent_id: Type.String({ description: 'ID of the target agent (from list_remote_agents)' }),
+  message: Type.String({ description: 'Natural language message to send to the agent' }),
+});
+
+const CheckStatusParams = Type.Object({
+  agent_id: Type.String({ description: 'ID of the agent that owns the task' }),
+  task_id: Type.String({ description: 'Task ID returned by delegate_to_agent' }),
+});
+
+const OrchestrateParams = Type.Object({
+  request: Type.String({ description: 'The complex request to decompose and execute across multiple agents' }),
+  subtasks: Type.Optional(Type.Array(Type.String(), { description: 'Pre-decomposed subtask descriptions. If omitted, auto-decomposition is used.' })),
+  strategy: Type.Optional(Type.Union([
+    Type.Literal('parallel'),
+    Type.Literal('sequential'),
+  ], { description: 'Execution strategy: parallel (default) or sequential', default: 'parallel' })),
+});
+
+/* ── Tool Implementations ──────────────────────────────────────────────── */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const a2aTools: AgentTool<any>[] = [
+  {
+    name: 'list_remote_agents',
+    label: 'List Remote Agents',
+    description: 'List all discovered remote A2A agents and their capabilities. Shows agent ID, name, skills, and reachability status. Call discover_agent first to add agents.',
+    parameters: Type.Object({}),
+    execute: async (_id: string) => {
+      const agents = getDiscoveredAgents();
+      if (agents.length === 0) {
+        return textResult('No remote agents discovered yet. Use discover_agent with a URL to find agents.');
+      }
+      const lines = agents.map(a => {
+        const skills = a.card.skills.map(s => s.name).join(', ');
+        const status = a.reachable ? 'reachable' : 'unreachable';
+        return `- **${a.card.name}** (id: ${a.id}, ${status})\n  Skills: ${skills || 'none declared'}`;
+      });
+      return textResult(`Discovered agents:\n\n${lines.join('\n\n')}`);
+    },
+  },
+
+  {
+    name: 'discover_agent',
+    label: 'Discover Remote Agent',
+    description: 'Discover a remote A2A agent by fetching its agent card from the given URL. The agent card describes the agent\'s capabilities and skills.',
+    parameters: DiscoverAgentParams,
+    execute: async (_id: string, params: Static<typeof DiscoverAgentParams>) => {
+      try {
+        const agent = await discoverAgent(params.url);
+        if (!agent) {
+          return textResult(`No A2A agent found at ${params.url}. The server may not support the A2A protocol.`);
+        }
+        const skills = agent.card.skills.map(s => `  - ${s.name}: ${s.description}`).join('\n');
+        return textResult(
+          `Discovered agent: **${agent.card.name}** (v${agent.card.version})\n` +
+          `ID: ${agent.id}\n` +
+          `Description: ${agent.card.description}\n` +
+          `Endpoint: ${agent.endpoint}\n` +
+          `Skills:\n${skills || '  (none declared)'}`
+        );
+      } catch (err) {
+        return textResult(`Failed to discover agent at ${params.url}: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'discover_agents',
+    label: 'Discover Multiple Agents',
+    description: 'Discover multiple remote A2A agents by fetching their agent cards concurrently. Returns all successfully discovered agents.',
+    parameters: DiscoverMultipleParams,
+    execute: async (_id: string, params: Static<typeof DiscoverMultipleParams>) => {
+      try {
+        const agents = await discoverAgents(params.urls);
+        if (agents.length === 0) {
+          return textResult(`No A2A agents found at any of the ${params.urls.length} URLs.`);
+        }
+        const lines = agents.map(a =>
+          `- **${a.card.name}** (id: ${a.id}) — ${a.card.skills.length} skills`
+        );
+        return textResult(`Discovered ${agents.length}/${params.urls.length} agents:\n\n${lines.join('\n')}`);
+      } catch (err) {
+        return textResult(`Discovery failed: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'delegate_to_agent',
+    label: 'Delegate Task to Agent',
+    description: 'Send a task to a remote A2A agent. The agent will process the message and return a result. Use list_remote_agents to see available agents and their skills first.',
+    parameters: DelegateParams,
+    execute: async (_id: string, params: Static<typeof DelegateParams>) => {
+      try {
+        const task = await delegateTask(params.agent_id, params.message);
+
+        if (task.status.state === 'TASK_STATE_COMPLETED') {
+          const result = task.artifacts?.[0]?.parts?.[0]?.text
+            ?? task.history?.find(m => m.role === 'ROLE_AGENT')?.parts?.[0]?.text
+            ?? 'Task completed (no text result)';
+          return textResult(`Agent completed task (id: ${task.id}):\n\n${result}`);
+        }
+
+        if (task.status.state === 'TASK_STATE_FAILED') {
+          const errMsg = task.status.message?.parts?.[0]?.text ?? 'Unknown error';
+          return textResult(`Agent failed task (id: ${task.id}): ${errMsg}`);
+        }
+
+        // Task is still in progress (non-blocking)
+        return textResult(
+          `Task submitted (id: ${task.id}, state: ${task.status.state}).\n` +
+          `Use check_task_status to poll for completion.`
+        );
+      } catch (err) {
+        return textResult(`Delegation failed: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'check_task_status',
+    label: 'Check Remote Task Status',
+    description: 'Check the status of a task previously delegated to a remote agent. Returns the current state, any results, or error information.',
+    parameters: CheckStatusParams,
+    execute: async (_id: string, params: Static<typeof CheckStatusParams>) => {
+      try {
+        const task = await checkRemoteTaskStatus(params.agent_id, params.task_id);
+
+        const state = task.status.state;
+        if (state === 'TASK_STATE_COMPLETED') {
+          const result = task.artifacts?.[0]?.parts?.[0]?.text ?? 'Completed (no text)';
+          return textResult(`Task ${params.task_id} completed:\n\n${result}`);
+        }
+        if (state === 'TASK_STATE_FAILED') {
+          const errMsg = task.status.message?.parts?.[0]?.text ?? 'Unknown error';
+          return textResult(`Task ${params.task_id} failed: ${errMsg}`);
+        }
+
+        return textResult(`Task ${params.task_id} state: ${state}`);
+      } catch (err) {
+        return textResult(`Status check failed: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'orchestrate',
+    label: 'Orchestrate Multi-Agent Task',
+    description: 'Decompose a complex request into subtasks and execute them across multiple remote agents. Auto-matches subtasks to the best available agent based on skills. Use discover_agent first to register agents.',
+    parameters: OrchestrateParams,
+    execute: async (_id: string, params: Static<typeof OrchestrateParams>) => {
+      try {
+        const strategy = params.strategy ?? 'parallel';
+        const plan = createPlan(params.request, strategy, params.subtasks);
+
+        const assigned = plan.subtasks.filter(st => st.assignedAgentId);
+        if (assigned.length === 0) {
+          return textResult(
+            `Created plan with ${plan.subtasks.length} subtasks but no agents matched any skill.\n` +
+            `Subtasks: ${plan.subtasks.map(st => st.description).join(', ')}\n\n` +
+            'Discover agents first using discover_agent, then retry.'
+          );
+        }
+
+        const result = await executePlan(plan);
+
+        const summary = plan.subtasks.map(st => {
+          const icon = st.status === 'completed' ? '[OK]' : st.status === 'failed' ? '[FAIL]' : '[?]';
+          return `${icon} ${st.description}`;
+        }).join('\n');
+
+        return textResult(
+          `Orchestration ${result.status} (${strategy}, ${plan.subtasks.length} subtasks):\n\n` +
+          `${summary}\n\n---\n\n${result.aggregatedResult ?? '(no result)'}`
+        );
+      } catch (err) {
+        return textResult(`Orchestration failed: ${(err as Error).message}`);
+      }
+    },
+  },
+];