agents-dojo 0.1.6 → 0.1.7

package/monitor/src/lib/interactables.ts

@@ -0,0 +1,162 @@
+/**
+ * Interactable framework — unified system for objects that agents interact with.
+ *
+ * Each interactable defines:
+ *   - Its position and collision shape
+ *   - Where the agent should stand/sit to interact
+ *   - What animation the agent plays during interaction
+ *   - What animation the object plays when interacted with
+ *
+ * To add a new interactable type:
+ *   1. Add an entry to INTERACTABLE_DEFS below
+ *   2. Create a sprite component using the InteractableSprite helper
+ *   3. Register it in Stage.tsx
+ */
+
+import positionsData from '../../public/positions.json';
+
+// ── Types ──────────────────────────────────────────────────
+
+export type InteractableType = 'stake' | 'cushion';
+
+export interface InteractableDef {
+  type: InteractableType;
+
+  /** Anchor position in design coords (where the object sits) */
+  anchorX: number;
+  anchorY: number;
+
+  /** Where the agent should move to interact (feet position) */
+  agentX: number;
+  agentY: number;
+
+  /** Which direction the agent faces during interaction (true = face left) */
+  agentFaceLeft: boolean;
+
+  /** Agent animation during interaction */
+  agentAnim: 'sit' | 'attack' | 'idle';
+
+  /** Collision radius for wander avoidance */
+  collisionRadius: number;
+
+  /** Sprite file path */
+  spriteFile: string;
+
+  /** Original pixel dimensions (for scaling to design space) */
+  origW: number;
+  origH: number;
+
+  /** Rendering: anchor point of the sprite */
+  spriteAnchorX: number;
+  spriteAnchorY: number;
+
+  /** Rendering: y position for the sprite */
+  spriteY: number;
+
+  /** Index for matching to agent assignments */
+  index: number;
+}
+
+// ── Constants ──────────────────────────────────────────────
+
+const DS = 960 / 2400; // design scale factor
+
+// Stake: 104px wide in original → 41.6px design → half = ~21px
+const STAKE_HALF_W = 21;
+const STAKE_AGENT_GAP = 4;  // gap between agent and stake edge
+const STAKE_AGENT_OFFSET_X = STAKE_HALF_W + STAKE_AGENT_GAP; // 25px
+
+// Cushion: agent sits slightly above cushion center so body overlaps the cushion
+const CUSHION_SIT_OFFSET_Y = 2;
+
+// ── Build interactable list from positions data ────────────
+
+export const INTERACTABLES: InteractableDef[] = [];
+
+// Stakes
+for (let i = 0; i < positionsData.stakes.length; i++) {
+  const s = positionsData.stakes[i];
+  INTERACTABLES.push({
+    type: 'stake',
+    anchorX: s.x,
+    anchorY: (s.y_top + s.y_bot) / 2,
+    // Agent stands beside stake, feet at stake bottom y
+    agentX: s.x + STAKE_AGENT_OFFSET_X,
+    agentY: s.y_bot,
+    agentFaceLeft: true,
+    agentAnim: 'attack',
+    collisionRadius: 20,
+    spriteFile: `/sprites/stake_${i}.png`,
+    origW: s.w,
+    origH: s.h,
+    spriteAnchorX: 0.5,
+    spriteAnchorY: 0,
+    spriteY: s.y_top,
+    index: i,
+  });
+}
+
+// Cushions (skip the 11th lone cushion if > 10 agents)
+const cushionCount = Math.min(positionsData.cushions.length, 10);
+for (let i = 0; i < cushionCount; i++) {
+  const c = positionsData.cushions[i];
+  INTERACTABLES.push({
+    type: 'cushion',
+    anchorX: c.x,
+    anchorY: c.y,
+    // Agent sits at cushion center x, shifted down for overlap
+    agentX: c.x,
+    agentY: c.y + CUSHION_SIT_OFFSET_Y,
+    agentFaceLeft: false,
+    agentAnim: 'sit',
+    collisionRadius: 18,
+    spriteFile: `/sprites/cushion_${i}.png`,
+    origW: c.w,
+    origH: c.h,
+    spriteAnchorX: 0.5,
+    spriteAnchorY: 0.5,
+    spriteY: c.y,
+    index: i,
+  });
+}
+
+// ── Helpers for agent assignment ───────────────────────────
+
+/** Get all interactables of a given type, sorted by index */
+export function getByType(type: InteractableType): InteractableDef[] {
+  return INTERACTABLES.filter((i) => i.type === type).sort((a, b) => a.index - b.index);
+}
+
+/** Get obstacles for wander collision avoidance */
+export function getObstacles(): Array<{ x: number; y: number; r: number }> {
+  return INTERACTABLES.map((i) => ({ x: i.anchorX, y: i.anchorY, r: i.collisionRadius }));
+}
+
+/** Pair cushions and stakes 1:1 by proximity (returns paired arrays) */
+export function getPairedPositions(): Array<{
+  cushion: InteractableDef;
+  stake: InteractableDef;
+}> {
+  const cushions = getByType('cushion');
+  const stakes = getByType('stake');
+  const usedStakes = new Set<number>();
+  const pairs: Array<{ cushion: InteractableDef; stake: InteractableDef }> = [];
+
+  for (const c of cushions) {
+    let bestIdx = -1;
+    let bestDist = Infinity;
+    for (let j = 0; j < stakes.length; j++) {
+      if (usedStakes.has(j)) continue;
+      const dist = Math.abs(stakes[j].anchorX - c.anchorX);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestIdx = j;
+      }
+    }
+    if (bestIdx >= 0) {
+      usedStakes.add(bestIdx);
+      pairs.push({ cushion: c, stake: stakes[bestIdx] });
+    }
+  }
+  return pairs;
+}

package/monitor/src/lib/store.ts

@@ -0,0 +1,352 @@
+import { create } from 'zustand';
+import type { Agent, AgentState, AgentAnim, ChatSession, MessageLink, MonitorEvent, UserChat, ChatMessage } from './types.js';
+import { getPairedPositions } from './interactables.js';
+
+const PAIRED = getPairedPositions();
+
+// ── localStorage persistence (position + state) ────────────
+
+const STORAGE_KEY = 'dojo-monitor-agents';
+
+interface SavedAgent {
+  position: { x: number; y: number };
+  state: AgentState;
+  taskFrom?: string;
+}
+
+function loadSavedAgents(): Map<string, SavedAgent> {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return new Map();
+    const obj = JSON.parse(raw) as Record<string, SavedAgent>;
+    return new Map(Object.entries(obj));
+  } catch { return new Map(); }
+}
+
+let saveTimer: ReturnType<typeof setTimeout> | null = null;
+function scheduleSave(agents: Map<string, Agent>) {
+  if (saveTimer) return; // already scheduled
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    try {
+      const obj: Record<string, SavedAgent> = {};
+      for (const [id, a] of agents) {
+        obj[id] = { position: a.position, state: a.state, taskFrom: a.taskFrom };
+      }
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(obj));
+    } catch { /* ignore quota errors */ }
+  }, 500);
+}
+
+interface MonitorStore {
+  agents: Map<string, Agent>;
+  links: Map<string, MessageLink>;
+  chatSessions: Map<string, ChatSession>;
+  taskToAgent: Map<string, string>;
+  connected: boolean;
+  agentIndex: number;
+
+  // User chat (monitor GUI → agent)
+  userChat: UserChat | null;
+  // Master bubble message (client's message shown on master sprite)
+  masterMessage: string | null;
+  // Context menu
+  menuAgentId: string | null;
+  menuPosition: { x: number; y: number } | null;
+
+  applyEvent: (event: MonitorEvent) => void;
+  setConnected: (b: boolean) => void;
+  setPosition: (id: string, x: number, y: number) => void;
+  setAnim: (id: string, anim: AgentAnim) => void;
+
+  // Chat session API
+  createChatSession: (session: ChatSession) => void;
+  endChatSession: (sessionId: string) => void;
+  getAgentSession: (agentId: string) => ChatSession | undefined;
+
+  // User chat actions
+  openChat: (agentId: string) => void;
+  closeChat: () => void;
+  addChatMessage: (msg: ChatMessage) => void;
+  setChatLoading: (loading: boolean) => void;
+
+  // Context menu actions
+  openMenu: (agentId: string, x: number, y: number) => void;
+  closeMenu: () => void;
+}
+
+/**
+ * Compute where each member stands around the meetPoint.
+ * Members form a circle/line around the center point.
+ */
+export function getChatPosition(meetPoint: { x: number; y: number }, memberIndex: number, totalMembers: number): { x: number; y: number } {
+  const SPACING = 30;
+  if (totalMembers <= 2) {
+    // Two people: side by side
+    const offset = memberIndex === 0 ? -SPACING / 2 : SPACING / 2;
+    return { x: meetPoint.x + offset, y: meetPoint.y };
+  }
+  // N people: arrange in a circle
+  const angle = (2 * Math.PI * memberIndex) / totalMembers - Math.PI / 2;
+  const radius = SPACING;
+  return {
+    x: meetPoint.x + Math.cos(angle) * radius,
+    y: meetPoint.y + Math.sin(angle) * radius * 0.6, // squash y for pseudo-isometric
+  };
+}
+
+export const useMonitorStore = create<MonitorStore>((set, get) => {
+  if (typeof window !== 'undefined') {
+    (window as any).__DOJO_STORE__ = { getState: () => get() };
+  }
+  return ({
+  agents: new Map(),
+  links: new Map(),
+  chatSessions: new Map(),
+  taskToAgent: new Map(),
+  connected: false,
+  agentIndex: 0,
+  userChat: null,
+  masterMessage: null,
+  menuAgentId: null,
+  menuPosition: null,
+
+  setConnected: (b) => set({ connected: b }),
+
+  setPosition: (id, x, y) => {
+    const a = get().agents.get(id);
+    // Skip if position hasn't actually changed (avoids unnecessary re-renders)
+    if (!a || (Math.abs(a.position.x - x) < 0.5 && Math.abs(a.position.y - y) < 0.5)) return;
+    const agents = new Map(get().agents);
+    agents.set(id, { ...a, position: { x, y } });
+    set({ agents });
+    scheduleSave(agents);
+  },
+
+  setAnim: (id, anim) => {
+    const agents = new Map(get().agents);
+    const a = agents.get(id);
+    if (a && a.currentAnim !== anim) {
+      agents.set(id, { ...a, currentAnim: anim });
+      set({ agents });
+    }
+  },
+
+  createChatSession: (session) => {
+    const sessions = new Map(get().chatSessions);
+    const agents = new Map(get().agents);
+    sessions.set(session.id, session);
+    // Tag each member with the session ID
+    for (const mid of session.memberIds) {
+      const a = agents.get(mid);
+      if (a) agents.set(mid, { ...a, chatSessionId: session.id });
+    }
+    set({ chatSessions: sessions, agents });
+  },
+
+  endChatSession: (sessionId) => {
+    const sessions = new Map(get().chatSessions);
+    const agents = new Map(get().agents);
+    const session = sessions.get(sessionId);
+    if (session) {
+      for (const mid of session.memberIds) {
+        const a = agents.get(mid);
+        if (a) agents.set(mid, { ...a, chatSessionId: undefined });
+      }
+      sessions.delete(sessionId);
+    }
+    set({ chatSessions: sessions, agents });
+  },
+
+  getAgentSession: (agentId) => {
+    const a = get().agents.get(agentId);
+    if (!a?.chatSessionId) return undefined;
+    return get().chatSessions.get(a.chatSessionId);
+  },
+
+  // User chat actions
+  openChat: (agentId) => set({ userChat: { agentId, messages: [], loading: false }, menuAgentId: null, menuPosition: null }),
+  closeChat: () => set({ userChat: null }),
+  addChatMessage: (msg) => {
+    const chat = get().userChat;
+    if (!chat) return;
+    set({ userChat: { ...chat, messages: [...chat.messages, msg] } });
+  },
+  setChatLoading: (loading) => {
+    const chat = get().userChat;
+    if (!chat) return;
+    set({ userChat: { ...chat, loading } });
+  },
+
+  // Context menu actions
+  openMenu: (agentId, x, y) => set({ menuAgentId: agentId, menuPosition: { x, y } }),
+  closeMenu: () => set({ menuAgentId: null, menuPosition: null }),
+
+  applyEvent: (event) => {
+    const agents = new Map(get().agents);
+    const links = new Map(get().links);
+    const taskToAgent = new Map(get().taskToAgent);
+
+    switch (event.type) {
+      case 'agent_loaded': {
+        if (!agents.has(event.agentId)) {
+          const idx = get().agentIndex;
+          const pair = PAIRED[idx % PAIRED.length];
+          const home = { x: pair.cushion.agentX, y: pair.cushion.agentY };
+          const saved = loadSavedAgents().get(event.agentId);
+          agents.set(event.agentId, {
+            id: event.agentId,
+            position: saved?.position ?? { ...home },
+            homePosition: { ...home },
+            stakePosition: { x: pair.stake.anchorX, y: pair.stake.agentY },
+            sprite: 'default',
+            state: saved?.state ?? 'idle',
+            currentAnim: 'idle',
+            taskFrom: saved?.taskFrom,
+          });
+          set({ agentIndex: idx + 1 });
+        }
+        break;
+      }
+      case 'task_created': {
+        taskToAgent.set(event.taskId, event.to);
+
+        // Detect agent-to-agent call: if another agent is currently working/tool_call,
+        // it likely called this agent via the call-agent skill.
+        let callerAgentId: string | undefined;
+        for (const [id, a] of agents) {
+          if (id !== event.to && (a.state === 'working' || a.state === 'tool_call')) {
+            callerAgentId = id;
+            break;
+          }
+        }
+
+        const fromId = callerAgentId ?? event.from;
+        const link: MessageLink = {
+          id: event.taskId,
+          from: fromId,
+          to: event.to,
+          preview: event.preview, startTime: Date.now(), taskId: event.taskId,
+        };
+        links.set(link.id, link);
+        const to = agents.get(event.to);
+        // Client's message is shown on master, not on the agent
+        if (!callerAgentId) {
+          set({ masterMessage: event.preview });
+        }
+        if (to) agents.set(to.id, { ...to, state: 'submitted', taskFrom: fromId });
+        if (callerAgentId) {
+          // Agent-to-agent call — create a chat session
+          const sessionId = `peer-${event.taskId}`;
+          const meetPoint = {
+            x: ((agents.get(callerAgentId)?.position.x ?? 480) + (to?.position.x ?? 480)) / 2,
+            y: Math.max(agents.get(callerAgentId)?.position.y ?? 400, to?.position.y ?? 400),
+          };
+          const chatSessions = new Map(get().chatSessions);
+          chatSessions.set(sessionId, {
+            id: sessionId,
+            initiatorId: callerAgentId,
+            memberIds: [callerAgentId, event.to],
+            meetPoint,
+            duration: 30000,
+            startTime: Date.now(),
+          });
+          agents.set(callerAgentId, { ...agents.get(callerAgentId)!, chatSessionId: sessionId });
+          if (to) agents.set(to.id, { ...to, state: 'submitted', taskFrom: fromId, chatSessionId: sessionId });
+          set({ chatSessions });
+        }
+        break;
+      }
+      case 'task_status': {
+        const targetId = taskToAgent.get(event.taskId);
+        if (targetId) {
+          const agent = agents.get(targetId);
+          if (agent) {
+            let newState: AgentState;
+            switch (event.state) {
+              case 'submitted': newState = 'submitted'; break;
+              case 'working': newState = 'working'; break;
+              case 'completed': newState = 'completed'; break;
+              case 'failed': newState = 'failed'; break;
+              case 'canceled': newState = 'canceled'; break;
+              case 'rejected': newState = 'rejected'; break;
+              case 'input-required': newState = 'input-required'; break;
+              case 'auth-required': newState = 'auth-required'; break;
+              default: newState = 'idle';
+            }
+            const msg = event.message ?? agent.lastMessage;
+            agents.set(targetId, { ...agent, state: newState, lastMessage: msg });
+          }
+        }
+        const terminalStates = ['completed', 'failed', 'canceled', 'rejected'];
+        if (terminalStates.includes(event.state)) {
+          // Clear master bubble on task end
+          set({ masterMessage: null });
+
+          // End any peer chat session associated with this task
+          const peerSessionId = `peer-${event.taskId}`;
+          if (get().chatSessions.has(peerSessionId)) {
+            setTimeout(() => {
+              useMonitorStore.getState().endChatSession(peerSessionId);
+            }, 1500);
+          }
+
+          for (const [id, link] of links) {
+            if (link.taskId === event.taskId) {
+              setTimeout(() => {
+                const s = useMonitorStore.getState();
+                const newLinks = new Map(s.links);
+                newLinks.delete(id);
+                const newAgents = new Map(s.agents);
+                if (targetId) {
+                  const a = newAgents.get(targetId);
+                  if (a && (a.state === 'completed' || a.state === 'failed' || a.state === 'canceled' || a.state === 'rejected')) {
+                    newAgents.set(targetId, { ...a, state: 'idle', lastToolName: undefined, chatSessionId: undefined, lastMessage: undefined, taskFrom: undefined });
+                  }
+                }
+                useMonitorStore.setState({ links: newLinks, agents: newAgents });
+              }, 3000);
+            }
+          }
+          setTimeout(() => {
+            const newMap = new Map(useMonitorStore.getState().taskToAgent);
+            newMap.delete(event.taskId);
+            useMonitorStore.setState({ taskToAgent: newMap });
+          }, 5000);
+        }
+        break;
+      }
+      case 'tool_call_start': {
+        const targetId = taskToAgent.get(event.taskId);
+        if (targetId) {
+          const agent = agents.get(targetId);
+          if (agent) agents.set(targetId, { ...agent, state: 'tool_call', lastToolName: event.toolName });
+        }
+        break;
+      }
+      case 'tool_call_end': {
+        const targetId = taskToAgent.get(event.taskId);
+        if (targetId) {
+          const agent = agents.get(targetId);
+          if (agent && agent.state === 'tool_call') agents.set(targetId, { ...agent, state: 'working', lastToolName: undefined });
+        }
+        break;
+      }
+      case 'chat_response': {
+        const chat = get().userChat;
+        if (chat && chat.agentId === event.agentId) {
+          const newChat = {
+            ...chat,
+            messages: [...chat.messages, { role: 'agent' as const, text: event.text }],
+            loading: event.final ? false : chat.loading,
+          };
+          set({ userChat: newChat });
+        }
+        break;
+      }
+    }
+
+    set({ agents, links, taskToAgent });
+    scheduleSave(agents);
+  },
+})});

package/monitor/src/lib/types.ts

@@ -0,0 +1,72 @@
+export type MonitorEvent =
+  | { type: 'agent_loaded'; agentId: string; position?: { x: number; y: number } }
+  | { type: 'agent_reloaded'; agentId: string }
+  | { type: 'task_created'; taskId: string; contextId: string; from: string; to: string; preview: string }
+  | { type: 'task_status'; taskId: string; state: string; message?: string }
+  | { type: 'tool_call_start'; taskId: string; toolName: string; inputSummary: string }
+  | { type: 'tool_call_end'; taskId: string; toolName: string; success: boolean }
+  | { type: 'chat_response'; chatId: string; agentId: string; text: string; final: boolean };
+
+export type AgentState =
+  | 'idle'
+  | 'submitted'        // task just received, walking to master
+  | 'working'          // executing task (attack or chat depending on context)
+  | 'tool_call'        // working sub-state: calling a tool
+  | 'input-required'   // paused, waiting for client input (walk back to master)
+  | 'auth-required'    // paused, waiting for auth (same as input-required)
+  | 'completed'        // task done, walking home
+  | 'failed'           // task failed, shake-hand then walk home
+  | 'canceled'         // task canceled by client, walk home
+  | 'rejected';        // agent refused the task, shake head at master
+
+export type AgentAnim = 'idle' | 'walk' | 'sit' | 'attack' | 'chat' | 'daydream' | 'shake_hand' | 'head_shake';
+
+/**
+ * A chat session between N agents.
+ * - initiatorId creates the session and invites others
+ * - memberIds includes all participants (initiator + invitees)
+ * - meetPoint is where everyone walks to
+ * - Each member gets a position offset around the meetPoint (computed from index)
+ */
+export interface ChatSession {
+  id: string;
+  initiatorId: string;
+  memberIds: string[];
+  meetPoint: { x: number; y: number };
+  duration: number;
+  startTime: number;
+}
+
+export interface Agent {
+  id: string;
+  position: { x: number; y: number };
+  homePosition: { x: number; y: number };
+  stakePosition: { x: number; y: number };
+  sprite: string;
+  state: AgentState;
+  currentAnim: AgentAnim;
+  chatSessionId?: string;        // ID of the chat session this agent is in
+  taskFrom?: string;             // 'user' for client calls, agent-id for agent-to-agent calls
+  lastToolName?: string;
+  lastMessage?: string;
+}
+
+export interface MessageLink {
+  id: string;
+  from: string;
+  to: string;
+  preview: string;
+  startTime: number;
+  taskId: string;
+}
+
+export interface ChatMessage {
+  role: 'user' | 'agent';
+  text: string;
+}
+
+export interface UserChat {
+  agentId: string;
+  messages: ChatMessage[];
+  loading: boolean;
+}

package/monitor/src/lib/ws-client.ts

@@ -0,0 +1,66 @@
+import { useMonitorStore } from './store.js';
+import type { MonitorEvent } from './types.js';
+
+const WS_URL = import.meta.env.VITE_MONITOR_WS_URL || 'ws://localhost:41242/monitor';
+
+/** Shared persistent connection for both events and commands. */
+let sharedWs: WebSocket | null = null;
+
+export function connectWs(): () => void {
+  const ws = new WebSocket(WS_URL);
+  sharedWs = ws;
+
+  ws.addEventListener('open', () => {
+    useMonitorStore.setState({ connected: true });
+  });
+  ws.addEventListener('close', () => {
+    // Only clear sharedWs if it's still pointing to this instance
+    // (avoids race with StrictMode double-mount)
+    if (sharedWs === ws) {
+      sharedWs = null;
+    }
+    useMonitorStore.setState({ connected: false });
+  });
+  ws.addEventListener('error', () => {
+    useMonitorStore.setState({ connected: false });
+  });
+  ws.addEventListener('message', (e) => {
+    try {
+      const event = JSON.parse(e.data) as MonitorEvent;
+      useMonitorStore.getState().applyEvent(event);
+    } catch (err) {
+      console.error('[ws-client] bad message:', err);
+    }
+  });
+
+  return () => ws.close();
+}
+
+export function sendCommand(cmd: object): void {
+  if (sharedWs && sharedWs.readyState === WebSocket.OPEN) {
+    sharedWs.send(JSON.stringify(cmd));
+    return;
+  }
+  // Fallback: open a one-shot connection
+  const ws = new WebSocket(WS_URL);
+  ws.addEventListener('open', () => {
+    ws.send(JSON.stringify(cmd));
+    ws.close();
+  });
+}
+
+let chatIdCounter = 0;
+
+/** Send a chat message to an agent and receive the response via store events. */
+export function sendChatMessage(agentId: string, message: string): string {
+  const chatId = `chat-${Date.now()}-${++chatIdCounter}`;
+  useMonitorStore.getState().addChatMessage({ role: 'user', text: message });
+  useMonitorStore.getState().setChatLoading(true);
+  sendCommand({ type: 'chat', chatId, agentId, message });
+  return chatId;
+}
+
+// Expose for E2E testing
+if (typeof window !== 'undefined') {
+  (window as any).__DOJO_SEND_CHAT__ = sendChatMessage;
+}

package/monitor/src/main.tsx

@@ -0,0 +1,9 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { App } from './App.js';
+
+createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);

package/monitor/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/monitor/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "resolveJsonModule": true
+  },
+  "include": ["src"]
+}

package/monitor/vite.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5173,
+    proxy: {
+      // Optional: proxy A2A HTTP calls to framework (if needed)
+      // '/a2a': 'http://localhost:41241',
+    },
+  },
+});