@adoptai/genui-components 0.1.58 → 0.1.60

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

@@ -26,6 +26,13 @@ export declare const decisionCardSchema: 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>;
@@ -33,6 +40,7 @@ export declare const decisionCardSchema: z.ZodObject<{
     }, z.core.$strip>>;
     resolved: z.ZodOptional<z.ZodObject<{
         option: z.ZodString;
+        value: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const decisionCardTool: {
@@ -116,6 +124,31 @@ export declare const decisionCardTool: {
                         recommended: {
                             type: string;
                         };
+                        value: {
+                            type: string;
+                            description: string;
+                        };
+                        adjust: {
+                            type: string;
+                            description: string;
+                            properties: {
+                                min: {
+                                    type: string;
+                                };
+                                max: {
+                                    type: string;
+                                };
+                                step: {
+                                    type: string;
+                                    description: string;
+                                };
+                                unit: {
+                                    type: string;
+                                    description: string;
+                                };
+                            };
+                            required: string[];
+                        };
                     };
                     required: string[];
                 };
@@ -139,6 +172,10 @@ export declare const decisionCardTool: {
                     option: {
                         type: string;
                     };
+                    value: {
+                        type: string;
+                        description: string;
+                    };
                 };
                 required: string[];
             };

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmD7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwF5B,CAAC"}

package/dist/schemas/index.cjs

@@ -3395,7 +3395,32 @@ var workflowStepperSchema = zod.z.object({
       n: zod.z.number().int().positive().optional(),
       title: zod.z.string(),
       sub: zod.z.string().optional(),
-      status: zod.z.enum(["done", "active", "review", "pending", "blocked", "failed"]),
+      status: zod.z.enum([
+        "done",
+        "active",
+        "running",
+        "review",
+        "pending",
+        "blocked",
+        "failed"
+      ]),
+      // Optional quality-gate verdict for a step run by an executor (e.g. a
+      // pipeline). Surfaces a subtle trust badge; flags hint at issues a human
+      // should review (the full list lives in the escalation dock).
+      eval: zod.z.object({
+        score: zod.z.number().min(0).max(1).nullable().optional(),
+        verdict: zod.z.enum(["good", "bad"]).optional(),
+        reasoning: zod.z.string().optional(),
+        judge_ok: zod.z.boolean().optional(),
+        data_quality_flags: zod.z.array(
+          zod.z.object({
+            field: zod.z.string().optional(),
+            issue: zod.z.string().optional(),
+            severity: zod.z.enum(["low", "medium", "high"]).optional(),
+            details: zod.z.string().optional()
+          })
+        ).optional()
+      }).optional(),
       assignees: zod.z.array(
         zod.z.object({
           name: zod.z.string(),
@@ -3431,7 +3456,32 @@ var workflowStepperTool = {
             n: { type: "number", description: "Step number; defaults to index + 1" },
             title: { type: "string" },
             sub: { type: "string", description: "Short status caption, e.g. '7 accounts \xB7 2 exceptions'" },
-            status: { type: "string", enum: ["done", "active", "review", "pending", "blocked", "failed"] },
+            status: {
+              type: "string",
+              enum: ["done", "active", "running", "review", "pending", "blocked", "failed"]
+            },
+            eval: {
+              type: "object",
+              description: "Optional quality-gate verdict for an executor-run step.",
+              properties: {
+                score: { type: "number" },
+                verdict: { type: "string", enum: ["good", "bad"] },
+                reasoning: { type: "string" },
+                judge_ok: { type: "boolean" },
+                data_quality_flags: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      field: { type: "string" },
+                      issue: { type: "string" },
+                      severity: { type: "string", enum: ["low", "medium", "high"] },
+                      details: { type: "string" }
+                    }
+                  }
+                }
+              }
+            },
             assignees: {
               type: "array",
               maxItems: 6,
@@ -3653,7 +3703,14 @@ var decisionCardSchema = zod.z.object({
     zod.z.object({
       id: zod.z.string().optional(),
       label: zod.z.string(),
-      recommended: zod.z.boolean().optional()
+      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({
@@ -3661,7 +3718,8 @@ var decisionCardSchema = zod.z.object({
     url: zod.z.string().optional()
   }).optional(),
   resolved: zod.z.object({
-    option: zod.z.string()
+    option: zod.z.string(),
+    value: zod.z.number().optional()
   }).optional()
 });
 var decisionCardTool = {
@@ -3704,13 +3762,28 @@ var decisionCardTool = {
         type: "array",
         minItems: 1,
         maxItems: 5,
-        description: "Mutually-exclusive resolution choices; mark one `recommended` to make it primary",
+        description: "Mutually-exclusive resolution choices; mark one `recommended` to make it primary. An option that carries a numeric figure the user may want to tune (e.g. 'Book reserve' at 50 units) should set `value` (your suggested figure) and `adjust` ({min,max[,step,unit]}) \u2014 the card then lets the user fine-tune the number within that range before confirming.",
         items: {
           type: "object",
           properties: {
             id: { type: "string" },
             label: { type: "string" },
-            recommended: { type: "boolean" }
+            recommended: { type: "boolean" },
+            value: {
+              type: "number",
+              description: "Suggested numeric figure for this option (the starting point of the adjuster)"
+            },
+            adjust: {
+              type: "object",
+              description: "Allow the user to tune `value` within this inclusive range before resolving",
+              properties: {
+                min: { type: "number" },
+                max: { type: "number" },
+                step: { type: "number", description: "Increment granularity; defaults to a sensible step for the range" },
+                unit: { type: "string", description: "Short unit suffix shown after the number, e.g. 'units', '%', 'hrs'" }
+              },
+              required: ["min", "max"]
+            }
           },
           required: ["label"]
         }
@@ -3727,7 +3800,8 @@ var decisionCardTool = {
         type: "object",
         description: "Pre-resolved state for transcript replay",
         properties: {
-          option: { type: "string" }
+          option: { type: "string" },
+          value: { type: "number", description: "Adjusted figure the user confirmed, when the option was adjustable" }
         },
         required: ["option"]
       }
@@ -3735,6 +3809,36 @@ var decisionCardTool = {
     required: ["type", "title", "question", "options"]
   }
 };
+var tabbyAuthSchema = zod.z.object({
+  type: zod.z.literal("tabby-auth"),
+  app: zod.z.string(),
+  url: zod.z.string(),
+  workspace: zod.z.string().optional(),
+  state: zod.z.enum(["pending", "connected"]).optional(),
+  ctaLabel: zod.z.string().optional(),
+  steps: zod.z.array(zod.z.string()).optional(),
+  description: zod.z.string().optional(),
+  iconUrl: zod.z.string().optional()
+});
+var tabbyAuthTool = {
+  name: "render_tabby_auth",
+  description: "Render a dedicated, trustworthy sign-in card when a harness skill needs the member to authenticate with a third-party app (e.g. Sage Intacct, Airbnb, an ERP) before a `call_web_api` request can proceed. Use this for the `login_required` path instead of a raw markdown link or a connect-integration card. `app` is the human display name (drives the title context, subtitle, and CTA). `url` is the login/short-link the prominent CTA opens in a new tab. `workspace` adds a subtitle suffix ('{app} \xB7 {workspace} workspace'). `state='pending'` (default) is the first-time connect; `state='connected'` is the verify/re-auth case (session already live) with a green badge and an Open deep-link. `steps` overrides the default numbered instructions; `description` is a one-line intro. The card title ('Authentication required') and the 'Credentials not stored by Adopt' trust footer are hardcoded brand constants \u2014 never supplied here.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["tabby-auth"] },
+      app: { type: "string" },
+      url: { type: "string" },
+      workspace: { type: "string" },
+      state: { type: "string", enum: ["pending", "connected"] },
+      ctaLabel: { type: "string" },
+      steps: { type: "array", items: { type: "string" } },
+      description: { type: "string" },
+      iconUrl: { type: "string" }
+    },
+    required: ["type", "app", "url"]
+  }
+};
 
 // src/schemas/buildRenderUITool.ts
 function buildRenderUITool(selectedSchemas) {
@@ -3855,7 +3959,8 @@ var schemaRegistry = {
   "pipeline-preview": { schema: pipelinePreviewSchema, tool: pipelinePreviewTool },
   "workflow-stepper": { schema: workflowStepperSchema, tool: workflowStepperTool },
   "document-field-extraction": { schema: documentFieldExtractionSchema, tool: documentFieldExtractionTool },
-  "decision-card": { schema: decisionCardSchema, tool: decisionCardTool }
+  "decision-card": { schema: decisionCardSchema, tool: decisionCardTool },
+  "tabby-auth": { schema: tabbyAuthSchema, tool: tabbyAuthTool }
 };
 
 exports.buildRenderUITool = buildRenderUITool;