@adoptai/genui-components 0.1.56 → 0.1.57

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

@@ -0,0 +1,149 @@
+import { z } from "zod";
+export declare const decisionCardSchema: z.ZodObject<{
+    type: z.ZodLiteral<"decision-card">;
+    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>;
+    }, z.core.$strip>>;
+    source: z.ZodOptional<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    resolved: z.ZodOptional<z.ZodObject<{
+        option: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const decisionCardTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            id: {
+                type: string;
+                description: string;
+            };
+            decision_type: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            question: {
+                type: string;
+                description: string;
+            };
+            amount: {
+                type: string;
+                description: string;
+            };
+            currency: {
+                type: string;
+                description: string;
+            };
+            amount_label: {
+                type: string;
+                description: string;
+            };
+            severity: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            flags: {
+                type: string;
+                maxItems: number;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        field: {
+                            type: string;
+                        };
+                        issue: {
+                            type: string;
+                        };
+                        severity: {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            options: {
+                type: string;
+                minItems: number;
+                maxItems: number;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        id: {
+                            type: string;
+                        };
+                        label: {
+                            type: string;
+                        };
+                        recommended: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            source: {
+                type: string;
+                description: string;
+                properties: {
+                    label: {
+                        type: string;
+                    };
+                    url: {
+                        type: string;
+                    };
+                };
+            };
+            resolved: {
+                type: string;
+                description: string;
+                properties: {
+                    option: {
+                        type: string;
+                    };
+                };
+                required: string[];
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=decision-card.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decision-card.d.ts","sourceRoot":"","sources":["../../src/schemas/decision-card.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuE5B,CAAC"}

package/dist/schemas/index.cjs

@@ -3455,6 +3455,109 @@ var workflowStepperTool = {
     required: ["type", "title", "steps"]
   }
 };
+var decisionCardSchema = zod.z.object({
+  type: zod.z.literal("decision-card"),
+  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()
+    })
+  ).min(1).max(5),
+  source: zod.z.object({
+    label: zod.z.string().optional(),
+    url: zod.z.string().optional()
+  }).optional(),
+  resolved: zod.z.object({
+    option: zod.z.string()
+  }).optional()
+});
+var decisionCardTool = {
+  name: "render_decision_card",
+  description: "Render an inline human-in-the-loop (HITL) decision card \u2014 a single judgment the agent needs from the user, resolved in-thread. Shows a titled question with an optional dollar amount at stake, optional data-quality flags, and 2-5 mutually-exclusive resolution options (the first or `recommended` one renders as the primary action), plus an optional 'view source' link. Use for inline approve/choose decisions the user resolves directly in the conversation. NOT for handing off to an external review portal (use escalation-card) and NOT for collecting multiple typed fields (use render_builder).",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["decision-card"] },
+      id: { type: "string", description: "Stable id for update-in-place rendering" },
+      decision_type: {
+        type: "string",
+        description: "Short category shown in the eyebrow, e.g. 'Cross-check', 'Allocation', 'Reserve'"
+      },
+      title: { type: "string", description: "The decision headline, e.g. 'AR reserve adequacy'" },
+      question: { type: "string", description: "The full question / context the user must judge" },
+      amount: { type: "number", description: "Dollar value at stake, e.g. 27100" },
+      currency: { type: "string", description: "ISO currency code; defaults to USD" },
+      amount_label: { type: "string", description: "Caption above the amount, e.g. 'At stake'" },
+      severity: {
+        type: "string",
+        enum: ["low", "medium", "high"],
+        description: "Severity of the decision; tints the accent rail"
+      },
+      flags: {
+        type: "array",
+        maxItems: 6,
+        description: "Optional data-quality flags surfaced on the card",
+        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,
+        description: "Mutually-exclusive resolution choices; mark one `recommended` to make it primary",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            label: { type: "string" },
+            recommended: { type: "boolean" }
+          },
+          required: ["label"]
+        }
+      },
+      source: {
+        type: "object",
+        description: "Optional provenance link for the figure",
+        properties: {
+          label: { type: "string" },
+          url: { type: "string" }
+        }
+      },
+      resolved: {
+        type: "object",
+        description: "Pre-resolved state for transcript replay",
+        properties: {
+          option: { type: "string" }
+        },
+        required: ["option"]
+      }
+    },
+    required: ["type", "title", "question", "options"]
+  }
+};
 
 // src/schemas/buildRenderUITool.ts
 function buildRenderUITool(selectedSchemas) {
@@ -3573,7 +3676,8 @@ var schemaRegistry = {
   "connect-integration": { schema: connectIntegrationSchema, tool: connectIntegrationTool },
   "integrations-list": { schema: integrationsListSchema, tool: integrationsListTool },
   "pipeline-preview": { schema: pipelinePreviewSchema, tool: pipelinePreviewTool },
-  "workflow-stepper": { schema: workflowStepperSchema, tool: workflowStepperTool }
+  "workflow-stepper": { schema: workflowStepperSchema, tool: workflowStepperTool },
+  "decision-card": { schema: decisionCardSchema, tool: decisionCardTool }
 };
 
 exports.buildRenderUITool = buildRenderUITool;