@loopstack/contracts 0.14.0

package/dist/schemas/startup.schema.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledTaskSchema = exports.StartupTaskSchema = exports.RunPipelineTaskSchema = exports.BaseStartupTaskSchema = exports.JobsScheduleSchema = void 0;
+const zod_1 = require("zod");
+const transition_payload_schema_1 = require("./transition-payload.schema");
+const RepeatOptionsSchema = zod_1.z.object({
+    every: zod_1.z.number().nonnegative().optional()
+        .describe('Repeat every X milliseconds. Example: 60000 for every minute'),
+    startDate: zod_1.z.string().optional()
+        .describe('ISO string or timestamp when to start repeating. Example: "2025-01-01T00:00:00.000Z" or Date.now()'),
+    endDate: zod_1.z.string().optional()
+        .describe('ISO string or timestamp when to stop repeating. Example: "2025-12-31T23:59:59.999Z"'),
+    limit: zod_1.z.number().nonnegative().optional()
+        .describe('Maximum number of times to repeat. Example: 100'),
+    immediately: zod_1.z.boolean().optional()
+        .describe('Whether to run the job immediately when created. Default: false'),
+    pattern: zod_1.z.string().optional()
+        .describe('Cron pattern for scheduling. Examples: "0 2 * * *" (daily at 2am), "*/15 * * * *" (every 15 min), "0 9 * * MON-FRI" (weekdays at 9am)'),
+    tz: zod_1.z.string().optional()
+        .describe('IANA timezone for cron pattern. Examples: "UTC", "America/New_York", "Europe/London", "Asia/Tokyo", "Australia/Sydney"'),
+});
+exports.JobsScheduleSchema = zod_1.z.object({
+    delay: zod_1.z.number().nonnegative().optional(),
+    repeat: RepeatOptionsSchema.optional(),
+}).partial();
+exports.BaseStartupTaskSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    title: zod_1.z.string().optional(),
+    type: zod_1.z.string(),
+    payload: zod_1.z.any(), // Keeping payload flexible as requested
+    user: zod_1.z.string(),
+    schedule: exports.JobsScheduleSchema.optional(),
+});
+exports.RunPipelineTaskSchema = exports.BaseStartupTaskSchema.extend({
+    type: zod_1.z.literal('run_pipeline'),
+    payload: zod_1.z.object({
+        id: zod_1.z.string(),
+        transition: transition_payload_schema_1.TransitionPayloadSchema.optional(),
+    }),
+});
+// export const CreateRunPipelineTaskSchema = BaseStartupTaskSchema.extend({
+//   type: z.literal('create_run_pipeline'),
+//   payload: z.object({
+//     pipeline: z.string(),
+//     transition: TransitionPayloadSchema.optional(),
+//   }),
+//   variables: z.record(z.string(), z.any()).optional(),
+// })
+// export const CreateWorkspaceTaskSchema = BaseStartupTaskSchema.extend({
+//   type: z.literal('create_workspace'),
+//   payload: z.object({
+//     workspace: z.string()
+//   }),
+// })
+//
+// const intervalRegex = /^(\d+)\s*(days?|hours?|minutes?|seconds?)$/i;
+// export const CleanupPipelineTaskSchema = BaseStartupTaskSchema.extend({
+//   type: z.literal('cleanup_pipeline'),
+//   payload: z.object({
+//     pipeline: z.string(),
+//     olderThan: z.string()
+//       .regex(intervalRegex, 'Duration must be in format: number followed by the unit (e.g., 30 days", "24 hours", "60 minutes")')
+//       .optional(),
+//     status: z.nativeEnum(PipelineState).optional(),
+//     skip: z.number().optional(), // keep the latest x items
+//     limit: z.number().positive().optional(), // Maximum number of pipelines to delete in one execution
+//   }),
+// })
+exports.StartupTaskSchema = zod_1.z.discriminatedUnion('type', [
+    exports.RunPipelineTaskSchema,
+    // CreateRunPipelineTaskSchema,
+    // CleanupPipelineTaskSchema,
+    // CreateWorkspaceTaskSchema,
+]);
+exports.ScheduledTaskSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1, 'id is required'),
+    task: exports.StartupTaskSchema,
+});

package/dist/schemas/template-expression.schema.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const TemplateExpression: z.ZodString;

package/dist/schemas/template-expression.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-expression.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/template-expression.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB,aAG9B,CAAC"}

package/dist/schemas/template-expression.schema.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateExpression = void 0;
+const zod_1 = require("zod");
+exports.TemplateExpression = zod_1.z.string().regex(/^(?:\||>)?(?:[-+])?\s*\$\{([\s\S]*?)\}\s*$/, "Must be an expression in format '${ expression }'");

package/dist/schemas/tool-call.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const ToolCallSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    tool: z.ZodString;
+    args: z.ZodOptional<z.ZodAny>;
+    assign: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNull, z.ZodString, z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodAny>]>>>;
+}, "strip", z.ZodTypeAny, {
+    tool: string;
+    id?: string | undefined;
+    args?: any;
+    assign?: Record<string, string | number | boolean | Record<string, any> | null> | undefined;
+}, {
+    tool: string;
+    id?: string | undefined;
+    args?: any;
+    assign?: Record<string, string | number | boolean | Record<string, any> | null> | undefined;
+}>;

package/dist/schemas/tool-call.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/tool-call.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAKzB,CAAC"}

package/dist/schemas/tool-call.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCallSchema = void 0;
+const zod_1 = require("zod");
+const assignment_schema_1 = require("./assignment.schema");
+exports.ToolCallSchema = zod_1.z.object({
+    id: zod_1.z.string().optional(),
+    tool: zod_1.z.string(),
+    args: zod_1.z.any().optional(),
+    assign: assignment_schema_1.AssignmentConfigSchema.optional(),
+});

package/dist/schemas/tool-config.schema.d.ts

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+export declare const ToolConfigSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodLiteral<"tool">>;
+    description: z.ZodOptional<z.ZodString>;
+    ui: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            transition: z.ZodString;
+            widget: z.ZodOptional<z.ZodString>;
+            enabledWhen: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        } & {
+            type: z.ZodLiteral<"button">;
+            options: z.ZodOptional<z.ZodObject<{
+                position: z.ZodOptional<z.ZodNumber>;
+                label: z.ZodOptional<z.ZodString>;
+                props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                position?: number | undefined;
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            }, {
+                position?: number | undefined;
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "button";
+            transition: string;
+            options?: {
+                position?: number | undefined;
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        }, {
+            type: "button";
+            transition: string;
+            options?: {
+                position?: number | undefined;
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        }>, z.ZodObject<{
+            transition: z.ZodString;
+            widget: z.ZodOptional<z.ZodString>;
+            enabledWhen: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        } & {
+            type: z.ZodLiteral<"custom">;
+            options: z.ZodOptional<z.ZodObject<{
+                label: z.ZodOptional<z.ZodString>;
+                props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            }, {
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "custom";
+            transition: string;
+            options?: {
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        }, {
+            type: "custom";
+            transition: string;
+            options?: {
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        }>]>, "many">>;
+        form: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+    }, "strip", z.ZodTypeAny, {
+        form?: any;
+        actions?: ({
+            type: "button";
+            transition: string;
+            options?: {
+                position?: number | undefined;
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        } | {
+            type: "custom";
+            transition: string;
+            options?: {
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        })[] | undefined;
+    }, {
+        form?: any;
+        actions?: ({
+            type: "button";
+            transition: string;
+            options?: {
+                position?: number | undefined;
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        } | {
+            type: "custom";
+            transition: string;
+            options?: {
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        })[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool";
+    description?: string | undefined;
+    ui?: {
+        form?: any;
+        actions?: ({
+            type: "button";
+            transition: string;
+            options?: {
+                position?: number | undefined;
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        } | {
+            type: "custom";
+            transition: string;
+            options?: {
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        })[] | undefined;
+    } | undefined;
+}, {
+    type?: "tool" | undefined;
+    description?: string | undefined;
+    ui?: {
+        form?: any;
+        actions?: ({
+            type: "button";
+            transition: string;
+            options?: {
+                position?: number | undefined;
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        } | {
+            type: "custom";
+            transition: string;
+            options?: {
+                label?: string | undefined;
+                props?: Record<string, any> | undefined;
+            } | undefined;
+            widget?: string | undefined;
+            enabledWhen?: string[] | undefined;
+        })[] | undefined;
+    } | undefined;
+}>;

package/dist/schemas/tool-config.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-config.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/tool-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI3B,CAAC"}

package/dist/schemas/tool-config.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolConfigSchema = void 0;
+const zod_1 = require("zod");
+const block_schema_1 = require("./block.schema");
+const ui_form_schema_1 = require("./ui-form.schema");
+exports.ToolConfigSchema = block_schema_1.BlockSchema.extend({
+    type: zod_1.z.literal('tool').default('tool'),
+    description: zod_1.z.string().optional(),
+    ui: ui_form_schema_1.UiFormSchema.optional()
+});

package/dist/schemas/transition-payload.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const TransitionPayloadSchema: z.ZodObject<{
+    id: z.ZodString;
+    workflowId: z.ZodString;
+    payload: z.ZodOptional<z.ZodAny>;
+    meta: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    workflowId: string;
+    meta?: any;
+    payload?: any;
+}, {
+    id: string;
+    workflowId: string;
+    meta?: any;
+    payload?: any;
+}>;

package/dist/schemas/transition-payload.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transition-payload.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/transition-payload.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAKlC,CAAC"}

package/dist/schemas/transition-payload.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransitionPayloadSchema = void 0;
+const zod_1 = require("zod");
+exports.TransitionPayloadSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    workflowId: zod_1.z.string(),
+    payload: zod_1.z.any().optional(),
+    meta: zod_1.z.any().optional(),
+});

package/dist/schemas/ui-form-element.schema.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+export declare const UiElementSchema: z.ZodObject<{
+    widget: z.ZodOptional<z.ZodString>;
+    index: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
+    descriptions: z.ZodOptional<z.ZodString>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    rows: z.ZodOptional<z.ZodNumber>;
+    inline: z.ZodOptional<z.ZodBoolean>;
+    inputType: z.ZodOptional<z.ZodString>;
+    emptyValue: z.ZodOptional<z.ZodAny>;
+    help: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    enumOptions: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        value?: any;
+    }, {
+        label: string;
+        value?: any;
+    }>, z.ZodString]>, "many">, z.ZodString]>>;
+    titleFormat: z.ZodOptional<z.ZodString>;
+    addable: z.ZodOptional<z.ZodBoolean>;
+    removable: z.ZodOptional<z.ZodBoolean>;
+    movable: z.ZodOptional<z.ZodBoolean>;
+    accept: z.ZodOptional<z.ZodString>;
+    multiple: z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    readonly: z.ZodOptional<z.ZodBoolean>;
+    collapsed: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    index?: number | undefined;
+    inline?: boolean | undefined;
+    inputType?: string | undefined;
+    order?: string[] | undefined;
+    hidden?: boolean | undefined;
+    label?: string | undefined;
+    title?: string | undefined;
+    descriptions?: string | undefined;
+    disabled?: boolean | undefined;
+    multiple?: boolean | undefined;
+    readonly?: boolean | undefined;
+    widget?: string | undefined;
+    placeholder?: string | undefined;
+    rows?: number | undefined;
+    emptyValue?: any;
+    help?: string | undefined;
+    enumOptions?: string | (string | {
+        label: string;
+        value?: any;
+    })[] | undefined;
+    titleFormat?: string | undefined;
+    addable?: boolean | undefined;
+    removable?: boolean | undefined;
+    movable?: boolean | undefined;
+    accept?: string | undefined;
+    collapsed?: boolean | undefined;
+}, {
+    index?: number | undefined;
+    inline?: boolean | undefined;
+    inputType?: string | undefined;
+    order?: string[] | undefined;
+    hidden?: boolean | undefined;
+    label?: string | undefined;
+    title?: string | undefined;
+    descriptions?: string | undefined;
+    disabled?: boolean | undefined;
+    multiple?: boolean | undefined;
+    readonly?: boolean | undefined;
+    widget?: string | undefined;
+    placeholder?: string | undefined;
+    rows?: number | undefined;
+    emptyValue?: any;
+    help?: string | undefined;
+    enumOptions?: string | (string | {
+        label: string;
+        value?: any;
+    })[] | undefined;
+    titleFormat?: string | undefined;
+    addable?: boolean | undefined;
+    removable?: boolean | undefined;
+    movable?: boolean | undefined;
+    accept?: string | undefined;
+    collapsed?: boolean | undefined;
+}>;

package/dist/schemas/ui-form-element.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-form-element.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/ui-form-element.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoC1B,CAAC"}

package/dist/schemas/ui-form-element.schema.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UiElementSchema = void 0;
+const zod_1 = require("zod");
+exports.UiElementSchema = zod_1.z.object({
+    widget: zod_1.z.string().optional(),
+    index: zod_1.z.number().optional(),
+    label: zod_1.z.string().optional(),
+    descriptions: zod_1.z.string().optional(),
+    placeholder: zod_1.z.string().optional(),
+    rows: zod_1.z.number().int().positive().optional(),
+    inline: zod_1.z.boolean().optional(),
+    inputType: zod_1.z.string().optional(),
+    emptyValue: zod_1.z.any().optional(),
+    help: zod_1.z.string().optional(),
+    title: zod_1.z.string().optional(),
+    enumOptions: zod_1.z.union([
+        zod_1.z.array(zod_1.z.union([
+            zod_1.z.object({
+                label: zod_1.z.string(),
+                value: zod_1.z.any()
+            }),
+            zod_1.z.string(),
+        ])),
+        zod_1.z.string()
+    ]).optional(),
+    titleFormat: zod_1.z.string().optional(),
+    addable: zod_1.z.boolean().optional(),
+    removable: zod_1.z.boolean().optional(),
+    movable: zod_1.z.boolean().optional(),
+    accept: zod_1.z.string().optional(),
+    multiple: zod_1.z.boolean().optional(),
+    hidden: zod_1.z.boolean().optional(),
+    disabled: zod_1.z.boolean().optional(),
+    readonly: zod_1.z.boolean().optional(),
+    collapsed: zod_1.z.boolean().optional(),
+    order: zod_1.z.array(zod_1.z.string()).optional(),
+});