@adoptai/genui-components 0.1.57 → 0.1.58

package/dist/schemas/document-field-extraction.d.ts

@@ -0,0 +1,258 @@
+import { z } from "zod";
+export declare const documentFieldExtractionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"document-field-extraction">;
+    doc_type: z.ZodOptional<z.ZodString>;
+    file_name: z.ZodOptional<z.ZodString>;
+    payload_ref: z.ZodOptional<z.ZodString>;
+    store_id: z.ZodOptional<z.ZodString>;
+    doc_id: z.ZodOptional<z.ZodString>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        page: z.ZodNumber;
+        imageUrl: z.ZodOptional<z.ZodString>;
+        width_pt: z.ZodNumber;
+        height_pt: z.ZodNumber;
+    }, z.core.$strip>>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field_key: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodString;
+        page: z.ZodNumber;
+        bbox: z.ZodOptional<z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        confidence_tier: z.ZodOptional<z.ZodEnum<{
+            red: "red";
+            green: "green";
+            amber: "amber";
+        }>>;
+        badge: z.ZodOptional<z.ZodEnum<{
+            SC: "SC";
+            CN: "CN";
+            AB: "AB";
+            SW: "SW";
+        }>>;
+        state: z.ZodOptional<z.ZodEnum<{
+            ok: "ok";
+            corrected: "corrected";
+            missing: "missing";
+            warn: "warn";
+        }>>;
+        entity_type: z.ZodOptional<z.ZodString>;
+        is_primary: z.ZodOptional<z.ZodBoolean>;
+        previous_value: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        corrected_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    page_count: z.ZodOptional<z.ZodNumber>;
+    pages_processed: z.ZodOptional<z.ZodNumber>;
+    summary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        display_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        short_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        organization: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        domain_group: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tax_year: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        crumbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        stats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field_key: z.ZodString;
+            label: z.ZodString;
+            value: z.ZodString;
+            caption: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        facts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field_key: z.ZodString;
+            label: z.ZodString;
+            value: z.ZodString;
+            badge: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const documentFieldExtractionTool: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            type: {
+                type: string;
+                enum: string[];
+            };
+            doc_type: {
+                type: string;
+            };
+            file_name: {
+                type: string;
+                description: string;
+            };
+            payload_ref: {
+                type: string;
+                description: string;
+            };
+            store_id: {
+                type: string;
+                description: string;
+            };
+            doc_id: {
+                type: string;
+                description: string;
+            };
+            pages: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        page: {
+                            type: string;
+                            description: string;
+                        };
+                        imageUrl: {
+                            type: string;
+                        };
+                        width_pt: {
+                            type: string;
+                        };
+                        height_pt: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            fields: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        field_key: {
+                            type: string;
+                        };
+                        label: {
+                            type: string;
+                        };
+                        value: {
+                            type: string;
+                        };
+                        page: {
+                            type: string;
+                            description: string;
+                        };
+                        bbox: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                            description: string;
+                        };
+                        confidence: {
+                            type: string;
+                        };
+                        confidence_tier: {
+                            type: string;
+                            enum: string[];
+                        };
+                        badge: {
+                            type: string;
+                            enum: string[];
+                        };
+                        state: {
+                            type: string;
+                            enum: string[];
+                        };
+                        entity_type: {
+                            type: string;
+                        };
+                        is_primary: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            page_count: {
+                type: string;
+            };
+            pages_processed: {
+                type: string;
+            };
+            summary: {
+                type: string;
+                description: string;
+                properties: {
+                    display_name: {
+                        type: string;
+                    };
+                    short_name: {
+                        type: string;
+                    };
+                    organization: {
+                        type: string;
+                    };
+                    domain: {
+                        type: string;
+                    };
+                    domain_group: {
+                        type: string;
+                    };
+                    tax_year: {
+                        type: string;
+                    };
+                    crumbs: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    tags: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    stats: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                field_key: {
+                                    type: string;
+                                };
+                                label: {
+                                    type: string;
+                                };
+                                value: {
+                                    type: string;
+                                };
+                                caption: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                        };
+                    };
+                    facts: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                field_key: {
+                                    type: string;
+                                };
+                                label: {
+                                    type: string;
+                                };
+                                value: {
+                                    type: string;
+                                };
+                                badge: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                        };
+                    };
+                };
+            };
+        };
+        required: string[];
+    };
+};
+//# sourceMappingURL=document-field-extraction.d.ts.map

package/dist/schemas/document-field-extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-field-extraction.d.ts","sourceRoot":"","sources":["../../src/schemas/document-field-extraction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgExB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBxC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6GvC,CAAC"}

package/dist/schemas/index.cjs

@@ -3455,6 +3455,183 @@ var workflowStepperTool = {
     required: ["type", "title", "steps"]
   }
 };
+var bbox = zod.z.tuple([zod.z.number(), zod.z.number(), zod.z.number(), zod.z.number()]);
+var fieldSchema = zod.z.object({
+  field_key: zod.z.string(),
+  label: zod.z.string(),
+  value: zod.z.string(),
+  page: zod.z.number(),
+  // 0-indexed, matches PageDimension.page
+  bbox: bbox.nullable().optional(),
+  confidence: zod.z.number().optional(),
+  confidence_tier: zod.z.enum(["green", "amber", "red"]).optional(),
+  badge: zod.z.enum(["SC", "CN", "AB", "SW"]).optional(),
+  state: zod.z.enum(["ok", "corrected", "missing", "warn"]).optional(),
+  entity_type: zod.z.string().optional(),
+  is_primary: zod.z.boolean().optional(),
+  // Set after a human correction (extractor output, or an optimistic in-card
+  // edit) so the editable field card can show old → new and who changed it.
+  previous_value: zod.z.string().nullable().optional(),
+  corrected_by: zod.z.string().nullable().optional()
+});
+var pageSchema = zod.z.object({
+  page: zod.z.number(),
+  // 0-indexed
+  imageUrl: zod.z.string().optional(),
+  // host-resolved from the durable image_ref
+  width_pt: zod.z.number(),
+  height_pt: zod.z.number()
+});
+var summaryStatSchema = zod.z.object({
+  field_key: zod.z.string(),
+  label: zod.z.string(),
+  value: zod.z.string(),
+  caption: zod.z.string().nullable().optional()
+});
+var summaryFactSchema = zod.z.object({
+  field_key: zod.z.string(),
+  label: zod.z.string(),
+  value: zod.z.string(),
+  badge: zod.z.string().nullable().optional()
+});
+var summarySchema = zod.z.object({
+  display_name: zod.z.string().nullable().optional(),
+  short_name: zod.z.string().nullable().optional(),
+  organization: zod.z.string().nullable().optional(),
+  domain: zod.z.string().nullable().optional(),
+  domain_group: zod.z.string().nullable().optional(),
+  tax_year: zod.z.union([zod.z.string(), zod.z.number()]).nullable().optional(),
+  crumbs: zod.z.array(zod.z.string()).optional(),
+  tags: zod.z.array(zod.z.string()).optional(),
+  stats: zod.z.array(summaryStatSchema).optional(),
+  facts: zod.z.array(summaryFactSchema).optional()
+});
+var documentFieldExtractionSchema = zod.z.object({
+  type: zod.z.literal("document-field-extraction"),
+  doc_type: zod.z.string().optional(),
+  // Original uploaded filename (e.g. "2024_gl.pdf"); preferred over doc_type for
+  // the card title since doc_type is often the "generic_fallback" schema name.
+  file_name: zod.z.string().optional(),
+  // Server-side token; resolved by the host into pages/fields before render.
+  payload_ref: zod.z.string().optional(),
+  // Present for persisted workstream docs; absent for pre-existing cards.
+  store_id: zod.z.string().optional(),
+  doc_id: zod.z.string().optional(),
+  pages: zod.z.array(pageSchema).max(100).optional(),
+  fields: zod.z.array(fieldSchema).max(1e3).optional(),
+  // Page-count metadata for the Details tab ("N of M pages extracted").
+  page_count: zod.z.number().optional(),
+  pages_processed: zod.z.number().optional(),
+  // Deterministic document summary for the Details tab.
+  summary: summarySchema.nullable().optional()
+});
+var documentFieldExtractionTool = {
+  name: "render_document_field_extraction",
+  description: "Render extracted document fields as an interactive overlay on the page image(s) \u2014 colored bounding boxes per field plus a synced field-card list. Use after the extract_document tool returns; pass the returned payload_ref (the host expands it). For invoices, statements, tax forms, receipts, KYC/loan docs, POs where the user wants to SEE where each value sits on the page.",
+  input_schema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: ["document-field-extraction"] },
+      doc_type: { type: "string" },
+      file_name: {
+        type: "string",
+        description: "Original uploaded filename; shown as the card title."
+      },
+      payload_ref: {
+        type: "string",
+        description: "Durable store key returned by extract_document; the GenUI host expands it into pages/fields at render time. Pass this verbatim \u2014 do NOT hand-build pages/fields."
+      },
+      store_id: {
+        type: "string",
+        description: "Docstore store id; present for persisted workstream docs. The host uses this to open the editable viewer."
+      },
+      doc_id: {
+        type: "string",
+        description: "Docstore document id; present for persisted workstream docs. Required for the editable viewer."
+      },
+      pages: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            page: { type: "number", description: "0-indexed page number" },
+            imageUrl: { type: "string" },
+            width_pt: { type: "number" },
+            height_pt: { type: "number" }
+          },
+          required: ["page", "width_pt", "height_pt"]
+        }
+      },
+      fields: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            field_key: { type: "string" },
+            label: { type: "string" },
+            value: { type: "string" },
+            page: { type: "number", description: "0-indexed page number" },
+            bbox: {
+              type: "array",
+              items: { type: "number" },
+              description: "[x0,y0,x1,y1] PDF points, origin bottom-left; null if unlocated"
+            },
+            confidence: { type: "number" },
+            confidence_tier: { type: "string", enum: ["green", "amber", "red"] },
+            badge: { type: "string", enum: ["SC", "CN", "AB", "SW"] },
+            state: { type: "string", enum: ["ok", "corrected", "missing", "warn"] },
+            entity_type: { type: "string" },
+            is_primary: { type: "boolean" }
+          },
+          required: ["field_key", "label", "value", "page"]
+        }
+      },
+      page_count: { type: "number" },
+      pages_processed: { type: "number" },
+      summary: {
+        type: "object",
+        description: "Deterministic document summary for the Details tab (display_name, organization, domain, stats, facts, tags). Produced by the extractor \u2014 pass through verbatim.",
+        properties: {
+          display_name: { type: "string" },
+          short_name: { type: "string" },
+          organization: { type: "string" },
+          domain: { type: "string" },
+          domain_group: { type: "string" },
+          tax_year: { type: "string" },
+          crumbs: { type: "array", items: { type: "string" } },
+          tags: { type: "array", items: { type: "string" } },
+          stats: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                field_key: { type: "string" },
+                label: { type: "string" },
+                value: { type: "string" },
+                caption: { type: "string" }
+              },
+              required: ["field_key", "label", "value"]
+            }
+          },
+          facts: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                field_key: { type: "string" },
+                label: { type: "string" },
+                value: { type: "string" },
+                badge: { type: "string" }
+              },
+              required: ["field_key", "label", "value"]
+            }
+          }
+        }
+      }
+    },
+    required: ["type"]
+  }
+};
 var decisionCardSchema = zod.z.object({
   type: zod.z.literal("decision-card"),
   id: zod.z.string().optional(),
@@ -3677,6 +3854,7 @@ var schemaRegistry = {
   "integrations-list": { schema: integrationsListSchema, tool: integrationsListTool },
   "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 }
 };