agents-dojo 0.1.4 → 0.1.6

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,14 +205,40 @@ 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))
         return '';
     for (const p of parts) {
         if (p && typeof p === 'object' && p.kind === 'text' && typeof p.text === 'string') {
-            const t = p.text;
-            return t.length > 80 ? t.slice(0, 80) + '…' : t;
+            return p.text;
         }
     }
     return '';

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/event-translator.js

@@ -30,7 +30,7 @@ export function createTranslator(ctx) {
             type: 'task_status',
             taskId: ctx.taskId,
             state: 'working',
-            message: text.length > 80 ? text.slice(0, 77) + '...' : text,
+            message: text,
         });
     }
     function publishCompleted() {

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/package.json

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