@dexto/server 1.2.5

package/dist/a2a/adapters/task-view.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var task_view_exports = {};
+__export(task_view_exports, {
+  TaskView: () => TaskView,
+  createTaskView: () => createTaskView
+});
+module.exports = __toCommonJS(task_view_exports);
+var import_message = require("./message.js");
+var import_state = require("./state.js");
+class TaskView {
+  constructor(session) {
+    this.session = session;
+  }
+  /**
+   * Convert the wrapped session to an A2A Task.
+   *
+   * This reads the session history and converts it to A2A format.
+   * State is derived from message patterns, not stored separately.
+   *
+   * @returns A2A protocol task structure
+   */
+  async toA2ATask() {
+    const history = await this.session.getHistory();
+    const a2aMessages = (0, import_message.internalMessagesToA2A)(history, this.session.id, this.session.id);
+    const state = (0, import_state.deriveTaskState)(history);
+    const status = {
+      state,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const task = {
+      id: this.session.id,
+      // taskId === sessionId
+      contextId: this.session.id,
+      // For now, contextId === taskId (could be enhanced for multi-task contexts)
+      status,
+      history: a2aMessages,
+      kind: "task",
+      metadata: {
+        dexto: {
+          sessionId: this.session.id
+        }
+      }
+    };
+    return task;
+  }
+  /**
+   * Get the underlying session ID.
+   * Since taskId === sessionId, this is the same as the task ID.
+   */
+  get sessionId() {
+    return this.session.id;
+  }
+  /**
+   * Get the underlying session (for advanced use).
+   */
+  get session_() {
+    return this.session;
+  }
+}
+async function createTaskView(sessionId, agent) {
+  const session = await agent.createSession(sessionId);
+  return new TaskView(session);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TaskView,
+  createTaskView
+});

package/dist/a2a/adapters/task-view.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A2A TaskView Adapter
+ *
+ * Wraps a Dexto ChatSession to present it as an A2A Task.
+ * This is a pure adapter - no storage, no persistence, just a view.
+ *
+ * Key principle: taskId === sessionId
+ */
+import type { ChatSession } from '@dexto/core';
+import type { Task } from '../types.js';
+/**
+ * TaskView wraps a ChatSession to provide A2A-compliant task interface.
+ *
+ * This is a lightweight adapter that converts session state to A2A format
+ * on-demand. No state is cached or stored.
+ *
+ * Usage:
+ * ```typescript
+ * const session = await agent.createSession(taskId);
+ * const taskView = new TaskView(session);
+ * const task = await taskView.toA2ATask();
+ * ```
+ */
+export declare class TaskView {
+    private session;
+    constructor(session: ChatSession);
+    /**
+     * Convert the wrapped session to an A2A Task.
+     *
+     * This reads the session history and converts it to A2A format.
+     * State is derived from message patterns, not stored separately.
+     *
+     * @returns A2A protocol task structure
+     */
+    toA2ATask(): Promise<Task>;
+    /**
+     * Get the underlying session ID.
+     * Since taskId === sessionId, this is the same as the task ID.
+     */
+    get sessionId(): string;
+    /**
+     * Get the underlying session (for advanced use).
+     */
+    get session_(): ChatSession;
+}
+/**
+ * Create a TaskView from a session ID and agent.
+ *
+ * Convenience factory function.
+ *
+ * @param sessionId Session/Task ID
+ * @param agent DextoAgent instance
+ * @returns TaskView wrapper
+ */
+export declare function createTaskView(sessionId: string, agent: {
+    createSession(id: string): Promise<ChatSession>;
+}): Promise<TaskView>;
+//# sourceMappingURL=task-view.d.ts.map

package/dist/a2a/adapters/task-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-view.d.ts","sourceRoot":"","sources":["../../../src/a2a/adapters/task-view.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAc,MAAM,aAAa,CAAC;AAIpD;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAQ;IACL,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,WAAW;IAExC;;;;;;;OAOG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAiChC;;;OAGG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,WAAW,CAE1B;CACJ;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAChC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE;IAAE,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;CAAE,GAC3D,OAAO,CAAC,QAAQ,CAAC,CAGnB"}

package/dist/a2a/adapters/task-view.js

@@ -0,0 +1,60 @@
+import { internalMessagesToA2A } from "./message.js";
+import { deriveTaskState } from "./state.js";
+class TaskView {
+  constructor(session) {
+    this.session = session;
+  }
+  /**
+   * Convert the wrapped session to an A2A Task.
+   *
+   * This reads the session history and converts it to A2A format.
+   * State is derived from message patterns, not stored separately.
+   *
+   * @returns A2A protocol task structure
+   */
+  async toA2ATask() {
+    const history = await this.session.getHistory();
+    const a2aMessages = internalMessagesToA2A(history, this.session.id, this.session.id);
+    const state = deriveTaskState(history);
+    const status = {
+      state,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const task = {
+      id: this.session.id,
+      // taskId === sessionId
+      contextId: this.session.id,
+      // For now, contextId === taskId (could be enhanced for multi-task contexts)
+      status,
+      history: a2aMessages,
+      kind: "task",
+      metadata: {
+        dexto: {
+          sessionId: this.session.id
+        }
+      }
+    };
+    return task;
+  }
+  /**
+   * Get the underlying session ID.
+   * Since taskId === sessionId, this is the same as the task ID.
+   */
+  get sessionId() {
+    return this.session.id;
+  }
+  /**
+   * Get the underlying session (for advanced use).
+   */
+  get session_() {
+    return this.session;
+  }
+}
+async function createTaskView(sessionId, agent) {
+  const session = await agent.createSession(sessionId);
+  return new TaskView(session);
+}
+export {
+  TaskView,
+  createTaskView
+};

package/dist/a2a/index.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var a2a_exports = {};
+__export(a2a_exports, {
+  A2AMethodHandlers: () => import_jsonrpc.A2AMethodHandlers,
+  JsonRpcErrorCode: () => import_jsonrpc.JsonRpcErrorCode,
+  JsonRpcServer: () => import_jsonrpc.JsonRpcServer,
+  TaskView: () => import_adapters.TaskView,
+  a2aToInternalMessage: () => import_adapters.a2aToInternalMessage,
+  createTaskView: () => import_adapters.createTaskView,
+  deriveTaskState: () => import_adapters.deriveTaskState,
+  deriveTaskStateFromA2A: () => import_adapters.deriveTaskStateFromA2A,
+  internalMessagesToA2A: () => import_adapters.internalMessagesToA2A,
+  internalToA2AMessage: () => import_adapters.internalToA2AMessage,
+  isJsonRpcError: () => import_jsonrpc.isJsonRpcError,
+  isJsonRpcSuccess: () => import_jsonrpc.isJsonRpcSuccess
+});
+module.exports = __toCommonJS(a2a_exports);
+var import_adapters = require("./adapters/index.js");
+var import_jsonrpc = require("./jsonrpc/index.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AMethodHandlers,
+  JsonRpcErrorCode,
+  JsonRpcServer,
+  TaskView,
+  a2aToInternalMessage,
+  createTaskView,
+  deriveTaskState,
+  deriveTaskStateFromA2A,
+  internalMessagesToA2A,
+  internalToA2AMessage,
+  isJsonRpcError,
+  isJsonRpcSuccess
+});

package/dist/a2a/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A2A Protocol Implementation
+ *
+ * Server-layer implementation of A2A Protocol v0.3.0.
+ * Exposes DextoAgent capabilities through A2A-compliant interfaces.
+ *
+ * Specification: https://a2a-protocol.org/latest/specification
+ *
+ * @module a2a
+ */
+export type { Task, TaskState, TaskStatus, Message, MessageRole, Part, TextPart, FilePart, DataPart, FileWithBytes, FileWithUri, Artifact, TaskStatusUpdateEvent, TaskArtifactUpdateEvent, MessageSendParams, MessageSendConfiguration, TaskQueryParams, ListTasksParams, ListTasksResult, TaskIdParams, ConvertedMessage, } from './types.js';
+export { TaskView, createTaskView, a2aToInternalMessage, internalToA2AMessage, internalMessagesToA2A, deriveTaskState, deriveTaskStateFromA2A, } from './adapters/index.js';
+export { JsonRpcServer, A2AMethodHandlers, JsonRpcErrorCode, isJsonRpcError, isJsonRpcSuccess, } from './jsonrpc/index.js';
+export type { JsonRpcRequest, JsonRpcResponse, JsonRpcError, JsonRpcMethodHandler, JsonRpcServerOptions, } from './jsonrpc/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/a2a/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/a2a/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,YAAY,EACR,IAAI,EACJ,SAAS,EACT,UAAU,EACV,OAAO,EACP,WAAW,EACX,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,aAAa,EACb,WAAW,EACX,QAAQ,EACR,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,eAAe,EACf,YAAY,EACZ,gBAAgB,GACnB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACH,QAAQ,EACR,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,sBAAsB,GACzB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACH,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,gBAAgB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACR,cAAc,EACd,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,oBAAoB,GACvB,MAAM,oBAAoB,CAAC"}

package/dist/a2a/index.js

@@ -0,0 +1,30 @@
+import {
+  TaskView,
+  createTaskView,
+  a2aToInternalMessage,
+  internalToA2AMessage,
+  internalMessagesToA2A,
+  deriveTaskState,
+  deriveTaskStateFromA2A
+} from "./adapters/index.js";
+import {
+  JsonRpcServer,
+  A2AMethodHandlers,
+  JsonRpcErrorCode,
+  isJsonRpcError,
+  isJsonRpcSuccess
+} from "./jsonrpc/index.js";
+export {
+  A2AMethodHandlers,
+  JsonRpcErrorCode,
+  JsonRpcServer,
+  TaskView,
+  a2aToInternalMessage,
+  createTaskView,
+  deriveTaskState,
+  deriveTaskStateFromA2A,
+  internalMessagesToA2A,
+  internalToA2AMessage,
+  isJsonRpcError,
+  isJsonRpcSuccess
+};

package/dist/a2a/jsonrpc/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsonrpc_exports = {};
+__export(jsonrpc_exports, {
+  A2AMethodHandlers: () => import_methods.A2AMethodHandlers,
+  JsonRpcErrorCode: () => import_types.JsonRpcErrorCode,
+  JsonRpcServer: () => import_server.JsonRpcServer,
+  isJsonRpcError: () => import_types.isJsonRpcError,
+  isJsonRpcSuccess: () => import_types.isJsonRpcSuccess
+});
+module.exports = __toCommonJS(jsonrpc_exports);
+var import_server = require("./server.js");
+var import_methods = require("./methods.js");
+var import_types = require("./types.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AMethodHandlers,
+  JsonRpcErrorCode,
+  JsonRpcServer,
+  isJsonRpcError,
+  isJsonRpcSuccess
+});

package/dist/a2a/jsonrpc/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A2A JSON-RPC 2.0 Implementation
+ *
+ * JSON-RPC transport layer for A2A Protocol.
+ */
+export { JsonRpcServer } from './server.js';
+export type { JsonRpcMethodHandler, JsonRpcServerOptions } from './server.js';
+export { A2AMethodHandlers } from './methods.js';
+export type { JsonRpcRequest, JsonRpcResponse, JsonRpcSuccessResponse, JsonRpcErrorResponse, JsonRpcError, JsonRpcBatchRequest, JsonRpcBatchResponse, } from './types.js';
+export { JsonRpcErrorCode, isJsonRpcError, isJsonRpcSuccess } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/a2a/jsonrpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/a2a/jsonrpc/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,YAAY,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,YAAY,EACR,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,YAAY,EACZ,mBAAmB,EACnB,oBAAoB,GACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/a2a/jsonrpc/index.js

@@ -0,0 +1,10 @@
+import { JsonRpcServer } from "./server.js";
+import { A2AMethodHandlers } from "./methods.js";
+import { JsonRpcErrorCode, isJsonRpcError, isJsonRpcSuccess } from "./types.js";
+export {
+  A2AMethodHandlers,
+  JsonRpcErrorCode,
+  JsonRpcServer,
+  isJsonRpcError,
+  isJsonRpcSuccess
+};

package/dist/a2a/jsonrpc/methods.cjs

@@ -0,0 +1,183 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var methods_exports = {};
+__export(methods_exports, {
+  A2AMethodHandlers: () => A2AMethodHandlers
+});
+module.exports = __toCommonJS(methods_exports);
+var import_task_view = require("../adapters/task-view.js");
+var import_message = require("../adapters/message.js");
+class A2AMethodHandlers {
+  constructor(agent) {
+    this.agent = agent;
+  }
+  /**
+   * message/send - Send a message to the agent
+   *
+   * This is the primary method for interacting with an agent.
+   * Creates a task if taskId not provided in message, or adds to existing task.
+   *
+   * @param params Message send parameters
+   * @returns Task or Message depending on configuration.blocking
+   */
+  async messageSend(params) {
+    if (!params?.message) {
+      throw new Error("message is required");
+    }
+    const { message } = params;
+    const taskId = message.taskId;
+    const session = await this.agent.createSession(taskId);
+    const { text, image, file } = (0, import_message.a2aToInternalMessage)(message);
+    await this.agent.run(text, image, file, session.id);
+    const taskView = new import_task_view.TaskView(session);
+    const task = await taskView.toA2ATask();
+    return task;
+  }
+  /**
+   * tasks/get - Retrieve a task by ID
+   *
+   * @param params Parameters containing task ID
+   * @returns Task details
+   * @throws Error if task not found
+   */
+  async tasksGet(params) {
+    if (!params?.id) {
+      throw new Error("id is required");
+    }
+    const session = await this.agent.getSession(params.id);
+    if (!session) {
+      throw new Error(`Task not found: ${params.id}`);
+    }
+    const taskView = new import_task_view.TaskView(session);
+    return await taskView.toA2ATask();
+  }
+  /**
+   * tasks/list - List all tasks (optional filters)
+   *
+   * Note: This implementation loads all sessions, applies filters, then paginates.
+   * For production with many sessions, consider filtering at the session manager level.
+   *
+   * @param params Optional filter parameters
+   * @returns List of tasks with pagination info
+   */
+  async tasksList(params) {
+    const sessionIds = await this.agent.listSessions();
+    const allTasks = [];
+    for (const sessionId of sessionIds) {
+      const session = await this.agent.getSession(sessionId);
+      if (!session) {
+        continue;
+      }
+      const taskView = new import_task_view.TaskView(session);
+      const task = await taskView.toA2ATask();
+      if (params?.status && task.status.state !== params.status) {
+        continue;
+      }
+      if (params?.contextId && task.contextId !== params.contextId) {
+        continue;
+      }
+      allTasks.push(task);
+    }
+    const pageSize = Math.min(params?.pageSize ?? 50, 100);
+    const offset = 0;
+    const paginatedTasks = allTasks.slice(offset, offset + pageSize);
+    return {
+      tasks: paginatedTasks,
+      totalSize: allTasks.length,
+      // Total matching tasks before pagination
+      pageSize,
+      nextPageToken: ""
+      // TODO: Implement pagination tokens
+    };
+  }
+  /**
+   * tasks/cancel - Cancel a running task
+   *
+   * @param params Parameters containing task ID
+   * @returns Updated task (in canceled state)
+   * @throws Error if task not found
+   */
+  async tasksCancel(params) {
+    if (!params?.id) {
+      throw new Error("id is required");
+    }
+    const session = await this.agent.getSession(params.id);
+    if (!session) {
+      throw new Error(`Task not found: ${params.id}`);
+    }
+    session.cancel();
+    const taskView = new import_task_view.TaskView(session);
+    return await taskView.toA2ATask();
+  }
+  /**
+   * message/stream - Send a message with streaming response
+   *
+   * This is a streaming variant of message/send. Instead of returning a complete Task,
+   * it returns a stream of TaskStatusUpdateEvent and TaskArtifactUpdateEvent as the
+   * agent processes the message.
+   *
+   * **ARCHITECTURE NOTE**: This method is designed as a lightweight handler that returns
+   * a taskId immediately. The actual message processing happens at the transport layer:
+   *
+   * - **JSON-RPC Transport** (packages/server/src/hono/routes/a2a-jsonrpc.ts:72-112):
+   *   The route intercepts 'message/stream' requests BEFORE calling this handler,
+   *   processes the message directly (lines 96-99), and returns an SSE stream.
+   *   This handler is registered but never actually invoked for JSON-RPC streaming.
+   *
+   * - **REST Transport** (packages/server/src/hono/routes/a2a-tasks.ts:206-244):
+   *   Similar pattern - route processes message and returns SSE stream directly.
+   *
+   * This design separates concerns:
+   * - Handler provides taskId for API compatibility
+   * - Transport layer manages SSE streaming and message processing
+   * - Event bus broadcasts updates to connected SSE clients
+   *
+   * @param params Message send parameters (same as message/send)
+   * @returns Task ID for streaming (transport layer handles actual SSE stream and message processing)
+   */
+  async messageStream(params) {
+    if (!params?.message) {
+      throw new Error("message is required");
+    }
+    const { message } = params;
+    const taskId = message.taskId;
+    const session = await this.agent.createSession(taskId);
+    return { taskId: session.id };
+  }
+  /**
+   * Get all method handlers as a Record for JsonRpcServer
+   *
+   * Returns methods with A2A-compliant names (slash notation).
+   *
+   * @returns Map of method names to handlers
+   */
+  getMethods() {
+    return {
+      "message/send": this.messageSend.bind(this),
+      "message/stream": this.messageStream.bind(this),
+      "tasks/get": this.tasksGet.bind(this),
+      "tasks/list": this.tasksList.bind(this),
+      "tasks/cancel": this.tasksCancel.bind(this)
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AMethodHandlers
+});

package/dist/a2a/jsonrpc/methods.d.ts

@@ -0,0 +1,110 @@
+/**
+ * A2A Protocol JSON-RPC Method Handlers
+ *
+ * Implements A2A Protocol v0.3.0 RPC methods by calling DextoAgent.
+ * These are thin wrappers that translate between A2A protocol and DextoAgent API.
+ *
+ * Method names per spec:
+ * - message/send - Send a message to the agent
+ * - message/stream - Send a message with streaming response
+ * - tasks/get - Retrieve a specific task
+ * - tasks/list - List tasks with optional filtering
+ * - tasks/cancel - Cancel an in-progress task
+ */
+import type { DextoAgent } from '@dexto/core';
+import type { Task, Message, MessageSendParams, TaskQueryParams, ListTasksParams, ListTasksResult, TaskIdParams } from '../types.js';
+/**
+ * A2A Method Handlers
+ *
+ * Implements all A2A Protocol JSON-RPC methods.
+ * Each method:
+ * 1. Validates params
+ * 2. Calls DextoAgent methods
+ * 3. Converts response to A2A format using TaskView
+ *
+ * Usage:
+ * ```typescript
+ * const handlers = new A2AMethodHandlers(agent);
+ * const server = new JsonRpcServer({
+ *   methods: handlers.getMethods()
+ * });
+ * ```
+ */
+export declare class A2AMethodHandlers {
+    private agent;
+    constructor(agent: DextoAgent);
+    /**
+     * message/send - Send a message to the agent
+     *
+     * This is the primary method for interacting with an agent.
+     * Creates a task if taskId not provided in message, or adds to existing task.
+     *
+     * @param params Message send parameters
+     * @returns Task or Message depending on configuration.blocking
+     */
+    messageSend(params: MessageSendParams): Promise<Task | Message>;
+    /**
+     * tasks/get - Retrieve a task by ID
+     *
+     * @param params Parameters containing task ID
+     * @returns Task details
+     * @throws Error if task not found
+     */
+    tasksGet(params: TaskQueryParams): Promise<Task>;
+    /**
+     * tasks/list - List all tasks (optional filters)
+     *
+     * Note: This implementation loads all sessions, applies filters, then paginates.
+     * For production with many sessions, consider filtering at the session manager level.
+     *
+     * @param params Optional filter parameters
+     * @returns List of tasks with pagination info
+     */
+    tasksList(params?: ListTasksParams): Promise<ListTasksResult>;
+    /**
+     * tasks/cancel - Cancel a running task
+     *
+     * @param params Parameters containing task ID
+     * @returns Updated task (in canceled state)
+     * @throws Error if task not found
+     */
+    tasksCancel(params: TaskIdParams): Promise<Task>;
+    /**
+     * message/stream - Send a message with streaming response
+     *
+     * This is a streaming variant of message/send. Instead of returning a complete Task,
+     * it returns a stream of TaskStatusUpdateEvent and TaskArtifactUpdateEvent as the
+     * agent processes the message.
+     *
+     * **ARCHITECTURE NOTE**: This method is designed as a lightweight handler that returns
+     * a taskId immediately. The actual message processing happens at the transport layer:
+     *
+     * - **JSON-RPC Transport** (packages/server/src/hono/routes/a2a-jsonrpc.ts:72-112):
+     *   The route intercepts 'message/stream' requests BEFORE calling this handler,
+     *   processes the message directly (lines 96-99), and returns an SSE stream.
+     *   This handler is registered but never actually invoked for JSON-RPC streaming.
+     *
+     * - **REST Transport** (packages/server/src/hono/routes/a2a-tasks.ts:206-244):
+     *   Similar pattern - route processes message and returns SSE stream directly.
+     *
+     * This design separates concerns:
+     * - Handler provides taskId for API compatibility
+     * - Transport layer manages SSE streaming and message processing
+     * - Event bus broadcasts updates to connected SSE clients
+     *
+     * @param params Message send parameters (same as message/send)
+     * @returns Task ID for streaming (transport layer handles actual SSE stream and message processing)
+     */
+    messageStream(params: MessageSendParams): Promise<{
+        taskId: string;
+    }>;
+    /**
+     * Get all method handlers as a Record for JsonRpcServer
+     *
+     * Returns methods with A2A-compliant names (slash notation).
+     *
+     * @returns Map of method names to handlers
+     */
+    getMethods(): Record<string, (params: any) => Promise<any>>;
+}
+//# sourceMappingURL=methods.d.ts.map

package/dist/a2a/jsonrpc/methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.ts","sourceRoot":"","sources":["../../../src/a2a/jsonrpc/methods.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EACR,IAAI,EACJ,OAAO,EACP,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,eAAe,EACf,YAAY,EACf,MAAM,aAAa,CAAC;AAIrB;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,iBAAiB;IACd,OAAO,CAAC,KAAK;gBAAL,KAAK,EAAE,UAAU;IAErC;;;;;;;;OAQG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC;IA2BrE;;;;;;OAMG;IACG,QAAQ,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBtD;;;;;;;;OAQG;IACG,SAAS,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IA0CnE;;;;;;OAMG;IACG,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBtD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAmB3E;;;;;;OAMG;IACH,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CAS9D"}