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

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

@@ -0,0 +1,283 @@
+import { z } from 'zod/v4';
+export declare const ERROR: unique symbol;
+export declare const targetNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"entry">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"service">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+        type: z.ZodLiteral<"null">;
+    }, z.core.$strip>]>>;
+    name: z.ZodString;
+    version: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    configurationSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodNumber>;
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"logic">;
+    alias: z.ZodOptional<z.ZodString>;
+    script: z.ZodString;
+    concurrency: z.ZodDefault<z.ZodBoolean>;
+    language: z.ZodDefault<z.ZodEnum<{
+        javascript: "javascript";
+        python: "python";
+        typescript: "typescript";
+    }>>;
+    maxExecutionTime: z.ZodDefault<z.ZodNumber>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"or">;
+    alias: z.ZodOptional<z.ZodString>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"reference">;
+    alias: z.ZodOptional<z.ZodString>;
+    reference: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"exit">;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+export type TargetNode = z.infer<typeof targetNodeSchema>;
+export declare const treeEntryNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"entry">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const treeServiceNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"service">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+        type: z.ZodLiteral<"null">;
+    }, z.core.$strip>]>>;
+    name: z.ZodString;
+    version: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    configurationSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodNumber>;
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const treeLogicNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"logic">;
+    alias: z.ZodOptional<z.ZodString>;
+    script: z.ZodString;
+    concurrency: z.ZodDefault<z.ZodBoolean>;
+    language: z.ZodDefault<z.ZodEnum<{
+        javascript: "javascript";
+        python: "python";
+        typescript: "typescript";
+    }>>;
+    maxExecutionTime: z.ZodDefault<z.ZodNumber>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const treeOrNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"or">;
+    alias: z.ZodOptional<z.ZodString>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const treeReferenceNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"reference">;
+    alias: z.ZodOptional<z.ZodString>;
+    reference: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const treeExitNodeSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"exit">;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const treeNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"entry">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"service">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+        type: z.ZodLiteral<"null">;
+    }, z.core.$strip>]>>;
+    name: z.ZodString;
+    version: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    configurationSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodNumber>;
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"logic">;
+    alias: z.ZodOptional<z.ZodString>;
+    script: z.ZodString;
+    concurrency: z.ZodDefault<z.ZodBoolean>;
+    language: z.ZodDefault<z.ZodEnum<{
+        javascript: "javascript";
+        python: "python";
+        typescript: "typescript";
+    }>>;
+    maxExecutionTime: z.ZodDefault<z.ZodNumber>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"or">;
+    alias: z.ZodOptional<z.ZodString>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"reference">;
+    alias: z.ZodOptional<z.ZodString>;
+    reference: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+        schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"exit">;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+export declare const treeEdgeSchema: z.ZodObject<{
+    source: z.ZodUUID;
+    sourceHandle: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof ERROR, typeof ERROR>]>>;
+    target: z.ZodUUID;
+}, z.core.$strip>;
+export type TreeEdge = z.infer<typeof treeEdgeSchema>;
+export type TreeNode = z.infer<typeof treeNodeSchema>;
+export type EntryNode = Extract<TreeNode, {
+    type: 'entry';
+}>;
+export type ServiceNode = Extract<TreeNode, {
+    type: 'service';
+}>;
+export type LogicNode = Extract<TreeNode, {
+    type: 'logic';
+}>;
+export type ReferenceNode = Extract<TreeNode, {
+    type: 'reference';
+}>;
+export type OrNode = Extract<TreeNode, {
+    type: 'or';
+}>;
+export type ExitNode = Extract<TreeNode, {
+    type: 'exit';
+}>;
+//# sourceMappingURL=nodeType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeType.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/nodeType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,KAAK,eAAW,CAAA;AAoI7B,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAO3B,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAwBzD,eAAO,MAAM,mBAAmB;;;;;;;;;kBAA4C,CAAA;AAC5E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;kBAA8C,CAAA;AAChF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;kBAA4C,CAAA;AAC5E,eAAO,MAAM,gBAAgB;;;;;;;;kBAAyC,CAAA;AACtE,eAAO,MAAM,uBAAuB;;;;;;;;;;kBACW,CAAA;AAC/C,eAAO,MAAM,kBAAkB;;;;kBAAiB,CAAA;AAEhD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAOzB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;iBAIzB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AACrD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAC5D,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC,CAAA;AAChE,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAC5D,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,CAAA;AACpE,MAAM,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AACtD,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA"}

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

@@ -0,0 +1,253 @@
+import { z } from 'zod/v4';
+export declare const targetNodesSchema: z.ZodPipe<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"entry">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof import("./nodeType.ts").ERROR, typeof import("./nodeType.ts").ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"service">;
+    alias: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+    }, z.core.$strip>, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>, z.ZodObject<{
+        type: z.ZodLiteral<"null">;
+    }, z.core.$strip>]>>;
+    name: z.ZodString;
+    version: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    configurationSchema: z.ZodDefault<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodNumber>;
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof import("./nodeType.ts").ERROR, typeof import("./nodeType.ts").ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"logic">;
+    alias: z.ZodOptional<z.ZodString>;
+    script: z.ZodString;
+    concurrency: z.ZodDefault<z.ZodBoolean>;
+    language: z.ZodDefault<z.ZodEnum<{
+        javascript: "javascript";
+        python: "python";
+        typescript: "typescript";
+    }>>;
+    maxExecutionTime: z.ZodDefault<z.ZodNumber>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof import("./nodeType.ts").ERROR, typeof import("./nodeType.ts").ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"or">;
+    alias: z.ZodOptional<z.ZodString>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof import("./nodeType.ts").ERROR, typeof import("./nodeType.ts").ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"reference">;
+    alias: z.ZodOptional<z.ZodString>;
+    reference: z.ZodString;
+    configuration: z.ZodOptional<z.ZodAny>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        schema: z.ZodDefault<z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+        name: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof import("./nodeType.ts").ERROR, typeof import("./nodeType.ts").ERROR>]>>;
+        target: z.ZodString;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }, string | {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodUUID>;
+    type: z.ZodLiteral<"exit">;
+    alias: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>>, z.ZodTransform<{
+    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;
+    }[];
+}, ({
+    id: string;
+    type: "entry";
+    inputSchema: import("json-schema").JSONSchema7;
+    outputs: {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }[];
+    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: {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }[];
+    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: {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }[];
+    alias?: string | undefined;
+} | {
+    id: string;
+    type: "or";
+    outputs: {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }[];
+    alias?: string | undefined;
+} | {
+    id: string;
+    type: "reference";
+    reference: string;
+    outputs: {
+        schema: import("json-schema").JSONSchema7 | null;
+        name: string | typeof import("./nodeType.ts").ERROR | null;
+        target: string;
+    }[];
+    alias?: string | undefined;
+    configuration?: any;
+} | {
+    id: string;
+    type: "exit";
+    alias?: string | undefined;
+})[]>>;
+//# sourceMappingURL=targetNodes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"targetNodes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/targetNodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwG3B,CAAA"}

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

@@ -0,0 +1,22 @@
+import { z } from 'zod/v4';
+export declare const taskOptionsSchema: 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>;
+export type TaskOptions = z.infer<typeof taskOptionsSchema>;
+export type TaskOptionsInput = z.input<typeof taskOptionsSchema>;
+//# sourceMappingURL=taskOptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"taskOptions.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/taskOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;iBAoB3B,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"}