@pixelbyte-software/pixcode 1.34.0 → 1.35.1

package/server/modules/orchestration/a2a/routes.ts

@@ -10,6 +10,7 @@ import { adapterRegistry } from '@/modules/orchestration/a2a/adapter-registry.js
 import { buildPixcodeAgentCard } from '@/modules/orchestration/a2a/agent-card.js';
 import { a2aAuth } from '@/modules/orchestration/a2a/auth.middleware.js';
 import { a2aBus } from '@/modules/orchestration/a2a/bus.js';
+import { A2ATaskStore } from '@/modules/orchestration/a2a/task-store.js';
 import type {
   BusEvent,
   Message,
@@ -21,21 +22,58 @@ import {
   assertMessage,
   assertSubmitTaskInput,
 } from '@/modules/orchestration/a2a/validator.js';
+import { portWatcher } from '@/modules/orchestration/preview/port-watcher.js';
+import type { PreviewArtifactData } from '@/modules/orchestration/preview/types.js';
+import { workspaceManager } from '@/modules/orchestration/workspace/workspace-manager.js';
+import type {
+  WorkspaceHandle,
+  WorkspaceKind,
+  WorkspaceMetadata,
+} from '@/modules/orchestration/workspace/types.js';
+import { WorkspaceError } from '@/modules/orchestration/workspace/types.js';
+
+type RoutingHints = {
+  preferredAdapterId?: string;
+  preferredProvider?: string;
+  preferredSkillId?: string;
+};
+
+function readRoutingHints(value: unknown): RoutingHints {
+  if (!value || typeof value !== 'object') {
+    return {};
+  }
 
-// In-memory task store. Persistence is out of scope for the foundation;
-// a follow-on plan adds SQLite-backed storage.
-const tasks = new Map<string, Task>();
+  const source = value as Record<string, unknown>;
+  return {
+    preferredAdapterId:
+      typeof source.preferredAdapterId === 'string' ? source.preferredAdapterId : undefined,
+    preferredProvider:
+      typeof source.preferredProvider === 'string' ? source.preferredProvider : undefined,
+    preferredSkillId:
+      typeof source.preferredSkillId === 'string' ? source.preferredSkillId : undefined,
+  };
+}
+
+const TERMINAL: TaskState[] = ['completed', 'canceled', 'failed'];
 // Per-task bus unsubscribe handles; called on terminal state.
 const taskUnsubs = new Map<string, () => void>();
 // Eviction timeouts (terminal tasks live for 1 hour before being purged).
 const taskEvictions = new Map<string, NodeJS.Timeout>();
 const TERMINAL_TASK_TTL_MS = 60 * 60 * 1000; // 1 hour
 const MAX_TASKS = 1000;
+const taskStore = new A2ATaskStore({ terminalTaskTtlMs: TERMINAL_TASK_TTL_MS });
+const activeWorkspaces = new Map<string, WorkspaceHandle>();
+const previewStops = new Map<string, () => void>();
+const finalizingTasks = new Set<string>();
 
 function newId(prefix: string): string {
   return `${prefix}_${crypto.randomBytes(8).toString('hex')}`;
 }
 
+function isTerminalTaskState(state: TaskState): boolean {
+  return TERMINAL.includes(state);
+}
+
 function getBaseUrl(req: Request): string {
   // TODO: this trusts X-Forwarded-Proto/Host without checking app's
   // trust-proxy setting. Same posture as auth.middleware.ts; revisit
@@ -45,40 +83,174 @@ function getBaseUrl(req: Request): string {
   return `${proto}://${host}`;
 }
 
+function scheduleTaskEviction(taskId: string): void {
+  const existingTimeout = taskEvictions.get(taskId);
+  if (existingTimeout) {
+    clearTimeout(existingTimeout);
+  }
+
+  const task = taskStore.get(taskId);
+  if (!task) {
+    taskEvictions.delete(taskId);
+    return;
+  }
+
+  const remainingMs = Math.max(0, task.updatedAt + TERMINAL_TASK_TTL_MS - Date.now());
+  taskEvictions.set(
+    taskId,
+    setTimeout(() => {
+      taskStore.delete(taskId);
+      taskEvictions.delete(taskId);
+    }, remainingMs),
+  );
+}
+
+function parseTaskState(value: unknown): TaskState | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  const normalized = value.trim();
+  if (
+    normalized === 'submitted' ||
+    normalized === 'working' ||
+    normalized === 'input-required' ||
+    normalized === 'completed' ||
+    normalized === 'canceled' ||
+    normalized === 'failed'
+  ) {
+    return normalized;
+  }
+
+  return undefined;
+}
+
+function parsePositiveInt(value: unknown, fallback: number): number {
+  if (typeof value !== 'string') {
+    return fallback;
+  }
+
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallback;
+  }
+
+  return parsed;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value : undefined;
+}
+
+function readBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+function readObject(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' ? value as Record<string, unknown> : undefined;
+}
+
+function readWorkspaceKind(value: unknown): WorkspaceKind | undefined {
+  return value === 'host' || value === 'worktree' || value === 'docker' ? value : undefined;
+}
+
+function workspaceMetadata(workspace: WorkspaceHandle, keepAfterCompletion?: boolean): WorkspaceMetadata {
+  return {
+    id: workspace.id,
+    kind: workspace.kind,
+    path: workspace.path,
+    baseRef: workspace.baseRef,
+    branchName: workspace.branchName,
+    keepAfterCompletion,
+  };
+}
+
+async function finalizeTerminalTask(task: Task): Promise<void> {
+  if (finalizingTasks.has(task.id)) return;
+  finalizingTasks.add(task.id);
+
+  const stopPreview = previewStops.get(task.id);
+  if (stopPreview) {
+    stopPreview();
+    previewStops.delete(task.id);
+  }
+
+  const workspace = activeWorkspaces.get(task.id);
+  try {
+    if (workspace) {
+      const diff = await workspace.diff();
+      a2aBus.publish({
+        kind: 'artifact',
+        taskId: task.id,
+        artifact: {
+          artifactId: newId('art'),
+          type: 'file-diff',
+          parts: [{ kind: 'text', text: diff }],
+          metadata: {
+            source: 'workspace-diff',
+            workspaceId: workspace.id,
+            workspaceKind: workspace.kind,
+            baseRef: workspace.baseRef,
+          },
+        },
+      });
+
+      const keepAfterCompletion = task.metadata?.workspace &&
+        typeof task.metadata.workspace === 'object' &&
+        readBoolean((task.metadata.workspace as Record<string, unknown>).keepAfterCompletion);
+      if (workspace.kind !== 'host' && keepAfterCompletion !== true) {
+        await workspace.destroy();
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    task.metadata = {
+      ...task.metadata,
+      workspaceFinalizationError: message,
+    };
+    task.updatedAt = Date.now();
+    taskStore.set(task);
+  } finally {
+    activeWorkspaces.delete(task.id);
+    const unsub = taskUnsubs.get(task.id);
+    if (unsub) {
+      unsub();
+      taskUnsubs.delete(task.id);
+    }
+    scheduleTaskEviction(task.id);
+    finalizingTasks.delete(task.id);
+  }
+}
+
 function attachBusToTask(task: Task): void {
   const unsubscribe = a2aBus.subscribe(task.id, (event: BusEvent) => {
     if (event.kind === 'task-state') {
       task.state = event.state;
       if (event.error) task.error = event.error;
       task.updatedAt = Date.now();
-      if (event.state === 'completed' || event.state === 'canceled' || event.state === 'failed') {
-        // Release the listener; schedule eviction.
-        const unsub = taskUnsubs.get(task.id);
-        if (unsub) {
-          unsub();
-          taskUnsubs.delete(task.id);
-        }
-        const existingTimeout = taskEvictions.get(task.id);
-        if (existingTimeout) clearTimeout(existingTimeout);
-        taskEvictions.set(
-          task.id,
-          setTimeout(() => {
-            tasks.delete(task.id);
-            taskEvictions.delete(task.id);
-          }, TERMINAL_TASK_TTL_MS),
-        );
+      taskStore.set(task);
+      if (isTerminalTaskState(event.state)) {
+        void finalizeTerminalTask(task);
       }
     } else if (event.kind === 'message') {
       task.history.push(event.message);
       task.updatedAt = Date.now();
+      taskStore.set(task);
     } else if (event.kind === 'artifact') {
       task.artifacts.push(event.artifact);
       task.updatedAt = Date.now();
+      taskStore.set(task);
     }
   });
   taskUnsubs.set(task.id, unsubscribe);
 }
 
+for (const task of taskStore.values()) {
+  if (isTerminalTaskState(task.state)) {
+    scheduleTaskEviction(task.id);
+  }
+}
+
 export function createA2ARouter(): Router {
   const router: Router = express.Router();
 
@@ -103,6 +275,57 @@ export function createA2ARouter(): Router {
     res.json(adapter.agentCard);
   });
 
+  router.post('/adapters/resolve', (req, res) => {
+    const selector = typeof req.body?.adapterId === 'string' ? req.body.adapterId : '';
+    if (!selector.trim()) {
+      res.status(400).json({
+        error: { code: 'ADAPTER_ID_REQUIRED', message: 'adapterId is required.' },
+      });
+      return;
+    }
+
+    const routing = readRoutingHints(req.body?.routing);
+    const adapter = adapterRegistry.resolve(selector, routing);
+    if (!adapter) {
+      res.status(404).json({
+        error: {
+          code: 'ADAPTER_NOT_FOUND',
+          message: selector,
+          availableAdapters: adapterRegistry.list().map((candidate) => candidate.id),
+        },
+      });
+      return;
+    }
+
+    res.json({
+      selector,
+      resolvedAdapterId: adapter.id,
+      agentCard: adapter.agentCard,
+    });
+  });
+
+  router.get('/tasks', (req, res) => {
+    const state = parseTaskState(req.query.state);
+    const contextId = typeof req.query.contextId === 'string' ? req.query.contextId : undefined;
+    const adapterId = typeof req.query.adapterId === 'string' ? req.query.adapterId : undefined;
+    const limit = parsePositiveInt(req.query.limit, 50);
+
+    const tasks = taskStore
+      .list({ state, contextId, adapterId, limit })
+      .map((task) => taskStore.summarize(task));
+
+    res.json({
+      tasks,
+      count: tasks.length,
+      filters: {
+        state,
+        contextId,
+        adapterId,
+        limit,
+      },
+    });
+  });
+
   // Task lifecycle
   router.post('/tasks', async (req: Request, res: Response) => {
     try {
@@ -113,20 +336,27 @@ export function createA2ARouter(): Router {
       return;
     }
 
-    const adapter = adapterRegistry.get(req.body.adapterId);
+    const metadata = req.body.metadata as Record<string, unknown> | undefined;
+    const routing = readRoutingHints(metadata?.routing);
+
+    const adapter = adapterRegistry.resolve(req.body.adapterId, routing);
     if (!adapter) {
       res.status(404).json({
-        error: { code: 'ADAPTER_NOT_FOUND', message: req.body.adapterId },
+        error: {
+          code: 'ADAPTER_NOT_FOUND',
+          message: req.body.adapterId,
+          availableAdapters: adapterRegistry.list().map((candidate) => candidate.id),
+        },
       });
       return;
     }
 
     // Enforce MAX_TASKS cap. Evict the oldest terminal task first; if all
     // active, fail closed with 503.
-    if (tasks.size >= MAX_TASKS) {
+    if (taskStore.size >= MAX_TASKS) {
       let evicted = false;
-      for (const [tid, t] of tasks) {
-        if (t.state === 'completed' || t.state === 'canceled' || t.state === 'failed') {
+      for (const [tid, t] of taskStore.entries()) {
+        if (isTerminalTaskState(t.state)) {
           const timeout = taskEvictions.get(tid);
           if (timeout) clearTimeout(timeout);
           taskEvictions.delete(tid);
@@ -135,7 +365,7 @@ export function createA2ARouter(): Router {
             unsub();
             taskUnsubs.delete(tid);
           }
-          tasks.delete(tid);
+          taskStore.delete(tid);
           evicted = true;
           break;
         }
@@ -153,20 +383,98 @@ export function createA2ARouter(): Router {
       id: newId('task'),
       contextId: req.body.contextId,
       state: 'submitted',
-      history: [userMessage],
+      history: [],
       artifacts: [],
       metadata: req.body.metadata,
       createdAt: Date.now(),
       updatedAt: Date.now(),
     };
-    tasks.set(task.id, task);
+    task.history.push({ ...userMessage, taskId: task.id });
+    const workspaceOptions = (metadata?.workspace && typeof metadata.workspace === 'object'
+      ? metadata.workspace
+      : {}) as Record<string, unknown>;
     // Persist adapterId in metadata so cancel can resolve the owning adapter
     // even when the original request body is no longer available.
-    task.metadata = { ...task.metadata, adapterId: req.body.adapterId };
+    task.metadata = {
+      ...task.metadata,
+      adapterId: adapter.id,
+      adapterSelector: req.body.adapterId,
+    };
+    taskStore.set(task);
     attachBusToTask(task);
 
+    let workspace: WorkspaceHandle;
     try {
-      await adapter.submitTask(task, { cwd: process.cwd() });
+      workspace = await workspaceManager.create({
+        taskId: task.id,
+        projectPath: readString(workspaceOptions.projectPath) ?? process.cwd(),
+        kind: readWorkspaceKind(workspaceOptions.kind) ?? readWorkspaceKind(metadata?.isolation),
+        baseRef: readString(workspaceOptions.baseRef) ?? readString(metadata?.baseRef) ?? 'HEAD',
+        keepAfterCompletion: readBoolean(workspaceOptions.keepAfterCompletion),
+        metadata: workspaceOptions,
+      });
+    } catch (err) {
+      const workspaceError = err instanceof WorkspaceError ? err : undefined;
+      a2aBus.publish({
+        kind: 'task-state',
+        taskId: task.id,
+        state: 'failed',
+        error: {
+          code: workspaceError?.code ?? 'WORKSPACE_CREATE_FAILED',
+          message: err instanceof Error ? err.message : String(err),
+          details: workspaceError?.details,
+        },
+      });
+      res.status(202).json(task);
+      return;
+    }
+
+    activeWorkspaces.set(task.id, workspace);
+    task.metadata = {
+      ...task.metadata,
+      workspace: workspaceMetadata(workspace, readBoolean(workspaceOptions.keepAfterCompletion)),
+    };
+    taskStore.set(task);
+
+    previewStops.set(
+      task.id,
+      portWatcher.watch({
+        taskId: task.id,
+        workspace,
+        onPort: (event) => {
+          const data: PreviewArtifactData = {
+            url: event.url,
+            proxiedUrl: `/preview/${event.port}/`,
+            port: event.port,
+            host: event.host,
+            processName: event.processName,
+            confidence: event.confidence,
+          };
+          a2aBus.publish({
+            kind: 'artifact',
+            taskId: task.id,
+            artifact: {
+              artifactId: newId('art'),
+              type: 'preview-url',
+              parts: [{ kind: 'data', data: { ...data } }],
+              metadata: {
+                source: 'port-watcher',
+                workspaceId: workspace.id,
+              },
+            },
+          });
+        },
+      }),
+    );
+
+    try {
+      await adapter.submitTask(task, {
+        cwd: workspace.path,
+        workspace,
+        model: readString(metadata?.model),
+        permissionMode: readString(metadata?.permissionMode),
+        toolsSettings: readObject(metadata?.toolsSettings),
+      });
     } catch (err) {
       // Publish to bus so SSE subscribers and the attachBusToTask listener
       // both see the failure transition. The listener mutates the stored
@@ -186,7 +494,7 @@ export function createA2ARouter(): Router {
   });
 
   router.get('/tasks/:id', (req, res) => {
-    const task = tasks.get(req.params.id);
+    const task = taskStore.get(req.params.id);
     if (!task) {
       res.status(404).json({ error: { code: 'TASK_NOT_FOUND', message: req.params.id } });
       return;
@@ -195,7 +503,7 @@ export function createA2ARouter(): Router {
   });
 
   router.get('/tasks/:id/stream', (req, res) => {
-    const task = tasks.get(req.params.id);
+    const task = taskStore.get(req.params.id);
     if (!task) {
       res.status(404).json({ error: { code: 'TASK_NOT_FOUND', message: req.params.id } });
       return;
@@ -209,11 +517,10 @@ export function createA2ARouter(): Router {
     const initial = { kind: 'task-snapshot' as const, task };
     res.write(`event: snapshot\ndata: ${JSON.stringify(initial)}\n\n`);
 
-    const TERMINAL: TaskState[] = ['completed', 'canceled', 'failed'];
     const unsubscribe = a2aBus.subscribe(task.id, (event) => {
       res.write(`event: ${event.kind}\ndata: ${JSON.stringify(event)}\n\n`);
       if (event.kind === 'task-state' && TERMINAL.includes(event.state)) {
-        res.end();
+        setTimeout(() => res.end(), 1500);
       }
     });
 
@@ -223,14 +530,14 @@ export function createA2ARouter(): Router {
   });
 
   router.post('/tasks/:id/cancel', async (req, res) => {
-    const task = tasks.get(req.params.id);
+    const task = taskStore.get(req.params.id);
     if (!task) {
       res.status(404).json({ error: { code: 'TASK_NOT_FOUND', message: req.params.id } });
       return;
     }
     // Look up the adapter that owns this task. We stored adapterId in metadata.
     const adapterId = req.body?.adapterId ?? task.metadata?.adapterId;
-    const adapter = typeof adapterId === 'string' ? adapterRegistry.get(adapterId) : undefined;
+    const adapter = typeof adapterId === 'string' ? adapterRegistry.resolve(adapterId) : undefined;
     if (!adapter) {
       res.status(400).json({
         error: {
@@ -241,7 +548,7 @@ export function createA2ARouter(): Router {
       return;
     }
     await adapter.cancelTask(task.id);
-    res.json(tasks.get(task.id));
+    res.json(taskStore.get(task.id));
   });
 
   router.post('/messages', (req, res) => {
@@ -252,6 +559,12 @@ export function createA2ARouter(): Router {
       res.status(400).json({ error: { code: 'INVALID_INPUT', message: e.message, path: e.path } });
       return;
     }
+    if (typeof req.body.taskId === 'string' && !taskStore.get(req.body.taskId)) {
+      res.status(404).json({
+        error: { code: 'TASK_NOT_FOUND', message: req.body.taskId },
+      });
+      return;
+    }
     a2aBus.publish({
       kind: 'message',
       taskId: req.body.taskId ?? 'broadcast',

package/server/modules/orchestration/a2a/task-store.ts

@@ -0,0 +1,178 @@
+// server/modules/orchestration/a2a/task-store.ts
+// A2A task persistence backed by shared JsonStore for atomic writes and corruption recovery.
+// Exposes a Map-compatible surface (get/set/delete/size/entries/values) so routes.ts
+// can treat the store as a typed Map while still benefiting from durable JSON storage.
+
+import os from 'os';
+import path from 'path';
+
+import { JsonStore } from '@/database/json-store.js';
+import type { Message, Task, TaskState, TaskSummary } from '@/modules/orchestration/a2a/types.js';
+
+const filePath = path.join(os.homedir(), '.pixcode', 'a2a-tasks.json');
+
+export interface A2ATaskStoreOptions {
+  terminalTaskTtlMs?: number;
+}
+
+export interface ListOptions {
+  state?: TaskState;
+  contextId?: string;
+  adapterId?: string;
+  limit?: number;
+}
+
+export class A2ATaskStore {
+  private store: JsonStore;
+
+  constructor(_options?: A2ATaskStoreOptions) {
+    this.store = new JsonStore(filePath, { a2a_tasks: [] });
+  }
+
+  // ── Map-compatible API ─────────────────────────────────────────────────────
+
+  get(id: string): Task | undefined {
+    return this.store.findWhere('a2a_tasks', (t: Task) => t.id === id) ?? undefined;
+  }
+
+  set(task: Task): void {
+    const existing = this.get(task.id);
+    if (existing) {
+      this.store.updateWhere('a2a_tasks', (t: Task) => t.id === task.id, task);
+    } else {
+      this.store.insert('a2a_tasks', task, { autoId: false });
+    }
+  }
+
+  delete(id: string): void {
+    this.store.deleteWhere('a2a_tasks', (t: Task) => t.id === id);
+  }
+
+  get size(): number {
+    return (this.store.filterWhere('a2a_tasks', () => true) as Task[]).length;
+  }
+
+  *entries(): IterableIterator<[string, Task]> {
+    const tasks = this.store.filterWhere('a2a_tasks', () => true) as Task[];
+    for (const task of tasks) {
+      yield [task.id, task];
+    }
+  }
+
+  *values(): IterableIterator<Task> {
+    const tasks = this.store.filterWhere('a2a_tasks', () => true) as Task[];
+    for (const task of tasks) {
+      yield task;
+    }
+  }
+
+  // ── Query helpers ──────────────────────────────────────────────────────────
+
+  list(options: ListOptions = {}): Task[] {
+    const { state, contextId, adapterId, limit = 50 } = options;
+    let tasks = this.store.filterWhere('a2a_tasks', (t: Task) => {
+      if (state && t.state !== state) return false;
+      if (contextId && t.contextId !== contextId) return false;
+      if (adapterId && (t.metadata?.adapterId as string | undefined) !== adapterId) return false;
+      return true;
+    }) as Task[];
+    if (limit > 0) tasks = tasks.slice(0, limit);
+    return tasks;
+  }
+
+  summarize(task: Task): TaskSummary {
+    return {
+      id: task.id,
+      contextId: task.contextId,
+      state: task.state,
+      adapterId: task.metadata?.adapterId as string | undefined,
+      adapterSelector: task.metadata?.adapterSelector as string | undefined,
+      error: task.error,
+      createdAt: task.createdAt,
+      updatedAt: task.updatedAt,
+      messageCount: task.history?.length ?? 0,
+      artifactCount: task.artifacts?.length ?? 0,
+      lastMessage: task.history?.at(-1),
+    };
+  }
+
+  // ── Legacy named methods (kept for any future internal callers) ────────────
+
+  getTask(id: string): Task | undefined {
+    return this.get(id);
+  }
+
+  getTaskByIndex(index: number): Task | undefined {
+    const tasks = this.store.filterWhere('a2a_tasks', () => true) as Task[];
+    return tasks[index] ?? undefined;
+  }
+
+  getTasks(): Task[] {
+    return this.store.filterWhere('a2a_tasks', () => true) as Task[];
+  }
+
+  createTask(task: Task): void {
+    this.store.insert('a2a_tasks', task, { autoId: false });
+  }
+
+  updateTask(id: string, updates: Partial<Task>): void {
+    const existing = this.get(id);
+    if (!existing) return;
+    const updated = { ...existing, ...updates, id: existing.id };
+    this.store.updateWhere('a2a_tasks', (t: Task) => t.id === id, updated);
+  }
+
+  updateTaskState(id: string, state: TaskState): void {
+    this.updateTask(id, { status: { state } } as Partial<Task>);
+  }
+
+  deleteTask(id: string): void {
+    this.delete(id);
+  }
+
+  appendHistory(id: string, entry: { state: TaskState; timestamp: string }): void {
+    const task = this.get(id);
+    if (!task) return;
+    const history = [...(task.history ?? []), entry as unknown as Message];
+    this.updateTask(id, { history } as Partial<Task>);
+  }
+
+  addArtifact(id: string, artifact: NonNullable<Task['artifacts']>[number]): void {
+    const task = this.get(id);
+    if (!task) return;
+    const artifacts = [...(task.artifacts ?? []), artifact];
+    this.updateTask(id, { artifacts } as Partial<Task>);
+  }
+
+  addMessage(id: string, message: Message): void {
+    const task = this.get(id);
+    if (!task) return;
+    const history = [...(task.history ?? []), message];
+    this.updateTask(id, { history } as Partial<Task>);
+  }
+
+  updateMessage(id: string, messageId: string, updates: Partial<Message>): void {
+    const task = this.get(id);
+    if (!task?.history) return;
+    const history = task.history.map((m) =>
+      m.messageId === messageId ? { ...m, ...updates } : m,
+    );
+    this.updateTask(id, { history } as Partial<Task>);
+  }
+
+  getMessage(id: string, messageId: string): Message | undefined {
+    const task = this.get(id);
+    return task?.history?.find((m) => m.messageId === messageId);
+  }
+
+  getMessages(id: string): Message[] {
+    const task = this.get(id);
+    return task?.history ?? [];
+  }
+
+  clearMessages(id: string): void {
+    this.updateTask(id, { history: [] } as Partial<Task>);
+  }
+}
+
+export const a2aTaskStore = new A2ATaskStore();