@a2a-js/sdk 0.2.1

package/build/src/server/request_handler/default_request_handler.js

@@ -0,0 +1,296 @@
+import { v4 as uuidv4 } from 'uuid'; // For generating unique IDs
+import { RequestContext } from "../agent_execution/request_context.js";
+import { A2AError } from "../error.js";
+import { DefaultExecutionEventBusManager } from "../events/execution_event_bus_manager.js";
+import { ExecutionEventQueue } from "../events/execution_event_queue.js";
+import { ResultManager } from "../result_manager.js";
+export class DefaultRequestHandler {
+    agentCard;
+    taskStore;
+    agentExecutor;
+    eventBusManager;
+    // Store for push notification configurations (could be part of TaskStore or separate)
+    pushNotificationConfigs = new Map();
+    constructor(agentCard, taskStore, agentExecutor, eventBusManager = new DefaultExecutionEventBusManager()) {
+        this.agentCard = agentCard;
+        this.taskStore = taskStore;
+        this.agentExecutor = agentExecutor;
+        this.eventBusManager = eventBusManager;
+    }
+    async getAgentCard() {
+        return this.agentCard;
+    }
+    async _createRequestContext(incomingMessage, taskId, isStream) {
+        let task;
+        let referenceTasks;
+        // incomingMessage would contain taskId, if a task already exists.
+        if (incomingMessage.taskId) {
+            task = await this.taskStore.load(incomingMessage.taskId);
+            if (!task) {
+                throw A2AError.taskNotFound(incomingMessage.taskId);
+            }
+        }
+        if (incomingMessage.referenceTaskIds && incomingMessage.referenceTaskIds.length > 0) {
+            referenceTasks = [];
+            for (const refId of incomingMessage.referenceTaskIds) {
+                const refTask = await this.taskStore.load(refId);
+                if (refTask) {
+                    referenceTasks.push(refTask);
+                }
+                else {
+                    console.warn(`Reference task ${refId} not found.`);
+                    // Optionally, throw an error or handle as per specific requirements
+                }
+            }
+        }
+        // Ensure contextId is present
+        const messageForContext = { ...incomingMessage };
+        if (!messageForContext.contextId) {
+            messageForContext.contextId = task?.contextId || uuidv4();
+        }
+        const contextId = incomingMessage.contextId || uuidv4();
+        return new RequestContext(messageForContext, taskId, contextId, task, referenceTasks);
+    }
+    async sendMessage(params) {
+        const incomingMessage = params.message;
+        if (!incomingMessage.messageId) {
+            throw A2AError.invalidParams('message.messageId is required.');
+        }
+        const taskId = incomingMessage.taskId || uuidv4();
+        // Instantiate ResultManager before creating RequestContext
+        const resultManager = new ResultManager(this.taskStore);
+        resultManager.setContext(incomingMessage); // Set context for ResultManager
+        const requestContext = await this._createRequestContext(incomingMessage, taskId, false);
+        // Use the (potentially updated) contextId from requestContext
+        const finalMessageForAgent = requestContext.userMessage;
+        const eventBus = this.eventBusManager.createOrGetByTaskId(taskId);
+        const eventQueue = new ExecutionEventQueue(eventBus);
+        // Start agent execution (non-blocking)
+        this.agentExecutor.execute(requestContext, eventBus).catch(err => {
+            console.error(`Agent execution failed for message ${finalMessageForAgent.messageId}:`, err);
+            // Publish a synthetic error event if needed, or handle error reporting
+            // For example, create a Task with a failed status
+            const errorTask = {
+                id: requestContext.task?.id || uuidv4(), // Use existing task ID or generate new
+                contextId: finalMessageForAgent.contextId,
+                status: {
+                    state: "failed",
+                    message: {
+                        kind: "message",
+                        role: "agent",
+                        messageId: uuidv4(),
+                        parts: [{ kind: "text", text: `Agent execution error: ${err.message}` }],
+                        taskId: requestContext.task?.id,
+                        contextId: finalMessageForAgent.contextId,
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+                history: requestContext.task?.history ? [...requestContext.task.history] : [],
+                kind: "task",
+            };
+            if (finalMessageForAgent) { // Add incoming message to history
+                if (!errorTask.history?.find(m => m.messageId === finalMessageForAgent.messageId)) {
+                    errorTask.history?.push(finalMessageForAgent);
+                }
+            }
+            eventBus.publish(errorTask); // This will update the task store via ResultManager
+            eventBus.publish({
+                kind: "status-update",
+                taskId: errorTask.id,
+                contextId: errorTask.contextId,
+                status: errorTask.status,
+                final: true,
+            });
+            eventBus.finished();
+        });
+        for await (const event of eventQueue.events()) {
+            // lastEvent is no longer needed here as ResultManager tracks the final result type
+            await resultManager.processEvent(event);
+        }
+        const finalResult = resultManager.getFinalResult();
+        if (!finalResult) {
+            throw A2AError.internalError('Agent execution finished without a result, and no task context found.');
+        }
+        // Cleanup after processing is complete for taskId
+        this.eventBusManager.cleanupByTaskId(taskId);
+        return finalResult;
+    }
+    async *sendMessageStream(params) {
+        const incomingMessage = params.message;
+        if (!incomingMessage.messageId) {
+            // For streams, messageId might be set by client, or server can generate if not present.
+            // Let's assume client provides it or throw for now.
+            throw A2AError.invalidParams('message.messageId is required for streaming.');
+        }
+        const taskId = incomingMessage.taskId || uuidv4();
+        // Instantiate ResultManager before creating RequestContext
+        const resultManager = new ResultManager(this.taskStore);
+        resultManager.setContext(incomingMessage); // Set context for ResultManager
+        const requestContext = await this._createRequestContext(incomingMessage, taskId, true);
+        const finalMessageForAgent = requestContext.userMessage;
+        const eventBus = this.eventBusManager.createOrGetByTaskId(taskId);
+        const eventQueue = new ExecutionEventQueue(eventBus);
+        // Start agent execution (non-blocking)
+        this.agentExecutor.execute(requestContext, eventBus).catch(err => {
+            console.error(`Agent execution failed for stream message ${finalMessageForAgent.messageId}:`, err);
+            // Publish a synthetic error event if needed
+            const errorTaskStatus = {
+                kind: "status-update",
+                taskId: requestContext.task?.id || uuidv4(), // Use existing or a placeholder
+                contextId: finalMessageForAgent.contextId,
+                status: {
+                    state: "failed",
+                    message: {
+                        kind: "message",
+                        role: "agent",
+                        messageId: uuidv4(),
+                        parts: [{ kind: "text", text: `Agent execution error: ${err.message}` }],
+                        taskId: requestContext.task?.id,
+                        contextId: finalMessageForAgent.contextId,
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+                final: true, // This will terminate the stream for the client
+            };
+            eventBus.publish(errorTaskStatus);
+        });
+        try {
+            for await (const event of eventQueue.events()) {
+                await resultManager.processEvent(event); // Update store in background
+                yield event; // Stream the event to the client
+            }
+        }
+        finally {
+            // Cleanup when the stream is fully consumed or breaks
+            this.eventBusManager.cleanupByTaskId(taskId);
+        }
+    }
+    async getTask(params) {
+        const task = await this.taskStore.load(params.id);
+        if (!task) {
+            throw A2AError.taskNotFound(params.id);
+        }
+        if (params.historyLength !== undefined && params.historyLength >= 0) {
+            if (task.history) {
+                task.history = task.history.slice(-params.historyLength);
+            }
+        }
+        else {
+            // Negative or invalid historyLength means no history
+            task.history = [];
+        }
+        return task;
+    }
+    async cancelTask(params) {
+        const task = await this.taskStore.load(params.id);
+        if (!task) {
+            throw A2AError.taskNotFound(params.id);
+        }
+        // Check if task is in a cancelable state
+        const nonCancelableStates = ["completed", "failed", "canceled", "rejected"];
+        if (nonCancelableStates.includes(task.status.state)) {
+            throw A2AError.taskNotCancelable(params.id);
+        }
+        const eventBus = this.eventBusManager.getByTaskId(params.id);
+        if (eventBus) {
+            await this.agentExecutor.cancelTask(params.id, eventBus);
+        }
+        else {
+            // Here we are marking task as cancelled. We are not waiting for the executor to actually cancel processing.
+            task.status = {
+                state: "canceled",
+                message: {
+                    kind: "message",
+                    role: "agent",
+                    messageId: uuidv4(),
+                    parts: [{ kind: "text", text: "Task cancellation requested by user." }],
+                    taskId: task.id,
+                    contextId: task.contextId,
+                },
+                timestamp: new Date().toISOString(),
+            };
+            // Add cancellation message to history
+            task.history = [...(task.history || []), task.status.message];
+            await this.taskStore.save(task);
+        }
+        const latestTask = await this.taskStore.load(params.id);
+        return latestTask;
+    }
+    async setTaskPushNotificationConfig(params) {
+        if (!this.agentCard.capabilities.pushNotifications) {
+            throw A2AError.pushNotificationNotSupported();
+        }
+        const taskAndHistory = await this.taskStore.load(params.taskId);
+        if (!taskAndHistory) {
+            throw A2AError.taskNotFound(params.taskId);
+        }
+        // Store the config. In a real app, this might be stored in the TaskStore
+        // or a dedicated push notification service.
+        this.pushNotificationConfigs.set(params.taskId, params.pushNotificationConfig);
+        return params;
+    }
+    async getTaskPushNotificationConfig(params) {
+        if (!this.agentCard.capabilities.pushNotifications) {
+            throw A2AError.pushNotificationNotSupported();
+        }
+        const taskAndHistory = await this.taskStore.load(params.id); // Ensure task exists
+        if (!taskAndHistory) {
+            throw A2AError.taskNotFound(params.id);
+        }
+        const config = this.pushNotificationConfigs.get(params.id);
+        if (!config) {
+            throw A2AError.internalError(`Push notification config not found for task ${params.id}.`);
+        }
+        return { taskId: params.id, pushNotificationConfig: config };
+    }
+    async *resubscribe(params) {
+        if (!this.agentCard.capabilities.streaming) {
+            throw A2AError.unsupportedOperation("Streaming (and thus resubscription) is not supported.");
+        }
+        const task = await this.taskStore.load(params.id);
+        if (!task) {
+            throw A2AError.taskNotFound(params.id);
+        }
+        // Yield the current task state first
+        yield task;
+        // If task is already in a final state, no more events will come.
+        const finalStates = ["completed", "failed", "canceled", "rejected"];
+        if (finalStates.includes(task.status.state)) {
+            return;
+        }
+        const eventBus = this.eventBusManager.getByTaskId(params.id);
+        if (!eventBus) {
+            // No active execution for this task, so no live events.
+            console.warn(`Resubscribe: No active event bus for task ${params.id}.`);
+            return;
+        }
+        // Attach a new queue to the existing bus for this resubscription
+        const eventQueue = new ExecutionEventQueue(eventBus);
+        // Note: The ResultManager part is already handled by the original execution flow.
+        // Resubscribe just listens for new events.
+        try {
+            for await (const event of eventQueue.events()) {
+                // We only care about updates related to *this* task.
+                // The event bus might be shared if messageId was reused, though
+                // ExecutionEventBusManager tries to give one bus per original message.
+                if (event.kind === 'status-update' && event.taskId === params.id) {
+                    yield event;
+                }
+                else if (event.kind === 'artifact-update' && event.taskId === params.id) {
+                    yield event;
+                }
+                else if (event.kind === 'task' && event.id === params.id) {
+                    // This implies the task was re-emitted, yield it.
+                    yield event;
+                }
+                // We don't yield 'message' events on resubscribe typically,
+                // as those signal the end of an interaction for the *original* request.
+                // If a 'message' event for the original request terminates the bus, this loop will also end.
+            }
+        }
+        finally {
+            eventQueue.stop();
+        }
+    }
+}
+//# sourceMappingURL=default_request_handler.js.map

package/build/src/server/result_manager.d.ts

@@ -0,0 +1,29 @@
+import { Message, Task } from "../types.js";
+import { AgentExecutionEvent } from "./events/execution_event_bus.js";
+import { TaskStore } from "./store.js";
+export declare class ResultManager {
+    private taskStore;
+    private currentTask?;
+    private latestUserMessage?;
+    private finalMessageResult?;
+    constructor(taskStore: TaskStore);
+    setContext(latestUserMessage: Message): void;
+    /**
+     * Processes an agent execution event and updates the task store.
+     * @param event The agent execution event.
+     */
+    processEvent(event: AgentExecutionEvent): Promise<void>;
+    private saveCurrentTask;
+    /**
+     * Gets the final result, which could be a Message or a Task.
+     * This should be called after the event stream has been fully processed.
+     * @returns The final Message or the current Task.
+     */
+    getFinalResult(): Message | Task | undefined;
+    /**
+     * Gets the task currently being managed by this ResultManager instance.
+     * This task could be one that was started with or one created during agent execution.
+     * @returns The current Task or undefined if no task is active.
+     */
+    getCurrentTask(): Task | undefined;
+}

package/build/src/server/result_manager.js

@@ -0,0 +1,149 @@
+export class ResultManager {
+    taskStore;
+    currentTask;
+    latestUserMessage; // To add to history if a new task is created
+    finalMessageResult; // Stores the message if it's the final result
+    constructor(taskStore) {
+        this.taskStore = taskStore;
+    }
+    setContext(latestUserMessage) {
+        this.latestUserMessage = latestUserMessage;
+    }
+    /**
+     * Processes an agent execution event and updates the task store.
+     * @param event The agent execution event.
+     */
+    async processEvent(event) {
+        if (event.kind === 'message') {
+            this.finalMessageResult = event;
+            // If a message is received, it's usually the final result,
+            // but we continue processing to ensure task state (if any) is also saved.
+            // The ExecutionEventQueue will stop after a message event.
+        }
+        else if (event.kind === 'task') {
+            const taskEvent = event;
+            this.currentTask = { ...taskEvent }; // Make a copy
+            // Ensure the latest user message is in history if not already present
+            if (this.latestUserMessage) {
+                if (!this.currentTask.history?.find(msg => msg.messageId === this.latestUserMessage.messageId)) {
+                    this.currentTask.history = [this.latestUserMessage, ...(this.currentTask.history || [])];
+                }
+            }
+            await this.saveCurrentTask();
+        }
+        else if (event.kind === 'status-update') {
+            const updateEvent = event;
+            if (this.currentTask && this.currentTask.id === updateEvent.taskId) {
+                this.currentTask.status = updateEvent.status;
+                if (updateEvent.status.message) {
+                    // Add message to history if not already present
+                    if (!this.currentTask.history?.find(msg => msg.messageId === updateEvent.status.message.messageId)) {
+                        this.currentTask.history = [...(this.currentTask.history || []), updateEvent.status.message];
+                    }
+                }
+                await this.saveCurrentTask();
+            }
+            else if (!this.currentTask && updateEvent.taskId) {
+                // Potentially an update for a task we haven't seen the 'task' event for yet,
+                // or we are rehydrating. Attempt to load.
+                const loaded = await this.taskStore.load(updateEvent.taskId);
+                if (loaded) {
+                    this.currentTask = loaded;
+                    this.currentTask.status = updateEvent.status;
+                    if (updateEvent.status.message) {
+                        if (!this.currentTask.history?.find(msg => msg.messageId === updateEvent.status.message.messageId)) {
+                            this.currentTask.history = [...(this.currentTask.history || []), updateEvent.status.message];
+                        }
+                    }
+                    await this.saveCurrentTask();
+                }
+                else {
+                    console.warn(`ResultManager: Received status update for unknown task ${updateEvent.taskId}`);
+                }
+            }
+            // If it's a final status update, the ExecutionEventQueue will stop.
+            // The final result will be the currentTask.
+        }
+        else if (event.kind === 'artifact-update') {
+            const artifactEvent = event;
+            if (this.currentTask && this.currentTask.id === artifactEvent.taskId) {
+                if (!this.currentTask.artifacts) {
+                    this.currentTask.artifacts = [];
+                }
+                const existingArtifactIndex = this.currentTask.artifacts.findIndex((art) => art.artifactId === artifactEvent.artifact.artifactId);
+                if (existingArtifactIndex !== -1) {
+                    if (artifactEvent.append) {
+                        // Basic append logic, assuming parts are compatible
+                        // More sophisticated merging might be needed for specific part types
+                        const existingArtifact = this.currentTask.artifacts[existingArtifactIndex];
+                        existingArtifact.parts.push(...artifactEvent.artifact.parts);
+                        if (artifactEvent.artifact.description)
+                            existingArtifact.description = artifactEvent.artifact.description;
+                        if (artifactEvent.artifact.name)
+                            existingArtifact.name = artifactEvent.artifact.name;
+                        if (artifactEvent.artifact.metadata)
+                            existingArtifact.metadata = { ...existingArtifact.metadata, ...artifactEvent.artifact.metadata };
+                    }
+                    else {
+                        this.currentTask.artifacts[existingArtifactIndex] = artifactEvent.artifact;
+                    }
+                }
+                else {
+                    this.currentTask.artifacts.push(artifactEvent.artifact);
+                }
+                await this.saveCurrentTask();
+            }
+            else if (!this.currentTask && artifactEvent.taskId) {
+                // Similar to status update, try to load if task not in memory
+                const loaded = await this.taskStore.load(artifactEvent.taskId);
+                if (loaded) {
+                    this.currentTask = loaded;
+                    if (!this.currentTask.artifacts)
+                        this.currentTask.artifacts = [];
+                    // Apply artifact update logic (as above)
+                    const existingArtifactIndex = this.currentTask.artifacts.findIndex((art) => art.artifactId === artifactEvent.artifact.artifactId);
+                    if (existingArtifactIndex !== -1) {
+                        if (artifactEvent.append) {
+                            this.currentTask.artifacts[existingArtifactIndex].parts.push(...artifactEvent.artifact.parts);
+                        }
+                        else {
+                            this.currentTask.artifacts[existingArtifactIndex] = artifactEvent.artifact;
+                        }
+                    }
+                    else {
+                        this.currentTask.artifacts.push(artifactEvent.artifact);
+                    }
+                    await this.saveCurrentTask();
+                }
+                else {
+                    console.warn(`ResultManager: Received artifact update for unknown task ${artifactEvent.taskId}`);
+                }
+            }
+        }
+    }
+    async saveCurrentTask() {
+        if (this.currentTask) {
+            await this.taskStore.save(this.currentTask);
+        }
+    }
+    /**
+     * Gets the final result, which could be a Message or a Task.
+     * This should be called after the event stream has been fully processed.
+     * @returns The final Message or the current Task.
+     */
+    getFinalResult() {
+        if (this.finalMessageResult) {
+            return this.finalMessageResult;
+        }
+        return this.currentTask;
+    }
+    /**
+     * Gets the task currently being managed by this ResultManager instance.
+     * This task could be one that was started with or one created during agent execution.
+     * @returns The current Task or undefined if no task is active.
+     */
+    getCurrentTask() {
+        return this.currentTask;
+    }
+}
+//# sourceMappingURL=result_manager.js.map

package/build/src/server/store.d.ts

@@ -0,0 +1,25 @@
+import { Task } from "../types.js";
+/**
+ * Simplified interface for task storage providers.
+ * Stores and retrieves the task.
+ */
+export interface TaskStore {
+    /**
+     * Saves a task.
+     * Overwrites existing data if the task ID exists.
+     * @param data An object containing the task.
+     * @returns A promise resolving when the save operation is complete.
+     */
+    save(task: Task): Promise<void>;
+    /**
+     * Loads a task by task ID.
+     * @param taskId The ID of the task to load.
+     * @returns A promise resolving to an object containing the Task, or undefined if not found.
+     */
+    load(taskId: string): Promise<Task | undefined>;
+}
+export declare class InMemoryTaskStore implements TaskStore {
+    private store;
+    load(taskId: string): Promise<Task | undefined>;
+    save(task: Task): Promise<void>;
+}

package/build/src/server/store.js

@@ -0,0 +1,17 @@
+// ========================
+// InMemoryTaskStore
+// ========================
+// Use Task directly for storage
+export class InMemoryTaskStore {
+    store = new Map();
+    async load(taskId) {
+        const entry = this.store.get(taskId);
+        // Return copies to prevent external mutation
+        return entry ? { ...entry } : undefined;
+    }
+    async save(task) {
+        // Store copies to prevent internal mutation if caller reuses objects
+        this.store.set(task.id, { ...task });
+    }
+}
+//# sourceMappingURL=store.js.map

package/build/src/server/transports/jsonrpc_transport_handler.d.ts

@@ -0,0 +1,15 @@
+import { A2AResponse } from "../../a2a_response.js";
+import { A2ARequestHandler } from "../request_handler/a2a_request_handler.js";
+/**
+ * Handles JSON-RPC transport layer, routing requests to A2ARequestHandler.
+ */
+export declare class JsonRpcTransportHandler {
+    private requestHandler;
+    constructor(requestHandler: A2ARequestHandler);
+    /**
+     * Handles an incoming JSON-RPC request.
+     * For streaming methods, it returns an AsyncGenerator of JSONRPCResult.
+     * For non-streaming methods, it returns a Promise of a single JSONRPCMessage (Result or ErrorResponse).
+     */
+    handle(requestBody: any): Promise<A2AResponse | AsyncGenerator<A2AResponse, void, undefined>>;
+}

package/build/src/server/transports/jsonrpc_transport_handler.js

@@ -0,0 +1,114 @@
+import { A2AError } from "../error.js";
+/**
+ * Handles JSON-RPC transport layer, routing requests to A2ARequestHandler.
+ */
+export class JsonRpcTransportHandler {
+    requestHandler;
+    constructor(requestHandler) {
+        this.requestHandler = requestHandler;
+    }
+    /**
+     * Handles an incoming JSON-RPC request.
+     * For streaming methods, it returns an AsyncGenerator of JSONRPCResult.
+     * For non-streaming methods, it returns a Promise of a single JSONRPCMessage (Result or ErrorResponse).
+     */
+    async handle(requestBody) {
+        let rpcRequest;
+        try {
+            if (typeof requestBody === 'string') {
+                rpcRequest = JSON.parse(requestBody);
+            }
+            else if (typeof requestBody === 'object' && requestBody !== null) {
+                rpcRequest = requestBody;
+            }
+            else {
+                throw A2AError.parseError('Invalid request body type.');
+            }
+            if (rpcRequest.jsonrpc !== '2.0' ||
+                !rpcRequest.method ||
+                typeof rpcRequest.method !== 'string') {
+                throw A2AError.invalidRequest('Invalid JSON-RPC request structure.');
+            }
+        }
+        catch (error) {
+            const a2aError = error instanceof A2AError ? error : A2AError.parseError(error.message || 'Failed to parse JSON request.');
+            return {
+                jsonrpc: '2.0',
+                id: (typeof rpcRequest?.id !== 'undefined' ? rpcRequest.id : null),
+                error: a2aError.toJSONRPCError(),
+            };
+        }
+        const { method, params = {}, id: requestId = null } = rpcRequest;
+        try {
+            if (method === 'message/stream' || method === 'tasks/resubscribe') {
+                const agentCard = await this.requestHandler.getAgentCard();
+                if (!agentCard.capabilities.streaming) {
+                    throw A2AError.unsupportedOperation(`Method ${method} requires streaming capability.`);
+                }
+                const agentEventStream = method === 'message/stream'
+                    ? this.requestHandler.sendMessageStream(params)
+                    : this.requestHandler.resubscribe(params);
+                // Wrap the agent event stream into a JSON-RPC result stream
+                return (async function* jsonRpcEventStream() {
+                    try {
+                        for await (const event of agentEventStream) {
+                            yield {
+                                jsonrpc: '2.0',
+                                id: requestId, // Use the original request ID for all streamed responses
+                                result: event,
+                            };
+                        }
+                    }
+                    catch (streamError) {
+                        // If the underlying agent stream throws an error, we need to yield a JSONRPCErrorResponse.
+                        // However, an AsyncGenerator is expected to yield JSONRPCResult.
+                        // This indicates an issue with how errors from the agent's stream are propagated.
+                        // For now, log it. The Express layer will handle the generator ending.
+                        console.error(`Error in agent event stream for ${method} (request ${requestId}):`, streamError);
+                        // Ideally, the Express layer should catch this and send a final error to the client if the stream breaks.
+                        // Or, the agentEventStream itself should yield a final error event that gets wrapped.
+                        // For now, we re-throw so it can be caught by A2AExpressApp's stream handling.
+                        throw streamError;
+                    }
+                })();
+            }
+            else {
+                // Handle non-streaming methods
+                let result;
+                switch (method) {
+                    case 'message/send':
+                        result = await this.requestHandler.sendMessage(params);
+                        break;
+                    case 'tasks/get':
+                        result = await this.requestHandler.getTask(params);
+                        break;
+                    case 'tasks/cancel':
+                        result = await this.requestHandler.cancelTask(params);
+                        break;
+                    case 'tasks/pushNotificationConfig/set':
+                        result = await this.requestHandler.setTaskPushNotificationConfig(params);
+                        break;
+                    case 'tasks/pushNotificationConfig/get':
+                        result = await this.requestHandler.getTaskPushNotificationConfig(params);
+                        break;
+                    default:
+                        throw A2AError.methodNotFound(method);
+                }
+                return {
+                    jsonrpc: '2.0',
+                    id: requestId,
+                    result: result,
+                };
+            }
+        }
+        catch (error) {
+            const a2aError = error instanceof A2AError ? error : A2AError.internalError(error.message || 'An unexpected error occurred.');
+            return {
+                jsonrpc: '2.0',
+                id: requestId,
+                error: a2aError.toJSONRPCError(),
+            };
+        }
+    }
+}
+//# sourceMappingURL=jsonrpc_transport_handler.js.map

package/build/src/server/utils.d.ts

@@ -0,0 +1,22 @@
+import { TaskStatus, Artifact } from "../types.js";
+/**
+ * Generates a timestamp in ISO 8601 format.
+ * @returns The current timestamp as a string.
+ */
+export declare function getCurrentTimestamp(): string;
+/**
+ * Checks if a value is a plain object (excluding arrays and null).
+ * @param value The value to check.
+ * @returns True if the value is a plain object, false otherwise.
+ */
+export declare function isObject(value: unknown): value is Record<string, any>;
+/**
+ * Type guard to check if an object is a TaskStatus update (lacks 'parts').
+ * Used to differentiate yielded updates from the handler.
+ */
+export declare function isTaskStatusUpdate(update: any): update is Omit<TaskStatus, "timestamp">;
+/**
+ * Type guard to check if an object is an Artifact update (has 'parts').
+ * Used to differentiate yielded updates from the handler.
+ */
+export declare function isArtifactUpdate(update: any): update is Artifact;