@dexto/server 1.2.5

package/dist/hono/middleware/redaction.cjs

@@ -0,0 +1,45 @@
+"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 redaction_exports = {};
+__export(redaction_exports, {
+  prettyJsonMiddleware: () => prettyJsonMiddleware,
+  redactionMiddleware: () => redactionMiddleware
+});
+module.exports = __toCommonJS(redaction_exports);
+var import_pretty_json = require("hono/pretty-json");
+var import_core = require("@dexto/core");
+const prettyJsonMiddleware = (0, import_pretty_json.prettyJSON)();
+const redactionMiddleware = async (ctx, next) => {
+  const originalJson = ctx.json.bind(ctx);
+  ctx.json = ((data, status, headers) => {
+    const redacted = (0, import_core.redactSensitiveData)(data);
+    return originalJson(redacted, status, headers);
+  });
+  const originalBody = ctx.body.bind(ctx);
+  ctx.body = ((data, status, headers) => {
+    const payload = typeof data === "string" ? (0, import_core.redactSensitiveData)(data) : data;
+    return originalBody(payload, status, headers);
+  });
+  await next();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prettyJsonMiddleware,
+  redactionMiddleware
+});

package/dist/hono/middleware/redaction.d.ts

@@ -0,0 +1,4 @@
+import type { MiddlewareHandler } from 'hono';
+export declare const prettyJsonMiddleware: MiddlewareHandler;
+export declare const redactionMiddleware: MiddlewareHandler;
+//# sourceMappingURL=redaction.d.ts.map

package/dist/hono/middleware/redaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.d.ts","sourceRoot":"","sources":["../../../src/hono/middleware/redaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAG9C,eAAO,MAAM,oBAAoB,mBAAe,CAAC;AAEjD,eAAO,MAAM,mBAAmB,EAAE,iBAejC,CAAC"}

package/dist/hono/middleware/redaction.js

@@ -0,0 +1,20 @@
+import { prettyJSON } from "hono/pretty-json";
+import { redactSensitiveData } from "@dexto/core";
+const prettyJsonMiddleware = prettyJSON();
+const redactionMiddleware = async (ctx, next) => {
+  const originalJson = ctx.json.bind(ctx);
+  ctx.json = ((data, status, headers) => {
+    const redacted = redactSensitiveData(data);
+    return originalJson(redacted, status, headers);
+  });
+  const originalBody = ctx.body.bind(ctx);
+  ctx.body = ((data, status, headers) => {
+    const payload = typeof data === "string" ? redactSensitiveData(data) : data;
+    return originalBody(payload, status, headers);
+  });
+  await next();
+};
+export {
+  prettyJsonMiddleware,
+  redactionMiddleware
+};

package/dist/hono/node/index.cjs

@@ -0,0 +1,139 @@
+"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 node_exports = {};
+__export(node_exports, {
+  createNodeServer: () => createNodeServer
+});
+module.exports = __toCommonJS(node_exports);
+var import_node_http = require("node:http");
+var import_node_stream = require("node:stream");
+var import_core = require("@dexto/core");
+function createNodeServer(app, options) {
+  const { getAgent: _getAgent } = options;
+  const webhookSubscriber = app.webhookSubscriber;
+  const server = (0, import_node_http.createServer)(async (req, res) => {
+    try {
+      if (options.mcpHandlers && req.url?.startsWith("/mcp")) {
+        if (req.method === "GET") {
+          await options.mcpHandlers.handleGet(req, res);
+          return;
+        }
+        if (req.method === "POST") {
+          req.setEncoding("utf8");
+          let body = "";
+          const MAX_BODY_SIZE = 10 * 1024 * 1024;
+          req.on("data", (chunk) => {
+            body += chunk;
+            if (body.length > MAX_BODY_SIZE) {
+              req.destroy();
+              res.statusCode = 413;
+              res.end("Payload too large");
+            }
+          });
+          req.on("end", async () => {
+            try {
+              const parsed = body.length > 0 ? JSON.parse(body) : void 0;
+              await options.mcpHandlers.handlePost(req, res, parsed);
+            } catch (err) {
+              import_core.logger.error(`Failed to process MCP POST body: ${String(err)}`);
+              res.statusCode = 400;
+              res.end("Invalid JSON body");
+            }
+          });
+          req.on("error", (err) => {
+            import_core.logger.error(`Error reading MCP POST body: ${String(err)}`);
+            res.statusCode = 500;
+            res.end("Failed to read request body");
+          });
+          return;
+        }
+      }
+      const request = await toRequest(req);
+      const response = await app.fetch(request);
+      await sendNodeResponse(res, response);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      import_core.logger.error(`Unhandled error in Node bridge: ${message}`, { error });
+      res.statusCode = 500;
+      res.end("Internal Server Error");
+    }
+  });
+  server.on("close", () => {
+    webhookSubscriber?.cleanup?.();
+  });
+  if (typeof options.port === "number") {
+    const hostname = options.hostname ?? "0.0.0.0";
+    server.listen(options.port, hostname, () => {
+      import_core.logger.info(`Hono Node bridge listening on http://${hostname}:${options.port}`);
+    });
+  }
+  const result = {
+    server
+  };
+  if (webhookSubscriber) {
+    result.webhookSubscriber = webhookSubscriber;
+  }
+  return result;
+}
+async function toRequest(req) {
+  const protocol = req.socket?.encrypted ? "https" : "http";
+  const host = req.headers.host ?? "localhost";
+  const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+  const headers = new globalThis.Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      value.forEach((entry) => headers.append(key, entry));
+    } else {
+      headers.set(key, value);
+    }
+  }
+  const method = req.method ?? "GET";
+  const body = method === "GET" || method === "HEAD" ? null : req;
+  return new globalThis.Request(url, {
+    method,
+    headers,
+    body: body ?? void 0,
+    duplex: body ? "half" : void 0
+  });
+}
+async function sendNodeResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    if (key.toLowerCase() === "content-length") {
+      return;
+    }
+    res.setHeader(key, value);
+  });
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  const webStream = response.body;
+  const readable = import_node_stream.Readable.fromWeb(webStream);
+  await new Promise((resolve, reject) => {
+    readable.on("error", reject);
+    res.on("finish", resolve);
+    readable.pipe(res);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNodeServer
+});

package/dist/hono/node/index.d.ts

@@ -0,0 +1,19 @@
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import type { DextoApp } from '../types.js';
+import type { DextoAgent } from '@dexto/core';
+import type { WebhookEventSubscriber } from '../../events/webhook-subscriber.js';
+export type NodeBridgeOptions = {
+    getAgent: () => DextoAgent;
+    port?: number;
+    hostname?: string;
+    mcpHandlers?: {
+        handlePost: (req: IncomingMessage, res: ServerResponse, body: unknown) => Promise<void> | void;
+        handleGet: (req: IncomingMessage, res: ServerResponse) => Promise<void> | void;
+    } | null;
+};
+export type NodeBridgeResult = {
+    server: ReturnType<typeof createServer>;
+    webhookSubscriber?: WebhookEventSubscriber;
+};
+export declare function createNodeServer(app: DextoApp, options: NodeBridgeOptions): NodeBridgeResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/hono/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hono/node/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAGpF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAKjF,MAAM,MAAM,iBAAiB,GAAG;IAC5B,QAAQ,EAAE,MAAM,UAAU,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE;QACV,UAAU,EAAE,CACR,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,OAAO,KACZ,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QAC1B,SAAS,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;KAClF,GAAG,IAAI,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC3B,MAAM,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;IACxC,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;CAC9C,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CAyE5F"}

package/dist/hono/node/index.js

@@ -0,0 +1,115 @@
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+import { logger } from "@dexto/core";
+function createNodeServer(app, options) {
+  const { getAgent: _getAgent } = options;
+  const webhookSubscriber = app.webhookSubscriber;
+  const server = createServer(async (req, res) => {
+    try {
+      if (options.mcpHandlers && req.url?.startsWith("/mcp")) {
+        if (req.method === "GET") {
+          await options.mcpHandlers.handleGet(req, res);
+          return;
+        }
+        if (req.method === "POST") {
+          req.setEncoding("utf8");
+          let body = "";
+          const MAX_BODY_SIZE = 10 * 1024 * 1024;
+          req.on("data", (chunk) => {
+            body += chunk;
+            if (body.length > MAX_BODY_SIZE) {
+              req.destroy();
+              res.statusCode = 413;
+              res.end("Payload too large");
+            }
+          });
+          req.on("end", async () => {
+            try {
+              const parsed = body.length > 0 ? JSON.parse(body) : void 0;
+              await options.mcpHandlers.handlePost(req, res, parsed);
+            } catch (err) {
+              logger.error(`Failed to process MCP POST body: ${String(err)}`);
+              res.statusCode = 400;
+              res.end("Invalid JSON body");
+            }
+          });
+          req.on("error", (err) => {
+            logger.error(`Error reading MCP POST body: ${String(err)}`);
+            res.statusCode = 500;
+            res.end("Failed to read request body");
+          });
+          return;
+        }
+      }
+      const request = await toRequest(req);
+      const response = await app.fetch(request);
+      await sendNodeResponse(res, response);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`Unhandled error in Node bridge: ${message}`, { error });
+      res.statusCode = 500;
+      res.end("Internal Server Error");
+    }
+  });
+  server.on("close", () => {
+    webhookSubscriber?.cleanup?.();
+  });
+  if (typeof options.port === "number") {
+    const hostname = options.hostname ?? "0.0.0.0";
+    server.listen(options.port, hostname, () => {
+      logger.info(`Hono Node bridge listening on http://${hostname}:${options.port}`);
+    });
+  }
+  const result = {
+    server
+  };
+  if (webhookSubscriber) {
+    result.webhookSubscriber = webhookSubscriber;
+  }
+  return result;
+}
+async function toRequest(req) {
+  const protocol = req.socket?.encrypted ? "https" : "http";
+  const host = req.headers.host ?? "localhost";
+  const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+  const headers = new globalThis.Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      value.forEach((entry) => headers.append(key, entry));
+    } else {
+      headers.set(key, value);
+    }
+  }
+  const method = req.method ?? "GET";
+  const body = method === "GET" || method === "HEAD" ? null : req;
+  return new globalThis.Request(url, {
+    method,
+    headers,
+    body: body ?? void 0,
+    duplex: body ? "half" : void 0
+  });
+}
+async function sendNodeResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    if (key.toLowerCase() === "content-length") {
+      return;
+    }
+    res.setHeader(key, value);
+  });
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  const webStream = response.body;
+  const readable = Readable.fromWeb(webStream);
+  await new Promise((resolve, reject) => {
+    readable.on("error", reject);
+    res.on("finish", resolve);
+    readable.pipe(res);
+  });
+}
+export {
+  createNodeServer
+};

package/dist/hono/routes/a2a-jsonrpc.cjs

@@ -0,0 +1,119 @@
+"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_jsonrpc_exports = {};
+__export(a2a_jsonrpc_exports, {
+  createA2AJsonRpcRouter: () => createA2AJsonRpcRouter
+});
+module.exports = __toCommonJS(a2a_jsonrpc_exports);
+var import_hono = require("hono");
+var import_server = require("../../a2a/jsonrpc/server.js");
+var import_methods = require("../../a2a/jsonrpc/methods.js");
+var import_core = require("@dexto/core");
+var import_message = require("../../a2a/adapters/message.js");
+function createA2AJsonRpcRouter(getAgent, sseSubscriber) {
+  const app = new import_hono.Hono();
+  app.post("/jsonrpc", async (ctx) => {
+    try {
+      const agent = getAgent();
+      const requestBody = await ctx.req.json();
+      const isStreamingRequest = !Array.isArray(requestBody) && requestBody.method === "message/stream";
+      if (isStreamingRequest) {
+        import_core.logger.info("JSON-RPC streaming request: message/stream");
+        const params = requestBody.params;
+        if (!params?.message) {
+          return ctx.json({
+            jsonrpc: "2.0",
+            error: {
+              code: -32602,
+              message: "Invalid params: message is required"
+            },
+            id: requestBody.id
+          });
+        }
+        const taskId = params.message.taskId;
+        const session = await agent.createSession(taskId);
+        const stream = sseSubscriber.createStream(session.id);
+        const { text, image, file } = (0, import_message.a2aToInternalMessage)(params.message);
+        agent.run(text, image, file, session.id).catch((error) => {
+          import_core.logger.error(`Error in streaming task ${session.id}: ${error}`);
+        });
+        import_core.logger.info(`JSON-RPC SSE stream opened for task ${session.id}`);
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no"
+          }
+        });
+      }
+      const handlers = new import_methods.A2AMethodHandlers(agent);
+      const rpcServer = new import_server.JsonRpcServer({
+        methods: handlers.getMethods(),
+        onError: (error, request) => {
+          import_core.logger.error(`JSON-RPC error for method ${request?.method}: ${error.message}`, {
+            error,
+            request
+          });
+        }
+      });
+      import_core.logger.debug(`A2A JSON-RPC request received`, {
+        method: Array.isArray(requestBody) ? `batch(${requestBody.length})` : requestBody.method
+      });
+      const response = await rpcServer.handle(requestBody);
+      return ctx.json(response);
+    } catch (error) {
+      import_core.logger.error(`Failed to process JSON-RPC request: ${error}`, { error });
+      return ctx.json({
+        jsonrpc: "2.0",
+        error: {
+          code: -32700,
+          message: "Parse error",
+          data: error instanceof Error ? error.message : String(error)
+        },
+        id: null
+      });
+    }
+  });
+  app.get("/jsonrpc", (ctx) => {
+    const agent = getAgent();
+    const handlers = new import_methods.A2AMethodHandlers(agent);
+    return ctx.json({
+      service: "A2A JSON-RPC 2.0",
+      version: "0.3.0",
+      endpoint: "/jsonrpc",
+      methods: Object.keys(handlers.getMethods()),
+      usage: {
+        method: "POST",
+        contentType: "application/json",
+        example: {
+          jsonrpc: "2.0",
+          method: "agent.getInfo",
+          params: {},
+          id: 1
+        }
+      }
+    });
+  });
+  return app;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createA2AJsonRpcRouter
+});

package/dist/hono/routes/a2a-jsonrpc.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A2A JSON-RPC HTTP Endpoint
+ *
+ * Exposes A2A Protocol JSON-RPC methods via HTTP POST endpoint.
+ * Implements JSON-RPC 2.0 over HTTP transport.
+ */
+import { Hono } from 'hono';
+import type { DextoAgent } from '@dexto/core';
+import type { A2ASseEventSubscriber } from '../../events/a2a-sse-subscriber.js';
+/**
+ * Create A2A JSON-RPC router
+ *
+ * Exposes POST /jsonrpc endpoint for A2A Protocol communication.
+ *
+ * Usage:
+ * ```typescript
+ * const a2aRouter = createA2AJsonRpcRouter(getAgent, sseSubscriber);
+ * app.route('/', a2aRouter);
+ * ```
+ *
+ * Example request:
+ * ```json
+ * POST /jsonrpc
+ * Content-Type: application/json
+ *
+ * {
+ *   "jsonrpc": "2.0",
+ *   "method": "message/send",
+ *   "params": {
+ *     "message": {
+ *       "role": "user",
+ *       "parts": [{ "kind": "text", "text": "Hello!" }],
+ *       "messageId": "msg-123",
+ *       "kind": "message"
+ *     }
+ *   },
+ *   "id": 1
+ * }
+ * ```
+ *
+ * @param getAgent Function to get current DextoAgent instance
+ * @param sseSubscriber SSE event subscriber for streaming methods
+ * @returns Hono router with /jsonrpc endpoint
+ */
+export declare function createA2AJsonRpcRouter(getAgent: () => DextoAgent, sseSubscriber: A2ASseEventSubscriber): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=a2a-jsonrpc.d.ts.map

package/dist/hono/routes/a2a-jsonrpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-jsonrpc.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/a2a-jsonrpc.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAGhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,sBAAsB,CAClC,QAAQ,EAAE,MAAM,UAAU,EAC1B,aAAa,EAAE,qBAAqB,8EA4HvC"}

package/dist/hono/routes/a2a-jsonrpc.js

@@ -0,0 +1,95 @@
+import { Hono } from "hono";
+import { JsonRpcServer } from "../../a2a/jsonrpc/server.js";
+import { A2AMethodHandlers } from "../../a2a/jsonrpc/methods.js";
+import { logger } from "@dexto/core";
+import { a2aToInternalMessage } from "../../a2a/adapters/message.js";
+function createA2AJsonRpcRouter(getAgent, sseSubscriber) {
+  const app = new Hono();
+  app.post("/jsonrpc", async (ctx) => {
+    try {
+      const agent = getAgent();
+      const requestBody = await ctx.req.json();
+      const isStreamingRequest = !Array.isArray(requestBody) && requestBody.method === "message/stream";
+      if (isStreamingRequest) {
+        logger.info("JSON-RPC streaming request: message/stream");
+        const params = requestBody.params;
+        if (!params?.message) {
+          return ctx.json({
+            jsonrpc: "2.0",
+            error: {
+              code: -32602,
+              message: "Invalid params: message is required"
+            },
+            id: requestBody.id
+          });
+        }
+        const taskId = params.message.taskId;
+        const session = await agent.createSession(taskId);
+        const stream = sseSubscriber.createStream(session.id);
+        const { text, image, file } = a2aToInternalMessage(params.message);
+        agent.run(text, image, file, session.id).catch((error) => {
+          logger.error(`Error in streaming task ${session.id}: ${error}`);
+        });
+        logger.info(`JSON-RPC SSE stream opened for task ${session.id}`);
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no"
+          }
+        });
+      }
+      const handlers = new A2AMethodHandlers(agent);
+      const rpcServer = new JsonRpcServer({
+        methods: handlers.getMethods(),
+        onError: (error, request) => {
+          logger.error(`JSON-RPC error for method ${request?.method}: ${error.message}`, {
+            error,
+            request
+          });
+        }
+      });
+      logger.debug(`A2A JSON-RPC request received`, {
+        method: Array.isArray(requestBody) ? `batch(${requestBody.length})` : requestBody.method
+      });
+      const response = await rpcServer.handle(requestBody);
+      return ctx.json(response);
+    } catch (error) {
+      logger.error(`Failed to process JSON-RPC request: ${error}`, { error });
+      return ctx.json({
+        jsonrpc: "2.0",
+        error: {
+          code: -32700,
+          message: "Parse error",
+          data: error instanceof Error ? error.message : String(error)
+        },
+        id: null
+      });
+    }
+  });
+  app.get("/jsonrpc", (ctx) => {
+    const agent = getAgent();
+    const handlers = new A2AMethodHandlers(agent);
+    return ctx.json({
+      service: "A2A JSON-RPC 2.0",
+      version: "0.3.0",
+      endpoint: "/jsonrpc",
+      methods: Object.keys(handlers.getMethods()),
+      usage: {
+        method: "POST",
+        contentType: "application/json",
+        example: {
+          jsonrpc: "2.0",
+          method: "agent.getInfo",
+          params: {},
+          id: 1
+        }
+      }
+    });
+  });
+  return app;
+}
+export {
+  createA2AJsonRpcRouter
+};