@dexto/server 1.2.5

package/dist/a2a/jsonrpc/methods.js

@@ -0,0 +1,159 @@
+import { TaskView } from "../adapters/task-view.js";
+import { a2aToInternalMessage } from "../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 } = a2aToInternalMessage(message);
+    await this.agent.run(text, image, file, session.id);
+    const taskView = new 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 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 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 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)
+    };
+  }
+}
+export {
+  A2AMethodHandlers
+};

package/dist/a2a/jsonrpc/server.cjs

@@ -0,0 +1,199 @@
+"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 server_exports = {};
+__export(server_exports, {
+  JsonRpcServer: () => JsonRpcServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_types = require("./types.js");
+class JsonRpcServer {
+  methods;
+  onError;
+  constructor(options) {
+    this.methods = options.methods;
+    this.onError = options.onError;
+  }
+  /**
+   * Handle a JSON-RPC request (single or batch).
+   *
+   * @param request Single request or batch array
+   * @returns Single response, batch array, or undefined for notifications
+   */
+  async handle(request) {
+    if (Array.isArray(request)) {
+      return await this.handleBatch(request);
+    }
+    return await this.handleSingle(request);
+  }
+  /**
+   * Handle a batch of JSON-RPC requests.
+   *
+   * Processes all requests in parallel per JSON-RPC 2.0 spec.
+   *
+   * @param requests Array of requests
+   * @returns Array of responses, or undefined if all were notifications
+   */
+  async handleBatch(requests) {
+    if (requests.length === 0) {
+      return [
+        this.createErrorResponse(null, import_types.JsonRpcErrorCode.INVALID_REQUEST, "Empty batch")
+      ];
+    }
+    const responses = await Promise.all(requests.map((req) => this.handleSingle(req)));
+    const validResponses = responses.filter((res) => res !== void 0);
+    if (validResponses.length === 0) {
+      return void 0;
+    }
+    return validResponses;
+  }
+  /**
+   * Handle a single JSON-RPC request.
+   *
+   * @param request JSON-RPC request object
+   * @returns JSON-RPC response object, or undefined for notifications
+   */
+  async handleSingle(request) {
+    try {
+      if (request.jsonrpc !== "2.0") {
+        if (request.id === void 0) {
+          return void 0;
+        }
+        return this.createErrorResponse(
+          request.id ?? null,
+          import_types.JsonRpcErrorCode.INVALID_REQUEST,
+          'Invalid JSON-RPC version (must be "2.0")'
+        );
+      }
+      if (typeof request.method !== "string") {
+        if (request.id === void 0) {
+          return void 0;
+        }
+        return this.createErrorResponse(
+          request.id ?? null,
+          import_types.JsonRpcErrorCode.INVALID_REQUEST,
+          "Method must be a string"
+        );
+      }
+      const handler = this.methods[request.method];
+      if (!handler) {
+        if (request.id === void 0) {
+          return void 0;
+        }
+        return this.createErrorResponse(
+          request.id ?? null,
+          import_types.JsonRpcErrorCode.METHOD_NOT_FOUND,
+          `Method not found: ${request.method}`
+        );
+      }
+      try {
+        const result = await handler(request.params);
+        if (request.id === void 0) {
+          return void 0;
+        }
+        return this.createSuccessResponse(request.id ?? null, result);
+      } catch (error) {
+        if (this.onError) {
+          this.onError(
+            error instanceof Error ? error : new Error(String(error)),
+            request
+          );
+        }
+        if (request.id === void 0) {
+          return void 0;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorData = error instanceof Error ? { name: error.name } : void 0;
+        return this.createErrorResponse(
+          request.id ?? null,
+          import_types.JsonRpcErrorCode.INTERNAL_ERROR,
+          errorMessage,
+          errorData
+        );
+      }
+    } catch (error) {
+      if (request.id === void 0) {
+        return void 0;
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return this.createErrorResponse(null, import_types.JsonRpcErrorCode.INVALID_REQUEST, errorMessage);
+    }
+  }
+  /**
+   * Create a success response.
+   */
+  createSuccessResponse(id, result) {
+    return {
+      jsonrpc: "2.0",
+      result,
+      id
+    };
+  }
+  /**
+   * Create an error response.
+   */
+  createErrorResponse(id, code, message, data) {
+    const error = { code, message };
+    if (data !== void 0) {
+      error.data = data;
+    }
+    return {
+      jsonrpc: "2.0",
+      error,
+      id
+    };
+  }
+  /**
+   * Register a new method handler.
+   *
+   * @param method Method name
+   * @param handler Handler function
+   */
+  registerMethod(method, handler) {
+    this.methods[method] = handler;
+  }
+  /**
+   * Unregister a method handler.
+   *
+   * @param method Method name
+   */
+  unregisterMethod(method) {
+    delete this.methods[method];
+  }
+  /**
+   * Check if a method is registered.
+   *
+   * @param method Method name
+   * @returns True if method exists
+   */
+  hasMethod(method) {
+    return method in this.methods;
+  }
+  /**
+   * Get list of registered method names.
+   *
+   * @returns Array of method names
+   */
+  getMethods() {
+    return Object.keys(this.methods);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonRpcServer
+});

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

@@ -0,0 +1,100 @@
+/**
+ * JSON-RPC 2.0 Server
+ *
+ * Handles JSON-RPC 2.0 request parsing, method dispatch, and response formatting.
+ * Implements the full JSON-RPC 2.0 specification including batch requests.
+ */
+import type { JsonRpcRequest, JsonRpcResponse, JsonRpcBatchRequest, JsonRpcBatchResponse } from './types.js';
+/**
+ * Method handler function type
+ */
+export type JsonRpcMethodHandler = (params: any) => Promise<any>;
+/**
+ * JSON-RPC 2.0 Server Options
+ */
+export interface JsonRpcServerOptions {
+    /** Method handlers map */
+    methods: Record<string, JsonRpcMethodHandler>;
+    /** Optional error handler */
+    onError?: (error: Error, request?: JsonRpcRequest) => void;
+}
+/**
+ * JSON-RPC 2.0 Server
+ *
+ * Parses JSON-RPC requests, dispatches to handlers, and formats responses.
+ *
+ * Usage:
+ * ```typescript
+ * const server = new JsonRpcServer({
+ *   methods: {
+ *     'agent.createTask': async (params) => { ... },
+ *     'agent.getTask': async (params) => { ... },
+ *   }
+ * });
+ *
+ * const response = await server.handle(request);
+ * ```
+ */
+export declare class JsonRpcServer {
+    private methods;
+    private onError;
+    constructor(options: JsonRpcServerOptions);
+    /**
+     * Handle a JSON-RPC request (single or batch).
+     *
+     * @param request Single request or batch array
+     * @returns Single response, batch array, or undefined for notifications
+     */
+    handle(request: JsonRpcRequest | JsonRpcBatchRequest): Promise<JsonRpcResponse | JsonRpcBatchResponse | undefined>;
+    /**
+     * Handle a batch of JSON-RPC requests.
+     *
+     * Processes all requests in parallel per JSON-RPC 2.0 spec.
+     *
+     * @param requests Array of requests
+     * @returns Array of responses, or undefined if all were notifications
+     */
+    private handleBatch;
+    /**
+     * Handle a single JSON-RPC request.
+     *
+     * @param request JSON-RPC request object
+     * @returns JSON-RPC response object, or undefined for notifications
+     */
+    private handleSingle;
+    /**
+     * Create a success response.
+     */
+    private createSuccessResponse;
+    /**
+     * Create an error response.
+     */
+    private createErrorResponse;
+    /**
+     * Register a new method handler.
+     *
+     * @param method Method name
+     * @param handler Handler function
+     */
+    registerMethod(method: string, handler: JsonRpcMethodHandler): void;
+    /**
+     * Unregister a method handler.
+     *
+     * @param method Method name
+     */
+    unregisterMethod(method: string): void;
+    /**
+     * Check if a method is registered.
+     *
+     * @param method Method name
+     * @returns True if method exists
+     */
+    hasMethod(method: string): boolean;
+    /**
+     * Get list of registered method names.
+     *
+     * @returns Array of method names
+     */
+    getMethods(): string[];
+}
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/a2a/jsonrpc/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACR,cAAc,EACd,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EAEvB,MAAM,YAAY,CAAC;AAGpB;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC9C,6BAA6B;IAC7B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;CAC9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,OAAO,CAAiE;gBAEpE,OAAO,EAAE,oBAAoB;IAKzC;;;;;OAKG;IACG,MAAM,CACR,OAAO,EAAE,cAAc,GAAG,mBAAmB,GAC9C,OAAO,CAAC,eAAe,GAAG,oBAAoB,GAAG,SAAS,CAAC;IAU9D;;;;;;;OAOG;YACW,WAAW;IAwBzB;;;;;OAKG;YACW,YAAY;IAwF1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAkB3B;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAInE;;;;OAIG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAItC;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC;;;;OAIG;IACH,UAAU,IAAI,MAAM,EAAE;CAGzB"}

package/dist/a2a/jsonrpc/server.js

@@ -0,0 +1,175 @@
+import { JsonRpcErrorCode } from "./types.js";
+class JsonRpcServer {
+  methods;
+  onError;
+  constructor(options) {
+    this.methods = options.methods;
+    this.onError = options.onError;
+  }
+  /**
+   * Handle a JSON-RPC request (single or batch).
+   *
+   * @param request Single request or batch array
+   * @returns Single response, batch array, or undefined for notifications
+   */
+  async handle(request) {
+    if (Array.isArray(request)) {
+      return await this.handleBatch(request);
+    }
+    return await this.handleSingle(request);
+  }
+  /**
+   * Handle a batch of JSON-RPC requests.
+   *
+   * Processes all requests in parallel per JSON-RPC 2.0 spec.
+   *
+   * @param requests Array of requests
+   * @returns Array of responses, or undefined if all were notifications
+   */
+  async handleBatch(requests) {
+    if (requests.length === 0) {
+      return [
+        this.createErrorResponse(null, JsonRpcErrorCode.INVALID_REQUEST, "Empty batch")
+      ];
+    }
+    const responses = await Promise.all(requests.map((req) => this.handleSingle(req)));
+    const validResponses = responses.filter((res) => res !== void 0);
+    if (validResponses.length === 0) {
+      return void 0;
+    }
+    return validResponses;
+  }
+  /**
+   * Handle a single JSON-RPC request.
+   *
+   * @param request JSON-RPC request object
+   * @returns JSON-RPC response object, or undefined for notifications
+   */
+  async handleSingle(request) {
+    try {
+      if (request.jsonrpc !== "2.0") {
+        if (request.id === void 0) {
+          return void 0;
+        }
+        return this.createErrorResponse(
+          request.id ?? null,
+          JsonRpcErrorCode.INVALID_REQUEST,
+          'Invalid JSON-RPC version (must be "2.0")'
+        );
+      }
+      if (typeof request.method !== "string") {
+        if (request.id === void 0) {
+          return void 0;
+        }
+        return this.createErrorResponse(
+          request.id ?? null,
+          JsonRpcErrorCode.INVALID_REQUEST,
+          "Method must be a string"
+        );
+      }
+      const handler = this.methods[request.method];
+      if (!handler) {
+        if (request.id === void 0) {
+          return void 0;
+        }
+        return this.createErrorResponse(
+          request.id ?? null,
+          JsonRpcErrorCode.METHOD_NOT_FOUND,
+          `Method not found: ${request.method}`
+        );
+      }
+      try {
+        const result = await handler(request.params);
+        if (request.id === void 0) {
+          return void 0;
+        }
+        return this.createSuccessResponse(request.id ?? null, result);
+      } catch (error) {
+        if (this.onError) {
+          this.onError(
+            error instanceof Error ? error : new Error(String(error)),
+            request
+          );
+        }
+        if (request.id === void 0) {
+          return void 0;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorData = error instanceof Error ? { name: error.name } : void 0;
+        return this.createErrorResponse(
+          request.id ?? null,
+          JsonRpcErrorCode.INTERNAL_ERROR,
+          errorMessage,
+          errorData
+        );
+      }
+    } catch (error) {
+      if (request.id === void 0) {
+        return void 0;
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return this.createErrorResponse(null, JsonRpcErrorCode.INVALID_REQUEST, errorMessage);
+    }
+  }
+  /**
+   * Create a success response.
+   */
+  createSuccessResponse(id, result) {
+    return {
+      jsonrpc: "2.0",
+      result,
+      id
+    };
+  }
+  /**
+   * Create an error response.
+   */
+  createErrorResponse(id, code, message, data) {
+    const error = { code, message };
+    if (data !== void 0) {
+      error.data = data;
+    }
+    return {
+      jsonrpc: "2.0",
+      error,
+      id
+    };
+  }
+  /**
+   * Register a new method handler.
+   *
+   * @param method Method name
+   * @param handler Handler function
+   */
+  registerMethod(method, handler) {
+    this.methods[method] = handler;
+  }
+  /**
+   * Unregister a method handler.
+   *
+   * @param method Method name
+   */
+  unregisterMethod(method) {
+    delete this.methods[method];
+  }
+  /**
+   * Check if a method is registered.
+   *
+   * @param method Method name
+   * @returns True if method exists
+   */
+  hasMethod(method) {
+    return method in this.methods;
+  }
+  /**
+   * Get list of registered method names.
+   *
+   * @returns Array of method names
+   */
+  getMethods() {
+    return Object.keys(this.methods);
+  }
+}
+export {
+  JsonRpcServer
+};

package/dist/a2a/jsonrpc/types.cjs

@@ -0,0 +1,47 @@
+"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 types_exports = {};
+__export(types_exports, {
+  JsonRpcErrorCode: () => JsonRpcErrorCode,
+  isJsonRpcError: () => isJsonRpcError,
+  isJsonRpcSuccess: () => isJsonRpcSuccess
+});
+module.exports = __toCommonJS(types_exports);
+var JsonRpcErrorCode = /* @__PURE__ */ ((JsonRpcErrorCode2) => {
+  JsonRpcErrorCode2[JsonRpcErrorCode2["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["SERVER_ERROR_START"] = -32099] = "SERVER_ERROR_START";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["SERVER_ERROR_END"] = -32e3] = "SERVER_ERROR_END";
+  return JsonRpcErrorCode2;
+})(JsonRpcErrorCode || {});
+function isJsonRpcError(response) {
+  return "error" in response;
+}
+function isJsonRpcSuccess(response) {
+  return "result" in response;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonRpcErrorCode,
+  isJsonRpcError,
+  isJsonRpcSuccess
+});