@dexto/server 1.6.19 → 1.6.21

package/dist/hono/routes/approvals.cjs

@@ -23,9 +23,12 @@ __export(approvals_exports, {
 module.exports = __toCommonJS(approvals_exports);
 var import_zod_openapi = require("@hono/zod-openapi");
 var import_core = require("@dexto/core");
+var import_responses = require("../schemas/responses.js");
 const ApprovalBodySchema = import_zod_openapi.z.object({
   status: import_zod_openapi.z.enum([import_core.ApprovalStatus.APPROVED, import_core.ApprovalStatus.DENIED, import_core.ApprovalStatus.CANCELLED]).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)"),
+  formData: import_responses.JsonObjectSchema.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"),
   rememberPattern: import_zod_openapi.z.string().optional().describe("Optional approval pattern to remember for future requests"),
   rememberDirectory: import_zod_openapi.z.boolean().optional().describe("Whether to remember the approved directory for future requests"),
@@ -110,91 +113,111 @@ const PendingApprovalSchema = import_zod_openapi.z.object({
   sessionId: import_zod_openapi.z.string().optional().describe("The session ID if applicable"),
   timeout: import_zod_openapi.z.number().optional().describe("Timeout in milliseconds"),
   timestamp: import_zod_openapi.z.string().describe("ISO timestamp when the request was created"),
-  metadata: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).describe("Type-specific metadata")
+  metadata: import_responses.JsonObjectSchema.describe("Type-specific metadata for the pending approval")
 }).describe("A pending approval request");
 const PendingApprovalsResponseSchema = import_zod_openapi.z.object({
   ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
   approvals: import_zod_openapi.z.array(PendingApprovalSchema).describe("List of pending approval requests")
 }).describe("Response containing pending approval requests");
-function createApprovalsRouter(getAgent, approvalCoordinator) {
-  const app = new import_zod_openapi.OpenAPIHono();
-  const getPendingApprovalsRoute = (0, import_zod_openapi.createRoute)({
-    method: "get",
-    path: "/approvals",
-    summary: "Get Pending Approvals",
-    description: "Fetch all pending approval requests for a session. Use this to restore UI state after page refresh.",
-    tags: ["approvals"],
-    request: {
-      query: import_zod_openapi.z.object({
-        sessionId: import_zod_openapi.z.string().describe("The session ID to fetch pending approvals for")
-      })
-    },
-    responses: {
-      200: {
-        description: "List of pending approval requests",
-        content: {
-          "application/json": {
-            schema: PendingApprovalsResponseSchema
-          }
+const GetPendingApprovalsQuerySchema = import_zod_openapi.z.object({
+  sessionId: import_zod_openapi.z.string().describe("The session ID to fetch pending approvals for")
+}).describe("Query parameters for fetching pending approvals");
+const ApprovalIdParamSchema = import_zod_openapi.z.object({
+  approvalId: import_zod_openapi.z.string().describe("The ID of the approval request")
+}).describe("Approval identifier params");
+const ApprovalHeadersSchema = import_zod_openapi.z.object({
+  "Idempotency-Key": import_zod_openapi.z.string().optional().describe("Optional key to ensure idempotent processing")
+}).describe("Approval request headers");
+const getPendingApprovalsRoute = (0, import_zod_openapi.createRoute)({
+  method: "get",
+  path: "/approvals",
+  summary: "Get Pending Approvals",
+  description: "Fetch all pending approval requests for a session. Use this to restore UI state after page refresh.",
+  tags: ["approvals"],
+  request: {
+    query: GetPendingApprovalsQuerySchema
+  },
+  responses: {
+    200: {
+      description: "List of pending approval requests",
+      content: {
+        "application/json": {
+          schema: PendingApprovalsResponseSchema
         }
       }
-    }
-  });
-  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
-          }
+    400: import_responses.BadRequestErrorResponse,
+    500: import_responses.InternalErrorResponse
+  }
+});
+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: ApprovalIdParamSchema,
+    body: {
+      content: { "application/json": { schema: ApprovalBodySchema } }
+    },
+    headers: ApprovalHeadersSchema
+  },
+  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)"
       }
+    },
+    404: {
+      description: "Approval request not found or expired",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: import_responses.ApiErrorResponseSchema } }
+    },
+    503: {
+      description: "Approval coordinator unavailable (server not initialized for approvals)",
+      content: { "application/json": { schema: ApprovalResponseSchema } }
+    },
+    500: {
+      description: "Approval processing failed",
+      content: { "application/json": { schema: ApprovalResponseSchema } }
     }
-  });
-  return app.openapi(getPendingApprovalsRoute, async (ctx) => {
+  }
+});
+function mountApprovalsSubrouter(app, router) {
+  app.route("/", router);
+}
+function createApprovalsRouter(getAgent, approvalCoordinator) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const getPendingApprovalsRouter = new import_zod_openapi.OpenAPIHono();
+  getPendingApprovalsRouter.openapi(getPendingApprovalsRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
     agent.logger.debug(`Fetching pending approvals for session ${sessionId}`);
-    const pendingIds = agent.services.approvalManager.getPendingApprovals();
-    const approvals = pendingIds.map((approvalId) => ({
-      approvalId,
-      type: "tool_confirmation",
-      // Default type
-      sessionId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      metadata: {}
+    const approvals = agent.services.approvalManager.getPendingApprovalRequests().filter((approvalRequest) => approvalRequest.sessionId === sessionId).map((approvalRequest) => ({
+      approvalId: approvalRequest.approvalId,
+      type: approvalRequest.type,
+      sessionId: approvalRequest.sessionId,
+      timeout: approvalRequest.timeout,
+      timestamp: approvalRequest.timestamp.toISOString(),
+      metadata: import_responses.JsonObjectSchema.parse(approvalRequest.metadata)
     }));
-    return ctx.json({
-      ok: true,
-      approvals
-    });
-  }).openapi(submitApprovalRoute, async (ctx) => {
+    return ctx.json(
+      {
+        ok: true,
+        approvals
+      },
+      200
+    );
+  });
+  const submitApprovalRouter = new import_zod_openapi.OpenAPIHono();
+  submitApprovalRouter.openapi(submitApprovalRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { approvalId } = ctx.req.valid("param");
     const {
@@ -209,7 +232,8 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
     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 response = { ok: false, approvalId, status };
+      return ctx.json(response, 503);
     }
     const pendingApprovals = agent.services.approvalManager.getPendingApprovals();
     if (!pendingApprovals.includes(approvalId)) {
@@ -247,16 +271,17 @@ function createApprovalsRouter(getAgent, approvalCoordinator) {
         ...Object.keys(data).length > 0 ? { data } : {}
       };
       approvalCoordinator.emitResponse(responsePayload);
-      return ctx.json({
-        ok: true,
-        approvalId,
-        status
-      });
+      const response = { ok: true, approvalId, status };
+      return ctx.json(response, 200);
     } catch (error) {
       agent.logger.error("Error processing approval", { approvalId, error });
-      return ctx.json({ ok: false, approvalId, status }, 500);
+      const response = { ok: false, approvalId, status };
+      return ctx.json(response, 500);
     }
   });
+  mountApprovalsSubrouter(app, getPendingApprovalsRouter);
+  mountApprovalsSubrouter(app, submitApprovalRouter);
+  return app;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {