@renseiai/agentfactory-server 0.8.0

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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"}