agents-dojo 0.1.2 → 0.1.3

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/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/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,11 +22,24 @@ 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 });
         await new Promise((r) => monitorHttp.listen(opts.monitorPort, r));

package/package.json

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