@adoptai/genui-components 0.1.60 → 0.1.61

package/dist/schemas/decision-queue.d.ts

@@ -0,0 +1,227 @@
+import { z } from "zod";
+export declare const decisionQueueSchema: z.ZodObject<{
+    type: z.ZodLiteral<"decision-queue">;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    submit_label: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        decision_type: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        question: z.ZodString;
+        amount: z.ZodOptional<z.ZodNumber>;
+        currency: z.ZodOptional<z.ZodString>;
+        amount_label: z.ZodOptional<z.ZodString>;
+        severity: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+        flags: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodOptional<z.ZodString>;
+            issue: z.ZodString;
+            severity: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
+        }, z.core.$strip>>>;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            label: z.ZodString;
+            recommended: z.ZodOptional<z.ZodBoolean>;
+            value: z.ZodOptional<z.ZodNumber>;
+            adjust: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+                step: z.ZodOptional<z.ZodNumber>;
+                unit: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    resolved: z.ZodOptional<z.ZodObject<{
+        decisions: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            title: z.ZodString;
+            option: z.ZodString;
+            value: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const decisionQueueTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            id: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            submit_label: {
+                type: string;
+                description: string;
+            };
+            items: {
+                type: string;
+                minItems: number;
+                maxItems: number;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        id: {
+                            type: string;
+                        };
+                        decision_type: {
+                            type: string;
+                            description: string;
+                        };
+                        title: {
+                            type: string;
+                        };
+                        question: {
+                            type: string;
+                        };
+                        amount: {
+                            type: string;
+                        };
+                        currency: {
+                            type: string;
+                        };
+                        amount_label: {
+                            type: string;
+                        };
+                        severity: {
+                            type: string;
+                            enum: string[];
+                        };
+                        flags: {
+                            type: string;
+                            maxItems: number;
+                            items: {
+                                type: string;
+                                properties: {
+                                    field: {
+                                        type: string;
+                                    };
+                                    issue: {
+                                        type: string;
+                                    };
+                                    severity: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                        options: {
+                            type: string;
+                            minItems: number;
+                            maxItems: number;
+                            items: {
+                                type: string;
+                                properties: {
+                                    id: {
+                                        type: string;
+                                    };
+                                    label: {
+                                        type: string;
+                                    };
+                                    recommended: {
+                                        type: string;
+                                    };
+                                    value: {
+                                        type: string;
+                                        description: string;
+                                    };
+                                    adjust: {
+                                        type: string;
+                                        description: string;
+                                        properties: {
+                                            min: {
+                                                type: string;
+                                            };
+                                            max: {
+                                                type: string;
+                                            };
+                                            step: {
+                                                type: string;
+                                            };
+                                            unit: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                        };
+                                        required: string[];
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                        source: {
+                            type: string;
+                            properties: {
+                                label: {
+                                    type: string;
+                                };
+                                url: {
+                                    type: string;
+                                };
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            resolved: {
+                type: string;
+                description: string;
+                properties: {
+                    decisions: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                id: {
+                                    type: string;
+                                };
+                                title: {
+                                    type: string;
+                                };
+                                option: {
+                                    type: string;
+                                };
+                                value: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                        };
+                    };
+                };
+                required: string[];
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=decision-queue.d.ts.map

package/dist/schemas/decision-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-queue.d.ts","sourceRoot":"","sources":["../../src/schemas/decision-queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmDxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB9B,CAAC;AA2BH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqF7B,CAAC"}

package/dist/schemas/index.cjs

@@ -3809,6 +3809,167 @@ var decisionCardTool = {
     required: ["type", "title", "question", "options"]
   }
 };
+var decisionQueueItemSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  decision_type: zod.z.string().optional(),
+  title: zod.z.string(),
+  question: zod.z.string(),
+  amount: zod.z.number().optional(),
+  currency: zod.z.string().optional(),
+  amount_label: zod.z.string().optional(),
+  severity: zod.z.enum(["low", "medium", "high"]).optional(),
+  flags: zod.z.array(
+    zod.z.object({
+      field: zod.z.string().optional(),
+      issue: zod.z.string(),
+      severity: zod.z.enum(["low", "medium", "high"]).optional()
+    })
+  ).max(6).optional(),
+  options: zod.z.array(
+    zod.z.object({
+      id: zod.z.string().optional(),
+      label: zod.z.string(),
+      recommended: zod.z.boolean().optional(),
+      value: zod.z.number().optional(),
+      adjust: zod.z.object({
+        min: zod.z.number(),
+        max: zod.z.number(),
+        step: zod.z.number().optional(),
+        unit: zod.z.string().optional()
+      }).optional()
+    })
+  ).min(1).max(5),
+  source: zod.z.object({
+    label: zod.z.string().optional(),
+    url: zod.z.string().optional()
+  }).optional()
+});
+var decisionQueueSchema = zod.z.object({
+  type: zod.z.literal("decision-queue"),
+  id: zod.z.string().optional(),
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  submit_label: zod.z.string().optional(),
+  items: zod.z.array(decisionQueueItemSchema).min(2).max(12),
+  resolved: zod.z.object({
+    decisions: zod.z.array(
+      zod.z.object({
+        id: zod.z.string().optional(),
+        title: zod.z.string(),
+        option: zod.z.string(),
+        value: zod.z.number().optional()
+      })
+    )
+  }).optional()
+});
+var OPTION_ITEM_JSON = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    label: { type: "string" },
+    recommended: { type: "boolean" },
+    value: {
+      type: "number",
+      description: "Suggested numeric figure for this option (starting point of the adjuster)"
+    },
+    adjust: {
+      type: "object",
+      description: "Allow the user to tune `value` within this inclusive range before deciding",
+      properties: {
+        min: { type: "number" },
+        max: { type: "number" },
+        step: { type: "number" },
+        unit: { type: "string", description: "Short unit suffix, e.g. 'units', '%', 'hrs'" }
+      },
+      required: ["min", "max"]
+    }
+  },
+  required: ["label"]
+};
+var decisionQueueTool = {
+  name: "render_decision_queue",
+  description: "Render a SEQUENTIAL QUEUE of 2-12 related human-in-the-loop judgments, decided one at a time at full decision-card richness (amount at stake, data-quality flags, adjustable figures, source links) and submitted TOGETHER as one reply. Use whenever MORE THAN ONE decision is pending in the same turn \u2014 never emit multiple loose decision-cards. Give deferrable items an explicit 'leave open'-style option so the user can always complete the queue. For a single judgment use decision-card; for typed field input (names, dates, uploads) use render_builder.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["decision-queue"] },
+      id: { type: "string", description: "Stable id for update-in-place rendering" },
+      title: {
+        type: "string",
+        description: "Batch headline shown in the header, e.g. 'Reconciliation exceptions'"
+      },
+      description: { type: "string", description: "One-line context above the queue" },
+      submit_label: { type: "string", description: "CTA label; defaults to 'Submit N decisions'" },
+      items: {
+        type: "array",
+        minItems: 2,
+        maxItems: 12,
+        description: "The pending judgments, in the order the user should take them. Each is a full decision-card body (no `type`).",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            decision_type: {
+              type: "string",
+              description: "Short category eyebrow, e.g. 'Duplicate', 'Capitalization'"
+            },
+            title: { type: "string" },
+            question: { type: "string" },
+            amount: { type: "number" },
+            currency: { type: "string" },
+            amount_label: { type: "string" },
+            severity: { type: "string", enum: ["low", "medium", "high"] },
+            flags: {
+              type: "array",
+              maxItems: 6,
+              items: {
+                type: "object",
+                properties: {
+                  field: { type: "string" },
+                  issue: { type: "string" },
+                  severity: { type: "string", enum: ["low", "medium", "high"] }
+                },
+                required: ["issue"]
+              }
+            },
+            options: {
+              type: "array",
+              minItems: 1,
+              maxItems: 5,
+              items: OPTION_ITEM_JSON
+            },
+            source: {
+              type: "object",
+              properties: { label: { type: "string" }, url: { type: "string" } }
+            }
+          },
+          required: ["title", "question", "options"]
+        }
+      },
+      resolved: {
+        type: "object",
+        description: "Pre-resolved state for transcript replay",
+        properties: {
+          decisions: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                title: { type: "string" },
+                option: { type: "string" },
+                value: { type: "number" }
+              },
+              required: ["title", "option"]
+            }
+          }
+        },
+        required: ["decisions"]
+      }
+    },
+    required: ["type", "items"]
+  }
+};
 var tabbyAuthSchema = zod.z.object({
   type: zod.z.literal("tabby-auth"),
   app: zod.z.string(),
@@ -3960,6 +4121,7 @@ var schemaRegistry = {
   "workflow-stepper": { schema: workflowStepperSchema, tool: workflowStepperTool },
   "document-field-extraction": { schema: documentFieldExtractionSchema, tool: documentFieldExtractionTool },
   "decision-card": { schema: decisionCardSchema, tool: decisionCardTool },
+  "decision-queue": { schema: decisionQueueSchema, tool: decisionQueueTool },
   "tabby-auth": { schema: tabbyAuthSchema, tool: tabbyAuthTool }
 };