@dexto/core 1.1.9 → 1.1.11

package/dist/approval/schemas.cjs

@@ -0,0 +1,168 @@
+"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 schemas_exports = {};
+__export(schemas_exports, {
+  ApprovalRequestDetailsSchema: () => ApprovalRequestDetailsSchema,
+  ApprovalRequestSchema: () => ApprovalRequestSchema,
+  ApprovalResponseSchema: () => ApprovalResponseSchema,
+  ApprovalStatusSchema: () => ApprovalStatusSchema,
+  ApprovalTypeSchema: () => ApprovalTypeSchema,
+  BaseApprovalRequestSchema: () => BaseApprovalRequestSchema,
+  BaseApprovalResponseSchema: () => BaseApprovalResponseSchema,
+  CustomApprovalMetadataSchema: () => CustomApprovalMetadataSchema,
+  CustomApprovalRequestSchema: () => CustomApprovalRequestSchema,
+  CustomApprovalResponseDataSchema: () => CustomApprovalResponseDataSchema,
+  CustomApprovalResponseSchema: () => CustomApprovalResponseSchema,
+  ElicitationMetadataSchema: () => ElicitationMetadataSchema,
+  ElicitationRequestSchema: () => ElicitationRequestSchema,
+  ElicitationResponseDataSchema: () => ElicitationResponseDataSchema,
+  ElicitationResponseSchema: () => ElicitationResponseSchema,
+  ToolConfirmationMetadataSchema: () => ToolConfirmationMetadataSchema,
+  ToolConfirmationRequestSchema: () => ToolConfirmationRequestSchema,
+  ToolConfirmationResponseDataSchema: () => ToolConfirmationResponseDataSchema,
+  ToolConfirmationResponseSchema: () => ToolConfirmationResponseSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var import_types = require("./types.js");
+const ApprovalTypeSchema = import_zod.z.nativeEnum(import_types.ApprovalType);
+const ApprovalStatusSchema = import_zod.z.nativeEnum(import_types.ApprovalStatus);
+const ToolConfirmationMetadataSchema = import_zod.z.object({
+  toolName: import_zod.z.string().describe("Name of the tool to confirm"),
+  args: import_zod.z.record(import_zod.z.unknown()).describe("Arguments for the tool"),
+  description: import_zod.z.string().optional().describe("Description of the tool")
+}).strict().describe("Tool confirmation metadata");
+const ElicitationMetadataSchema = import_zod.z.object({
+  schema: import_zod.z.record(import_zod.z.unknown()).describe("JSON Schema for the form"),
+  prompt: import_zod.z.string().describe("Prompt to show the user"),
+  serverName: import_zod.z.string().describe("MCP server requesting input"),
+  context: import_zod.z.record(import_zod.z.unknown()).optional().describe("Additional context")
+}).strict().describe("Elicitation metadata");
+const CustomApprovalMetadataSchema = import_zod.z.record(import_zod.z.unknown()).describe("Custom metadata");
+const BaseApprovalRequestSchema = import_zod.z.object({
+  approvalId: import_zod.z.string().uuid().describe("Unique approval identifier"),
+  type: ApprovalTypeSchema.describe("Type of approval"),
+  sessionId: import_zod.z.string().optional().describe("Session identifier"),
+  timeout: import_zod.z.number().int().positive().describe("Timeout in milliseconds"),
+  timestamp: import_zod.z.date().describe("When the request was created")
+}).describe("Base approval request");
+const ToolConfirmationRequestSchema = BaseApprovalRequestSchema.extend({
+  type: import_zod.z.literal(import_types.ApprovalType.TOOL_CONFIRMATION),
+  metadata: ToolConfirmationMetadataSchema
+}).strict();
+const ElicitationRequestSchema = BaseApprovalRequestSchema.extend({
+  type: import_zod.z.literal(import_types.ApprovalType.ELICITATION),
+  metadata: ElicitationMetadataSchema
+}).strict();
+const CustomApprovalRequestSchema = BaseApprovalRequestSchema.extend({
+  type: import_zod.z.literal(import_types.ApprovalType.CUSTOM),
+  metadata: CustomApprovalMetadataSchema
+}).strict();
+const ApprovalRequestSchema = import_zod.z.discriminatedUnion("type", [
+  ToolConfirmationRequestSchema,
+  ElicitationRequestSchema,
+  CustomApprovalRequestSchema
+]);
+const ToolConfirmationResponseDataSchema = import_zod.z.object({
+  rememberChoice: import_zod.z.boolean().optional().describe("Remember this choice")
+}).strict().describe("Tool confirmation response data");
+const ElicitationResponseDataSchema = import_zod.z.object({
+  formData: import_zod.z.record(import_zod.z.unknown()).describe("Form data matching schema")
+}).strict().describe("Elicitation response data");
+const CustomApprovalResponseDataSchema = import_zod.z.record(import_zod.z.unknown()).describe("Custom response data");
+const BaseApprovalResponseSchema = import_zod.z.object({
+  approvalId: import_zod.z.string().uuid().describe("Must match request approvalId"),
+  status: ApprovalStatusSchema.describe("Approval status"),
+  sessionId: import_zod.z.string().optional().describe("Session identifier")
+}).describe("Base approval response");
+const ToolConfirmationResponseSchema = BaseApprovalResponseSchema.extend({
+  data: ToolConfirmationResponseDataSchema.optional()
+}).strict();
+const ElicitationResponseSchema = BaseApprovalResponseSchema.extend({
+  data: ElicitationResponseDataSchema.optional()
+}).strict();
+const CustomApprovalResponseSchema = BaseApprovalResponseSchema.extend({
+  data: CustomApprovalResponseDataSchema.optional()
+}).strict();
+const ApprovalResponseSchema = import_zod.z.union([
+  ToolConfirmationResponseSchema,
+  ElicitationResponseSchema,
+  CustomApprovalResponseSchema
+]);
+const ApprovalRequestDetailsSchema = import_zod.z.object({
+  type: ApprovalTypeSchema,
+  sessionId: import_zod.z.string().optional(),
+  timeout: import_zod.z.number().int().positive(),
+  metadata: import_zod.z.union([
+    ToolConfirmationMetadataSchema,
+    ElicitationMetadataSchema,
+    CustomApprovalMetadataSchema
+  ])
+}).superRefine((data, ctx) => {
+  if (data.type === import_types.ApprovalType.TOOL_CONFIRMATION) {
+    const result = ToolConfirmationMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Metadata must match ToolConfirmationMetadataSchema for TOOL_CONFIRMATION type",
+        path: ["metadata"]
+      });
+    }
+  } else if (data.type === import_types.ApprovalType.ELICITATION) {
+    const result = ElicitationMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Metadata must match ElicitationMetadataSchema for ELICITATION type",
+        path: ["metadata"]
+      });
+    }
+  } else if (data.type === import_types.ApprovalType.CUSTOM) {
+    const result = CustomApprovalMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Metadata must match CustomApprovalMetadataSchema for CUSTOM type",
+        path: ["metadata"]
+      });
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApprovalRequestDetailsSchema,
+  ApprovalRequestSchema,
+  ApprovalResponseSchema,
+  ApprovalStatusSchema,
+  ApprovalTypeSchema,
+  BaseApprovalRequestSchema,
+  BaseApprovalResponseSchema,
+  CustomApprovalMetadataSchema,
+  CustomApprovalRequestSchema,
+  CustomApprovalResponseDataSchema,
+  CustomApprovalResponseSchema,
+  ElicitationMetadataSchema,
+  ElicitationRequestSchema,
+  ElicitationResponseDataSchema,
+  ElicitationResponseSchema,
+  ToolConfirmationMetadataSchema,
+  ToolConfirmationRequestSchema,
+  ToolConfirmationResponseDataSchema,
+  ToolConfirmationResponseSchema
+});