@requence/service 1.0.0-alpha.4 → 1.0.0-alpha.40

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

@@ -0,0 +1,471 @@
+import { z } from 'zod/v4';
+export declare const abortCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ABORT">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AbortCommand = z.infer<typeof abortCommandSchema>;
+export declare const createCommandSchema: 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";
+        }>>;
+        priority: z.ZodDefault<z.ZodInt>;
+        uploadUrl: z.ZodOptional<z.ZodString>;
+        streamUrl: z.ZodOptional<z.ZodString>;
+        referencedBy: z.ZodOptional<z.ZodObject<{
+            taskId: z.ZodUUID;
+            nodeId: z.ZodUUID;
+            messageId: z.ZodUUID;
+        }, z.core.$strip>>;
+    }, 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;
+                compliance: "mcp-tool" | null;
+                mode: "linear" | "continuous";
+                priority: number;
+                uploadUrl?: string | undefined;
+                streamUrl?: string | undefined;
+                referencedBy?: {
+                    taskId: string;
+                    nodeId: string;
+                    messageId: string;
+                } | undefined;
+            };
+            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;
+    };
+    type: "CREATE";
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "mcp-tool" | null;
+        mode: "linear" | "continuous";
+        priority: number;
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+        referencedBy?: {
+            taskId: string;
+            nodeId: string;
+            messageId: 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";
+        priority: number;
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+        referencedBy?: {
+            taskId: string;
+            nodeId: string;
+            messageId: string;
+        } | undefined;
+    };
+}>>;
+export type CreateCommand = z.infer<typeof createCommandSchema>;
+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";
+        }>>;
+        priority: z.ZodDefault<z.ZodInt>;
+        uploadUrl: z.ZodOptional<z.ZodString>;
+        streamUrl: z.ZodOptional<z.ZodString>;
+        referencedBy: z.ZodOptional<z.ZodObject<{
+            taskId: z.ZodUUID;
+            nodeId: z.ZodUUID;
+            messageId: z.ZodUUID;
+        }, z.core.$strip>>;
+    }, 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;
+                compliance: "mcp-tool" | null;
+                mode: "linear" | "continuous";
+                priority: number;
+                uploadUrl?: string | undefined;
+                streamUrl?: string | undefined;
+                referencedBy?: {
+                    taskId: string;
+                    nodeId: string;
+                    messageId: string;
+                } | undefined;
+            };
+            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;
+    };
+    type: "CREATE";
+    input: any;
+    options: {
+        maxExecutions: number;
+        compliance: "mcp-tool" | null;
+        mode: "linear" | "continuous";
+        priority: number;
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+        referencedBy?: {
+            taskId: string;
+            nodeId: string;
+            messageId: 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";
+        priority: number;
+        uploadUrl?: string | undefined;
+        streamUrl?: string | undefined;
+        referencedBy?: {
+            taskId: string;
+            nodeId: string;
+            messageId: 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,kBAAkB;;;iBAG7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsB3B,CAAA;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAqD,CAAA;AAC/E,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 './taskOptions.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"}