agents-dojo 0.1.0

package/dist/monitor-bus.js

@@ -0,0 +1,19 @@
+export function createMonitorBus() {
+    const subs = new Set();
+    return {
+        subscribe(fn) {
+            subs.add(fn);
+            return () => subs.delete(fn);
+        },
+        emit(event) {
+            for (const fn of subs) {
+                try {
+                    fn(event);
+                }
+                catch (err) {
+                    console.error('[monitor-bus] subscriber threw:', err);
+                }
+            }
+        },
+    };
+}

package/dist/monitor-ws.d.ts

@@ -0,0 +1,25 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import type { Server } from 'http';
+import type { AgentRegistry } from './agent-registry.js';
+import type { MonitorBus } from './monitor-bus.js';
+export interface MonitorWsOptions {
+    server: Server;
+    bus: MonitorBus;
+    path: string;
+    registry: AgentRegistry;
+}
+export type MonitorCommand = {
+    type: 'reload';
+    agentId: string;
+} | {
+    type: 'set_position';
+    agentId: string;
+    x: number;
+    y: number;
+};
+export type MonitorCommandHandler = (cmd: MonitorCommand) => void | Promise<void>;
+export interface MonitorWsHandle {
+    wss: WebSocketServer;
+    clients: Set<WebSocket>;
+}
+export declare function createMonitorWs(opts: MonitorWsOptions): MonitorWsHandle;

package/dist/monitor-ws.js

@@ -0,0 +1,61 @@
+// src/monitor-ws.ts
+import { WebSocketServer, WebSocket } from 'ws';
+export function createMonitorWs(opts) {
+    const clients = new Set();
+    const wss = new WebSocketServer({ server: opts.server, path: opts.path });
+    function handleCommand(cmd) {
+        if (cmd.type === 'reload') {
+            const result = opts.registry.reload(cmd.agentId);
+            // WS protocol is fire-and-forget for commands; on failure, log so the
+            // operator sees it in the server stderr rather than silently dropping.
+            if (!result.ok) {
+                console.error(`[monitor-ws] reload failed for "${cmd.agentId}": ${result.code} — ${result.message}`);
+            }
+            return;
+        }
+        if (cmd.type === 'set_position') {
+            const agent = opts.registry.get(cmd.agentId);
+            if (!agent)
+                return;
+            agent.manifest.monitor = { ...agent.manifest.monitor, position: { x: cmd.x, y: cmd.y } };
+        }
+    }
+    wss.on('connection', (ws) => {
+        clients.add(ws);
+        // Replay current agent list so late-connecting monitors see all loaded agents
+        for (const id of opts.registry.list()) {
+            const agent = opts.registry.get(id);
+            if (agent && ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                    type: 'agent_loaded',
+                    agentId: id,
+                    position: agent.manifest.monitor?.position,
+                }));
+            }
+        }
+        ws.on('close', () => clients.delete(ws));
+        ws.on('error', () => clients.delete(ws));
+        ws.on('message', (data) => {
+            try {
+                const parsed = JSON.parse(data.toString());
+                if (parsed &&
+                    typeof parsed === 'object' &&
+                    (parsed.type === 'reload' || parsed.type === 'set_position')) {
+                    handleCommand(parsed);
+                }
+            }
+            catch {
+                // ignore malformed JSON
+            }
+        });
+    });
+    opts.bus.subscribe((event) => {
+        const msg = JSON.stringify(event);
+        for (const ws of clients) {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(msg);
+            }
+        }
+    });
+    return { wss, clients };
+}

package/dist/part-mapper.d.ts

@@ -0,0 +1,31 @@
+export type A2APart = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'file';
+    file: {
+        uri: string;
+        mimeType: string;
+        name: string;
+    };
+} | {
+    kind: 'data';
+    data: unknown;
+};
+export type AnthropicContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    source: {
+        type: 'url';
+        url: string;
+    };
+} | {
+    type: 'document';
+    source: {
+        type: 'url';
+        url: string;
+    };
+};
+export declare function a2aToContentBlocks(parts: A2APart[]): AnthropicContentBlock[];

package/dist/part-mapper.js

@@ -0,0 +1,21 @@
+const IMAGE_MIME_PREFIX = 'image/';
+const PDF_MIME = 'application/pdf';
+export function a2aToContentBlocks(parts) {
+    return parts.map(part => {
+        switch (part.kind) {
+            case 'text':
+                return { type: 'text', text: part.text };
+            case 'file': {
+                if (part.file.mimeType.startsWith(IMAGE_MIME_PREFIX)) {
+                    return { type: 'image', source: { type: 'url', url: part.file.uri } };
+                }
+                if (part.file.mimeType === PDF_MIME) {
+                    return { type: 'document', source: { type: 'url', url: part.file.uri } };
+                }
+                throw new Error(`Unsupported file mime type: ${part.file.mimeType}`);
+            }
+            case 'data':
+                return { type: 'text', text: JSON.stringify(part.data, null, 2) };
+        }
+    });
+}

package/dist/reload-api.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import type { AgentRegistry } from './agent-registry.js';
+export declare function createReloadApi(registry: AgentRegistry): Router;

package/dist/reload-api.js

@@ -0,0 +1,51 @@
+// src/reload-api.ts
+import { Router } from 'express';
+export function createReloadApi(registry) {
+    const router = Router();
+    router.get('/', (_req, res) => {
+        const items = registry.list().map(id => {
+            const a = registry.get(id);
+            return {
+                id,
+                name: a?.manifest.name,
+                version: a?.manifest.version,
+                position: a?.manifest.monitor?.position,
+            };
+        });
+        res.json({ agents: items });
+    });
+    router.post('/:id/reload', (req, res) => {
+        const { id } = req.params;
+        const result = registry.reload(id);
+        if (!result.ok) {
+            // Discriminate on the error code from the registry rather than parsing
+            // the message string.
+            if (result.code === 'not_found') {
+                res.status(404).json({ error: result.message });
+            }
+            else {
+                // load_error: the on-disk manifest is invalid or a referenced file
+                // is missing. Surface the upstream error to the caller.
+                res.status(500).json({ error: result.message });
+            }
+            return;
+        }
+        res.json({ ok: true, agent: { id, name: result.agent.manifest.name } });
+    });
+    router.post('/:id/position', (req, res) => {
+        const { id } = req.params;
+        const { x, y } = req.body ?? {};
+        if (typeof x !== 'number' || typeof y !== 'number') {
+            res.status(400).json({ error: 'x and y must be numbers' });
+            return;
+        }
+        const agent = registry.get(id);
+        if (!agent) {
+            res.status(404).json({ error: `Agent "${id}" not found` });
+            return;
+        }
+        agent.manifest.monitor = { ...agent.manifest.monitor, position: { x, y } };
+        res.json({ ok: true });
+    });
+    return router;
+}

package/dist/server.d.ts

@@ -0,0 +1,16 @@
+import { createServer as createHttpServer } from 'http';
+import { AgentRegistry } from './agent-registry.js';
+import { createMonitorBus } from './monitor-bus.js';
+export interface CreateServerOptions {
+    agentsDir: string;
+    port?: number;
+    monitorPort?: number;
+    singleAgent?: string;
+}
+export interface DojoServer {
+    registry: AgentRegistry;
+    bus: ReturnType<typeof createMonitorBus>;
+    httpServer: ReturnType<typeof createHttpServer>;
+    close: () => Promise<void>;
+}
+export declare function createServer(opts: CreateServerOptions): Promise<DojoServer>;

package/dist/server.js

@@ -0,0 +1,39 @@
+import { createServer as createHttpServer } from 'http';
+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';
+export async function createServer(opts) {
+    // Create bus FIRST so handlers can reference it
+    const bus = createMonitorBus();
+    const registry = new AgentRegistry(opts.agentsDir);
+    registry.load();
+    setAgentsLoaded(registry.list().length);
+    registry.on('agent_loaded', (e) => {
+        setAgentsLoaded(registry.list().length);
+        bus.emit({ type: 'agent_loaded', ...e });
+    });
+    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;
+    app.use('/agents', createReloadApi(registry));
+    app.use('/metrics', createMetricsRouter());
+    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));
+    }
+    await new Promise((r) => httpServer.listen(opts.port ?? 41241, r));
+    return {
+        registry,
+        bus,
+        httpServer,
+        close: () => new Promise((resolve) => {
+            httpServer.close(() => resolve());
+        }),
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+export interface A2ACardConfig {
+    provider?: {
+        organization: string;
+        url: string;
+    };
+    capabilities?: {
+        streaming?: boolean;
+        pushNotifications?: boolean;
+        stateTransitionHistory?: boolean;
+    };
+    defaultInputModes?: Array<'text' | 'file' | 'data'>;
+    defaultOutputModes?: Array<'text' | 'file' | 'task-status'>;
+    skills?: Array<{
+        id: string;
+        name: string;
+        description: string;
+        tags?: string[];
+        examples?: string[];
+        inputModes?: string[];
+        outputModes?: string[];
+    }>;
+}
+export interface MonitorConfig {
+    position?: {
+        x: number;
+        y: number;
+    };
+    sprite?: string;
+}
+export interface LoadedAgent {
+    manifest: AgentManifest;
+    agentDir: string;
+    fixedContextContent: string;
+    mcpServersPath?: string;
+    hooksPath?: string;
+    settingsPath?: string;
+    agentsPath?: string;
+    sandboxPath?: string;
+}
+export type AgentManifest = {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+    fixedContext: string;
+    systemPromptAppend?: string;
+    model?: string;
+    fallbackModel?: string;
+    executable?: 'bun' | 'deno' | 'node';
+    executableArgs?: string[];
+    pathToClaudeCodeExecutable?: string;
+    extraArgs?: Record<string, string | null>;
+    env?: Record<string, string | undefined>;
+    configDir?: string;
+    tools?: string[] | {
+        type: 'preset';
+        preset: 'claude_code';
+    };
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    toolAliases?: Record<string, string>;
+    permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | 'dontAsk' | 'auto';
+    planModeInstructions?: string;
+    allowDangerouslySkipPermissions?: boolean;
+    permissionPromptToolName?: string;
+    strictMcpConfig?: boolean;
+    additionalDirectories?: string[];
+    hooks?: string;
+    includeHookEvents?: boolean;
+    mcpServers?: string;
+    plugins?: Array<{
+        type: 'local';
+        path: string;
+    }>;
+    skills?: string[] | 'all';
+    settingSources?: Array<'user' | 'project' | 'local'>;
+    settings?: string;
+    agent?: string;
+    agents?: string;
+    agentProgressSummaries?: boolean;
+    forwardSubagentText?: boolean;
+    thinking?: {
+        type: 'adaptive';
+    } | {
+        type: 'enabled';
+        budgetTokens: number;
+    } | {
+        type: 'disabled';
+    };
+    effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+    maxThinkingTokens?: number;
+    maxTurns?: number;
+    maxBudgetUsd?: number;
+    taskBudget?: {
+        tokens: number;
+    };
+    betas?: string[];
+    outputFormat?: {
+        type: 'json_schema';
+        schema: object;
+    };
+    sandbox?: string;
+    forkSession?: boolean;
+    a2aCard?: A2ACardConfig;
+    monitor?: MonitorConfig;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "agents-dojo",
+  "version": "0.1.0",
+  "description": "A2A-compatible Agent framework built on Claude Code SDK",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "agents-dojo": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "vitest run tests/e2e",
+    "start": "node dist/cli.js",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@a2a-js/sdk": "^0.3.13",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.145",
+    "express": "^5.2.1",
+    "strip-json-comments": "^5.0.3",
+    "uuid": "^14.0.0",
+    "ws": "^8.18.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.9.1",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}