@stndrds/schema 1.0.0-alpha.85 → 1.0.0-alpha.87

package/dist/{chunk-HKT7LEYM.mjs → chunk-IFJJT3JZ.mjs}

@@ -1390,6 +1390,9 @@ function isConditionNode(node) {
 function isAssignNode(node) {
   return node.type === "assign";
 }
+function isAINode(node) {
+  return node.type === "ai";
+}
 function isEndNode(node) {
   return node.type === "end";
 }
@@ -1530,6 +1533,47 @@ var assignNodeType = {
 };
 nodeTypeRegistry.register(assignNodeType);
 
+// src/types/workflows/node-types/ai.node-type.ts
+var aiNodeType = {
+  type: "ai",
+  isLinear: true,
+  structural: false,
+  getOutputs(node) {
+    return node.next ? [node.next] : [];
+  },
+  setNext(node, targetId) {
+    return { ...node, next: targetId };
+  },
+  getSlotIds(node) {
+    const slotIds = /* @__PURE__ */ new Set();
+    const action = node.action;
+    if (action.type === "document-generation") {
+      for (const id of action.inputSlotIds) slotIds.add(id);
+      for (const id of action.targetSlotIds) slotIds.add(id);
+    } else if (action.type === "code-execution") {
+      for (const id of action.inputSlotIds ?? []) slotIds.add(id);
+    }
+    return [...slotIds];
+  },
+  validate(node) {
+    const errors = [];
+    if (!node.label) errors.push("AINode must have a label");
+    if (!node.action) errors.push("AINode must have an action");
+    if (!node.next) errors.push("AINode must have a 'next' target");
+    if (node.action?.type === "document-generation") {
+      if (!node.action.templateId) errors.push("Document generation must have a templateId");
+      if (!node.action.inputSlotIds?.length)
+        errors.push("Document generation must have input slots");
+      if (!node.action.targetSlotIds?.length)
+        errors.push("Document generation must have target slots");
+    } else if (node.action?.type === "code-execution") {
+      if (!node.action.code) errors.push("Code execution must have code");
+    }
+    return errors;
+  }
+};
+nodeTypeRegistry.register(aiNodeType);
+
 // src/types/workflows/node-types/end.node-type.ts
 var endNodeType = {
   type: "end",
@@ -1742,14 +1786,15 @@ function isInvitationOrGrantEvent(event) {
 var ZONE_ORDER = ["collect", "actions"];
 var ZONE_CONFIG = {
   collect: { allowedNodeTypes: ["form", "condition"] },
-  actions: { allowedNodeTypes: ["condition", "assign"] }
+  actions: { allowedNodeTypes: ["condition", "assign", "ai"] }
 };
 var TERMINAL_NODE_TYPES = /* @__PURE__ */ new Set(["start", "end"]);
 var NODE_TYPE_ZONE = {
   form: "collect",
   condition: "collect",
   // default — overridden by assignNodeZones logic
-  assign: "actions"
+  assign: "actions",
+  ai: "actions"
 };
 function assignNodeZones(orderedNodes) {
   const result = /* @__PURE__ */ new Map();
@@ -1834,9 +1879,14 @@ var StartNodeSchema = z.object({
   id: z.string().min(1),
   next: z.string().nullish()
 });
+var RelationFieldConfigSchema = z.object({
+  visibleProperties: z.array(z.string()).optional(),
+  allowCreate: z.boolean().optional()
+}).optional();
 var FormFieldRefSchema = z.object({
   slotId: z.string().min(1, "slotId is required"),
-  attribute: z.string().min(1, "attribute is required")
+  attribute: z.string().min(1, "attribute is required"),
+  relationConfig: RelationFieldConfigSchema
 });
 var FlowRowFieldSchema = z.object({
   id: z.string().min(1),
@@ -1844,7 +1894,8 @@ var FlowRowFieldSchema = z.object({
   attribute: z.string().min(1),
   label: z.string().max(200).optional(),
   tooltip: z.string().max(1e3).optional(),
-  required: z.boolean().optional()
+  required: z.boolean().optional(),
+  relationConfig: RelationFieldConfigSchema
 });
 var FlowFieldsRowSchema = z.object({
   id: z.string().min(1),
@@ -1925,6 +1976,35 @@ var AssignNodeSchema = z.object({
   assignments: z.array(AssignmentMappingSchema).min(1),
   next: z.string().nullish()
 });
+var DocumentGenerationActionSchema = z.object({
+  type: z.literal("document-generation"),
+  templateId: z.string().min(1, "Template ID is required"),
+  inputSlotIds: z.array(z.string().min(1)).min(1, "At least one input slot is required"),
+  targetSlotIds: z.array(z.string().min(1)).min(1, "At least one target slot is required"),
+  outputFormat: z.enum(["pdf", "docx"]),
+  aiInstructions: z.string().nullish()
+});
+var CodeExecutionActionSchema = z.object({
+  type: z.literal("code-execution"),
+  code: z.string().min(1, "Code is required"),
+  language: z.enum(["javascript", "typescript", "python"]),
+  inputSlotIds: z.array(z.string().min(1)).optional(),
+  outputVariable: z.string().optional(),
+  packages: z.array(z.string()).optional()
+});
+var AIActionConfigSchema = z.discriminatedUnion("type", [
+  DocumentGenerationActionSchema,
+  CodeExecutionActionSchema
+]);
+var AINodeSchema = z.object({
+  type: z.literal("ai"),
+  id: z.string().min(1),
+  label: z.string().min(1),
+  description: z.string().nullish(),
+  action: AIActionConfigSchema,
+  timeoutMs: z.number().positive().optional(),
+  next: z.string().nullish()
+});
 var EndNodeSchema = z.object({
   type: z.literal("end"),
   id: z.string().min(1),
@@ -1936,6 +2016,7 @@ var WorkflowNodeSchema = z.discriminatedUnion("type", [
   FormNodeSchema,
   ConditionNodeSchema,
   AssignNodeSchema,
+  AINodeSchema,
   EndNodeSchema
 ]);
 var SlotModeSchema = z.enum(["create", "select", "optional"]);
@@ -2899,6 +2980,214 @@ function resolveSource(source, slotValues) {
   }
 }
 
+// src/runtime/executors/ai.executor.ts
+var AIExecutor = class {
+  constructor(actionRegistry) {
+    this.actionRegistry = actionRegistry;
+    this.nodeType = "ai";
+  }
+  async execute(node, ctx) {
+    if (!node.next) {
+      return error("MISSING_NEXT", "AINode must have a 'next' target");
+    }
+    const handler = this.actionRegistry.get(node.action.type);
+    if (!handler) {
+      return error(
+        "UNKNOWN_AI_ACTION",
+        `No handler registered for AI action type: ${node.action.type}`
+      );
+    }
+    const result = await handler.execute(node.action, ctx);
+    if (!result.success) {
+      return error("AI_ACTION_FAILED", result.error ?? "AI action failed", true);
+    }
+    return success(node.next, result.contextUpdates);
+  }
+  validate(node) {
+    const errors = [];
+    if (!node.label) errors.push("AINode must have a label");
+    if (!node.action) errors.push("AINode must have an action");
+    if (!node.next) errors.push("AINode must have a 'next' target");
+    return errors;
+  }
+};
+
+// src/runtime/executors/ai-actions/types.ts
+var AIActionRegistry = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  register(handler) {
+    this.handlers.set(handler.actionType, handler);
+  }
+  get(actionType) {
+    return this.handlers.get(actionType);
+  }
+  has(actionType) {
+    return this.handlers.has(actionType);
+  }
+};
+
+// src/runtime/executors/ai-actions/document-generation.handler.ts
+var DocumentGenerationHandler = class {
+  constructor(deps = null) {
+    this.deps = deps;
+    this.actionType = "document-generation";
+  }
+  async execute(action, ctx) {
+    if (!this.deps) {
+      return {
+        success: false,
+        error: "Document generation not configured. Provide sandbox, fileService, and storage in SchemaModule."
+      };
+    }
+    const { sandbox, fileService, storage } = this.deps;
+    const file2 = await fileService.getFile(action.templateId);
+    if (!file2) {
+      return {
+        success: false,
+        error: `Template file not found: ${action.templateId}`
+      };
+    }
+    if (!storage.download) {
+      return {
+        success: false,
+        error: "StorageAdapter.download() not implemented. Required for document generation."
+      };
+    }
+    let templateContent;
+    try {
+      const buffer = await storage.download(file2.storagePath);
+      templateContent = new Uint8Array(buffer);
+    } catch (err) {
+      return {
+        success: false,
+        error: `Failed to download template "${file2.name}": ${err instanceof Error ? err.message : "unknown error"}`
+      };
+    }
+    const slotData = {};
+    for (const slotId of action.inputSlotIds) {
+      slotData[slotId] = ctx.executionContext.slots[slotId] ?? {};
+    }
+    const instructions = [
+      "Generate a professional document based on the provided template and data.",
+      action.aiInstructions ?? "",
+      "",
+      "## Data Context",
+      "```json",
+      JSON.stringify(slotData, null, 2),
+      "```",
+      "",
+      "## Instructions",
+      "1. Unpack the template: python3 /workspace/scripts/office/unpack.py /workspace/template.docx /workspace/unpacked/",
+      "2. Analyze the XML structure in /workspace/unpacked/word/document.xml",
+      "3. Read the data from /workspace/data.json",
+      "4. Modify the XML content using the provided data \u2014 replace placeholders, fill tables, update fields",
+      "5. Pack: python3 /workspace/scripts/office/pack.py /workspace/unpacked/ /workspace/output.docx",
+      "6. Validate: python3 /workspace/scripts/office/validate.py /workspace/output.docx",
+      action.outputFormat === "pdf" ? "7. Convert to PDF: python3 /workspace/scripts/office/convert.py /workspace/output.docx pdf /workspace/" : ""
+    ].filter(Boolean).join("\n");
+    const outputPath = action.outputFormat === "pdf" ? "/workspace/output.pdf" : "/workspace/output.docx";
+    try {
+      const result = await sandbox.executeAgent({
+        instructions,
+        template: "stndrds-pdf",
+        inputFiles: [
+          {
+            path: "/workspace/template.docx",
+            content: templateContent
+          },
+          {
+            path: "/workspace/data.json",
+            content: JSON.stringify(slotData, null, 2)
+          }
+        ],
+        expectedOutputs: [outputPath],
+        timeoutMs: 6e5,
+        maxIterations: 20
+      });
+      if (!result.success || result.artifacts.length === 0) {
+        return {
+          success: false,
+          error: result.summary ?? "Agent failed to generate document"
+        };
+      }
+      const contextUpdates = {};
+      for (const slotId of action.targetSlotIds) {
+        contextUpdates[slotId] = {
+          ...ctx.executionContext.slots[slotId] ?? {},
+          _generatedDocuments: result.artifacts.map((a) => ({
+            path: a.path,
+            mimeType: a.mimeType
+          }))
+        };
+      }
+      return { success: true, contextUpdates };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Document generation failed"
+      };
+    }
+  }
+};
+
+// src/runtime/executors/ai-actions/code-execution.handler.ts
+var CodeExecutionHandler = class {
+  constructor(sandbox = null) {
+    this.sandbox = sandbox;
+    this.actionType = "code-execution";
+  }
+  async execute(action, ctx) {
+    if (!this.sandbox) {
+      return {
+        success: false,
+        error: "Code execution handler not configured. Inject a SandboxExecutor via constructor."
+      };
+    }
+    const env = {};
+    for (const slotId of action.inputSlotIds ?? []) {
+      const slotData = ctx.executionContext.slots[slotId] ?? {};
+      env[`SLOT_${slotId.toUpperCase()}`] = JSON.stringify(slotData);
+    }
+    try {
+      const result = await this.sandbox.executeCode({
+        code: action.code,
+        language: action.language,
+        env,
+        packages: action.packages,
+        timeoutMs: 3e4
+        // 30s for code mode
+      });
+      if (result.exitCode !== 0) {
+        return {
+          success: false,
+          error: `Code execution failed (exit ${result.exitCode}): ${result.stderr}`
+        };
+      }
+      const contextUpdates = {};
+      if (action.outputVariable) {
+        contextUpdates[action.outputVariable] = result.stdout.trim();
+      }
+      return { success: true, contextUpdates };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Code execution failed"
+      };
+    }
+  }
+};
+
+// src/runtime/executors/ai-actions/index.ts
+function createDefaultAIActionRegistry(deps) {
+  const registry2 = new AIActionRegistry();
+  const docGenDeps = deps?.sandbox && deps?.fileService && deps?.storage ? { sandbox: deps.sandbox, fileService: deps.fileService, storage: deps.storage } : null;
+  registry2.register(new DocumentGenerationHandler(docGenDeps));
+  registry2.register(new CodeExecutionHandler(deps?.sandbox ?? null));
+  return registry2;
+}
+
 // src/runtime/executors/start.executor.ts
 var StartExecutor = class {
   constructor() {
@@ -7898,7 +8187,10 @@ var ListViewBuilder = class {
         groupByAttribute: tab.groupByAttribute,
         cardUserAttribute: tab.cardUserAttribute,
         cardDateAttribute: tab.cardDateAttribute,
-        createMode: tab.createMode
+        createMode: tab.createMode,
+        kanbanColumnOrder: tab.kanbanColumnOrder,
+        kanbanColumnVisibility: tab.kanbanColumnVisibility,
+        kanbanPinnedColumns: tab.kanbanPinnedColumns
       }))
     };
     return {
@@ -7987,6 +8279,34 @@ var ListViewTabConfigBuilder = class _ListViewTabConfigBuilder {
     this.tabData.cardDateAttribute = attributeName;
     return this;
   }
+  /**
+   * Set the order of kanban columns by option values (for kanban layout only)
+   * @param order - Array of option values in desired order
+   * @example .kanbanColumnOrder(["new", "in_progress", "done"])
+   */
+  kanbanColumnOrder(order) {
+    this.tabData.kanbanColumnOrder = order;
+    return this;
+  }
+  /**
+   * Set the visibility of kanban columns by option values (for kanban layout only)
+   * @param visibility - Record mapping option values to visibility (true = visible, false = hidden)
+   * @example .kanbanColumnVisibility({ "new": true, "archived": false })
+   */
+  kanbanColumnVisibility(visibility) {
+    this.tabData.kanbanColumnVisibility = visibility;
+    return this;
+  }
+  /**
+   * Set pinned kanban columns by option values (for kanban layout only)
+   * Pinned columns remain fixed during horizontal scrolling
+   * @param pinnedColumns - Array of option values to pin
+   * @example .kanbanPinnedColumns(["new", "done"])
+   */
+  kanbanPinnedColumns(pinnedColumns) {
+    this.tabData.kanbanPinnedColumns = pinnedColumns;
+    return this;
+  }
   /**
    * Set creation behavior when clicking "+"
    * @param mode - "redirect" (navigate to detail), "inline" (empty row), or "modal" (stacked modal)
@@ -8103,12 +8423,55 @@ var WorkflowFormRowBuilder = class {
     this.rowData.fields.push(field);
     return this;
   }
+  /**
+   * Add a relation field to the current row.
+   * Use this for relation attributes that need specific configuration
+   * (e.g., which qualified properties to display).
+   *
+   * @param slotId - The slot containing the relation attribute
+   * @param attribute - The relation attribute name
+   * @param options - Optional label, required flag, and relation config
+   */
+  relationField(slotId, attribute, options) {
+    const relationConfig = options?.visibleProperties || options?.allowCreate !== void 0 ? {
+      visibleProperties: options?.visibleProperties,
+      allowCreate: options?.allowCreate
+    } : void 0;
+    const field = {
+      id: `${this.rowData.id}-${slotId}-${attribute}`,
+      slotId,
+      attribute,
+      label: options?.label,
+      required: options?.required,
+      relationConfig
+    };
+    this.rowData.fields.push(field);
+    return this;
+  }
   /**
    * Start a new row
    */
   row(id) {
     return this.formBuilder._finalizeRow(this.rowData).row(id);
   }
+  /**
+   * Add a heading row (finalizes the current field row first)
+   */
+  heading(content, level) {
+    return this.formBuilder._finalizeRow(this.rowData).heading(content, level);
+  }
+  /**
+   * Add a visual separator (finalizes the current field row first)
+   */
+  separator() {
+    return this.formBuilder._finalizeRow(this.rowData).separator();
+  }
+  /**
+   * Add a static text row (finalizes the current field row first)
+   */
+  text(content) {
+    return this.formBuilder._finalizeRow(this.rowData).text(content);
+  }
   /**
    * Set the next node and finish this form
    */
@@ -8139,13 +8502,56 @@ var WorkflowFormBuilder = class {
     this.rowOrder++;
     return new WorkflowFormRowBuilder(this, id, this.rowOrder);
   }
+  /**
+   * Add a heading row to the form
+   */
+  heading(content, level) {
+    this.rowOrder++;
+    const row = {
+      id: `heading-${this.rowOrder}`,
+      order: this.rowOrder,
+      type: "heading",
+      content,
+      level
+    };
+    this.rows.push(row);
+    return this;
+  }
+  /**
+   * Add a visual separator row to the form
+   */
+  separator() {
+    this.rowOrder++;
+    const row = {
+      id: `separator-${this.rowOrder}`,
+      order: this.rowOrder,
+      type: "separator"
+    };
+    this.rows.push(row);
+    return this;
+  }
+  /**
+   * Add a static text row to the form
+   */
+  text(content) {
+    this.rowOrder++;
+    const row = {
+      id: `text-${this.rowOrder}`,
+      order: this.rowOrder,
+      type: "text",
+      content
+    };
+    this.rows.push(row);
+    return this;
+  }
   /**
    * Set the next node and complete the form definition
    */
   next(nodeId) {
-    if (this.rows.length === 0) {
+    const hasFieldRows = this.rows.some((r) => !r.type || r.type === "fields");
+    if (!hasFieldRows) {
       throw new Error(
-        `[WorkflowBuilder] Form "${this.nodeId}" has no rows. Use .row() to add rows.`
+        `[WorkflowBuilder] Form "${this.nodeId}" has no field rows. Use .row() to add fields.`
       );
     }
     return this.workflowBuilder._addFormNode({
@@ -8196,6 +8602,22 @@ var WorkflowSimpleFormBuilder = class {
     }
     return this;
   }
+  /**
+   * Add a relation field with optional configuration.
+   * Use this for relation attributes that need specific configuration
+   * (e.g., which qualified properties to display).
+   */
+  relationField(slotId, attribute, options) {
+    this.fieldList.push({
+      slotId,
+      attribute,
+      relationConfig: options ? {
+        visibleProperties: options.visibleProperties,
+        allowCreate: options.allowCreate
+      } : void 0
+    });
+    return this;
+  }
   /**
    * Set the next node and complete the form definition
    */
@@ -8337,6 +8759,68 @@ var WorkflowAssignBuilder = class {
     });
   }
 };
+var WorkflowAIBuilder = class {
+  /** @internal */
+  constructor(workflowBuilder, nodeId, label) {
+    this.action = null;
+    this.workflowBuilder = workflowBuilder;
+    this.nodeId = nodeId;
+    this.label = label;
+  }
+  /**
+   * Set the description for this AI node
+   */
+  describe(description) {
+    this.nodeDescription = description;
+    return this;
+  }
+  /**
+   * Set a custom timeout (default: 120_000ms)
+   */
+  timeout(ms) {
+    this.nodeTimeoutMs = ms;
+    return this;
+  }
+  /**
+   * Configure document generation action
+   */
+  documentGeneration(config) {
+    this.action = {
+      type: "document-generation",
+      ...config
+    };
+    return this;
+  }
+  /**
+   * Configure code execution action
+   */
+  codeExecution(config) {
+    this.action = {
+      type: "code-execution",
+      ...config
+    };
+    return this;
+  }
+  /**
+   * Set the next node and complete the AI node definition
+   */
+  next(nodeId) {
+    if (!this.action) {
+      throw new Error(
+        `[WorkflowBuilder] AI node "${this.nodeId}" must have an action. Use .documentGeneration() or .codeExecution() first.`
+      );
+    }
+    return this.workflowBuilder._addNode({
+      type: "ai",
+      id: this.nodeId,
+      label: this.label,
+      description: this.nodeDescription,
+      action: this.action,
+      timeoutMs: this.nodeTimeoutMs,
+      next: nodeId
+    });
+  }
+};
 var WorkflowEndBuilder = class {
   /** @internal */
   constructor(workflowBuilder, nodeId) {
@@ -8508,6 +8992,12 @@ var WorkflowBuilder = class {
   assign(id, label, targetSlotId) {
     return new WorkflowAssignBuilder(this, id, label, targetSlotId);
   }
+  /**
+   * Define an AI node (run an AI action like document generation or code execution)
+   */
+  ai(id, label) {
+    return new WorkflowAIBuilder(this, id, label);
+  }
   /**
    * Define an end node
    */
@@ -13630,7 +14120,7 @@ var WorkflowInstanceService = class extends BaseService {
    * Start a new workflow instance
    */
   async startWorkflow(input) {
-    const workflow2 = await this.workflowService.getWorkflow(input.workflowName);
+    let workflow2 = await this.workflowService.getWorkflow(input.workflowName);
     if (!workflow2) {
       throw new SchemaError(
         `Workflow "${input.workflowName}" not found`,
@@ -13643,6 +14133,20 @@ var WorkflowInstanceService = class extends BaseService {
         SchemaErrorCode.VALIDATION_FAILED
       );
     }
+    if (workflow2.system && this.adapter.workflows) {
+      const dbWorkflow = await this.adapter.workflows.upsert({
+        name: workflow2.name,
+        label: workflow2.label ?? workflow2.name,
+        description: workflow2.description,
+        status: "published",
+        version: workflow2.version,
+        slots: workflow2.slots ?? [],
+        nodes: workflow2.nodes,
+        startNodeId: workflow2.startNodeId,
+        system: true
+      });
+      workflow2 = { ...workflow2, id: dbWorkflow.id };
+    }
     const context = createEmptyContext();
     if (input.initialSlots) {
       for (const [slotId, data] of Object.entries(input.initialSlots)) {
@@ -17060,6 +17564,74 @@ var PermissionService = class extends BaseService {
   // ============================================================================
   // INITIALIZATION
   // ============================================================================
+  /**
+   * Reset all roles and permissions to their default configuration.
+   *
+   * This will:
+   * 1. Delete all custom (non-system) roles and reassign their users to the default member role
+   * 2. Reset permissions on the default roles (owner, member) back to defaults
+   * 3. Invalidate all permission caches
+   *
+   * @example
+   * ```typescript
+   * const service = new PermissionService(adapter);
+   * await service.resetToDefaults();
+   * ```
+   */
+  async resetToDefaults() {
+    const { DEFAULT_ROLES, DEFAULT_ROLE_PERMISSIONS } = await import("./default-roles-6D3HQ3DQ.mjs");
+    await this.initializeDefaultRoles();
+    const allRoles = await this.getRoles();
+    const memberRole = allRoles.find((r) => r.name === DEFAULT_ROLES.MEMBER);
+    if (!memberRole) {
+      throw new Error("Default member role not found after initialization");
+    }
+    const customRoles = allRoles.filter(
+      (r) => !Object.values(DEFAULT_ROLES).includes(
+        r.name
+      )
+    );
+    for (const role of customRoles) {
+      const usersWithRole = await this.permissionsRepo.countUsersWithRole(role.name);
+      if (usersWithRole > 0) {
+      }
+      await this.permissionsRepo.deleteRole(role.id);
+    }
+    for (const roleName of Object.values(DEFAULT_ROLES)) {
+      const role = allRoles.find((r) => r.name === roleName);
+      if (!role) continue;
+      const permConfig = DEFAULT_ROLE_PERMISSIONS[roleName];
+      const permissionInputs = [];
+      for (const perm of permConfig.system) {
+        permissionInputs.push({
+          scope: "system",
+          target: perm.target,
+          actions: perm.actions
+        });
+      }
+      for (const perm of permConfig.object) {
+        permissionInputs.push({
+          scope: "object",
+          target: perm.target,
+          actions: perm.actions
+        });
+      }
+      await this.permissionsRepo.setPermissions(role.id, permissionInputs);
+    }
+    await this.invalidateAllCache();
+    if (this.auditService && this.userId) {
+      await this.auditService.logRoleAction({
+        action: "role.updated",
+        actorId: this.userId,
+        roleId: "all",
+        roleLabel: "All roles",
+        metadata: {
+          resetToDefaults: true,
+          customRolesDeleted: customRoles.length
+        }
+      });
+    }
+  }
   /**
    * Initialize default roles for the tenant if they don't exist.
    *
@@ -18136,6 +18708,7 @@ export {
   isFormNode,
   isConditionNode,
   isAssignNode,
+  isAINode,
   isEndNode,
   isConditionRule,
   isConditionGroup,
@@ -18186,6 +18759,10 @@ export {
   AssignmentSourceSchema,
   AssignmentMappingSchema,
   AssignNodeSchema,
+  DocumentGenerationActionSchema,
+  CodeExecutionActionSchema,
+  AIActionConfigSchema,
+  AINodeSchema,
   EndNodeSchema,
   WorkflowNodeSchema,
   SlotModeSchema,
@@ -18283,6 +18860,7 @@ export {
   WorkflowSimpleFormBuilder,
   WorkflowConditionBuilder,
   WorkflowAssignBuilder,
+  WorkflowAIBuilder,
   WorkflowEndBuilder,
   WorkflowStartBuilder,
   WorkflowBuilder,
@@ -18336,6 +18914,11 @@ export {
   EndExecutor,
   FormExecutor,
   AssignExecutor,
+  AIExecutor,
+  AIActionRegistry,
+  DocumentGenerationHandler,
+  CodeExecutionHandler,
+  createDefaultAIActionRegistry,
   StartExecutor,
   createDefaultExecutorRegistry,
   getDefaultExecutorRegistry,