@artinet/sdk 0.5.18 → 0.6.0-preview.1

package/dist/types/{interfaces/services/mcp/service.d.ts → mcp/mcp.d.ts}

@@ -10,11 +10,11 @@
  * managing service lifecycle.
  *
  * @module MCPService
- * @version 0.5.7
+ * @version 0.6.0-preview
  * @since 0.5.7
  * @author The Artinet Project
  */
-import { ServiceInterface } from "../core/index.js";
+import { core } from "../core/index.js";
 /**
  * Main interface for MCP service implementations.
  *
@@ -40,10 +40,11 @@ import { ServiceInterface } from "../core/index.js";
  * @public
  * @since 0.5.7
  */
-export interface MCPServiceInterface extends Omit<ServiceInterface, "execute"> {
+export interface Service extends Omit<core.Service, "execute"> {
     /**
      * Registers tools for the MCP service.
      * @param uri - The URI of the agent card resource.
      */
     registerTools?: (uri: string) => void;
 }
+export * from "@artinet/types/mcp";

package/dist/{browser/types/interfaces/services/a2a/engine.js → types/mcp/mcp.js}

@@ -2,4 +2,4 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-export {};
+export * from "@artinet/types/mcp";

package/dist/types/storage.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Interface for a store of data.
+ * @deprecated Use IStore instead
+ * @template T - The type of data to store
+ */
+export interface Store<T> {
+    set(data: T, id?: string): Promise<void>;
+    get(id: string): Promise<T | undefined>;
+}
+/**
+ * Interface for a store of data.
+ * @template T - The type of data to store
+ */
+export interface IStore<T> {
+    set(id: string, data: T): Promise<void>;
+    get(id: string): Promise<T | undefined>;
+}

package/dist/utils/common/constants.d.ts

@@ -2,10 +2,10 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { TaskState, TaskStatusUpdateEvent, Message } from "../../types/index.js";
-export declare const STATUS_UPDATE: (taskId: string, contextId: string, status: TaskState, message?: Message, timestamp?: string, final?: boolean) => TaskStatusUpdateEvent;
-export declare const WORKING_UPDATE: (taskId: string, contextId: string, message?: Message, timestamp?: string) => TaskStatusUpdateEvent;
-export declare const CANCEL_UPDATE: (taskId: string, contextId: string, message?: Message, timestamp?: string) => TaskStatusUpdateEvent;
-export declare const SUBMITTED_UPDATE: (taskId: string, contextId: string, message?: Message, timestamp?: string) => TaskStatusUpdateEvent;
-export declare const FAILED_UPDATE_EVENT: (taskId: string, contextId: string, message?: Message, timestamp?: string) => TaskStatusUpdateEvent;
-export declare const FINAL_STATES: TaskState[];
+import { A2A } from "../../types/index.js";
+export declare const STATUS_UPDATE: (taskId: string, contextId: string, status: A2A.TaskState, message?: A2A.Message, timestamp?: string, final?: boolean) => A2A.TaskStatusUpdateEvent;
+export declare const WORKING_UPDATE: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+export declare const CANCEL_UPDATE: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+export declare const SUBMITTED_UPDATE: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+export declare const FAILED_UPDATE_EVENT: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+export declare const FINAL_STATES: A2A.TaskState[];

package/dist/utils/common/constants.js

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { TaskState } from "../../types/index.js";
+import { A2A } from "../../types/index.js";
 import { getCurrentTimestamp } from "./utils.js";
 //todo: protocol specific so move to a2a folder
 export const STATUS_UPDATE = (taskId, contextId, status, message, timestamp = getCurrentTimestamp(), final = false) => {
@@ -19,20 +19,20 @@ export const STATUS_UPDATE = (taskId, contextId, status, message, timestamp = ge
     };
 };
 export const WORKING_UPDATE = (taskId, contextId, message, timestamp) => {
-    return STATUS_UPDATE(taskId, contextId, TaskState.working, message, timestamp);
+    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.working, message, timestamp);
 };
 export const CANCEL_UPDATE = (taskId, contextId, message, timestamp) => {
-    return STATUS_UPDATE(taskId, contextId, TaskState.canceled, message, timestamp, true);
+    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.canceled, message, timestamp, true);
 };
 export const SUBMITTED_UPDATE = (taskId, contextId, message, timestamp) => {
-    return STATUS_UPDATE(taskId, contextId, TaskState.submitted, message, timestamp);
+    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.submitted, message, timestamp);
 };
 export const FAILED_UPDATE_EVENT = (taskId, contextId, message, timestamp) => {
-    return STATUS_UPDATE(taskId, contextId, TaskState.failed, message, timestamp, true);
+    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.failed, message, timestamp, true);
 };
 export const FINAL_STATES = [
-    TaskState.completed,
-    TaskState.failed,
-    TaskState.canceled,
-    TaskState.rejected,
+    A2A.TaskState.completed,
+    A2A.TaskState.failed,
+    A2A.TaskState.canceled,
+    A2A.TaskState.rejected,
 ];

package/dist/utils/common/errors.d.ts

@@ -2,23 +2,23 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { A2AError, InvalidParamsError, InvalidRequestError, JSONRPCError, MethodNotFoundError, InternalError, TaskNotFoundError, TaskNotCancelableError, ContentTypeNotSupportedError, InvalidAgentResponseError, TaskStatusUpdateEvent, JSONParseError, AuthenticatedExtendedCardNotConfiguredError } from "../../types/index.js";
-export declare class SystemError<T extends JSONRPCError> extends Error {
+import { A2A, MCP } from "../../types/index.js";
+export declare class SystemError<T extends MCP.JSONRPCError> extends Error {
     message: string;
-    code: T["code"];
-    data: T["data"];
-    constructor(message: string, code: T["code"], data: T["data"]);
+    code: T["error"]["code"];
+    data: T["error"]["data"];
+    constructor(message: string, code: T["error"]["code"], data: T["error"]["data"]);
 }
-export declare const PARSE_ERROR: <T extends JSONParseError>(data: T["data"]) => SystemError<T>;
-export declare const INVALID_REQUEST: <T extends InvalidRequestError>(data: T["data"]) => SystemError<T>;
-export declare const METHOD_NOT_FOUND: <T extends MethodNotFoundError>(data: T["data"]) => SystemError<T>;
-export declare const INVALID_PARAMS: <T extends InvalidParamsError>(data: T["data"]) => SystemError<T>;
-export declare const INTERNAL_ERROR: <T extends InternalError>(data: T["data"]) => SystemError<T>;
-export declare const TASK_NOT_FOUND: <T extends TaskNotFoundError>(data: T["data"]) => SystemError<T>;
-export declare const TASK_NOT_CANCELABLE: <T extends TaskNotCancelableError>(data: T["data"]) => SystemError<T>;
-export declare const PUSH_NOTIFICATION_NOT_SUPPORTED: <T extends A2AError>(data: T["data"]) => SystemError<T>;
-export declare const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED: <T extends AuthenticatedExtendedCardNotConfiguredError>(data: T["data"]) => SystemError<T>;
-export declare const UNSUPPORTED_OPERATION: <T extends A2AError>(data: T["data"]) => SystemError<T>;
-export declare const CONTENT_TYPE_NOT_SUPPORTED: <T extends ContentTypeNotSupportedError>(data: T["data"]) => SystemError<T>;
-export declare const INVALID_AGENT_RESPONSE: <T extends InvalidAgentResponseError>(data: T["data"]) => SystemError<T>;
-export declare const FAILED_UPDATE: (taskId: string, contextId: string, messageId: string | undefined, errMessage: string) => TaskStatusUpdateEvent;
+export declare const PARSE_ERROR: <T extends A2A.JSONParseError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INVALID_REQUEST: <T extends A2A.InvalidRequestError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const METHOD_NOT_FOUND: <T extends A2A.MethodNotFoundError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INVALID_PARAMS: <T extends A2A.InvalidParamsError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INTERNAL_ERROR: <T extends A2A.InternalError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const TASK_NOT_FOUND: <T extends A2A.TaskNotFoundError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const TASK_NOT_CANCELABLE: <T extends A2A.TaskNotCancelableError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const PUSH_NOTIFICATION_NOT_SUPPORTED: <T extends A2A.A2AError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED: <T extends A2A.AuthenticatedExtendedCardNotConfiguredError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const UNSUPPORTED_OPERATION: <T extends A2A.A2AError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const CONTENT_TYPE_NOT_SUPPORTED: <T extends A2A.ContentTypeNotSupportedError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INVALID_AGENT_RESPONSE: <T extends A2A.InvalidAgentResponseError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const FAILED_UPDATE: (taskId: string, contextId: string, messageId: string | undefined, errMessage: string) => A2A.TaskStatusUpdateEvent;

package/dist/utils/common/errors.js

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ErrorCodeInternalError, ErrorCodeInvalidRequest, ErrorCodeMethodNotFound, ErrorCodeParseError, ErrorCodeInvalidParams, ErrorCodeTaskNotFound, ErrorCodeTaskNotCancelable, ErrorCodeUnsupportedOperation, ErrorCodePushNotificationNotSupported, ErrorCodeContentTypeNotSupported, ErrorCodeInvalidAgentResponse, TaskState, ErrorCodeAuthenticatedExtendedCardNotConfigured, } from "../../types/index.js";
+import { A2A } from "../../types/index.js";
 export class SystemError extends Error {
     message;
     code;
@@ -16,25 +16,25 @@ export class SystemError extends Error {
     }
 }
 // Factory methods for common errors
-export const PARSE_ERROR = (data) => new SystemError("Invalid JSON payload", ErrorCodeParseError, data);
-export const INVALID_REQUEST = (data) => new SystemError("Request payload validation error", ErrorCodeInvalidRequest, data);
-export const METHOD_NOT_FOUND = (data) => new SystemError("Method not found", ErrorCodeMethodNotFound, data);
-export const INVALID_PARAMS = (data) => new SystemError("Invalid parameters", ErrorCodeInvalidParams, data);
-export const INTERNAL_ERROR = (data) => new SystemError("Internal error", ErrorCodeInternalError, data);
-export const TASK_NOT_FOUND = (data) => new SystemError("Task not found", ErrorCodeTaskNotFound, data);
-export const TASK_NOT_CANCELABLE = (data) => new SystemError("Task cannot be canceled", ErrorCodeTaskNotCancelable, data);
-export const PUSH_NOTIFICATION_NOT_SUPPORTED = (data) => new SystemError("Push Notifications is not supported", ErrorCodePushNotificationNotSupported, data);
-export const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED = (data) => new SystemError("Authenticated Extended Card is not configured", ErrorCodeAuthenticatedExtendedCardNotConfigured, data);
-export const UNSUPPORTED_OPERATION = (data) => new SystemError("This operation is not supported", ErrorCodeUnsupportedOperation, data);
-export const CONTENT_TYPE_NOT_SUPPORTED = (data) => new SystemError("Content type not supported", ErrorCodeContentTypeNotSupported, data);
-export const INVALID_AGENT_RESPONSE = (data) => new SystemError("Invalid agent response", ErrorCodeInvalidAgentResponse, data);
+export const PARSE_ERROR = (data) => new SystemError("Invalid JSON payload", A2A.ErrorCodeParseError, data);
+export const INVALID_REQUEST = (data) => new SystemError("Request payload validation error", A2A.ErrorCodeInvalidRequest, data);
+export const METHOD_NOT_FOUND = (data) => new SystemError("Method not found", A2A.ErrorCodeMethodNotFound, data);
+export const INVALID_PARAMS = (data) => new SystemError("Invalid parameters", A2A.ErrorCodeInvalidParams, data);
+export const INTERNAL_ERROR = (data) => new SystemError("Internal error", A2A.ErrorCodeInternalError, data);
+export const TASK_NOT_FOUND = (data) => new SystemError("Task not found", A2A.ErrorCodeTaskNotFound, data);
+export const TASK_NOT_CANCELABLE = (data) => new SystemError("Task cannot be canceled", A2A.ErrorCodeTaskNotCancelable, data);
+export const PUSH_NOTIFICATION_NOT_SUPPORTED = (data) => new SystemError("Push Notifications is not supported", A2A.ErrorCodePushNotificationNotSupported, data);
+export const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED = (data) => new SystemError("Authenticated Extended Card is not configured", A2A.ErrorCodeAuthenticatedExtendedCardNotConfigured, data);
+export const UNSUPPORTED_OPERATION = (data) => new SystemError("This operation is not supported", A2A.ErrorCodeUnsupportedOperation, data);
+export const CONTENT_TYPE_NOT_SUPPORTED = (data) => new SystemError("Content type not supported", A2A.ErrorCodeContentTypeNotSupported, data);
+export const INVALID_AGENT_RESPONSE = (data) => new SystemError("Invalid agent response", A2A.ErrorCodeInvalidAgentResponse, data);
 export const FAILED_UPDATE = (taskId, contextId, messageId = "failed-update", errMessage) => ({
     taskId,
     contextId,
     kind: "status-update",
     final: true,
     status: {
-        state: TaskState.failed,
+        state: A2A.TaskState.failed,
         message: {
             messageId,
             role: "agent",

package/dist/utils/common/parse.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from "zod/v4";
+export declare function safeParse<T = any>(json: string): T;
+export declare function safeParseSchema<T extends z.ZodSchema>(json: string, schema: T): Promise<z.infer<T>>;

package/dist/utils/common/parse.js

@@ -0,0 +1,14 @@
+import { validateSchema } from "./schema-validation.js";
+import { logger } from "../../config/index.js";
+export function safeParse(json) {
+    try {
+        return JSON.parse(json);
+    }
+    catch (error) {
+        logger.warn("safeParse error:", error, json);
+        return {};
+    }
+}
+export async function safeParseSchema(json, schema) {
+    return await validateSchema(schema, safeParse(json));
+}

package/dist/utils/common/schema-validation.d.ts

@@ -1,2 +1,2 @@
-import { z } from "zod/v3";
+import { z } from "zod/v4";
 export declare function validateSchema<T extends z.ZodSchema>(schema: T, data: unknown): Promise<z.infer<T>>;

package/dist/utils/common/schema-validation.js

@@ -1,12 +1,12 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
 import { INVALID_PARAMS } from "../index.js";
-import { logError } from "../logging/index.js";
+import { logger } from "../../config/index.js";
 export async function validateSchema(schema, data) {
     return await schema.parseAsync(data).catch((error) => {
-        logError("Schema validation failed", error.message, error);
-        throw INVALID_PARAMS({
-            data: {
-                message: error.message,
-            },
-        });
+        logger.error("Schema validation failed", error);
+        throw INVALID_PARAMS(error);
     });
 }

package/dist/utils/common/utils.d.ts

@@ -7,3 +7,26 @@
  * @returns The current timestamp as a string.
  */
 export declare function getCurrentTimestamp(): string;
+/**
+ * Sleeps for a given number of milliseconds.
+ * @param ms - The number of milliseconds to sleep.
+ * @returns A promise that resolves when the sleep is complete.
+ *
+ * @example
+ * ```typescript
+ * await sleep(1000);
+ * ```
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Formats a JSON object into a string with indentation.
+ * @param json - The JSON object to format.
+ * @returns A string representation of the JSON object.
+ */
+export declare function formatJson(json: object): string;
+/**
+ * Formats an error into a standard error object for logging.
+ * @param error - The error to format.
+ * @returns A standard error object.
+ */
+export declare function formatError(error: unknown): Error;

package/dist/utils/common/utils.js

@@ -9,3 +9,35 @@
 export function getCurrentTimestamp() {
     return new Date().toISOString();
 }
+/**
+ * Sleeps for a given number of milliseconds.
+ * @param ms - The number of milliseconds to sleep.
+ * @returns A promise that resolves when the sleep is complete.
+ *
+ * @example
+ * ```typescript
+ * await sleep(1000);
+ * ```
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Formats a JSON object into a string with indentation.
+ * @param json - The JSON object to format.
+ * @returns A string representation of the JSON object.
+ */
+export function formatJson(json) {
+    return JSON.stringify(json, null, 2);
+}
+/**
+ * Formats an error into a standard error object for logging.
+ * @param error - The error to format.
+ * @returns A standard error object.
+ */
+export function formatError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}

package/dist/utils/common/zAsyncIterable-v3.d.ts

@@ -1,5 +1,5 @@
 import type { TrackedEnvelope } from "@trpc/server";
-import { z } from "zod";
+import { z } from "zod/v3";
 /**
  * A Zod schema helper designed specifically for validating async iterables. This schema ensures that:
  * 1. The value being validated is an async iterable.

package/dist/utils/common/zAsyncIterable-v3.js

@@ -1,5 +1,6 @@
 import { isTrackedEnvelope, tracked } from "@trpc/server";
-import { z } from "zod";
+import { z } from "zod/v3";
+//!Maintain for backwards compatibility
 // v3 version of: https://trpc.io/docs/server/subscriptions#output-validation
 function isAsyncIterable(value) {
     return !!value && typeof value === "object" && Symbol.asyncIterator in value;

package/dist/utils/index.d.ts

@@ -6,7 +6,6 @@ export * from "./common/constants.js";
 export * from "./common/errors.js";
 export * from "./common/schema-validation.js";
 export * from "./common/utils.js";
-export * from "./common/zAsyncIterable-v3.js";
-export * from "./logging/index.js";
+export * from "./common/zAsyncIterable.js";
+export * from "./common/parse.js";
 export * from "./storage/file.js";
-export * from "./storage/memory.js";

package/dist/utils/index.js

@@ -6,7 +6,6 @@ export * from "./common/constants.js";
 export * from "./common/errors.js";
 export * from "./common/schema-validation.js";
 export * from "./common/utils.js";
-export * from "./common/zAsyncIterable-v3.js";
-export * from "./logging/index.js";
+export * from "./common/zAsyncIterable.js";
+export * from "./common/parse.js";
 export * from "./storage/file.js";
-export * from "./storage/memory.js";

package/dist/utils/storage/file.d.ts

@@ -2,12 +2,13 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { TaskAndHistory, TaskManagerInterface } from "../../types/index.js";
+import { A2A } from "../../types/index.js";
+import { Tasks } from "../../services/a2a/managers.js";
 /**
  * File-based implementation of the TaskStore interface.
  * Stores tasks and their history as JSON files on disk.
  */
-export declare class FileStore implements TaskManagerInterface<TaskAndHistory> {
+export declare class Files extends Tasks {
     private baseDir;
     /**
      * Creates a new FileStore.
@@ -20,12 +21,6 @@ export declare class FileStore implements TaskManagerInterface<TaskAndHistory> {
      * @returns The full file path for the task JSON file
      */
     private getTaskFilePath;
-    /**
-     * Constructs the file path for a task's history.
-     * @param taskId The task ID
-     * @returns The full file path for the history JSON file
-     */
-    private getHistoryFilePath;
     /**
      * Ensures the base directory exists.
      * @returns A promise that resolves when the directory exists.
@@ -44,23 +39,19 @@ export declare class FileStore implements TaskManagerInterface<TaskAndHistory> {
      * @returns A promise resolving to the parsed data, or null if the file doesn't exist
      */
     private readJsonFile;
-    /**
-     * Type guard to validate the structure of history file content.
-     * @param content The content to check
-     * @returns True if the content is a valid history file content
-     */
-    private isHistoryFileContent;
     /**
      * Loads a task and its history by task ID.
      * @param taskId The ID of the task to load.
      * @returns A promise resolving to the task and history, or null if not found.
      */
-    getState(taskId: string): Promise<TaskAndHistory | undefined>;
+    get(taskId: string): Promise<A2A.Task | undefined>;
     /**
      * Saves a task and its history.
      * @param data The task and history to save.
      * @returns A promise that resolves when the save is complete.
      */
-    setState(taskId: string, data: TaskAndHistory): Promise<void>;
-    getStates(): Promise<string[]>;
+    set(taskId: string, task?: A2A.Task): Promise<void>;
+    delete(taskId: string): Promise<void>;
+    has(taskId: string): Promise<boolean>;
+    list(): Promise<A2A.Task[]>;
 }

package/dist/utils/storage/file.js

@@ -2,21 +2,26 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { logError, logDebug } from "../logging/log.js";
+import { A2A } from "../../types/index.js";
 import fs from "fs/promises";
 import path from "path";
+import { logger } from "../../config/index.js";
+import { Tasks } from "../../services/a2a/managers.js";
+import { formatJson, safeParseSchema } from "../index.js";
 /**
  * File-based implementation of the TaskStore interface.
  * Stores tasks and their history as JSON files on disk.
  */
-export class FileStore {
+export class Files extends Tasks {
     baseDir;
     /**
      * Creates a new FileStore.
      * @param baseDir The base directory to store task files in.
      */
     constructor(baseDir) {
+        super(new Map());
         this.baseDir = baseDir;
+        logger.info(`FileStore[init]: baseDir`, { baseDir });
     }
     /**
      * Constructs the file path for a task.
@@ -26,14 +31,6 @@ export class FileStore {
     getTaskFilePath(taskId) {
         return path.join(this.baseDir, `${taskId}.task.json`);
     }
-    /**
-     * Constructs the file path for a task's history.
-     * @param taskId The task ID
-     * @returns The full file path for the history JSON file
-     */
-    getHistoryFilePath(taskId) {
-        return path.join(this.baseDir, `${taskId}.history.json`);
-    }
     /**
      * Ensures the base directory exists.
      * @returns A promise that resolves when the directory exists.
@@ -43,7 +40,7 @@ export class FileStore {
             await fs.mkdir(this.baseDir, { recursive: true });
         }
         catch (error) {
-            logError("FileStore", `Failed to create directory: ${this.baseDir}`, error);
+            logger.warn(`FileStore[ensureBaseDir]: ${this.baseDir}`, error);
             throw error;
         }
     }
@@ -53,15 +50,15 @@ export class FileStore {
      * @param data The data to write
      * @returns A promise that resolves when the write is complete
      */
-    async writeJsonFile(filePath, data) {
+    async writeJsonFile(filePath, task) {
         try {
             await this.ensureBaseDir();
-            await fs.writeFile(filePath, JSON.stringify(data, null, 2), {
+            await fs.writeFile(filePath, formatJson(task), {
                 encoding: "utf8",
             });
         }
         catch (error) {
-            logError("FileStore", `Failed to write file: ${filePath}`, error);
+            logger.warn(`FileStore[writeJsonFile]: ${filePath}`, error);
             throw error;
         }
     }
@@ -73,88 +70,62 @@ export class FileStore {
     async readJsonFile(filePath) {
         try {
             const content = await fs.readFile(filePath, { encoding: "utf8" });
-            return JSON.parse(content);
+            return await safeParseSchema(content, A2A.TaskSchema);
         }
         catch (error) {
             if (error.code === "ENOENT") {
-                // File not found - return null rather than throwing
+                logger.warn(`FileStore[readJsonFile]: ${filePath} not found`);
                 return null;
             }
-            logError("FileStore", `Failed to read file: ${filePath}`, error);
             throw error;
         }
     }
-    /**
-     * Type guard to validate the structure of history file content.
-     * @param content The content to check
-     * @returns True if the content is a valid history file content
-     */
-    isHistoryFileContent(content) {
-        return (content !== undefined &&
-            typeof content === "object" &&
-            content !== null &&
-            "messageHistory" in content &&
-            Array.isArray(content.messageHistory));
-    }
     /**
      * Loads a task and its history by task ID.
      * @param taskId The ID of the task to load.
      * @returns A promise resolving to the task and history, or null if not found.
      */
-    async getState(taskId) {
-        logDebug("FileStore", `Loading task: ${taskId}`);
-        const taskFilePath = this.getTaskFilePath(taskId);
-        const historyFilePath = this.getHistoryFilePath(taskId);
-        // Read task file first - if it doesn't exist, the task doesn't exist.
-        const task = await this.readJsonFile(taskFilePath).catch(() => undefined);
-        if (!task) {
-            return undefined; // Task not found
-        }
-        // Task exists, now try to read history. It might not exist yet.
-        let history = [];
-        try {
-            const historyContent = await this.readJsonFile(historyFilePath).catch(() => undefined);
-            // Validate the structure
-            if (this.isHistoryFileContent(historyContent)) {
-                history = historyContent.messageHistory;
-            }
-            else if (historyContent !== null) {
-                // Log a warning if the history file exists but is malformed
-                logError("FileStore", `Malformed history file found for task ${taskId}`, new Error("Invalid history file format"), { path: historyFilePath });
-                // Proceed with empty history
-            }
-            // If historyContent is null (file not found), history remains []
-        }
-        catch (error) {
-            // Log error reading history but proceed with empty history
-            logError("FileStore", `Error reading history file for task ${taskId}`, error, { path: historyFilePath });
-            // Proceed with empty history
-        }
-        return { task, history };
+    async get(taskId) {
+        const task = (await super.get(taskId)) ??
+            (await this.readJsonFile(this.getTaskFilePath(taskId)).catch(() => undefined));
+        return task ?? undefined;
     }
     /**
      * Saves a task and its history.
      * @param data The task and history to save.
      * @returns A promise that resolves when the save is complete.
      */
-    async setState(taskId, data) {
-        logDebug("FileStore", `Saving task: ${data.task.id}`);
-        if (taskId !== data.task.id) {
+    async set(taskId, task) {
+        logger.debug(`FileStore[set]: ${taskId}`);
+        if (!task) {
+            return;
+        }
+        if (task && taskId !== task.id) {
+            logger.warn("FileStore", `Task ID mismatch: ${taskId} !== ${task.id}`);
             throw new Error("Task ID mismatch");
         }
         const taskFilePath = this.getTaskFilePath(taskId);
-        const historyFilePath = this.getHistoryFilePath(taskId);
-        // For simplicity and atomicity, we'll write each file individually
-        // First, write the task file
-        await this.writeJsonFile(taskFilePath, data.task);
-        // Then, write the history file
-        // We'll wrap it in an object to allow for future extensibility
-        await this.writeJsonFile(historyFilePath, {
-            messageHistory: data.history,
-        });
+        await this.writeJsonFile(taskFilePath, task);
+        await super.set(taskId, task);
+    }
+    async delete(taskId) {
+        logger.debug(`FileStore[delete]: ${taskId}`);
+        const taskFilePath = this.getTaskFilePath(taskId);
+        await fs.unlink(taskFilePath);
+        await super.delete(taskId);
+    }
+    async has(taskId) {
+        if (await super.has(taskId)) {
+            return true;
+        }
+        const taskFilePath = this.getTaskFilePath(taskId);
+        return fs
+            .access(taskFilePath)
+            .then(() => true)
+            .catch(() => false);
     }
-    async getStates() {
+    async list() {
         const taskIds = await fs.readdir(this.baseDir);
-        return taskIds.map((taskId) => taskId.replace(".task.json", ""));
+        return Promise.all(taskIds.map((taskId) => this.get(taskId).catch(() => undefined))).then((tasks) => tasks.filter((task) => task !== undefined));
     }
 }