@microsoft/teams.a2a 2.0.0-preview.3

package/dist/server/tasks/task-manager.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManager = exports.finalStates = void 0;
+const task_utils_1 = require("./task-utils");
+// Handle state transitions for existing tasks
+exports.finalStates = [
+    'completed',
+    'failed',
+    'canceled',
+];
+class TaskManager {
+    taskStore;
+    logger;
+    constructor(taskStore, logger) {
+        this.taskStore = taskStore;
+        this.logger = logger;
+    }
+    applyUpdateToTaskAndHistory(current, update) {
+        const newTask = { ...current.task }; // Shallow copy task
+        const newHistory = [...current.history]; // Shallow copy history
+        if ((0, task_utils_1.isTaskStatusUpdate)(update)) {
+            // Merge status update
+            newTask.status = {
+                ...newTask.status, // Keep existing properties if not overwritten
+                ...update, // Apply updates
+                timestamp: (0, task_utils_1.getCurrentTimestamp)(), // Always update timestamp
+            };
+            // If the update includes an agent message, add it to history
+            if (update.message?.role === 'agent') {
+                newHistory.push(update.message);
+            }
+        }
+        else if ((0, task_utils_1.isArtifactUpdate)(update) ||
+            (Array.isArray(update) && update.every(task_utils_1.isArtifactUpdate))) {
+            // Handle artifact update
+            if (!newTask.artifacts) {
+                newTask.artifacts = [];
+            }
+            else {
+                // Ensure we're working with a copy of the artifacts array
+                newTask.artifacts = [...newTask.artifacts];
+            }
+            const updates = Array.isArray(update) ? update : [update];
+            for (const artifact of updates) {
+                const existingIndex = this.findArtifactIndex(newTask.artifacts, artifact);
+                if (existingIndex >= 0) {
+                    newTask.artifacts[existingIndex] = artifact.append
+                        ? this.appendToArtifact(newTask.artifacts[existingIndex], artifact)
+                        : { ...artifact };
+                }
+                else {
+                    newTask.artifacts.push({ ...artifact });
+                    this.sortArtifacts(newTask.artifacts);
+                }
+            }
+        }
+        return { task: newTask, history: newHistory };
+    }
+    stateChangeOnNewRequest(currentState) {
+        switch (currentState) {
+            case 'completed':
+            case 'failed':
+            case 'canceled':
+                // Reset to submitted when receiving message in final state
+                return 'submitted';
+            case 'input-required':
+                // If the previous state was "input-required", transition to working
+                return 'working';
+            case 'working':
+            case 'submitted':
+            case 'unknown':
+                // No state change needed
+                return null;
+        }
+    }
+    async loadOrCreateTaskAndHistory(taskId, initialMessage, sessionId, // Allow null
+    metadata // Allow null
+    ) {
+        let data = await this.taskStore.load(taskId);
+        let needsSave = false;
+        if (!data) {
+            // Create new task and history
+            const initialTask = {
+                id: taskId,
+                sessionId: sessionId ?? undefined, // Store undefined if null
+                status: {
+                    state: 'submitted', // Start as submitted
+                    timestamp: (0, task_utils_1.getCurrentTimestamp)(),
+                    message: null, // Initial user message goes only to history for now
+                },
+                artifacts: [],
+                metadata: metadata ?? undefined, // Store undefined if null
+            };
+            const initialHistory = [initialMessage]; // History starts with user message
+            data = { task: initialTask, history: initialHistory };
+            needsSave = true; // Mark for saving
+            this.logger.debug(`[Task ${taskId}] Created new task and history.`);
+        }
+        else {
+            this.logger.debug(`[Task ${taskId}] Loaded existing task and history.`);
+            // Add current user message to history
+            // Make a copy before potentially modifying
+            data = { task: data.task, history: [...data.history, initialMessage] };
+            needsSave = true; // History updated, mark for saving
+            // Use the state transition helper
+            const newState = this.stateChangeOnNewRequest(data.task.status.state);
+            if (newState) {
+                const stateUpdate = {
+                    state: newState,
+                    message: newState === 'submitted' ? null : data.task.status.message,
+                };
+                data = this.applyUpdateToTaskAndHistory(data, stateUpdate);
+                this.logger.debug(`[Task ${taskId}] Transitioned state to ${newState}.`);
+            }
+        }
+        // Save if created or modified before returning
+        if (needsSave) {
+            await this.taskStore.save(data);
+        }
+        // Return copies to prevent mutation by caller before handler runs
+        return { task: { ...data.task }, history: [...data.history] };
+    }
+    createTaskContext(task, userMessage, history) {
+        return {
+            task: { ...task }, // Pass a copy
+            userMessage: userMessage,
+            history: [...history], // Pass a copy of the history
+            isCancelled: () => false, // TODO: support this when cancellations are implemented
+        };
+    }
+    isFinalState(current) {
+        return exports.finalStates.includes(current.task.status.state);
+    }
+    createFailedTaskState(failureText) {
+        return {
+            state: 'failed',
+            message: {
+                role: 'agent',
+                parts: [
+                    {
+                        type: 'text',
+                        text: failureText,
+                    },
+                ],
+            },
+        };
+    }
+    createCompletedTaskState(text) {
+        return {
+            state: 'completed',
+            message: {
+                role: 'agent',
+                parts: [
+                    {
+                        type: 'text',
+                        text: text ?? 'task completed',
+                    },
+                ],
+            },
+        };
+    }
+    createTaskStatusEvent(taskId, status, final) {
+        return {
+            id: taskId,
+            status: status,
+            final: final,
+        };
+    }
+    createTaskArtifactEvent(taskId, artifact, final) {
+        return {
+            id: taskId,
+            artifact: artifact,
+            final: final,
+        };
+    }
+    // Private helper methods
+    findArtifactIndex(artifacts, update) {
+        if (update.index !== undefined) {
+            return update.index < artifacts.length ? update.index : -1;
+        }
+        return update.name
+            ? artifacts.findIndex((a) => a.name === update.name)
+            : -1;
+    }
+    appendToArtifact(existing, update) {
+        // Create a deep copy for modification to avoid mutating original
+        const artifact = JSON.parse(JSON.stringify(existing));
+        artifact.parts.push(...update.parts);
+        if (update.metadata) {
+            artifact.metadata = { ...(artifact.metadata || {}), ...update.metadata };
+        }
+        if (update.lastChunk !== undefined)
+            artifact.lastChunk = update.lastChunk;
+        if (update.description)
+            artifact.description = update.description;
+        return artifact;
+    }
+    sortArtifacts(artifacts) {
+        if (artifacts.some((a) => a.index !== undefined)) {
+            artifacts.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+        }
+    }
+}
+exports.TaskManager = TaskManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-manager.js","sourceRoot":"","sources":["../../../src/server/tasks/task-manager.ts"],"names":[],"mappings":"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"}

package/dist/server/tasks/task-store.d.ts

@@ -0,0 +1,8 @@
+import { IStorage } from '@microsoft/teams.common';
+import { ITaskStore, TaskAndHistory } from '../types/a2a-types';
+export declare class TaskStore implements ITaskStore {
+    private storage;
+    constructor(storage: IStorage<string, TaskAndHistory>);
+    save(data: TaskAndHistory): Promise<void>;
+    load(taskId: string): Promise<TaskAndHistory | null>;
+}

package/dist/server/tasks/task-store.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStore = void 0;
+class TaskStore {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async save(data) {
+        return this.storage.set(data.task.id, data);
+    }
+    async load(taskId) {
+        const result = await this.storage.get(taskId);
+        return result ?? null;
+    }
+}
+exports.TaskStore = TaskStore;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1zdG9yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZXJ2ZXIvdGFza3MvdGFzay1zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFJQSxNQUFhLFNBQVM7SUFDRTtJQUFwQixZQUFvQixPQUF5QztRQUF6QyxZQUFPLEdBQVAsT0FBTyxDQUFrQztJQUFJLENBQUM7SUFFbEUsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFvQjtRQUMzQixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ2hELENBQUM7SUFFRCxLQUFLLENBQUMsSUFBSSxDQUFDLE1BQWM7UUFDckIsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUM5QyxPQUFPLE1BQU0sSUFBSSxJQUFJLENBQUM7SUFDMUIsQ0FBQztDQUNKO0FBWEQsOEJBV0MifQ==

package/dist/server/tasks/task-utilities.d.ts

@@ -0,0 +1,27 @@
+import * as schema from '../../common/schema';
+import { TaskAndHistory, TaskContext, TaskUpdate } from '../types/a2a-types';
+/**
+ * Handles task-specific operations like state transitions and updates
+ */
+export declare class TaskUtilities {
+    private activeCancellations;
+    constructor(activeCancellations: Set<string>);
+    createContext(task: schema.Task, userMessage: schema.Message, history: schema.Message[]): TaskContext;
+    withAppliedUpdate(current: TaskAndHistory, update: TaskUpdate): TaskAndHistory;
+    stateChangeOnNewRequest(currentState: schema.TaskState): schema.TaskState | null;
+    createStateUpdate(state: schema.TaskState): TaskUpdate;
+    /**
+     * Creates a status update event object
+     */
+    createTaskStatusEvent(taskId: string, status: schema.TaskStatus, final: boolean): schema.TaskStatusUpdateEvent;
+    /**
+     * Creates an artifact update event object
+     */
+    createTaskArtifactEvent(taskId: string, artifact: schema.Artifact, final: boolean): schema.TaskArtifactUpdateEvent;
+    private applyStatusUpdate;
+    private applyArtifactUpdate;
+    private findArtifactIndex;
+    private appendToArtifact;
+    private sortArtifacts;
+    private isTaskStatusUpdate;
+}

package/dist/server/tasks/task-utilities.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskUtilities = void 0;
+const task_utils_1 = require("./task-utils");
+/**
+ * Handles task-specific operations like state transitions and updates
+ */
+class TaskUtilities {
+    activeCancellations;
+    constructor(activeCancellations) {
+        this.activeCancellations = activeCancellations;
+    }
+    createContext(task, userMessage, history) {
+        return {
+            task: { ...task },
+            userMessage,
+            history: [...history],
+            isCancelled: () => this.activeCancellations.has(task.id),
+        };
+    }
+    withAppliedUpdate(current, update) {
+        return this.isTaskStatusUpdate(update)
+            ? this.applyStatusUpdate(current, update)
+            : this.applyArtifactUpdate(current, update);
+    }
+    stateChangeOnNewRequest(currentState) {
+        switch (currentState) {
+            case 'completed':
+            case 'failed':
+            case 'canceled':
+                // In the original sample, they chose to restart the task.
+                // A stricter approach could be to throw an error here.
+                // Might make sense to make this behavior configurable.
+                throw new Error(`Cannot transition from final state: ${currentState}`);
+            case 'input-required':
+                // If the previous state was "input-required", we can assume the task is still in progress.
+                return 'working';
+            case 'working':
+                return null;
+            case 'submitted':
+                // The orgiinal sample considered this odd, but didn't care
+                return null;
+            case 'unknown':
+                // Let the caller handle this case
+                return null;
+        }
+    }
+    createStateUpdate(state) {
+        if (state === 'submitted') {
+            // If this is a new task, we reset the message
+            return { state, message: null };
+        }
+        return { state };
+    }
+    /**
+     * Creates a status update event object
+     */
+    createTaskStatusEvent(taskId, status, final) {
+        return {
+            id: taskId,
+            status: status,
+            final: final,
+        };
+    }
+    /**
+     * Creates an artifact update event object
+     */
+    createTaskArtifactEvent(taskId, artifact, final) {
+        return {
+            id: taskId,
+            artifact: artifact,
+            final: final,
+        };
+    }
+    applyStatusUpdate(current, update) {
+        const newTask = { ...current.task };
+        const newHistory = [...current.history];
+        // Merge status update
+        newTask.status = {
+            ...newTask.status, // Keep existing properties if not overwritten
+            ...update, // Apply updates
+            timestamp: (0, task_utils_1.getCurrentTimestamp)(), // Always update timestamp
+        };
+        // If the update includes an agent message, add it to history
+        if (update.message?.role === 'agent') {
+            newHistory.push(update.message);
+        }
+        return { task: newTask, history: newHistory };
+    }
+    applyArtifactUpdate(current, update) {
+        const newTask = { ...current.task };
+        newTask.artifacts = newTask.artifacts ? [...newTask.artifacts] : [];
+        const updates = Array.isArray(update) ? update : [update];
+        for (const update of updates) {
+            const existingIndex = this.findArtifactIndex(newTask.artifacts, update);
+            if (existingIndex >= 0) {
+                newTask.artifacts[existingIndex] = update.append
+                    ? this.appendToArtifact(newTask.artifacts[existingIndex], update)
+                    : { ...update };
+            }
+            else {
+                newTask.artifacts.push({ ...update });
+                this.sortArtifacts(newTask.artifacts);
+            }
+        }
+        return { task: newTask, history: current.history };
+    }
+    findArtifactIndex(artifacts, update) {
+        if (update.index !== undefined) {
+            return update.index < artifacts.length ? update.index : -1;
+        }
+        return update.name
+            ? artifacts.findIndex((a) => a.name === update.name)
+            : -1;
+    }
+    appendToArtifact(existing, update) {
+        // Create a deep copy for modification to avoid mutating original
+        const artifact = JSON.parse(JSON.stringify(existing));
+        artifact.parts.push(...update.parts);
+        if (update.metadata) {
+            artifact.metadata = { ...(artifact.metadata || {}), ...update.metadata };
+        }
+        if (update.lastChunk !== undefined)
+            artifact.lastChunk = update.lastChunk;
+        if (update.description)
+            artifact.description = update.description;
+        return artifact;
+    }
+    sortArtifacts(artifacts) {
+        if (artifacts.some((a) => a.index !== undefined)) {
+            artifacts.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+        }
+    }
+    isTaskStatusUpdate(update) {
+        return 'state' in update;
+    }
+}
+exports.TaskUtilities = TaskUtilities;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/server/tasks/task-utils.d.ts

@@ -0,0 +1,22 @@
+import * as schema from '../../common/schema';
+/**
+ * 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<schema.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 schema.Artifact;

package/dist/server/tasks/task-utils.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentTimestamp = getCurrentTimestamp;
+exports.isObject = isObject;
+exports.isTaskStatusUpdate = isTaskStatusUpdate;
+exports.isArtifactUpdate = isArtifactUpdate;
+/**
+ * Generates a timestamp in ISO 8601 format.
+ * @returns The current timestamp as a string.
+ */
+function getCurrentTimestamp() {
+    return new Date().toISOString();
+}
+/**
+ * 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.
+ */
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Type guard to check if an object is a TaskStatus update (lacks 'parts').
+ * Used to differentiate yielded updates from the handler.
+ */
+function isTaskStatusUpdate(update) {
+    // Check if it has 'state' and NOT 'parts' (which Artifacts have)
+    return isObject(update) && 'state' in update && !('parts' in update);
+}
+/**
+ * Type guard to check if an object is an Artifact update (has 'parts').
+ * Used to differentiate yielded updates from the handler.
+ */
+function isArtifactUpdate(update) {
+    // Check if it has 'parts'
+    return isObject(update) && 'parts' in update;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay11dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZXJ2ZXIvdGFza3MvdGFzay11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU1BLGtEQUVDO0FBT0QsNEJBRUM7QUFNRCxnREFLQztBQU1ELDRDQUtDO0FBckNEOzs7R0FHRztBQUNILFNBQWdCLG1CQUFtQjtJQUMvQixPQUFPLElBQUksSUFBSSxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7QUFDcEMsQ0FBQztBQUVEOzs7O0dBSUc7QUFDSCxTQUFnQixRQUFRLENBQUMsS0FBYztJQUNuQyxPQUFPLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxLQUFLLEtBQUssSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUNoRixDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsU0FBZ0Isa0JBQWtCLENBQzlCLE1BQVc7SUFFWCxpRUFBaUU7SUFDakUsT0FBTyxRQUFRLENBQUMsTUFBTSxDQUFDLElBQUksT0FBTyxJQUFJLE1BQU0sSUFBSSxDQUFDLENBQUMsT0FBTyxJQUFJLE1BQU0sQ0FBQyxDQUFDO0FBQ3pFLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxTQUFnQixnQkFBZ0IsQ0FDNUIsTUFBVztJQUVYLDBCQUEwQjtJQUMxQixPQUFPLFFBQVEsQ0FBQyxNQUFNLENBQUMsSUFBSSxPQUFPLElBQUksTUFBTSxDQUFDO0FBQ2pELENBQUMifQ==

package/dist/server/types/a2a-error.d.ts

@@ -0,0 +1,23 @@
+import * as schema from '../../common/schema';
+/**
+ * Custom error class for A2A server operations, incorporating JSON-RPC error codes.
+ */
+export declare class A2AError extends Error implements schema.A2AError {
+    code: schema.KnownErrorCode | number;
+    data?: unknown;
+    taskId?: string | number;
+    constructor(code: schema.KnownErrorCode | number, message: string, data?: unknown, taskId?: string | number);
+    static parseError(message: string, data?: unknown): A2AError;
+    static invalidRequest(message: string, data?: unknown): A2AError;
+    static methodNotFound(method: string): A2AError;
+    static invalidParams(message: string, data?: unknown): A2AError;
+    static internalError(message: string, data?: unknown): A2AError;
+    static taskNotFound(taskId: string): A2AError;
+    static taskNotCancelable(taskId: string): A2AError;
+    static pushNotificationNotSupported(): A2AError;
+    static unsupportedOperation(operation: string): A2AError;
+    /**
+     * Formats the error into a standard JSON-RPC error object structure.
+     */
+    toJSONRPCError(): schema.JSONRPCError<unknown>;
+}

package/dist/server/types/a2a-error.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2AError = void 0;
+const schema = __importStar(require("../../common/schema"));
+/**
+ * Custom error class for A2A server operations, incorporating JSON-RPC error codes.
+ */
+class A2AError extends Error {
+    code;
+    data;
+    taskId; // Optional task ID context
+    constructor(code, message, data, taskId) {
+        super(message);
+        this.name = 'A2AError';
+        this.code = code;
+        this.data = data;
+        this.taskId = taskId; // Store associated task ID if provided
+    }
+    // Static factory methods for common errors
+    static parseError(message, data) {
+        return new A2AError(schema.ErrorCodeParseError, message, data);
+    }
+    static invalidRequest(message, data) {
+        return new A2AError(schema.ErrorCodeInvalidRequest, message, data);
+    }
+    static methodNotFound(method) {
+        return new A2AError(schema.ErrorCodeMethodNotFound, `Method not found: ${method}`);
+    }
+    static invalidParams(message, data) {
+        return new A2AError(schema.ErrorCodeInvalidParams, message, data);
+    }
+    static internalError(message, data) {
+        return new A2AError(schema.ErrorCodeInternalError, message, data);
+    }
+    static taskNotFound(taskId) {
+        return new A2AError(schema.ErrorCodeTaskNotFound, `Task not found: ${taskId}`, undefined, taskId);
+    }
+    static taskNotCancelable(taskId) {
+        return new A2AError(schema.ErrorCodeTaskNotCancelable, `Task not cancelable: ${taskId}`, undefined, taskId);
+    }
+    static pushNotificationNotSupported() {
+        return new A2AError(schema.ErrorCodePushNotificationNotSupported, 'Push Notification is not supported');
+    }
+    static unsupportedOperation(operation) {
+        return new A2AError(schema.ErrorCodeUnsupportedOperation, `Unsupported operation: ${operation}`);
+    }
+    /**
+     * Formats the error into a standard JSON-RPC error object structure.
+     */
+    toJSONRPCError() {
+        const errorObject = {
+            code: this.code,
+            message: this.message,
+        };
+        if (this.data !== undefined) {
+            errorObject.data = this.data;
+        }
+        return errorObject;
+    }
+}
+exports.A2AError = A2AError;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,56 @@
+import * as schema from '../../common/schema';
+export type TaskAndHistory = {
+    task: schema.Task;
+    history: schema.Message[];
+};
+/**
+ * Simplified interface for task storage providers.
+ * Stores and retrieves both the task and its full message history together.
+ */
+export interface ITaskStore {
+    /**
+     * Saves a task and its associated message history.
+     * Overwrites existing data if the task ID exists.
+     * @param data An object containing the task and its history.
+     * @returns A promise resolving when the save operation is complete.
+     */
+    save(data: TaskAndHistory): Promise<void>;
+    /**
+     * Loads a task and its history by task ID.
+     * @param taskId The ID of the task to load.
+     * @returns A promise resolving to an object containing the Task and its history, or null if not found.
+     */
+    load(taskId: string): Promise<TaskAndHistory | null>;
+}
+/**
+ * Context object provided to the TaskHandler.
+ */
+export type TaskContext = {
+    /**
+     * The current state of the task when the handler is invoked or resumed.
+     * Note: This is a snapshot. For the absolute latest state during async operations,
+     * the handler might need to reload the task via the store.
+     */
+    task: schema.Task;
+    /**
+     * The specific user message that triggered this handler invocation or resumption.
+     */
+    userMessage: schema.Message;
+    /**
+     * Function to check if cancellation has been requested for this task.
+     * Handlers should ideally check this periodically during long-running operations.
+     * @returns {boolean} True if cancellation has been requested, false otherwise.
+     */
+    isCancelled(): boolean;
+    /**
+     * The message history associated with the task up to the point the handler is invoked.
+     * Optional, as history might not always be available or relevant.
+     */
+    history?: schema.Message[];
+};
+/**
+ * Represents the possible types of updates a TaskHandler can yield.
+ * It's either a partial TaskStatus (without the server-managed timestamp)
+ * or a complete Artifact object.
+ */
+export type TaskUpdate = Omit<schema.TaskStatus, 'timestamp'> | schema.Artifact | schema.Artifact[];