@dexto/server 1.2.5

package/dist/hono/routes/approvals.cjs

@@ -0,0 +1,125 @@
+"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 approvals_exports = {};
+__export(approvals_exports, {
+  createApprovalsRouter: () => createApprovalsRouter
+});
+module.exports = __toCommonJS(approvals_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+const ApprovalBodySchema = import_zod_openapi.z.object({
+  status: import_zod_openapi.z.enum([import_core.ApprovalStatus.APPROVED, import_core.ApprovalStatus.DENIED]).describe("The user decision"),
+  formData: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional form data provided by the user (for elicitation)"),
+  rememberChoice: import_zod_openapi.z.boolean().optional().describe("Whether to remember this choice for future requests")
+}).describe("Request body for submitting an approval decision");
+const ApprovalResponseSchema = import_zod_openapi.z.object({
+  ok: import_zod_openapi.z.boolean().describe("Whether the approval was successfully processed"),
+  approvalId: import_zod_openapi.z.string().describe("The ID of the processed approval"),
+  status: import_zod_openapi.z.enum([import_core.ApprovalStatus.APPROVED, import_core.ApprovalStatus.DENIED]).describe("The final status")
+}).describe("Response after processing approval");
+function createApprovalsRouter(getAgent, approvalCoordinator) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const submitApprovalRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/approvals/{approvalId}",
+    summary: "Submit Approval Decision",
+    description: "Submit a user decision for a pending approval request",
+    tags: ["approvals"],
+    request: {
+      params: import_zod_openapi.z.object({
+        approvalId: import_zod_openapi.z.string().describe("The ID of the approval request")
+      }),
+      body: {
+        content: { "application/json": { schema: ApprovalBodySchema } }
+      },
+      headers: import_zod_openapi.z.object({
+        "Idempotency-Key": import_zod_openapi.z.string().optional().describe("Optional key to ensure idempotent processing")
+      })
+    },
+    responses: {
+      200: {
+        description: "Approval processed successfully",
+        content: {
+          "application/json": {
+            schema: ApprovalResponseSchema
+          }
+        }
+      },
+      404: {
+        description: "Approval request not found or expired"
+      },
+      400: {
+        description: "Validation error"
+      },
+      503: {
+        description: "Approval coordinator unavailable (server not initialized for approvals)"
+      }
+    }
+  });
+  return app.openapi(submitApprovalRoute, async (ctx) => {
+    const agent = getAgent();
+    const { approvalId } = ctx.req.valid("param");
+    const { status, formData, rememberChoice } = ctx.req.valid("json");
+    agent.logger.info(`Received approval decision for ${approvalId}: ${status}`);
+    if (!approvalCoordinator) {
+      agent.logger.error("ApprovalCoordinator not available");
+      return ctx.json({ ok: false, approvalId, status }, 503);
+    }
+    const pendingApprovals = agent.services.approvalManager.getPendingApprovals();
+    if (!pendingApprovals.includes(approvalId)) {
+      throw import_core.ApprovalError.notFound(approvalId);
+    }
+    try {
+      const data = {};
+      if (status === import_core.ApprovalStatus.APPROVED) {
+        if (formData !== void 0) {
+          data.formData = formData;
+        }
+        if (rememberChoice !== void 0) {
+          data.rememberChoice = rememberChoice;
+        }
+      }
+      const sessionId = approvalCoordinator.getSessionId(approvalId);
+      const responsePayload = {
+        approvalId,
+        status,
+        sessionId,
+        // Attach sessionId for SSE routing to correct client streams
+        ...status === import_core.ApprovalStatus.DENIED ? {
+          reason: import_core.DenialReason.USER_DENIED,
+          message: "User denied the request via API"
+        } : {},
+        ...Object.keys(data).length > 0 ? { data } : {}
+      };
+      approvalCoordinator.emitResponse(responsePayload);
+      return ctx.json({
+        ok: true,
+        approvalId,
+        status
+      });
+    } catch (error) {
+      agent.logger.error("Error processing approval", { approvalId, error });
+      return ctx.json({ ok: false, approvalId, status }, 500);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createApprovalsRouter
+});

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

@@ -0,0 +1,89 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import { type DextoAgent, ApprovalStatus } from '@dexto/core';
+import type { ApprovalCoordinator } from '../../approval/approval-coordinator.js';
+export declare function createApprovalsRouter(getAgent: () => DextoAgent, approvalCoordinator?: ApprovalCoordinator): OpenAPIHono<import("hono").Env, {
+    "/approvals/:approvalId": {
+        $post: {
+            input: {
+                param: {
+                    approvalId: string;
+                };
+            } & {
+                header: {
+                    'Idempotency-Key'?: string | undefined;
+                };
+            } & {
+                json: {
+                    status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                    formData?: Record<string, unknown> | undefined;
+                    rememberChoice?: boolean | undefined;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    approvalId: string;
+                };
+            } & {
+                header: {
+                    'Idempotency-Key'?: string | undefined;
+                };
+            } & {
+                json: {
+                    status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                    formData?: Record<string, unknown> | undefined;
+                    rememberChoice?: boolean | undefined;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    approvalId: string;
+                };
+            } & {
+                header: {
+                    'Idempotency-Key'?: string | undefined;
+                };
+            } & {
+                json: {
+                    status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                    formData?: Record<string, unknown> | undefined;
+                    rememberChoice?: boolean | undefined;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 503;
+        } | {
+            input: {
+                param: {
+                    approvalId: string;
+                };
+            } & {
+                header: {
+                    'Idempotency-Key'?: string | undefined;
+                };
+            } & {
+                json: {
+                    status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                    formData?: Record<string, unknown> | undefined;
+                    rememberChoice?: boolean | undefined;
+                };
+            };
+            output: {
+                status: ApprovalStatus.APPROVED | ApprovalStatus.DENIED;
+                ok: boolean;
+                approvalId: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=approvals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"approvals.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/approvals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,KAAK,UAAU,EAAgB,cAAc,EAAiB,MAAM,aAAa,CAAC;AAC3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AA4BlF,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,MAAM,UAAU,EAC1B,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6G5C"}

package/dist/hono/routes/approvals.js

@@ -0,0 +1,101 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { DenialReason, ApprovalStatus, ApprovalError } from "@dexto/core";
+const ApprovalBodySchema = z.object({
+  status: z.enum([ApprovalStatus.APPROVED, ApprovalStatus.DENIED]).describe("The user decision"),
+  formData: z.record(z.unknown()).optional().describe("Optional form data provided by the user (for elicitation)"),
+  rememberChoice: z.boolean().optional().describe("Whether to remember this choice for future requests")
+}).describe("Request body for submitting an approval decision");
+const ApprovalResponseSchema = z.object({
+  ok: z.boolean().describe("Whether the approval was successfully processed"),
+  approvalId: z.string().describe("The ID of the processed approval"),
+  status: z.enum([ApprovalStatus.APPROVED, ApprovalStatus.DENIED]).describe("The final status")
+}).describe("Response after processing approval");
+function createApprovalsRouter(getAgent, approvalCoordinator) {
+  const app = new OpenAPIHono();
+  const submitApprovalRoute = createRoute({
+    method: "post",
+    path: "/approvals/{approvalId}",
+    summary: "Submit Approval Decision",
+    description: "Submit a user decision for a pending approval request",
+    tags: ["approvals"],
+    request: {
+      params: z.object({
+        approvalId: z.string().describe("The ID of the approval request")
+      }),
+      body: {
+        content: { "application/json": { schema: ApprovalBodySchema } }
+      },
+      headers: z.object({
+        "Idempotency-Key": z.string().optional().describe("Optional key to ensure idempotent processing")
+      })
+    },
+    responses: {
+      200: {
+        description: "Approval processed successfully",
+        content: {
+          "application/json": {
+            schema: ApprovalResponseSchema
+          }
+        }
+      },
+      404: {
+        description: "Approval request not found or expired"
+      },
+      400: {
+        description: "Validation error"
+      },
+      503: {
+        description: "Approval coordinator unavailable (server not initialized for approvals)"
+      }
+    }
+  });
+  return app.openapi(submitApprovalRoute, async (ctx) => {
+    const agent = getAgent();
+    const { approvalId } = ctx.req.valid("param");
+    const { status, formData, rememberChoice } = ctx.req.valid("json");
+    agent.logger.info(`Received approval decision for ${approvalId}: ${status}`);
+    if (!approvalCoordinator) {
+      agent.logger.error("ApprovalCoordinator not available");
+      return ctx.json({ ok: false, approvalId, status }, 503);
+    }
+    const pendingApprovals = agent.services.approvalManager.getPendingApprovals();
+    if (!pendingApprovals.includes(approvalId)) {
+      throw ApprovalError.notFound(approvalId);
+    }
+    try {
+      const data = {};
+      if (status === ApprovalStatus.APPROVED) {
+        if (formData !== void 0) {
+          data.formData = formData;
+        }
+        if (rememberChoice !== void 0) {
+          data.rememberChoice = rememberChoice;
+        }
+      }
+      const sessionId = approvalCoordinator.getSessionId(approvalId);
+      const responsePayload = {
+        approvalId,
+        status,
+        sessionId,
+        // Attach sessionId for SSE routing to correct client streams
+        ...status === ApprovalStatus.DENIED ? {
+          reason: DenialReason.USER_DENIED,
+          message: "User denied the request via API"
+        } : {},
+        ...Object.keys(data).length > 0 ? { data } : {}
+      };
+      approvalCoordinator.emitResponse(responsePayload);
+      return ctx.json({
+        ok: true,
+        approvalId,
+        status
+      });
+    } catch (error) {
+      agent.logger.error("Error processing approval", { approvalId, error });
+      return ctx.json({ ok: false, approvalId, status }, 500);
+    }
+  });
+}
+export {
+  createApprovalsRouter
+};

package/dist/hono/routes/greeting.cjs

@@ -0,0 +1,60 @@
+"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 greeting_exports = {};
+__export(greeting_exports, {
+  createGreetingRouter: () => createGreetingRouter
+});
+module.exports = __toCommonJS(greeting_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+const querySchema = import_zod_openapi.z.object({
+  sessionId: import_zod_openapi.z.string().optional().describe("Session identifier to retrieve session-specific greeting")
+}).describe("Query parameters for greeting endpoint");
+function createGreetingRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const greetingRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/greeting",
+    summary: "Get Greeting Message",
+    description: "Retrieves the greeting message from the agent configuration",
+    tags: ["config"],
+    request: { query: querySchema.pick({ sessionId: true }) },
+    responses: {
+      200: {
+        description: "Greeting",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              greeting: import_zod_openapi.z.string().optional().describe("Greeting message from agent configuration")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(greetingRoute, (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.valid("query");
+    const cfg = agent.getEffectiveConfig(sessionId);
+    return ctx.json({ greeting: cfg.greeting });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGreetingRouter
+});

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

@@ -0,0 +1,19 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+export declare function createGreetingRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+    "/greeting": {
+        $get: {
+            input: {
+                query: {
+                    sessionId?: string | undefined;
+                };
+            };
+            output: {
+                greeting?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=greeting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"greeting.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/greeting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAW9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;QAmC9D"}

package/dist/hono/routes/greeting.js

@@ -0,0 +1,36 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+const querySchema = z.object({
+  sessionId: z.string().optional().describe("Session identifier to retrieve session-specific greeting")
+}).describe("Query parameters for greeting endpoint");
+function createGreetingRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const greetingRoute = createRoute({
+    method: "get",
+    path: "/greeting",
+    summary: "Get Greeting Message",
+    description: "Retrieves the greeting message from the agent configuration",
+    tags: ["config"],
+    request: { query: querySchema.pick({ sessionId: true }) },
+    responses: {
+      200: {
+        description: "Greeting",
+        content: {
+          "application/json": {
+            schema: z.object({
+              greeting: z.string().optional().describe("Greeting message from agent configuration")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(greetingRoute, (ctx) => {
+    const agent = getAgent();
+    const { sessionId } = ctx.req.valid("query");
+    const cfg = agent.getEffectiveConfig(sessionId);
+    return ctx.json({ greeting: cfg.greeting });
+  });
+}
+export {
+  createGreetingRouter
+};

package/dist/hono/routes/health.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 health_exports = {};
+__export(health_exports, {
+  createHealthRouter: () => createHealthRouter
+});
+module.exports = __toCommonJS(health_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+function createHealthRouter(_getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const route = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/",
+    summary: "Health Check",
+    description: "Returns server health status",
+    tags: ["system"],
+    responses: {
+      200: {
+        description: "Server health",
+        content: { "text/plain": { schema: import_zod_openapi.z.string().openapi({ example: "OK" }) } }
+      }
+    }
+  });
+  return app.openapi(route, (c) => c.text("OK"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createHealthRouter
+});

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

@@ -0,0 +1,17 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+/**
+ * NOTE: If we introduce a transport-agnostic handler layer later, the logic in this module can move
+ * into that layer. For now we keep the implementation inline for simplicity.
+ */
+export declare function createHealthRouter(_getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+    "/": {
+        $get: {
+            input: {};
+            output: string;
+            outputFormat: "text";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=health.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/health.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,UAAU;;;;;;;;;QAiB7D"}

package/dist/hono/routes/health.js

@@ -0,0 +1,21 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+function createHealthRouter(_getAgent) {
+  const app = new OpenAPIHono();
+  const route = createRoute({
+    method: "get",
+    path: "/",
+    summary: "Health Check",
+    description: "Returns server health status",
+    tags: ["system"],
+    responses: {
+      200: {
+        description: "Server health",
+        content: { "text/plain": { schema: z.string().openapi({ example: "OK" }) } }
+      }
+    }
+  });
+  return app.openapi(route, (c) => c.text("OK"));
+}
+export {
+  createHealthRouter
+};