agents-dojo 0.1.2 → 0.1.4

package/README.md

@@ -24,10 +24,14 @@ See `agents/_template_echo/` for a complete manifest reference.
 
 ## Monitor GUI
 
+The Monitor GUI starts automatically when you run `agents-dojo`. It picks a free
+port for the WebSocket and launches the Vite dev server (installing dependencies
+on first run). The GUI URL is printed to the console.
+
 ```bash
-agents-dojo --monitor-port=41242
-cd monitor && npm install && npm run dev
-# Open http://localhost:5173
+agents-dojo                       # monitor starts automatically
+agents-dojo --monitor-port=9000   # use a specific WS port
+agents-dojo --no-monitor          # disable the monitor
 ```
 
 ## Architecture

package/dist/agent-executor.js

@@ -4,6 +4,26 @@ import { a2aToContentBlocks } from './part-mapper.js';
 import { runClaude } from './claude-bridge.js';
 import { createTranslator } from './event-translator.js';
 import { recordTaskStart, recordTaskEnd } from './metrics.js';
+import { logConversation, AgentConversationLogger } from './agent-logger.js';
+// ── Global concurrency limiter ─────────────────────────────
+// Prevents CPU overload by limiting simultaneous Claude SDK processes.
+const MAX_CONCURRENT = 3;
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes per task
+let running = 0;
+const waitQueue = [];
+function acquireSlot() {
+    if (running < MAX_CONCURRENT) {
+        running++;
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => waitQueue.push(() => { running++; resolve(); }));
+}
+function releaseSlot() {
+    running--;
+    const next = waitQueue.shift();
+    if (next)
+        next();
+}
 export class DojoAgentExecutor {
     agent;
     options;
@@ -22,7 +42,6 @@ export class DojoAgentExecutor {
         this.controllers.delete(taskId);
         this.contextIds.delete(taskId);
         // Publish canceled state to the bus so the client sees the transition.
-        // Guard against publishing if the bus is no longer accepting (best-effort).
         try {
             eventBus.publish({
                 kind: 'status-update',
@@ -39,9 +58,21 @@ export class DojoAgentExecutor {
         catch {
             // ignore — the SDK subprocess may already be torn down
         }
+        // Also notify monitor
+        this.options.monitorBus?.emit({ type: 'task_status', taskId, state: 'canceled' });
     };
     async execute(requestContext, eventBus) {
         const { taskId, contextId, userMessage } = requestContext;
+        // Wait for a concurrency slot
+        await acquireSlot();
+        // Set up task timeout
+        const timeoutTimer = setTimeout(() => {
+            const ctrl = this.controllers.get(taskId);
+            if (ctrl) {
+                console.warn(`[agents-dojo] Task ${taskId} timed out after ${DEFAULT_TIMEOUT_MS / 1000}s, aborting`);
+                ctrl.abort();
+            }
+        }, DEFAULT_TIMEOUT_MS);
         recordTaskStart();
         // Publish the initial task snapshot. The A2A SDK's ResultManager only
         // initializes its currentTask from a `kind: 'task'` event; without it,
@@ -58,15 +89,21 @@ export class DojoAgentExecutor {
             history: [userMessage],
             artifacts: [],
         });
-        // Emit task_created to monitor bus. A2A has no real "sender" concept beyond
-        // user/agent, so we use the convention from: 'user' for any inbound client.
+        // Emit task_created to monitor bus.
+        const preview = extractPreview(userMessage.parts);
         this.options.monitorBus?.emit({
             type: 'task_created',
             taskId,
             contextId,
             from: 'user',
             to: this.agent.manifest.id,
-            preview: extractPreview(userMessage.parts),
+            preview,
+        });
+        // Also emit submitted state to monitor
+        this.options.monitorBus?.emit({
+            type: 'task_status',
+            taskId,
+            state: 'submitted',
         });
         // 1. Extract text content from A2A message
         const parts = userMessage.parts;
@@ -86,12 +123,28 @@ export class DojoAgentExecutor {
         this.controllers.set(taskId, controller);
         this.contextIds.set(taskId, contextId);
         // 4. Run Claude (iterate events)
+        const startTime = Date.now();
+        let finalResponse = '';
+        let taskState = 'completed';
+        // Full SDK conversation logger — captures every message for transparency
+        const sdkLogger = new AgentConversationLogger(this.agent.agentDir, this.agent.manifest.id, taskId);
         try {
             for await (const sdkMsg of runClaude({
                 agent: this.agent,
                 contentBlocks,
                 contextId,
-                onEvent: (m) => translator.onSdkEvent(m),
+                onEvent: (m) => {
+                    translator.onSdkEvent(m);
+                    sdkLogger.onSdkMessage(m);
+                    // Capture final text for summary log
+                    const msg = m;
+                    if (msg.type === 'assistant' && msg.message?.content) {
+                        for (const block of msg.message.content) {
+                            if (block.type === 'text')
+                                finalResponse = block.text;
+                        }
+                    }
+                },
                 abortController: controller,
             })) {
                 // events are published via onEvent
@@ -100,13 +153,11 @@ export class DojoAgentExecutor {
         }
         catch (err) {
             recordTaskEnd(false);
-            // If the controller was aborted, the SDK throws an AbortError. We don't
-            // want to report it as a generic failure — cancelTask already published
-            // the canceled state. Suppress the publish in that case.
+            taskState = 'failed';
             const isAbort = controller.signal.aborted || (err instanceof Error && /abort/i.test(err.message));
             if (!isAbort) {
-                // SDK subprocess crash, network failure, etc.
                 const reason = err instanceof Error ? err.message : String(err);
+                finalResponse = `Error: ${reason}`;
                 eventBus.publish({
                     kind: 'status-update',
                     taskId,
@@ -129,8 +180,22 @@ export class DojoAgentExecutor {
             }
         }
         finally {
+            clearTimeout(timeoutTimer);
+            releaseSlot();
             this.controllers.delete(taskId);
             this.contextIds.delete(taskId);
+            // Flush full SDK conversation log (all LLM interactions)
+            sdkLogger.flush(taskState, Date.now() - startTime);
+            // Also save summary log
+            logConversation(this.agent.agentDir, {
+                taskId,
+                agentId: this.agent.manifest.id,
+                timestamp: new Date().toISOString(),
+                userMessage: extractPreview(userMessage.parts),
+                agentResponse: finalResponse.slice(0, 500),
+                state: taskState,
+                durationMs: Date.now() - startTime,
+            });
         }
     }
 }

package/dist/agent-logger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A logger that captures every SDK message for a single task.
+ * Create one per task, call .onSdkMessage() for each message,
+ * then .flush() when the task completes.
+ */
+export declare class AgentConversationLogger {
+    private agentDir;
+    private agentId;
+    private taskId;
+    private messages;
+    constructor(agentDir: string, agentId: string, taskId: string);
+    /** Record a raw SDK message (assistant, user, result, etc.) */
+    onSdkMessage(msg: unknown): void;
+    /** Write all captured messages to the agent's log file. */
+    flush(state: 'completed' | 'failed' | 'canceled', durationMs: number): void;
+}
+export interface ConversationEntry {
+    taskId: string;
+    agentId: string;
+    timestamp: string;
+    userMessage: string;
+    agentResponse: string;
+    state: 'completed' | 'failed';
+    durationMs: number;
+}
+export declare function logConversation(agentDir: string, entry: ConversationEntry): void;

package/dist/agent-logger.js

@@ -0,0 +1,63 @@
+// src/agent-logger.ts
+// Saves the complete LLM conversation (all SDK messages) for each agent task.
+import { appendFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+function todayStr() {
+    return new Date().toISOString().slice(0, 10);
+}
+/**
+ * A logger that captures every SDK message for a single task.
+ * Create one per task, call .onSdkMessage() for each message,
+ * then .flush() when the task completes.
+ */
+export class AgentConversationLogger {
+    agentDir;
+    agentId;
+    taskId;
+    messages = [];
+    constructor(agentDir, agentId, taskId) {
+        this.agentDir = agentDir;
+        this.agentId = agentId;
+        this.taskId = taskId;
+    }
+    /** Record a raw SDK message (assistant, user, result, etc.) */
+    onSdkMessage(msg) {
+        this.messages.push({
+            timestamp: new Date().toISOString(),
+            type: msg?.type ?? 'unknown',
+            data: msg,
+        });
+    }
+    /** Write all captured messages to the agent's log file. */
+    flush(state, durationMs) {
+        const logDir = join(this.agentDir, 'log');
+        mkdirSync(logDir, { recursive: true });
+        const file = join(logDir, `${todayStr()}.jsonl`);
+        const entry = {
+            taskId: this.taskId,
+            agentId: this.agentId,
+            timestamp: new Date().toISOString(),
+            state,
+            durationMs,
+            messageCount: this.messages.length,
+            messages: this.messages,
+        };
+        try {
+            appendFileSync(file, JSON.stringify(entry) + '\n');
+        }
+        catch (err) {
+            console.error(`[agent-logger] Failed to write to ${file}:`, err);
+        }
+    }
+}
+export function logConversation(agentDir, entry) {
+    const logDir = join(agentDir, 'log');
+    mkdirSync(logDir, { recursive: true });
+    const file = join(logDir, `${todayStr()}.jsonl`);
+    try {
+        appendFileSync(file, JSON.stringify(entry) + '\n');
+    }
+    catch (err) {
+        console.error(`[agent-logger] Failed to write:`, err);
+    }
+}

package/dist/cli.js

@@ -1,7 +1,11 @@
 #!/usr/bin/env node
-import { resolve, join } from 'path';
+import { resolve, join, dirname } from 'path';
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { spawn, execSync } from 'child_process';
 import { createServer } from './server.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 // ── init command ──────────────────────────────────────────
 const ECHO_MANIFEST = `{
   "id": "echo",
@@ -140,7 +144,7 @@ function installCallAgentSkill(agentDir) {
 export const DEFAULT_ARGS = {
     agentsDir: './agents',
     port: 41241,
-    monitorPort: 41242,
+    monitorPort: 0, // 0 = OS picks a free port
     singleAgent: null,
     help: false,
 };
@@ -172,17 +176,149 @@ function printHelp() {
 
 Commands:
   init                   Create agents/echo/ example in the current directory
+  chat <agentId> <msg>   One-shot chat with an agent (connects to a running server)
   (default)              Start the A2A server
 
 Options:
   --agents-dir <path>    Directory containing agent subdirectories (default: ${DEFAULT_ARGS.agentsDir})
   --port <port>          A2A HTTP port (default: ${DEFAULT_ARGS.port})
-  --monitor-port <port>  Monitor WebSocket port (default: ${DEFAULT_ARGS.monitorPort})
-  --no-monitor           Disable Monitor WebSocket
+  --monitor-port <port>  Monitor WebSocket port (default: auto)
+  --no-monitor           Disable Monitor GUI
   --agent=<id>           Single Agent mode: only load and serve the named agent
   -h, --help             Show this help
 `);
 }
+// ── chat command ─────────────────────────────────────────
+async function runChat(agentId, message, port) {
+    const { v4: uuidv4 } = await import('uuid');
+    const body = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'message/send',
+        params: {
+            message: {
+                messageId: uuidv4(),
+                kind: 'message',
+                role: 'user',
+                parts: [{ kind: 'text', text: message }],
+            },
+        },
+    };
+    const res = await fetch(`http://localhost:${port}/a2a/${agentId}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        console.error(`Error: A2A server returned ${res.status}`);
+        const text = await res.text();
+        if (text)
+            console.error(text);
+        process.exit(1);
+    }
+    const json = await res.json();
+    const result = json.result;
+    if (!result) {
+        console.error('Error: no result in response');
+        process.exit(1);
+    }
+    // Extract reply text
+    let replyText = '';
+    for (const a of (result.artifacts ?? [])) {
+        for (const p of (a.parts ?? [])) {
+            if (p.kind === 'text')
+                replyText += p.text;
+        }
+    }
+    if (!replyText) {
+        const statusMsg = result.status?.message;
+        if (statusMsg) {
+            for (const p of (statusMsg.parts ?? [])) {
+                if (p.kind === 'text')
+                    replyText += p.text;
+            }
+        }
+    }
+    if (replyText) {
+        console.log(replyText);
+    }
+    else {
+        console.log('(no response)');
+    }
+}
+// ── monitor GUI launcher ─────────────────────────────────
+/** Resolve the monitor/ directory shipped alongside the package. */
+function resolveMonitorDir() {
+    // __dirname is dist/ after build, so monitor/ is one level up
+    return resolve(__dirname, '..', 'monitor');
+}
+function startMonitorGui(monitorWsPort) {
+    const monitorDir = resolveMonitorDir();
+    if (!existsSync(join(monitorDir, 'package.json'))) {
+        console.warn('[agents-dojo] Monitor GUI not found — skipping.');
+        return null;
+    }
+    // Auto-install monitor deps if missing
+    if (!existsSync(join(monitorDir, 'node_modules'))) {
+        console.log('[agents-dojo] Installing monitor dependencies…');
+        try {
+            execSync('npm install --no-audit --no-fund', { cwd: monitorDir, stdio: 'inherit' });
+        }
+        catch {
+            console.warn('[agents-dojo] Failed to install monitor dependencies — skipping GUI.');
+            return null;
+        }
+    }
+    const wsUrl = `ws://localhost:${monitorWsPort}/monitor`;
+    const child = spawn(join(monitorDir, 'node_modules', '.bin', 'vite'), [], {
+        cwd: monitorDir,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            VITE_MONITOR_WS_URL: wsUrl,
+        },
+    });
+    child.stdout?.on('data', (data) => {
+        const line = data.toString().trim();
+        if (line) {
+            // Extract and print the local URL from vite output
+            const urlMatch = line.match(/Local:\s+(https?:\/\/\S+)/);
+            if (urlMatch) {
+                console.log(`[agents-dojo] Monitor GUI: ${urlMatch[1]}`);
+            }
+            else if (line.includes('ready in') || line.includes('VITE')) {
+                // Print vite ready messages
+                console.log(`[agents-dojo] ${line}`);
+            }
+        }
+    });
+    child.stderr?.on('data', (data) => {
+        const line = data.toString().trim();
+        if (line)
+            console.error(`[monitor] ${line}`);
+    });
+    child.on('error', (err) => {
+        console.warn(`[agents-dojo] Failed to start Monitor GUI: ${err.message}`);
+    });
+    return child;
+}
+/** Ensure child processes are killed on exit. */
+function registerCleanup(child) {
+    const kill = () => {
+        if (!child.killed) {
+            child.kill('SIGTERM');
+            // Force kill after 2s if SIGTERM didn't work
+            setTimeout(() => {
+                if (!child.killed)
+                    child.kill('SIGKILL');
+            }, 2000).unref();
+        }
+    };
+    process.on('exit', kill);
+    process.on('SIGINT', () => { kill(); process.exit(0); });
+    process.on('SIGTERM', () => { kill(); process.exit(0); });
+}
+// ── main ─────────────────────────────────────────────────
 async function main() {
     const rawArgs = process.argv.slice(2);
     // Handle `agents-dojo init [dir]`
@@ -190,6 +326,24 @@ async function main() {
         runInit(resolve(rawArgs[1] ?? '.'));
         return;
     }
+    // Handle `agents-dojo chat <agentId> <message...>`
+    if (rawArgs[0] === 'chat') {
+        const agentId = rawArgs[1];
+        const message = rawArgs.slice(2).join(' ');
+        if (!agentId || !message) {
+            console.error('Usage: agents-dojo chat <agentId> <message>');
+            process.exit(1);
+        }
+        // Check for --port flag in remaining args
+        let port = DEFAULT_ARGS.port;
+        for (let i = 2; i < rawArgs.length; i++) {
+            if (rawArgs[i] === '--port' && rawArgs[i + 1]) {
+                port = parseInt(rawArgs[++i], 10);
+            }
+        }
+        await runChat(agentId, message, port);
+        return;
+    }
     const args = parseArgs(rawArgs);
     if (args.help) {
         printHelp();
@@ -197,9 +351,6 @@ async function main() {
     }
     console.log(`[agents-dojo] agents-dir: ${args.agentsDir}`);
     console.log(`[agents-dojo] A2A port: ${args.port}`);
-    if (args.monitorPort !== null) {
-        console.log(`[agents-dojo] Monitor port: ${args.monitorPort}`);
-    }
     if (args.singleAgent) {
         console.log(`[agents-dojo] Single agent mode: ${args.singleAgent}`);
     }
@@ -210,6 +361,17 @@ async function main() {
         singleAgent: args.singleAgent ?? undefined,
     });
     console.log(`[agents-dojo] ${server.registry.list().length} agents loaded: ${server.registry.list().join(', ')}`);
+    // Auto-start monitor GUI
+    if (server.monitorPort) {
+        console.log(`[agents-dojo] Monitor WS port: ${server.monitorPort}`);
+        const monitorChild = startMonitorGui(server.monitorPort);
+        if (monitorChild) {
+            registerCleanup(monitorChild);
+        }
+    }
+    else {
+        console.log(`[agents-dojo] Monitor disabled.`);
+    }
     console.log(`[agents-dojo] Ready.`);
 }
 main().catch((err) => {

package/dist/log-writer.d.ts

@@ -0,0 +1,26 @@
+import type { MonitorBus } from './monitor-bus.js';
+/**
+ * A single chat message in the conversation log.
+ */
+export interface ChatMessage {
+    timestamp: string;
+    taskId: string;
+    from: string;
+    to: string;
+    content: string;
+    direction: 'incoming' | 'outgoing';
+}
+/**
+ * Subscribe to monitor bus and save chat messages (not raw events).
+ * Only task_created (incoming message) and task_status with working/completed
+ * (agent response) are saved as chat records.
+ */
+export declare function startMonitorLogger(bus: MonitorBus, logDir: string): void;
+/**
+ * Read chat messages from logs.
+ */
+export declare function readLogs(logDir: string, date?: string): ChatMessage[];
+/**
+ * List available log dates.
+ */
+export declare function listLogDates(logDir: string): string[];

package/dist/log-writer.js

@@ -0,0 +1,123 @@
+// src/log-writer.ts
+// Saves agent conversations (who said what to whom) as chat-style records.
+import { appendFileSync, mkdirSync, existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+function todayStr() {
+    return new Date().toISOString().slice(0, 10);
+}
+/**
+ * Subscribe to monitor bus and save chat messages (not raw events).
+ * Only task_created (incoming message) and task_status with working/completed
+ * (agent response) are saved as chat records.
+ */
+export function startMonitorLogger(bus, logDir) {
+    mkdirSync(logDir, { recursive: true });
+    // Track taskId → agent mapping for responses
+    const taskAgents = new Map();
+    // Track which agents are currently working (for detecting peer calls)
+    const workingAgents = new Set();
+    bus.subscribe((event) => {
+        const file = join(logDir, `${todayStr()}.jsonl`);
+        if (event.type === 'task_created') {
+            // Detect agent-to-agent call: if another agent is working, it's likely the caller
+            let from = event.from;
+            if (from === 'user') {
+                for (const agentId of workingAgents) {
+                    if (agentId !== event.to) {
+                        from = agentId;
+                        break;
+                    }
+                }
+            }
+            taskAgents.set(event.taskId, { from, to: event.to });
+            const msg = {
+                timestamp: new Date().toISOString(),
+                taskId: event.taskId,
+                from,
+                to: event.to,
+                content: event.preview,
+                direction: 'incoming',
+            };
+            writeLine(file, msg);
+        }
+        // Track working agents from tool_call events too
+        if (event.type === 'tool_call_start') {
+            const targetId = [...taskAgents.entries()].find(([tid]) => tid === event.taskId)?.[1]?.to;
+            if (targetId)
+                workingAgents.add(targetId);
+        }
+        if (event.type === 'task_status') {
+            // Track working agents
+            const targetId = [...taskAgents.entries()].find(([tid]) => tid === event.taskId)?.[1]?.to;
+            if (targetId) {
+                if (event.state === 'working')
+                    workingAgents.add(targetId);
+                else if (event.state === 'completed' || event.state === 'failed' || event.state === 'canceled')
+                    workingAgents.delete(targetId);
+            }
+            if (event.message) {
+                const mapping = taskAgents.get(event.taskId);
+                if (mapping) {
+                    const msg = {
+                        timestamp: new Date().toISOString(),
+                        taskId: event.taskId,
+                        from: mapping.to, // agent is responding
+                        to: mapping.from, // back to the caller
+                        content: event.message,
+                        direction: 'outgoing',
+                    };
+                    writeLine(file, msg);
+                }
+            }
+            // Clean up on terminal states
+            const terminalStates = ['completed', 'failed', 'canceled', 'rejected'];
+            if (terminalStates.includes(event.state)) {
+                taskAgents.delete(event.taskId);
+            }
+        }
+    });
+}
+function writeLine(file, msg) {
+    try {
+        appendFileSync(file, JSON.stringify(msg) + '\n');
+    }
+    catch (err) {
+        console.error('[log-writer] Failed to write:', err);
+    }
+}
+/**
+ * Read chat messages from logs.
+ */
+export function readLogs(logDir, date) {
+    if (!existsSync(logDir))
+        return [];
+    const files = date
+        ? [`${date}.jsonl`]
+        : readdirSync(logDir).filter((f) => f.endsWith('.jsonl')).sort().reverse();
+    const entries = [];
+    for (const file of files) {
+        const path = join(logDir, file);
+        if (!existsSync(path))
+            continue;
+        const lines = readFileSync(path, 'utf-8').split('\n').filter(Boolean);
+        for (const line of lines) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch { /* skip */ }
+        }
+    }
+    return entries;
+}
+/**
+ * List available log dates.
+ */
+export function listLogDates(logDir) {
+    if (!existsSync(logDir))
+        return [];
+    return readdirSync(logDir)
+        .filter((f) => f.endsWith('.jsonl'))
+        .map((f) => f.replace('.jsonl', ''))
+        .sort()
+        .reverse();
+}

package/dist/monitor-bus.d.ts

@@ -30,6 +30,12 @@ export type MonitorEvent = {
     taskId: string;
     toolName: string;
     success: boolean;
+} | {
+    type: 'chat_response';
+    chatId: string;
+    agentId: string;
+    text: string;
+    final: boolean;
 };
 export type MonitorSubscriber = (event: MonitorEvent) => void;
 export type Unsubscribe = () => void;

package/dist/monitor-ws.d.ts

@@ -7,6 +7,8 @@ export interface MonitorWsOptions {
     bus: MonitorBus;
     path: string;
     registry: AgentRegistry;
+    /** A2A server port — needed to proxy chat commands. */
+    a2aPort: number;
 }
 export type MonitorCommand = {
     type: 'reload';
@@ -16,6 +18,11 @@ export type MonitorCommand = {
     agentId: string;
     x: number;
     y: number;
+} | {
+    type: 'chat';
+    chatId: string;
+    agentId: string;
+    message: string;
 };
 export type MonitorCommandHandler = (cmd: MonitorCommand) => void | Promise<void>;
 export interface MonitorWsHandle {

package/dist/monitor-ws.js

@@ -1,9 +1,10 @@
 // src/monitor-ws.ts
 import { WebSocketServer, WebSocket } from 'ws';
+import { v4 as uuidv4 } from 'uuid';
 export function createMonitorWs(opts) {
     const clients = new Set();
     const wss = new WebSocketServer({ server: opts.server, path: opts.path });
-    function handleCommand(cmd) {
+    function handleCommand(cmd, senderWs) {
         if (cmd.type === 'reload') {
             const result = opts.registry.reload(cmd.agentId);
             // WS protocol is fire-and-forget for commands; on failure, log so the
@@ -18,6 +19,83 @@ export function createMonitorWs(opts) {
             if (!agent)
                 return;
             agent.manifest.monitor = { ...agent.manifest.monitor, position: { x: cmd.x, y: cmd.y } };
+            return;
+        }
+        if (cmd.type === 'chat') {
+            handleChat(cmd, senderWs).catch((err) => {
+                console.error(`[monitor-ws] chat error for "${cmd.agentId}":`, err);
+                const errEvent = {
+                    type: 'chat_response',
+                    chatId: cmd.chatId,
+                    agentId: cmd.agentId,
+                    text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    final: true,
+                };
+                if (senderWs.readyState === WebSocket.OPEN) {
+                    senderWs.send(JSON.stringify(errEvent));
+                }
+            });
+        }
+    }
+    /** Proxy a chat message to the A2A endpoint and stream the reply back. */
+    async function handleChat(cmd, senderWs) {
+        const body = {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'message/send',
+            params: {
+                message: {
+                    messageId: uuidv4(),
+                    kind: 'message',
+                    role: 'user',
+                    parts: [{ kind: 'text', text: cmd.message }],
+                },
+            },
+        };
+        const res = await fetch(`http://localhost:${opts.a2aPort}/a2a/${cmd.agentId}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            throw new Error(`A2A returned ${res.status}: ${await res.text()}`);
+        }
+        const json = await res.json();
+        // Extract the agent's reply text from the A2A JSON-RPC response
+        let replyText = '';
+        const result = json.result;
+        if (result) {
+            // Try artifacts first (main response content)
+            const artifacts = result.artifacts ?? [];
+            for (const a of artifacts) {
+                for (const p of (a.parts ?? [])) {
+                    if (p.kind === 'text')
+                        replyText += p.text;
+                }
+            }
+            // Fall back to status message
+            if (!replyText) {
+                const statusMsg = result.status?.message;
+                if (statusMsg) {
+                    for (const p of (statusMsg.parts ?? [])) {
+                        if (p.kind === 'text')
+                            replyText += p.text;
+                    }
+                }
+            }
+        }
+        if (!replyText)
+            replyText = '(no response)';
+        // Send the response only to the requesting client
+        const event = {
+            type: 'chat_response',
+            chatId: cmd.chatId,
+            agentId: cmd.agentId,
+            text: replyText,
+            final: true,
+        };
+        if (senderWs.readyState === WebSocket.OPEN) {
+            senderWs.send(JSON.stringify(event));
         }
     }
     wss.on('connection', (ws) => {
@@ -40,8 +118,8 @@ export function createMonitorWs(opts) {
                 const parsed = JSON.parse(data.toString());
                 if (parsed &&
                     typeof parsed === 'object' &&
-                    (parsed.type === 'reload' || parsed.type === 'set_position')) {
-                    handleCommand(parsed);
+                    (parsed.type === 'reload' || parsed.type === 'set_position' || parsed.type === 'chat')) {
+                    handleCommand(parsed, ws);
                 }
             }
             catch {

package/dist/server.d.ts

@@ -11,6 +11,8 @@ export interface DojoServer {
     registry: AgentRegistry;
     bus: ReturnType<typeof createMonitorBus>;
     httpServer: ReturnType<typeof createHttpServer>;
+    /** Actual monitor WebSocket port (undefined when --no-monitor). */
+    monitorPort?: number;
     close: () => Promise<void>;
 }
 export declare function createServer(opts: CreateServerOptions): Promise<DojoServer>;

package/dist/server.js

@@ -1,13 +1,17 @@
 import { createServer as createHttpServer } from 'http';
+import { resolve, join } from 'path';
 import { AgentRegistry } from './agent-registry.js';
 import { createA2AServer } from './a2a-server.js';
 import { createReloadApi } from './reload-api.js';
 import { createMetricsRouter, setAgentsLoaded } from './metrics.js';
 import { createMonitorBus } from './monitor-bus.js';
 import { createMonitorWs } from './monitor-ws.js';
+import { startMonitorLogger, readLogs, listLogDates } from './log-writer.js';
 export async function createServer(opts) {
-    // Create bus FIRST so handlers can reference it
     const bus = createMonitorBus();
+    // Start monitor event logger
+    const logDir = join(resolve(opts.agentsDir), '..', 'monitor-logs');
+    startMonitorLogger(bus, logDir);
     const registry = new AgentRegistry(opts.agentsDir);
     registry.load();
     setAgentsLoaded(registry.list().length);
@@ -18,22 +22,45 @@ export async function createServer(opts) {
     registry.on('agent_reloaded', (e) => bus.emit({ type: 'agent_reloaded', ...e }));
     const a2a = createA2AServer({ registry, singleAgent: opts.singleAgent, port: opts.port, monitorBus: bus });
     const app = a2a.app;
+    // CORS for Monitor GUI (runs on a different port)
+    app.use('/logs', (_req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', 'GET');
+        next();
+    });
     app.use('/agents', createReloadApi(registry));
     app.use('/metrics', createMetricsRouter());
+    // Logs REST API
+    app.get('/logs', (_req, res) => {
+        const date = _req.query.date;
+        res.json({ entries: readLogs(logDir, date) });
+    });
+    app.get('/logs/dates', (_req, res) => {
+        res.json({ dates: listLogDates(logDir) });
+    });
     const httpServer = createHttpServer(app);
-    if (opts.monitorPort) {
-        // Bind monitor on a separate server
-        const monitorHttp = createHttpServer();
-        createMonitorWs({ server: monitorHttp, bus, path: '/monitor', registry });
+    // Listen on main server first so we know the actual port (important when port=0)
+    await new Promise((r) => httpServer.listen(opts.port ?? 41241, r));
+    const actualA2APort = httpServer.address().port;
+    let monitorHttp;
+    let actualMonitorPort;
+    if (opts.monitorPort !== undefined) {
+        // Bind monitor on a separate server (port 0 = OS picks a free port)
+        monitorHttp = createHttpServer();
+        createMonitorWs({ server: monitorHttp, bus, path: '/monitor', registry, a2aPort: actualA2APort });
         await new Promise((r) => monitorHttp.listen(opts.monitorPort, r));
+        actualMonitorPort = monitorHttp.address().port;
     }
-    await new Promise((r) => httpServer.listen(opts.port ?? 41241, r));
     return {
         registry,
         bus,
         httpServer,
+        monitorPort: actualMonitorPort,
         close: () => new Promise((resolve) => {
-            httpServer.close(() => resolve());
+            const closeMonitor = monitorHttp
+                ? new Promise((r) => monitorHttp.close(() => r()))
+                : Promise.resolve();
+            httpServer.close(() => closeMonitor.then(resolve));
         }),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-dojo",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "A2A-compatible Agent framework built on Claude Code SDK",
   "type": "module",
   "main": "dist/index.js",