@a2a-js/sdk 0.2.2 → 0.2.3

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

@@ -1,340 +0,0 @@
-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";
-const terminalStates = ["completed", "failed", "canceled", "rejected"];
-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 (terminalStates.includes(task.status.state)) {
-                // Throw an error that conforms to the JSON-RPC Invalid Request error specification.
-                throw A2AError.invalidRequest(`Task ${task.id} is in a terminal state (${task.status.state}) and cannot be modified.`);
-            }
-        }
-        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 _processEvents(taskId, resultManager, eventQueue, options) {
-        let firstResultSent = false;
-        try {
-            for await (const event of eventQueue.events()) {
-                await resultManager.processEvent(event);
-                if (options?.firstResultResolver && !firstResultSent) {
-                    if (event.kind === 'message' || event.kind === 'task') {
-                        options.firstResultResolver(event);
-                        firstResultSent = true;
-                    }
-                }
-            }
-            if (options?.firstResultRejector && !firstResultSent) {
-                options.firstResultRejector(A2AError.internalError('Execution finished before a message or task was produced.'));
-            }
-        }
-        catch (error) {
-            console.error(`Event processing loop failed for task ${taskId}:`, error);
-            if (options?.firstResultRejector && !firstResultSent) {
-                options.firstResultRejector(error);
-            }
-            // re-throw error for blocking case to catch
-            throw error;
-        }
-        finally {
-            this.eventBusManager.cleanupByTaskId(taskId);
-        }
-    }
-    async sendMessage(params) {
-        const incomingMessage = params.message;
-        if (!incomingMessage.messageId) {
-            throw A2AError.invalidParams('message.messageId is required.');
-        }
-        // Default to blocking behavior if 'blocking' is not explicitly false.
-        const isBlocking = params.configuration?.blocking !== false;
-        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);
-        // EventQueue should be attached to the bus, before the agent execution begins.
-        const eventQueue = new ExecutionEventQueue(eventBus);
-        // Start agent execution (non-blocking).
-        // It runs in the background and publishes events to the eventBus.
-        this.agentExecutor.execute(requestContext, eventBus).catch(err => {
-            console.error(`Agent execution failed for message ${finalMessageForAgent.messageId}:`, err);
-            // Publish a synthetic error event, which will be handled by the ResultManager
-            // and will also settle the firstResultPromise for non-blocking calls.
-            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);
-            eventBus.publish({
-                kind: "status-update",
-                taskId: errorTask.id,
-                contextId: errorTask.contextId,
-                status: errorTask.status,
-                final: true,
-            });
-            eventBus.finished();
-        });
-        if (isBlocking) {
-            // In blocking mode, wait for the full processing to complete.
-            await this._processEvents(taskId, resultManager, eventQueue);
-            const finalResult = resultManager.getFinalResult();
-            if (!finalResult) {
-                throw A2AError.internalError('Agent execution finished without a result, and no task context found.');
-            }
-            return finalResult;
-        }
-        else {
-            // In non-blocking mode, return a promise that will be settled by fullProcessing.
-            return new Promise((resolve, reject) => {
-                this._processEvents(taskId, resultManager, eventQueue, {
-                    firstResultResolver: resolve,
-                    firstResultRejector: reject,
-                });
-            });
-        }
-    }
-    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

@@ -1,29 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,17 +0,0 @@
-// ========================
-// 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

@@ -1,15 +0,0 @@
-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>>;
-}