agents-dojo 0.1.5 → 0.1.7

package/dist/a2a-server.d.ts

@@ -1,4 +1,5 @@
 import { type Express } from 'express';
+import { DojoAgentExecutor } from './agent-executor.js';
 import type { AgentRegistry } from './agent-registry.js';
 import type { MonitorBus } from './monitor-bus.js';
 export interface A2AServerOptions {
@@ -9,6 +10,7 @@ export interface A2AServerOptions {
 }
 export interface A2AServerHandle {
     app: Express;
+    executors: Map<string, DojoAgentExecutor>;
     close: () => Promise<void>;
 }
 export declare function createA2AServer(opts: A2AServerOptions): A2AServerHandle;

package/dist/a2a-server.js

@@ -10,6 +10,7 @@ export function createA2AServer(opts) {
     const agents = opts.singleAgent
         ? [opts.registry.get(opts.singleAgent)].filter((a) => a !== undefined)
         : opts.registry.list().map((id) => opts.registry.get(id)).filter((a) => a !== undefined);
+    const executors = new Map();
     for (const loaded of agents) {
         const card = {
             name: loaded.manifest.name,
@@ -28,6 +29,7 @@ export function createA2AServer(opts) {
         };
         const taskStore = new InMemoryTaskStore();
         const executor = new DojoAgentExecutor(loaded, { monitorBus: opts.monitorBus });
+        executors.set(loaded.manifest.id, executor);
         const requestHandler = new DefaultRequestHandler(card, taskStore, executor);
         const userBuilder = UserBuilder.noAuthentication;
         app.use(`/a2a/${loaded.manifest.id}`, jsonRpcHandler({ requestHandler, userBuilder }));
@@ -36,6 +38,7 @@ export function createA2AServer(opts) {
     }
     return {
         app,
+        executors,
         close: () => new Promise((resolve) => {
             // No actual server here; createServer() handles listening
             resolve();

package/dist/agent-executor.d.ts

@@ -9,7 +9,14 @@ export declare class DojoAgentExecutor implements AgentExecutor {
     private options;
     private controllers;
     private contextIds;
+    /** Persistent session ID for this agent — enables cross-call memory. */
+    private sessionId;
     constructor(agent: LoadedAgent, options?: AgentExecutorOptions);
     cancelTask: (taskId: string, eventBus: ExecutionEventBus) => Promise<void>;
     execute(requestContext: RequestContext, eventBus: ExecutionEventBus): Promise<void>;
+    /**
+     * btw-style one-shot chat: forks the agent's current session, disables all tools,
+     * gets a text-only reply, then discards the fork. Does not affect the main session.
+     */
+    executeBtw(message: string): Promise<string>;
 }

package/dist/agent-executor.js

@@ -29,6 +29,8 @@ export class DojoAgentExecutor {
     options;
     controllers = new Map();
     contextIds = new Map();
+    /** Persistent session ID for this agent — enables cross-call memory. */
+    sessionId;
     constructor(agent, options = {}) {
         this.agent = agent;
         this.options = options;
@@ -133,11 +135,16 @@ export class DojoAgentExecutor {
                 agent: this.agent,
                 contentBlocks,
                 contextId,
+                resume: this.sessionId,
                 onEvent: (m) => {
                     translator.onSdkEvent(m);
                     sdkLogger.onSdkMessage(m);
-                    // Capture final text for summary log
                     const msg = m;
+                    // Capture session_id for cross-call continuity
+                    if (msg.session_id && typeof msg.session_id === 'string') {
+                        this.sessionId = msg.session_id;
+                    }
+                    // Capture final text for summary log
                     if (msg.type === 'assistant' && msg.message?.content) {
                         for (const block of msg.message.content) {
                             if (block.type === 'text')
@@ -198,6 +205,33 @@ export class DojoAgentExecutor {
             });
         }
     }
+    /**
+     * btw-style one-shot chat: forks the agent's current session, disables all tools,
+     * gets a text-only reply, then discards the fork. Does not affect the main session.
+     */
+    async executeBtw(message) {
+        // btw is only meaningful when the agent already has a session to fork from.
+        // Without a session, there's no context to branch — just run a plain ephemeral query.
+        let reply = '';
+        for await (const sdkMsg of runClaude({
+            agent: this.agent,
+            contentBlocks: [{ type: 'text', text: message }],
+            contextId: 'btw-' + Date.now(),
+            resume: this.sessionId, // undefined if no session yet — SDK creates a fresh one
+            btw: this.sessionId !== undefined, // only fork if there's a session to fork from
+            onEvent: (m) => {
+                const msg = m;
+                // Do NOT capture session_id — btw must never affect the main session
+                if (msg.type === 'assistant' && msg.message?.content) {
+                    for (const block of msg.message.content) {
+                        if (block.type === 'text')
+                            reply = block.text;
+                    }
+                }
+            },
+        })) { /* consume */ }
+        return reply || '(no response)';
+    }
 }
 function extractPreview(parts) {
     if (!Array.isArray(parts))

package/dist/claude-bridge.d.ts

@@ -7,5 +7,9 @@ export interface RunClaudeParams {
     contextId: string;
     onEvent: (event: SDKMessage) => void;
     abortController?: AbortController;
+    /** Resume an existing session (pass the session UUID from a previous query). */
+    resume?: string;
+    /** btw mode: fork the session, disable all tools, don't persist the fork. */
+    btw?: boolean;
 }
 export declare function runClaude(params: RunClaudeParams): AsyncGenerator<SDKMessage>;

package/dist/claude-bridge.js

@@ -1,5 +1,6 @@
 // src/claude-bridge.ts
 import { join } from 'path';
+import { existsSync, mkdirSync, symlinkSync } from 'fs';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 export async function* runClaude(params) {
     const { agent, contentBlocks, onEvent, abortController } = params;
@@ -12,23 +13,42 @@ export async function* runClaude(params) {
         PATH: process.env.PATH,
         ...(m.env ?? {}),
     };
-    // Only override CLAUDE_CONFIG_DIR if the user explicitly specified configDir.
-    // Otherwise, let the subprocess inherit the parent's config (preserving auth).
-    if (m.configDir) {
-        env.CLAUDE_CONFIG_DIR = m.configDir.startsWith('/')
-            ? m.configDir
-            : join(agent.agentDir, m.configDir);
+    // Each agent stores sessions/config in its own .claude directory by default.
+    // This keeps session data co-located with the agent rather than polluting ~/.claude.
+    const agentConfigDir = m.configDir
+        ? (m.configDir.startsWith('/') ? m.configDir : join(agent.agentDir, m.configDir))
+        : join(agent.agentDir, '.claude');
+    env.CLAUDE_CONFIG_DIR = agentConfigDir;
+    // Ensure the agent's .claude dir exists and symlink global settings (auth, permissions).
+    // Symlink keeps all agents in sync with the user's global config automatically.
+    mkdirSync(agentConfigDir, { recursive: true });
+    const globalSettings = join(process.env.HOME ?? '', '.claude', 'settings.json');
+    const localSettings = join(agentConfigDir, 'settings.json');
+    if (existsSync(globalSettings) && !existsSync(localSettings)) {
+        try {
+            symlinkSync(globalSettings, localSettings);
+        }
+        catch { /* race or permission — ignore */ }
     }
-    // Build options. Note: we do NOT pass `resume: contextId` here — the Claude
-    // SDK treats resume as a previously-issued session ID, and A2A's contextId
-    // is a fresh UUID with no corresponding SDK session. Treating every send
-    // as a brand-new Claude session is the safe default. (Future: persist a
-    // contextId→sessionId mapping if cross-call continuity is required.)
     const options = {
         systemPrompt,
         cwd: agent.agentDir,
         env,
     };
+    // Session continuity: resume an existing session if provided
+    if (params.resume) {
+        options.resume = params.resume;
+    }
+    // btw mode: disable tools, don't persist. Fork only if resuming an existing session.
+    if (params.btw) {
+        options.tools = [];
+        options.allowedTools = [];
+        options.disallowedTools = [];
+        options.persistSession = false;
+        if (params.resume) {
+            options.forkSession = true;
+        }
+    }
     if (abortController) {
         options.abortController = abortController;
     }
@@ -44,12 +64,15 @@ export async function* runClaude(params) {
         options.pathToClaudeCodeExecutable = m.pathToClaudeCodeExecutable;
     if (m.extraArgs)
         options.extraArgs = m.extraArgs;
-    if (m.tools)
-        options.tools = m.tools;
-    if (m.allowedTools)
-        options.allowedTools = m.allowedTools;
-    if (m.disallowedTools)
-        options.disallowedTools = m.disallowedTools;
+    // In btw mode, tools are already disabled — don't let manifest override
+    if (!params.btw) {
+        if (m.tools)
+            options.tools = m.tools;
+        if (m.allowedTools)
+            options.allowedTools = m.allowedTools;
+        if (m.disallowedTools)
+            options.disallowedTools = m.disallowedTools;
+    }
     if (m.toolAliases)
         options.toolAliases = m.toolAliases;
     if (m.permissionMode)
@@ -86,7 +109,7 @@ export async function* runClaude(params) {
         options.betas = m.betas;
     if (m.outputFormat)
         options.outputFormat = m.outputFormat;
-    if (m.forkSession !== undefined)
+    if (m.forkSession !== undefined && !params.btw)
         options.forkSession = m.forkSession;
     if (agent.agentsPath)
         options.agents = agent.agentsPath;

package/dist/cli.js

@@ -188,63 +188,22 @@ Options:
   -h, --help             Show this help
 `);
 }
-// ── chat command ─────────────────────────────────────────
+// ── chat command (btw mode) ───────────────────────────────
 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}`, {
+    const res = await fetch(`http://localhost:${port}/btw/${agentId}`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
+        body: JSON.stringify({ message }),
     });
     if (!res.ok) {
-        console.error(`Error: A2A server returned ${res.status}`);
+        console.error(`Error: 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)');
-    }
+    console.log(json.reply ?? '(no response)');
 }
 // ── monitor GUI launcher ─────────────────────────────────
 /** Resolve the monitor/ directory shipped alongside the package. */

package/dist/monitor-ws.d.ts

@@ -1,14 +1,15 @@
 import { WebSocketServer, WebSocket } from 'ws';
 import type { Server } from 'http';
 import type { AgentRegistry } from './agent-registry.js';
+import type { DojoAgentExecutor } from './agent-executor.js';
 import type { MonitorBus } from './monitor-bus.js';
 export interface MonitorWsOptions {
     server: Server;
     bus: MonitorBus;
     path: string;
     registry: AgentRegistry;
-    /** A2A server port — needed to proxy chat commands. */
-    a2aPort: number;
+    /** Agent executors — needed for btw-style chat. */
+    executors: Map<string, DojoAgentExecutor>;
 }
 export type MonitorCommand = {
     type: 'reload';

package/dist/monitor-ws.js

@@ -1,6 +1,5 @@
 // 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 });
@@ -37,56 +36,13 @@ export function createMonitorWs(opts) {
             });
         }
     }
-    /** Proxy a chat message to the A2A endpoint and stream the reply back. */
+    /** btw-style chat: fork agent session, get text-only reply, discard fork. */
     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;
-                    }
-                }
-            }
+        const executor = opts.executors.get(cmd.agentId);
+        if (!executor) {
+            throw new Error(`Agent "${cmd.agentId}" not found`);
         }
-        if (!replyText)
-            replyText = '(no response)';
-        // Send the response only to the requesting client
+        const replyText = await executor.executeBtw(cmd.message);
         const event = {
             type: 'chat_response',
             chatId: cmd.chatId,

package/dist/server.js

@@ -38,6 +38,27 @@ export async function createServer(opts) {
     app.get('/logs/dates', (_req, res) => {
         res.json({ dates: listLogDates(logDir) });
     });
+    // btw-style one-shot chat endpoint (forks session, no tools, ephemeral)
+    app.post('/btw/:agentId', async (req, res) => {
+        const { agentId } = req.params;
+        const { message } = req.body;
+        if (!message) {
+            res.status(400).json({ error: 'message required' });
+            return;
+        }
+        const executor = a2a.executors.get(agentId);
+        if (!executor) {
+            res.status(404).json({ error: `agent "${agentId}" not found` });
+            return;
+        }
+        try {
+            const reply = await executor.executeBtw(message);
+            res.json({ reply });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
     const httpServer = createHttpServer(app);
     // 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));
@@ -47,7 +68,7 @@ export async function createServer(opts) {
     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 });
+        createMonitorWs({ server: monitorHttp, bus, path: '/monitor', registry, executors: a2a.executors });
         await new Promise((r) => monitorHttp.listen(opts.monitorPort, r));
         actualMonitorPort = monitorHttp.address().port;
     }

package/monitor/.env.development

@@ -0,0 +1 @@
+VITE_MONITOR_WS_URL=ws://localhost:41242/monitor

package/monitor/.env.production

@@ -0,0 +1 @@
+VITE_MONITOR_WS_URL=ws://localhost:41242/monitor

package/monitor/ANIMATION_REQUIREMENTS.md

@@ -0,0 +1,118 @@
+# Monitor GUI 动画需求清单
+
+以下是从历史对话中提取的所有前端动画相关需求，按时间顺序排列。
+
+---
+
+## 1. 场景背景
+
+- **R1.1** 使用指定的像素风道场背景图 (`bg_clean.png`)
+- **R1.2** 页面缩放时，背景与角色位置保持同步，不能错位
+- **R1.3** 固定设计分辨率 960×600，所有元素在 Pixi.js 内渲染
+
+## 2. 角色基本形象
+
+- **R2.1** 角色使用像素风 sprite，风格与道场背景匹配
+- **R2.2** 角色大小与木桩差不多高（约 60-64px）
+- **R2.3** 角色头顶显示名字标签，名字要清晰可辨
+- **R2.4** 角色活动范围限定在地板区域（不能跑到墙壁上）
+
+## 3. 角色动作集
+
+- **R3.1** idle（站立发呆）：站立，眨眼动画
+- **R3.2** walk（走路）：四帧走路动画，移动时自动切换
+- **R3.3** sit（坐在蒲团上）：蒲团上的打坐动画
+- **R3.4** attack（打木桩）：击打木桩的攻击动画
+- **R3.5** daydream（站着发呆）：和 idle 不同的发呆动画
+- **R3.6** chat（聊天）：两个 agent 面对面聊天的动画
+- **R3.7** ~~坐地发呆~~ 已移除（效果不佳）
+- **R3.8** ~~躺下~~ 已移除（像素分辨率限制，效果不佳）
+
+## 4. 闲置行为（Idle Behavior）
+
+- **R4.1** 无任务时，角色在地图上随机游荡（wander）
+- **R4.2** 随机切换站立发呆（pause）和 daydream
+- **R4.3** 移动时自动切换朝向（面向移动方向）
+
+## 5. 角色与物品交互
+
+### 5.1 蒲团（Cushion）
+
+- **R5.1** 每个 agent 有固定的 home 蒲团位置
+- **R5.2** agent 只能坐在自己的蒲团上，不能随地坐
+- **R5.3** agent 坐到蒲团上时，蒲团有被压扁的动画
+- **R5.4** agent 与蒲团的位置要精准对齐，不能浮空
+
+### 5.2 木桩（Stake）
+
+- **R5.5** 每个 agent 有固定的木桩位置
+- **R5.6** agent 击打木桩时，木桩有受击晃动动画
+- **R5.7** 木桩晃动必须在 agent 出拳后才触发（不是提前晃）
+- **R5.8** agent 应当和木桩保持平行，站在木桩侧面击打
+
+### 5.3 碰撞与移动
+
+- **R5.9** agent 与蒲团、木桩之间有碰撞体积，不能穿过去
+- **R5.10** 碰撞不能卡住 agent 移动（绕行而不是卡死）
+- **R5.11** 物品交互框架化设计，便于后续添加新物品
+- A: agent 设计避让
+- A: 在下面的任务、物品可以挡住上面的，符合人类的观感
+
+## 6. 任务驱动动画
+
+- **R6.1** 收到任务（receiving）→ agent 走向 Master 老师傅
+- **R6.2** 到达 Master 后 → 走向自己的木桩
+- **R6.3** 执行任务（working/tool_call）→ 在木桩前做 attack 动画
+- **R6.4** 任务完成（completed/failed）→ 走回蒲团 home 位置
+
+## 7. Agent 间交互（Peer Chat）
+
+- **R7.1** agent 之间交流时，两人走到空地面对面
+- **R7.2** 面对面聊天时显示 chat 动画
+- **R7.3** 支持多于两人一起沟通（不限两人）
+- **R7.4** 聊天时头顶显示聊天气泡，显示消息内容
+
+## 8. Master 老师傅
+
+- **R8.1** 新增一个 Master 角色，固定在场景中央
+- **R8.2** Master 只有 idle 动画（不移动）
+- **R8.3** 当 client 与 agent 交互时，Master 呼唤 agent 过来
+
+## 9. 其他 UI
+
+- **R9.1** StatusBar 显示连接状态、agent 数量
+- **R9.2** Logs 按钮进入聊天记录页面
+
+## 10. 状态机
+
+人物状态机以如下要求为准。
+
+### 10.1 Client → Agent（外部任务）
+
+| 状态 | 动画表现 |
+|------|----------|
+| `idle` | 坐在蒲团上发呆（闲置行为：偶尔起身随机游荡、daydream） |
+| `submitted` | 从蒲团起身，走向 Master 老师傅 |
+| `working` | 从 Master 处走向自己的木桩，开始打桩（attack 动画） |
+| `input-required` | 停下打桩，走回 Master 前等待；收到输入后再回木桩继续 |
+| `auth-required` | 同 `input-required`，走回 Master 前等待 |
+| `completed` | 停下打桩，走回蒲团坐下 |
+| `failed` | 打桩手痛 → 甩手动画 → 走回蒲团坐下 |
+| `canceled` | 被 Master 叫回 → 立即停下当前动作，走回蒲团坐下 |
+| `rejected` | 在 Master 前摇头拒绝 → 气泡显示拒绝原因 → 走回蒲团坐下 |
+
+### 10.2 Agent → Agent（内部调用）
+
+当 Agent A（处于 working/打桩中）调用 Agent B 时：
+
+| 角色 | 行为 |
+|------|------|
+| Agent A（发起方） | 停下打桩 → 走向空地等 B → 面对面 chat → B 回复后回木桩继续打桩 |
+| Agent B（被调用方） | 从蒲团起身 → 走向 A → 面对面 chat → 回复完毕后走回蒲团 |
+
+关键规则：
+- **判断依据**：看任务的 `from` 是 client 还是 agent，决定 working 状态的动画是打桩还是聊天
+- A 和 B 在对话过程中都处于 `working` 状态，但动画表现为聊天（chat），不是打桩
+- B 回复完成后（B 的任务 completed），B 走回蒲团
+- A 拿到回复后，A 回木桩继续打桩（A 的任务仍在 working）
+- 支持多人同时聊天（参考第 7 节）

package/monitor/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>AgentsDojo Monitor</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>