@supaku/agentfactory-server 0.7.52 → 0.7.55

package/dist/src/a2a-server.d.ts

@@ -0,0 +1,88 @@
+/**
+ * A2A Server Handlers
+ *
+ * Framework-agnostic utilities for exposing AgentFactory fleet capabilities
+ * via the Agent-to-Agent (A2A) protocol. Provides AgentCard generation,
+ * JSON-RPC request routing, and SSE event formatting.
+ *
+ * Consuming applications wire these handlers into their own HTTP server
+ * (Express, Hono, Next.js, etc.) — this module has no framework dependency.
+ */
+import type { A2aAgentCard, A2aAuthScheme, A2aMessage, A2aSkill, A2aTask, A2aTaskEvent, JsonRpcRequest, JsonRpcResponse } from './a2a-types.js';
+/** Configuration for building an AgentCard */
+export interface A2aServerConfig {
+    /** Human-readable agent name */
+    name: string;
+    /** Short description of the agent's purpose */
+    description: string;
+    /** Base URL where A2A endpoints are exposed */
+    url: string;
+    /** Semantic version of the agent (defaults to '1.0.0') */
+    version?: string;
+    /** Explicit skill list; when omitted skills are derived from AgentWorkType */
+    skills?: A2aSkill[];
+    /** Whether the agent supports SSE streaming (defaults to false) */
+    streaming?: boolean;
+    /** Authentication schemes the endpoint accepts */
+    authSchemes?: A2aAuthScheme[];
+}
+/**
+ * Build an A2A AgentCard from the supplied configuration.
+ *
+ * If no explicit skills are provided the card is populated with skills
+ * derived from every known {@link AgentWorkType}.
+ *
+ * @param config - Server configuration
+ * @returns A fully-formed AgentCard
+ */
+export declare function buildAgentCard(config: A2aServerConfig): A2aAgentCard;
+/** Callbacks that the consuming application must supply */
+export interface A2aHandlerOptions {
+    /** Handle an incoming message, optionally targeting an existing task */
+    onSendMessage: (message: A2aMessage, taskId?: string) => Promise<A2aTask>;
+    /** Retrieve an existing task by ID */
+    onGetTask: (taskId: string) => Promise<A2aTask | null>;
+    /** Cancel an existing task by ID */
+    onCancelTask: (taskId: string) => Promise<A2aTask | null>;
+    /**
+     * Verify the Authorization header.
+     * Defaults to Bearer-token verification via {@link verifyApiKey}.
+     */
+    verifyAuth?: (authHeader: string | undefined) => boolean;
+}
+/**
+ * A framework-agnostic function that accepts a parsed JSON-RPC request
+ * (plus an optional Authorization header) and returns a JSON-RPC response.
+ */
+export type A2aRequestHandler = (request: JsonRpcRequest, authHeader?: string) => Promise<JsonRpcResponse>;
+/**
+ * Create a framework-agnostic A2A request handler.
+ *
+ * The returned function processes a single JSON-RPC request and returns
+ * the corresponding response. The consuming application is responsible
+ * for HTTP parsing, serialisation, and transport.
+ *
+ * Supported methods:
+ * - `message/send` — send a message (optionally to an existing task)
+ * - `tasks/get`    — retrieve a task by ID
+ * - `tasks/cancel` — cancel a task by ID
+ *
+ * @param options - Callbacks for task lifecycle and (optional) auth
+ * @returns An async handler function
+ */
+export declare function createA2aRequestHandler(options: A2aHandlerOptions): A2aRequestHandler;
+/**
+ * Format an A2A task event as a Server-Sent Events (SSE) message.
+ *
+ * The output follows the SSE text/event-stream format:
+ * ```
+ * event: <type>
+ * data: <JSON payload>
+ *
+ * ```
+ *
+ * @param event - The task event to format
+ * @returns A string ready to write to an SSE response stream
+ */
+export declare function formatSseEvent(event: A2aTaskEvent): string;
+//# sourceMappingURL=a2a-server.d.ts.map

package/dist/src/a2a-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-server.d.ts","sourceRoot":"","sources":["../../src/a2a-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,UAAU,EACV,QAAQ,EACR,OAAO,EACP,YAAY,EACZ,cAAc,EACd,eAAe,EAChB,MAAM,gBAAgB,CAAA;AAMvB,8CAA8C;AAC9C,MAAM,WAAW,eAAe;IAC9B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,+CAA+C;IAC/C,WAAW,EAAE,MAAM,CAAA;IACnB,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAA;IACX,0DAA0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAA;IACnB,mEAAmE;IACnE,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,kDAAkD;IAClD,WAAW,CAAC,EAAE,aAAa,EAAE,CAAA;CAC9B;AA2ED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,YAAY,CAmBpE;AAMD,2DAA2D;AAC3D,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,aAAa,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACzE,sCAAsC;IACtC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAA;IACtD,oCAAoC;IACpC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAA;IACzD;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAA;CACzD;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,OAAO,EAAE,cAAc,EACvB,UAAU,CAAC,EAAE,MAAM,KAChB,OAAO,CAAC,eAAe,CAAC,CAAA;AAwC7B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,iBAAiB,GAAG,iBAAiB,CAoErF;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAG1D"}

package/dist/src/a2a-server.integration.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration tests for the A2A Server
+ *
+ * Wires the A2A request handler to mock task callbacks and verifies
+ * end-to-end JSON-RPC handling, AgentCard generation, SSE formatting,
+ * and auth integration.
+ */
+export {};
+//# sourceMappingURL=a2a-server.integration.test.d.ts.map

package/dist/src/a2a-server.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-server.integration.test.d.ts","sourceRoot":"","sources":["../../src/a2a-server.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/src/a2a-server.integration.test.js

@@ -0,0 +1,397 @@
+/**
+ * Integration tests for the A2A Server
+ *
+ * Wires the A2A request handler to mock task callbacks and verifies
+ * end-to-end JSON-RPC handling, AgentCard generation, SSE formatting,
+ * and auth integration.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { buildAgentCard, createA2aRequestHandler, formatSseEvent, } from './a2a-server.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeRequest(method, params, id = 'req-1') {
+    return { jsonrpc: '2.0', id, method, params };
+}
+function makeMessage(text, role = 'user') {
+    return { role, parts: [{ type: 'text', text }] };
+}
+function makeTask(overrides = {}) {
+    return {
+        id: 'task-1',
+        status: 'submitted',
+        messages: [],
+        artifacts: [],
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// 1. Full message/send -> task lifecycle
+// ---------------------------------------------------------------------------
+describe('A2A Server — full task lifecycle', () => {
+    it('creates a task via message/send, retrieves it, and cancels it', async () => {
+        // In-memory task store
+        const tasks = new Map();
+        const onSendMessage = vi.fn(async (message, _taskId) => {
+            const task = {
+                id: 'task-lifecycle-1',
+                status: 'working',
+                messages: [message],
+                artifacts: [],
+            };
+            tasks.set(task.id, task);
+            return task;
+        });
+        const onGetTask = vi.fn(async (taskId) => {
+            return tasks.get(taskId) ?? null;
+        });
+        const onCancelTask = vi.fn(async (taskId) => {
+            const task = tasks.get(taskId);
+            if (!task)
+                return null;
+            task.status = 'canceled';
+            return task;
+        });
+        const handler = createA2aRequestHandler({
+            onSendMessage,
+            onGetTask,
+            onCancelTask,
+            verifyAuth: () => true,
+        });
+        // Step 1: Send message
+        const sendRes = await handler(makeRequest('message/send', { message: makeMessage('Build the feature') }));
+        expect(sendRes.error).toBeUndefined();
+        const createdTask = sendRes.result;
+        expect(createdTask.id).toBe('task-lifecycle-1');
+        expect(createdTask.status).toBe('working');
+        expect(createdTask.messages).toHaveLength(1);
+        expect(createdTask.messages[0].parts[0]).toMatchObject({ type: 'text', text: 'Build the feature' });
+        expect(onSendMessage).toHaveBeenCalledWith(makeMessage('Build the feature'), undefined);
+        // Step 2: Get task
+        const getRes = await handler(makeRequest('tasks/get', { taskId: 'task-lifecycle-1' }));
+        expect(getRes.error).toBeUndefined();
+        const retrievedTask = getRes.result;
+        expect(retrievedTask.id).toBe('task-lifecycle-1');
+        expect(retrievedTask.status).toBe('working');
+        expect(onGetTask).toHaveBeenCalledWith('task-lifecycle-1');
+        // Step 3: Cancel task
+        const cancelRes = await handler(makeRequest('tasks/cancel', { taskId: 'task-lifecycle-1' }));
+        expect(cancelRes.error).toBeUndefined();
+        const canceledTask = cancelRes.result;
+        expect(canceledTask.id).toBe('task-lifecycle-1');
+        expect(canceledTask.status).toBe('canceled');
+        expect(onCancelTask).toHaveBeenCalledWith('task-lifecycle-1');
+    });
+    it('returns -32001 when getting a non-existent task', async () => {
+        const handler = createA2aRequestHandler({
+            onSendMessage: vi.fn(async () => makeTask()),
+            onGetTask: vi.fn(async () => null),
+            onCancelTask: vi.fn(async () => null),
+            verifyAuth: () => true,
+        });
+        const res = await handler(makeRequest('tasks/get', { taskId: 'nonexistent' }));
+        expect(res.error?.code).toBe(-32001);
+        expect(res.error?.message).toBe('Task not found');
+    });
+    it('returns -32001 when canceling a non-existent task', async () => {
+        const handler = createA2aRequestHandler({
+            onSendMessage: vi.fn(async () => makeTask()),
+            onGetTask: vi.fn(async () => null),
+            onCancelTask: vi.fn(async () => null),
+            verifyAuth: () => true,
+        });
+        const res = await handler(makeRequest('tasks/cancel', { taskId: 'nonexistent' }));
+        expect(res.error?.code).toBe(-32001);
+        expect(res.error?.message).toBe('Task not found');
+    });
+    it('passes taskId to onSendMessage for follow-up messages', async () => {
+        const onSendMessage = vi.fn(async () => makeTask({ id: 'task-followup', status: 'working' }));
+        const handler = createA2aRequestHandler({
+            onSendMessage,
+            onGetTask: vi.fn(async () => null),
+            onCancelTask: vi.fn(async () => null),
+            verifyAuth: () => true,
+        });
+        await handler(makeRequest('message/send', {
+            message: makeMessage('Continue working'),
+            taskId: 'task-followup',
+        }));
+        expect(onSendMessage).toHaveBeenCalledWith(makeMessage('Continue working'), 'task-followup');
+    });
+    it('returns -32603 when onSendMessage throws an error', async () => {
+        const handler = createA2aRequestHandler({
+            onSendMessage: vi.fn(async () => { throw new Error('Queue overflow'); }),
+            onGetTask: vi.fn(async () => null),
+            onCancelTask: vi.fn(async () => null),
+            verifyAuth: () => true,
+        });
+        const res = await handler(makeRequest('message/send', { message: makeMessage('hello') }));
+        expect(res.error?.code).toBe(-32603);
+        expect(res.error?.message).toBe('Queue overflow');
+    });
+    it('returns -32601 for unknown methods', async () => {
+        const handler = createA2aRequestHandler({
+            onSendMessage: vi.fn(async () => makeTask()),
+            onGetTask: vi.fn(async () => null),
+            onCancelTask: vi.fn(async () => null),
+            verifyAuth: () => true,
+        });
+        const res = await handler(makeRequest('tasks/unknown'));
+        expect(res.error?.code).toBe(-32601);
+        expect(res.error?.message).toContain('Method not found');
+        expect(res.error?.message).toContain('tasks/unknown');
+    });
+    it('always returns JSON-RPC 2.0 version and echoes request id', async () => {
+        const handler = createA2aRequestHandler({
+            onSendMessage: vi.fn(async () => makeTask()),
+            onGetTask: vi.fn(async () => makeTask()),
+            onCancelTask: vi.fn(async () => null),
+            verifyAuth: () => true,
+        });
+        const res = await handler(makeRequest('tasks/get', { taskId: 'task-1' }, 'my-req-42'));
+        expect(res.jsonrpc).toBe('2.0');
+        expect(res.id).toBe('my-req-42');
+    });
+});
+// ---------------------------------------------------------------------------
+// 2. AgentCard generation end-to-end
+// ---------------------------------------------------------------------------
+describe('A2A Server — AgentCard generation', () => {
+    it('builds a complete agent card with all fields', () => {
+        const config = {
+            name: 'FleetCoordinator',
+            description: 'Coordinates work across multiple agents',
+            url: 'https://fleet.example.com/a2a',
+            version: '2.1.0',
+            streaming: true,
+            authSchemes: [
+                { type: 'http', scheme: 'bearer' },
+                { type: 'apiKey', in: 'header', name: 'x-api-key' },
+            ],
+        };
+        const card = buildAgentCard(config);
+        expect(card.name).toBe('FleetCoordinator');
+        expect(card.description).toBe('Coordinates work across multiple agents');
+        expect(card.url).toBe('https://fleet.example.com/a2a');
+        expect(card.version).toBe('2.1.0');
+        expect(card.capabilities.streaming).toBe(true);
+        expect(card.capabilities.pushNotifications).toBe(false);
+        expect(card.capabilities.stateTransitionHistory).toBe(false);
+        expect(card.authentication).toEqual([
+            { type: 'http', scheme: 'bearer' },
+            { type: 'apiKey', in: 'header', name: 'x-api-key' },
+        ]);
+        expect(card.defaultInputContentTypes).toEqual(['text/plain']);
+        expect(card.defaultOutputContentTypes).toEqual(['text/plain']);
+    });
+    it('auto-generates skills from work types when none provided', () => {
+        const card = buildAgentCard({
+            name: 'Worker',
+            description: 'Generic worker',
+            url: 'https://worker.example.com/a2a',
+        });
+        expect(card.skills.length).toBeGreaterThan(0);
+        const skillIds = card.skills.map(s => s.id);
+        expect(skillIds).toContain('code-development');
+        expect(skillIds).toContain('quality-assurance');
+        expect(skillIds).toContain('research-analysis');
+        expect(skillIds).toContain('backlog-creation');
+        expect(skillIds).toContain('inflight-work');
+        expect(skillIds).toContain('acceptance-review');
+        expect(skillIds).toContain('refinement');
+        expect(skillIds).toContain('coordination');
+        expect(skillIds).toContain('qa-coordination');
+        expect(skillIds).toContain('acceptance-coordination');
+        // Each skill should have an id, name, and description
+        for (const skill of card.skills) {
+            expect(skill.id).toBeTruthy();
+            expect(skill.name).toBeTruthy();
+            expect(skill.description).toBeTruthy();
+        }
+    });
+    it('uses explicit skills when provided', () => {
+        const card = buildAgentCard({
+            name: 'Specialist',
+            description: 'A specialist agent',
+            url: 'https://specialist.example.com/a2a',
+            skills: [
+                {
+                    id: 'data-analysis',
+                    name: 'Data Analysis',
+                    description: 'Analyze data sets and produce reports',
+                    tags: ['analysis'],
+                },
+            ],
+        });
+        expect(card.skills).toHaveLength(1);
+        expect(card.skills[0].id).toBe('data-analysis');
+        expect(card.skills[0].name).toBe('Data Analysis');
+        expect(card.skills[0].tags).toEqual(['analysis']);
+    });
+    it('defaults version to 1.0.0 and streaming to false', () => {
+        const card = buildAgentCard({
+            name: 'Default',
+            description: 'Defaults test',
+            url: 'https://default.example.com/a2a',
+        });
+        expect(card.version).toBe('1.0.0');
+        expect(card.capabilities.streaming).toBe(false);
+    });
+    it('omits authentication when no authSchemes provided', () => {
+        const card = buildAgentCard({
+            name: 'NoAuth',
+            description: 'No auth agent',
+            url: 'https://noauth.example.com/a2a',
+        });
+        expect(card.authentication).toBeUndefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// 3. SSE event formatting round-trip
+// ---------------------------------------------------------------------------
+describe('A2A Server — SSE formatting round-trip', () => {
+    it('formats and parses TaskStatusUpdate correctly', () => {
+        const event = {
+            type: 'TaskStatusUpdate',
+            taskId: 'task-rt-1',
+            status: 'working',
+            message: makeMessage('Processing your request...', 'agent'),
+            final: false,
+        };
+        const formatted = formatSseEvent(event);
+        // Parse the SSE output
+        const lines = formatted.split('\n');
+        expect(lines[0]).toBe('event: TaskStatusUpdate');
+        const dataLine = lines[1];
+        expect(dataLine.startsWith('data: ')).toBe(true);
+        const parsed = JSON.parse(dataLine.slice(6));
+        expect(parsed.type).toBe('TaskStatusUpdate');
+        expect(parsed.taskId).toBe('task-rt-1');
+        expect(parsed.status).toBe('working');
+        expect(parsed.message.role).toBe('agent');
+        expect(parsed.message.parts[0].text).toBe('Processing your request...');
+        expect(parsed.final).toBe(false);
+        // Ends with double newline
+        expect(formatted.endsWith('\n\n')).toBe(true);
+    });
+    it('formats and parses TaskArtifactUpdate correctly', () => {
+        const event = {
+            type: 'TaskArtifactUpdate',
+            taskId: 'task-rt-2',
+            artifact: {
+                name: 'output.json',
+                parts: [{ type: 'data', data: { result: 42, status: 'ok' } }],
+            },
+        };
+        const formatted = formatSseEvent(event);
+        const lines = formatted.split('\n');
+        expect(lines[0]).toBe('event: TaskArtifactUpdate');
+        const parsed = JSON.parse(lines[1].slice(6));
+        expect(parsed.type).toBe('TaskArtifactUpdate');
+        expect(parsed.taskId).toBe('task-rt-2');
+        expect(parsed.artifact.name).toBe('output.json');
+        expect(parsed.artifact.parts[0].data).toEqual({ result: 42, status: 'ok' });
+    });
+    it('produces valid SSE format with event and data lines separated by double newline', () => {
+        const event = {
+            type: 'TaskStatusUpdate',
+            taskId: 'task-fmt',
+            status: 'completed',
+            final: true,
+        };
+        const formatted = formatSseEvent(event);
+        // Should match the exact SSE spec: event line, data line, empty line
+        const pattern = /^event: \w+\ndata: .+\n\n$/;
+        expect(formatted).toMatch(pattern);
+    });
+    it('round-trips a completed status event with final: true', () => {
+        const original = {
+            type: 'TaskStatusUpdate',
+            taskId: 'task-complete',
+            status: 'completed',
+            message: makeMessage('All done!', 'agent'),
+            final: true,
+        };
+        const formatted = formatSseEvent(original);
+        const dataLine = formatted.split('\n')[1];
+        const roundTripped = JSON.parse(dataLine.slice(6));
+        expect(roundTripped.type).toBe(original.type);
+        expect(roundTripped.taskId).toBe(original.taskId);
+        expect(roundTripped.status).toBe(original.status);
+        expect(roundTripped.final).toBe(original.final);
+        expect(roundTripped.message).toEqual(original.message);
+    });
+});
+// ---------------------------------------------------------------------------
+// 4. Auth integration
+// ---------------------------------------------------------------------------
+describe('A2A Server — auth integration', () => {
+    function createAuthHandler(validTokens) {
+        const verifyAuth = (authHeader) => {
+            if (!authHeader)
+                return false;
+            const token = authHeader.startsWith('Bearer ')
+                ? authHeader.slice(7)
+                : authHeader;
+            return validTokens.includes(token);
+        };
+        return createA2aRequestHandler({
+            onSendMessage: vi.fn(async () => makeTask()),
+            onGetTask: vi.fn(async () => makeTask()),
+            onCancelTask: vi.fn(async () => makeTask({ status: 'canceled' })),
+            verifyAuth,
+        });
+    }
+    it('allows requests with a valid Bearer token', async () => {
+        const handler = createAuthHandler(['valid-token-123']);
+        const res = await handler(makeRequest('tasks/get', { taskId: 'task-1' }), 'Bearer valid-token-123');
+        expect(res.error).toBeUndefined();
+        expect(res.result).toBeDefined();
+    });
+    it('allows requests with a valid raw API key', async () => {
+        const handler = createAuthHandler(['raw-api-key-456']);
+        const res = await handler(makeRequest('tasks/get', { taskId: 'task-1' }), 'raw-api-key-456');
+        expect(res.error).toBeUndefined();
+        expect(res.result).toBeDefined();
+    });
+    it('rejects requests with an invalid token', async () => {
+        const handler = createAuthHandler(['valid-token-123']);
+        const res = await handler(makeRequest('tasks/get', { taskId: 'task-1' }), 'Bearer wrong-token');
+        expect(res.error?.code).toBe(-32000);
+        expect(res.error?.message).toBe('Unauthorized');
+        expect(res.result).toBeUndefined();
+    });
+    it('rejects requests with no auth header', async () => {
+        const handler = createAuthHandler(['valid-token-123']);
+        const res = await handler(makeRequest('tasks/get', { taskId: 'task-1' }));
+        expect(res.error?.code).toBe(-32000);
+        expect(res.error?.message).toBe('Unauthorized');
+    });
+    it('rejects requests with empty auth header', async () => {
+        const handler = createAuthHandler(['valid-token-123']);
+        const res = await handler(makeRequest('tasks/get', { taskId: 'task-1' }), '');
+        expect(res.error?.code).toBe(-32000);
+        expect(res.error?.message).toBe('Unauthorized');
+    });
+    it('allows different methods when auth passes', async () => {
+        const handler = createAuthHandler(['super-secret']);
+        // message/send
+        const sendRes = await handler(makeRequest('message/send', { message: makeMessage('hi') }), 'Bearer super-secret');
+        expect(sendRes.error).toBeUndefined();
+        // tasks/get
+        const getRes = await handler(makeRequest('tasks/get', { taskId: 'task-1' }), 'Bearer super-secret');
+        expect(getRes.error).toBeUndefined();
+        // tasks/cancel
+        const cancelRes = await handler(makeRequest('tasks/cancel', { taskId: 'task-1' }), 'Bearer super-secret');
+        expect(cancelRes.error).toBeUndefined();
+    });
+    it('blocks all methods when auth fails', async () => {
+        const handler = createAuthHandler(['good-key']);
+        const sendRes = await handler(makeRequest('message/send', { message: makeMessage('hi') }), 'Bearer bad-key');
+        expect(sendRes.error?.code).toBe(-32000);
+        const getRes = await handler(makeRequest('tasks/get', { taskId: 'task-1' }), 'Bearer bad-key');
+        expect(getRes.error?.code).toBe(-32000);
+        const cancelRes = await handler(makeRequest('tasks/cancel', { taskId: 'task-1' }), 'Bearer bad-key');
+        expect(cancelRes.error?.code).toBe(-32000);
+    });
+});

package/dist/src/a2a-server.js

@@ -0,0 +1,235 @@
+/**
+ * A2A Server Handlers
+ *
+ * Framework-agnostic utilities for exposing AgentFactory fleet capabilities
+ * via the Agent-to-Agent (A2A) protocol. Provides AgentCard generation,
+ * JSON-RPC request routing, and SSE event formatting.
+ *
+ * Consuming applications wire these handlers into their own HTTP server
+ * (Express, Hono, Next.js, etc.) — this module has no framework dependency.
+ */
+import { extractBearerToken, verifyApiKey } from './worker-auth.js';
+/**
+ * Mapping from AgentWorkType values to auto-generated skill descriptors.
+ * Used when the caller does not supply an explicit skill list.
+ */
+const WORK_TYPE_SKILLS = {
+    development: {
+        id: 'code-development',
+        name: 'Code Development',
+        description: 'Implement features, fix bugs, and write code changes',
+        tags: ['coding', 'development'],
+    },
+    qa: {
+        id: 'quality-assurance',
+        name: 'Quality Assurance',
+        description: 'Run tests, review code quality, and verify changes',
+        tags: ['testing', 'qa'],
+    },
+    research: {
+        id: 'research-analysis',
+        name: 'Research & Analysis',
+        description: 'Investigate topics, gather information, and produce research reports',
+        tags: ['research', 'analysis'],
+    },
+    'backlog-creation': {
+        id: 'backlog-creation',
+        name: 'Backlog Creation',
+        description: 'Create and prioritize backlog items from requirements',
+        tags: ['planning', 'backlog'],
+    },
+    inflight: {
+        id: 'inflight-work',
+        name: 'In-Flight Work',
+        description: 'Continue work on in-progress tasks',
+        tags: ['workflow'],
+    },
+    acceptance: {
+        id: 'acceptance-review',
+        name: 'Acceptance Review',
+        description: 'Review completed work against acceptance criteria',
+        tags: ['review', 'acceptance'],
+    },
+    refinement: {
+        id: 'refinement',
+        name: 'Refinement',
+        description: 'Refine and improve existing work based on feedback',
+        tags: ['refinement', 'iteration'],
+    },
+    coordination: {
+        id: 'coordination',
+        name: 'Coordination',
+        description: 'Coordinate work across multiple agents and tasks',
+        tags: ['coordination', 'orchestration'],
+    },
+    'qa-coordination': {
+        id: 'qa-coordination',
+        name: 'QA Coordination',
+        description: 'Coordinate quality assurance across multiple agents',
+        tags: ['qa', 'coordination'],
+    },
+    'acceptance-coordination': {
+        id: 'acceptance-coordination',
+        name: 'Acceptance Coordination',
+        description: 'Coordinate acceptance reviews across multiple agents',
+        tags: ['acceptance', 'coordination'],
+    },
+    'refinement-coordination': {
+        id: 'refinement-coordination',
+        name: 'Refinement Coordination',
+        description: 'Coordinate refinement across sub-issues after QA/acceptance failure',
+        tags: ['refinement', 'coordination'],
+    },
+};
+/**
+ * Build an A2A AgentCard from the supplied configuration.
+ *
+ * If no explicit skills are provided the card is populated with skills
+ * derived from every known {@link AgentWorkType}.
+ *
+ * @param config - Server configuration
+ * @returns A fully-formed AgentCard
+ */
+export function buildAgentCard(config) {
+    const skills = config.skills ?? Object.values(WORK_TYPE_SKILLS);
+    return {
+        name: config.name,
+        description: config.description,
+        url: config.url,
+        version: config.version ?? '1.0.0',
+        capabilities: {
+            streaming: config.streaming ?? false,
+            pushNotifications: false,
+            stateTransitionHistory: false,
+        },
+        skills,
+        ...(config.authSchemes && { authentication: config.authSchemes }),
+        defaultInputContentTypes: ['text/plain'],
+        defaultOutputContentTypes: ['text/plain'],
+    };
+}
+// ---- JSON-RPC error helpers ------------------------------------------------
+const JSON_RPC_VERSION = '2.0';
+function rpcError(id, code, message, data) {
+    return {
+        jsonrpc: JSON_RPC_VERSION,
+        id,
+        error: { code, message, ...(data !== undefined && { data }) },
+    };
+}
+function rpcResult(id, result) {
+    return {
+        jsonrpc: JSON_RPC_VERSION,
+        id,
+        result,
+    };
+}
+// ---- Default auth verifier --------------------------------------------------
+function defaultVerifyAuth(authHeader) {
+    const token = extractBearerToken(authHeader ?? null);
+    if (!token)
+        return false;
+    return verifyApiKey(token);
+}
+// ---- Factory ----------------------------------------------------------------
+/**
+ * Create a framework-agnostic A2A request handler.
+ *
+ * The returned function processes a single JSON-RPC request and returns
+ * the corresponding response. The consuming application is responsible
+ * for HTTP parsing, serialisation, and transport.
+ *
+ * Supported methods:
+ * - `message/send` — send a message (optionally to an existing task)
+ * - `tasks/get`    — retrieve a task by ID
+ * - `tasks/cancel` — cancel a task by ID
+ *
+ * @param options - Callbacks for task lifecycle and (optional) auth
+ * @returns An async handler function
+ */
+export function createA2aRequestHandler(options) {
+    const { onSendMessage, onGetTask, onCancelTask } = options;
+    const verifyAuth = options.verifyAuth ?? defaultVerifyAuth;
+    return async (request, authHeader) => {
+        const id = request.id ?? null;
+        // --- Auth check ---
+        if (!verifyAuth(authHeader)) {
+            return rpcError(id, -32000, 'Unauthorized');
+        }
+        // --- Method routing ---
+        switch (request.method) {
+            case 'message/send': {
+                const params = request.params;
+                if (!params || !params.message) {
+                    return rpcError(id, -32602, 'Invalid params: message is required');
+                }
+                const message = params.message;
+                const taskId = params.taskId;
+                try {
+                    const task = await onSendMessage(message, taskId);
+                    return rpcResult(id, task);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : 'Internal error';
+                    return rpcError(id, -32603, msg);
+                }
+            }
+            case 'tasks/get': {
+                const params = request.params;
+                if (!params || typeof params.taskId !== 'string') {
+                    return rpcError(id, -32602, 'Invalid params: taskId is required');
+                }
+                try {
+                    const task = await onGetTask(params.taskId);
+                    if (!task) {
+                        return rpcError(id, -32001, 'Task not found');
+                    }
+                    return rpcResult(id, task);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : 'Internal error';
+                    return rpcError(id, -32603, msg);
+                }
+            }
+            case 'tasks/cancel': {
+                const params = request.params;
+                if (!params || typeof params.taskId !== 'string') {
+                    return rpcError(id, -32602, 'Invalid params: taskId is required');
+                }
+                try {
+                    const task = await onCancelTask(params.taskId);
+                    if (!task) {
+                        return rpcError(id, -32001, 'Task not found');
+                    }
+                    return rpcResult(id, task);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : 'Internal error';
+                    return rpcError(id, -32603, msg);
+                }
+            }
+            default:
+                return rpcError(id, -32601, `Method not found: ${request.method}`);
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// SSE event formatter
+// ---------------------------------------------------------------------------
+/**
+ * Format an A2A task event as a Server-Sent Events (SSE) message.
+ *
+ * The output follows the SSE text/event-stream format:
+ * ```
+ * event: <type>
+ * data: <JSON payload>
+ *
+ * ```
+ *
+ * @param event - The task event to format
+ * @returns A string ready to write to an SSE response stream
+ */
+export function formatSseEvent(event) {
+    const data = JSON.stringify(event);
+    return `event: ${event.type}\ndata: ${data}\n\n`;
+}

package/dist/src/a2a-server.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=a2a-server.test.d.ts.map

package/dist/src/a2a-server.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-server.test.d.ts","sourceRoot":"","sources":["../../src/a2a-server.test.ts"],"names":[],"mappings":""}

package/dist/src/a2a-server.test.js

@@ -0,0 +1,311 @@
+import { describe, it, expect, vi } from 'vitest';
+import { buildAgentCard, createA2aRequestHandler, formatSseEvent } from './a2a-server.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeRequest(method, params, id = 1) {
+    return { jsonrpc: '2.0', id, method, params };
+}
+function makeMessage(text, role = 'user') {
+    return { role, parts: [{ type: 'text', text }] };
+}
+function makeTask(overrides = {}) {
+    return {
+        id: 'task-1',
+        status: 'submitted',
+        messages: [],
+        artifacts: [],
+        ...overrides,
+    };
+}
+/** Build a handler with permissive auth and controllable callbacks */
+function createTestHandler(opts = {}) {
+    const onSendMessage = opts.onSendMessage ?? vi.fn(async () => makeTask());
+    const onGetTask = opts.onGetTask ?? vi.fn(async () => makeTask());
+    const onCancelTask = opts.onCancelTask ?? vi.fn(async () => makeTask());
+    const verifyAuth = opts.verifyAuth ?? (() => true);
+    const handler = createA2aRequestHandler({
+        onSendMessage,
+        onGetTask,
+        onCancelTask,
+        verifyAuth,
+    });
+    return { handler, onSendMessage, onGetTask, onCancelTask };
+}
+// ---------------------------------------------------------------------------
+// buildAgentCard
+// ---------------------------------------------------------------------------
+describe('buildAgentCard', () => {
+    const baseConfig = {
+        name: 'TestAgent',
+        description: 'A test agent',
+        url: 'https://example.com/a2a',
+    };
+    it('generates a valid card from minimal config', () => {
+        const card = buildAgentCard(baseConfig);
+        expect(card.name).toBe('TestAgent');
+        expect(card.description).toBe('A test agent');
+        expect(card.url).toBe('https://example.com/a2a');
+        expect(card.version).toBe('1.0.0');
+        expect(card.capabilities.streaming).toBe(false);
+        expect(card.capabilities.pushNotifications).toBe(false);
+        expect(card.capabilities.stateTransitionHistory).toBe(false);
+        expect(card.defaultInputContentTypes).toEqual(['text/plain']);
+        expect(card.defaultOutputContentTypes).toEqual(['text/plain']);
+    });
+    it('uses the provided version', () => {
+        const card = buildAgentCard({ ...baseConfig, version: '2.3.1' });
+        expect(card.version).toBe('2.3.1');
+    });
+    it('sets streaming capability when configured', () => {
+        const card = buildAgentCard({ ...baseConfig, streaming: true });
+        expect(card.capabilities.streaming).toBe(true);
+    });
+    it('includes authentication schemes when provided', () => {
+        const card = buildAgentCard({
+            ...baseConfig,
+            authSchemes: [{ type: 'http', scheme: 'bearer' }],
+        });
+        expect(card.authentication).toEqual([{ type: 'http', scheme: 'bearer' }]);
+    });
+    it('does not include authentication when not provided', () => {
+        const card = buildAgentCard(baseConfig);
+        expect(card.authentication).toBeUndefined();
+    });
+    it('auto-generates skills from AgentWorkType values when none provided', () => {
+        const card = buildAgentCard(baseConfig);
+        expect(card.skills.length).toBeGreaterThan(0);
+        const ids = card.skills.map((s) => s.id);
+        expect(ids).toContain('code-development');
+        expect(ids).toContain('quality-assurance');
+        expect(ids).toContain('research-analysis');
+        expect(ids).toContain('backlog-creation');
+        expect(ids).toContain('coordination');
+    });
+    it('uses explicit skills when provided, ignoring auto-generation', () => {
+        const customSkills = [
+            { id: 'custom-skill', name: 'Custom', description: 'A custom skill' },
+        ];
+        const card = buildAgentCard({ ...baseConfig, skills: customSkills });
+        expect(card.skills).toEqual(customSkills);
+        expect(card.skills).toHaveLength(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// createA2aRequestHandler — method routing
+// ---------------------------------------------------------------------------
+describe('createA2aRequestHandler', () => {
+    describe('message/send', () => {
+        it('routes message/send and returns the task', async () => {
+            const task = makeTask({ id: 'task-42', status: 'working' });
+            const onSendMessage = vi.fn(async () => task);
+            const { handler } = createTestHandler({ onSendMessage });
+            const message = makeMessage('Hello agent');
+            const res = await handler(makeRequest('message/send', { message }));
+            expect(res.error).toBeUndefined();
+            expect(res.result).toEqual(task);
+            expect(onSendMessage).toHaveBeenCalledWith(message, undefined);
+        });
+        it('passes taskId to onSendMessage when provided', async () => {
+            const onSendMessage = vi.fn(async () => makeTask());
+            const { handler } = createTestHandler({ onSendMessage });
+            const message = makeMessage('Continue working');
+            await handler(makeRequest('message/send', { message, taskId: 'existing-task' }));
+            expect(onSendMessage).toHaveBeenCalledWith(message, 'existing-task');
+        });
+        it('returns -32602 when message param is missing', async () => {
+            const { handler } = createTestHandler();
+            const res = await handler(makeRequest('message/send', {}));
+            expect(res.error?.code).toBe(-32602);
+            expect(res.error?.message).toContain('message is required');
+        });
+        it('returns -32602 when params are missing entirely', async () => {
+            const { handler } = createTestHandler();
+            const res = await handler(makeRequest('message/send'));
+            expect(res.error?.code).toBe(-32602);
+        });
+        it('returns -32603 when onSendMessage throws', async () => {
+            const onSendMessage = vi.fn(async () => {
+                throw new Error('Queue full');
+            });
+            const { handler } = createTestHandler({ onSendMessage });
+            const res = await handler(makeRequest('message/send', { message: makeMessage('hi') }));
+            expect(res.error?.code).toBe(-32603);
+            expect(res.error?.message).toBe('Queue full');
+        });
+    });
+    describe('tasks/get', () => {
+        it('returns the task when found', async () => {
+            const task = makeTask({ id: 'task-99', status: 'completed' });
+            const onGetTask = vi.fn(async () => task);
+            const { handler } = createTestHandler({ onGetTask });
+            const res = await handler(makeRequest('tasks/get', { taskId: 'task-99' }));
+            expect(res.error).toBeUndefined();
+            expect(res.result).toEqual(task);
+            expect(onGetTask).toHaveBeenCalledWith('task-99');
+        });
+        it('returns -32001 when task is not found', async () => {
+            const onGetTask = vi.fn(async () => null);
+            const { handler } = createTestHandler({ onGetTask });
+            const res = await handler(makeRequest('tasks/get', { taskId: 'missing' }));
+            expect(res.error?.code).toBe(-32001);
+            expect(res.error?.message).toBe('Task not found');
+        });
+        it('returns -32602 when taskId is missing', async () => {
+            const { handler } = createTestHandler();
+            const res = await handler(makeRequest('tasks/get', {}));
+            expect(res.error?.code).toBe(-32602);
+            expect(res.error?.message).toContain('taskId is required');
+        });
+        it('returns -32602 when taskId is not a string', async () => {
+            const { handler } = createTestHandler();
+            const res = await handler(makeRequest('tasks/get', { taskId: 123 }));
+            expect(res.error?.code).toBe(-32602);
+        });
+    });
+    describe('tasks/cancel', () => {
+        it('returns the canceled task', async () => {
+            const task = makeTask({ id: 'task-5', status: 'canceled' });
+            const onCancelTask = vi.fn(async () => task);
+            const { handler } = createTestHandler({ onCancelTask });
+            const res = await handler(makeRequest('tasks/cancel', { taskId: 'task-5' }));
+            expect(res.error).toBeUndefined();
+            expect(res.result).toEqual(task);
+            expect(onCancelTask).toHaveBeenCalledWith('task-5');
+        });
+        it('returns -32001 when task is not found', async () => {
+            const onCancelTask = vi.fn(async () => null);
+            const { handler } = createTestHandler({ onCancelTask });
+            const res = await handler(makeRequest('tasks/cancel', { taskId: 'no-such' }));
+            expect(res.error?.code).toBe(-32001);
+            expect(res.error?.message).toBe('Task not found');
+        });
+        it('returns -32602 when taskId is missing', async () => {
+            const { handler } = createTestHandler();
+            const res = await handler(makeRequest('tasks/cancel'));
+            expect(res.error?.code).toBe(-32602);
+        });
+    });
+    describe('unknown method', () => {
+        it('returns -32601 for an unrecognised method', async () => {
+            const { handler } = createTestHandler();
+            const res = await handler(makeRequest('foo/bar'));
+            expect(res.error?.code).toBe(-32601);
+            expect(res.error?.message).toContain('Method not found');
+            expect(res.error?.message).toContain('foo/bar');
+        });
+    });
+    describe('authentication', () => {
+        it('returns -32000 when verifyAuth rejects', async () => {
+            const verifyAuth = () => false;
+            const { handler } = createTestHandler({ verifyAuth });
+            const res = await handler(makeRequest('tasks/get', { taskId: 'x' }));
+            expect(res.error?.code).toBe(-32000);
+            expect(res.error?.message).toBe('Unauthorized');
+        });
+        it('passes the auth header to verifyAuth', async () => {
+            const verifyAuth = vi.fn(() => true);
+            const { handler } = createTestHandler({ verifyAuth });
+            await handler(makeRequest('tasks/get', { taskId: 'x' }), 'Bearer tok-123');
+            expect(verifyAuth).toHaveBeenCalledWith('Bearer tok-123');
+        });
+        it('passes undefined when no auth header is provided', async () => {
+            const verifyAuth = vi.fn(() => true);
+            const { handler } = createTestHandler({ verifyAuth });
+            await handler(makeRequest('tasks/get', { taskId: 'x' }));
+            expect(verifyAuth).toHaveBeenCalledWith(undefined);
+        });
+    });
+    describe('response format', () => {
+        it('always includes jsonrpc 2.0 version', async () => {
+            const { handler } = createTestHandler();
+            const res = await handler(makeRequest('tasks/get', { taskId: 'x' }));
+            expect(res.jsonrpc).toBe('2.0');
+        });
+        it('echoes back the request id', async () => {
+            const { handler } = createTestHandler();
+            const res = await handler(makeRequest('tasks/get', { taskId: 'x' }, 42));
+            expect(res.id).toBe(42);
+        });
+        it('echoes string ids correctly', async () => {
+            const { handler } = createTestHandler();
+            const res = await handler(makeRequest('tasks/get', { taskId: 'x' }, 'req-abc'));
+            expect(res.id).toBe('req-abc');
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// formatSseEvent
+// ---------------------------------------------------------------------------
+describe('formatSseEvent', () => {
+    it('formats a TaskStatusUpdate event', () => {
+        const event = {
+            type: 'TaskStatusUpdate',
+            taskId: 'task-1',
+            status: 'working',
+            final: false,
+        };
+        const result = formatSseEvent(event);
+        expect(result).toBe('event: TaskStatusUpdate\n' +
+            `data: ${JSON.stringify(event)}\n\n`);
+    });
+    it('formats a TaskStatusUpdate with message', () => {
+        const event = {
+            type: 'TaskStatusUpdate',
+            taskId: 'task-2',
+            status: 'completed',
+            message: makeMessage('Done!', 'agent'),
+            final: true,
+        };
+        const result = formatSseEvent(event);
+        expect(result).toContain('event: TaskStatusUpdate\n');
+        expect(result).toContain('"final":true');
+        expect(result).toContain('"text":"Done!"');
+        expect(result.endsWith('\n\n')).toBe(true);
+    });
+    it('formats a TaskArtifactUpdate event', () => {
+        const event = {
+            type: 'TaskArtifactUpdate',
+            taskId: 'task-3',
+            artifact: {
+                name: 'report.md',
+                parts: [{ type: 'text', text: '# Report' }],
+            },
+        };
+        const result = formatSseEvent(event);
+        expect(result).toBe('event: TaskArtifactUpdate\n' +
+            `data: ${JSON.stringify(event)}\n\n`);
+    });
+    it('uses the event type as the SSE event name', () => {
+        const event = {
+            type: 'TaskStatusUpdate',
+            taskId: 'task-1',
+            status: 'failed',
+            final: true,
+        };
+        const lines = formatSseEvent(event).split('\n');
+        expect(lines[0]).toBe('event: TaskStatusUpdate');
+    });
+    it('puts the full JSON payload on the data line', () => {
+        const event = {
+            type: 'TaskStatusUpdate',
+            taskId: 'task-1',
+            status: 'submitted',
+            final: false,
+        };
+        const lines = formatSseEvent(event).split('\n');
+        const dataLine = lines[1];
+        const parsed = JSON.parse(dataLine.replace('data: ', ''));
+        expect(parsed.taskId).toBe('task-1');
+        expect(parsed.status).toBe('submitted');
+    });
+    it('ends with double newline', () => {
+        const event = {
+            type: 'TaskStatusUpdate',
+            taskId: 't',
+            status: 'working',
+            final: false,
+        };
+        expect(formatSseEvent(event)).toMatch(/\n\n$/);
+    });
+});

package/dist/src/a2a-types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * A2A Protocol Types
+ *
+ * TypeScript type definitions for the Agent-to-Agent (A2A) protocol.
+ * Covers AgentCard discovery, JSON-RPC messaging, task lifecycle,
+ * and Server-Sent Events (SSE) streaming.
+ */
+/** Describes an agent's identity, capabilities, and discoverable skills */
+export interface A2aAgentCard {
+    name: string;
+    description: string;
+    url: string;
+    version: string;
+    capabilities: A2aCapabilities;
+    skills: A2aSkill[];
+    authentication?: A2aAuthScheme[];
+    defaultInputContentTypes?: string[];
+    defaultOutputContentTypes?: string[];
+}
+/** Feature flags advertised by the agent */
+export interface A2aCapabilities {
+    streaming: boolean;
+    pushNotifications: boolean;
+    stateTransitionHistory: boolean;
+}
+/** A discrete capability the agent can perform */
+export interface A2aSkill {
+    id: string;
+    name: string;
+    description: string;
+    tags?: string[];
+    examples?: string[];
+}
+/** Authentication scheme supported by the agent endpoint */
+export interface A2aAuthScheme {
+    type: 'apiKey' | 'http' | 'oauth2';
+    /** For http type, e.g. 'bearer' */
+    scheme?: string;
+    /** For apiKey type, e.g. 'header' */
+    in?: string;
+    /** For apiKey type, the header name */
+    name?: string;
+}
+/** A JSON-RPC 2.0 request object */
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+/** A JSON-RPC 2.0 response object */
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: string | number | null;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+/** A JSON-RPC 2.0 error object */
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/** Represents a unit of work managed by the agent */
+export interface A2aTask {
+    id: string;
+    status: A2aTaskStatus;
+    messages: A2aMessage[];
+    artifacts: A2aArtifact[];
+    metadata?: Record<string, unknown>;
+}
+/** Possible states of an A2A task */
+export type A2aTaskStatus = 'submitted' | 'working' | 'input-required' | 'completed' | 'failed' | 'canceled';
+/** A message exchanged between user and agent */
+export interface A2aMessage {
+    role: 'user' | 'agent';
+    parts: A2aPart[];
+    metadata?: Record<string, unknown>;
+}
+/** A content part within a message or artifact */
+export type A2aPart = A2aTextPart | A2aFilePart | A2aDataPart;
+/** Plain text content part */
+export interface A2aTextPart {
+    type: 'text';
+    text: string;
+}
+/** File content part (URI or inline bytes) */
+export interface A2aFilePart {
+    type: 'file';
+    file: {
+        name: string;
+        mimeType: string;
+        uri?: string;
+        bytes?: string;
+    };
+}
+/** Structured data content part */
+export interface A2aDataPart {
+    type: 'data';
+    data: Record<string, unknown>;
+}
+/** An output artifact produced by the agent */
+export interface A2aArtifact {
+    name: string;
+    description?: string;
+    parts: A2aPart[];
+    metadata?: Record<string, unknown>;
+}
+/** Notifies the client of a task status change */
+export interface A2aTaskStatusUpdateEvent {
+    type: 'TaskStatusUpdate';
+    taskId: string;
+    status: A2aTaskStatus;
+    message?: A2aMessage;
+    final: boolean;
+}
+/** Notifies the client of a new or updated artifact */
+export interface A2aTaskArtifactUpdateEvent {
+    type: 'TaskArtifactUpdate';
+    taskId: string;
+    artifact: A2aArtifact;
+}
+/** Union of all SSE event types emitted during task streaming */
+export type A2aTaskEvent = A2aTaskStatusUpdateEvent | A2aTaskArtifactUpdateEvent;
+//# sourceMappingURL=a2a-types.d.ts.map

package/dist/src/a2a-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-types.d.ts","sourceRoot":"","sources":["../../src/a2a-types.ts"],"names":[],"mappings":"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"}

package/dist/src/a2a-types.js

@@ -0,0 +1,8 @@
+/**
+ * A2A Protocol Types
+ *
+ * TypeScript type definitions for the Agent-to-Agent (A2A) protocol.
+ * Covers AgentCard discovery, JSON-RPC messaging, task lifecycle,
+ * and Server-Sent Events (SSE) streaming.
+ */
+export {};

package/dist/src/index.d.ts

@@ -21,4 +21,6 @@ export * from './governor-dedup.js';
 export * from './redis-rate-limiter.js';
 export * from './redis-circuit-breaker.js';
 export * from './quota-tracker.js';
+export * from './a2a-types.js';
+export * from './a2a-server.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAG3B,cAAc,YAAY,CAAA;AAG1B,cAAc,YAAY,CAAA;AAG1B,cAAc,sBAAsB,CAAA;AAGpC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,0BAA0B,CAAA;AAGxC,cAAc,sBAAsB,CAAA;AAGpC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,kBAAkB,CAAA;AAGhC,cAAc,mBAAmB,CAAA;AAGjC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,oBAAoB,CAAA;AAGlC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,uBAAuB,CAAA;AAGrC,cAAc,+BAA+B,CAAA;AAG7C,cAAc,yBAAyB,CAAA;AAGvC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,yBAAyB,CAAA;AAGvC,cAAc,4BAA4B,CAAA;AAG1C,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAG3B,cAAc,YAAY,CAAA;AAG1B,cAAc,YAAY,CAAA;AAG1B,cAAc,sBAAsB,CAAA;AAGpC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,qBAAqB,CAAA;AAGnC,cAAc,0BAA0B,CAAA;AAGxC,cAAc,sBAAsB,CAAA;AAGpC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,kBAAkB,CAAA;AAGhC,cAAc,mBAAmB,CAAA;AAGjC,cAAc,iBAAiB,CAAA;AAG/B,cAAc,oBAAoB,CAAA;AAGlC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,uBAAuB,CAAA;AAGrC,cAAc,+BAA+B,CAAA;AAG7C,cAAc,yBAAyB,CAAA;AAGvC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,yBAAyB,CAAA;AAGvC,cAAc,4BAA4B,CAAA;AAG1C,cAAc,oBAAoB,CAAA;AAGlC,cAAc,gBAAgB,CAAA;AAG9B,cAAc,iBAAiB,CAAA"}

package/dist/src/index.js

@@ -44,3 +44,7 @@ export * from './redis-rate-limiter.js';
 export * from './redis-circuit-breaker.js';
 // Linear API quota tracker (reads rate limit headers)
 export * from './quota-tracker.js';
+// A2A Protocol types
+export * from './a2a-types.js';
+// A2A Server (AgentCard + JSON-RPC handlers)
+export * from './a2a-server.js';

package/dist/src/types.d.ts

@@ -7,5 +7,5 @@
 /**
  * Type of agent work being performed based on issue status
  */
-export type AgentWorkType = 'research' | 'backlog-creation' | 'development' | 'inflight' | 'qa' | 'acceptance' | 'refinement' | 'coordination' | 'qa-coordination' | 'acceptance-coordination';
+export type AgentWorkType = 'research' | 'backlog-creation' | 'development' | 'inflight' | 'qa' | 'acceptance' | 'refinement' | 'refinement-coordination' | 'coordination' | 'qa-coordination' | 'acceptance-coordination';
 //# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,kBAAkB,GAClB,aAAa,GACb,UAAU,GACV,IAAI,GACJ,YAAY,GACZ,YAAY,GACZ,cAAc,GACd,iBAAiB,GACjB,yBAAyB,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,kBAAkB,GAClB,aAAa,GACb,UAAU,GACV,IAAI,GACJ,YAAY,GACZ,YAAY,GACZ,yBAAyB,GACzB,cAAc,GACd,iBAAiB,GACjB,yBAAyB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supaku/agentfactory-server",
-  "version": "0.7.52",
+  "version": "0.7.55",
   "type": "module",
   "description": "Webhook server and distributed worker pool for AgentFactory — Redis queues, issue locks, session management",
   "author": "Supaku (https://supaku.com)",
@@ -44,8 +44,8 @@
   ],
   "dependencies": {
     "ioredis": "^5.4.2",
-    "@supaku/agentfactory": "0.7.52",
-    "@supaku/agentfactory-linear": "0.7.52"
+    "@supaku/agentfactory": "0.7.55",
+    "@supaku/agentfactory-linear": "0.7.55"
   },
   "devDependencies": {
     "@types/node": "^22.5.4",