@hexabot-ai/types 3.0.2-alpha.10 → 3.0.2-alpha.11

package/dist/types/workflow/workflow-transfer.d.ts

@@ -0,0 +1,329 @@
+import { z } from "zod";
+export declare const WORKFLOW_EXPORT_BUNDLE_KIND = "hexabot.workflow.bundle";
+export declare const WORKFLOW_TRANSFER_RESOURCE_KIND_PATTERN: RegExp;
+export declare const workflowTransferResourceKindSchema: z.ZodString;
+export declare const workflowExportBundleMemoryDefinitionSchema: z.ZodObject<{
+    exportId: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    scope: z.ZodEnum<typeof import("./domain").MemoryScope>;
+    schema: z.ZodAny;
+    ttlSeconds: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strict>;
+export declare const workflowExportBundleCredentialSchema: z.ZodObject<{
+    exportId: z.ZodString;
+    name: z.ZodString;
+    exportedOwnerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const workflowExportBundleMcpServerSchema: z.ZodObject<{
+    exportId: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodCoercedBoolean<unknown>;
+    transport: z.ZodEnum<typeof import("./domain").McpServerTransport>;
+    url: z.ZodNullable<z.ZodString>;
+    command: z.ZodNullable<z.ZodString>;
+    args: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodNullable<z.ZodString>;
+    credentialExportId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const workflowExportBundleContentTypeSchema: z.ZodObject<{
+    exportId: z.ZodString;
+    name: z.ZodString;
+    schema: z.ZodAny;
+}, z.core.$strict>;
+export declare const workflowExportBundleLabelGroupSchema: z.ZodObject<{
+    exportId: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export declare const workflowExportBundleLabelSchema: z.ZodObject<{
+    exportId: z.ZodString;
+    title: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    groupExportId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const workflowExportBundleWorkflowDependencySchema: z.ZodObject<{
+    exportId: z.ZodString;
+    workflow: z.ZodObject<{
+        type: z.ZodEnum<typeof import("./domain").WorkflowType>;
+        description: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        schedule: z.ZodNullable<z.ZodString>;
+        inputSchema: z.ZodAny;
+        layout: z.ZodObject<{
+            x: z.ZodCoercedNumber<unknown>;
+            y: z.ZodCoercedNumber<unknown>;
+            zoom: z.ZodCoercedNumber<unknown>;
+            direction: z.ZodEnum<typeof import("./domain").DirectionType>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    version: z.ZodObject<{
+        number: z.ZodCoercedNumber<unknown>;
+        checksum: z.ZodString;
+        message: z.ZodNullable<z.ZodString>;
+        exportedVersionId: z.ZodString;
+    }, z.core.$strict>;
+    definitionYml: z.ZodString;
+}, z.core.$strict>;
+export declare const workflowExportBundleV1Schema: z.ZodObject<{
+    kind: z.ZodLiteral<"hexabot.workflow.bundle">;
+    schemaVersion: z.ZodLiteral<1>;
+    exportedAt: z.ZodISODateTime;
+    workflow: z.ZodObject<{
+        exportId: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        type: z.ZodEnum<typeof import("./domain").WorkflowType>;
+        schedule: z.ZodNullable<z.ZodString>;
+        inputSchema: z.ZodAny;
+        layout: z.ZodObject<{
+            x: z.ZodCoercedNumber<unknown>;
+            y: z.ZodCoercedNumber<unknown>;
+            zoom: z.ZodCoercedNumber<unknown>;
+            direction: z.ZodEnum<typeof import("./domain").DirectionType>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    version: z.ZodObject<{
+        number: z.ZodCoercedNumber<unknown>;
+        checksum: z.ZodString;
+        message: z.ZodNullable<z.ZodString>;
+        exportedVersionId: z.ZodString;
+    }, z.core.$strict>;
+    definitionYml: z.ZodString;
+    resources: z.ZodObject<{
+        memoryDefinitions: z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+            slug: z.ZodString;
+            scope: z.ZodEnum<typeof import("./domain").MemoryScope>;
+            schema: z.ZodAny;
+            ttlSeconds: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+        }, z.core.$strict>>;
+        mcpServers: z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodCoercedBoolean<unknown>;
+            transport: z.ZodEnum<typeof import("./domain").McpServerTransport>;
+            url: z.ZodNullable<z.ZodString>;
+            command: z.ZodNullable<z.ZodString>;
+            args: z.ZodNullable<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodNullable<z.ZodString>;
+            credentialExportId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        credentials: z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+            exportedOwnerId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        contentTypes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+            schema: z.ZodAny;
+        }, z.core.$strict>>>;
+        labelGroups: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            title: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            groupExportId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>>;
+        workflows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            workflow: z.ZodObject<{
+                type: z.ZodEnum<typeof import("./domain").WorkflowType>;
+                description: z.ZodNullable<z.ZodString>;
+                name: z.ZodString;
+                schedule: z.ZodNullable<z.ZodString>;
+                inputSchema: z.ZodAny;
+                layout: z.ZodObject<{
+                    x: z.ZodCoercedNumber<unknown>;
+                    y: z.ZodCoercedNumber<unknown>;
+                    zoom: z.ZodCoercedNumber<unknown>;
+                    direction: z.ZodEnum<typeof import("./domain").DirectionType>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            version: z.ZodObject<{
+                number: z.ZodCoercedNumber<unknown>;
+                checksum: z.ZodString;
+                message: z.ZodNullable<z.ZodString>;
+                exportedVersionId: z.ZodString;
+            }, z.core.$strict>;
+            definitionYml: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$catchall<z.ZodArray<z.ZodUnknown>>>;
+}, z.core.$strict>;
+export declare const workflowExportBundleSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"hexabot.workflow.bundle">;
+    schemaVersion: z.ZodLiteral<1>;
+    exportedAt: z.ZodISODateTime;
+    workflow: z.ZodObject<{
+        exportId: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        type: z.ZodEnum<typeof import("./domain").WorkflowType>;
+        schedule: z.ZodNullable<z.ZodString>;
+        inputSchema: z.ZodAny;
+        layout: z.ZodObject<{
+            x: z.ZodCoercedNumber<unknown>;
+            y: z.ZodCoercedNumber<unknown>;
+            zoom: z.ZodCoercedNumber<unknown>;
+            direction: z.ZodEnum<typeof import("./domain").DirectionType>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    version: z.ZodObject<{
+        number: z.ZodCoercedNumber<unknown>;
+        checksum: z.ZodString;
+        message: z.ZodNullable<z.ZodString>;
+        exportedVersionId: z.ZodString;
+    }, z.core.$strict>;
+    definitionYml: z.ZodString;
+    resources: z.ZodObject<{
+        memoryDefinitions: z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+            slug: z.ZodString;
+            scope: z.ZodEnum<typeof import("./domain").MemoryScope>;
+            schema: z.ZodAny;
+            ttlSeconds: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+        }, z.core.$strict>>;
+        mcpServers: z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodCoercedBoolean<unknown>;
+            transport: z.ZodEnum<typeof import("./domain").McpServerTransport>;
+            url: z.ZodNullable<z.ZodString>;
+            command: z.ZodNullable<z.ZodString>;
+            args: z.ZodNullable<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodNullable<z.ZodString>;
+            credentialExportId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        credentials: z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+            exportedOwnerId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        contentTypes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+            schema: z.ZodAny;
+        }, z.core.$strict>>>;
+        labelGroups: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            title: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            groupExportId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>>;
+        workflows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            exportId: z.ZodString;
+            workflow: z.ZodObject<{
+                type: z.ZodEnum<typeof import("./domain").WorkflowType>;
+                description: z.ZodNullable<z.ZodString>;
+                name: z.ZodString;
+                schedule: z.ZodNullable<z.ZodString>;
+                inputSchema: z.ZodAny;
+                layout: z.ZodObject<{
+                    x: z.ZodCoercedNumber<unknown>;
+                    y: z.ZodCoercedNumber<unknown>;
+                    zoom: z.ZodCoercedNumber<unknown>;
+                    direction: z.ZodEnum<typeof import("./domain").DirectionType>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            version: z.ZodObject<{
+                number: z.ZodCoercedNumber<unknown>;
+                checksum: z.ZodString;
+                message: z.ZodNullable<z.ZodString>;
+                exportedVersionId: z.ZodString;
+            }, z.core.$strict>;
+            definitionYml: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$catchall<z.ZodArray<z.ZodUnknown>>>;
+}, z.core.$strict>;
+export declare const workflowImportResourceActionSchema: z.ZodEnum<{
+    reused: "reused";
+    created: "created";
+    placeholder_created: "placeholder_created";
+}>;
+export declare const workflowImportResourceResultSchema: z.ZodObject<{
+    kind: z.ZodString;
+    exportId: z.ZodString;
+    localId: z.ZodString;
+    name: z.ZodString;
+    action: z.ZodEnum<{
+        reused: "reused";
+        created: "created";
+        placeholder_created: "placeholder_created";
+    }>;
+}, z.core.$strict>;
+export declare const workflowImportResultSchema: z.ZodObject<{
+    workflow: z.ZodType<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        description: string | null;
+        type: import("./domain").WorkflowType;
+        schedule: string | null;
+        inputSchema: any;
+        builtin: boolean;
+        x: number;
+        y: number;
+        zoom: number;
+        direction: import("./domain").DirectionType;
+        createdBy: string | null;
+        runAfterMs: number;
+        currentVersion?: string | null | undefined;
+        publishedVersion?: string | null | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        description: string | null;
+        type: import("./domain").WorkflowType;
+        schedule: string | null;
+        inputSchema: any;
+        builtin: boolean;
+        x: number;
+        y: number;
+        zoom: number;
+        direction: import("./domain").DirectionType;
+        createdBy: string | null;
+        runAfterMs: number;
+        currentVersion?: string | null | undefined;
+        publishedVersion?: string | null | undefined;
+    }, unknown>>;
+    resources: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        exportId: z.ZodString;
+        localId: z.ZodString;
+        name: z.ZodString;
+        action: z.ZodEnum<{
+            reused: "reused";
+            created: "created";
+            placeholder_created: "placeholder_created";
+        }>;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type WorkflowExportBundleMemoryDefinition = z.infer<typeof workflowExportBundleMemoryDefinitionSchema>;
+export type WorkflowExportBundleCredential = z.infer<typeof workflowExportBundleCredentialSchema>;
+export type WorkflowExportBundleMcpServer = z.infer<typeof workflowExportBundleMcpServerSchema>;
+export type WorkflowExportBundleContentType = z.infer<typeof workflowExportBundleContentTypeSchema>;
+export type WorkflowExportBundleLabelGroup = z.infer<typeof workflowExportBundleLabelGroupSchema>;
+export type WorkflowExportBundleLabel = z.infer<typeof workflowExportBundleLabelSchema>;
+export type WorkflowExportBundleWorkflowDependency = z.infer<typeof workflowExportBundleWorkflowDependencySchema>;
+export type WorkflowExportBundleV1 = z.infer<typeof workflowExportBundleV1Schema>;
+export type WorkflowExportBundle = z.infer<typeof workflowExportBundleSchema>;
+export type WorkflowImportResourceAction = z.infer<typeof workflowImportResourceActionSchema>;
+export type WorkflowImportResourceResult = z.infer<typeof workflowImportResourceResultSchema>;
+export type WorkflowImportResult = z.infer<typeof workflowImportResultSchema>;
+//# sourceMappingURL=workflow-transfer.d.ts.map

package/dist/types/workflow/workflow-transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-transfer.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-transfer.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,2BAA2B,4BAA4B,CAAC;AAErE,eAAO,MAAM,uCAAuC,QACP,CAAC;AAE9C,eAAO,MAAM,kCAAkC,aAGE,CAAC;AAwBlD,eAAO,MAAM,0CAA0C;;;;;;;kBAOrD,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;kBAI/C,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;kBAU9C,CAAC;AAEH,eAAO,MAAM,qCAAqC;;;;kBAIhD,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;kBAG/C,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;kBAM1C,CAAC;AAEH,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;kBAKvD,CAAC;AAgBH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQvC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA+B,CAAC;AAEvE,eAAO,MAAM,kCAAkC;;;;EAI7C,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;kBAM7C,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIrC,CAAC;AAEH,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,qCAAqC,CAC7C,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,4CAA4C,CACpD,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexabot-ai/types",
-  "version": "3.0.2-alpha.10",
+  "version": "3.0.2-alpha.11",
   "description": "Shared zod schemas and inferred entity types for Hexabot.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

package/src/index.test.ts

@@ -57,6 +57,9 @@ import {
   userFullSchema,
   userSchema,
   workflowFullSchema,
+  workflowExportBundleSchema,
+  workflowExportBundleV1Schema,
+  workflowImportResultSchema,
   workflowRunFullSchema,
   workflowRunSchema,
   workflowVersionFullSchema,
@@ -777,6 +780,300 @@ describe("@hexabot-ai/types schemas", () => {
     expect(parser).toHaveBeenCalledTimes(1);
   });
 
+  it("parses workflow export bundles without credential secrets", () => {
+    const bundle = workflowExportBundleSchema.parse({
+      kind: "hexabot.workflow.bundle",
+      schemaVersion: 1,
+      exportedAt: now,
+      workflow: {
+        exportId: "wf_1",
+        name: "Main",
+        description: null,
+        type: WorkflowType.conversational,
+        schedule: null,
+        inputSchema: {},
+        layout: {
+          x: 0,
+          y: 0,
+          zoom: 1,
+          direction: "horizontal",
+        },
+      },
+      version: {
+        number: 3,
+        checksum: "sha",
+        message: null,
+        exportedVersionId: "wfv_1",
+      },
+      definitionYml: "defs: {}\nflow: []\noutputs: {}",
+      resources: {
+        memoryDefinitions: [
+          {
+            exportId: "mem_1",
+            name: "Profile",
+            slug: "profile",
+            scope: MemoryScope.workflow,
+            schema: { type: "object" },
+            ttlSeconds: null,
+          },
+        ],
+        mcpServers: [
+          {
+            exportId: "mcp_1",
+            name: "Search",
+            enabled: true,
+            transport: McpServerTransport.http,
+            url: "https://mcp.example.com",
+            command: null,
+            args: null,
+            cwd: null,
+            credentialExportId: "cred_1",
+          },
+        ],
+        credentials: [
+          {
+            exportId: "cred_1",
+            name: "Search API",
+            exportedOwnerId: "u_1",
+          },
+        ],
+        contentTypes: [
+          {
+            exportId: "ct_1",
+            name: "Article",
+            schema: { type: "object" },
+          },
+        ],
+        labelGroups: [
+          {
+            exportId: "lg_1",
+            name: "Status",
+          },
+        ],
+        labels: [
+          {
+            exportId: "label_1",
+            title: "Qualified",
+            name: "QUALIFIED",
+            description: null,
+            groupExportId: "lg_1",
+          },
+        ],
+        workflows: [
+          {
+            exportId: "wf_child",
+            workflow: {
+              name: "Child",
+              description: "Called child workflow",
+              type: WorkflowType.conversational,
+              schedule: null,
+              inputSchema: {},
+              layout: {
+                x: 10,
+                y: 20,
+                zoom: 1,
+                direction: "horizontal",
+              },
+            },
+            version: {
+              number: 2,
+              checksum: "child-sha",
+              message: "Child version",
+              exportedVersionId: "wfv_child",
+            },
+            definitionYml: "defs: {}\nflow: []\noutputs: {}",
+          },
+        ],
+        knowledgeBases: [
+          {
+            exportId: "kb_1",
+            name: "Docs",
+            config: { index: "docs" },
+          },
+        ],
+      },
+    });
+
+    expect(bundle.resources.credentials[0]).toEqual({
+      exportId: "cred_1",
+      name: "Search API",
+      exportedOwnerId: "u_1",
+    });
+    expect(bundle.workflow.exportId).toBe("wf_1");
+    expect(bundle.resources.contentTypes[0]?.name).toBe("Article");
+    expect(bundle.resources.labelGroups[0]?.name).toBe("Status");
+    expect(bundle.resources.labels[0]).toMatchObject({
+      exportId: "label_1",
+      groupExportId: "lg_1",
+    });
+    expect(bundle.resources.workflows[0]).toMatchObject({
+      exportId: "wf_child",
+      workflow: { name: "Child" },
+      version: { exportedVersionId: "wfv_child" },
+    });
+    expect(bundle.resources.knowledgeBases).toEqual([
+      {
+        exportId: "kb_1",
+        name: "Docs",
+        config: { index: "docs" },
+      },
+    ]);
+  });
+
+  it("defaults new workflow bundle resource arrays for older bundles", () => {
+    const bundle = workflowExportBundleSchema.parse({
+      kind: "hexabot.workflow.bundle",
+      schemaVersion: 1,
+      exportedAt: now,
+      workflow: {
+        name: "Main",
+        description: null,
+        type: WorkflowType.conversational,
+        schedule: null,
+        inputSchema: {},
+        layout: {
+          x: 0,
+          y: 0,
+          zoom: 1,
+          direction: "horizontal",
+        },
+      },
+      version: {
+        number: 1,
+        checksum: "sha",
+        message: null,
+        exportedVersionId: "wfv_1",
+      },
+      definitionYml: "defs: {}\nflow: []\noutputs: {}",
+      resources: {
+        memoryDefinitions: [],
+        mcpServers: [],
+        credentials: [],
+      },
+    });
+
+    expect(bundle.resources.contentTypes).toEqual([]);
+    expect(bundle.resources.labelGroups).toEqual([]);
+    expect(bundle.resources.labels).toEqual([]);
+    expect(bundle.resources.workflows).toEqual([]);
+  });
+
+  it("rejects non-array custom workflow bundle resource buckets", () => {
+    expect(() =>
+      workflowExportBundleV1Schema.parse({
+        kind: "hexabot.workflow.bundle",
+        schemaVersion: 1,
+        exportedAt: now,
+        workflow: {
+          name: "Main",
+          description: null,
+          type: WorkflowType.conversational,
+          schedule: null,
+          inputSchema: {},
+          layout: {
+            x: 0,
+            y: 0,
+            zoom: 1,
+            direction: "horizontal",
+          },
+        },
+        version: {
+          number: 1,
+          checksum: "sha",
+          message: null,
+          exportedVersionId: "wfv_1",
+        },
+        definitionYml: "defs: {}\nflow: []\noutputs: {}",
+        resources: {
+          memoryDefinitions: [],
+          mcpServers: [],
+          credentials: [],
+          knowledgeBases: {
+            exportId: "kb_1",
+          },
+        },
+      }),
+    ).toThrow();
+  });
+
+  it("rejects credential values in workflow export bundles", () => {
+    expect(() =>
+      workflowExportBundleV1Schema.parse({
+        kind: "hexabot.workflow.bundle",
+        schemaVersion: 1,
+        exportedAt: now,
+        workflow: {
+          name: "Main",
+          description: null,
+          type: WorkflowType.conversational,
+          schedule: null,
+          inputSchema: {},
+          layout: {
+            x: 0,
+            y: 0,
+            zoom: 1,
+            direction: "horizontal",
+          },
+        },
+        version: {
+          number: 1,
+          checksum: "sha",
+          message: null,
+          exportedVersionId: "wfv_1",
+        },
+        definitionYml: "defs: {}\nflow: []\noutputs: {}",
+        resources: {
+          memoryDefinitions: [],
+          mcpServers: [],
+          credentials: [
+            {
+              exportId: "cred_1",
+              name: "Search API",
+              value: "secret",
+            },
+          ],
+        },
+      }),
+    ).toThrow();
+  });
+
+  it("parses workflow import results", () => {
+    const result = workflowImportResultSchema.parse({
+      workflow: {
+        id: "wf_1",
+        createdAt: now,
+        updatedAt: now,
+        name: "Imported",
+        description: null,
+        type: WorkflowType.conversational,
+        schedule: null,
+        inputSchema: {},
+        builtin: false,
+        x: 0,
+        y: 0,
+        zoom: 1,
+        direction: "horizontal",
+        currentVersion: "wfv_1",
+        publishedVersion: null,
+        createdBy: "u_1",
+        runAfterMs: 0,
+      },
+      resources: [
+        {
+          kind: "knowledgeBase",
+          exportId: "kb_1",
+          localId: "kb_local",
+          name: "Docs",
+          action: "reused",
+        },
+      ],
+      warnings: ["Credential placeholder created."],
+    });
+
+    expect(result.resources[0]?.action).toBe("reused");
+    expect(result.resources[0]?.kind).toBe("knowledgeBase");
+  });
+
   it("computes workflow run duration and mixed triggeredBy coercion", () => {
     const run = workflowRunSchema.parse({
       id: "run_1",
@@ -788,6 +1085,7 @@ describe("@hexabot-ai/types schemas", () => {
       workflowVersionId: "wfv_1",
       triggeredById: "s_1",
       threadId: "t_1",
+      parentRun: "parent_run_1",
       finishedAt: "2026-01-01T00:02:00.000Z",
     });
     const full = workflowRunFullSchema.parse({
@@ -837,10 +1135,23 @@ describe("@hexabot-ai/types schemas", () => {
         avatar: null,
       },
       thread: null,
+      parentRun: {
+        id: "parent_run_1",
+        createdAt: now,
+        updatedAt: now,
+        status: "suspended",
+        context: {},
+        workflowId: "parent_wf_1",
+        workflowVersionId: null,
+        triggeredById: null,
+        parentRun: null,
+      },
     });
 
     expect(run.duration).toBe(120000);
+    expect(run.parentRun).toBe("parent_run_1");
     expect(full.triggeredBy?.id).toBe("s_1");
+    expect(full.parentRun?.workflow).toBe("parent_wf_1");
     expect(typeof resolveRunDurationMs(run)).toBe("number");
   });