@requence/service 1.0.0-alpha.2 → 1.0.0-alpha.20

package/build/types/helpers/src/protocol/command.d.ts

@@ -0,0 +1,414 @@
+import { z } from 'zod/v4';
+export declare const abortSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ABORT">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Abort = z.infer<typeof abortSchema>;
+export declare const createNodesSchema: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"CREATE">;
+    treeList: z.ZodObject<{
+        tree: z.ZodObject<{
+            nodes: z.ZodArray<z.ZodAny>;
+            edges: z.ZodArray<z.ZodAny>;
+        }, z.core.$strip>;
+        references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    }, z.core.$strip>;
+    input: z.ZodAny;
+    options: z.ZodObject<{
+        maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        compliance: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            "mcp-tool": "mcp-tool";
+        }>>>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            linear: "linear";
+            continuous: "continuous";
+        }>>;
+        uploadUrl: z.ZodOptional<z.ZodString>;
+        streamUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodTransform<{
+    treeList: {
+        tree: {
+            nodes: ({
+                id: string;
+                type: "exit";
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "entry";
+                inputSchema: import("json-schema").JSONSchema7;
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "service";
+                inputSchema: ({
+                    type: "object";
+                } & import("json-schema").JSONSchema7) | {
+                    type: "null";
+                };
+                name: string;
+                version: string;
+                configurationSchema: import("json-schema").JSONSchema7;
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+                configuration?: any;
+                ttl?: number | undefined;
+                retry?: number | undefined;
+                retryDelay?: number | undefined;
+            } | {
+                id: string;
+                type: "logic";
+                script: string;
+                concurrency: boolean;
+                language: "javascript" | "python" | "typescript";
+                maxExecutionTime: number;
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "or";
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "reference";
+                reference: string;
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+                configuration?: any;
+            })[];
+            edges: {
+                source: string;
+                sourceHandle: string | typeof import("./nodeType.ts").ERROR | null;
+                target: string;
+            }[];
+        };
+        references?: {
+            id: string;
+            options: {
+                maxExecutions: number;
+            };
+            tree: {
+                nodes: ({
+                    id: string;
+                    type: "exit";
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "entry";
+                    inputSchema: import("json-schema").JSONSchema7;
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "service";
+                    inputSchema: ({
+                        type: "object";
+                    } & import("json-schema").JSONSchema7) | {
+                        type: "null";
+                    };
+                    name: string;
+                    version: string;
+                    configurationSchema: import("json-schema").JSONSchema7;
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                    configuration?: any;
+                    ttl?: number | undefined;
+                    retry?: number | undefined;
+                    retryDelay?: number | undefined;
+                } | {
+                    id: string;
+                    type: "logic";
+                    script: string;
+                    concurrency: boolean;
+                    language: "javascript" | "python" | "typescript";
+                    maxExecutionTime: number;
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "or";
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "reference";
+                    reference: string;
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                    configuration?: any;
+                })[];
+                edges: {
+                    source: string;
+                    sourceHandle: string | typeof import("./nodeType.ts").ERROR | null;
+                    target: string;
+                }[];
+            };
+            references?: /*elided*/ any[] | undefined;
+        }[] | undefined;
+    };
+    type: "CREATE";
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "mcp-tool" | null;
+        mode: "linear" | "continuous";
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+    };
+}, {
+    type: "CREATE";
+    treeList: {
+        tree: {
+            nodes: any[];
+            edges: any[];
+        };
+        references?: any[] | undefined;
+    };
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "mcp-tool" | null;
+        mode: "linear" | "continuous";
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+    };
+}>>;
+export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"ABORT">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"CREATE">;
+    treeList: z.ZodObject<{
+        tree: z.ZodObject<{
+            nodes: z.ZodArray<z.ZodAny>;
+            edges: z.ZodArray<z.ZodAny>;
+        }, z.core.$strip>;
+        references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    }, z.core.$strip>;
+    input: z.ZodAny;
+    options: z.ZodObject<{
+        maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        compliance: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            "mcp-tool": "mcp-tool";
+        }>>>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            linear: "linear";
+            continuous: "continuous";
+        }>>;
+        uploadUrl: z.ZodOptional<z.ZodString>;
+        streamUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodTransform<{
+    treeList: {
+        tree: {
+            nodes: ({
+                id: string;
+                type: "exit";
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "entry";
+                inputSchema: import("json-schema").JSONSchema7;
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "service";
+                inputSchema: ({
+                    type: "object";
+                } & import("json-schema").JSONSchema7) | {
+                    type: "null";
+                };
+                name: string;
+                version: string;
+                configurationSchema: import("json-schema").JSONSchema7;
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+                configuration?: any;
+                ttl?: number | undefined;
+                retry?: number | undefined;
+                retryDelay?: number | undefined;
+            } | {
+                id: string;
+                type: "logic";
+                script: string;
+                concurrency: boolean;
+                language: "javascript" | "python" | "typescript";
+                maxExecutionTime: number;
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "or";
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+            } | {
+                id: string;
+                type: "reference";
+                reference: string;
+                outputs: {
+                    name: string | typeof import("./nodeType.ts").ERROR | null;
+                    schema: import("json-schema").JSONSchema7 | null;
+                }[];
+                alias?: string | undefined;
+                configuration?: any;
+            })[];
+            edges: {
+                source: string;
+                sourceHandle: string | typeof import("./nodeType.ts").ERROR | null;
+                target: string;
+            }[];
+        };
+        references?: {
+            id: string;
+            options: {
+                maxExecutions: number;
+            };
+            tree: {
+                nodes: ({
+                    id: string;
+                    type: "exit";
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "entry";
+                    inputSchema: import("json-schema").JSONSchema7;
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "service";
+                    inputSchema: ({
+                        type: "object";
+                    } & import("json-schema").JSONSchema7) | {
+                        type: "null";
+                    };
+                    name: string;
+                    version: string;
+                    configurationSchema: import("json-schema").JSONSchema7;
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                    configuration?: any;
+                    ttl?: number | undefined;
+                    retry?: number | undefined;
+                    retryDelay?: number | undefined;
+                } | {
+                    id: string;
+                    type: "logic";
+                    script: string;
+                    concurrency: boolean;
+                    language: "javascript" | "python" | "typescript";
+                    maxExecutionTime: number;
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "or";
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                } | {
+                    id: string;
+                    type: "reference";
+                    reference: string;
+                    outputs: {
+                        name: string | typeof import("./nodeType.ts").ERROR | null;
+                        schema: import("json-schema").JSONSchema7 | null;
+                    }[];
+                    alias?: string | undefined;
+                    configuration?: any;
+                })[];
+                edges: {
+                    source: string;
+                    sourceHandle: string | typeof import("./nodeType.ts").ERROR | null;
+                    target: string;
+                }[];
+            };
+            references?: /*elided*/ any[] | undefined;
+        }[] | undefined;
+    };
+    type: "CREATE";
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "mcp-tool" | null;
+        mode: "linear" | "continuous";
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+    };
+}, {
+    type: "CREATE";
+    treeList: {
+        tree: {
+            nodes: any[];
+            edges: any[];
+        };
+        references?: any[] | undefined;
+    };
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "mcp-tool" | null;
+        mode: "linear" | "continuous";
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+    };
+}>>]>;
+export type Command = z.infer<typeof commandSchema>;
+export type CommandInput = z.input<typeof commandSchema>;
+//# sourceMappingURL=command.d.ts.map

package/build/types/helpers/src/protocol/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAK1B,eAAO,MAAM,WAAW;;;iBAGtB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBzB,CAAA;AAEL,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA4C,CAAA;AAEtE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}

package/build/types/helpers/src/protocol/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { z } from 'zod/v4';
+export declare class NodeTransformError extends Error {
+}
+export declare function safeTransform<T extends () => any>(ctx: z.RefinementCtx, handler: T): ReturnType<T>;
+//# sourceMappingURL=helpers.d.ts.map

package/build/types/helpers/src/protocol/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE/B,qBAAa,kBAAmB,SAAQ,KAAK;CAAG;AAEhD,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,EAC/C,GAAG,EAAE,CAAC,CAAC,aAAa,EACpB,OAAO,EAAE,CAAC,GACT,UAAU,CAAC,CAAC,CAAC,CAUf"}

package/build/types/helpers/src/protocol/index.d.ts

@@ -0,0 +1,8 @@
+export * from './command.ts';
+export * from './nodeType.ts';
+export * from './targetNodes.ts';
+export * from './update.ts';
+export * from './treeNodes.ts';
+export * from './NodeTree.ts';
+export * from './nodeOptions.ts';
+//# sourceMappingURL=index.d.ts.map

package/build/types/helpers/src/protocol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA"}

package/build/types/helpers/src/protocol/nodeOptions.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod/v4';
+export declare const nodeOptionsSchema: z.ZodObject<{
+    maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    compliance: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        "mcp-tool": "mcp-tool";
+    }>>>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        linear: "linear";
+        continuous: "continuous";
+    }>>;
+    uploadUrl: z.ZodOptional<z.ZodString>;
+    streamUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type NodeOptions = z.infer<typeof nodeOptionsSchema>;
+export type NodeOptionsInput = z.input<typeof nodeOptionsSchema>;
+//# sourceMappingURL=nodeOptions.d.ts.map

package/build/types/helpers/src/protocol/nodeOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeOptions.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/nodeOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAY3B,CAAA;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}