agents-dojo 0.1.0

package/dist/cli.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import { resolve, join } from 'path';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { createServer } from './server.js';
+// ── init command ──────────────────────────────────────────
+const ECHO_MANIFEST = `{
+  "id": "echo",
+  "name": "Echo Agent",
+  "description": "A minimal example agent that echoes user input.",
+  "version": "0.1.0",
+  "fixedContext": "context.md",
+  "a2aCard": {
+    "skills": [
+      {
+        "id": "echo",
+        "name": "Echo",
+        "description": "Repeats back whatever you send",
+        "tags": ["example"]
+      }
+    ]
+  },
+  "monitor": {
+    "position": { "x": 200, "y": 200 },
+    "sprite": "default"
+  }
+}
+`;
+const ECHO_CONTEXT = `# Role
+
+You are **Echo Agent**, a minimal example agent.
+
+Repeat back the user's input, prefixed with "ECHO:".
+Do not add any other commentary.
+`;
+function runInit(targetDir) {
+    const agentsDir = join(targetDir, 'agents');
+    const echoDir = join(agentsDir, 'echo');
+    if (existsSync(echoDir)) {
+        console.log(`agents/echo/ already exists — skipping.`);
+        return;
+    }
+    mkdirSync(echoDir, { recursive: true });
+    writeFileSync(join(echoDir, 'manifest.jsonc'), ECHO_MANIFEST);
+    writeFileSync(join(echoDir, 'context.md'), ECHO_CONTEXT);
+    console.log(`Created agents/echo/ with manifest.jsonc and context.md.
+
+Next steps:
+  agents-dojo              # start the server
+  agents-dojo --help       # see all options
+
+To add your own agent:
+  mkdir agents/my-agent
+  # create manifest.jsonc and context.md inside it
+`);
+}
+export const DEFAULT_ARGS = {
+    agentsDir: './agents',
+    port: 41241,
+    monitorPort: 41242,
+    singleAgent: null,
+    help: false,
+};
+function parseArgs(argv) {
+    const args = { ...DEFAULT_ARGS };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--help' || a === '-h')
+            args.help = true;
+        else if (a === '--agents-dir' && argv[i + 1])
+            args.agentsDir = resolve(argv[++i]);
+        else if (a.startsWith('--agents-dir='))
+            args.agentsDir = resolve(a.slice('--agents-dir='.length));
+        else if (a === '--port' && argv[i + 1])
+            args.port = parseInt(argv[++i], 10);
+        else if (a === '--monitor-port' && argv[i + 1])
+            args.monitorPort = parseInt(argv[++i], 10);
+        else if (a === '--no-monitor')
+            args.monitorPort = null;
+        else if (a.startsWith('--agent='))
+            args.singleAgent = a.slice('--agent='.length);
+        else if (a === '--agent' && argv[i + 1])
+            args.singleAgent = argv[++i];
+    }
+    return args;
+}
+function printHelp() {
+    console.log(`Usage: agents-dojo [command] [options]
+
+Commands:
+  init                   Create agents/echo/ example in the current directory
+  (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
+  --agent=<id>           Single Agent mode: only load and serve the named agent
+  -h, --help             Show this help
+`);
+}
+async function main() {
+    const rawArgs = process.argv.slice(2);
+    // Handle `agents-dojo init [dir]`
+    if (rawArgs[0] === 'init') {
+        runInit(resolve(rawArgs[1] ?? '.'));
+        return;
+    }
+    const args = parseArgs(rawArgs);
+    if (args.help) {
+        printHelp();
+        return;
+    }
+    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}`);
+    }
+    const server = await createServer({
+        agentsDir: args.agentsDir,
+        port: args.port,
+        monitorPort: args.monitorPort ?? undefined,
+        singleAgent: args.singleAgent ?? undefined,
+    });
+    console.log(`[agents-dojo] ${server.registry.list().length} agents loaded: ${server.registry.list().join(', ')}`);
+    console.log(`[agents-dojo] Ready.`);
+}
+main().catch((err) => {
+    console.error('[agents-dojo] Fatal:', err);
+    process.exit(1);
+});

package/dist/context-manager.d.ts

@@ -0,0 +1,5 @@
+export declare class ContextLoadError extends Error {
+    constructor(message: string);
+}
+export declare function loadContext(agentDir: string, relativePath: string): string;
+export declare function resolveConfigDir(agentDir: string, override?: string): string;

package/dist/context-manager.js

@@ -0,0 +1,30 @@
+// src/context-manager.ts
+import { readFileSync, existsSync } from 'fs';
+import { join, resolve, isAbsolute } from 'path';
+export class ContextLoadError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ContextLoadError';
+    }
+}
+export function loadContext(agentDir, relativePath) {
+    const resolved = isAbsolute(relativePath) ? relativePath : join(agentDir, relativePath);
+    const normalized = resolve(resolved);
+    // Reject path traversal
+    const agentAbs = resolve(agentDir);
+    if (!normalized.startsWith(agentAbs + '/') && normalized !== agentAbs) {
+        throw new ContextLoadError(`Path "${relativePath}" escapes agent directory`);
+    }
+    if (!existsSync(normalized)) {
+        throw new ContextLoadError(`Context file not found: ${normalized}`);
+    }
+    return readFileSync(normalized, 'utf-8');
+}
+export function resolveConfigDir(agentDir, override) {
+    if (override) {
+        if (isAbsolute(override))
+            return override;
+        return join(agentDir, override);
+    }
+    return join(agentDir, '.claude');
+}

package/dist/event-translator.d.ts

@@ -0,0 +1,16 @@
+import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { MonitorBus } from './monitor-bus.js';
+export interface TranslatorContext {
+    agentId: string;
+    taskId: string;
+    contextId: string;
+    bus: {
+        publish: (event: any) => void;
+        finished: () => void;
+    };
+    monitorBus?: MonitorBus;
+}
+export interface Translator {
+    onSdkEvent: (msg: SDKMessage) => void;
+}
+export declare function createTranslator(ctx: TranslatorContext): Translator;

package/dist/event-translator.js

@@ -0,0 +1,142 @@
+// src/event-translator.ts
+import { v4 as uuidv4 } from 'uuid';
+export function createTranslator(ctx) {
+    let finalText = '';
+    // Map tool_use_id -> tool name, so tool_result events (which only carry id)
+    // can be reported back to the monitor with the right name.
+    const toolNames = new Map();
+    function publishWorking(text) {
+        ctx.bus.publish({
+            kind: 'status-update',
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            status: {
+                kind: 'status',
+                state: 'working',
+                message: {
+                    kind: 'message',
+                    role: 'agent',
+                    messageId: uuidv4(),
+                    parts: [{ kind: 'text', text }],
+                    taskId: ctx.taskId,
+                    contextId: ctx.contextId,
+                },
+                timestamp: new Date().toISOString(),
+            },
+            final: false,
+        });
+    }
+    function publishCompleted() {
+        ctx.bus.publish({
+            kind: 'status-update',
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            status: {
+                kind: 'status',
+                state: 'completed',
+                timestamp: new Date().toISOString(),
+            },
+            final: true,
+        });
+        ctx.bus.finished();
+    }
+    function publishFailed(reason) {
+        ctx.bus.publish({
+            kind: 'status-update',
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            status: {
+                kind: 'status',
+                state: 'failed',
+                message: {
+                    kind: 'message',
+                    role: 'agent',
+                    messageId: uuidv4(),
+                    parts: [{ kind: 'text', text: reason }],
+                    taskId: ctx.taskId,
+                    contextId: ctx.contextId,
+                },
+                timestamp: new Date().toISOString(),
+            },
+            final: true,
+        });
+        ctx.bus.finished();
+    }
+    function summarizeInput(input) {
+        if (input == null)
+            return '';
+        if (typeof input === 'string')
+            return input.slice(0, 80);
+        try {
+            const s = JSON.stringify(input);
+            return s.length > 80 ? s.slice(0, 80) + '…' : s;
+        }
+        catch {
+            return '';
+        }
+    }
+    return {
+        onSdkEvent(msg) {
+            const m = msg;
+            if (m.type === 'assistant' && m.message?.content) {
+                for (const block of m.message.content) {
+                    if (block.type === 'text') {
+                        finalText = block.text;
+                        // Treat all assistant text as "thinking" / intermediate
+                        publishWorking(block.text);
+                    }
+                    else if (block.type === 'tool_use' && ctx.monitorBus) {
+                        if (block.id)
+                            toolNames.set(block.id, block.name);
+                        ctx.monitorBus.emit({
+                            type: 'tool_call_start',
+                            taskId: ctx.taskId,
+                            toolName: block.name,
+                            inputSummary: summarizeInput(block.input),
+                        });
+                    }
+                }
+            }
+            else if (m.type === 'user' && m.message?.content && ctx.monitorBus) {
+                const content = Array.isArray(m.message.content) ? m.message.content : [];
+                for (const block of content) {
+                    if (block.type === 'tool_result') {
+                        const id = block.tool_use_id;
+                        const name = block.tool_name || (id && toolNames.get(id)) || 'tool';
+                        ctx.monitorBus.emit({
+                            type: 'tool_call_end',
+                            taskId: ctx.taskId,
+                            toolName: name,
+                            success: !block.is_error,
+                        });
+                    }
+                }
+            }
+            else if (m.type === 'result') {
+                if (m.subtype === 'success' || m.subtype === undefined) {
+                    // Emit the final artifact with the last text we saw
+                    if (finalText) {
+                        ctx.bus.publish({
+                            kind: 'artifact-update',
+                            taskId: ctx.taskId,
+                            contextId: ctx.contextId,
+                            artifact: {
+                                artifactId: uuidv4(),
+                                name: 'Response',
+                                parts: [{ kind: 'text', text: finalText }],
+                            },
+                            append: false,
+                            lastChunk: true,
+                        });
+                    }
+                    publishCompleted();
+                }
+                else {
+                    // error_max_turns, error_during_execution, etc.
+                    const reason = m.errors?.join('; ') || m.subtype;
+                    publishFailed(reason);
+                }
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { createServer } from './server.js';
+export type { CreateServerOptions, DojoServer } from './server.js';
+export { AgentRegistry } from './agent-registry.js';
+export { loadAgent, loadAgents } from './agent-loader.js';
+export type { AgentManifest, LoadedAgent, A2ACardConfig, MonitorConfig } from './types.js';
+export { AgentManifestSchema, A2ACardSchema } from './manifest-schema.js';
+export { a2aToContentBlocks } from './part-mapper.js';
+export { createMonitorBus, type MonitorEvent } from './monitor-bus.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+// src/index.ts
+export { createServer } from './server.js';
+export { AgentRegistry } from './agent-registry.js';
+export { loadAgent, loadAgents } from './agent-loader.js';
+export { AgentManifestSchema, A2ACardSchema } from './manifest-schema.js';
+export { a2aToContentBlocks } from './part-mapper.js';
+export { createMonitorBus } from './monitor-bus.js';

package/dist/manifest-schema.d.ts

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+export declare const A2ASkillSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inputModes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    outputModes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const A2ACardSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodObject<{
+        organization: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        streaming: z.ZodOptional<z.ZodBoolean>;
+        pushNotifications: z.ZodOptional<z.ZodBoolean>;
+        stateTransitionHistory: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    defaultInputModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        text: "text";
+        file: "file";
+        data: "data";
+    }>>>;
+    defaultOutputModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        text: "text";
+        file: "file";
+        "task-status": "task-status";
+    }>>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        inputModes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        outputModes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const AgentManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodString;
+    fixedContext: z.ZodString;
+    systemPromptAppend: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    fallbackModel: z.ZodOptional<z.ZodString>;
+    executable: z.ZodOptional<z.ZodEnum<{
+        bun: "bun";
+        deno: "deno";
+        node: "node";
+    }>>;
+    executableArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    pathToClaudeCodeExecutable: z.ZodOptional<z.ZodString>;
+    extraArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
+    configDir: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        type: z.ZodLiteral<"preset">;
+        preset: z.ZodLiteral<"claude_code">;
+    }, z.core.$strip>]>>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    toolAliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    permissionMode: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        acceptEdits: "acceptEdits";
+        bypassPermissions: "bypassPermissions";
+        plan: "plan";
+        dontAsk: "dontAsk";
+        auto: "auto";
+    }>>;
+    planModeInstructions: z.ZodOptional<z.ZodString>;
+    allowDangerouslySkipPermissions: z.ZodOptional<z.ZodBoolean>;
+    permissionPromptToolName: z.ZodOptional<z.ZodString>;
+    strictMcpConfig: z.ZodOptional<z.ZodBoolean>;
+    additionalDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hooks: z.ZodOptional<z.ZodString>;
+    includeHookEvents: z.ZodOptional<z.ZodBoolean>;
+    mcpServers: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"local">;
+        path: z.ZodString;
+    }, z.core.$strip>>>;
+    skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>>;
+    settingSources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        local: "local";
+        user: "user";
+        project: "project";
+    }>>>;
+    settings: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodString>;
+    agentProgressSummaries: z.ZodOptional<z.ZodBoolean>;
+    forwardSubagentText: z.ZodOptional<z.ZodBoolean>;
+    thinking: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"adaptive">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"enabled">;
+        budgetTokens: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"disabled">;
+    }, z.core.$strip>]>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+    maxThinkingTokens: z.ZodOptional<z.ZodNumber>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    maxBudgetUsd: z.ZodOptional<z.ZodNumber>;
+    taskBudget: z.ZodOptional<z.ZodObject<{
+        tokens: z.ZodNumber;
+    }, z.core.$strip>>;
+    betas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    outputFormat: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"json_schema">;
+        schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, z.core.$strip>>;
+    sandbox: z.ZodOptional<z.ZodString>;
+    forkSession: z.ZodOptional<z.ZodBoolean>;
+    a2aCard: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodOptional<z.ZodObject<{
+            organization: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strip>>;
+        capabilities: z.ZodOptional<z.ZodObject<{
+            streaming: z.ZodOptional<z.ZodBoolean>;
+            pushNotifications: z.ZodOptional<z.ZodBoolean>;
+            stateTransitionHistory: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        defaultInputModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            text: "text";
+            file: "file";
+            data: "data";
+        }>>>;
+        defaultOutputModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            text: "text";
+            file: "file";
+            "task-status": "task-status";
+        }>>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            inputModes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            outputModes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    monitor: z.ZodOptional<z.ZodObject<{
+        position: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+        sprite: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/manifest-schema.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+export const A2ASkillSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    description: z.string().min(1),
+    tags: z.array(z.string()).optional(),
+    examples: z.array(z.string()).optional(),
+    inputModes: z.array(z.string()).optional(),
+    outputModes: z.array(z.string()).optional(),
+});
+export const A2ACardSchema = z.object({
+    provider: z.object({ organization: z.string(), url: z.string() }).optional(),
+    capabilities: z
+        .object({
+        streaming: z.boolean().optional(),
+        pushNotifications: z.boolean().optional(),
+        stateTransitionHistory: z.boolean().optional(),
+    })
+        .optional(),
+    defaultInputModes: z.array(z.enum(['text', 'file', 'data'])).optional(),
+    defaultOutputModes: z.array(z.enum(['text', 'file', 'task-status'])).optional(),
+    skills: z.array(A2ASkillSchema).optional(),
+});
+export const AgentManifestSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    description: z.string().min(1),
+    version: z
+        .string()
+        .regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?(?:\+[0-9A-Za-z-.]+)?$/, 'Must be semver'),
+    fixedContext: z.string().min(1),
+    systemPromptAppend: z.string().optional(),
+    model: z.string().optional(),
+    fallbackModel: z.string().optional(),
+    executable: z.enum(['bun', 'deno', 'node']).optional(),
+    executableArgs: z.array(z.string()).optional(),
+    pathToClaudeCodeExecutable: z.string().optional(),
+    extraArgs: z.record(z.string(), z.string().nullable()).optional(),
+    env: z.record(z.string(), z.string().optional()).optional(),
+    configDir: z.string().optional(),
+    tools: z
+        .union([z.array(z.string()), z.object({ type: z.literal('preset'), preset: z.literal('claude_code') })])
+        .optional(),
+    allowedTools: z.array(z.string()).optional(),
+    disallowedTools: z.array(z.string()).optional(),
+    toolAliases: z.record(z.string(), z.string()).optional(),
+    permissionMode: z
+        .enum(['default', 'acceptEdits', 'bypassPermissions', 'plan', 'dontAsk', 'auto'])
+        .optional(),
+    planModeInstructions: z.string().optional(),
+    allowDangerouslySkipPermissions: z.boolean().optional(),
+    permissionPromptToolName: z.string().optional(),
+    strictMcpConfig: z.boolean().optional(),
+    additionalDirectories: z.array(z.string()).optional(),
+    hooks: z.string().optional(),
+    includeHookEvents: z.boolean().optional(),
+    mcpServers: z.string().optional(),
+    plugins: z
+        .array(z.object({
+        type: z.literal('local'),
+        path: z.string(),
+    }))
+        .optional(),
+    skills: z.union([z.literal('all'), z.array(z.string())]).optional(),
+    settingSources: z.array(z.enum(['user', 'project', 'local'])).optional(),
+    settings: z.string().optional(),
+    agent: z.string().optional(),
+    agents: z.string().optional(),
+    agentProgressSummaries: z.boolean().optional(),
+    forwardSubagentText: z.boolean().optional(),
+    thinking: z
+        .union([
+        z.object({ type: z.literal('adaptive') }),
+        z.object({ type: z.literal('enabled'), budgetTokens: z.number() }),
+        z.object({ type: z.literal('disabled') }),
+    ])
+        .optional(),
+    effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
+    maxThinkingTokens: z.number().optional(),
+    maxTurns: z.number().optional(),
+    maxBudgetUsd: z.number().optional(),
+    taskBudget: z.object({ tokens: z.number() }).optional(),
+    betas: z.array(z.string()).optional(),
+    outputFormat: z.object({ type: z.literal('json_schema'), schema: z.record(z.string(), z.any()) }).optional(),
+    sandbox: z.string().optional(),
+    forkSession: z.boolean().optional(),
+    a2aCard: A2ACardSchema.optional(),
+    monitor: z
+        .object({
+        position: z.object({ x: z.number(), y: z.number() }).optional(),
+        sprite: z.string().optional(),
+    })
+        .optional(),
+});

package/dist/metrics.d.ts

@@ -0,0 +1,5 @@
+import { Router } from 'express';
+export declare function recordTaskStart(): void;
+export declare function recordTaskEnd(success: boolean): void;
+export declare function setAgentsLoaded(n: number): void;
+export declare function createMetricsRouter(): Router;

package/dist/metrics.js

@@ -0,0 +1,29 @@
+// src/metrics.ts
+import { Router } from 'express';
+let tasksTotal = 0;
+let tasksFailed = 0;
+let agentsLoaded = 0;
+const startTime = Date.now();
+export function recordTaskStart() {
+    // Reserved for future use (e.g. active gauge); counters are incremented in recordTaskEnd
+}
+export function recordTaskEnd(success) {
+    tasksTotal++;
+    if (!success)
+        tasksFailed++;
+}
+export function setAgentsLoaded(n) {
+    agentsLoaded = n;
+}
+export function createMetricsRouter() {
+    const router = Router();
+    router.get('/', (_req, res) => {
+        res.json({
+            agents_loaded: agentsLoaded,
+            tasks_total: tasksTotal,
+            tasks_failed: tasksFailed,
+            uptime_seconds: Math.floor((Date.now() - startTime) / 1000),
+        });
+    });
+    return router;
+}

package/dist/monitor-bus.d.ts

@@ -0,0 +1,40 @@
+export type MonitorEvent = {
+    type: 'agent_loaded';
+    agentId: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'agent_reloaded';
+    agentId: string;
+} | {
+    type: 'task_created';
+    taskId: string;
+    contextId: string;
+    from: string;
+    to: string;
+    preview: string;
+} | {
+    type: 'task_status';
+    taskId: string;
+    state: string;
+    message?: string;
+} | {
+    type: 'tool_call_start';
+    taskId: string;
+    toolName: string;
+    inputSummary: string;
+} | {
+    type: 'tool_call_end';
+    taskId: string;
+    toolName: string;
+    success: boolean;
+};
+export type MonitorSubscriber = (event: MonitorEvent) => void;
+export type Unsubscribe = () => void;
+export interface MonitorBus {
+    subscribe(fn: MonitorSubscriber): Unsubscribe;
+    emit(event: MonitorEvent): void;
+}
+export declare function createMonitorBus(): MonitorBus;