@vertesia/common 0.24.0-dev.202601221707

package/src/store/doc-analyzer.ts

@@ -0,0 +1,161 @@
+import { WorkflowExecutionPayload, WorkflowRunStatus } from "./workflow.js";
+
+export interface PdfToRichtextOptions {
+    features: string[];
+    debug?: boolean;
+    [key: string]: any;
+}
+
+export interface PdfToRichTextWorkflowPayload extends Omit<WorkflowExecutionPayload, "vars"> {
+    vars: PdfToRichtextOptions;
+}
+
+/**
+ * Represents a image in a document that has been analyzed
+ */
+export interface DocImage {
+    id?: string;
+    page_number?: number;
+    description?: string;
+    is_meaningful?: boolean;
+    width?: number;
+    height?: number;
+}
+
+/**
+ * The export type formats for tables.
+ */
+export type ExportTableFormats = 'json' | 'csv' | 'xml';
+
+/**
+ * Represents a table in a document that has been analyzed
+ */
+export interface DocTable {
+    page_number?: number;
+    table_number?: number;
+    title?: string;
+    format: "application/csv" | "application/json";
+}
+
+/**
+ * Represents a table in a document that has been analyzed in CSV format
+ */
+export interface DocTableCsv extends DocTable {
+    format: "application/csv";
+    title?: string;
+    data: string;
+}
+
+/**
+ * Represents a table in a document that has been analyzed in JSON format
+ */
+export interface DocTableJson extends DocTable {
+    format: "application/json";
+    title?: string;
+    data: Object[];
+}
+
+/**
+ * Output format for document processing workflows
+ */
+export type DocProcessorOutputFormat = "xml" | "markdown";
+
+/**
+ * Represents a document analysis run status
+ */
+export interface DocAnalyzeRunStatusResponse extends WorkflowRunStatus {
+    progress?: DocAnalyzerProgress;
+    /** The output format being used for processing (markdown or xml) */
+    output_format?: DocProcessorOutputFormat;
+}
+
+export interface DocAnalyzerResultResponse {
+    document?: string;
+    tables?: DocTableCsv[] | DocTableJson[];
+    images?: DocImage[];
+    annotated?: string | null;
+}
+
+export interface DocAnalyzerProgress {
+    pages: DocAnalyzerProgressStatus;
+    images: DocAnalyzerProgressStatus;
+    tables: DocAnalyzerProgressStatus;
+    visuals: DocAnalyzerProgressStatus;
+    started_at?: number;
+    percent: number;
+    /** The output format being used for processing (markdown or xml) */
+    output_format?: DocProcessorOutputFormat;
+}
+
+interface DocAnalyzerProgressStatus {
+    total: number;
+    processed: number;
+    success: number;
+    failed: number;
+}
+
+/**
+ * Adapt Tables Parameters, part of the request
+ */
+export interface AdaptTablesParams {
+    /**
+     * JSON Schema to to convert the table into
+     */
+    target_schema: string;
+
+    /**
+     * Natural language description of the type item the table are composed of
+     */
+    item_name: string;
+
+    /**
+     * Natural language description of the type of table or item to convert
+     */
+    instructions?: string;
+
+    /**
+     * Format to return the data in (csv, json)
+     */
+    format?: "csv" | "json";
+
+    /**
+     * Process the table as a whole or by page
+     */
+    process_as?: "page" | "table";
+
+    /**
+     * Process the table as a CSV file
+     */
+    process_as_csv?: boolean;
+}
+
+interface DocAnalyzerRequestBase {
+    synchronous?: boolean;
+
+    notify_endpoints?: string[];
+
+    /**
+     * What environment to use to run the request
+     * If none specified the project embedded environment will be used
+     */
+    environment?: string;
+}
+
+export interface AdaptTablesRequest extends DocAnalyzerRequestBase, AdaptTablesParams {}
+
+/**
+ * Get Adapted Tables Request
+ * @param raw If true, the raw data will be returned
+ * @param format The format to return the data in (csv, json)
+ */
+export interface GetAdaptedTablesRequestQuery {
+    raw?: boolean;
+    format: "csv" | "json";
+}
+/**
+ * The adapted table result format
+ */
+export interface AdaptedTable {
+    comment?: string;
+    data: Record<string, any>[];
+}

package/src/store/dsl-workflow.ts

@@ -0,0 +1,288 @@
+import { StringValue } from "ms";
+import { BaseObject } from "./common.js";
+import { WorkflowExecutionPayload } from "./index.js";
+import { ParentClosePolicyType } from "./temporalio.js";
+
+
+/**
+ * The payload sent when starting a workflow from the temporal client to the workflow instance.
+ */
+export interface DSLWorkflowExecutionPayload extends WorkflowExecutionPayload {
+    /**
+     * The workflow definition to be used by the DSL workflow.
+     * If a dsl workflow is executed and no definition is provided the workflow will fail.
+     */
+    workflow: DSLWorkflowSpec;
+}
+
+/**
+ * The payload for a DSL activity options.
+ *
+ * @see ActivityOptions in @temporalio/common
+ */
+export interface DSLActivityOptions {
+    startToCloseTimeout?: StringValue | number;
+    scheduleToStartTimeout?: StringValue | number;
+    scheduleToCloseTimeout?: StringValue | number;
+    retry?: DSLRetryPolicy;
+}
+
+/**
+ * The payload for a DSL retry policy.
+ *
+ * @see RetryPolicy in @temporalio/common
+ */
+export interface DSLRetryPolicy {
+    backoffCoefficient?: number;
+    initialInterval?: StringValue | number;
+    maximumAttempts?: number;
+    maximumInterval?: StringValue | number;
+    nonRetryableErrorTypes?: string[];
+}
+
+/**
+ * The payload for a DSL activity execution.
+ */
+export interface DSLActivityExecutionPayload<ParamsT extends Record<string, any>> extends WorkflowExecutionPayload {
+    activity: DSLActivitySpec;
+    params: ParamsT;
+    workflow_name: string;
+    debug_mode?: boolean;
+}
+
+
+export type ImportSpec = (string | Record<string, string>)[];
+export interface ActivityFetchSpec {
+    /**
+     * The data provider name
+     */
+    type: "document" | "document_type" | "interaction_run";
+    /**
+     * An optional URI to the data source.
+     */
+    source?: string;
+    /**
+     * The query to be executed by the data provider
+     */
+    query: Record<string, any>;
+    /**
+     * a string of space separated field names.
+     * Prefix a field name with "-" to exclude it from the result.
+     */
+    select?: string;
+
+    /**
+     * The number of results to return. If the result is limited to 1 the result will be a single object
+     */
+    limit?: number;
+
+    /**
+     * How to handle not found objects.
+     * 1. ignore - Ignore and return an empty array for multi objects query (or undefined for single object query) or empty array for multiple objects throw an error.
+     * 2. throw - Throw an error if the object or no objects are found.
+     */
+    on_not_found?: "ignore" | "throw";
+}
+
+export interface DSLWorkflowStepBase {
+    /**
+     * The type fo the step.
+     * If not set defaults to "activity"
+     */
+    type: "activity" | "workflow";
+}
+
+export interface DSLActivitySpec<PARAMS extends Record<string, any> = Record<string, any>> {
+    /**
+     * The name of the activity function
+     */
+    name: string;
+    /**
+     * Title of the activity to be displayed in the UI workflow builder
+     */
+    title?: string;
+    /**
+     * The description of the activity to e displayed in the UI workflow builder
+     */
+    description?: string;
+    /**
+     * Activities parameters. These parameters can be either literals
+     * (hardcoded strings, numbers, booleans, objects, arrays etc.), either
+     * references to the workflow variables.
+     * The workflow variables are built from the workflow params (e.g. the workflow configuration)
+     * and from the result of the previous activities.
+     */
+    params?: PARAMS;
+    /**
+     * The name of the workflow variable that will store the result of the activity
+     * If not specified the result will not be stored
+     * The parameters describe how the actual parameters will be obtained from the workflow execution vars.
+     * since it may contain references to workflow execution vars.
+     */
+    output?: string;
+
+    /**
+     * A JSON expression which evaluate to true or false similar to mongo matches.
+     * We support for now basic expression like: $true, $false, $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $regexp
+     * {$eq: {name: value}},
+     * Ex: {$eq: {wfVarName: value}}
+     */
+    condition?: Record<string, any>;
+
+    /**
+     * The import spec is used to import data from workflow variables.
+     * The import spec is a list of variable names to import from the workflow context.
+     * You can also use objects to rename the imported variables, or to reference an expression.
+     * Example:
+     * ["runId", {"typeId": "docType.id"}]
+     */
+    import?: ImportSpec;
+
+    /**
+     * The fetch phase is used to fetch data from external sources.
+     */
+    fetch?: Record<string, ActivityFetchSpec>;
+
+    /**
+     * Projection to apply to the result. Not all activities support this.
+     */
+    projection?: never | Record<string, any>;
+
+    // ---------- Optional features not implemented in a first step ------------
+    /**
+     * If true the activity will be executed in parallel with the other activities.
+     * (i.e. the workflow will not wait for the activity to finish before starting the next one)
+     */
+    parallel?: boolean;
+
+    /**
+     * Await for a parallel activity execution to return.
+     */
+    await?: string; //the activity name to await
+
+    /**
+     * Activity options for configuring the activity execution, which overrides the activity options
+     * defined at workflow level.
+     */
+    options?: DSLActivityOptions;
+}
+
+export interface DSLActivityStep<PARAMS extends Record<string, any> = Record<string, any>> extends DSLActivitySpec<PARAMS>, DSLWorkflowStepBase {
+    type: "activity";
+}
+
+export interface DSLChildWorkflowStep extends DSLWorkflowStepBase {
+    type: "workflow";
+    // the workflow endpoint to run
+    name: string;
+    /**
+     * The parameters to pass to the child workflow.
+     * These parameters will be merged over the parent workflow vars and passed altogether to the child workflow.
+     */
+    vars?: Record<string, any>;
+    // whether or not to wait for the workflow to finish.
+    // default is false. (the parent workflow will await for the workflow to finish)
+    async?: boolean;
+    /**
+     * The name of the workflow variable that will store the result of the child workflow (if async the workflow id is stored)
+     * If not specified the result will not be stored
+     * The parameters describe how the actual parameters will be obtained from the workflow execution vars.
+     * since it may contain references to workflow execution vars.
+     */
+    output?: string;
+    /**
+     * In case the dslWorkflow is used as a child workflow the spec is used to define the child workflow.
+     * If spec is defined then the name must be "dslWorkflow"
+     */
+    spec?: DSLWorkflowSpec;
+    /**
+     * If true, copy the parent's workspace artifacts (scripts/, files/, skills/, docs/, out/)
+     * to the child workflow's agent space before execution. Defaults to true.
+     * conversation.json and tools.json are never copied.
+     */
+    inherit_artifacts?: boolean;
+    options?: {
+        memo?: Record<string, any>;
+        retry?: DSLRetryPolicy;
+        searchAttributes?: Record<string, string[] | number[] | boolean[] | Date[]>;
+        taskQueue?: string;
+        workflowExecutionTimeout?: StringValue | number;
+        workflowRunTimeout?: StringValue | number;
+        workflowTaskTimeout?: StringValue | number;
+        workflowId?: string;
+        cronSchedule?: string;
+        parentClosePolicy?: ParentClosePolicyType;
+        //TODO
+        //cancellationType
+        //versioningIntent
+        //workflowIdReusePolicy
+    }
+}
+
+export type DSLWorkflowStep = DSLActivityStep | DSLChildWorkflowStep;
+
+export interface DSLWorkflowSpecBase {
+    name: string;
+    description?: string;
+    tags?: string[];
+
+    steps?: DSLWorkflowStep[] | never;
+    /**
+     * @deprecated use steps instead
+     */
+    activities?: DSLActivitySpec[] | never;
+
+    // a dictionary of vars to initialize the workflow execution vars
+    // Initial vars cannot contains references to other vars
+    vars: Record<string, any>;
+    // activity options that apply to all activities within the workflow
+    options?: DSLActivityOptions;
+    // the name of the variable that will hold the workflow result
+    // if not specified "result" will be assumed
+    result?: string;
+    debug_mode?: boolean;
+}
+
+export interface DSLWorkflowSpecWithSteps extends DSLWorkflowSpecBase {
+    steps: DSLWorkflowStep[];
+    /**
+     * @deprecated use steps instead
+     */
+    activities?: never;
+}
+
+/**
+ * @deprecated use steps instead
+ */
+export interface DSLWorkflowSpecWithActivities extends DSLWorkflowSpecBase {
+    steps?: never;
+    /**
+     * @deprecated use steps instead
+     */
+    activities: DSLActivitySpec[];
+}
+
+/**
+ * activities and steps fields are mutually exclusive
+ * steps was added after activities and may contain a mix of activities and other tasks like exec child workflows.
+ * For backward compatibility we keep the activities field as a fallback but one should use one or the other not both.
+ */
+export type DSLWorkflowSpec = DSLWorkflowSpecWithSteps | DSLWorkflowSpecWithActivities;
+
+export interface DSLWorkflowDefinition extends BaseObject, DSLWorkflowSpecBase {
+    // an optional JSON schema to describe the input vars of the workflow.
+    input_schema?: Record<string, any>;
+    activities?: DSLActivitySpec[];
+    steps?: DSLWorkflowStep[];
+}
+
+export interface WorkflowDefinitionRef {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    created_at: Date;
+    updated_at: Date;
+}
+
+export const WorkflowDefinitionRefPopulate = "id name description tags created_at updated_at"

package/src/store/index.ts

@@ -0,0 +1,14 @@
+export * from "./activity-catalog.js";
+export * from "./collections.js";
+export * from "./common.js";
+export * from "./conversation-state.js";
+export * from "./doc-analyzer.js";
+export * from "./dsl-workflow.js";
+export * from "./object-types.js";
+export * from "./schedule.js";
+export * from "./signals.js";
+export * from "./store.js";
+export * from "./temporalio.js";
+export * from "./worker.js";
+export * from "./workflow.js";
+

package/src/store/ms.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Types for the `ms` package (version 3.0.0-canary.1)
+ */
+declare module "ms" {
+    declare type Unit = 'Years' | 'Year' | 'Yrs' | 'Yr' | 'Y' | 'Weeks' | 'Week' | 'W' | 'Days' | 'Day' | 'D' | 'Hours' | 'Hour' | 'Hrs' | 'Hr' | 'H' | 'Minutes' | 'Minute' | 'Mins' | 'Min' | 'M' | 'Seconds' | 'Second' | 'Secs' | 'Sec' | 's' | 'Milliseconds' | 'Millisecond' | 'Msecs' | 'Msec' | 'Ms';
+    declare type UnitAnyCase = Unit | Uppercase<Unit> | Lowercase<Unit>;
+    export declare type StringValue = `${number}` | `${number}${UnitAnyCase}` | `${number} ${UnitAnyCase}`;
+    declare function ms(value: StringValue, options?: Options): number;
+    declare function ms(value: number, options?: Options): string;
+    export default ms;
+}

package/src/store/object-types.ts

@@ -0,0 +1,127 @@
+import type { JSONSchemaType } from "ajv"
+
+/*Default JSON Schema type for rendition*/
+
+export interface RenditionProperties {
+    mime_type: string,
+    source_etag?: string,
+    height?: number,
+    width?: number,
+    multipart?: boolean,
+    total_parts?: number,
+}
+
+export const RenditionSchema: JSONSchemaType<RenditionProperties> = {
+
+    type: "object",
+    description: "Represent a rendition of a file stored in an object. It will be stored as a separate object in the database.",
+    properties: {
+        mime_type: {
+            type: "string",
+            description: "The format of the rendition. This is a MIME type."
+        },
+        source_etag: {
+            type: "string",
+            description: "The ETag of the file used for the rendition.",
+            nullable: true
+        },
+        height: {
+            type: "integer",
+            description: "The height of the rendition",
+            nullable: true
+        },
+        width: {
+            type: "integer",
+            description: "The width of the rendition",
+            nullable: true
+        },
+        multipart: {
+            type: "boolean",
+            description: "If the rendition is a multi-part rendition",
+            nullable: true,
+            default: false
+        },
+        total_parts: {
+            type: "integer",
+            description: "The total number of parts in the rendition",
+            nullable: true
+        }
+    },
+    required: ["mime_type"],
+}
+
+
+
+export interface DocumentPartProperties {
+
+    source_etag?: string,
+    part_number: number,
+    title?: string,
+    source_line_start?: number,
+    source_line_end?: number,
+    type?: 'text' | 'image' | 'table' | 'chart' | 'diagram' | 'code' | 'other',
+    page_number?: number,
+    description?: string,
+    height?: number,
+    width?: number,
+
+}
+
+
+export const DocumentPartSchema: JSONSchemaType<DocumentPartProperties> = {
+    type: "object",
+    description: "Represent a semantic chunk of a document",
+    properties: {
+        source_etag: {
+            type: "string",
+            description: "The ETag of the file used for the rendition.",
+            nullable: true
+        },
+        part_number: {
+            type: "integer",
+            description: "The part number of the chunk",
+        },
+        title: {
+            type: "string",
+            description: "The title of the chunk",
+            nullable: true
+        },
+        source_line_start: {
+            type: "integer",
+            description: "The line number where the chunk starts",
+            nullable: true
+        },
+        source_line_end: {
+            type: "integer",
+            description: "The line number where the chunk ends",
+            nullable: true
+        },
+        type: {
+            type: "string",
+            description: "The type of the chunk",
+            enum: ['text', 'image', 'table', 'chart', 'diagram', 'code', 'other'],
+            nullable: true
+        },
+        page_number: {
+            type: "integer",
+            description: "The page number of the document part",
+            nullable: true
+        },
+        description: {
+            type: "string",
+            description: "The description of the document part, if it's an image, the exhaustive description of the image",
+            nullable: true
+        },
+        height: {
+            type: "integer",
+            description: "The height of the rendition",
+            nullable: true
+        },
+        width: {
+            type: "integer",
+            description: "The width of the rendition",
+            nullable: true
+        }
+    },
+    required: ["part_number"],
+}