@dexto/server 1.2.5

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

@@ -0,0 +1,291 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { A2AMethodHandlers } from "../../a2a/jsonrpc/methods.js";
+import { logger } from "@dexto/core";
+import { a2aToInternalMessage } from "../../a2a/adapters/message.js";
+const PartSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("text").describe("Part type discriminator"),
+    text: z.string().describe("Text content"),
+    metadata: z.record(z.any()).optional().describe("Extension metadata")
+  }),
+  z.object({
+    kind: z.literal("file").describe("Part type discriminator"),
+    file: z.union([
+      z.object({
+        bytes: z.string().describe("Base64-encoded file data"),
+        name: z.string().optional().describe("File name"),
+        mimeType: z.string().optional().describe("MIME type")
+      }),
+      z.object({
+        uri: z.string().describe("File URI"),
+        name: z.string().optional().describe("File name"),
+        mimeType: z.string().optional().describe("MIME type")
+      })
+    ]).describe("File data (bytes or URI)"),
+    metadata: z.record(z.any()).optional().describe("Extension metadata")
+  }),
+  z.object({
+    kind: z.literal("data").describe("Part type discriminator"),
+    data: z.record(z.any()).describe("Structured JSON data"),
+    metadata: z.record(z.any()).optional().describe("Extension metadata")
+  })
+]).describe("Message part (text, file, or data)");
+const MessageSchema = z.object({
+  role: z.enum(["user", "agent"]).describe("Message role"),
+  parts: z.array(PartSchema).describe("Message parts"),
+  messageId: z.string().describe("Unique message identifier"),
+  taskId: z.string().optional().describe("Associated task ID"),
+  contextId: z.string().optional().describe("Context identifier"),
+  metadata: z.record(z.any()).optional().describe("Extension metadata"),
+  extensions: z.array(z.string()).optional().describe("Extension identifiers"),
+  referenceTaskIds: z.array(z.string()).optional().describe("Referenced task IDs"),
+  kind: z.literal("message").describe("Object type discriminator")
+}).describe("A2A Protocol message");
+const TaskStatusSchema = z.object({
+  state: z.enum([
+    "submitted",
+    "working",
+    "input-required",
+    "completed",
+    "canceled",
+    "failed",
+    "rejected",
+    "auth-required",
+    "unknown"
+  ]).describe("Current task state"),
+  message: MessageSchema.optional().describe("Status message"),
+  timestamp: z.string().optional().describe("ISO 8601 timestamp")
+}).describe("Task status");
+const TaskSchema = z.object({
+  id: z.string().describe("Unique task identifier"),
+  contextId: z.string().describe("Context identifier across related tasks"),
+  status: TaskStatusSchema.describe("Current task status"),
+  history: z.array(MessageSchema).optional().describe("Conversation history"),
+  artifacts: z.array(z.any()).optional().describe("Task artifacts"),
+  metadata: z.record(z.any()).optional().describe("Extension metadata"),
+  kind: z.literal("task").describe("Object type discriminator")
+}).describe("A2A Protocol task");
+const MessageSendRequestSchema = z.object({
+  message: MessageSchema.describe("Message to send to the agent"),
+  configuration: z.object({
+    acceptedOutputModes: z.array(z.string()).optional().describe("Accepted output MIME types"),
+    historyLength: z.number().optional().describe("Limit conversation history length"),
+    pushNotificationConfig: z.object({
+      url: z.string().describe("Push notification webhook URL"),
+      headers: z.record(z.string()).optional().describe("HTTP headers for webhook")
+    }).optional().describe("Push notification configuration"),
+    blocking: z.boolean().optional().describe("Wait for task completion")
+  }).optional().describe("Optional configuration"),
+  metadata: z.record(z.any()).optional().describe("Optional metadata")
+}).describe("Request body for message/send");
+const TaskListQuerySchema = z.object({
+  contextId: z.string().optional().describe("Filter by context ID"),
+  status: z.enum([
+    "submitted",
+    "working",
+    "input-required",
+    "completed",
+    "canceled",
+    "failed",
+    "rejected",
+    "auth-required",
+    "unknown"
+  ]).optional().describe("Filter by task state"),
+  pageSize: z.string().optional().transform((v) => {
+    if (!v) return void 0;
+    const n = Number.parseInt(v, 10);
+    if (Number.isNaN(n) || n < 1 || n > 100) return void 0;
+    return n;
+  }).describe("Number of results (1-100, default 50)"),
+  pageToken: z.string().optional().describe("Pagination token (not yet implemented - reserved for future use)"),
+  historyLength: z.string().optional().transform((v) => {
+    if (!v) return void 0;
+    const n = Number.parseInt(v, 10);
+    return Number.isNaN(n) ? void 0 : n;
+  }).describe("Limit history items (not yet implemented - reserved for future use)"),
+  lastUpdatedAfter: z.string().optional().transform((v) => {
+    if (!v) return void 0;
+    const n = Number.parseInt(v, 10);
+    return Number.isNaN(n) ? void 0 : n;
+  }).describe("Unix timestamp filter (not yet implemented - reserved for future use)"),
+  includeArtifacts: z.string().optional().transform((v) => v === "true").describe(
+    "Include artifacts in response (not yet implemented - reserved for future use)"
+  )
+}).describe("Query parameters for tasks/list");
+function createA2ATasksRouter(getAgent, sseSubscriber) {
+  const app = new OpenAPIHono();
+  const messageSendRoute = createRoute({
+    method: "post",
+    path: "/v1/message:send",
+    summary: "Send Message",
+    description: "Send a message to the agent (A2A message/send)",
+    tags: ["a2a"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: MessageSendRequestSchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "Task with agent response",
+        content: {
+          "application/json": {
+            schema: TaskSchema
+          }
+        }
+      }
+    }
+  });
+  const listTasksRoute = createRoute({
+    method: "get",
+    path: "/v1/tasks",
+    summary: "List Tasks",
+    description: "List all A2A tasks with optional filtering (A2A tasks/list)",
+    tags: ["a2a"],
+    request: {
+      query: TaskListQuerySchema
+    },
+    responses: {
+      200: {
+        description: "Task list",
+        content: {
+          "application/json": {
+            schema: z.object({
+              tasks: z.array(TaskSchema).describe("Array of tasks"),
+              totalSize: z.number().describe("Total number of tasks"),
+              pageSize: z.number().describe("Number of tasks in this page"),
+              nextPageToken: z.string().describe("Token for next page")
+            }).describe("Response body for tasks/list")
+          }
+        }
+      }
+    }
+  });
+  const getTaskRoute = createRoute({
+    method: "get",
+    path: "/v1/tasks/{id}",
+    summary: "Get Task",
+    description: "Retrieve a specific task by ID (A2A tasks/get)",
+    tags: ["a2a"],
+    request: {
+      params: z.object({
+        id: z.string().describe("Task ID")
+      })
+    },
+    responses: {
+      200: {
+        description: "Task details",
+        content: {
+          "application/json": {
+            schema: TaskSchema
+          }
+        }
+      },
+      404: {
+        description: "Task not found"
+      }
+    }
+  });
+  const cancelTaskRoute = createRoute({
+    method: "post",
+    path: "/v1/tasks/{id}:cancel",
+    summary: "Cancel Task",
+    description: "Cancel a running task (A2A tasks/cancel)",
+    tags: ["a2a"],
+    request: {
+      params: z.object({
+        id: z.string().describe("Task ID")
+      })
+    },
+    responses: {
+      200: {
+        description: "Task cancelled",
+        content: {
+          "application/json": {
+            schema: TaskSchema
+          }
+        }
+      },
+      404: {
+        description: "Task not found"
+      }
+    }
+  });
+  app.post("/v1/message:stream", async (ctx) => {
+    try {
+      const body = await ctx.req.json();
+      const parseResult = MessageSendRequestSchema.safeParse(body);
+      if (!parseResult.success) {
+        return ctx.json(
+          {
+            error: "Invalid request body",
+            details: parseResult.error.issues
+          },
+          400
+        );
+      }
+      const validatedBody = parseResult.data;
+      logger.info("REST: message/stream", { hasMessage: !!validatedBody.message });
+      const taskId = validatedBody.message.taskId;
+      const agent = getAgent();
+      const session = await agent.createSession(taskId);
+      const stream = sseSubscriber.createStream(session.id);
+      const { text, image, file } = a2aToInternalMessage(validatedBody.message);
+      agent.run(text, image, file, session.id).catch((error) => {
+        logger.error(`Error in streaming task ${session.id}: ${error}`);
+      });
+      logger.info(`REST 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"
+        }
+      });
+    } catch (error) {
+      logger.error(`Failed to handle message:stream: ${error}`);
+      return ctx.json({ error: "Failed to initiate streaming" }, 500);
+    }
+  });
+  return app.openapi(messageSendRoute, async (ctx) => {
+    const handlers = new A2AMethodHandlers(getAgent());
+    const body = ctx.req.valid("json");
+    logger.info("REST: message/send", { hasMessage: !!body.message });
+    const result = await handlers.messageSend(body);
+    return ctx.json(result);
+  }).openapi(listTasksRoute, async (ctx) => {
+    const handlers = new A2AMethodHandlers(getAgent());
+    const query = ctx.req.valid("query");
+    const result = await handlers.tasksList(query);
+    return ctx.json(result);
+  }).openapi(getTaskRoute, async (ctx) => {
+    const handlers = new A2AMethodHandlers(getAgent());
+    const { id } = ctx.req.valid("param");
+    try {
+      const task = await handlers.tasksGet({ id });
+      return ctx.json(task);
+    } catch (error) {
+      logger.warn(`Task ${id} not found: ${error}`);
+      return ctx.json({ error: "Task not found" }, 404);
+    }
+  }).openapi(cancelTaskRoute, async (ctx) => {
+    const handlers = new A2AMethodHandlers(getAgent());
+    const { id } = ctx.req.valid("param");
+    logger.info(`REST: tasks/cancel ${id}`);
+    try {
+      const task = await handlers.tasksCancel({ id });
+      return ctx.json(task);
+    } catch (error) {
+      logger.error(`Failed to cancel task ${id}: ${error}`);
+      return ctx.json({ error: "Task not found" }, 404);
+    }
+  });
+}
+export {
+  createA2ATasksRouter
+};

package/dist/hono/routes/a2a.cjs

@@ -0,0 +1,36 @@
+"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, {
+  createA2aRouter: () => createA2aRouter
+});
+module.exports = __toCommonJS(a2a_exports);
+var import_hono = require("hono");
+function createA2aRouter(getAgentCard) {
+  const app = new import_hono.Hono();
+  app.get("/.well-known/agent-card.json", (ctx) => {
+    const agentCard = getAgentCard();
+    return ctx.json(agentCard, 200);
+  });
+  return app;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createA2aRouter
+});

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

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import type { AgentCard } from '@dexto/core';
+export declare function createA2aRouter(getAgentCard: () => AgentCard): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=a2a.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"a2a.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/a2a.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,SAAS,8EAO5D"}

package/dist/hono/routes/a2a.js

@@ -0,0 +1,12 @@
+import { Hono } from "hono";
+function createA2aRouter(getAgentCard) {
+  const app = new Hono();
+  app.get("/.well-known/agent-card.json", (ctx) => {
+    const agentCard = getAgentCard();
+    return ctx.json(agentCard, 200);
+  });
+  return app;
+}
+export {
+  createA2aRouter
+};