diff --git a/api/controllers/console/app/generator.py b/api/controllers/console/app/generator.py index 1ac55b5e8d..d398997ccf 100644 --- a/api/controllers/console/app/generator.py +++ b/api/controllers/console/app/generator.py @@ -1,4 +1,5 @@ from collections.abc import Sequence +from typing import Any from flask_restx import Resource from pydantic import BaseModel, Field @@ -19,6 +20,7 @@ from core.helper.code_executor.python3.python3_code_provider import Python3CodeP from core.llm_generator.entities import RuleCodeGeneratePayload, RuleGeneratePayload, RuleStructuredOutputPayload from core.llm_generator.llm_generator import LLMGenerator from core.model_runtime.errors.invoke import InvokeError +from core.workflow.generator import WorkflowGenerator from extensions.ext_database import db from libs.login import current_account_with_tenant, login_required from models import App @@ -41,6 +43,30 @@ class InstructionTemplatePayload(BaseModel): type: str = Field(..., description="Instruction template type") +class PreviousWorkflow(BaseModel): + """Previous workflow attempt for regeneration context.""" + + nodes: list[dict[str, Any]] = Field(default_factory=list, description="Previously generated nodes") + edges: list[dict[str, Any]] = Field(default_factory=list, description="Previously generated edges") + warnings: list[str] = Field(default_factory=list, description="Warnings from previous generation") + + +class FlowchartGeneratePayload(BaseModel): + instruction: str = Field(..., description="Workflow flowchart generation instruction") + model_config_data: dict[str, Any] = Field(..., alias="model_config", description="Model configuration") + available_nodes: list[dict[str, Any]] = Field(default_factory=list, description="Available node types") + existing_nodes: list[dict[str, Any]] = Field(default_factory=list, description="Existing workflow nodes") + existing_edges: list[dict[str, Any]] = Field(default_factory=list, description="Existing workflow edges") + available_tools: list[dict[str, Any]] = Field(default_factory=list, description="Available tools") + selected_node_ids: list[str] = Field(default_factory=list, description="IDs of selected nodes for context") + previous_workflow: PreviousWorkflow | None = Field(default=None, description="Previous workflow for regeneration") + regenerate_mode: bool = Field(default=False, description="Whether this is a regeneration request") + # Language preference for generated content (node titles, descriptions) + language: str | None = Field(default=None, description="Preferred language for generated content") + # Available models that user has configured (for LLM/question-classifier nodes) + available_models: list[dict[str, Any]] = Field(default_factory=list, description="User's configured models") + + def reg(cls: type[BaseModel]): console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)) @@ -50,6 +76,7 @@ reg(RuleCodeGeneratePayload) reg(RuleStructuredOutputPayload) reg(InstructionGeneratePayload) reg(InstructionTemplatePayload) +reg(FlowchartGeneratePayload) reg(ModelConfig) @@ -240,6 +267,52 @@ class InstructionGenerateApi(Resource): raise CompletionRequestError(e.description) +@console_ns.route("/flowchart-generate") +class FlowchartGenerateApi(Resource): + @console_ns.doc("generate_workflow_flowchart") + @console_ns.doc(description="Generate workflow flowchart using LLM with intent classification") + @console_ns.expect(console_ns.models[FlowchartGeneratePayload.__name__]) + @console_ns.response(200, "Flowchart generated successfully") + @console_ns.response(400, "Invalid request parameters") + @console_ns.response(402, "Provider quota exceeded") + @setup_required + @login_required + @account_initialization_required + def post(self): + args = FlowchartGeneratePayload.model_validate(console_ns.payload) + _, current_tenant_id = current_account_with_tenant() + + try: + # Convert PreviousWorkflow to dict if present + previous_workflow_dict = args.previous_workflow.model_dump() if args.previous_workflow else None + + result = WorkflowGenerator.generate_workflow_flowchart( + tenant_id=current_tenant_id, + instruction=args.instruction, + model_config=args.model_config_data, + available_nodes=args.available_nodes, + existing_nodes=args.existing_nodes, + existing_edges=args.existing_edges, + available_tools=args.available_tools, + selected_node_ids=args.selected_node_ids, + previous_workflow=previous_workflow_dict, + regenerate_mode=args.regenerate_mode, + preferred_language=args.language, + available_models=args.available_models, + ) + + except ProviderTokenNotInitError as ex: + raise ProviderNotInitializeError(ex.description) + except QuotaExceededError: + raise ProviderQuotaExceededError() + except ModelCurrentlyNotSupportError: + raise ProviderModelCurrentlyNotSupportError() + except InvokeError as e: + raise CompletionRequestError(e.description) + + return result + + @console_ns.route("/instruction-generate/template") class InstructionGenerationTemplateApi(Resource): @console_ns.doc("get_instruction_template") diff --git a/api/core/workflow/generator/__init__.py b/api/core/workflow/generator/__init__.py new file mode 100644 index 0000000000..2b722441a9 --- /dev/null +++ b/api/core/workflow/generator/__init__.py @@ -0,0 +1 @@ +from .runner import WorkflowGenerator diff --git a/api/core/workflow/generator/config/__init__.py b/api/core/workflow/generator/config/__init__.py new file mode 100644 index 0000000000..b7f6d1d3e9 --- /dev/null +++ b/api/core/workflow/generator/config/__init__.py @@ -0,0 +1,29 @@ +""" +Vibe Workflow Generator Configuration Module. + +This module centralizes configuration for the Vibe workflow generation feature, +including node schemas, fallback rules, and response templates. +""" + +from core.workflow.generator.config.node_schemas import ( + BUILTIN_NODE_SCHEMAS, + FALLBACK_RULES, + FIELD_NAME_CORRECTIONS, + NODE_TYPE_ALIASES, + get_builtin_node_schemas, + get_corrected_field_name, + validate_node_schemas, +) +from core.workflow.generator.config.responses import DEFAULT_SUGGESTIONS, OFF_TOPIC_RESPONSES + +__all__ = [ + "BUILTIN_NODE_SCHEMAS", + "DEFAULT_SUGGESTIONS", + "FALLBACK_RULES", + "FIELD_NAME_CORRECTIONS", + "NODE_TYPE_ALIASES", + "OFF_TOPIC_RESPONSES", + "get_builtin_node_schemas", + "get_corrected_field_name", + "validate_node_schemas", +] diff --git a/api/core/workflow/generator/config/node_schemas.py b/api/core/workflow/generator/config/node_schemas.py new file mode 100644 index 0000000000..e4980cd4c3 --- /dev/null +++ b/api/core/workflow/generator/config/node_schemas.py @@ -0,0 +1,501 @@ +""" +Unified Node Configuration for Vibe Workflow Generation. + +This module centralizes all node-related configuration: +- Node schemas (parameter definitions) +- Fallback rules (keyword-based node type inference) +- Node type aliases (natural language to canonical type mapping) +- Field name corrections (LLM output normalization) +- Validation utilities + +Note: These definitions are the single source of truth. +Frontend has a mirrored copy at web/app/components/workflow/hooks/use-workflow-vibe-config.ts +""" + +from typing import Any + +# ============================================================================= +# NODE SCHEMAS +# ============================================================================= + +# Built-in node schemas with parameter definitions +# These help the model understand what config each node type requires +_HARDCODED_SCHEMAS: dict[str, dict[str, Any]] = { + "http-request": { + "description": "Send HTTP requests to external APIs or fetch web content", + "required": ["url", "method"], + "parameters": { + "url": { + "type": "string", + "description": "Full URL including protocol (https://...)", + "example": "{{#start.url#}} or https://api.example.com/data", + }, + "method": { + "type": "enum", + "options": ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"], + "description": "HTTP method", + }, + "headers": { + "type": "string", + "description": "HTTP headers as newline-separated 'Key: Value' pairs", + "example": "Content-Type: application/json\nAuthorization: Bearer {{#start.api_key#}}", + }, + "params": { + "type": "string", + "description": "URL query parameters as newline-separated 'key: value' pairs", + }, + "body": { + "type": "object", + "description": "Request body with type field required", + "example": {"type": "none", "data": []}, + }, + "authorization": { + "type": "object", + "description": "Authorization config", + "example": {"type": "no-auth"}, + }, + "timeout": { + "type": "number", + "description": "Request timeout in seconds", + "default": 60, + }, + }, + "outputs": ["body (response content)", "status_code", "headers"], + }, + "code": { + "description": "Execute Python or JavaScript code for custom logic", + "required": ["code", "language"], + "parameters": { + "code": { + "type": "string", + "description": "Code to execute. Must define a main() function that returns a dict.", + }, + "language": { + "type": "enum", + "options": ["python3", "javascript"], + }, + "variables": { + "type": "array", + "description": "Input variables passed to the code", + "item_schema": {"variable": "string", "value_selector": "array"}, + }, + "outputs": { + "type": "object", + "description": "Output variable definitions", + }, + }, + "outputs": ["Variables defined in outputs schema"], + }, + "llm": { + "description": "Call a large language model for text generation/processing", + "required": ["prompt_template"], + "parameters": { + "model": { + "type": "object", + "description": "Model configuration (provider, name, mode)", + }, + "prompt_template": { + "type": "array", + "description": "Messages for the LLM", + "item_schema": { + "role": "enum: system, user, assistant", + "text": "string - message content, can include {{#node_id.field#}} references", + }, + }, + "context": { + "type": "object", + "description": "Optional context settings", + }, + "memory": { + "type": "object", + "description": "Optional memory/conversation settings", + }, + }, + "outputs": ["text (generated response)"], + }, + "if-else": { + "description": "Conditional branching based on conditions", + "required": ["cases"], + "parameters": { + "cases": { + "type": "array", + "description": "List of condition cases. Each case defines when 'true' branch is taken.", + "item_schema": { + "case_id": "string - unique case identifier (e.g., 'case_1')", + "logical_operator": "enum: and, or - how multiple conditions combine", + "conditions": { + "type": "array", + "item_schema": { + "variable_selector": "array of strings - path to variable, e.g. ['node_id', 'field']", + "comparison_operator": ( + "enum: =, ≠, >, <, ≥, ≤, contains, not contains, is, is not, empty, not empty" + ), + "value": "string or number - value to compare against", + }, + }, + }, + }, + }, + "outputs": ["Branches: true (first case conditions met), false (else/no case matched)"], + }, + "knowledge-retrieval": { + "description": "Query knowledge base for relevant content", + "required": ["query_variable_selector", "dataset_ids"], + "parameters": { + "query_variable_selector": { + "type": "array", + "description": "Path to query variable, e.g. ['start', 'query']", + }, + "dataset_ids": { + "type": "array", + "description": "List of knowledge base IDs to search", + }, + "retrieval_mode": { + "type": "enum", + "options": ["single", "multiple"], + }, + }, + "outputs": ["result (retrieved documents)"], + }, + "template-transform": { + "description": "Transform data using Jinja2 templates", + "required": ["template", "variables"], + "parameters": { + "template": { + "type": "string", + "description": "Jinja2 template string. Use {{ variable_name }} to reference variables.", + }, + "variables": { + "type": "array", + "description": "Input variables defined for the template", + "item_schema": { + "variable": "string - variable name to use in template", + "value_selector": "array - path to source value, e.g. ['start', 'user_input']", + }, + }, + }, + "outputs": ["output (transformed string)"], + }, + "variable-aggregator": { + "description": "Aggregate variables from multiple branches", + "required": ["variables"], + "parameters": { + "variables": { + "type": "array", + "description": "List of variable selectors to aggregate", + "item_schema": "array of strings - path to source variable, e.g. ['node_id', 'field']", + }, + }, + "outputs": ["output (aggregated value)"], + }, + "iteration": { + "description": "Loop over array items", + "required": ["iterator_selector"], + "parameters": { + "iterator_selector": { + "type": "array", + "description": "Path to array variable to iterate", + }, + }, + "outputs": ["item (current iteration item)", "index (current index)"], + }, + "parameter-extractor": { + "description": "Extract structured parameters from user input using LLM", + "required": ["query", "parameters"], + "parameters": { + "model": { + "type": "object", + "description": "Model configuration (provider, name, mode)", + }, + "query": { + "type": "array", + "description": "Path to input text to extract parameters from, e.g. ['start', 'user_input']", + }, + "parameters": { + "type": "array", + "description": "Parameters to extract from the input", + "item_schema": { + "name": "string - parameter name (required)", + "type": ( + "enum: string, number, boolean, array[string], array[number], array[object], array[boolean]" + ), + "description": "string - description of what to extract (required)", + "required": "boolean - whether this parameter is required (MUST be specified)", + "options": "array of strings (optional) - for enum-like selection", + }, + }, + "instruction": { + "type": "string", + "description": "Additional instructions for extraction", + }, + "reasoning_mode": { + "type": "enum", + "options": ["function_call", "prompt"], + "description": "How to perform extraction (defaults to function_call)", + }, + }, + "outputs": ["Extracted parameters as defined in parameters array", "__is_success", "__reason"], + }, + "question-classifier": { + "description": "Classify user input into predefined categories using LLM", + "required": ["query", "classes"], + "parameters": { + "model": { + "type": "object", + "description": "Model configuration (provider, name, mode)", + }, + "query": { + "type": "array", + "description": "Path to input text to classify, e.g. ['start', 'user_input']", + }, + "classes": { + "type": "array", + "description": "Classification categories", + "item_schema": { + "id": "string - unique class identifier", + "name": "string - class name/label", + }, + }, + "instruction": { + "type": "string", + "description": "Additional instructions for classification", + }, + }, + "outputs": ["class_name (selected class)"], + }, +} + + +def _get_dynamic_schemas() -> dict[str, dict[str, Any]]: + """ + Dynamically load schemas from node classes. + Uses lazy import to avoid circular dependency. + """ + from core.workflow.nodes.node_mapping import LATEST_VERSION, NODE_TYPE_CLASSES_MAPPING + + schemas = {} + for node_type, version_map in NODE_TYPE_CLASSES_MAPPING.items(): + # Get the latest version class + node_cls = version_map.get(LATEST_VERSION) + if not node_cls: + continue + + # Get schema from the class + schema = node_cls.get_default_config_schema() + if schema: + schemas[node_type.value] = schema + + return schemas + + +# Cache for built-in schemas (populated on first access) +_builtin_schemas_cache: dict[str, dict[str, Any]] | None = None + + +def get_builtin_node_schemas() -> dict[str, dict[str, Any]]: + """ + Get the complete set of built-in node schemas. + Combines hardcoded schemas with dynamically loaded ones. + Results are cached after first call. + """ + global _builtin_schemas_cache + if _builtin_schemas_cache is None: + _builtin_schemas_cache = {**_HARDCODED_SCHEMAS, **_get_dynamic_schemas()} + return _builtin_schemas_cache + + +# For backward compatibility - but use get_builtin_node_schemas() for lazy loading +BUILTIN_NODE_SCHEMAS: dict[str, dict[str, Any]] = _HARDCODED_SCHEMAS.copy() + + +# ============================================================================= +# FALLBACK RULES +# ============================================================================= + +# Keyword rules for smart fallback detection +# Maps node type to keywords that suggest using that node type as a fallback +FALLBACK_RULES: dict[str, list[str]] = { + "http-request": [ + "http", + "url", + "web", + "scrape", + "scraper", + "fetch", + "api", + "request", + "download", + "upload", + "webhook", + "endpoint", + "rest", + "get", + "post", + ], + "code": [ + "code", + "script", + "calculate", + "compute", + "process", + "transform", + "parse", + "convert", + "format", + "filter", + "sort", + "math", + "logic", + ], + "llm": [ + "analyze", + "summarize", + "summary", + "extract", + "classify", + "translate", + "generate", + "write", + "rewrite", + "explain", + "answer", + "chat", + ], +} + + +# ============================================================================= +# NODE TYPE ALIASES +# ============================================================================= + +# Node type aliases for inference from natural language +# Maps common terms to canonical node type names +NODE_TYPE_ALIASES: dict[str, str] = { + # Start node aliases + "start": "start", + "begin": "start", + "input": "start", + # End node aliases + "end": "end", + "finish": "end", + "output": "end", + # LLM node aliases + "llm": "llm", + "ai": "llm", + "gpt": "llm", + "model": "llm", + "chat": "llm", + # Code node aliases + "code": "code", + "script": "code", + "python": "code", + "javascript": "code", + # HTTP request node aliases + "http-request": "http-request", + "http": "http-request", + "request": "http-request", + "api": "http-request", + "fetch": "http-request", + "webhook": "http-request", + # Conditional node aliases + "if-else": "if-else", + "condition": "if-else", + "branch": "if-else", + "switch": "if-else", + # Loop node aliases + "iteration": "iteration", + "loop": "loop", + "foreach": "iteration", + # Tool node alias + "tool": "tool", +} + + +# ============================================================================= +# FIELD NAME CORRECTIONS +# ============================================================================= + +# Field name corrections for LLM-generated node configs +# Maps incorrect field names to correct ones for specific node types +FIELD_NAME_CORRECTIONS: dict[str, dict[str, str]] = { + "http-request": { + "text": "body", # LLM might use "text" instead of "body" + "content": "body", + "response": "body", + }, + "code": { + "text": "result", # LLM might use "text" instead of "result" + "output": "result", + }, + "llm": { + "response": "text", + "answer": "text", + }, +} + + +def get_corrected_field_name(node_type: str, field: str) -> str: + """ + Get the corrected field name for a node type. + + Args: + node_type: The type of the node (e.g., "http-request", "code") + field: The field name to correct + + Returns: + The corrected field name, or the original if no correction needed + """ + corrections = FIELD_NAME_CORRECTIONS.get(node_type, {}) + return corrections.get(field, field) + + +# ============================================================================= +# VALIDATION UTILITIES +# ============================================================================= + +# Node types that are internal and don't need schemas for LLM generation +_INTERNAL_NODE_TYPES: set[str] = { + # Internal workflow nodes + "answer", # Internal to chatflow + "loop", # Uses iteration internally + "assigner", # Variable assignment utility + "variable-assigner", # Variable assignment utility + "agent", # Agent node (complex, handled separately) + "document-extractor", # Internal document processing + "list-operator", # Internal list operations + # Iteration internal nodes + "iteration-start", # Internal to iteration loop + "loop-start", # Internal to loop + "loop-end", # Internal to loop + # Trigger nodes (not user-creatable via LLM) + "trigger-plugin", # Plugin trigger + "trigger-schedule", # Scheduled trigger + "trigger-webhook", # Webhook trigger + # Other internal nodes + "datasource", # Data source configuration + "human-input", # Human-in-the-loop node + "knowledge-index", # Knowledge indexing node +} + + +def validate_node_schemas() -> list[str]: + """ + Validate that all registered node types have corresponding schemas. + + This function checks if BUILTIN_NODE_SCHEMAS covers all node types + registered in NODE_TYPE_CLASSES_MAPPING, excluding internal node types. + + Returns: + List of warning messages for missing schemas (empty if all valid) + """ + from core.workflow.nodes.node_mapping import NODE_TYPE_CLASSES_MAPPING + + schemas = get_builtin_node_schemas() + warnings = [] + for node_type in NODE_TYPE_CLASSES_MAPPING: + type_value = node_type.value + if type_value in _INTERNAL_NODE_TYPES: + continue + if type_value not in schemas: + warnings.append(f"Missing schema for node type: {type_value}") + return warnings diff --git a/api/core/workflow/generator/config/responses.py b/api/core/workflow/generator/config/responses.py new file mode 100644 index 0000000000..6a252d0efc --- /dev/null +++ b/api/core/workflow/generator/config/responses.py @@ -0,0 +1,72 @@ +""" +Response Templates for Vibe Workflow Generation. + +This module defines templates for off-topic responses and default suggestions +to guide users back to workflow-related requests. +""" + +# Off-topic response templates for different categories +# Each category has messages in multiple languages +OFF_TOPIC_RESPONSES: dict[str, dict[str, str]] = { + "weather": { + "en": ( + "I'm the workflow design assistant - I can't check the weather, " + "but I can help you build AI workflows! For example, I could help you " + "create a workflow that fetches weather data from an API." + ), + "zh": "我是工作流设计助手，无法查询天气。但我可以帮你创建一个从API获取天气数据的工作流！", + }, + "math": { + "en": ( + "I focus on workflow design rather than calculations. However, " + "if you need calculations in a workflow, I can help you add a Code node " + "that handles math operations!" + ), + "zh": "我专注于工作流设计而非计算。但如果您需要在工作流中进行计算，我可以帮您添加一个处理数学运算的代码节点！", + }, + "joke": { + "en": ( + "While I'd love to share a laugh, I'm specialized in workflow design. " + "How about we create something fun instead - like a workflow that generates jokes using AI?" + ), + "zh": "虽然我很想讲笑话，但我专门从事工作流设计。不如我们创建一个有趣的东西——比如使用AI生成笑话的工作流？", + }, + "translation": { + "en": ( + "I can't translate directly, but I can help you build a translation workflow! " + "Would you like to create one using an LLM node?" + ), + "zh": "我不能直接翻译，但我可以帮你构建一个翻译工作流！要创建一个使用LLM节点的翻译流程吗？", + }, + "general_coding": { + "en": ( + "I'm specialized in Dify workflow design rather than general coding help. " + "But if you want to add code logic to your workflow, I can help you configure a Code node!" + ), + "zh": ( + "我专注于Dify工作流设计，而非通用编程帮助。但如果您想在工作流中添加代码逻辑，我可以帮您配置一个代码节点！" + ), + }, + "default": { + "en": ( + "I'm the Dify workflow design assistant. I help create AI automation workflows, " + "but I can't help with general questions. Would you like to create a workflow instead?" + ), + "zh": "我是Dify工作流设计助手。我帮助创建AI自动化工作流，但无法回答一般性问题。您想创建一个工作流吗？", + }, +} + +# Default suggestions for off-topic requests +# These help guide users towards valid workflow requests +DEFAULT_SUGGESTIONS: dict[str, list[str]] = { + "en": [ + "Create a chatbot workflow", + "Build a document summarization pipeline", + "Add email notification to workflow", + ], + "zh": [ + "创建一个聊天机器人工作流", + "构建文档摘要处理流程", + "添加邮件通知到工作流", + ], +} diff --git a/api/core/workflow/generator/prompts/__init__.py b/api/core/workflow/generator/prompts/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/api/core/workflow/generator/prompts/builder_prompts.py b/api/core/workflow/generator/prompts/builder_prompts.py new file mode 100644 index 0000000000..d6030bcbf3 --- /dev/null +++ b/api/core/workflow/generator/prompts/builder_prompts.py @@ -0,0 +1,733 @@ +# ============================================================================= +# NEW FORMAT: depends_on based prompt (for use with GraphBuilder) +# ============================================================================= + +BUILDER_SYSTEM_PROMPT_V2 = """ +You are a Workflow Configuration Engineer. +Your goal is to generate workflow node configurations with dependency declarations. +The graph structure (edges, start/end nodes) will be automatically built from your output. + + + +- Detect the language of the user's request automatically (e.g., English, Chinese, Japanese, etc.). +- Generate ALL node titles, descriptions, and user-facing text in the SAME language as the user's input. +- If the input language is ambiguous or cannot be determined (e.g. code-only input), + use {preferred_language} as the target language. + + + + +{plan_context} + + + +{tool_schemas} + + + +{builtin_node_specs} + + + +{available_models} + + + + +{existing_nodes_context} + + +{selected_nodes_context} + + + + + +1. **DO NOT generate start or end nodes** - they are automatically added +2. **DO NOT generate edges** - they are automatically built from depends_on +3. **Use depends_on array** to declare which nodes must run before this one +4. **Leave depends_on empty []** for nodes that should start immediately (connect to start) + + + +1. **Configuration**: + - You MUST fill ALL required parameters for every node. + - Use `{{{{#node_id.field#}}}}` syntax to reference outputs from previous nodes in text fields. + +2. **Dependency Declaration**: + - Each node has a `depends_on` array listing node IDs that must complete before it runs + - Empty depends_on `[]` means the node runs immediately after start + - Example: `"depends_on": ["fetch_data"]` means this node waits for fetch_data to complete + +3. **Variable References**: + - For text fields (like prompts, queries): use string format `{{{{#node_id.field#}}}}` + - Dependencies will be auto-inferred from variable references if not explicitly declared + +4. **Tools**: + - ONLY use the tools listed in ``. + - If a planned tool is missing from schemas, fallback to `http-request` or `code`. + +5. **Model Selection** (CRITICAL): + - For LLM, question-classifier, and parameter-extractor nodes, you MUST include a "model" config. + - You MUST use ONLY models from the `` section above. + - Copy the EXACT provider and name values from available_models. + - NEVER use openai/gpt-4o, gpt-3.5-turbo, gpt-4, or any other models unless they appear in available_models. + - If available_models is empty or shows "No models configured", omit the model config entirely. + +6. **if-else Branching**: + - Add `true_branch` and `false_branch` in config to specify target node IDs + - Example: `"config": {{"cases": [...], "true_branch": "success_node", "false_branch": "fallback_node"}}` + +7. **question-classifier Branching**: + - Add `target` field to each class in the classes array + - Example: `"classes": [{{"id": "tech", "name": "Tech", "target": "tech_handler"}}, ...]` + +8. **Node Specifics**: + - For `if-else` comparison_operator, use literal symbols: `≥`, `≤`, `=`, `≠` (NOT `>=` or `==`). + + + +Return ONLY a JSON object with a `nodes` array. Each node has: +- id: unique identifier +- type: node type +- title: display name +- config: node configuration +- depends_on: array of node IDs this depends on + +```json +{{{{ + "nodes": [ + {{{{ + "id": "fetch_data", + "type": "http-request", + "title": "Fetch Data", + "config": {{"url": "{{{{#start.url#}}}}", "method": "GET"}}, + "depends_on": [] + }}}}, + {{{{ + "id": "analyze", + "type": "llm", + "title": "Analyze", + "config": {{"prompt_template": [{{"role": "user", "text": "Analyze: {{{{#fetch_data.body#}}}}"}}]}}, + "depends_on": ["fetch_data"] + }}}} + ] +}}}} +``` + + + + +```json +{{{{ + "nodes": [ + {{{{ + "id": "llm", + "type": "llm", + "title": "Generate Response", + "config": {{{{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "prompt_template": [{{"role": "user", "text": "Answer: {{{{#start.query#}}}}"}}] + }}}}, + "depends_on": [] + }}}} + ] +}}}} +``` + + + +```json +{{{{ + "nodes": [ + {{{{ + "id": "api1", + "type": "http-request", + "title": "Fetch API 1", + "config": {{"url": "https://api1.example.com", "method": "GET"}}, + "depends_on": [] + }}}}, + {{{{ + "id": "api2", + "type": "http-request", + "title": "Fetch API 2", + "config": {{"url": "https://api2.example.com", "method": "GET"}}, + "depends_on": [] + }}}}, + {{{{ + "id": "merge", + "type": "llm", + "title": "Merge Results", + "config": {{{{ + "prompt_template": [{{"role": "user", "text": "Combine: {{{{#api1.body#}}}} and {{{{#api2.body#}}}}"}}] + }}}}, + "depends_on": ["api1", "api2"] + }}}} + ] +}}}} +``` + + + +```json +{{{{ + "nodes": [ + {{{{ + "id": "check", + "type": "if-else", + "title": "Check Condition", + "config": {{{{ + "cases": [{{{{ + "case_id": "case_1", + "logical_operator": "and", + "conditions": [{{{{ + "variable_selector": ["start", "score"], + "comparison_operator": "≥", + "value": "60" + }}}}] + }}}}], + "true_branch": "pass_handler", + "false_branch": "fail_handler" + }}}}, + "depends_on": [] + }}}}, + {{{{ + "id": "pass_handler", + "type": "llm", + "title": "Pass Response", + "config": {{"prompt_template": [{{"role": "user", "text": "Congratulations!"}}]}}, + "depends_on": [] + }}}}, + {{{{ + "id": "fail_handler", + "type": "llm", + "title": "Fail Response", + "config": {{"prompt_template": [{{"role": "user", "text": "Try again."}}]}}, + "depends_on": [] + }}}} + ] +}}}} +``` +Note: pass_handler and fail_handler have empty depends_on because their connections come from if-else branches. + + + +```json +{{{{ + "nodes": [ + {{{{ + "id": "classifier", + "type": "question-classifier", + "title": "Classify Intent", + "config": {{{{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "query_variable_selector": ["start", "user_input"], + "classes": [ + {{"id": "tech", "name": "Technical", "target": "tech_handler"}}, + {{"id": "billing", "name": "Billing", "target": "billing_handler"}}, + {{"id": "other", "name": "Other", "target": "other_handler"}} + ] + }}}}, + "depends_on": [] + }}}}, + {{{{ + "id": "tech_handler", + "type": "llm", + "title": "Tech Support", + "config": {{"prompt_template": [{{"role": "user", "text": "Help with tech: {{{{#start.user_input#}}}}"}}]}}, + "depends_on": [] + }}}}, + {{{{ + "id": "billing_handler", + "type": "llm", + "title": "Billing Support", + "config": {{"prompt_template": [{{"role": "user", "text": "Help with billing: {{{{#start.user_input#}}}}"}}]}}, + "depends_on": [] + }}}}, + {{{{ + "id": "other_handler", + "type": "llm", + "title": "General Support", + "config": {{"prompt_template": [{{"role": "user", "text": "General help: {{{{#start.user_input#}}}}"}}]}}, + "depends_on": [] + }}}} + ] +}}}} +``` +Note: Handler nodes have empty depends_on because their connections come from classifier branches. + + +""" + +BUILDER_USER_PROMPT_V2 = """ +{instruction} + + +Generate the workflow nodes configuration. Remember: +1. Do NOT generate start or end nodes +2. Do NOT generate edges - use depends_on instead +3. For if-else: add true_branch/false_branch in config +4. For question-classifier: add target to each class +""" + +# ============================================================================= +# LEGACY FORMAT: edges-based prompt (backward compatible) +# ============================================================================= + +BUILDER_SYSTEM_PROMPT = """ +You are a Workflow Configuration Engineer. +Your goal is to implement the Architect's plan by generating a precise, runnable Dify Workflow JSON configuration. + + + +- Detect the language of the user's request automatically (e.g., English, Chinese, Japanese, etc.). +- Generate ALL node titles, descriptions, and user-facing text in the SAME language as the user's input. +- If the input language is ambiguous or cannot be determined (e.g. code-only input), + use {preferred_language} as the target language. + + + + +{plan_context} + + + +{tool_schemas} + + + +{builtin_node_specs} + + + +{available_models} + + + + +{existing_nodes_context} + + +{existing_edges_context} + + +{selected_nodes_context} + + + + + +1. **Configuration**: + - You MUST fill ALL required parameters for every node. + - Use `{{{{#node_id.field#}}}}` syntax to reference outputs from previous nodes in text fields. + - For 'start' node, define all necessary user inputs. + +2. **Variable References**: + - For text fields (like prompts, queries): use string format `{{{{#node_id.field#}}}}` + - For 'end' node outputs: use `value_selector` array format `["node_id", "field"]` + - Example: to reference 'llm' node's 'text' output in end node, use `["llm", "text"]` + +3. **Tools**: + - ONLY use the tools listed in ``. + - If a planned tool is missing from schemas, fallback to `http-request` or `code`. + +4. **Model Selection** (CRITICAL): + - For LLM, question-classifier, and parameter-extractor nodes, you MUST include a "model" config. + - You MUST use ONLY models from the `` section above. + - Copy the EXACT provider and name values from available_models. + - NEVER use openai/gpt-4o, gpt-3.5-turbo, gpt-4, or any other models unless they appear in available_models. + - If available_models is empty or shows "No models configured", omit the model config entirely. + +5. **Node Specifics**: + - For `if-else` comparison_operator, use literal symbols: `≥`, `≤`, `=`, `≠` (NOT `>=` or `==`). + +6. **Modification Mode**: + - If `` contains nodes, you are MODIFYING an existing workflow. + - Keep nodes that are NOT mentioned in the user's instruction UNCHANGED. + - Only modify/add/remove nodes that the user explicitly requested. + - Preserve node IDs for unchanged nodes to maintain connections. + - If user says "add X", append new nodes to existing workflow. + - If user says "change Y to Z", only modify that specific node. + - If user says "remove X", exclude that node from output. + + **Edge Modification**: + - Use `` to understand current node connections. + - If user mentions "fix edge", "connect", "link", or "add connection", + review existing_edges and correct missing/wrong connections. + - For multi-branch nodes (if-else, question-classifier), + ensure EACH branch has proper sourceHandle (e.g., "true"/"false") and target. + - Common edge issues to fix: + * Missing edge: Two nodes should connect but don't - add the edge + * Wrong target: Edge points to wrong node - update the target + * Missing sourceHandle: if-else/classifier branches lack sourceHandle - add "true"/"false" + * Disconnected nodes: Node has no incoming or outgoing edges - connect it properly + - When modifying edges, ensure logical flow makes sense (start → middle → end). + - ALWAYS output complete edges array, even if only modifying one edge. + + **Validation Feedback** (Automatic Retry): + - If `` is present, you are RETRYING after validation errors. + - Focus ONLY on fixing the specific validation issues mentioned. + - Keep everything else from the previous attempt UNCHANGED (preserve node IDs, edges, etc). + - Common validation issues and fixes: + * "Missing required connection" → Add the missing edge + * "Invalid node configuration" → Fix the specific node's config section + * "Type mismatch in variable reference" → Correct the variable selector path + * "Unknown variable" → Update variable reference to existing output + - When fixing, make MINIMAL changes to address each specific error. + +7. **Output**: + - Return ONLY the JSON object with `nodes` and `edges`. + - Do NOT generate Mermaid diagrams. + - Do NOT generate explanations. + + + +**EDGES ARE CRITICAL** - Every node except 'end' MUST have at least one outgoing edge. + +1. **Linear Flow**: Simple source -> target connection + ``` + {{"source": "node_a", "target": "node_b"}} + ``` + +2. **question-classifier Branching**: Each class MUST have a separate edge with `sourceHandle` = class `id` + - If you define classes: [{{"id": "cls_refund", "name": "Refund"}}, {{"id": "cls_inquiry", "name": "Inquiry"}}] + - You MUST create edges: + - {{"source": "classifier", "sourceHandle": "cls_refund", "target": "refund_handler"}} + - {{"source": "classifier", "sourceHandle": "cls_inquiry", "target": "inquiry_handler"}} + +3. **if-else Branching**: MUST have exactly TWO edges with sourceHandle "true" and "false" + - {{"source": "condition", "sourceHandle": "true", "target": "true_branch"}} + - {{"source": "condition", "sourceHandle": "false", "target": "false_branch"}} + +4. **Branch Convergence**: Multiple branches can connect to same downstream node + - Both true_branch and false_branch can connect to the same 'end' node + +5. **NEVER leave orphan nodes**: Every node must be connected in the graph + + + + +```json +{{ + "nodes": [ + {{ + "id": "start", + "type": "start", + "title": "Start", + "config": {{ + "variables": [{{"variable": "query", "label": "Query", "type": "text-input"}}] + }} + }}, + {{ + "id": "llm", + "type": "llm", + "title": "Generate Response", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "prompt_template": [{{"role": "user", "text": "Answer: {{{{#start.query#}}}}"}}] + }} + }}, + {{ + "id": "end", + "type": "end", + "title": "End", + "config": {{ + "outputs": [ + {{"variable": "result", "value_selector": ["llm", "text"]}} + ] + }} + }} + ], + "edges": [ + {{"source": "start", "target": "llm"}}, + {{"source": "llm", "target": "end"}} + ] +}} +``` + + + +```json +{{ + "nodes": [ + {{ + "id": "start", + "type": "start", + "title": "Start", + "config": {{ + "variables": [{{"variable": "user_input", "label": "User Message", "type": "text-input", "required": true}}] + }} + }}, + {{ + "id": "classifier", + "type": "question-classifier", + "title": "Classify Intent", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "query_variable_selector": ["start", "user_input"], + "classes": [ + {{"id": "cls_refund", "name": "Refund Request"}}, + {{"id": "cls_inquiry", "name": "Product Inquiry"}}, + {{"id": "cls_complaint", "name": "Complaint"}}, + {{"id": "cls_other", "name": "Other"}} + ], + "instruction": "Classify the user's intent" + }} + }}, + {{ + "id": "handle_refund", + "type": "llm", + "title": "Handle Refund", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "prompt_template": [{{"role": "user", "text": "Extract order number and respond: {{{{#start.user_input#}}}}"}}] + }} + }}, + {{ + "id": "handle_inquiry", + "type": "llm", + "title": "Handle Inquiry", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "prompt_template": [{{"role": "user", "text": "Answer product question: {{{{#start.user_input#}}}}"}}] + }} + }}, + {{ + "id": "handle_complaint", + "type": "llm", + "title": "Handle Complaint", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "prompt_template": [{{"role": "user", "text": "Respond with empathy: {{{{#start.user_input#}}}}"}}] + }} + }}, + {{ + "id": "handle_other", + "type": "llm", + "title": "Handle Other", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "prompt_template": [{{"role": "user", "text": "Provide general response: {{{{#start.user_input#}}}}"}}] + }} + }}, + {{ + "id": "end", + "type": "end", + "title": "End", + "config": {{ + "outputs": [{{"variable": "response", "value_selector": ["handle_refund", "text"]}}] + }} + }} + ], + "edges": [ + {{"source": "start", "target": "classifier"}}, + {{"source": "classifier", "sourceHandle": "cls_refund", "target": "handle_refund"}}, + {{"source": "classifier", "sourceHandle": "cls_inquiry", "target": "handle_inquiry"}}, + {{"source": "classifier", "sourceHandle": "cls_complaint", "target": "handle_complaint"}}, + {{"source": "classifier", "sourceHandle": "cls_other", "target": "handle_other"}}, + {{"source": "handle_refund", "target": "end"}}, + {{"source": "handle_inquiry", "target": "end"}}, + {{"source": "handle_complaint", "target": "end"}}, + {{"source": "handle_other", "target": "end"}} + ] +}} +``` +CRITICAL: Notice that each class id (cls_refund, cls_inquiry, etc.) becomes a sourceHandle in the edges! + + + +```json +{{ + "nodes": [ + {{ + "id": "start", + "type": "start", + "title": "Start", + "config": {{ + "variables": [{{"variable": "years", "label": "Years of Experience", "type": "number", "required": true}}] + }} + }}, + {{ + "id": "check_experience", + "type": "if-else", + "title": "Check Experience", + "config": {{ + "cases": [ + {{ + "case_id": "case_1", + "logical_operator": "and", + "conditions": [ + {{ + "variable_selector": ["start", "years"], + "comparison_operator": "≥", + "value": "3" + }} + ] + }} + ] + }} + }}, + {{ + "id": "qualified", + "type": "llm", + "title": "Qualified Response", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "prompt_template": [{{"role": "user", "text": "Generate qualified candidate response"}}] + }} + }}, + {{ + "id": "not_qualified", + "type": "llm", + "title": "Not Qualified Response", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "prompt_template": [{{"role": "user", "text": "Generate rejection response"}}] + }} + }}, + {{ + "id": "end", + "type": "end", + "title": "End", + "config": {{ + "outputs": [{{"variable": "result", "value_selector": ["qualified", "text"]}}] + }} + }} + ], + "edges": [ + {{"source": "start", "target": "check_experience"}}, + {{"source": "check_experience", "sourceHandle": "true", "target": "qualified"}}, + {{"source": "check_experience", "sourceHandle": "false", "target": "not_qualified"}}, + {{"source": "qualified", "target": "end"}}, + {{"source": "not_qualified", "target": "end"}} + ] +}} +``` +CRITICAL: if-else MUST have exactly two edges with sourceHandle "true" and "false"! + + + +```json +{{ + "nodes": [ + {{ + "id": "start", + "type": "start", + "title": "Start", + "config": {{ + "variables": [{{"variable": "resume", "label": "Resume Text", "type": "paragraph", "required": true}}] + }} + }}, + {{ + "id": "extract", + "type": "parameter-extractor", + "title": "Extract Info", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "query": ["start", "resume"], + "parameters": [ + {{"name": "name", "type": "string", "description": "Candidate name", "required": true}}, + {{"name": "years", "type": "number", "description": "Years of experience", "required": true}}, + {{"name": "skills", "type": "array[string]", "description": "List of skills", "required": true}} + ], + "instruction": "Extract candidate information from resume" + }} + }}, + {{ + "id": "process", + "type": "llm", + "title": "Process Data", + "config": {{ + "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}}, + "prompt_template": [{{"role": "user", "text": "Name: {{{{#extract.name#}}}}, Years: {{{{#extract.years#}}}}"}}] + }} + }}, + {{ + "id": "end", + "type": "end", + "title": "End", + "config": {{ + "outputs": [{{"variable": "result", "value_selector": ["process", "text"]}}] + }} + }} + ], + "edges": [ + {{"source": "start", "target": "extract"}}, + {{"source": "extract", "target": "process"}}, + {{"source": "process", "target": "end"}} + ] +}} +``` + + + + +Before finalizing, verify: +1. [ ] Every node (except 'end') has at least one outgoing edge +2. [ ] 'start' node has exactly one outgoing edge +3. [ ] 'question-classifier' has one edge per class, each with sourceHandle = class id +4. [ ] 'if-else' has exactly two edges: sourceHandle "true" and sourceHandle "false" +5. [ ] All branches eventually connect to 'end' (directly or through other nodes) +6. [ ] No orphan nodes exist (every node is reachable from 'start') + +""" + +BUILDER_USER_PROMPT = """ +{instruction} + + +Generate the full workflow configuration now. Pay special attention to: +1. Creating edges for ALL branches of question-classifier and if-else nodes +2. Using correct sourceHandle values for branching nodes +3. Ensuring every node is connected in the graph +""" + + +def format_existing_nodes(nodes: list[dict] | None) -> str: + """Format existing workflow nodes for context.""" + if not nodes: + return "No existing nodes in workflow (creating from scratch)." + + lines = [] + for node in nodes: + node_id = node.get("id", "unknown") + node_type = node.get("type", "unknown") + title = node.get("title", "Untitled") + lines.append(f"- [{node_id}] {title} ({node_type})") + return "\n".join(lines) + + +def format_selected_nodes( + selected_ids: list[str] | None, + existing_nodes: list[dict] | None, +) -> str: + """Format selected nodes for modification context.""" + if not selected_ids: + return "No nodes selected (generating new workflow)." + + node_map = {n.get("id"): n for n in (existing_nodes or [])} + lines = [] + for node_id in selected_ids: + if node_id in node_map: + node = node_map[node_id] + lines.append(f"- [{node_id}] {node.get('title', 'Untitled')} ({node.get('type', 'unknown')})") + else: + lines.append(f"- [{node_id}] (not found in current workflow)") + return "\n".join(lines) + + +def format_existing_edges(edges: list[dict] | None) -> str: + """Format existing workflow edges to show connections.""" + if not edges: + return "No existing edges (creating new workflow)." + + lines = [] + for edge in edges: + source = edge.get("source", "unknown") + target = edge.get("target", "unknown") + source_handle = edge.get("sourceHandle", "") + if source_handle: + lines.append(f"- {source} ({source_handle}) -> {target}") + else: + lines.append(f"- {source} -> {target}") + return "\n".join(lines) diff --git a/api/core/workflow/generator/prompts/planner_prompts.py b/api/core/workflow/generator/prompts/planner_prompts.py new file mode 100644 index 0000000000..ada791bf94 --- /dev/null +++ b/api/core/workflow/generator/prompts/planner_prompts.py @@ -0,0 +1,75 @@ +PLANNER_SYSTEM_PROMPT = """ +You are an expert Workflow Architect. +Your job is to analyze user requests and plan a high-level automation workflow. + + + +1. **Classify Intent**: + - Is the user asking to create an automation/workflow? -> Intent: "generate" + - Is it general chat/weather/jokes? -> Intent: "off_topic" + +2. **Plan Steps** (if intent is "generate"): + - Break down the user's goal into logical steps. + - For each step, identify if a specific capability/tool is needed. + - Select the MOST RELEVANT tools from the available_tools list. + - DO NOT configure parameters yet. Just identify the tool. + +3. **Output Format**: + Return a JSON object. + + + +{tools_summary} + + + +If intent is "generate": +```json +{{ + "intent": "generate", + "plan_thought": "Brief explanation of the plan...", + "steps": [ + {{ "step": 1, "description": "Fetch data from URL", "tool": "http-request" }}, + {{ "step": 2, "description": "Summarize content", "tool": "llm" }}, + {{ "step": 3, "description": "Search for info", "tool": "google_search" }} + ], + "required_tool_keys": ["google_search"] +}} +``` +(Note: 'http-request', 'llm', 'code' are built-in, you don't need to list them in required_tool_keys, +only external tools) + +If intent is "off_topic": +```json +{{ + "intent": "off_topic", + "message": "I can only help you build workflows. Try asking me to 'Create a workflow that...'", + "suggestions": ["Scrape a website", "Summarize a PDF"] +}} +``` + +""" + +PLANNER_USER_PROMPT = """ +{instruction} + +""" + + +def format_tools_for_planner(tools: list[dict]) -> str: + """Format tools list for planner (Lightweight: Name + Description only).""" + if not tools: + return "No external tools available." + + lines = [] + for t in tools: + key = t.get("tool_key") or t.get("tool_name") + provider = t.get("provider_id") or t.get("provider", "") + desc = t.get("tool_description") or t.get("description", "") + label = t.get("tool_label") or key + + # Format: - [provider/key] Label: Description + full_key = f"{provider}/{key}" if provider else key + lines.append(f"- [{full_key}] {label}: {desc}") + + return "\n".join(lines) diff --git a/api/core/workflow/generator/prompts/vibe_prompts.py b/api/core/workflow/generator/prompts/vibe_prompts.py new file mode 100644 index 0000000000..11845efbbd --- /dev/null +++ b/api/core/workflow/generator/prompts/vibe_prompts.py @@ -0,0 +1,1264 @@ +""" +Vibe Workflow Generator - Enhanced Prompts with Inline Intent Classification. + +This module provides prompts for the agent-enhanced workflow generation +with inline intent classification (no separate ReAct loop to stay within +single endpoint constraints). +""" + +import json +import re +from typing import Any + +from core.workflow.generator.config import ( + BUILTIN_NODE_SCHEMAS, + DEFAULT_SUGGESTIONS, + FALLBACK_RULES, + OFF_TOPIC_RESPONSES, +) +from core.workflow.generator.types import ( + AvailableModelDict, + AvailableToolDict, + WorkflowDataDict, + WorkflowNodeDict, +) + + +def extract_instruction_values(instruction: str) -> dict[str, Any]: + """ + Extract concrete values from user instruction for auto-fill hints. + + This pre-processes the instruction to find URLs, emails, and other + concrete values that can be used as defaults in the generated workflow. + """ + urls = re.findall(r'https?://[^\s<>"{}|\\^`\[\]]+', instruction) + + return { + "urls": urls, + "emails": re.findall(r"[\w.-]+@[\w.-]+\.\w+", instruction), + "api_endpoints": [u for u in urls if "/api/" in u or "/v1/" in u or "/v2/" in u], + "file_extensions": re.findall(r"\.(json|csv|txt|pdf|docx?)(?:\s|$)", instruction, re.IGNORECASE), + "json_paths": re.findall(r"\.[\w]+(?:\.[\w]+)+", instruction), # e.g., .data.results + } + + +def format_extracted_values(extracted: dict[str, Any]) -> str: + """Format extracted values as XML for prompt inclusion.""" + parts = [] + + if extracted.get("urls"): + urls_str = ", ".join(extracted["urls"]) + parts.append(f" {urls_str}") + + if extracted.get("api_endpoints"): + endpoints_str = ", ".join(extracted["api_endpoints"]) + parts.append(f" {endpoints_str}") + + if extracted.get("emails"): + emails_str = ", ".join(extracted["emails"]) + parts.append(f" {emails_str}") + + if extracted.get("file_extensions"): + exts_str = ", ".join(extracted["file_extensions"]) + parts.append(f" {exts_str}") + + if parts: + return "\n" + "\n".join(parts) + "\n" + return "" + + +VIBE_ENHANCED_SYSTEM_PROMPT = """ +You are a Dify workflow design assistant. +You help users create AI automation workflows by generating workflow configurations. + + + +- Detect the language of the user's request automatically (e.g., English, Chinese, Japanese, etc.). +- Generate ALL node titles, descriptions, and user-facing text in the SAME language as the user's input. +- If the input language is ambiguous or cannot be determined (e.g. code-only input), + use {preferred_language} as the target language. + + + +- Generate workflow configurations from natural language descriptions +- Validate tool references against available integrations +- Provide clear, helpful responses +- Reject requests that are not about workflow design + + +{available_nodes_formatted} + +{available_tools_formatted} + +{available_models_formatted} + + + How to reference data from other nodes in your workflow + {{{{#node_id.field_name#}}}} + + {{{{#start.url#}}}} + {{{{#start.query#}}}} + {{{{#llm_node_id.text#}}}} + {{{{#http_node_id.body#}}}} + {{{{#code_node_id.result#}}}} + + + + + + For LLM, question-classifier, parameter-extractor nodes: + - You MUST include a "model" config with provider and name from available_models section + - Copy the EXACT provider and name values from available_models + - NEVER use openai/gpt-4o, openai/gpt-3.5-turbo, openai/gpt-4 unless they appear in available_models + - If available_models is empty or not provided, omit the model config entirely + + + ONLY use tools with status="configured" from available_tools. + NEVER invent tool names like "webscraper", "email_sender", etc. + If no matching tool exists, use http-request or code node as fallback. + + + ALWAYS fill ALL required_params for each node type. + Check the node's params section to know what config is needed. + + + Use {{{{#node_id.field#}}}} syntax to reference outputs from previous nodes. + Start node variables: {{{{#start.variable_name#}}}} + + + + + When user requests capability with NO matching tool in available_tools + + Configure with: url (the URL to fetch), method: GET + + + Configure with: url, method, headers, body as needed + + + Write Python/JavaScript code with main() function + + + Use prompt_template with appropriate system/user messages + + Add warning to response explaining the fallback substitution + + + + +{existing_nodes_formatted} + + +{selected_nodes_formatted} + + + + + +```json +{{{{ + "intent": "generate", + "thinking": "Brief analysis of user request and approach", + "message": "User-friendly explanation of the workflow", + "mermaid": "flowchart TD\\n N1[\\"type=start|title=Start\\"]\\n ...", + "nodes": [ + {{{{ + "id": "node_id", + "type": "node_type", + "title": "Display Name", + "config": {{{{ /* REQUIRED: Fill all required_params from node schema */ }}}} + }}}} + ], + "edges": [{{{{"source": "node1_id", "target": "node2_id"}}}}], + "warnings": ["Any warnings about fallbacks or missing features"] +}}}} +``` + + +```json +{{{{ + "intent": "off_topic", + "message": "Explanation of what you can help with", + "suggestions": ["Workflow suggestion 1", "Suggestion 2"] +}}}} +``` + + + + + Weather queries, math calculations, jokes, general knowledge + Translation requests, general coding help, account/billing questions + Workflow creation, node configuration, automation design + Questions about Dify workflow capabilities + + + + Use `flowchart TD` for top-down flow + Node format: `ID["type=TYPE|title=TITLE"]` or `ID["type=tool|title=TITLE|tool=TOOL_KEY"]` + type= and title= are REQUIRED for EVERY node + Declare all nodes BEFORE edges + Use `-->` for connections, `-->|true|` and `-->|false|` for branches + + N1["type=start|title=Start"] + N2["type=http-request|title=Fetch Data"] + N3["type=tool|title=Search|tool=google/google_search"] + Start[Start] + N1["type=tool|title=Scrape|tool=webscraper"] + + + + + + {{{{ + "id": "fetch", + "type": "http-request", + "title": "Fetch Webpage", + "config": {{{{ + "url": "{{{{#start.url#}}}}", + "method": "GET", + "headers": "", + "params": "", + "body": {{{{"type": "none", "data": []}}}}, + "authorization": {{{{"type": "no-auth"}}}} + }}}} + }}}} + + + {{{{ + "id": "analyze", + "type": "llm", + "title": "Analyze Content", + "config": {{{{ + "model": {{{{"provider": "USE_FROM_AVAILABLE_MODELS", "name": "USE_FROM_AVAILABLE_MODELS", "mode": "chat"}}}}, + "prompt_template": [ + {{{{"role": "system", "text": "You are a helpful analyst."}}}}, + {{{{"role": "user", "text": "Analyze this content:\\n\\n{{{{#fetch.body#}}}}"}}}} + ] + }}}} + }}}} + NOTE: Replace "USE_FROM_AVAILABLE_MODELS" with actual values from available_models section! + + + {{{{ + "id": "process", + "type": "code", + "title": "Process Data", + "config": {{{{ + "language": "python3", + "code": "def main(data):\\n return {{\\"result\\": data.upper()}}" + }}}} + }}}} + + + + + CRITICAL: Auto-fill all parameters so workflow runs immediately + + + MUST define input variables for ALL data the workflow needs from user + Use extracted values from user instruction as "default" when available + + URL fetching workflow → add "url" variable with type="text-input" + Text processing workflow → add "content" or "query" variable + API integration → add "api_key" variable if authentication needed + + + {{{{ + "variables": [ + {{{{"variable": "url", "label": "Target URL", "type": "text-input", "required": true, "default": "https://..."}}}} + ] + }}}} + + + + + EVERY node parameter that needs data must reference a source: + - User input from start node → {{{{#start.variable_name#}}}} + - Output from previous node → {{{{#node_id.output_field#}}}} + - Or a concrete hardcoded value extracted from user instruction + NEVER leave parameters empty - always fill with variable reference or concrete value + If you cannot determine a value, you MUST use the exact string "__PLACEHOLDER__" + + + + url: MUST be {{{{#start.url#}}}} OR concrete URL from instruction - NEVER empty + method: Set based on action (fetch/get → GET, send/post/create → POST, update → PUT, delete → DELETE) + headers: Include Authorization if API key is available + + + + prompt_template MUST reference previous node output for context + Example: {{{{"role": "user", "text": "Analyze this:\\n\\n{{{{#http_node.body#}}}}"}}}} + Include system message to set AI behavior/role + + + + variables array MUST include inputs from previous nodes + Example: {{{{"variable": "data", "value_selector": ["http_node", "body"]}}}} + code must define main() function that returns dict + + + + outputs MUST use value_selector to reference the final processing node's output + Example: {{{{"variable": "result", "value_selector": ["llm_node", "text"]}}}} + + + +{extracted_values_formatted} +""" + +VIBE_ENHANCED_USER_PROMPT = """ +{instruction} + + + + + Is this request about workflow/automation design? + - If NO (weather, jokes, math, translations, general questions) → return off_topic response + - If YES → proceed to Step 2 + + + + - What is the user trying to achieve? + - What inputs are needed (define in start node)? + - What processing steps are required? + - What outputs should be produced (define in end node)? + + + + - Check available_tools - which tools with status="configured" can be used? + - For each required capability, check if a matching tool exists + - If NO matching tool: use fallback node (http-request, code, or llm) + - NEVER invent tool names - only use exact keys from available_tools + + + + - For EACH node, check its required_params in available_nodes + - Fill ALL required config fields with proper values + - Use {{{{#node_id.field#}}}} syntax to reference previous node outputs + - http-request MUST have: url, method + - code MUST have: code, language + - llm MUST have: prompt_template + + + + - Create mermaid flowchart with correct syntax + - Generate nodes array with complete config for each node + - Generate edges array connecting the nodes + - Add warnings if using fallback nodes + + + +{previous_attempt_formatted} + + +Generate your JSON response now. Remember: +1. Fill ALL required_params for each node type +2. Use variable references like {{{{#start.url#}}}} to connect nodes +3. Never invent tool names - use fallback nodes instead + +""" + + +def format_available_nodes(nodes: list[WorkflowNodeDict] | None) -> str: + """Format available nodes as XML with parameter schemas.""" + lines = [""] + + # First, add built-in nodes with their schemas + for node_type, schema in BUILTIN_NODE_SCHEMAS.items(): + lines.append(f' ') + lines.append(f" {schema.get('description', '')}") + + required = schema.get("required", []) + if required: + lines.append(f" {', '.join(required)}") + + params = schema.get("parameters", {}) + if params: + lines.append(" ") + for param_name, param_info in params.items(): + param_type = param_info.get("type", "string") + is_required = param_name in required + desc = param_info.get("description", "") + + if param_type == "enum": + options = param_info.get("options", []) + lines.append( + f' ' + f"{desc}" + ) + else: + lines.append( + f' {desc}' + ) + + # Add example if present + if "example" in param_info: + example = param_info["example"] + if isinstance(example, dict): + example = json.dumps(example) + lines.append(f" ") + lines.append(" ") + + outputs = schema.get("outputs", []) + if outputs: + lines.append(f" {', '.join(outputs)}") + + lines.append(" ") + + # Add custom nodes from the provided list (without detailed schemas) + if nodes: + for node in nodes: + node_type = node.get("type", "unknown") + # Skip if already covered by built-in schemas + if node_type in BUILTIN_NODE_SCHEMAS: + continue + description = node.get("description", "No description") + lines.append(f' ') + lines.append(f" {description}") + lines.append(" ") + + lines.append("") + return "\n".join(lines) + + +def format_available_tools(tools: list[AvailableToolDict] | None) -> str: + """Format available tools as XML with parameter schemas.""" + lines = [""] + + if not tools: + lines.append(" ") + lines.append(" ") + lines.append("") + return "\n".join(lines) + + configured_tools: list[AvailableToolDict] = [] + unconfigured_tools: list[AvailableToolDict] = [] + + for tool in tools: + if tool.get("is_team_authorization", False): + configured_tools.append(tool) + else: + unconfigured_tools.append(tool) + + # Configured tools (ready to use) + lines.append(" ") + if configured_tools: + for tool in configured_tools: + tool_key = tool.get("tool_key") or f"{tool.get('provider_id')}/{tool.get('tool_name')}" + description = tool.get("tool_description") or tool.get("description", "") + lines.append(f' ') + lines.append(f" {description}") + + # Add parameter schemas if available + parameters = tool.get("parameters") + if parameters: + lines.append(" ") + for param in parameters: + param_name = param.get("name", "") + param_type = param.get("type", "string") + required = param.get("required", False) + param_desc = param.get("human_description") or param.get("llm_description") or "" + # Handle localized descriptions + if isinstance(param_desc, dict): + param_desc = param_desc.get("en_US") or param_desc.get("zh_Hans") or str(param_desc) + options = param.get("options", []) + + if options: + opt_str = ",".join(str(o.get("value", o)) if isinstance(o, dict) else str(o) for o in options) + lines.append( + f' {param_desc}' + ) + else: + lines.append( + f' {param_desc}' + ) + lines.append(" ") + + lines.append(" ") + else: + lines.append(" ") + + # Unconfigured tools (need setup first) + lines.append("") + lines.append(" ") + if unconfigured_tools: + for tool in unconfigured_tools: + tool_key = tool.get("tool_key") or f"{tool.get('provider_id')}/{tool.get('tool_name')}" + description = tool.get("tool_description") or tool.get("description", "") + lines.append(f' ') + lines.append(f" {description}") + lines.append(" ") + lines.append(" ") + else: + lines.append(" ") + + lines.append("") + return "\n".join(lines) + + +def format_existing_nodes(nodes: list[WorkflowNodeDict] | None) -> str: + """Format existing workflow nodes for context.""" + if not nodes: + return "No existing nodes in workflow (creating from scratch)." + + lines = [] + for node in nodes: + node_id = node.get("id", "unknown") + node_type = node.get("type", "unknown") + title = node.get("title", "Untitled") + lines.append(f"- [{node_id}] {title} ({node_type})") + return "\n".join(lines) + + +def format_selected_nodes( + selected_ids: list[str] | None, + existing_nodes: list[WorkflowNodeDict] | None, +) -> str: + """Format selected nodes for modification context.""" + if not selected_ids: + return "No nodes selected (generating new workflow)." + + node_map = {n.get("id"): n for n in (existing_nodes or [])} + lines = [] + for node_id in selected_ids: + if node_id in node_map: + node = node_map[node_id] + lines.append(f"- [{node_id}] {node.get('title', 'Untitled')} ({node.get('type', 'unknown')})") + else: + lines.append(f"- [{node_id}] (not found in current workflow)") + return "\n".join(lines) + + +def format_previous_attempt( + previous_workflow: WorkflowDataDict | None, + regenerate_mode: bool = False, +) -> str: + """ + Format previous workflow attempt as XML context for regeneration. + + When regenerating, we pass the previous workflow and warnings so the model + can fix specific issues instead of starting from scratch. + """ + if not regenerate_mode or not previous_workflow: + return "" + + nodes = previous_workflow.get("nodes", []) + edges = previous_workflow.get("edges", []) + warnings = previous_workflow.get("warnings", []) + + parts = [""] + parts.append(" ") + parts.append(" Your previous generation had issues. Please fix them while keeping the good parts.") + parts.append(" ") + + if warnings: + parts.append(" ") + for warning in warnings: + parts.append(f" - {warning}") + parts.append(" ") + + if nodes: + # Summarize nodes without full config to save tokens + parts.append(" ") + for node in nodes: + node_id = node.get("id", "unknown") + node_type = node.get("type", "unknown") + title = node.get("title", "Untitled") + config = node.get("config", {}) + + # Show key config issues for debugging + config_summary = "" + if node_type == "http-request": + url = config.get("url", "") + if not url: + config_summary = " (url: EMPTY - needs fix)" + elif url.startswith("{{#"): + config_summary = f" (url: {url})" + elif node_type == "tool": + tool_name = config.get("tool_name", "") + config_summary = f" (tool: {tool_name})" + + parts.append(f" - [{node_id}] {title} ({node_type}){config_summary}") + parts.append(" ") + + if edges: + parts.append(" ") + for edge in edges: + parts.append(f" - {edge.get('source', '?')} → {edge.get('target', '?')}") + parts.append(" ") + + parts.append(" ") + parts.append(" 1. Keep the workflow structure if it makes sense") + parts.append(" 2. Fix any invalid tool references - use http-request or code as fallback") + parts.append(" 3. Fill ALL required parameters (url, method, prompt_template, etc.)") + parts.append(" 4. Use {{#node_id.field#}} syntax for variable references") + parts.append(" 5. Define input variables in the Start node") + parts.append(" ") + parts.append("") + + return "\n".join(parts) + + +def format_available_models(models: list[AvailableModelDict] | None) -> str: + """Format available models as XML for prompt inclusion.""" + if not models: + return "\n \n" + + lines = [""] + for model in models: + provider = model.get("provider", "unknown") + model_name = model.get("model", "unknown") + lines.append(f' ') + lines.append("") + + # Add model selection rule with concrete example + lines.append("") + lines.append("") + lines.append(" CRITICAL: For LLM, question-classifier, and parameter-extractor nodes:") + lines.append(" - You MUST include a 'model' field in the config") + lines.append(" - You MUST use ONLY models from available_models above") + lines.append(" - NEVER use openai/gpt-4o, gpt-3.5-turbo, gpt-4 unless they appear in available_models") + lines.append("") + + # Provide concrete JSON example to copy + first_model = models[0] + provider = first_model.get("provider", "unknown") + model_name = first_model.get("model", "unknown") + lines.append(" COPY THIS EXACT MODEL CONFIG for all LLM/question-classifier/parameter-extractor nodes:") + lines.append(f' "model": {{"provider": "{provider}", "name": "{model_name}", "mode": "chat"}}') + + if len(models) > 1: + lines.append("") + lines.append(" Alternative models you can use:") + for m in models[1:4]: # Show up to 3 alternatives + p = m.get("provider", "unknown") + n = m.get("model", "unknown") + lines.append(f' - "model": {{"provider": "{p}", "name": "{n}", "mode": "chat"}}') + + lines.append("") + + return "\n".join(lines) + + +def build_vibe_enhanced_prompt( + instruction: str, + available_nodes: list[WorkflowNodeDict] | None = None, + available_tools: list[AvailableToolDict] | None = None, + existing_nodes: list[WorkflowNodeDict] | None = None, + selected_node_ids: list[str] | None = None, + previous_workflow: WorkflowDataDict | None = None, + regenerate_mode: bool = False, + preferred_language: str | None = None, + available_models: list[AvailableModelDict] | None = None, +) -> tuple[str, str]: + """Build the complete system and user prompts.""" + # Extract concrete values from user instruction for auto-fill hints + extracted = extract_instruction_values(instruction) + extracted_values_xml = format_extracted_values(extracted) + + # Format previous attempt context for regeneration + previous_attempt_xml = format_previous_attempt(previous_workflow, regenerate_mode) + + # Default to English if no preferred language specified + language_hint = preferred_language or "English" + + system_prompt = VIBE_ENHANCED_SYSTEM_PROMPT.format( + preferred_language=language_hint, + available_nodes_formatted=format_available_nodes(available_nodes), + available_tools_formatted=format_available_tools(available_tools), + existing_nodes_formatted=format_existing_nodes(existing_nodes), + selected_nodes_formatted=format_selected_nodes(selected_node_ids, existing_nodes), + extracted_values_formatted=extracted_values_xml, + previous_attempt_formatted=previous_attempt_xml, + available_models_formatted=format_available_models(available_models), + ) + + user_prompt = VIBE_ENHANCED_USER_PROMPT.format( + instruction=instruction, + previous_attempt_formatted=previous_attempt_xml, + ) + + return system_prompt, user_prompt + + +def parse_vibe_response(content: str) -> dict[str, Any]: + """Parse LLM response into structured format.""" + # Extract JSON from markdown code block if present + json_match = re.search(r"```(?:json)?\s*([\s\S]+?)```", content) + if json_match: + content = json_match.group(1).strip() + + # Try parsing JSON + try: + data = json.loads(content) + except json.JSONDecodeError: + # Attempt simple repair: remove trailing commas + cleaned = re.sub(r",\s*([}\]])", r"\1", content) + try: + data = json.loads(cleaned) + except json.JSONDecodeError: + # Return error format + return { + "intent": "error", + "error": "Failed to parse LLM response as JSON", + "raw_content": content[:500], # First 500 chars for debugging + } + + # Validate and normalize + if "intent" not in data: + data["intent"] = "generate" # Default assumption + + # Ensure required fields for generate intent + if data["intent"] == "generate": + data.setdefault("mermaid", "") + data.setdefault("nodes", []) + data.setdefault("edges", []) + data.setdefault("message", "") + data.setdefault("warnings", []) + + # Ensure required fields for off_topic intent + if data["intent"] == "off_topic": + data.setdefault("message", OFF_TOPIC_RESPONSES["default"]["en"]) + data.setdefault("suggestions", DEFAULT_SUGGESTIONS["en"]) + + return data + + +def validate_tool_references( + nodes: list[WorkflowNodeDict], + available_tools: list[AvailableToolDict] | None, +) -> tuple[list[str], list[dict[str, Any]]]: + """ + Validate tool references and return warnings and recommendations. + + Returns: + tuple of (warnings, tool_recommendations) + """ + if not available_tools: + return [], [] + + # Build lookup sets for configured and unconfigured tools + configured_keys: set[str] = set() + unconfigured_keys: set[str] = set() + tool_info_map: dict[str, dict[str, Any]] = {} + + for tool in available_tools: + provider = tool.get("provider_id") or tool.get("provider", "") + tool_key = tool.get("tool_key") or tool.get("tool_name", "") + is_authorized = tool.get("is_team_authorization", False) + + full_key = f"{provider}/{tool_key}" if provider else tool_key + tool_info_map[full_key] = { + "provider_id": provider, + "tool_name": tool_key, + "description": tool.get("tool_description") or tool.get("description", ""), + } + + if is_authorized: + configured_keys.add(full_key) + if tool_key: + configured_keys.add(tool_key) + else: + unconfigured_keys.add(full_key) + if tool_key: + unconfigured_keys.add(tool_key) + + warnings: list[str] = [] + recommendations: list[dict[str, Any]] = [] + seen_recommendations: set[str] = set() + + for node in nodes: + if node.get("type") == "tool": + config = node.get("config", {}) + tool_ref = config.get("tool_key") or config.get("tool") or node.get("tool_name") + + if not tool_ref: + continue + + # Check if tool is configured + if tool_ref in configured_keys: + continue + + # Check if tool exists but is unconfigured + if tool_ref in unconfigured_keys: + if tool_ref not in seen_recommendations: + seen_recommendations.add(tool_ref) + warnings.append(f"Tool '{tool_ref}' requires configuration") + tool_info = tool_info_map.get(tool_ref, {}) + recommendations.append( + { + "requested_capability": f"Use {tool_ref}", + "unconfigured_tools": [tool_info] if tool_info else [], + "configured_alternatives": [], + "recommendation": f"Configure '{tool_ref}' in Tools settings to enable this functionality", + } + ) + else: + # Tool doesn't exist at all + warnings.append(f"Tool '{tool_ref}' not found in available tools") + + return warnings, recommendations + + +def determine_fallback_type(tool_ref: str, node_title: str) -> str | None: + """ + Determine the best fallback node type based on tool name/title semantics. + + Returns: + - "http-request" for web/API related tools + - "code" for logic/calculation related tools + - "llm" for text/AI analysis related tools + - None if no appropriate fallback can be determined + """ + combined = f"{tool_ref} {node_title}".lower() + + for fallback_type, keywords in FALLBACK_RULES.items(): + if any(kw in combined for kw in keywords): + return fallback_type + + # No matching rule - don't force a fallback + return None + + +def create_http_request_fallback(original_node: WorkflowNodeDict) -> WorkflowNodeDict: + """Create http-request fallback node, preserving original URL if present.""" + config = original_node.get("config", {}) + tool_params = config.get("tool_parameters", {}) + # Also check "params" - LLM may put tool parameters there + params = config.get("params", {}) + if isinstance(params, str): + # params might be a string (query params), not tool params + params = {} + + # Try to preserve URL from original config (check multiple locations) + original_url = config.get("url") or tool_params.get("url") or params.get("url") or "" + + # Headers should be a string (newline separated key: value pairs) + headers = config.get("headers") or tool_params.get("headers") or params.get("headers") or "" + if isinstance(headers, dict): + # Convert dict to string format + headers = "\n".join(f"{k}: {v}" for k, v in headers.items()) if headers else "" + + # Body should have a type field - use "none" as default + body = config.get("body") or tool_params.get("body") or params.get("body") or {} + if not isinstance(body, dict) or "type" not in body: + body = {"type": "none", "data": []} + + # Method - check multiple locations + method = config.get("method") or tool_params.get("method") or params.get("method") or "GET" + + return { + "id": original_node.get("id", ""), + "type": "http-request", + "title": f"{original_node.get('title', 'Request')} (fallback)", + "config": { + "method": method, + "url": original_url, + "headers": headers, + "params": "", + "body": body, + "authorization": {"type": "no-auth"}, + }, + } + + +def create_code_fallback(original_node: WorkflowNodeDict) -> WorkflowNodeDict: + """Create code fallback node with placeholder implementation.""" + title = original_node.get("title", "Process") + return { + "id": original_node.get("id", ""), + "type": "code", + "title": f"{title} (fallback)", + "config": { + "language": "python3", + "code": f'def main():\n # TODO: Implement "{title}" logic\n return {{"result": "placeholder"}}', + }, + } + + +def create_llm_fallback(original_node: WorkflowNodeDict) -> WorkflowNodeDict: + """Create LLM fallback node for text analysis tasks.""" + title = original_node.get("title", "Analyze") + return { + "id": original_node.get("id", ""), + "type": "llm", + "title": f"{title} (fallback)", + "config": { + "prompt_template": [ + {"role": "system", "text": "You are a helpful assistant."}, + {"role": "user", "text": f"Please help with: {title}"}, + ], + }, + } + + +def sanitize_tool_nodes( + nodes: list[WorkflowNodeDict], + available_tools: list[AvailableToolDict] | None, +) -> tuple[list[WorkflowNodeDict], list[str]]: + """ + Replace invalid tool nodes with fallback nodes (http-request or code). + + This is a safety net for when the LLM hallucinates tool names despite prompt instructions. + + Returns: + tuple of (sanitized_nodes, warnings) + """ + if not nodes: + return [], [] + + # Build set of valid tool keys + valid_tool_keys: set[str] = set() + if available_tools: + for tool in available_tools: + provider = tool.get("provider_id") or tool.get("provider", "") + tool_key = tool.get("tool_key") or tool.get("tool_name", "") + if provider and tool_key: + valid_tool_keys.add(f"{provider}/{tool_key}") + if tool_key: + valid_tool_keys.add(tool_key) + + sanitized: list[WorkflowNodeDict] = [] + warnings: list[str] = [] + + for node in nodes: + if node.get("type") != "tool": + sanitized.append(node) + continue + + # Check if tool reference is valid + config = node.get("config", {}) + tool_ref = ( + config.get("tool_key") + or config.get("tool_name") + or config.get("provider_id", "") + "/" + config.get("tool_name", "") + ) + + # Normalize and check validity + normalized_refs = [tool_ref] + if "/" in tool_ref: + # Also check just the tool name part + normalized_refs.append(tool_ref.split("/")[-1]) + + is_valid = any(ref in valid_tool_keys for ref in normalized_refs if ref) + + if is_valid: + sanitized.append(node) + else: + # Determine the best fallback type based on tool semantics + node_title = node.get("title", "") + fallback_type = determine_fallback_type(tool_ref, node_title) + + if fallback_type == "http-request": + fallback_node = create_http_request_fallback(node) + sanitized.append(fallback_node) + warnings.append( + f"Tool '{tool_ref}' not found. Replaced with http-request node. " + "Please configure the URL if not set." + ) + elif fallback_type == "code": + fallback_node = create_code_fallback(node) + sanitized.append(fallback_node) + warnings.append( + f"Tool '{tool_ref}' not found. Replaced with code node. " + "Please implement the logic in the code editor." + ) + elif fallback_type == "llm": + fallback_node = create_llm_fallback(node) + sanitized.append(fallback_node) + warnings.append( + f"Tool '{tool_ref}' not found. Replaced with LLM node. Please configure the prompt template." + ) + else: + # No appropriate fallback - keep original node and warn + sanitized.append(node) + warnings.append( + f"Tool '{tool_ref}' not found and no suitable fallback determined. " + "Please configure a valid tool or replace this node manually." + ) + + return sanitized, warnings + + +def validate_node_parameters(nodes: list[WorkflowNodeDict]) -> list[str]: + """ + Validate that all required parameters are properly filled in generated nodes. + + Returns a list of warnings for nodes with missing or empty parameters. + """ + warnings: list[str] = [] + + for node in nodes: + node_id = node.get("id", "unknown") + node_type = node.get("type", "") + config = node.get("config", {}) + + if node_type == "http-request": + url = config.get("url", "") + if not url: + warnings.append(f"Node '{node_id}': http-request is missing required 'url' parameter") + elif url == "": + warnings.append(f"Node '{node_id}': http-request has empty 'url' - please configure") + method = config.get("method", "") + if not method: + warnings.append(f"Node '{node_id}': http-request should have 'method' (GET, POST, etc.)") + + elif node_type == "llm": + prompt_template = config.get("prompt_template", []) + if not prompt_template: + warnings.append(f"Node '{node_id}': LLM node is missing 'prompt_template'") + else: + # Check if any prompt references previous node output + has_reference = any("{{#" in p.get("text", "") for p in prompt_template if isinstance(p, dict)) + if not has_reference: + warnings.append( + f"Node '{node_id}': LLM prompt should reference previous node output " + "using {{#node_id.field#}} syntax" + ) + + elif node_type == "code": + code = config.get("code", "") + if not code: + warnings.append(f"Node '{node_id}': code node is missing 'code' parameter") + language = config.get("language", "") + if not language: + warnings.append(f"Node '{node_id}': code node should specify 'language' (python3 or javascript)") + + elif node_type == "start": + variables = config.get("variables", []) + if not variables: + warnings.append("Start node should define input variables for user data (e.g., url, query, content)") + + elif node_type == "end": + outputs = config.get("outputs", []) + if not outputs: + warnings.append("End node should define output variables to return workflow results") + + return warnings + + +def extract_mermaid_from_response(data: dict[str, Any]) -> str: + """Extract mermaid flowchart from parsed response.""" + mermaid = data.get("mermaid", "") + + if not mermaid: + return "" + + # Clean up mermaid code + mermaid = mermaid.strip() + # Remove code fence if present + if mermaid.startswith("```"): + match = re.search(r"```(?:mermaid)?\s*([\s\S]+?)```", mermaid) + if match: + mermaid = match.group(1).strip() + + # Sanitize edge labels to remove characters that break Mermaid parsing + # Edge labels in Mermaid are ONLY in the pattern: -->|label| + # We must NOT match |pipe| characters inside node labels like ["type=start|title=开始"] + def sanitize_edge_label(match: re.Match) -> str: + arrow = match.group(1) # --> or --- + label = match.group(2) # the label between pipes + # Remove or replace special characters that break Mermaid + # Parentheses, brackets, braces have special meaning in Mermaid + sanitized = re.sub(r"[(){}\[\]]", "", label) + return f"{arrow}|{sanitized}|" + + # Only match edge labels: --> or --- followed by |label| + # This pattern ensures we only sanitize actual edge labels, not node content + mermaid = re.sub(r"(-->|---)\|([^|]+)\|", sanitize_edge_label, mermaid) + + return mermaid + + +def classify_validation_errors( + nodes: list[dict[str, Any]], + available_models: list[dict[str, Any]] | None = None, + available_tools: list[dict[str, Any]] | None = None, + edges: list[dict[str, Any]] | None = None, +) -> dict[str, list[dict[str, Any]]]: + """ + Classify validation errors into fixable and user-required categories. + + This function uses the declarative rule engine to validate nodes. + The rule engine provides deterministic, testable validation without + relying on LLM judgment. + + Fixable errors can be automatically corrected by the LLM in subsequent + iterations. User-required errors need manual intervention. + + Args: + nodes: List of generated workflow nodes + available_models: List of models the user has configured + available_tools: List of available tools + edges: List of edges connecting nodes + + Returns: + dict with: + - "fixable": errors that LLM can fix automatically + - "user_required": errors that need user intervention + - "all_warnings": combined warning messages for backwards compatibility + - "stats": validation statistics + """ + from core.workflow.generator.validation import ValidationContext, ValidationEngine + + # Build validation context + context = ValidationContext( + nodes=nodes, + edges=edges or [], + available_models=available_models or [], + available_tools=available_tools or [], + ) + + # Run validation through rule engine + engine = ValidationEngine() + result = engine.validate(context) + + # Convert to legacy format for backwards compatibility + fixable: list[dict[str, Any]] = [] + user_required: list[dict[str, Any]] = [] + + for error in result.fixable_errors: + fixable.append( + { + "node_id": error.node_id, + "node_type": error.node_type, + "error_type": error.rule_id, + "message": error.message, + "is_fixable": True, + "fix_hint": error.fix_hint, + "category": error.category.value, + "details": error.details, + } + ) + + for error in result.user_required_errors: + user_required.append( + { + "node_id": error.node_id, + "node_type": error.node_type, + "error_type": error.rule_id, + "message": error.message, + "is_fixable": False, + "fix_hint": error.fix_hint, + "category": error.category.value, + "details": error.details, + } + ) + + # Include warnings in user_required (they're non-blocking but informative) + for error in result.warnings: + user_required.append( + { + "node_id": error.node_id, + "node_type": error.node_type, + "error_type": error.rule_id, + "message": error.message, + "is_fixable": error.is_fixable, + "fix_hint": error.fix_hint, + "category": error.category.value, + "severity": "warning", + "details": error.details, + } + ) + + # Generate combined warnings for backwards compatibility + all_warnings = [e["message"] for e in fixable + user_required] + + return { + "fixable": fixable, + "user_required": user_required, + "all_warnings": all_warnings, + "stats": result.stats, + } + + +def build_fix_prompt( + fixable_errors: list[dict[str, Any]], + previous_nodes: list[dict[str, Any]], + available_models: list[dict[str, Any]] | None = None, +) -> str: + """ + Build a prompt for LLM to fix the identified errors. + + This creates a focused instruction that tells the LLM exactly what + to fix in the previous generation. + + Args: + fixable_errors: List of errors that can be automatically fixed + previous_nodes: The nodes from the previous generation attempt + available_models: Available models for model configuration fixes + + Returns: + Formatted prompt string for the fix iteration + """ + if not fixable_errors: + return "" + + parts = [""] + parts.append(" ") + parts.append(" Your previous generation has errors that need fixing.") + parts.append(" Please regenerate with the following corrections:") + parts.append(" ") + + # Group errors by node + errors_by_node: dict[str, list[dict[str, Any]]] = {} + for error in fixable_errors: + node_id = error["node_id"] + if node_id not in errors_by_node: + errors_by_node[node_id] = [] + errors_by_node[node_id].append(error) + + parts.append(" ") + for node_id, node_errors in errors_by_node.items(): + parts.append(f' ') + for error in node_errors: + error_type = error["error_type"] + message = error["message"] + fix_hint = error.get("fix_hint", "") + parts.append(f' ') + parts.append(f" {message}") + if fix_hint: + parts.append(f" {fix_hint}") + parts.append(" ") + parts.append(" ") + parts.append(" ") + + # Add model selection help if there are model-related errors + model_errors = [e for e in fixable_errors if "model" in e["error_type"]] + if model_errors and available_models: + parts.append(" ") + parts.append(" Use one of these models for nodes requiring model config:") + for model in available_models[:3]: # Show top 3 + provider = model.get("provider", "unknown") + name = model.get("model", "unknown") + parts.append(f' - {{"provider": "{provider}", "name": "{name}", "mode": "chat"}}') + parts.append(" ") + + # Add previous nodes summary for context + parts.append(" ") + for node in previous_nodes: + node_id = node.get("id", "unknown") + if node_id in errors_by_node: + # Only include nodes that have errors + node_type = node.get("type", "unknown") + title = node.get("title", "Untitled") + config_summary = json.dumps(node.get("config", {}), ensure_ascii=False)[:200] + parts.append(f' ') + parts.append(f" {config_summary}...") + parts.append(" ") + parts.append(" ") + + parts.append(" ") + parts.append(" 1. Keep the workflow structure and logic unchanged") + parts.append(" 2. Fix ONLY the errors listed above") + parts.append(" 3. Ensure all required fields are properly filled") + parts.append(" 4. Use variable references {{#node_id.field#}} where appropriate") + parts.append(" ") + parts.append("") + + return "\n".join(parts) diff --git a/api/core/workflow/generator/runner.py b/api/core/workflow/generator/runner.py new file mode 100644 index 0000000000..24092c2276 --- /dev/null +++ b/api/core/workflow/generator/runner.py @@ -0,0 +1,349 @@ +import json +import logging +import re +from collections.abc import Sequence + +import json_repair + +from core.model_manager import ModelManager +from core.model_runtime.entities.message_entities import SystemPromptMessage, UserPromptMessage +from core.model_runtime.entities.model_entities import ModelType +from core.workflow.generator.prompts.builder_prompts import ( + BUILDER_SYSTEM_PROMPT, + BUILDER_SYSTEM_PROMPT_V2, + BUILDER_USER_PROMPT, + BUILDER_USER_PROMPT_V2, + format_existing_edges, + format_existing_nodes, + format_selected_nodes, +) +from core.workflow.generator.prompts.planner_prompts import ( + PLANNER_SYSTEM_PROMPT, + PLANNER_USER_PROMPT, + format_tools_for_planner, +) +from core.workflow.generator.prompts.vibe_prompts import ( + format_available_models, + format_available_nodes, + format_available_tools, + parse_vibe_response, +) +from core.workflow.generator.utils.graph_builder import CyclicDependencyError, GraphBuilder +from core.workflow.generator.utils.mermaid_generator import generate_mermaid +from core.workflow.generator.utils.workflow_validator import ValidationHint, WorkflowValidator + +logger = logging.getLogger(__name__) + + +class WorkflowGenerator: + """ + Refactored Vibe Workflow Generator (Planner-Builder Architecture). + Extracts Vibe logic from the monolithic LLMGenerator. + """ + + @classmethod + def generate_workflow_flowchart( + cls, + tenant_id: str, + instruction: str, + model_config: dict, + available_nodes: Sequence[dict[str, object]] | None = None, + existing_nodes: Sequence[dict[str, object]] | None = None, + existing_edges: Sequence[dict[str, object]] | None = None, + available_tools: Sequence[dict[str, object]] | None = None, + selected_node_ids: Sequence[str] | None = None, + previous_workflow: dict[str, object] | None = None, + regenerate_mode: bool = False, + preferred_language: str | None = None, + available_models: Sequence[dict[str, object]] | None = None, + use_graph_builder: bool = False, + ): + """ + Generates a Dify Workflow Flowchart from natural language instruction. + + Pipeline: + 1. Planner: Analyze intent & select tools. + 2. Context Filter: Filter relevant tools (reduce tokens). + 3. Builder: Generate node configurations. + 4. Repair: Fix common node/edge issues (NodeRepair, EdgeRepair). + 5. Validator: Check for errors & generate friendly hints. + 6. Renderer: Deterministic Mermaid generation. + """ + model_manager = ModelManager() + model_instance = model_manager.get_model_instance( + tenant_id=tenant_id, + model_type=ModelType.LLM, + provider=model_config.get("provider", ""), + model=model_config.get("name", ""), + ) + model_parameters = model_config.get("completion_params", {}) + available_tools_list = list(available_tools) if available_tools else [] + + # Check if this is modification mode (user is refining existing workflow) + has_existing_nodes = existing_nodes and len(list(existing_nodes)) > 0 + + # --- STEP 1: PLANNER (Skip in modification mode) --- + if has_existing_nodes: + # In modification mode, skip Planner: + # - User intent is clear: modify the existing workflow + # - Tools are already in use (from existing nodes) + # - No need for intent classification or tool selection + plan_data = {"intent": "generate", "steps": [], "required_tool_keys": []} + filtered_tools = available_tools_list # Use all available tools + else: + # In creation mode, run Planner to validate intent and select tools + planner_tools_context = format_tools_for_planner(available_tools_list) + planner_system = PLANNER_SYSTEM_PROMPT.format(tools_summary=planner_tools_context) + planner_user = PLANNER_USER_PROMPT.format(instruction=instruction) + + try: + response = model_instance.invoke_llm( + prompt_messages=[ + SystemPromptMessage(content=planner_system), + UserPromptMessage(content=planner_user), + ], + model_parameters=model_parameters, + stream=False, + ) + plan_content = response.message.content + # Reuse parse_vibe_response logic or simple load + plan_data = parse_vibe_response(plan_content) + except Exception as e: + logger.exception("Planner failed") + return {"intent": "error", "error": f"Planning failed: {str(e)}"} + + if plan_data.get("intent") == "off_topic": + return { + "intent": "off_topic", + "message": plan_data.get("message", "I can only help with workflow creation."), + "suggestions": plan_data.get("suggestions", []), + } + + # --- STEP 2: CONTEXT FILTERING --- + required_tools = plan_data.get("required_tool_keys", []) + + filtered_tools = [] + if required_tools: + # Simple linear search (optimized version would use a map) + for tool in available_tools_list: + t_key = tool.get("tool_key") or tool.get("tool_name") + provider = tool.get("provider_id") or tool.get("provider") + full_key = f"{provider}/{t_key}" if provider else t_key + + # Check if this tool is in required list (match either full key or short name) + if t_key in required_tools or full_key in required_tools: + filtered_tools.append(tool) + else: + # If logic only, no tools needed + filtered_tools = [] + + # --- STEP 3: BUILDER (with retry loop) --- + MAX_GLOBAL_RETRIES = 2 # Total attempts: 1 initial + 1 retry + + workflow_data = None + mermaid_code = None + all_warnings = [] + all_fixes = [] + retry_count = 0 + validation_hints = [] + + for attempt in range(MAX_GLOBAL_RETRIES): + retry_count = attempt + logger.info("Generation attempt %s/%s", attempt + 1, MAX_GLOBAL_RETRIES) + + # Prepare context + tool_schemas = format_available_tools(filtered_tools) + node_specs = format_available_nodes(list(available_nodes) if available_nodes else []) + existing_nodes_context = format_existing_nodes(list(existing_nodes) if existing_nodes else None) + existing_edges_context = format_existing_edges(list(existing_edges) if existing_edges else None) + selected_nodes_context = format_selected_nodes( + list(selected_node_ids) if selected_node_ids else None, list(existing_nodes) if existing_nodes else None + ) + + # Build retry context + retry_context = "" + + # NOTE: Manual regeneration/refinement mode removed + # Only handle automatic retry (validation errors) + + # For automatic retry (validation errors) + if attempt > 0 and validation_hints: + severe_issues = [h for h in validation_hints if h.severity == "error"] + if severe_issues: + retry_context = "\n\n" + retry_context += "The previous generation had validation errors:\n" + for idx, hint in enumerate(severe_issues[:5], 1): + retry_context += f"{idx}. {hint.message}\n" + retry_context += "\nPlease fix these specific issues while keeping everything else UNCHANGED.\n" + retry_context += "\n" + + # Select prompt version based on use_graph_builder flag + if use_graph_builder: + builder_system = BUILDER_SYSTEM_PROMPT_V2.format( + plan_context=json.dumps(plan_data.get("steps", []), indent=2), + tool_schemas=tool_schemas, + builtin_node_specs=node_specs, + available_models=format_available_models(list(available_models or [])), + preferred_language=preferred_language or "English", + existing_nodes_context=existing_nodes_context, + selected_nodes_context=selected_nodes_context, + ) + builder_user = BUILDER_USER_PROMPT_V2.format(instruction=instruction) + retry_context + else: + builder_system = BUILDER_SYSTEM_PROMPT.format( + plan_context=json.dumps(plan_data.get("steps", []), indent=2), + tool_schemas=tool_schemas, + builtin_node_specs=node_specs, + available_models=format_available_models(list(available_models or [])), + preferred_language=preferred_language or "English", + existing_nodes_context=existing_nodes_context, + existing_edges_context=existing_edges_context, + selected_nodes_context=selected_nodes_context, + ) + builder_user = BUILDER_USER_PROMPT.format(instruction=instruction) + retry_context + + try: + build_res = model_instance.invoke_llm( + prompt_messages=[ + SystemPromptMessage(content=builder_system), + UserPromptMessage(content=builder_user), + ], + model_parameters=model_parameters, + stream=False, + ) + # Builder output is raw JSON nodes/edges + build_content = build_res.message.content + match = re.search(r"```(?:json)?\s*([\s\S]+?)```", build_content) + if match: + build_content = match.group(1) + + workflow_data = json_repair.loads(build_content) + + if "nodes" not in workflow_data: + workflow_data["nodes"] = [] + + # --- GraphBuilder Mode: Build graph from depends_on --- + if use_graph_builder: + try: + # Extract nodes from LLM output (without start/end) + llm_nodes = workflow_data.get("nodes", []) + + # Build complete graph with start/end and edges + complete_nodes, edges = GraphBuilder.build_graph(llm_nodes) + + workflow_data["nodes"] = complete_nodes + workflow_data["edges"] = edges + + logger.info( + "GraphBuilder: built %d nodes, %d edges from %d LLM nodes", + len(complete_nodes), + len(edges), + len(llm_nodes), + ) + + except CyclicDependencyError as e: + logger.warning("GraphBuilder: cyclic dependency detected: %s", e) + # Add to validation hints for retry + validation_hints.append( + ValidationHint( + node_id="", + field="depends_on", + message=f"Cyclic dependency detected: {e}. Please fix the dependency chain.", + severity="error", + ) + ) + if attempt == MAX_GLOBAL_RETRIES - 1: + return { + "intent": "error", + "error": "Failed to build workflow: cyclic dependency detected.", + } + continue # Retry with error feedback + + except Exception as e: + logger.exception("GraphBuilder failed on attempt %d", attempt + 1) + if attempt == MAX_GLOBAL_RETRIES - 1: + return {"intent": "error", "error": f"Graph building failed: {str(e)}"} + continue + else: + # Legacy mode: edges from LLM output + if "edges" not in workflow_data: + workflow_data["edges"] = [] + + except Exception as e: + logger.exception("Builder failed on attempt %d", attempt + 1) + if attempt == MAX_GLOBAL_RETRIES - 1: + return {"intent": "error", "error": f"Building failed: {str(e)}"} + continue # Try again + + # NOTE: NodeRepair and EdgeRepair have been removed. + # Validation will detect structural issues, and LLM will fix them on retry. + # This is more accurate because LLM understands the workflow context. + + # --- STEP 4: RENDERER (Generate Mermaid early for validation) --- + mermaid_code = generate_mermaid(workflow_data) + + # --- STEP 5: VALIDATOR --- + is_valid, validation_hints = WorkflowValidator.validate(workflow_data, available_tools_list) + + # --- STEP 6: GRAPH VALIDATION (structural checks using graph algorithms) --- + if attempt < MAX_GLOBAL_RETRIES - 1: + try: + from core.workflow.generator.utils.graph_validator import GraphValidator + + graph_result = GraphValidator.validate(workflow_data) + + if not graph_result.success: + # Convert graph errors to validation hints + for graph_error in graph_result.errors: + validation_hints.append( + ValidationHint( + node_id=graph_error.node_id, + field="edges", + message=f"[Graph] {graph_error.message}", + severity="error", + ) + ) + # Also add warnings (dead ends) as hints + for graph_warning in graph_result.warnings: + validation_hints.append( + ValidationHint( + node_id=graph_warning.node_id, + field="edges", + message=f"[Graph] {graph_warning.message}", + severity="warning", + ) + ) + except Exception as e: + logger.warning("Graph validation error: %s", e) + # Collect all validation warnings + all_warnings = [h.message for h in validation_hints] + + # Check if we should retry + severe_issues = [h for h in validation_hints if h.severity == "error"] + + if not severe_issues or attempt == MAX_GLOBAL_RETRIES - 1: + break + + # Has severe errors and retries remaining - continue to next attempt + + # Collect all validation warnings + all_warnings = [h.message for h in validation_hints] + + # Add stability warning (as requested by user) + stability_warning = "The generated workflow may require debugging." + if preferred_language and preferred_language.startswith("zh"): + stability_warning = "生成的 Workflow 可能需要调试。" + all_warnings.append(stability_warning) + + return { + "intent": "generate", + "flowchart": mermaid_code, + "nodes": workflow_data["nodes"], + "edges": workflow_data["edges"], + "message": plan_data.get("plan_thought", "Generated workflow based on your request."), + "warnings": all_warnings, + "tool_recommendations": [], # Legacy field + "error": "", + "fixed_issues": all_fixes, # Track what was auto-fixed + "retry_count": retry_count, # Track how many retries were needed + } diff --git a/api/core/workflow/generator/types.py b/api/core/workflow/generator/types.py new file mode 100644 index 0000000000..fd46dc519d --- /dev/null +++ b/api/core/workflow/generator/types.py @@ -0,0 +1,217 @@ +""" +Type definitions for Vibe Workflow Generator. + +This module provides: +- TypedDict classes for lightweight type hints (no runtime overhead) +- Pydantic models for runtime validation where needed + +Usage: + # For type hints only (no runtime validation): + from core.workflow.generator.types import WorkflowNodeDict, WorkflowEdgeDict + + # For runtime validation: + from core.workflow.generator.types import WorkflowNode, WorkflowEdge +""" + +from typing import Any, TypedDict + +from pydantic import BaseModel, Field + +# ============================================================ +# TypedDict definitions (lightweight, for type hints only) +# ============================================================ + + +class WorkflowNodeDict(TypedDict, total=False): + """ + Workflow node structure (TypedDict for hints). + + Attributes: + id: Unique node identifier + type: Node type (e.g., "start", "end", "llm", "if-else", "http-request") + title: Human-readable node title + config: Node-specific configuration + data: Additional node data + """ + + id: str + type: str + title: str + config: dict[str, Any] + data: dict[str, Any] + + +class WorkflowEdgeDict(TypedDict, total=False): + """ + Workflow edge structure (TypedDict for hints). + + Attributes: + source: Source node ID + target: Target node ID + sourceHandle: Branch handle for if-else/question-classifier nodes + """ + + source: str + target: str + sourceHandle: str + + +class AvailableModelDict(TypedDict): + """ + Available model structure. + + Attributes: + provider: Model provider (e.g., "openai", "anthropic") + model: Model name (e.g., "gpt-4", "claude-3") + """ + + provider: str + model: str + + +class ToolParameterDict(TypedDict, total=False): + """ + Tool parameter structure. + + Attributes: + name: Parameter name + type: Parameter type (e.g., "string", "number", "boolean") + required: Whether parameter is required + human_description: Human-readable description + llm_description: LLM-oriented description + options: Available options for enum-type parameters + """ + + name: str + type: str + required: bool + human_description: str | dict[str, str] + llm_description: str + options: list[Any] + + +class AvailableToolDict(TypedDict, total=False): + """ + Available tool structure. + + Attributes: + provider_id: Tool provider ID + provider: Tool provider name (alternative to provider_id) + tool_key: Unique tool key + tool_name: Tool name (alternative to tool_key) + tool_description: Tool description + description: Alternative description field + is_team_authorization: Whether tool is configured/authorized + parameters: List of tool parameters + """ + + provider_id: str + provider: str + tool_key: str + tool_name: str + tool_description: str + description: str + is_team_authorization: bool + parameters: list[ToolParameterDict] + + +class WorkflowDataDict(TypedDict, total=False): + """ + Complete workflow data structure. + + Attributes: + nodes: List of workflow nodes + edges: List of workflow edges + warnings: List of warning messages + """ + + nodes: list[WorkflowNodeDict] + edges: list[WorkflowEdgeDict] + warnings: list[str] + + +# ============================================================ +# Pydantic models (for runtime validation) +# ============================================================ + + +class WorkflowNode(BaseModel): + """ + Workflow node with runtime validation. + + Use this model when you need to validate node data at runtime. + For lightweight type hints without validation, use WorkflowNodeDict. + """ + + id: str + type: str + title: str = "" + config: dict[str, Any] = Field(default_factory=dict) + data: dict[str, Any] = Field(default_factory=dict) + + +class WorkflowEdge(BaseModel): + """ + Workflow edge with runtime validation. + + Use this model when you need to validate edge data at runtime. + For lightweight type hints without validation, use WorkflowEdgeDict. + """ + + source: str + target: str + sourceHandle: str | None = None + + +class AvailableModel(BaseModel): + """ + Available model with runtime validation. + + Use this model when you need to validate model data at runtime. + For lightweight type hints without validation, use AvailableModelDict. + """ + + provider: str + model: str + + +class ToolParameter(BaseModel): + """Tool parameter with runtime validation.""" + + name: str = "" + type: str = "string" + required: bool = False + human_description: str | dict[str, str] = "" + llm_description: str = "" + options: list[Any] = Field(default_factory=list) + + +class AvailableTool(BaseModel): + """ + Available tool with runtime validation. + + Use this model when you need to validate tool data at runtime. + For lightweight type hints without validation, use AvailableToolDict. + """ + + provider_id: str = "" + provider: str = "" + tool_key: str = "" + tool_name: str = "" + tool_description: str = "" + description: str = "" + is_team_authorization: bool = False + parameters: list[ToolParameter] = Field(default_factory=list) + + +class WorkflowData(BaseModel): + """ + Complete workflow data with runtime validation. + + Use this model when you need to validate workflow data at runtime. + For lightweight type hints without validation, use WorkflowDataDict. + """ + + nodes: list[WorkflowNode] = Field(default_factory=list) + edges: list[WorkflowEdge] = Field(default_factory=list) + warnings: list[str] = Field(default_factory=list) diff --git a/api/core/workflow/generator/utils/edge_repair.py b/api/core/workflow/generator/utils/edge_repair.py new file mode 100644 index 0000000000..a318fe7bee --- /dev/null +++ b/api/core/workflow/generator/utils/edge_repair.py @@ -0,0 +1,384 @@ +""" +Edge Repair Utility for Vibe Workflow Generation. + +This module provides intelligent edge repair capabilities for generated workflows. +It can detect and fix common edge issues: +- Missing edges between sequential nodes +- Incomplete branches for question-classifier and if-else nodes +- Orphaned nodes without connections + +The repair logic is deterministic and doesn't require LLM calls. +""" + +import logging +from dataclasses import dataclass, field + +from core.workflow.generator.types import WorkflowDataDict, WorkflowEdgeDict, WorkflowNodeDict + +logger = logging.getLogger(__name__) + + +@dataclass +class RepairResult: + """Result of edge repair operation.""" + + nodes: list[WorkflowNodeDict] + edges: list[WorkflowEdgeDict] + repairs_made: list[str] = field(default_factory=list) + warnings: list[str] = field(default_factory=list) + + @property + def was_repaired(self) -> bool: + """Check if any repairs were made.""" + return len(self.repairs_made) > 0 + + +class EdgeRepair: + """ + Intelligent edge repair for workflow graphs. + + Repairs are applied in order: + 1. Infer linear connections from node order (if no edges exist) + 2. Add missing branch edges for question-classifier + 3. Add missing branch edges for if-else + 4. Connect orphaned nodes + """ + + @classmethod + def repair(cls, workflow_data: WorkflowDataDict) -> RepairResult: + """ + Repair edges in the workflow data. + + Args: + workflow_data: Dict containing 'nodes' and 'edges' + + Returns: + RepairResult with repaired nodes, edges, and repair logs + """ + nodes = list(workflow_data.get("nodes", [])) + edges = list(workflow_data.get("edges", [])) + repairs: list[str] = [] + warnings: list[str] = [] + + logger.info("[EDGE REPAIR] Starting repair process for %s nodes, %s edges", len(nodes), len(edges)) + + # Build node lookup + + # Build node lookup + node_map = {n.get("id"): n for n in nodes if n.get("id")} + node_ids = set(node_map.keys()) + + # 1. If no edges at all, infer linear chain + if not edges and len(nodes) > 1: + edges, inferred_repairs = cls._infer_linear_chain(nodes) + repairs.extend(inferred_repairs) + + # 2. Build edge index for analysis + outgoing_edges: dict[str, list[WorkflowEdgeDict]] = {} + incoming_edges: dict[str, list[WorkflowEdgeDict]] = {} + for edge in edges: + src = edge.get("source") + tgt = edge.get("target") + if src: + outgoing_edges.setdefault(src, []).append(edge) + if tgt: + incoming_edges.setdefault(tgt, []).append(edge) + + # 3. Repair question-classifier branches + for node in nodes: + if node.get("type") == "question-classifier": + new_edges, branch_repairs, branch_warnings = cls._repair_classifier_branches( + node, edges, outgoing_edges, node_ids + ) + edges.extend(new_edges) + repairs.extend(branch_repairs) + warnings.extend(branch_warnings) + # Update outgoing index + for edge in new_edges: + outgoing_edges.setdefault(edge.get("source"), []).append(edge) + + # 4. Repair if-else branches + for node in nodes: + if node.get("type") == "if-else": + new_edges, branch_repairs, branch_warnings = cls._repair_if_else_branches( + node, edges, outgoing_edges, node_ids + ) + edges.extend(new_edges) + repairs.extend(branch_repairs) + warnings.extend(branch_warnings) + # Update outgoing index + for edge in new_edges: + outgoing_edges.setdefault(edge.get("source"), []).append(edge) + + # 5. Connect orphaned nodes (nodes with no incoming edge, except start) + new_edges, orphan_repairs = cls._connect_orphaned_nodes(nodes, edges, outgoing_edges, incoming_edges) + edges.extend(new_edges) + repairs.extend(orphan_repairs) + + # 6. Connect nodes with no outgoing edge to 'end' (except end nodes) + new_edges, terminal_repairs = cls._connect_terminal_nodes(nodes, edges, outgoing_edges) + edges.extend(new_edges) + repairs.extend(terminal_repairs) + + if repairs: + logger.info("[EDGE REPAIR] Completed with %s repairs:", len(repairs)) + for i, repair in enumerate(repairs, 1): + logger.info("[EDGE REPAIR] %s. %s", i, repair) + else: + logger.info("[EDGE REPAIR] Completed - no repairs needed") + + return RepairResult( + nodes=nodes, + edges=edges, + repairs_made=repairs, + warnings=warnings, + ) + + @classmethod + def _infer_linear_chain(cls, nodes: list[WorkflowNodeDict]) -> tuple[list[WorkflowEdgeDict], list[str]]: + """ + Infer a linear chain of edges from node order. + + This is used when no edges are provided at all. + """ + edges: list[WorkflowEdgeDict] = [] + repairs: list[str] = [] + + # Filter to get ordered node IDs + node_ids = [n.get("id") for n in nodes if n.get("id")] + + if len(node_ids) < 2: + return edges, repairs + + # Create edges between consecutive nodes + for i in range(len(node_ids) - 1): + src = node_ids[i] + tgt = node_ids[i + 1] + edges.append({"source": src, "target": tgt}) + repairs.append(f"Inferred edge: {src} -> {tgt}") + + return edges, repairs + + @classmethod + def _repair_classifier_branches( + cls, + node: WorkflowNodeDict, + edges: list[WorkflowEdgeDict], + outgoing_edges: dict[str, list[WorkflowEdgeDict]], + valid_node_ids: set[str], + ) -> tuple[list[WorkflowEdgeDict], list[str], list[str]]: + """ + Repair missing branches for question-classifier nodes. + + For each class that doesn't have an edge, create one pointing to 'end'. + """ + new_edges: list[WorkflowEdgeDict] = [] + repairs: list[str] = [] + warnings: list[str] = [] + + node_id = node.get("id") + if not node_id: + return new_edges, repairs, warnings + + config = node.get("config", {}) + classes = config.get("classes", []) + + if not classes: + return new_edges, repairs, warnings + + # Get existing sourceHandles for this node + existing_handles = set() + for edge in outgoing_edges.get(node_id, []): + handle = edge.get("sourceHandle") + if handle: + existing_handles.add(handle) + + # Find 'end' node as default target + end_node_id = "end" + if "end" not in valid_node_ids: + # Try to find an end node + for nid in valid_node_ids: + if "end" in nid.lower(): + end_node_id = nid + break + + # Add missing branches + for cls_def in classes: + if not isinstance(cls_def, dict): + continue + cls_id = cls_def.get("id") + cls_name = cls_def.get("name", cls_id) + + if cls_id and cls_id not in existing_handles: + new_edge = { + "source": node_id, + "sourceHandle": cls_id, + "target": end_node_id, + } + new_edges.append(new_edge) + repairs.append(f"Added missing branch edge for class '{cls_name}' -> {end_node_id}") + warnings.append( + f"Auto-connected question-classifier branch '{cls_name}' to '{end_node_id}'. " + "You may want to redirect this to a specific handler node." + ) + + return new_edges, repairs, warnings + + @classmethod + def _repair_if_else_branches( + cls, + node: WorkflowNodeDict, + edges: list[WorkflowEdgeDict], + outgoing_edges: dict[str, list[WorkflowEdgeDict]], + valid_node_ids: set[str], + ) -> tuple[list[WorkflowEdgeDict], list[str], list[str]]: + """ + Repair missing branches for if-else nodes. + + If-else in Dify uses case_id as sourceHandle for each condition, + plus 'false' for the else branch. + """ + new_edges: list[WorkflowEdgeDict] = [] + repairs: list[str] = [] + warnings: list[str] = [] + + node_id = node.get("id") + if not node_id: + return new_edges, repairs, warnings + + # Get existing sourceHandles + existing_handles = set() + for edge in outgoing_edges.get(node_id, []): + handle = edge.get("sourceHandle") + if handle: + existing_handles.add(handle) + + # Find 'end' node as default target + end_node_id = "end" + if "end" not in valid_node_ids: + for nid in valid_node_ids: + if "end" in nid.lower(): + end_node_id = nid + break + + # Get required branches from config + config = node.get("config", {}) + cases = config.get("cases", []) + + # Build required handles: each case_id + 'false' for else + required_branches = set() + for case in cases: + case_id = case.get("case_id") + if case_id: + required_branches.add(case_id) + required_branches.add("false") # else branch + + # Add missing branches + for branch in required_branches: + if branch not in existing_handles: + new_edge = { + "source": node_id, + "sourceHandle": branch, + "target": end_node_id, + } + new_edges.append(new_edge) + repairs.append(f"Added missing if-else branch '{branch}' -> {end_node_id}") + warnings.append( + f"Auto-connected if-else branch '{branch}' to '{end_node_id}'. " + "You may want to redirect this to a specific handler node." + ) + + return new_edges, repairs, warnings + + @classmethod + def _connect_orphaned_nodes( + cls, + nodes: list[WorkflowNodeDict], + edges: list[WorkflowEdgeDict], + outgoing_edges: dict[str, list[WorkflowEdgeDict]], + incoming_edges: dict[str, list[WorkflowEdgeDict]], + ) -> tuple[list[WorkflowEdgeDict], list[str]]: + """ + Connect orphaned nodes to the previous node in sequence. + + An orphaned node has no incoming edges and is not a 'start' node. + """ + new_edges: list[WorkflowEdgeDict] = [] + repairs: list[str] = [] + + node_ids = [n.get("id") for n in nodes if n.get("id")] + node_types = {n.get("id"): n.get("type") for n in nodes} + + for i, node_id in enumerate(node_ids): + node_type = node_types.get(node_id) + + # Skip start nodes - they don't need incoming edges + if node_type == "start": + continue + + # Check if node has incoming edges + if node_id not in incoming_edges or not incoming_edges[node_id]: + # Find previous node to connect from + if i > 0: + prev_node_id = node_ids[i - 1] + new_edge = {"source": prev_node_id, "target": node_id} + new_edges.append(new_edge) + repairs.append(f"Connected orphaned node: {prev_node_id} -> {node_id}") + + # Update incoming_edges for subsequent checks + incoming_edges.setdefault(node_id, []).append(new_edge) + + return new_edges, repairs + + @classmethod + def _connect_terminal_nodes( + cls, + nodes: list[WorkflowNodeDict], + edges: list[WorkflowEdgeDict], + outgoing_edges: dict[str, list[WorkflowEdgeDict]], + ) -> tuple[list[WorkflowEdgeDict], list[str]]: + """ + Connect terminal nodes (no outgoing edges) to 'end'. + + A terminal node has no outgoing edges and is not an 'end' node. + This ensures all branches eventually reach 'end'. + """ + new_edges: list[WorkflowEdgeDict] = [] + repairs: list[str] = [] + + # Find end node + end_node_id = None + node_ids = set() + for n in nodes: + nid = n.get("id") + ntype = n.get("type") + if nid: + node_ids.add(nid) + if ntype == "end": + end_node_id = nid + + if not end_node_id: + # No end node found, can't connect + return new_edges, repairs + + for node in nodes: + node_id = node.get("id") + node_type = node.get("type") + + # Skip end nodes + if node_type == "end": + continue + + # Skip nodes that already have outgoing edges + if outgoing_edges.get(node_id): + continue + + # Connect to end + new_edge = {"source": node_id, "target": end_node_id} + new_edges.append(new_edge) + repairs.append(f"Connected terminal node to end: {node_id} -> {end_node_id}") + + # Update for subsequent checks + outgoing_edges.setdefault(node_id, []).append(new_edge) + + return new_edges, repairs diff --git a/api/core/workflow/generator/utils/graph_builder.py b/api/core/workflow/generator/utils/graph_builder.py new file mode 100644 index 0000000000..9f3fde3b4a --- /dev/null +++ b/api/core/workflow/generator/utils/graph_builder.py @@ -0,0 +1,621 @@ +""" +GraphBuilder: Automatic workflow graph construction from node list. + +This module implements the core logic for building complete workflow graphs +from LLM-generated node lists with dependency declarations. + +Key features: +- Automatic start/end node generation +- Dependency inference from variable references +- Topological sorting with cycle detection +- Special handling for branching nodes (if-else, question-classifier) +- Silent error recovery where possible +""" + +import json +import logging +import re +import uuid +from collections import defaultdict +from typing import Any + +logger = logging.getLogger(__name__) + +# Pattern to match variable references like {{#node_id.field#}} +VAR_PATTERN = re.compile(r"\{\{#([^.#]+)\.[^#]+#\}\}") + +# System variable prefixes to exclude from dependency inference +SYSTEM_VAR_PREFIXES = {"sys", "start", "env"} + +# Node types that have special branching behavior +BRANCHING_NODE_TYPES = {"if-else", "question-classifier"} + +# Container node types (iteration, loop) - these have internal subgraphs +# but behave as single-input-single-output nodes in the external graph +CONTAINER_NODE_TYPES = {"iteration", "loop"} + + +class GraphBuildError(Exception): + """Raised when graph cannot be built due to unrecoverable errors.""" + + pass + + +class CyclicDependencyError(GraphBuildError): + """Raised when cyclic dependencies are detected.""" + + pass + + +class GraphBuilder: + """ + Builds complete workflow graphs from LLM-generated node lists. + + This class handles the conversion from a simplified node list format + (with depends_on declarations) to a full workflow graph with nodes and edges. + + The LLM only needs to generate: + - Node configurations with depends_on arrays + - Branch targets in config for branching nodes + + The GraphBuilder automatically: + - Adds start and end nodes + - Generates all edges from dependencies + - Infers implicit dependencies from variable references + - Handles branching nodes (if-else, question-classifier) + - Validates graph structure (no cycles, proper connectivity) + """ + + @classmethod + def build_graph( + cls, + nodes: list[dict[str, Any]], + start_config: dict[str, Any] | None = None, + end_config: dict[str, Any] | None = None, + ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + """ + Build a complete workflow graph from a node list. + + Args: + nodes: LLM-generated nodes (without start/end) + start_config: Optional configuration for start node + end_config: Optional configuration for end node + + Returns: + Tuple of (complete_nodes, edges) where: + - complete_nodes includes start, user nodes, and end + - edges contains all connections + + Raises: + CyclicDependencyError: If cyclic dependencies are detected + GraphBuildError: If graph cannot be built + """ + if not nodes: + # Empty node list - create minimal workflow + start_node = cls._create_start_node([], start_config) + end_node = cls._create_end_node([], end_config) + edge = cls._create_edge("start", "end") + return [start_node, end_node], [edge] + + # Build node index for quick lookup + node_map = {node["id"]: node for node in nodes} + + # Step 1: Extract explicit dependencies from depends_on + dependencies = cls._extract_explicit_dependencies(nodes) + + # Step 2: Infer implicit dependencies from variable references + dependencies = cls._infer_dependencies_from_variables(nodes, dependencies, node_map) + + # Step 3: Validate and fix dependencies (remove invalid references) + dependencies = cls._validate_dependencies(dependencies, node_map) + + # Step 4: Topological sort (detects cycles) + sorted_node_ids = cls._topological_sort(nodes, dependencies) + + # Step 5: Generate start node + start_node = cls._create_start_node(nodes, start_config) + + # Step 6: Generate edges + edges = cls._generate_edges(nodes, sorted_node_ids, dependencies, node_map) + + # Step 7: Find terminal nodes and generate end node + terminal_nodes = cls._find_terminal_nodes(nodes, dependencies, node_map) + end_node = cls._create_end_node(terminal_nodes, end_config) + + # Step 8: Add edges from terminal nodes to end + for terminal_id in terminal_nodes: + edges.append(cls._create_edge(terminal_id, "end")) + + # Step 9: Assemble complete node list + all_nodes = [start_node, *nodes, end_node] + + return all_nodes, edges + + @classmethod + def _extract_explicit_dependencies( + cls, + nodes: list[dict[str, Any]], + ) -> dict[str, list[str]]: + """ + Extract explicit dependencies from depends_on field. + + Args: + nodes: List of nodes with optional depends_on field + + Returns: + Dictionary mapping node_id -> list of dependency node_ids + """ + dependencies: dict[str, list[str]] = {} + + for node in nodes: + node_id = node.get("id", "") + depends_on = node.get("depends_on", []) + + # Ensure depends_on is a list + if isinstance(depends_on, str): + depends_on = [depends_on] if depends_on else [] + elif not isinstance(depends_on, list): + depends_on = [] + + dependencies[node_id] = list(depends_on) + + return dependencies + + @classmethod + def _infer_dependencies_from_variables( + cls, + nodes: list[dict[str, Any]], + explicit_deps: dict[str, list[str]], + node_map: dict[str, dict[str, Any]], + ) -> dict[str, list[str]]: + """ + Infer implicit dependencies from variable references in config. + + Scans node configurations for patterns like {{#node_id.field#}} + and adds those as dependencies if not already declared. + + Args: + nodes: List of nodes + explicit_deps: Already extracted explicit dependencies + node_map: Map of node_id -> node for validation + + Returns: + Updated dependencies dictionary + """ + for node in nodes: + node_id = node.get("id", "") + config = node.get("config", {}) + + # Serialize config to search for variable references + try: + config_str = json.dumps(config, ensure_ascii=False) + except (TypeError, ValueError): + continue + + # Find all variable references + referenced_nodes = set(VAR_PATTERN.findall(config_str)) + + # Filter out system variables + referenced_nodes -= SYSTEM_VAR_PREFIXES + + # Ensure node_id exists in dependencies + if node_id not in explicit_deps: + explicit_deps[node_id] = [] + + # Add inferred dependencies + for ref in referenced_nodes: + # Skip self-references (e.g., loop nodes referencing their own outputs) + if ref == node_id: + logger.debug( + "Skipping self-reference: %s -> %s", + node_id, + ref, + ) + continue + + if ref in node_map and ref not in explicit_deps[node_id]: + explicit_deps[node_id].append(ref) + logger.debug( + "Inferred dependency: %s -> %s (from variable reference)", + node_id, + ref, + ) + + return explicit_deps + + @classmethod + def _validate_dependencies( + cls, + dependencies: dict[str, list[str]], + node_map: dict[str, dict[str, Any]], + ) -> dict[str, list[str]]: + """ + Validate dependencies and remove invalid references. + + Silent fix: References to non-existent nodes are removed. + + Args: + dependencies: Dependencies to validate + node_map: Map of valid node IDs + + Returns: + Validated dependencies + """ + valid_deps: dict[str, list[str]] = {} + + for node_id, deps in dependencies.items(): + valid_deps[node_id] = [] + for dep in deps: + if dep in node_map: + valid_deps[node_id].append(dep) + else: + logger.warning( + "Removed invalid dependency: %s -> %s (node does not exist)", + node_id, + dep, + ) + + return valid_deps + + @classmethod + def _topological_sort( + cls, + nodes: list[dict[str, Any]], + dependencies: dict[str, list[str]], + ) -> list[str]: + """ + Perform topological sort on nodes based on dependencies. + + Uses Kahn's algorithm for cycle detection. + + Args: + nodes: List of nodes + dependencies: Dependency graph + + Returns: + List of node IDs in topological order + + Raises: + CyclicDependencyError: If cyclic dependencies are detected + """ + # Build in-degree map + in_degree: dict[str, int] = defaultdict(int) + reverse_deps: dict[str, list[str]] = defaultdict(list) + + node_ids = {node["id"] for node in nodes} + + for node_id in node_ids: + in_degree[node_id] = 0 + + for node_id, deps in dependencies.items(): + for dep in deps: + if dep in node_ids: + in_degree[node_id] += 1 + reverse_deps[dep].append(node_id) + + # Start with nodes that have no dependencies + queue = [nid for nid in node_ids if in_degree[nid] == 0] + sorted_ids: list[str] = [] + + while queue: + current = queue.pop(0) + sorted_ids.append(current) + + for dependent in reverse_deps[current]: + in_degree[dependent] -= 1 + if in_degree[dependent] == 0: + queue.append(dependent) + + # Check for cycles + if len(sorted_ids) != len(node_ids): + remaining = node_ids - set(sorted_ids) + raise CyclicDependencyError( + f"Cyclic dependency detected involving nodes: {remaining}" + ) + + return sorted_ids + + @classmethod + def _generate_edges( + cls, + nodes: list[dict[str, Any]], + sorted_node_ids: list[str], + dependencies: dict[str, list[str]], + node_map: dict[str, dict[str, Any]], + ) -> list[dict[str, Any]]: + """ + Generate all edges based on dependencies and special node handling. + + Args: + nodes: List of nodes + sorted_node_ids: Topologically sorted node IDs + dependencies: Dependency graph + node_map: Map of node_id -> node + + Returns: + List of edge dictionaries + """ + edges: list[dict[str, Any]] = [] + nodes_with_incoming: set[str] = set() + + # Track which nodes have outgoing edges from branching + branching_sources: set[str] = set() + + # First pass: Handle branching nodes + for node in nodes: + node_id = node.get("id", "") + node_type = node.get("type", "") + + if node_type == "if-else": + branch_edges = cls._handle_if_else_node(node) + edges.extend(branch_edges) + branching_sources.add(node_id) + nodes_with_incoming.update(edge["target"] for edge in branch_edges) + + elif node_type == "question-classifier": + branch_edges = cls._handle_question_classifier_node(node) + edges.extend(branch_edges) + branching_sources.add(node_id) + nodes_with_incoming.update(edge["target"] for edge in branch_edges) + + # Second pass: Generate edges from dependencies + for node_id in sorted_node_ids: + deps = dependencies.get(node_id, []) + + if deps: + # Connect from each dependency + for dep_id in deps: + dep_node = node_map.get(dep_id, {}) + dep_type = dep_node.get("type", "") + + # Skip if dependency is a branching node (edges handled above) + if dep_type in BRANCHING_NODE_TYPES: + continue + + edges.append(cls._create_edge(dep_id, node_id)) + nodes_with_incoming.add(node_id) + else: + # No dependencies - connect from start + # But skip if this node receives edges from branching nodes + if node_id not in nodes_with_incoming: + edges.append(cls._create_edge("start", node_id)) + nodes_with_incoming.add(node_id) + + return edges + + @classmethod + def _handle_if_else_node( + cls, + node: dict[str, Any], + ) -> list[dict[str, Any]]: + """ + Handle if-else node branching. + + Expects config to contain true_branch and/or false_branch. + + Args: + node: If-else node + + Returns: + List of branch edges + """ + edges: list[dict[str, Any]] = [] + node_id = node.get("id", "") + config = node.get("config", {}) + + true_branch = config.get("true_branch") + false_branch = config.get("false_branch") + + if true_branch: + edges.append(cls._create_edge(node_id, true_branch, source_handle="true")) + + if false_branch: + edges.append(cls._create_edge(node_id, false_branch, source_handle="false")) + + # If no branches specified, log warning + if not true_branch and not false_branch: + logger.warning( + "if-else node %s has no branch targets specified", + node_id, + ) + + return edges + + @classmethod + def _handle_question_classifier_node( + cls, + node: dict[str, Any], + ) -> list[dict[str, Any]]: + """ + Handle question-classifier node branching. + + Expects config.classes to contain class definitions with target fields. + + Args: + node: Question-classifier node + + Returns: + List of branch edges + """ + edges: list[dict[str, Any]] = [] + node_id = node.get("id", "") + config = node.get("config", {}) + classes = config.get("classes", []) + + if not classes: + logger.warning( + "question-classifier node %s has no classes defined", + node_id, + ) + return edges + + for cls_def in classes: + class_id = cls_def.get("id", "") + target = cls_def.get("target") + + if target: + edges.append(cls._create_edge(node_id, target, source_handle=class_id)) + else: + # Silent fix: Connect to end if no target specified + edges.append(cls._create_edge(node_id, "end", source_handle=class_id)) + logger.debug( + "question-classifier class %s has no target, connecting to end", + class_id, + ) + + return edges + + @classmethod + def _find_terminal_nodes( + cls, + nodes: list[dict[str, Any]], + dependencies: dict[str, list[str]], + node_map: dict[str, dict[str, Any]], + ) -> list[str]: + """ + Find nodes that should connect to the end node. + + Terminal nodes are those that: + - Are not dependencies of any other node + - Are not branching nodes (those connect to their branches) + + Args: + nodes: List of nodes + dependencies: Dependency graph + node_map: Map of node_id -> node + + Returns: + List of terminal node IDs + """ + # Build set of all nodes that are depended upon + depended_upon: set[str] = set() + for deps in dependencies.values(): + depended_upon.update(deps) + + # Also track nodes that are branch targets + branch_targets: set[str] = set() + branching_nodes: set[str] = set() + + for node in nodes: + node_id = node.get("id", "") + node_type = node.get("type", "") + config = node.get("config", {}) + + if node_type == "if-else": + branching_nodes.add(node_id) + if config.get("true_branch"): + branch_targets.add(config["true_branch"]) + if config.get("false_branch"): + branch_targets.add(config["false_branch"]) + + elif node_type == "question-classifier": + branching_nodes.add(node_id) + for cls_def in config.get("classes", []): + if cls_def.get("target"): + branch_targets.add(cls_def["target"]) + + # Find terminal nodes + terminal_nodes: list[str] = [] + for node in nodes: + node_id = node.get("id", "") + node_type = node.get("type", "") + + # Skip branching nodes - they don't connect to end directly + if node_type in BRANCHING_NODE_TYPES: + continue + + # Terminal if not depended upon and not a branch target that leads elsewhere + if node_id not in depended_upon: + terminal_nodes.append(node_id) + + # If no terminal nodes found (shouldn't happen), use all non-branching nodes + if not terminal_nodes: + terminal_nodes = [ + node["id"] + for node in nodes + if node.get("type") not in BRANCHING_NODE_TYPES + ] + logger.warning("No terminal nodes found, using all non-branching nodes") + + return terminal_nodes + + @classmethod + def _create_start_node( + cls, + nodes: list[dict[str, Any]], + config: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """ + Create a start node. + + Args: + nodes: User nodes (for potential config inference) + config: Optional start node configuration + + Returns: + Start node dictionary + """ + return { + "id": "start", + "type": "start", + "title": "Start", + "config": config or {}, + "data": {}, + } + + @classmethod + def _create_end_node( + cls, + terminal_nodes: list[str], + config: dict[str, Any] | None = None, + ) -> dict[str, Any]: + """ + Create an end node. + + Args: + terminal_nodes: Nodes that will connect to end + config: Optional end node configuration + + Returns: + End node dictionary + """ + return { + "id": "end", + "type": "end", + "title": "End", + "config": config or {}, + "data": {}, + } + + @classmethod + def _create_edge( + cls, + source: str, + target: str, + source_handle: str | None = None, + ) -> dict[str, Any]: + """ + Create an edge dictionary. + + Args: + source: Source node ID + target: Target node ID + source_handle: Optional handle for branching (e.g., "true", "false", class_id) + + Returns: + Edge dictionary + """ + edge: dict[str, Any] = { + "id": f"{source}-{target}-{uuid.uuid4().hex[:8]}", + "source": source, + "target": target, + } + + if source_handle: + edge["sourceHandle"] = source_handle + else: + edge["sourceHandle"] = "source" + + edge["targetHandle"] = "target" + + return edge diff --git a/api/core/workflow/generator/utils/graph_validator.py b/api/core/workflow/generator/utils/graph_validator.py new file mode 100644 index 0000000000..dc8e89a054 --- /dev/null +++ b/api/core/workflow/generator/utils/graph_validator.py @@ -0,0 +1,280 @@ +""" +Graph Validator for Workflow Generation + +Validates workflow graph structure using graph algorithms: +- Reachability from start node (BFS) +- Reachability to end node (reverse BFS) +- Branch edge validation for if-else and classifier nodes +""" + +import time +from collections import deque +from dataclasses import dataclass, field + + +@dataclass +class GraphError: + """Represents a structural error in the workflow graph.""" + + node_id: str + node_type: str + error_type: str # "unreachable", "dead_end", "cycle", "missing_start", "missing_end" + message: str + + +@dataclass +class GraphValidationResult: + """Result of graph validation.""" + + success: bool + errors: list[GraphError] = field(default_factory=list) + warnings: list[GraphError] = field(default_factory=list) + execution_time: float = 0.0 + stats: dict = field(default_factory=dict) + + +class GraphValidator: + """ + Validates workflow graph structure using proper graph algorithms. + + Performs: + 1. Forward reachability analysis (BFS from start) + 2. Backward reachability analysis (reverse BFS from end) + 3. Branch edge validation for if-else and classifier nodes + """ + + @staticmethod + def _build_adjacency( + nodes: dict[str, dict], edges: list[dict] + ) -> tuple[dict[str, list[str]], dict[str, list[str]]]: + """Build forward and reverse adjacency lists from edges.""" + outgoing: dict[str, list[str]] = {node_id: [] for node_id in nodes} + incoming: dict[str, list[str]] = {node_id: [] for node_id in nodes} + + for edge in edges: + source = edge.get("source") + target = edge.get("target") + if source in outgoing and target in incoming: + outgoing[source].append(target) + incoming[target].append(source) + + return outgoing, incoming + + @staticmethod + def _bfs_reachable(start: str, adjacency: dict[str, list[str]]) -> set[str]: + """BFS to find all nodes reachable from start node.""" + if start not in adjacency: + return set() + + visited = set() + queue = deque([start]) + visited.add(start) + + while queue: + current = queue.popleft() + for neighbor in adjacency.get(current, []): + if neighbor not in visited: + visited.add(neighbor) + queue.append(neighbor) + + return visited + + @staticmethod + def validate(workflow_data: dict) -> GraphValidationResult: + """Validate workflow graph structure.""" + start_time = time.time() + errors: list[GraphError] = [] + warnings: list[GraphError] = [] + + nodes_list = workflow_data.get("nodes", []) + edges_list = workflow_data.get("edges", []) + nodes = {n["id"]: n for n in nodes_list if n.get("id")} + + # Find start and end nodes + start_node_id = None + end_node_ids = [] + + for node_id, node in nodes.items(): + node_type = node.get("type") + if node_type == "start": + start_node_id = node_id + elif node_type == "end": + end_node_ids.append(node_id) + + # Check start node exists + if not start_node_id: + errors.append( + GraphError( + node_id="workflow", + node_type="workflow", + error_type="missing_start", + message="Workflow has no start node", + ) + ) + + # Check end node exists + if not end_node_ids: + errors.append( + GraphError( + node_id="workflow", + node_type="workflow", + error_type="missing_end", + message="Workflow has no end node", + ) + ) + + # If missing start or end, can't do reachability analysis + if not start_node_id or not end_node_ids: + execution_time = time.time() - start_time + return GraphValidationResult( + success=False, + errors=errors, + warnings=warnings, + execution_time=execution_time, + stats={"nodes": len(nodes), "edges": len(edges_list)}, + ) + + # Build adjacency lists + outgoing, incoming = GraphValidator._build_adjacency(nodes, edges_list) + + # --- FORWARD REACHABILITY: BFS from start --- + reachable_from_start = GraphValidator._bfs_reachable(start_node_id, outgoing) + + # Find unreachable nodes + unreachable_nodes = set(nodes.keys()) - reachable_from_start + for node_id in unreachable_nodes: + node = nodes[node_id] + errors.append( + GraphError( + node_id=node_id, + node_type=node.get("type", "unknown"), + error_type="unreachable", + message=f"Node '{node_id}' is not reachable from start node", + ) + ) + + # --- BACKWARD REACHABILITY: Reverse BFS from end nodes --- + can_reach_end: set[str] = set() + for end_id in end_node_ids: + can_reach_end.update(GraphValidator._bfs_reachable(end_id, incoming)) + + # Find dead-end nodes (can't reach any end node) + dead_end_nodes = set(nodes.keys()) - can_reach_end + for node_id in dead_end_nodes: + if node_id in unreachable_nodes: + continue + node = nodes[node_id] + warnings.append( + GraphError( + node_id=node_id, + node_type=node.get("type", "unknown"), + error_type="dead_end", + message=f"Node '{node_id}' cannot reach any end node (dead end)", + ) + ) + + # --- Start node has outgoing edges? --- + if not outgoing.get(start_node_id): + errors.append( + GraphError( + node_id=start_node_id, + node_type="start", + error_type="disconnected", + message="Start node has no outgoing connections", + ) + ) + + # --- End nodes have incoming edges? --- + for end_id in end_node_ids: + if not incoming.get(end_id): + errors.append( + GraphError( + node_id=end_id, + node_type="end", + error_type="disconnected", + message="End node has no incoming connections", + ) + ) + + # --- BRANCH EDGE VALIDATION --- + edge_handles: dict[str, set[str]] = {} + for edge in edges_list: + source = edge.get("source") + handle = edge.get("sourceHandle", "") + if source: + if source not in edge_handles: + edge_handles[source] = set() + edge_handles[source].add(handle) + + # Check if-else and question-classifier nodes + for node_id, node in nodes.items(): + node_type = node.get("type") + + if node_type == "if-else": + handles = edge_handles.get(node_id, set()) + config = node.get("config", {}) + cases = config.get("cases", []) + + required_handles = set() + for case in cases: + case_id = case.get("case_id") + if case_id: + required_handles.add(case_id) + required_handles.add("false") + + missing = required_handles - handles + for handle in missing: + errors.append( + GraphError( + node_id=node_id, + node_type=node_type, + error_type="missing_branch", + message=f"If-else node '{node_id}' missing edge for branch '{handle}'", + ) + ) + + elif node_type == "question-classifier": + handles = edge_handles.get(node_id, set()) + config = node.get("config", {}) + classes = config.get("classes", []) + + required_handles = set() + for cls in classes: + if isinstance(cls, dict): + cls_id = cls.get("id") + if cls_id: + required_handles.add(cls_id) + + missing = required_handles - handles + for handle in missing: + cls_name = handle + for cls in classes: + if isinstance(cls, dict) and cls.get("id") == handle: + cls_name = cls.get("name", handle) + break + errors.append( + GraphError( + node_id=node_id, + node_type=node_type, + error_type="missing_branch", + message=f"Classifier '{node_id}' missing edge for class '{cls_name}'", + ) + ) + + execution_time = time.time() - start_time + success = len(errors) == 0 + + return GraphValidationResult( + success=success, + errors=errors, + warnings=warnings, + execution_time=execution_time, + stats={ + "nodes": len(nodes), + "edges": len(edges_list), + "reachable_from_start": len(reachable_from_start), + "can_reach_end": len(can_reach_end), + "unreachable": len(unreachable_nodes), + "dead_ends": len(dead_end_nodes - unreachable_nodes), + }, + ) diff --git a/api/core/workflow/generator/utils/mermaid_generator.py b/api/core/workflow/generator/utils/mermaid_generator.py new file mode 100644 index 0000000000..c042f7c481 --- /dev/null +++ b/api/core/workflow/generator/utils/mermaid_generator.py @@ -0,0 +1,113 @@ +import logging + +from core.workflow.generator.types import WorkflowDataDict + +logger = logging.getLogger(__name__) + + +def generate_mermaid(workflow_data: WorkflowDataDict) -> str: + """ + Generate a Mermaid flowchart from workflow data consisting of nodes and edges. + + Args: + workflow_data: Dict containing 'nodes' (list) and 'edges' (list) + + Returns: + String containing the Mermaid flowchart syntax + """ + nodes = workflow_data.get("nodes", []) + edges = workflow_data.get("edges", []) + + lines = ["flowchart TD"] + + # 1. Define Nodes + # Format: node_id["title
type"] or similar + # We will use the Vibe Workflow standard format: id["type=TYPE|title=TITLE"] + # Or specifically for tool nodes: id["type=tool|title=TITLE|tool=TOOL_KEY"] + + # Map of original IDs to safe Mermaid IDs + id_map = {} + + def get_safe_id(original_id: str) -> str: + if original_id == "end": + return "end_node" + if original_id == "subgraph": + return "subgraph_node" + # Mermaid IDs should be alphanumeric. + # If the ID has special chars, we might need to escape or hash, but Vibe usually generates simple IDs. + # We'll trust standard IDs but handle the reserved keyword 'end'. + return original_id + + for node in nodes: + node_id = node.get("id") + if not node_id: + continue + + safe_id = get_safe_id(node_id) + id_map[node_id] = safe_id + + node_type = node.get("type", "unknown") + title = node.get("title", "Untitled") + + # Escape quotes in title + safe_title = title.replace('"', "'") + + if node_type == "tool": + config = node.get("config", {}) + # Try multiple fields for tool reference + tool_ref = ( + config.get("tool_key") + or config.get("tool") + or config.get("tool_name") + or node.get("tool_name") + or "unknown" + ) + node_def = f'{safe_id}["type={node_type}|title={safe_title}|tool={tool_ref}"]' + else: + node_def = f'{safe_id}["type={node_type}|title={safe_title}"]' + + lines.append(f" {node_def}") + + # 2. Define Edges + # Format: source --> target + + # Track defined nodes to avoid edge errors + defined_node_ids = {n.get("id") for n in nodes if n.get("id")} + + for edge in edges: + source = edge.get("source") + target = edge.get("target") + + # Skip invalid edges + if not source or not target: + continue + + if source not in defined_node_ids or target not in defined_node_ids: + continue + + safe_source = id_map.get(source, source) + safe_target = id_map.get(target, target) + + # Handle conditional branches (true/false) if present + # In Dify workflow, sourceHandle is often used for this + source_handle = edge.get("sourceHandle") + label = "" + + if source_handle == "true": + label = "|true|" + elif source_handle == "false": + label = "|false|" + elif source_handle and source_handle != "source": + # For question-classifier or other multi-path nodes + # Clean up handle for display if needed + safe_handle = str(source_handle).replace('"', "'") + label = f"|{safe_handle}|" + + edge_line = f" {safe_source} -->{label} {safe_target}" + lines.append(edge_line) + + # Start/End nodes are implicitly handled if they are in the 'nodes' list + # If not, we might need to add them, but usually the Builder should produce them. + + result = "\n".join(lines) + return result diff --git a/api/core/workflow/generator/utils/node_repair.py b/api/core/workflow/generator/utils/node_repair.py new file mode 100644 index 0000000000..5fe81e560e --- /dev/null +++ b/api/core/workflow/generator/utils/node_repair.py @@ -0,0 +1,304 @@ +""" +Node Repair Utility for Vibe Workflow Generation. + +This module provides intelligent node configuration repair capabilities. +It can detect and fix common node configuration issues: +- Invalid comparison operators in if-else nodes (e.g. '>=' -> '≥') +""" + +import copy +import logging +import uuid +from dataclasses import dataclass, field + +from core.workflow.generator.types import WorkflowNodeDict + +logger = logging.getLogger(__name__) + + +@dataclass +class NodeRepairResult: + """Result of node repair operation.""" + + nodes: list[WorkflowNodeDict] + repairs_made: list[str] = field(default_factory=list) + warnings: list[str] = field(default_factory=list) + + @property + def was_repaired(self) -> bool: + """Check if any repairs were made.""" + return len(self.repairs_made) > 0 + + +class NodeRepair: + """ + Intelligent node configuration repair. + """ + + OPERATOR_MAP = { + ">=": "≥", + "<=": "≤", + "!=": "≠", + "==": "=", + } + + TYPE_MAPPING = { + "json": "object", + "dict": "object", + "dictionary": "object", + "float": "number", + "int": "number", + "integer": "number", + "double": "number", + "str": "string", + "text": "string", + "bool": "boolean", + "list": "array[object]", + "array": "array[object]", + } + + _REPAIR_HANDLERS = { + "if-else": "_repair_if_else_operators", + "variable-aggregator": "_repair_variable_aggregator_variables", + "code": "_repair_code_node_config", + } + + @classmethod + def repair( + cls, + nodes: list[WorkflowNodeDict], + llm_callback=None, + ) -> NodeRepairResult: + """ + Repair node configurations. + + Args: + nodes: List of node dictionaries + llm_callback: Optional callback(node, issue_desc) -> fixed_config_part + + Returns: + NodeRepairResult with repaired nodes and logs + """ + # Deep copy to avoid mutating original + nodes = copy.deepcopy(nodes) + repairs: list[str] = [] + warnings: list[str] = [] + + logger.info("[NODE REPAIR] Starting repair process for %s nodes", len(nodes)) + + for node in nodes: + node_type = node.get("type") + + # 1. Rule-based repairs + handler_name = cls._REPAIR_HANDLERS.get(node_type) + if handler_name: + handler = getattr(cls, handler_name) + # Check if handler accepts llm_callback (inspect signature or just pass generic kwargs?) + # Simplest for now: handlers signature: (node, repairs, llm_callback=None) + try: + handler(node, repairs, llm_callback=llm_callback) + except TypeError: + # Fallback for handlers that don't accept llm_callback yet + handler(node, repairs) + + # Add other node type repairs here as needed + + if repairs: + logger.info("[NODE REPAIR] Completed with %s repairs:", len(repairs)) + for i, repair in enumerate(repairs, 1): + logger.info("[NODE REPAIR] %s. %s", i, repair) + else: + logger.info("[NODE REPAIR] Completed - no repairs needed") + + return NodeRepairResult( + nodes=nodes, + repairs_made=repairs, + warnings=warnings, + ) + + @classmethod + def _repair_if_else_operators(cls, node: WorkflowNodeDict, repairs: list[str], **kwargs): + """ + Normalize comparison operators in if-else nodes. + And ensure 'id' field exists for cases and conditions (frontend requirement). + """ + node_id = node.get("id", "unknown") + config = node.get("config", {}) + cases = config.get("cases", []) + + for case in cases: + # Ensure case_id + if "case_id" not in case: + case["case_id"] = str(uuid.uuid4()) + repairs.append(f"Generated missing case_id for case in node '{node_id}'") + + conditions = case.get("conditions", []) + for condition in conditions: + # Ensure condition id + if "id" not in condition: + condition["id"] = str(uuid.uuid4()) + # Not logging this repair to avoid clutter, as it's a structural fix + + # Ensure value type (LLM might return int/float, but we need str/bool/list) + val = condition.get("value") + if isinstance(val, (int, float)) and not isinstance(val, bool): + condition["value"] = str(val) + repairs.append(f"Coerced numeric value to string in node '{node_id}'") + + op = condition.get("comparison_operator") + if op in cls.OPERATOR_MAP: + new_op = cls.OPERATOR_MAP[op] + condition["comparison_operator"] = new_op + repairs.append(f"Normalized operator '{op}' to '{new_op}' in node '{node_id}'") + + @classmethod + def _repair_variable_aggregator_variables(cls, node: WorkflowNodeDict, repairs: list[str]): + """ + Repair variable-aggregator variables format. + Converts dict format to list[list[str]] format. + Expected: [["node_id", "field"], ["node_id2", "field2"]] + May receive: [{"name": "...", "value_selector": ["node_id", "field"]}, ...] + """ + node_id = node.get("id", "unknown") + config = node.get("config", {}) + variables = config.get("variables", []) + + if not variables: + return + + repaired = False + repaired_variables = [] + + for var in variables: + if isinstance(var, dict): + # Convert dict format to array format + value_selector = var.get("value_selector") or var.get("selector") or var.get("path") + if isinstance(value_selector, list) and len(value_selector) > 0: + repaired_variables.append(value_selector) + repaired = True + else: + # Try to extract from name field - LLM may generate {"name": "node_id.field"} + name = var.get("name") + if isinstance(name, str) and "." in name: + # Try to parse "node_id.field" format + parts = name.split(".", 1) + if len(parts) == 2: + repaired_variables.append([parts[0], parts[1]]) + repaired = True + else: + logger.warning( + "Variable aggregator node '%s' has invalid variable format: %s", + node_id, + var, + ) + repaired_variables.append([]) # Empty array as fallback + else: + # If no valid selector or name, skip this variable + logger.warning( + "Variable aggregator node '%s' has invalid variable format: %s", + node_id, + var, + ) + # Don't add empty array - skip invalid variables + elif isinstance(var, list): + # Already in correct format + repaired_variables.append(var) + else: + # Unknown format, skip + logger.warning("Variable aggregator node '%s' has unknown variable format: %s", node_id, var) + # Don't add empty array - skip invalid variables + + if repaired: + config["variables"] = repaired_variables + repairs.append(f"Repaired variable-aggregator variables format in node '{node_id}'") + + @classmethod + def _repair_code_node_config(cls, node: WorkflowNodeDict, repairs: list[str], llm_callback=None): + """ + Repair code node configuration (outputs and variables). + 1. Outputs: Converts list format to dict format AND normalizes types. + 2. Variables: Ensures value_selector exists. + """ + node_id = node.get("id", "unknown") + config = node.get("config", {}) + + if "variables" not in config: + config["variables"] = [] + + # --- Repair Variables --- + variables = config.get("variables") + if isinstance(variables, list): + for var in variables: + if isinstance(var, dict): + # Ensure value_selector exists (frontend crashes if missing) + if "value_selector" not in var: + var["value_selector"] = [] + # Not logging trivial repairs + + # --- Repair Outputs --- + outputs = config.get("outputs") + + if not outputs: + return + + # Helper to normalize type + def normalize_type(t: str) -> str: + t_lower = str(t).lower() + return cls.TYPE_MAPPING.get(t_lower, t) + + # 1. Handle Dict format (Standard) - Check for invalid types + if isinstance(outputs, dict): + changed = False + for var_name, var_config in outputs.items(): + if isinstance(var_config, dict): + original_type = var_config.get("type") + if original_type: + new_type = normalize_type(original_type) + if new_type != original_type: + var_config["type"] = new_type + changed = True + repairs.append( + f"Normalized type '{original_type}' to '{new_type}' " + f"for var '{var_name}' in node '{node_id}'" + ) + return + + # 2. Handle List format (Repair needed) + if isinstance(outputs, list): + new_outputs = {} + for item in outputs: + if isinstance(item, dict): + var_name = item.get("variable") or item.get("name") + var_type = item.get("type") + if var_name and var_type: + norm_type = normalize_type(var_type) + new_outputs[var_name] = {"type": norm_type} + if norm_type != var_type: + repairs.append( + f"Normalized type '{var_type}' to '{norm_type}' " + f"during list conversion in node '{node_id}'" + ) + + if new_outputs: + config["outputs"] = new_outputs + repairs.append(f"Repaired code node outputs format in node '{node_id}'") + else: + # Fallback: Try LLM if available + if llm_callback: + try: + # Attempt to fix using LLM + fixed_outputs = llm_callback( + node, + "outputs must be a dictionary like {'var_name': {'type': 'string'}}, " + "but got a list or valid conversion failed.", + ) + if isinstance(fixed_outputs, dict) and fixed_outputs: + config["outputs"] = fixed_outputs + repairs.append(f"Repaired code node outputs format using LLM in node '{node_id}'") + return + except Exception as e: + logger.warning("LLM fallback repair failed for node '%s': %s", node_id, e) + + # If conversion/LLM failed, set to empty dict + config["outputs"] = {} + repairs.append(f"Reset invalid code node outputs to empty dict in node '{node_id}'") diff --git a/api/core/workflow/generator/utils/workflow_validator.py b/api/core/workflow/generator/utils/workflow_validator.py new file mode 100644 index 0000000000..4679cbfe24 --- /dev/null +++ b/api/core/workflow/generator/utils/workflow_validator.py @@ -0,0 +1,101 @@ +from dataclasses import dataclass + +from core.workflow.generator.types import AvailableModelDict, AvailableToolDict, WorkflowDataDict +from core.workflow.generator.validation.context import ValidationContext +from core.workflow.generator.validation.engine import ValidationEngine +from core.workflow.generator.validation.rules import Severity + + +@dataclass +class ValidationHint: + """Legacy compatibility class for validation hints.""" + + node_id: str + field: str + message: str + severity: str # 'error', 'warning' + suggestion: str = None + node_type: str = None # Added for test compatibility + + # Alias for potential old code using 'type' instead of 'severity' + @property + def type(self) -> str: + return self.severity + + @property + def element_id(self) -> str: + return self.node_id + + +FriendlyHint = ValidationHint # Alias for backward compatibility + + +class WorkflowValidator: + """ + Validates the generated workflow configuration (nodes and edges). + Wraps the new ValidationEngine for backward compatibility. + """ + + @classmethod + def validate( + cls, + workflow_data: WorkflowDataDict, + available_tools: list[AvailableToolDict], + available_models: list[AvailableModelDict] | None = None, + ) -> tuple[bool, list[ValidationHint]]: + """ + Validate workflow data and return validity status and hints. + + Args: + workflow_data: Dict containing 'nodes' and 'edges' + available_tools: List of available tool configurations + available_models: List of available models (added for Vibe compat) + + Returns: + Tuple(max_severity_is_not_error, list_of_hints) + """ + nodes = workflow_data.get("nodes", []) + edges = workflow_data.get("edges", []) + + # Create context + context = ValidationContext( + nodes=nodes, + edges=edges, + available_models=available_models or [], + available_tools=available_tools or [], + ) + + # Run validation engine + engine = ValidationEngine() + result = engine.validate(context) + + # Convert engine errors to legacy hints + hints: list[ValidationHint] = [] + + error_count = 0 + warning_count = 0 + + for error in result.all_errors: + # Map severity + severity = "error" if error.severity == Severity.ERROR else "warning" + + if severity == "error": + error_count += 1 + else: + warning_count += 1 + + # Map field from message or details if possible (heuristic) + field_name = error.details.get("field", "unknown") + + hints.append( + ValidationHint( + node_id=error.node_id, + field=field_name, + message=error.message, + severity=severity, + suggestion=error.fix_hint, + node_type=error.node_type, + ) + ) + + return result.is_valid, hints diff --git a/api/core/workflow/generator/validation/__init__.py b/api/core/workflow/generator/validation/__init__.py new file mode 100644 index 0000000000..1f54b6865a --- /dev/null +++ b/api/core/workflow/generator/validation/__init__.py @@ -0,0 +1,42 @@ +""" +Validation Rule Engine for Vibe Workflow Generation. + +This module provides a declarative, schema-based validation system for +generated workflow nodes. It classifies errors into fixable (LLM can auto-fix) +and user-required (needs manual intervention) categories. + +Usage: + from core.workflow.generator.validation import ValidationEngine, ValidationContext + + context = ValidationContext( + available_models=[...], + available_tools=[...], + nodes=[...], + edges=[...], + ) + engine = ValidationEngine() + result = engine.validate(context) + + # Access classified errors + fixable_errors = result.fixable_errors + user_required_errors = result.user_required_errors +""" + +from core.workflow.generator.validation.context import ValidationContext +from core.workflow.generator.validation.engine import ValidationEngine, ValidationResult +from core.workflow.generator.validation.rules import ( + RuleCategory, + Severity, + ValidationError, + ValidationRule, +) + +__all__ = [ + "RuleCategory", + "Severity", + "ValidationContext", + "ValidationEngine", + "ValidationError", + "ValidationResult", + "ValidationRule", +] diff --git a/api/core/workflow/generator/validation/context.py b/api/core/workflow/generator/validation/context.py new file mode 100644 index 0000000000..4f44f52440 --- /dev/null +++ b/api/core/workflow/generator/validation/context.py @@ -0,0 +1,115 @@ +""" +Validation Context for the Rule Engine. + +The ValidationContext holds all the data needed for validation: +- Generated nodes and edges +- Available models, tools, and datasets +- Node output schemas for variable reference validation +""" + +from dataclasses import dataclass, field + +from core.workflow.generator.types import ( + AvailableModelDict, + AvailableToolDict, + WorkflowEdgeDict, + WorkflowNodeDict, +) + + +@dataclass +class ValidationContext: + """ + Context object containing all data needed for validation. + + This is passed to each validation rule, providing access to: + - The nodes being validated + - Edge connections between nodes + - Available external resources (models, tools) + """ + + # Generated workflow data + nodes: list[WorkflowNodeDict] = field(default_factory=list) + edges: list[WorkflowEdgeDict] = field(default_factory=list) + + # Available external resources + available_models: list[AvailableModelDict] = field(default_factory=list) + available_tools: list[AvailableToolDict] = field(default_factory=list) + + # Cached lookups (populated lazily) + _node_map: dict[str, WorkflowNodeDict] | None = field(default=None, repr=False) + _model_set: set[tuple[str, str]] | None = field(default=None, repr=False) + _tool_set: set[str] | None = field(default=None, repr=False) + _configured_tool_set: set[str] | None = field(default=None, repr=False) + + @property + def node_map(self) -> dict[str, WorkflowNodeDict]: + """Get a map of node_id -> node for quick lookup.""" + if self._node_map is None: + self._node_map = {node.get("id", ""): node for node in self.nodes} + return self._node_map + + @property + def model_set(self) -> set[tuple[str, str]]: + """Get a set of (provider, model_name) tuples for quick lookup.""" + if self._model_set is None: + self._model_set = {(m.get("provider", ""), m.get("model", "")) for m in self.available_models} + return self._model_set + + @property + def tool_set(self) -> set[str]: + """Get a set of all tool keys (both configured and unconfigured).""" + if self._tool_set is None: + self._tool_set = set() + for tool in self.available_tools: + provider = tool.get("provider_id") or tool.get("provider", "") + tool_key = tool.get("tool_key") or tool.get("tool_name", "") + if provider and tool_key: + self._tool_set.add(f"{provider}/{tool_key}") + if tool_key: + self._tool_set.add(tool_key) + return self._tool_set + + @property + def configured_tool_set(self) -> set[str]: + """Get a set of configured (authorized) tool keys.""" + if self._configured_tool_set is None: + self._configured_tool_set = set() + for tool in self.available_tools: + if not tool.get("is_team_authorization", False): + continue + provider = tool.get("provider_id") or tool.get("provider", "") + tool_key = tool.get("tool_key") or tool.get("tool_name", "") + if provider and tool_key: + self._configured_tool_set.add(f"{provider}/{tool_key}") + if tool_key: + self._configured_tool_set.add(tool_key) + return self._configured_tool_set + + def has_model(self, provider: str, model_name: str) -> bool: + """Check if a model is available.""" + return (provider, model_name) in self.model_set + + def has_tool(self, tool_key: str) -> bool: + """Check if a tool exists (configured or not).""" + return tool_key in self.tool_set + + def is_tool_configured(self, tool_key: str) -> bool: + """Check if a tool is configured and ready to use.""" + return tool_key in self.configured_tool_set + + def get_node(self, node_id: str) -> WorkflowNodeDict | None: + """Get a node by its ID.""" + return self.node_map.get(node_id) + + def get_node_ids(self) -> set[str]: + """Get all node IDs in the workflow.""" + return set(self.node_map.keys()) + + def get_upstream_nodes(self, node_id: str) -> list[str]: + """Get IDs of nodes that connect to this node (upstream).""" + return [edge.get("source", "") for edge in self.edges if edge.get("target") == node_id] + + def get_downstream_nodes(self, node_id: str) -> list[str]: + """Get IDs of nodes that this node connects to (downstream).""" + return [edge.get("target", "") for edge in self.edges if edge.get("source") == node_id] diff --git a/api/core/workflow/generator/validation/engine.py b/api/core/workflow/generator/validation/engine.py new file mode 100644 index 0000000000..48f880f5f7 --- /dev/null +++ b/api/core/workflow/generator/validation/engine.py @@ -0,0 +1,260 @@ +""" +Validation Engine - Core validation logic. + +The ValidationEngine orchestrates rule execution and aggregates results. +It provides a clean interface for validating workflow nodes. +""" + +import logging +from dataclasses import dataclass, field +from typing import Any + +from core.workflow.generator.types import ( + AvailableModelDict, + AvailableToolDict, + WorkflowEdgeDict, + WorkflowNodeDict, +) +from core.workflow.generator.validation.context import ValidationContext +from core.workflow.generator.validation.rules import ( + RuleCategory, + Severity, + ValidationError, + get_registry, +) + +logger = logging.getLogger(__name__) + + +@dataclass +class ValidationResult: + """ + Result of validation containing all errors classified by fixability. + + Attributes: + all_errors: All validation errors found + fixable_errors: Errors that LLM can automatically fix + user_required_errors: Errors that require user intervention + warnings: Non-blocking warnings + stats: Validation statistics + """ + + all_errors: list[ValidationError] = field(default_factory=list) + fixable_errors: list[ValidationError] = field(default_factory=list) + user_required_errors: list[ValidationError] = field(default_factory=list) + warnings: list[ValidationError] = field(default_factory=list) + stats: dict[str, int] = field(default_factory=dict) + + @property + def has_errors(self) -> bool: + """Check if there are any errors (excluding warnings).""" + return len(self.fixable_errors) > 0 or len(self.user_required_errors) > 0 + + @property + def has_fixable_errors(self) -> bool: + """Check if there are fixable errors.""" + return len(self.fixable_errors) > 0 + + @property + def is_valid(self) -> bool: + """Check if validation passed (no errors, warnings are OK).""" + return not self.has_errors + + def to_dict(self) -> dict[str, Any]: + """Convert to dictionary for API response.""" + return { + "fixable": [e.to_dict() for e in self.fixable_errors], + "user_required": [e.to_dict() for e in self.user_required_errors], + "warnings": [e.to_dict() for e in self.warnings], + "all_warnings": [e.message for e in self.all_errors], + "stats": self.stats, + } + + def get_error_messages(self) -> list[str]: + """Get all error messages as strings.""" + return [e.message for e in self.all_errors] + + def get_fixable_by_node(self) -> dict[str, list[ValidationError]]: + """Group fixable errors by node ID.""" + result: dict[str, list[ValidationError]] = {} + for error in self.fixable_errors: + if error.node_id not in result: + result[error.node_id] = [] + result[error.node_id].append(error) + return result + + +class ValidationEngine: + """ + The main validation engine. + + Usage: + engine = ValidationEngine() + context = ValidationContext(nodes=[...], available_models=[...]) + result = engine.validate(context) + """ + + def __init__(self): + self._registry = get_registry() + + def validate(self, context: ValidationContext) -> ValidationResult: + """ + Validate all nodes in the context. + + Args: + context: ValidationContext with nodes, edges, and available resources + + Returns: + ValidationResult with classified errors + """ + result = ValidationResult() + stats = { + "total_nodes": len(context.nodes), + "total_rules_checked": 0, + "total_errors": 0, + "fixable_count": 0, + "user_required_count": 0, + "warning_count": 0, + } + + # Validate each node + for node in context.nodes: + node_type = node.get("type", "unknown") + node_id = node.get("id", "unknown") + + # Get applicable rules for this node type + rules = self._registry.get_rules_for_node(node_type) + + for rule in rules: + stats["total_rules_checked"] += 1 + + try: + errors = rule.check(node, context) + for error in errors: + result.all_errors.append(error) + stats["total_errors"] += 1 + + # Classify by severity and fixability + if error.severity == Severity.WARNING: + result.warnings.append(error) + stats["warning_count"] += 1 + elif error.is_fixable: + result.fixable_errors.append(error) + stats["fixable_count"] += 1 + else: + result.user_required_errors.append(error) + stats["user_required_count"] += 1 + + except Exception: + logger.exception( + "Rule '%s' failed for node '%s'", + rule.id, + node_id, + ) + # Don't let a rule failure break the entire validation + continue + + # Validate edges separately + edge_errors = self._validate_edges(context) + for error in edge_errors: + result.all_errors.append(error) + stats["total_errors"] += 1 + if error.is_fixable: + result.fixable_errors.append(error) + stats["fixable_count"] += 1 + else: + result.user_required_errors.append(error) + stats["user_required_count"] += 1 + + result.stats = stats + + return result + + def _validate_edges(self, context: ValidationContext) -> list[ValidationError]: + """Validate edge connections.""" + errors: list[ValidationError] = [] + valid_node_ids = context.get_node_ids() + + for edge in context.edges: + source = edge.get("source", "") + target = edge.get("target", "") + + if source and source not in valid_node_ids: + errors.append( + ValidationError( + rule_id="edge.source.invalid", + node_id=source, + node_type="edge", + category=RuleCategory.SEMANTIC, + severity=Severity.ERROR, + is_fixable=True, + message=f"Edge source '{source}' does not exist", + fix_hint="Update edge to reference existing node", + ) + ) + + if target and target not in valid_node_ids: + errors.append( + ValidationError( + rule_id="edge.target.invalid", + node_id=target, + node_type="edge", + category=RuleCategory.SEMANTIC, + severity=Severity.ERROR, + is_fixable=True, + message=f"Edge target '{target}' does not exist", + fix_hint="Update edge to reference existing node", + ) + ) + + return errors + + def validate_single_node( + self, + node: WorkflowNodeDict, + context: ValidationContext, + ) -> list[ValidationError]: + """ + Validate a single node. + + Useful for incremental validation when a node is added/modified. + """ + node_type = node.get("type", "unknown") + rules = self._registry.get_rules_for_node(node_type) + + errors: list[ValidationError] = [] + for rule in rules: + try: + errors.extend(rule.check(node, context)) + except Exception: + logger.exception("Rule '%s' failed", rule.id) + + return errors + + +def validate_nodes( + nodes: list[WorkflowNodeDict], + edges: list[WorkflowEdgeDict] | None = None, + available_models: list[AvailableModelDict] | None = None, + available_tools: list[AvailableToolDict] | None = None, +) -> ValidationResult: + """ + Convenience function to validate nodes without creating engine/context manually. + + Args: + nodes: List of workflow nodes to validate + edges: Optional list of edges + available_models: Optional list of available models + available_tools: Optional list of available tools + + Returns: + ValidationResult with classified errors + """ + context = ValidationContext( + nodes=nodes, + edges=edges or [], + available_models=available_models or [], + available_tools=available_tools or [], + ) + engine = ValidationEngine() + return engine.validate(context) diff --git a/api/core/workflow/generator/validation/rules.py b/api/core/workflow/generator/validation/rules.py new file mode 100644 index 0000000000..674440d6da --- /dev/null +++ b/api/core/workflow/generator/validation/rules.py @@ -0,0 +1,947 @@ +""" +Validation Rules Definition and Registry. + +This module defines: +- ValidationRule: The rule structure +- RuleCategory: Categories of validation rules +- Severity: Error severity levels +- ValidationError: Error output structure +- All built-in validation rules +""" + +import re +from collections.abc import Callable +from dataclasses import dataclass, field +from enum import Enum +from typing import TYPE_CHECKING, Any + +from core.workflow.generator.types import WorkflowNodeDict + +if TYPE_CHECKING: + from core.workflow.generator.validation.context import ValidationContext + + +class RuleCategory(Enum): + """Categories of validation rules.""" + + STRUCTURE = "structure" # Field existence, types, formats + SEMANTIC = "semantic" # Variable references, edge connections + REFERENCE = "reference" # External resources (models, tools, datasets) + + +class Severity(Enum): + """Severity levels for validation errors.""" + + ERROR = "error" # Must be fixed + WARNING = "warning" # Should be fixed but not blocking + + +@dataclass +class ValidationError: + """ + Represents a validation error found during rule execution. + + Attributes: + rule_id: The ID of the rule that generated this error + node_id: The ID of the node with the error + node_type: The type of the node + category: The rule category + severity: Error severity + is_fixable: Whether LLM can auto-fix this error + message: Human-readable error message + fix_hint: Hint for LLM to fix the error + details: Additional error details + """ + + rule_id: str + node_id: str + node_type: str + category: RuleCategory + severity: Severity + is_fixable: bool + message: str + fix_hint: str = "" + details: dict[str, Any] = field(default_factory=dict) + + def to_dict(self) -> dict[str, Any]: + """Convert to dictionary for API response.""" + return { + "rule_id": self.rule_id, + "node_id": self.node_id, + "node_type": self.node_type, + "category": self.category.value, + "severity": self.severity.value, + "is_fixable": self.is_fixable, + "message": self.message, + "fix_hint": self.fix_hint, + "details": self.details, + } + + +# Type alias for rule check functions +RuleCheckFn = Callable[ + [WorkflowNodeDict, "ValidationContext"], + list[ValidationError], +] + + +@dataclass +class ValidationRule: + """ + A validation rule definition. + + Attributes: + id: Unique rule identifier (e.g., "llm.model.required") + node_types: List of node types this rule applies to, or ["*"] for all + category: The rule category + severity: Default severity for errors from this rule + is_fixable: Whether errors from this rule can be auto-fixed by LLM + check: The validation function + description: Human-readable description of what this rule checks + fix_hint: Default hint for fixing errors from this rule + """ + + id: str + node_types: list[str] + category: RuleCategory + severity: Severity + is_fixable: bool + check: RuleCheckFn + description: str = "" + fix_hint: str = "" + + def applies_to(self, node_type: str) -> bool: + """Check if this rule applies to a given node type.""" + return "*" in self.node_types or node_type in self.node_types + + +# ============================================================================= +# Rule Registry +# ============================================================================= + + +class RuleRegistry: + """ + Registry for validation rules. + + Rules are registered here and can be retrieved by category or node type. + """ + + def __init__(self): + self._rules: list[ValidationRule] = [] + + def register(self, rule: ValidationRule) -> None: + """Register a validation rule.""" + self._rules.append(rule) + + def get_rules_for_node(self, node_type: str) -> list[ValidationRule]: + """Get all rules that apply to a given node type.""" + return [r for r in self._rules if r.applies_to(node_type)] + + def get_rules_by_category(self, category: RuleCategory) -> list[ValidationRule]: + """Get all rules in a given category.""" + return [r for r in self._rules if r.category == category] + + def get_all_rules(self) -> list[ValidationRule]: + """Get all registered rules.""" + return list(self._rules) + + +# Global rule registry instance +_registry = RuleRegistry() + + +def register_rule(rule: ValidationRule) -> ValidationRule: + """Decorator/function to register a rule with the global registry.""" + _registry.register(rule) + return rule + + +def get_registry() -> RuleRegistry: + """Get the global rule registry.""" + return _registry + + +# ============================================================================= +# Helper Functions for Rule Implementations +# ============================================================================= + +# Explicit placeholder value defined in prompt contract +# See: api/core/workflow/generator/prompts/vibe_prompts.py +PLACEHOLDER_VALUE = "__PLACEHOLDER__" + +# Variable reference pattern: {{#node_id.field#}} +VARIABLE_REF_PATTERN = re.compile(r"\{\{#([^.#]+)\.([^#]+)#\}\}") + + +def is_placeholder(value: Any) -> bool: + """Check if a value appears to be a placeholder.""" + if not isinstance(value, str): + return False + return value == PLACEHOLDER_VALUE or PLACEHOLDER_VALUE in value + + +def extract_variable_refs(text: str) -> list[tuple[str, str]]: + """ + Extract variable references from text. + + Returns list of (node_id, field_name) tuples. + """ + return VARIABLE_REF_PATTERN.findall(text) + + +def check_required_field( + config: dict[str, Any], + field_name: str, + node_id: str, + node_type: str, + rule_id: str, + fix_hint: str = "", +) -> ValidationError | None: + """Helper to check if a required field exists and is non-empty.""" + value = config.get(field_name) + if value is None or value == "" or (isinstance(value, list) and len(value) == 0): + return ValidationError( + rule_id=rule_id, + node_id=node_id, + node_type=node_type, + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}': missing required field '{field_name}'", + fix_hint=fix_hint or f"Add '{field_name}' to the node config", + ) + return None + + +# ============================================================================= +# Structure Rules - Field existence, types, formats +# ============================================================================= + + +def _check_llm_prompt_template(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that LLM node has prompt_template.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + config = node.get("config", {}) + + err = check_required_field( + config, + "prompt_template", + node_id, + "llm", + "llm.prompt_template.required", + "Add prompt_template with system and user messages", + ) + if err: + errors.append(err) + + return errors + + +def _check_http_request_url(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that http-request node has url and method.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + config = node.get("config", {}) + + # Check url + url = config.get("url", "") + if not url: + errors.append( + ValidationError( + rule_id="http.url.required", + node_id=node_id, + node_type="http-request", + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}': http-request missing required 'url'", + fix_hint="Add url - use {{#start.url#}} or a concrete URL", + ) + ) + elif is_placeholder(url): + errors.append( + ValidationError( + rule_id="http.url.placeholder", + node_id=node_id, + node_type="http-request", + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}': url contains placeholder value", + fix_hint="Replace placeholder with actual URL or variable reference", + ) + ) + + # Check method + method = config.get("method", "") + if not method: + errors.append( + ValidationError( + rule_id="http.method.required", + node_id=node_id, + node_type="http-request", + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}': http-request missing 'method'", + fix_hint="Add method: GET, POST, PUT, DELETE, or PATCH", + ) + ) + + return errors + + +def _check_code_node(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that code node has code and language.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + config = node.get("config", {}) + + err = check_required_field( + config, + "code", + node_id, + "code", + "code.code.required", + "Add code with a main() function that returns a dict", + ) + if err: + errors.append(err) + + err = check_required_field( + config, + "language", + node_id, + "code", + "code.language.required", + "Add language: python3 or javascript", + ) + if err: + errors.append(err) + + return errors + + +def _check_question_classifier(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that question-classifier has classes.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + config = node.get("config", {}) + + err = check_required_field( + config, + "classes", + node_id, + "question-classifier", + "classifier.classes.required", + "Add classes array with id and name for each classification", + ) + if err: + errors.append(err) + + return errors + + +def _check_parameter_extractor(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that parameter-extractor has parameters and instruction.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + config = node.get("config", {}) + + err = check_required_field( + config, + "parameters", + node_id, + "parameter-extractor", + "extractor.parameters.required", + "Add parameters array with name, type, description fields", + ) + if err: + errors.append(err) + else: + # Check individual parameters for required fields + parameters = config.get("parameters", []) + if isinstance(parameters, list): + for i, param in enumerate(parameters): + if isinstance(param, dict): + # Check for 'required' field (boolean) + if "required" not in param: + errors.append( + ValidationError( + rule_id="extractor.param.required_field.missing", + node_id=node_id, + node_type="parameter-extractor", + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}': parameter[{i}] missing 'required' field", + fix_hint=f"Add 'required': True to parameter '{param.get('name', 'unknown')}'", + details={"param_index": i, "param_name": param.get("name")}, + ) + ) + + # instruction is recommended but not strictly required + if not config.get("instruction"): + errors.append( + ValidationError( + rule_id="extractor.instruction.recommended", + node_id=node_id, + node_type="parameter-extractor", + category=RuleCategory.STRUCTURE, + severity=Severity.WARNING, + is_fixable=True, + message=f"Node '{node_id}': parameter-extractor should have 'instruction'", + fix_hint="Add instruction describing what to extract", + ) + ) + + return errors + + +def _check_knowledge_retrieval(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that knowledge-retrieval has dataset_ids.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + config = node.get("config", {}) + + dataset_ids = config.get("dataset_ids", []) + if not dataset_ids: + errors.append( + ValidationError( + rule_id="knowledge.dataset.required", + node_id=node_id, + node_type="knowledge-retrieval", + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=False, # User must select knowledge base + message=f"Node '{node_id}': knowledge-retrieval missing 'dataset_ids'", + fix_hint="User must select knowledge bases in the UI", + ) + ) + else: + # Check for placeholder values + for ds_id in dataset_ids: + if is_placeholder(ds_id): + errors.append( + ValidationError( + rule_id="knowledge.dataset.placeholder", + node_id=node_id, + node_type="knowledge-retrieval", + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=False, + message=f"Node '{node_id}': dataset_ids contains placeholder", + fix_hint="User must replace placeholder with actual knowledge base ID", + details={"placeholder_value": ds_id}, + ) + ) + break + + return errors + + +def _check_end_node(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that end node has outputs defined.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + config = node.get("config", {}) + + outputs = config.get("outputs", []) + if not outputs: + errors.append( + ValidationError( + rule_id="end.outputs.recommended", + node_id=node_id, + node_type="end", + category=RuleCategory.STRUCTURE, + severity=Severity.WARNING, + is_fixable=True, + message="End node should define output variables", + fix_hint="Add outputs array with variable and value_selector", + ) + ) + + return errors + + +# ============================================================================= +# Semantic Rules - Variable references, edge connections +# ============================================================================= + + +def _check_variable_references(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that variable references point to valid nodes.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + node_type = node.get("type", "unknown") + config = node.get("config", {}) + + # Get all valid node IDs (including 'start' which is always valid) + valid_node_ids = ctx.get_node_ids() + valid_node_ids.add("start") + valid_node_ids.add("sys") # System variables + + def check_text_for_refs(text: str, field_path: str) -> None: + if not isinstance(text, str): + return + refs = extract_variable_refs(text) + for ref_node_id, ref_field in refs: + if ref_node_id not in valid_node_ids: + errors.append( + ValidationError( + rule_id="variable.ref.invalid_node", + node_id=node_id, + node_type=node_type, + category=RuleCategory.SEMANTIC, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}': references non-existent node '{ref_node_id}'", + fix_hint=f"Change {{{{#{ref_node_id}.{ref_field}#}}}} to reference a valid node", + details={"field_path": field_path, "invalid_ref": ref_node_id}, + ) + ) + + # Check prompt_template for LLM nodes + prompt_template = config.get("prompt_template", []) + if isinstance(prompt_template, list): + for i, msg in enumerate(prompt_template): + if isinstance(msg, dict): + text = msg.get("text", "") + check_text_for_refs(text, f"prompt_template[{i}].text") + + # Check instruction field + instruction = config.get("instruction", "") + check_text_for_refs(instruction, "instruction") + + # Check url for http-request + url = config.get("url", "") + check_text_for_refs(url, "url") + + return errors + + +# NOTE: _check_node_has_outgoing_edge removed - handled by GraphValidator + + +# NOTE: _check_node_has_incoming_edge removed - handled by GraphValidator + + +# NOTE: _check_question_classifier_branches removed - handled by EdgeRepair + + +# NOTE: _check_if_else_branches removed - handled by EdgeRepair + + +def _check_if_else_operators(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that if-else comparison operators are valid.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + node_type = node.get("type", "unknown") + + if node_type != "if-else": + return errors + + valid_operators = { + "contains", + "not contains", + "start with", + "end with", + "is", + "is not", + "empty", + "not empty", + "in", + "not in", + "all of", + "=", + "≠", + ">", + "<", + "≥", + "≤", + "null", + "not null", + "exists", + "not exists", + } + + config = node.get("config", {}) + cases = config.get("cases", []) + + for case in cases: + conditions = case.get("conditions", []) + for condition in conditions: + op = condition.get("comparison_operator") + if op and op not in valid_operators: + errors.append( + ValidationError( + rule_id="ifelse.operator.invalid", + node_id=node_id, + node_type=node_type, + category=RuleCategory.SEMANTIC, + severity=Severity.ERROR, + is_fixable=True, + message=f"Invalid operator '{op}' in if-else node", + fix_hint=f"Use one of: {', '.join(sorted(valid_operators))}", + details={"invalid_operator": op, "field": "config.cases.conditions.comparison_operator"}, + ) + ) + + return errors + + +def _check_edge_targets_exist(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that edge targets reference existing nodes.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + node_type = node.get("type", "unknown") + + valid_node_ids = ctx.get_node_ids() + + # Check all outgoing edges from this node + for edge in ctx.edges: + if edge.get("source") == node_id: + target = edge.get("target") + if target and target not in valid_node_ids: + errors.append( + ValidationError( + rule_id="edge.target.invalid", + node_id=node_id, + node_type=node_type, + category=RuleCategory.SEMANTIC, + severity=Severity.ERROR, + is_fixable=True, + message=f"Edge from '{node_id}' targets non-existent node '{target}'", + fix_hint=f"Change edge target from '{target}' to an existing node", + details={"invalid_target": target, "field": "edges"}, + ) + ) + + return errors + + +# ============================================================================= +# Reference Rules - External resources (models, tools, datasets) +# ============================================================================= + +# Node types that require model configuration +MODEL_REQUIRED_NODE_TYPES = {"llm", "question-classifier", "parameter-extractor"} + + +def _check_model_config(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that model configuration is valid.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + node_type = node.get("type", "unknown") + config = node.get("config", {}) + + if node_type not in MODEL_REQUIRED_NODE_TYPES: + return errors + + model = config.get("model") + + # Check if model config exists + if not model: + if ctx.available_models: + errors.append( + ValidationError( + rule_id="model.required", + node_id=node_id, + node_type=node_type, + category=RuleCategory.REFERENCE, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}' ({node_type}): missing required 'model' configuration", + fix_hint="Add model config using one of the available models", + ) + ) + else: + errors.append( + ValidationError( + rule_id="model.no_available", + node_id=node_id, + node_type=node_type, + category=RuleCategory.REFERENCE, + severity=Severity.ERROR, + is_fixable=False, + message=f"Node '{node_id}' ({node_type}): needs model but no models available", + fix_hint="User must configure a model provider first", + ) + ) + return errors + + # Check if model config is valid + if isinstance(model, dict): + provider = model.get("provider", "") + name = model.get("name", "") + + # Check for placeholder values + if is_placeholder(provider) or is_placeholder(name): + if ctx.available_models: + errors.append( + ValidationError( + rule_id="model.placeholder", + node_id=node_id, + node_type=node_type, + category=RuleCategory.REFERENCE, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}': model config contains placeholder", + fix_hint="Replace placeholder with actual model from available_models", + ) + ) + return errors + + # Check if model exists in available_models + if ctx.available_models and provider and name: + if not ctx.has_model(provider, name): + errors.append( + ValidationError( + rule_id="model.not_found", + node_id=node_id, + node_type=node_type, + category=RuleCategory.REFERENCE, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}': model '{provider}/{name}' not in available models", + fix_hint="Replace with a model from available_models", + details={"provider": provider, "model": name}, + ) + ) + + return errors + + +def _check_tool_reference(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]: + """Check that tool references are valid and configured.""" + errors: list[ValidationError] = [] + node_id = node.get("id", "unknown") + node_type = node.get("type", "unknown") + + if node_type != "tool": + return errors + + config = node.get("config", {}) + tool_ref = ( + config.get("tool_key") + or config.get("tool_name") + or config.get("provider_id", "") + "/" + config.get("tool_name", "") + ) + + if not tool_ref: + errors.append( + ValidationError( + rule_id="tool.key.required", + node_id=node_id, + node_type=node_type, + category=RuleCategory.REFERENCE, + severity=Severity.ERROR, + is_fixable=True, + message=f"Node '{node_id}': tool node missing tool_key", + fix_hint="Add tool_key from available_tools", + ) + ) + return errors + + # Check if tool exists + if not ctx.has_tool(tool_ref): + errors.append( + ValidationError( + rule_id="tool.not_found", + node_id=node_id, + node_type=node_type, + category=RuleCategory.REFERENCE, + severity=Severity.ERROR, + is_fixable=True, # Can be replaced with http-request fallback + message=f"Node '{node_id}': tool '{tool_ref}' not found", + fix_hint="Use http-request or code node as fallback", + details={"tool_ref": tool_ref}, + ) + ) + elif not ctx.is_tool_configured(tool_ref): + errors.append( + ValidationError( + rule_id="tool.not_configured", + node_id=node_id, + node_type=node_type, + category=RuleCategory.REFERENCE, + severity=Severity.WARNING, + is_fixable=False, # User needs to configure + message=f"Node '{node_id}': tool '{tool_ref}' requires configuration", + fix_hint="Configure the tool in Tools settings", + details={"tool_ref": tool_ref}, + ) + ) + + return errors + + +# ============================================================================= +# Register All Rules +# ============================================================================= + +# Structure Rules +register_rule( + ValidationRule( + id="llm.prompt_template.required", + node_types=["llm"], + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + check=_check_llm_prompt_template, + description="LLM node must have prompt_template", + fix_hint="Add prompt_template with system and user messages", + ) +) + +register_rule( + ValidationRule( + id="http.config.required", + node_types=["http-request"], + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + check=_check_http_request_url, + description="HTTP request node must have url and method", + fix_hint="Add url and method to config", + ) +) + +register_rule( + ValidationRule( + id="code.config.required", + node_types=["code"], + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + check=_check_code_node, + description="Code node must have code and language", + fix_hint="Add code with main() function and language", + ) +) + +register_rule( + ValidationRule( + id="classifier.classes.required", + node_types=["question-classifier"], + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + check=_check_question_classifier, + description="Question classifier must have classes", + fix_hint="Add classes array with classification options", + ) +) + +register_rule( + ValidationRule( + id="extractor.config.required", + node_types=["parameter-extractor"], + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=True, + check=_check_parameter_extractor, + description="Parameter extractor must have parameters", + fix_hint="Add parameters array", + ) +) + +register_rule( + ValidationRule( + id="knowledge.config.required", + node_types=["knowledge-retrieval"], + category=RuleCategory.STRUCTURE, + severity=Severity.ERROR, + is_fixable=False, + check=_check_knowledge_retrieval, + description="Knowledge retrieval must have dataset_ids", + fix_hint="User must select knowledge base", + ) +) + +register_rule( + ValidationRule( + id="end.outputs.check", + node_types=["end"], + category=RuleCategory.STRUCTURE, + severity=Severity.WARNING, + is_fixable=True, + check=_check_end_node, + description="End node should have outputs", + fix_hint="Add outputs array", + ) +) + +# Semantic Rules +register_rule( + ValidationRule( + id="variable.references.valid", + node_types=["*"], + category=RuleCategory.SEMANTIC, + severity=Severity.ERROR, + is_fixable=True, + check=_check_variable_references, + description="Variable references must point to valid nodes", + fix_hint="Fix variable reference to use valid node ID", + ) +) + +# Edge Validation Rules +# NOTE: Edge connectivity and branch completeness are now handled by: +# - GraphValidator (BFS-based reachability analysis) +# - EdgeRepair (automatic branch edge repair) + +register_rule( + ValidationRule( + id="edge.targets.valid", + node_types=["*"], + category=RuleCategory.SEMANTIC, + severity=Severity.ERROR, + is_fixable=True, + check=_check_edge_targets_exist, + description="Edge targets must reference existing nodes", + fix_hint="Change edge target to an existing node ID", + ) +) + +# Reference Rules +register_rule( + ValidationRule( + id="model.config.valid", + node_types=["llm", "question-classifier", "parameter-extractor"], + category=RuleCategory.REFERENCE, + severity=Severity.ERROR, + is_fixable=True, + check=_check_model_config, + description="Model configuration must be valid", + fix_hint="Add valid model from available_models", + ) +) + +register_rule( + ValidationRule( + id="tool.reference.valid", + node_types=["tool"], + category=RuleCategory.REFERENCE, + severity=Severity.ERROR, + is_fixable=True, + check=_check_tool_reference, + description="Tool reference must be valid and configured", + fix_hint="Use valid tool or fallback node", + ) +) + +register_rule( + ValidationRule( + id="ifelse.operator.valid", + node_types=["if-else"], + category=RuleCategory.SEMANTIC, + severity=Severity.ERROR, + is_fixable=True, + check=_check_if_else_operators, + description="If-else operators must be valid", + fix_hint="Use standard operators like ≥, ≤, =, ≠", + ) +) diff --git a/api/tests/unit_tests/core/llm_generator/test_workflow_validator_vibe.py b/api/tests/unit_tests/core/llm_generator/test_workflow_validator_vibe.py new file mode 100644 index 0000000000..de53b4ee33 --- /dev/null +++ b/api/tests/unit_tests/core/llm_generator/test_workflow_validator_vibe.py @@ -0,0 +1,434 @@ +""" +Unit tests for the Vibe Workflow Validator. + +Tests cover: +- Basic validation function +- User-friendly validation hints +- Edge cases and error handling +""" + +from core.workflow.generator.utils.workflow_validator import ValidationHint, WorkflowValidator + + +class TestValidationHint: + """Tests for ValidationHint dataclass.""" + + def test_hint_creation(self): + """Test creating a validation hint.""" + hint = ValidationHint( + node_id="llm_1", + field="model", + message="Model is not configured", + severity="error", + ) + assert hint.node_id == "llm_1" + assert hint.field == "model" + assert hint.message == "Model is not configured" + assert hint.severity == "error" + + def test_hint_with_suggestion(self): + """Test hint with suggestion.""" + hint = ValidationHint( + node_id="http_1", + field="url", + message="URL is required", + severity="error", + suggestion="Add a valid URL like https://api.example.com", + ) + assert hint.suggestion is not None + + +class TestWorkflowValidatorBasic: + """Tests for basic validation scenarios.""" + + def test_empty_workflow_is_valid(self): + """Test empty workflow passes validation.""" + workflow_data = {"nodes": [], "edges": []} + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + + # Empty but valid structure + assert is_valid is True + assert len(hints) == 0 + + def test_minimal_valid_workflow(self): + """Test minimal Start → End workflow.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {}}, + {"id": "end", "type": "end", "config": {}}, + ], + "edges": [{"source": "start", "target": "end"}], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + + assert is_valid is True + + def test_complete_workflow_with_llm(self): + """Test complete workflow with LLM node.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {"variables": []}}, + { + "id": "llm", + "type": "llm", + "config": { + "model": {"provider": "openai", "name": "gpt-4"}, + "prompt_template": [{"role": "user", "text": "Hello"}], + }, + }, + {"id": "end", "type": "end", "config": {"outputs": []}}, + ], + "edges": [ + {"source": "start", "target": "llm"}, + {"source": "llm", "target": "end"}, + ], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + + # Should pass with no critical errors + errors = [h for h in hints if h.severity == "error"] + assert len(errors) == 0 + + +class TestVariableReferenceValidation: + """Tests for variable reference validation.""" + + def test_valid_variable_reference(self): + """Test valid variable reference passes.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {}}, + { + "id": "llm", + "type": "llm", + "config": {"prompt_template": [{"role": "user", "text": "Query: {{#start.query#}}"}]}, + }, + ], + "edges": [{"source": "start", "target": "llm"}], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + + ref_errors = [h for h in hints if "reference" in h.message.lower()] + assert len(ref_errors) == 0 + + def test_invalid_variable_reference(self): + """Test invalid variable reference generates hint.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {}}, + { + "id": "llm", + "type": "llm", + "config": {"prompt_template": [{"role": "user", "text": "{{#nonexistent.field#}}"}]}, + }, + ], + "edges": [{"source": "start", "target": "llm"}], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + + # Should have a hint about invalid reference + ref_hints = [h for h in hints if "nonexistent" in h.message or "reference" in h.message.lower()] + assert len(ref_hints) >= 1 + + +class TestEdgeValidation: + """Tests for edge validation.""" + + def test_edge_with_invalid_source(self): + """Test edge with non-existent source generates hint.""" + workflow_data = { + "nodes": [{"id": "end", "type": "end", "config": {}}], + "edges": [{"source": "nonexistent", "target": "end"}], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + + # Should have hint about invalid edge + edge_hints = [h for h in hints if "edge" in h.message.lower() or "source" in h.message.lower()] + assert len(edge_hints) >= 1 + + def test_edge_with_invalid_target(self): + """Test edge with non-existent target generates hint.""" + workflow_data = { + "nodes": [{"id": "start", "type": "start", "config": {}}], + "edges": [{"source": "start", "target": "nonexistent"}], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + + edge_hints = [h for h in hints if "edge" in h.message.lower() or "target" in h.message.lower()] + assert len(edge_hints) >= 1 + + +class TestToolValidation: + """Tests for tool node validation.""" + + def test_tool_node_found_in_available(self): + """Test tool node that exists in available tools.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {}}, + { + "id": "tool1", + "type": "tool", + "config": {"tool_key": "google/search"}, + }, + {"id": "end", "type": "end", "config": {}}, + ], + "edges": [{"source": "start", "target": "tool1"}, {"source": "tool1", "target": "end"}], + } + available_tools = [{"provider_id": "google", "tool_key": "search", "is_team_authorization": True}] + is_valid, hints = WorkflowValidator.validate(workflow_data, available_tools) + + tool_errors = [h for h in hints if h.severity == "error" and "tool" in h.message.lower()] + assert len(tool_errors) == 0 + + def test_tool_node_not_found(self): + """Test tool node not in available tools generates hint.""" + workflow_data = { + "nodes": [ + { + "id": "tool1", + "type": "tool", + "config": {"tool_key": "unknown/tool"}, + } + ], + "edges": [], + } + available_tools = [] + is_valid, hints = WorkflowValidator.validate(workflow_data, available_tools) + + tool_hints = [h for h in hints if "tool" in h.message.lower()] + assert len(tool_hints) >= 1 + + +class TestQuestionClassifierValidation: + """Tests for question-classifier node validation.""" + + def test_question_classifier_with_classes(self): + """Test question-classifier with valid classes.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {}}, + { + "id": "classifier", + "type": "question-classifier", + "config": { + "classes": [ + {"id": "class1", "name": "Class 1"}, + {"id": "class2", "name": "Class 2"}, + ], + "model": {"provider": "openai", "name": "gpt-4", "mode": "chat"}, + }, + }, + {"id": "h1", "type": "llm", "config": {}}, + {"id": "h2", "type": "llm", "config": {}}, + {"id": "end", "type": "end", "config": {}}, + ], + "edges": [ + {"source": "start", "target": "classifier"}, + {"source": "classifier", "sourceHandle": "class1", "target": "h1"}, + {"source": "classifier", "sourceHandle": "class2", "target": "h2"}, + {"source": "h1", "target": "end"}, + {"source": "h2", "target": "end"}, + ], + } + available_models = [{"provider": "openai", "model": "gpt-4", "mode": "chat"}] + is_valid, hints = WorkflowValidator.validate(workflow_data, [], available_models=available_models) + + class_errors = [h for h in hints if "class" in h.message.lower() and h.severity == "error"] + assert len(class_errors) == 0 + + def test_question_classifier_missing_classes(self): + """Test question-classifier without classes generates hint.""" + workflow_data = { + "nodes": [ + { + "id": "classifier", + "type": "question-classifier", + "config": {"model": {"provider": "openai", "name": "gpt-4", "mode": "chat"}}, + } + ], + "edges": [], + } + available_models = [{"provider": "openai", "model": "gpt-4", "mode": "chat"}] + is_valid, hints = WorkflowValidator.validate(workflow_data, [], available_models=available_models) + + # Should have hint about missing classes + class_hints = [h for h in hints if "class" in h.message.lower()] + assert len(class_hints) >= 1 + + +class TestHttpRequestValidation: + """Tests for HTTP request node validation.""" + + def test_http_request_with_url(self): + """Test HTTP request with valid URL.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {}}, + { + "id": "http", + "type": "http-request", + "config": {"url": "https://api.example.com", "method": "GET"}, + }, + {"id": "end", "type": "end", "config": {}}, + ], + "edges": [{"source": "start", "target": "http"}, {"source": "http", "target": "end"}], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + + url_errors = [h for h in hints if "url" in h.message.lower() and h.severity == "error"] + assert len(url_errors) == 0 + + def test_http_request_missing_url(self): + """Test HTTP request without URL generates hint.""" + workflow_data = { + "nodes": [ + { + "id": "http", + "type": "http-request", + "config": {"method": "GET"}, + } + ], + "edges": [], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + + url_hints = [h for h in hints if "url" in h.message.lower()] + assert len(url_hints) >= 1 + + +class TestParameterExtractorValidation: + """Tests for parameter-extractor node validation.""" + + def test_parameter_extractor_valid_params(self): + """Test parameter-extractor with valid parameters.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {}}, + { + "id": "extractor", + "type": "parameter-extractor", + "config": { + "instruction": "Extract info", + "parameters": [ + { + "name": "name", + "type": "string", + "description": "Name", + "required": True, + } + ], + "model": {"provider": "openai", "name": "gpt-4", "mode": "chat"}, + }, + }, + {"id": "end", "type": "end", "config": {}}, + ], + "edges": [{"source": "start", "target": "extractor"}, {"source": "extractor", "target": "end"}], + } + available_models = [{"provider": "openai", "model": "gpt-4", "mode": "chat"}] + is_valid, hints = WorkflowValidator.validate(workflow_data, [], available_models=available_models) + + errors = [h for h in hints if h.severity == "error"] + assert len(errors) == 0 + + def test_parameter_extractor_missing_required_field(self): + """Test parameter-extractor missing 'required' field in parameter item.""" + workflow_data = { + "nodes": [ + { + "id": "extractor", + "type": "parameter-extractor", + "config": { + "instruction": "Extract info", + "parameters": [ + { + "name": "name", + "type": "string", + "description": "Name", + # Missing 'required' + } + ], + "model": {"provider": "openai", "name": "gpt-4", "mode": "chat"}, + }, + } + ], + "edges": [], + } + available_models = [{"provider": "openai", "model": "gpt-4", "mode": "chat"}] + is_valid, hints = WorkflowValidator.validate(workflow_data, [], available_models=available_models) + + errors = [h for h in hints if "required" in h.message and h.severity == "error"] + assert len(errors) >= 1 + assert "parameter-extractor" in errors[0].node_type + + +class TestIfElseValidation: + """Tests for if-else node validation.""" + + def test_if_else_valid_operators(self): + """Test if-else with valid operators.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {}}, + { + "id": "ifelse", + "type": "if-else", + "config": { + "cases": [{"case_id": "c1", "conditions": [{"comparison_operator": "≥", "value": "1"}]}] + }, + }, + {"id": "t", "type": "llm", "config": {}}, + {"id": "f", "type": "llm", "config": {}}, + {"id": "end", "type": "end", "config": {}}, + ], + "edges": [ + {"source": "start", "target": "ifelse"}, + {"source": "ifelse", "sourceHandle": "true", "target": "t"}, + {"source": "ifelse", "sourceHandle": "false", "target": "f"}, + {"source": "t", "target": "end"}, + {"source": "f", "target": "end"}, + ], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + errors = [h for h in hints if h.severity == "error"] + # Filter out LLM model errors if any (available tools/models check might trigger) + # (actually available_models empty list might trigger model error? + # No, model config validation skips if model field not present? No, LLM has model config. + # But logic skips check if key missing? Let's check logic. + # _check_model_config checks if provider/name match available. If available is empty, it fails. + # But wait, validate default available_models is None? + # I should provide mock available_models or ignore model errors. + + # Actually LLM node "config": {} implies missing model config. Rules check if config structure is valid? + # Let's filter specifically for operator errors. + operator_errors = [h for h in errors if "operator" in h.message] + assert len(operator_errors) == 0 + + def test_if_else_invalid_operators(self): + """Test if-else with invalid operators.""" + workflow_data = { + "nodes": [ + {"id": "start", "type": "start", "config": {}}, + { + "id": "ifelse", + "type": "if-else", + "config": { + "cases": [{"case_id": "c1", "conditions": [{"comparison_operator": ">=", "value": "1"}]}] + }, + }, + {"id": "t", "type": "llm", "config": {}}, + {"id": "f", "type": "llm", "config": {}}, + {"id": "end", "type": "end", "config": {}}, + ], + "edges": [ + {"source": "start", "target": "ifelse"}, + {"source": "ifelse", "sourceHandle": "true", "target": "t"}, + {"source": "ifelse", "sourceHandle": "false", "target": "f"}, + {"source": "t", "target": "end"}, + {"source": "f", "target": "end"}, + ], + } + is_valid, hints = WorkflowValidator.validate(workflow_data, []) + operator_errors = [h for h in hints if "operator" in h.message and h.severity == "error"] + assert len(operator_errors) > 0 + assert "≥" in operator_errors[0].suggestion diff --git a/web/app/components/goto-anything/actions/commands/banana.spec.tsx b/web/app/components/goto-anything/actions/commands/banana.spec.tsx new file mode 100644 index 0000000000..47a1418aba --- /dev/null +++ b/web/app/components/goto-anything/actions/commands/banana.spec.tsx @@ -0,0 +1,189 @@ +import { isInWorkflowPage, VIBE_COMMAND_EVENT } from '@/app/components/workflow/constants' +import i18n from '@/i18n-config/i18next-config' +import { bananaCommand } from './banana' +import { registerCommands, unregisterCommands } from './command-bus' + +vi.mock('@/i18n-config/i18next-config', () => ({ + default: { + t: vi.fn((key: string, options?: Record) => { + if (!options) + return key + return `${key}:${JSON.stringify(options)}` + }), + }, +})) + +vi.mock('@/app/components/workflow/constants', async () => { + const actual = await vi.importActual( + '@/app/components/workflow/constants', + ) + return { + ...actual, + isInWorkflowPage: vi.fn(), + } +}) + +vi.mock('./command-bus', () => ({ + registerCommands: vi.fn(), + unregisterCommands: vi.fn(), +})) + +const mockedIsInWorkflowPage = vi.mocked(isInWorkflowPage) +const mockedRegisterCommands = vi.mocked(registerCommands) +const mockedUnregisterCommands = vi.mocked(unregisterCommands) +const mockedT = vi.mocked(i18n.t) + +type CommandArgs = { dsl?: string } +type CommandMap = Record void | Promise> + +beforeEach(() => { + vi.clearAllMocks() +}) + +// Command availability, search, and registration behavior for banana command. +describe('bananaCommand', () => { + // Command metadata mirrors the static definition. + describe('metadata', () => { + it('should expose name, mode, and description', () => { + // Assert + expect(bananaCommand.name).toBe('banana') + expect(bananaCommand.mode).toBe('submenu') + expect(bananaCommand.description).toContain('app.gotoAnything.actions.vibeDesc') + }) + }) + + // Availability mirrors workflow page detection. + describe('availability', () => { + it('should return true when on workflow page', () => { + // Arrange + mockedIsInWorkflowPage.mockReturnValue(true) + + // Act + const available = bananaCommand.isAvailable?.() + + // Assert + expect(available).toBe(true) + expect(mockedIsInWorkflowPage).toHaveBeenCalledTimes(1) + }) + + it('should return false when not on workflow page', () => { + // Arrange + mockedIsInWorkflowPage.mockReturnValue(false) + + // Act + const available = bananaCommand.isAvailable?.() + + // Assert + expect(available).toBe(false) + expect(mockedIsInWorkflowPage).toHaveBeenCalledTimes(1) + }) + }) + + // Search results depend on provided arguments. + describe('search', () => { + it('should return hint description when args are empty', async () => { + // Arrange + mockedIsInWorkflowPage.mockReturnValue(true) + + // Act + const result = await bananaCommand.search(' ') + + // Assert + expect(result).toHaveLength(1) + const [item] = result + expect(item.description).toContain('app.gotoAnything.actions.vibeHint') + expect(item.data?.args?.dsl).toBe('') + expect(item.data?.command).toBe('workflow.vibe') + expect(mockedT).toHaveBeenCalledWith( + 'app.gotoAnything.actions.vibeTitle', + expect.objectContaining({ lng: 'en' }), + ) + expect(mockedT).toHaveBeenCalledWith( + 'app.gotoAnything.actions.vibeHint', + expect.objectContaining({ prompt: expect.any(String), lng: 'en' }), + ) + }) + + it('should return default description when args are provided', async () => { + // Arrange + mockedIsInWorkflowPage.mockReturnValue(true) + + // Act + const result = await bananaCommand.search(' make a flow ', 'fr') + + // Assert + expect(result).toHaveLength(1) + const [item] = result + expect(item.description).toContain('app.gotoAnything.actions.vibeDesc') + expect(item.data?.args?.dsl).toBe('make a flow') + expect(item.data?.command).toBe('workflow.vibe') + expect(mockedT).toHaveBeenCalledWith( + 'app.gotoAnything.actions.vibeTitle', + expect.objectContaining({ lng: 'fr' }), + ) + expect(mockedT).toHaveBeenCalledWith( + 'app.gotoAnything.actions.vibeDesc', + expect.objectContaining({ lng: 'fr' }), + ) + }) + + it('should fall back to Banana when title translation is empty', async () => { + // Arrange + mockedIsInWorkflowPage.mockReturnValue(true) + mockedT.mockImplementationOnce(() => '') + + // Act + const result = await bananaCommand.search('make a plan') + + // Assert + expect(result).toHaveLength(1) + expect(result[0]?.title).toBe('Banana') + }) + }) + + // Command registration and event dispatching. + describe('registration', () => { + it('should register the workflow vibe command', () => { + // Act + expect(bananaCommand.register).toBeDefined() + bananaCommand.register?.({}) + + // Assert + expect(mockedRegisterCommands).toHaveBeenCalledTimes(1) + const commands = mockedRegisterCommands.mock.calls[0]?.[0] as CommandMap + expect(commands['workflow.vibe']).toEqual(expect.any(Function)) + }) + + it('should dispatch vibe event when command handler runs', async () => { + // Arrange + const dispatchSpy = vi.spyOn(document, 'dispatchEvent') + expect(bananaCommand.register).toBeDefined() + bananaCommand.register?.({}) + expect(mockedRegisterCommands).toHaveBeenCalledTimes(1) + const commands = mockedRegisterCommands.mock.calls[0]?.[0] as CommandMap + + try { + // Act + await commands['workflow.vibe']?.({ dsl: 'hello' }) + + // Assert + expect(dispatchSpy).toHaveBeenCalledTimes(1) + const event = dispatchSpy.mock.calls[0][0] as CustomEvent + expect(event.type).toBe(VIBE_COMMAND_EVENT) + expect(event.detail).toEqual({ dsl: 'hello' }) + } + finally { + dispatchSpy.mockRestore() + } + }) + + it('should unregister workflow vibe command', () => { + // Act + expect(bananaCommand.unregister).toBeDefined() + bananaCommand.unregister?.() + + // Assert + expect(mockedUnregisterCommands).toHaveBeenCalledWith(['workflow.vibe']) + }) + }) +}) diff --git a/web/app/components/goto-anything/actions/commands/banana.tsx b/web/app/components/goto-anything/actions/commands/banana.tsx new file mode 100644 index 0000000000..e071d84767 --- /dev/null +++ b/web/app/components/goto-anything/actions/commands/banana.tsx @@ -0,0 +1,59 @@ +import type { SlashCommandHandler } from './types' +import { RiSparklingFill } from '@remixicon/react' +import * as React from 'react' +import { getI18n } from 'react-i18next' +import { isInWorkflowPage, VIBE_COMMAND_EVENT } from '@/app/components/workflow/constants' +import { registerCommands, unregisterCommands } from './command-bus' + +type BananaDeps = Record + +const BANANA_PROMPT_EXAMPLE = 'Summarize a document, classify sentiment, then notify Slack' + +const dispatchVibeCommand = (input?: string) => { + if (typeof document === 'undefined') + return + + document.dispatchEvent(new CustomEvent(VIBE_COMMAND_EVENT, { detail: { dsl: input } })) +} + +export const bananaCommand: SlashCommandHandler = { + name: 'banana', + description: getI18n().t('gotoAnything.actions.vibeDesc', { ns: 'app' }), + mode: 'submenu', + isAvailable: () => isInWorkflowPage(), + + async search(args: string, locale: string = 'en') { + const trimmed = args.trim() + const hasInput = !!trimmed + + return [{ + id: 'banana-vibe', + title: getI18n().t('gotoAnything.actions.vibeTitle', { ns: 'app', lng: locale }) || 'Banana', + description: hasInput + ? getI18n().t('gotoAnything.actions.vibeDesc', { ns: 'app', lng: locale }) + : getI18n().t('gotoAnything.actions.vibeHint', { ns: 'app', lng: locale, prompt: BANANA_PROMPT_EXAMPLE }), + type: 'command' as const, + icon: ( +
+ +
+ ), + data: { + command: 'workflow.vibe', + args: { dsl: trimmed }, + }, + }] + }, + + register(_deps: BananaDeps) { + registerCommands({ + 'workflow.vibe': async (args) => { + dispatchVibeCommand(args?.dsl) + }, + }) + }, + + unregister() { + unregisterCommands(['workflow.vibe']) + }, +} diff --git a/web/app/components/goto-anything/actions/commands/slash.tsx b/web/app/components/goto-anything/actions/commands/slash.tsx index 6aad67731f..3063634416 100644 --- a/web/app/components/goto-anything/actions/commands/slash.tsx +++ b/web/app/components/goto-anything/actions/commands/slash.tsx @@ -5,6 +5,7 @@ import { useEffect } from 'react' import { getI18n } from 'react-i18next' import { setLocaleOnClient } from '@/i18n-config' import { accountCommand } from './account' +import { bananaCommand } from './banana' import { executeCommand } from './command-bus' import { communityCommand } from './community' import { docsCommand } from './docs' @@ -43,6 +44,7 @@ export const registerSlashCommands = (deps: Record) => { slashCommandRegistry.register(communityCommand, {}) slashCommandRegistry.register(accountCommand, {}) slashCommandRegistry.register(zenCommand, {}) + slashCommandRegistry.register(bananaCommand, {}) } export const unregisterSlashCommands = () => { @@ -54,6 +56,7 @@ export const unregisterSlashCommands = () => { slashCommandRegistry.unregister('community') slashCommandRegistry.unregister('account') slashCommandRegistry.unregister('zen') + slashCommandRegistry.unregister('banana') } export const SlashCommandProvider = () => { diff --git a/web/app/components/goto-anything/actions/commands/vibe.tsx b/web/app/components/goto-anything/actions/commands/vibe.tsx new file mode 100644 index 0000000000..76a371f7cc --- /dev/null +++ b/web/app/components/goto-anything/actions/commands/vibe.tsx @@ -0,0 +1,59 @@ +import type { SlashCommandHandler } from './types' +import { RiSparklingFill } from '@remixicon/react' +import * as React from 'react' +import { getI18n } from 'react-i18next' +import { isInWorkflowPage, VIBE_COMMAND_EVENT } from '@/app/components/workflow/constants' +import { registerCommands, unregisterCommands } from './command-bus' + +type VibeDeps = Record + +const VIBE_PROMPT_EXAMPLE = 'Summarize a document, classify sentiment, then notify Slack' + +const dispatchVibeCommand = (input?: string) => { + if (typeof document === 'undefined') + return + + document.dispatchEvent(new CustomEvent(VIBE_COMMAND_EVENT, { detail: { dsl: input } })) +} + +export const vibeCommand: SlashCommandHandler = { + name: 'vibe', + description: getI18n().t('gotoAnything.actions.vibeDesc', { ns: 'app' }), + mode: 'submenu', + isAvailable: () => isInWorkflowPage(), + + async search(args: string, locale: string = 'en') { + const trimmed = args.trim() + const hasInput = !!trimmed + + return [{ + id: 'vibe', + title: getI18n().t('gotoAnything.actions.vibeTitle', { ns: 'app', lng: locale }) || 'Vibe', + description: hasInput + ? getI18n().t('gotoAnything.actions.vibeDesc', { ns: 'app', lng: locale }) + : getI18n().t('gotoAnything.actions.vibeHint', { ns: 'app', lng: locale, prompt: VIBE_PROMPT_EXAMPLE }), + type: 'command' as const, + icon: ( +
+ +
+ ), + data: { + command: 'workflow.vibe', + args: { dsl: trimmed }, + }, + }] + }, + + register(_deps: VibeDeps) { + registerCommands({ + 'workflow.vibe': async (args) => { + dispatchVibeCommand(args?.dsl) + }, + }) + }, + + unregister() { + unregisterCommands(['workflow.vibe']) + }, +} diff --git a/web/app/components/goto-anything/actions/index.ts b/web/app/components/goto-anything/actions/index.ts index a038ef1a6c..024b6bfd2c 100644 --- a/web/app/components/goto-anything/actions/index.ts +++ b/web/app/components/goto-anything/actions/index.ts @@ -160,7 +160,7 @@ * - `@knowledge` / `@kb` - Search knowledge bases * - `@plugin` - Search plugins * - `@node` - Search workflow nodes (workflow pages only) - * - `/` - Execute slash commands (theme, language, etc.) + * - `/` - Execute slash commands (theme, language, banana, etc.) */ import type { ActionItem, SearchResult } from './types' diff --git a/web/app/components/goto-anything/command-selector.tsx b/web/app/components/goto-anything/command-selector.tsx index bdb641cae6..79d543faca 100644 --- a/web/app/components/goto-anything/command-selector.tsx +++ b/web/app/components/goto-anything/command-selector.tsx @@ -116,6 +116,7 @@ const CommandSelector: FC = ({ actions, onCommandSelect, searchFilter, co '/docs': 'gotoAnything.actions.docDesc', '/community': 'gotoAnything.actions.communityDesc', '/zen': 'gotoAnything.actions.zenDesc', + '/banana': 'gotoAnything.actions.vibeDesc', } as const return t(slashKeyMap[item.key as keyof typeof slashKeyMap] || item.description, { ns: 'app' }) })() diff --git a/web/app/components/workflow/constants.ts b/web/app/components/workflow/constants.ts index ed9a072824..e0e0b79b64 100644 --- a/web/app/components/workflow/constants.ts +++ b/web/app/components/workflow/constants.ts @@ -9,6 +9,9 @@ export const NODE_WIDTH = 240 export const X_OFFSET = 60 export const NODE_WIDTH_X_OFFSET = NODE_WIDTH + X_OFFSET export const Y_OFFSET = 39 +export const VIBE_COMMAND_EVENT = 'workflow-vibe-command' +export const VIBE_REGENERATE_EVENT = 'workflow-vibe-regenerate' +export const VIBE_ACCEPT_EVENT = 'workflow-vibe-accept' export const START_INITIAL_POSITION = { x: 80, y: 282 } export const AUTO_LAYOUT_OFFSET = { x: -42, diff --git a/web/app/components/workflow/hooks/__tests__/use-workflow-vibe.test.ts b/web/app/components/workflow/hooks/__tests__/use-workflow-vibe.test.ts new file mode 100644 index 0000000000..94a6b99e6f --- /dev/null +++ b/web/app/components/workflow/hooks/__tests__/use-workflow-vibe.test.ts @@ -0,0 +1,80 @@ +import { describe, expect, it } from 'vitest' +import { replaceVariableReferences } from '../use-workflow-vibe' + +// Mock types needed for the test +type NodeData = { + title: string + [key: string]: any +} + +describe('use-workflow-vibe', () => { + describe('replaceVariableReferences', () => { + it('should replace variable references in strings', () => { + const data = { + title: 'Test Node', + prompt: 'Hello {{#old_id.query#}}', + } + const nodeIdMap = new Map() + nodeIdMap.set('old_id', { id: 'new_uuid', data: { type: 'llm' } }) + + const result = replaceVariableReferences(data, nodeIdMap) as NodeData + expect(result.prompt).toBe('Hello {{#new_uuid.query#}}') + }) + + it('should handle multiple references in one string', () => { + const data = { + title: 'Test Node', + text: '{{#node1.out#}} and {{#node2.out#}}', + } + const nodeIdMap = new Map() + nodeIdMap.set('node1', { id: 'uuid1', data: { type: 'llm' } }) + nodeIdMap.set('node2', { id: 'uuid2', data: { type: 'llm' } }) + + const result = replaceVariableReferences(data, nodeIdMap) as NodeData + expect(result.text).toBe('{{#uuid1.out#}} and {{#uuid2.out#}}') + }) + + it('should replace variable references in value_selector arrays', () => { + const data = { + title: 'End Node', + outputs: [ + { + variable: 'result', + value_selector: ['old_id', 'text'], + }, + ], + } + const nodeIdMap = new Map() + nodeIdMap.set('old_id', { id: 'new_uuid', data: { type: 'llm' } }) + + const result = replaceVariableReferences(data, nodeIdMap) as NodeData + expect(result.outputs[0].value_selector).toEqual(['new_uuid', 'text']) + }) + + it('should handle nested objects recursively', () => { + const data = { + config: { + model: { + prompt: '{{#old_id.text#}}', + }, + }, + } + const nodeIdMap = new Map() + nodeIdMap.set('old_id', { id: 'new_uuid', data: { type: 'llm' } }) + + const result = replaceVariableReferences(data, nodeIdMap) as any + expect(result.config.model.prompt).toBe('{{#new_uuid.text#}}') + }) + + it('should ignoring missing node mappings', () => { + const data = { + text: '{{#missing_id.text#}}', + } + const nodeIdMap = new Map() + // missing_id is not in map + + const result = replaceVariableReferences(data, nodeIdMap) as NodeData + expect(result.text).toBe('{{#missing_id.text#}}') + }) + }) +}) diff --git a/web/app/components/workflow/hooks/index.ts b/web/app/components/workflow/hooks/index.ts index 4b879738e7..f3765b92ed 100644 --- a/web/app/components/workflow/hooks/index.ts +++ b/web/app/components/workflow/hooks/index.ts @@ -24,3 +24,5 @@ export * from './use-workflow-run' export * from './use-workflow-search' export * from './use-workflow-start-run' export * from './use-workflow-variables' +export * from './use-workflow-vibe' +export * from './use-workflow-vibe-config' diff --git a/web/app/components/workflow/hooks/use-workflow-vibe-config.ts b/web/app/components/workflow/hooks/use-workflow-vibe-config.ts new file mode 100644 index 0000000000..a149d15947 --- /dev/null +++ b/web/app/components/workflow/hooks/use-workflow-vibe-config.ts @@ -0,0 +1,99 @@ +/** + * Vibe Workflow Generator Configuration + * + * This module centralizes configuration for the Vibe workflow generation feature, + * including node type aliases and field name corrections. + * + * Note: These definitions are mirrored in the backend at: + * api/core/workflow/generator/config/node_schemas.py + * When updating these values, also update the backend file. + */ + +/** + * Node type aliases for inference from natural language. + * Maps common terms to canonical node type names. + */ +export const NODE_TYPE_ALIASES: Record = { + // Start node aliases + 'start': 'start', + 'begin': 'start', + 'input': 'start', + // End node aliases + 'end': 'end', + 'finish': 'end', + 'output': 'end', + // LLM node aliases + 'llm': 'llm', + 'ai': 'llm', + 'gpt': 'llm', + 'model': 'llm', + 'chat': 'llm', + // Code node aliases + 'code': 'code', + 'script': 'code', + 'python': 'code', + 'javascript': 'code', + // HTTP request node aliases + 'http-request': 'http-request', + 'http': 'http-request', + 'request': 'http-request', + 'api': 'http-request', + 'fetch': 'http-request', + 'webhook': 'http-request', + // Conditional node aliases + 'if-else': 'if-else', + 'condition': 'if-else', + 'branch': 'if-else', + 'switch': 'if-else', + // Loop node aliases + 'iteration': 'iteration', + 'loop': 'loop', + 'foreach': 'iteration', + // Tool node alias + 'tool': 'tool', +} + +/** + * Field name corrections for LLM-generated node configs. + * Maps incorrect field names to correct ones for specific node types. + */ +export const FIELD_NAME_CORRECTIONS: Record> = { + 'http-request': { + text: 'body', // LLM might use "text" instead of "body" + content: 'body', + response: 'body', + }, + 'code': { + text: 'result', // LLM might use "text" instead of "result" + output: 'result', + }, + 'llm': { + response: 'text', + answer: 'text', + }, +} + +/** + * Correct field names based on node type. + * LLM sometimes generates wrong field names (e.g., "text" instead of "body" for HTTP nodes). + * + * @param field - The field name to correct + * @param nodeType - The type of the node + * @returns The corrected field name, or the original if no correction needed + */ +export const correctFieldName = (field: string, nodeType: string): string => { + const corrections = FIELD_NAME_CORRECTIONS[nodeType] + if (corrections && corrections[field]) + return corrections[field] + return field +} + +/** + * Get the canonical node type from an alias. + * + * @param alias - The alias to look up + * @returns The canonical node type, or undefined if not found + */ +export const getCanonicalNodeType = (alias: string): string | undefined => { + return NODE_TYPE_ALIASES[alias.toLowerCase()] +} diff --git a/web/app/components/workflow/hooks/use-workflow-vibe.tsx b/web/app/components/workflow/hooks/use-workflow-vibe.tsx new file mode 100644 index 0000000000..83dd5c6987 --- /dev/null +++ b/web/app/components/workflow/hooks/use-workflow-vibe.tsx @@ -0,0 +1,1571 @@ +'use client' + +import type { ToolDefaultValue } from '../block-selector/types' +import type { FlowGraph } from '../store/workflow/vibe-workflow-slice' +import type { Edge, Node, ToolWithProvider } from '../types' +import type { Tool } from '@/app/components/tools/types' +import type { BackendEdgeSpec, BackendNodeSpec } from '@/service/debug' +import type { Model } from '@/types/app' +import { useCallback, useEffect, useMemo, useRef, useState } from 'react' +import { useTranslation } from 'react-i18next' +import { useStoreApi } from 'reactflow' +import { v4 as uuid4 } from 'uuid' +import Toast from '@/app/components/base/toast' +import { ModelTypeEnum } from '@/app/components/header/account-setting/model-provider-page/declarations' +import { useModelListAndDefaultModelAndCurrentProviderAndModel } from '@/app/components/header/account-setting/model-provider-page/hooks' +import { useGetLanguage } from '@/context/i18n' +import { generateFlowchart } from '@/service/use-goto-anything' +import { + useAllBuiltInTools, + useAllCustomTools, + useAllMCPTools, + useAllWorkflowTools, +} from '@/service/use-tools' +import { ModelModeType } from '@/types/app' +import { basePath } from '@/utils/var' +import { + CUSTOM_EDGE, + NODE_WIDTH, + NODE_WIDTH_X_OFFSET, + VIBE_APPLY_EVENT, + VIBE_COMMAND_EVENT, +} from '../constants' +import { useHooksStore } from '../hooks-store' +import { useStore, useWorkflowStore } from '../store' +import { BlockEnum } from '../types' +import { + generateNewNode, + getLayoutByDagre, + getNodeCustomTypeByNodeDataType, + getNodesConnectedSourceOrTargetHandleIdsMap, +} from '../utils' +import { initialNodes as initializeNodeData } from '../utils/workflow-init' +import { useNodesMetaData } from './use-nodes-meta-data' +import { useNodesSyncDraft } from './use-nodes-sync-draft' +import { useNodesReadOnly } from './use-workflow' +import { useWorkflowHistory, WorkflowHistoryEvent } from './use-workflow-history' +import { correctFieldName, NODE_TYPE_ALIASES } from './use-workflow-vibe-config' + +type VibeCommandDetail = { + dsl?: string +} + +type ParsedNodeDraft = { + id: string + type?: BlockEnum + title?: string + toolKey?: string +} + +type ParsedNode = { + id: string + type: BlockEnum + title?: string + toolKey?: string +} + +type ParsedEdge = { + sourceId: string + targetId: string + label?: string +} + +type ParseError = { + error: 'invalidMermaid' | 'missingNodeType' | 'unknownNodeType' | 'unknownTool' | 'missingNodeDefinition' | 'unknownNodeId' | 'unsupportedEdgeLabel' + detail?: string +} + +type ParseResult = { + nodes: ParsedNode[] + edges: ParsedEdge[] +} + +const NODE_DECLARATION = /^([A-Z][\w-]*)\s*\[(?:"([^"]+)"|([^\]]+))\]\s*$/i +const EDGE_DECLARATION = /^(.+?)\s*-->\s*(?:\|([^|]+)\|\s*)?(.+)$/ + +const extractMermaidCode = (raw: string) => { + const fencedMatch = raw.match(/```(?:mermaid)?\s*([\s\S]*?)```/i) + return (fencedMatch ? fencedMatch[1] : raw).trim() +} + +const isMermaidFlowchart = (value: string) => { + const trimmed = value.trim().toLowerCase() + return trimmed.startsWith('flowchart') || trimmed.startsWith('graph') +} + +const normalizeKey = (value: string) => value.trim().toLowerCase().replace(/[^\p{L}\p{N}]/gu, '') + +const normalizeProviderIcon = (icon?: ToolWithProvider['icon']) => { + if (!icon) + return icon + if (typeof icon === 'string' && basePath && icon.startsWith('/') && !icon.startsWith(`${basePath}/`)) + return `${basePath}${icon}` + return icon +} + +/** + * Replace variable references in node data using the nodeIdMap. + * Handles: + * - String templates: {{#old_id.field#}} → {{#new_id.field#}} + * - Value selectors: ["old_id", "field"] → ["new_id", "field"] + * - Mixed content objects: {type: "mixed", value: "..."} → normalized to string + * - Field name correction based on node type + */ +export const replaceVariableReferences = ( + data: unknown, + nodeIdMap: Map, + parentKey?: string, +): unknown => { + if (typeof data === 'string') { + // Replace {{#old_id.field#}} patterns and correct field names + return data.replace(/\{\{#([^.#]+)\.([^#]+)#\}\}/g, (match, oldId, field) => { + const newNode = nodeIdMap.get(oldId) + if (newNode) { + const nodeType = newNode.data?.type as string || '' + const correctedField = correctFieldName(field, nodeType) + return `{{#${newNode.id}.${correctedField}#}}` + } + return match // Keep original if no mapping found + }) + } + + if (Array.isArray(data)) { + // Check if this is a value_selector array: ["node_id", "field", ...] + if (data.length >= 2 && typeof data[0] === 'string' && typeof data[1] === 'string') { + const potentialNodeId = data[0] + const newNode = nodeIdMap.get(potentialNodeId) + // #region agent log + if (!newNode && !['sys', 'env', 'conversation'].includes(potentialNodeId)) { + console.warn(`[VIBE DEBUG] replaceVariableReferences: No mapping for "${potentialNodeId}" in selector [${data.join(', ')}]`) + } + // #endregion + if (newNode) { + const nodeType = newNode.data?.type as string || '' + const correctedField = correctFieldName(data[1], nodeType) + // Replace the node ID and correct field name in value_selector + return [newNode.id, correctedField, ...data.slice(2)] + } + } + // Recursively process array elements + return data.map(item => replaceVariableReferences(item, nodeIdMap)) + } + + if (data !== null && typeof data === 'object') { + const obj = data as Record + + // Handle "mixed content" objects like {type: "mixed", value: "{{#...#}}"} + // These should be normalized to plain strings for fields like 'url' + if (obj.type === 'mixed' && typeof obj.value === 'string') { + const processedValue = replaceVariableReferences(obj.value, nodeIdMap) as string + // For certain fields (url, headers, params), return just the string value + if (parentKey && ['url', 'headers', 'params'].includes(parentKey)) { + return processedValue + } + // Otherwise keep the object structure but update the value + return { ...obj, value: processedValue } + } + + // Recursively process object properties + const result: Record = {} + for (const [key, value] of Object.entries(obj)) { + result[key] = replaceVariableReferences(value, nodeIdMap, key) + } + return result + } + + return data // Return primitives as-is +} + +const parseNodeLabel = (label: string) => { + const tokens = label.split('|').map(token => token.trim()).filter(Boolean) + const info: Record = {} + + tokens.forEach((token) => { + const [rawKey, ...rest] = token.split('=') + if (!rawKey || rest.length === 0) + return + info[rawKey.trim().toLowerCase()] = rest.join('=').trim() + }) + + // Fallback: if no type= found, try to infer from label text + if (!info.type && tokens.length === 1 && !tokens[0].includes('=')) { + const labelLower = tokens[0].toLowerCase() + // Check if label matches a known node type alias + if (NODE_TYPE_ALIASES[labelLower]) { + info.type = NODE_TYPE_ALIASES[labelLower] + info.title = tokens[0] // Use original label as title + } + else { + info.type = tokens[0] + } + } + + if (!info.tool && info.tool_key) + info.tool = info.tool_key + + return info +} + +const parseNodeToken = (token: string) => { + const trimmed = token.trim() + const match = trimmed.match(NODE_DECLARATION) + if (match) + return { id: match[1], label: match[2] || match[3] } + const idMatch = trimmed.match(/^([A-Z][\w-]*)$/i) + if (idMatch) + return { id: idMatch[1] } + return null +} + +const normalizeBranchLabel = (label?: string) => { + if (!label) + return '' + const normalized = label.trim().toLowerCase() + if (['true', 'yes', 'y', '1'].includes(normalized)) + return 'true' + if (['false', 'no', 'n', '0'].includes(normalized)) + return 'false' + return '' +} + +const parseMermaidFlowchart = ( + raw: string, + nodeTypeLookup: Map, + toolLookup: Map, +): ParseResult | ParseError => { + const code = extractMermaidCode(raw) + const lines = code.split(/\r?\n/).map((line) => { + const commentIndex = line.indexOf('%%') + return (commentIndex >= 0 ? line.slice(0, commentIndex) : line).trim() + }).filter(Boolean) + + const nodesMap = new Map() + const declaredNodeIds = new Set() + const edges: ParsedEdge[] = [] + + const registerNode = (id: string, label?: string): ParseError | null => { + const existing = nodesMap.get(id) + if (!label) { + if (!existing) + nodesMap.set(id, { id }) + return null + } + + const info = parseNodeLabel(label) + if (!info.type) + return { error: 'missingNodeType', detail: label } + + const typeKey = normalizeKey(info.type) + const nodeType = nodeTypeLookup.get(typeKey) + if (!nodeType) + return { error: 'unknownNodeType', detail: info.type } + + const nodeData: ParsedNodeDraft = { + id, + type: nodeType, + title: info.title, + } + + if (nodeType === BlockEnum.Tool) { + if (!info.tool) + return { error: 'unknownTool', detail: 'tool' } + const toolKey = normalizeKey(info.tool) + if (!toolLookup.has(toolKey)) + return { error: 'unknownTool', detail: info.tool } + nodeData.toolKey = toolKey + } + + nodesMap.set(id, { ...(existing || {}), ...nodeData }) + declaredNodeIds.add(id) + return null + } + + for (const line of lines) { + if (line.toLowerCase().startsWith('flowchart') || line.toLowerCase().startsWith('graph')) + continue + + if (line.includes('-->')) { + const edgeMatch = line.match(EDGE_DECLARATION) + if (!edgeMatch) + return { error: 'invalidMermaid', detail: line } + + const sourceToken = parseNodeToken(edgeMatch[1]) + const targetToken = parseNodeToken(edgeMatch[3]) + if (!sourceToken || !targetToken) + return { error: 'invalidMermaid', detail: line } + + if (!sourceToken.label && !declaredNodeIds.has(sourceToken.id)) + return { error: 'unknownNodeId', detail: sourceToken.id } + if (!targetToken.label && !declaredNodeIds.has(targetToken.id)) + return { error: 'unknownNodeId', detail: targetToken.id } + + const sourceError = registerNode(sourceToken.id, sourceToken.label) + if (sourceError) + return sourceError + const targetError = registerNode(targetToken.id, targetToken.label) + if (targetError) + return targetError + + edges.push({ + sourceId: sourceToken.id, + targetId: targetToken.id, + label: edgeMatch[2]?.trim() || undefined, + }) + continue + } + + const nodeMatch = line.match(NODE_DECLARATION) + if (nodeMatch) { + const error = registerNode(nodeMatch[1], nodeMatch[2] || nodeMatch[3]) + if (error) + return error + } + } + + const parsedNodes: ParsedNode[] = [] + const nodeTypeById = new Map() + for (const node of nodesMap.values()) { + if (!node.type) + return { error: 'missingNodeDefinition', detail: node.id } + parsedNodes.push(node as ParsedNode) + nodeTypeById.set(node.id, node.type) + } + + if (!parsedNodes.length) + return { error: 'invalidMermaid', detail: '' } + + for (const edge of edges) { + if (!edge.label) + continue + const sourceType = nodeTypeById.get(edge.sourceId) + const branchLabel = normalizeBranchLabel(edge.label) + if (sourceType !== BlockEnum.IfElse || !branchLabel) + return { error: 'unsupportedEdgeLabel', detail: edge.label } + } + + return { nodes: parsedNodes, edges } +} + +const dedupeHandles = (handles?: string[]) => { + if (!handles) + return handles + return Array.from(new Set(handles)) +} + +const buildToolParams = (parameters?: Tool['parameters']) => { + const params: Record = {} + if (!parameters) + return params + parameters.forEach((item) => { + params[item.name] = '' + }) + return params +} + +// Sync vibe flow data to sessionStorage +const STORAGE_KEY_PREFIX = 'vibe-flow-' + +const loadFromSessionStorage = (flowId: string): { versions: FlowGraph[], currentIndex: number } | null => { + if (typeof window === 'undefined') + return null + + try { + const versionsKey = `${STORAGE_KEY_PREFIX}${flowId}-versions` + const indexKey = `${STORAGE_KEY_PREFIX}${flowId}-version-index` + + const versionsRaw = sessionStorage.getItem(versionsKey) + const indexRaw = sessionStorage.getItem(indexKey) + + if (!versionsRaw) + return null + + const versions = JSON.parse(versionsRaw) as FlowGraph[] + const currentIndex = indexRaw ? Number.parseInt(indexRaw, 10) : 0 + + return { versions, currentIndex } + } + catch { + return null + } +} + +const saveToSessionStorage = (flowId: string, versions: FlowGraph[], currentIndex: number) => { + if (typeof window === 'undefined') + return + + try { + const versionsKey = `${STORAGE_KEY_PREFIX}${flowId}-versions` + const indexKey = `${STORAGE_KEY_PREFIX}${flowId}-version-index` + + sessionStorage.setItem(versionsKey, JSON.stringify(versions)) + sessionStorage.setItem(indexKey, String(currentIndex)) + } + catch (error) { + console.error('Failed to save vibe flow to sessionStorage:', error) + } +} + +export const useVibeFlowSessionStorage = (flowId: string) => { + const workflowStore = useWorkflowStore() + const versions = useStore(s => s.vibeFlowVersions) + const currentIndex = useStore(s => s.vibeFlowCurrentIndex) + const loadedFlowIdRef = useRef(null) + const isLoadingRef = useRef(false) + + // Load from sessionStorage when flowId changes + useEffect(() => { + if (!flowId || loadedFlowIdRef.current === flowId) + return + + isLoadingRef.current = true + const stored = loadFromSessionStorage(flowId) + + if (stored) { + workflowStore.setState({ + vibeFlowVersions: stored.versions, + vibeFlowCurrentIndex: stored.currentIndex, + }) + } + else { + workflowStore.setState({ + vibeFlowVersions: [], + vibeFlowCurrentIndex: 0, + currentVibeFlow: undefined, + }) + } + + loadedFlowIdRef.current = flowId + // Delay to prevent immediate save + setTimeout(() => { + isLoadingRef.current = false + }, 100) + }, [flowId, workflowStore]) + + // Save to sessionStorage when versions or index change + useEffect(() => { + if (!flowId || loadedFlowIdRef.current !== flowId || isLoadingRef.current) + return + + saveToSessionStorage(flowId, versions, currentIndex) + }, [flowId, versions, currentIndex]) +} + +const buildEdge = ( + source: Node, + target: Node, + sourceHandle = 'source', + targetHandle = 'target', +): Edge => ({ + id: `${source.id}-${sourceHandle}-${target.id}-${targetHandle}`, + type: CUSTOM_EDGE, + source: source.id, + sourceHandle, + target: target.id, + targetHandle, + data: { + sourceType: source.data.type, + targetType: target.data.type, + isInIteration: false, + isInLoop: false, + _connectedNodeIsSelected: false, + }, + zIndex: 0, +}) + +export const useWorkflowVibe = () => { + const { t } = useTranslation() + const store = useStoreApi() + const workflowStore = useWorkflowStore() + const configsMap = useHooksStore(s => s.configsMap) + + const language = useGetLanguage() + const { nodesMap: nodesMetaDataMap } = useNodesMetaData() + const { handleSyncWorkflowDraft } = useNodesSyncDraft() + const { getNodesReadOnly } = useNodesReadOnly() + const { saveStateToHistory } = useWorkflowHistory() + const { defaultModel, modelList } = useModelListAndDefaultModelAndCurrentProviderAndModel(ModelTypeEnum.textGeneration) + + const { data: buildInTools } = useAllBuiltInTools() + const { data: customTools } = useAllCustomTools() + const { data: workflowTools } = useAllWorkflowTools() + const { data: mcpTools } = useAllMCPTools() + + const [modelConfig, setModelConfig] = useState(null) + const isGeneratingRef = useRef(false) + const lastInstructionRef = useRef('') + + useVibeFlowSessionStorage(configsMap?.flowId || '') + + useEffect(() => { + const storedModel = (() => { + if (typeof window === 'undefined') + return null + const stored = localStorage.getItem('auto-gen-model') + if (!stored) + return null + try { + return JSON.parse(stored) as Model + } + catch { + return null + } + })() + + if (storedModel) { + setModelConfig(storedModel) + return + } + + if (defaultModel) { + setModelConfig({ + name: defaultModel.model, + provider: defaultModel.provider.provider, + mode: ModelModeType.chat, + completion_params: {} as Model['completion_params'], + }) + } + }, [defaultModel]) + + const getLatestModelConfig = useCallback(() => { + if (typeof window === 'undefined') + return modelConfig + const stored = localStorage.getItem('auto-gen-model') + if (!stored) + return modelConfig + try { + return JSON.parse(stored) as Model + } + catch { + return modelConfig + } + }, [modelConfig]) + + const availableNodesList = useMemo(() => { + if (!nodesMetaDataMap) + return [] + return Object.values(nodesMetaDataMap).map(node => ({ + type: node.metaData.type, + title: node.metaData.title, + description: node.metaData.description, + })) + }, [nodesMetaDataMap]) + + const toolOptions = useMemo(() => { + const collections = [ + buildInTools, + customTools, + workflowTools, + mcpTools, + ].filter(Boolean) as ToolWithProvider[][] + + const tools: ToolDefaultValue[] = [] + const seen = new Set() + + collections.forEach((collection) => { + collection.forEach((provider) => { + provider.tools.forEach((tool) => { + const key = `${provider.id}:${tool.name}` + if (seen.has(key)) + return + seen.add(key) + + const params = buildToolParams(tool.parameters) + const toolDescription = typeof tool.description === 'object' + ? tool.description?.[language] + : tool.description + tools.push({ + provider_id: provider.id, + provider_type: provider.type, + provider_name: provider.name, + plugin_id: provider.plugin_id, + plugin_unique_identifier: provider.plugin_unique_identifier, + provider_icon: normalizeProviderIcon(provider.icon), + provider_icon_dark: normalizeProviderIcon(provider.icon_dark), + tool_name: tool.name, + tool_label: tool.label[language] || tool.name, + tool_description: toolDescription || '', + title: tool.label[language] || tool.name, + is_team_authorization: provider.is_team_authorization, + paramSchemas: tool.parameters, + params, + output_schema: tool.output_schema, + meta: provider.meta, + }) + }) + }) + }) + + return tools + }, [buildInTools, customTools, workflowTools, mcpTools, language]) + + const toolLookup = useMemo(() => { + const map = new Map() + toolOptions.forEach((tool) => { + // Primary key: provider_id/tool_name (e.g., "google/google_search") + const primaryKey = normalizeKey(`${tool.provider_id}/${tool.tool_name}`) + map.set(primaryKey, tool) + + // Fallback 1: provider_name/tool_name (e.g., "Google/google_search") + const providerNameKey = normalizeKey(`${tool.provider_name}/${tool.tool_name}`) + map.set(providerNameKey, tool) + + // Fallback 2: tool_label (display name) + const labelKey = normalizeKey(tool.tool_label) + map.set(labelKey, tool) + + // Fallback 3: tool_name alone (for partial matching when model omits provider) + const toolNameKey = normalizeKey(tool.tool_name) + if (!map.has(toolNameKey)) { + // Only set if not already taken (avoid collisions between providers) + map.set(toolNameKey, tool) + } + }) + return map + }, [toolOptions]) + + const nodeTypeLookup = useMemo(() => { + const map = new Map() + if (!nodesMetaDataMap) + return map + Object.values(nodesMetaDataMap).forEach((node) => { + map.set(normalizeKey(node.metaData.type), node.metaData.type) + if (node.metaData.title) + map.set(normalizeKey(node.metaData.title), node.metaData.type) + }) + map.set('ifelse', BlockEnum.IfElse) + map.set('ifelsecase', BlockEnum.IfElse) + return map + }, [nodesMetaDataMap]) + + const createGraphFromBackendNodes = useCallback(async ( + backendNodes: BackendNodeSpec[], + backendEdges: BackendEdgeSpec[], + ): Promise => { + const { getNodes } = store.getState() + const nodes = getNodes() + + if (!nodesMetaDataMap) { + Toast.notify({ type: 'error', message: t('vibe.nodesUnavailable', { ns: 'workflow' }) }) + return { nodes: [], edges: [] } + } + + const existingStartNode = nodes.find(node => node.data.type === BlockEnum.Start) + const newNodes: Node[] = [] + const nodeIdMap = new Map() + + for (const nodeSpec of backendNodes) { + // Map string type to BlockEnum + const typeKey = normalizeKey(nodeSpec.type) + const nodeType = nodeTypeLookup.get(typeKey) + if (!nodeType) { + // Skip unknown node types + continue + } + + if (nodeType === BlockEnum.Start && existingStartNode) { + // Merge backend variables into existing Start node + const backendVariables = (nodeSpec.config?.variables as Array>) || [] + if (backendVariables.length > 0) { + const existingVariables = (existingStartNode.data.variables as Array>) || [] + // Add new variables that don't already exist + for (const backendVar of backendVariables) { + const varName = backendVar.variable as string + const exists = existingVariables.some(v => v.variable === varName) + if (!exists) { + existingVariables.push(backendVar) + } + } + // Note: we don't mutate existingStartNode directly here for the return value, + // but we should probably include it in the graph if we want it to be part of the preview? + // Actually, existingStartNode is already in 'nodes'. + // The preview usually shows ONLY new nodes + maybe start node? + // User's code applied changes to existingStartNode directly. + // For preview, we might want to clone it. + // For now, we just map it. + } + + nodeIdMap.set(nodeSpec.id, existingStartNode) + continue + } + + const nodeDefault = nodesMetaDataMap[nodeType] + if (!nodeDefault) + continue + + const defaultValue = nodeDefault.defaultValue || {} + const title = nodeSpec.title?.trim() || nodeDefault.metaData.title || defaultValue.title || nodeSpec.type + + // For tool nodes, try to get tool default value from config + let toolDefaultValue: ToolDefaultValue | undefined + if (nodeType === BlockEnum.Tool && nodeSpec.config) { + const toolName = nodeSpec.config.tool_name as string | undefined + const providerId = nodeSpec.config.provider_id as string | undefined + if (toolName && providerId) { + const toolKey = normalizeKey(`${providerId}/${toolName}`) + toolDefaultValue = toolLookup.get(toolKey) || toolLookup.get(normalizeKey(toolName)) + } + } + + const desc = (toolDefaultValue?.tool_description || (defaultValue as { desc?: string }).desc || '') as string + + // Merge backend config into node data + // Backend provides: { url: "{{#start.url#}}", method: "GET", ... } + const backendConfig = nodeSpec.config || {} + + // Deep merge for nested objects (e.g., body, authorization) to preserve required fields + const mergedConfig: Record = { ...backendConfig } + const defaultValueRecord = defaultValue as Record + + // For http-request nodes, ensure body has all required fields + if (nodeType === BlockEnum.HttpRequest) { + const defaultBody = defaultValueRecord.body as Record | undefined + const backendBody = backendConfig.body as Record | undefined + if (defaultBody || backendBody) { + mergedConfig.body = { + type: 'none', + data: [], + ...(defaultBody || {}), + ...(backendBody || {}), + } + // Ensure data is always an array + if (!Array.isArray((mergedConfig.body as Record).data)) { + (mergedConfig.body as Record).data = [] + } + } + + // Ensure authorization has type + const defaultAuth = defaultValueRecord.authorization as Record | undefined + const backendAuth = backendConfig.authorization as Record | undefined + if (defaultAuth || backendAuth) { + mergedConfig.authorization = { + type: 'no-auth', + ...(defaultAuth || {}), + ...(backendAuth || {}), + } + } + } + + // For End nodes, ensure outputs have value_selector format + // New format (preferred): {"outputs": [{"variable": "name", "value_selector": ["nodeId", "field"]}]} + // Legacy format (fallback): {"outputs": [{"variable": "name", "value": "{{#nodeId.field#}}"}]} + if (nodeType === BlockEnum.End && backendConfig.outputs) { + const outputs = backendConfig.outputs as Array<{ variable?: string, value?: string, value_selector?: string[] }> + mergedConfig.outputs = outputs.map((output) => { + // Preferred: value_selector array format (new LLM output format) + if (output.value_selector && Array.isArray(output.value_selector)) { + return output + } + // Parse value like "{{#nodeId.field#}}" into ["nodeId", "field"] + if (output.value) { + const match = output.value.match(/\{\{#([^.]+)\.([^#]+)#\}\}/) + if (match) { + return { + variable: output.variable, + value_selector: [match[1], match[2]], + } + } + } + // Fallback: return with empty value_selector to prevent crash + return { + variable: output.variable || 'output', + value_selector: [], + } + }) + } + + // For Parameter Extractor nodes, ensure each parameter has a 'required' field + // Backend may omit this field, but Dify's Pydantic model requires it + if (nodeType === BlockEnum.ParameterExtractor) { + // Fix: If backend returns query as null, use default empty array instead + if (backendConfig.query === null || backendConfig.query === undefined) { + mergedConfig.query = [] + } + if (backendConfig.parameters) { + const parameters = backendConfig.parameters as Array<{ name?: string, type?: string, description?: string, required?: boolean }> + mergedConfig.parameters = parameters.map(param => ({ + ...param, + required: param.required ?? true, // Default to required if not specified + })) + } + } + + // For Question Classifier nodes, ensure query_variable_selector is not null + // Backend may return null, but Dify's Pydantic model requires an array + // Note: question-classifier uses 'query' field in backend config, but 'query_variable_selector' in frontend + if (nodeType === BlockEnum.QuestionClassifier) { + // Fix: If backend returns query as null, use default empty array instead + const backendQuery = backendConfig.query + if (backendQuery === null || backendQuery === undefined) { + mergedConfig.query_variable_selector = [] + } + else if (Array.isArray(backendQuery)) { + // Map backend 'query' field to frontend 'query_variable_selector' field + mergedConfig.query_variable_selector = backendQuery + // Remove the 'query' field to avoid confusion + delete mergedConfig.query + } + } + + // For Variable Aggregator nodes, ensure variables format is correct + // Backend expects list[list[str]], but LLM may generate dict format + if (nodeType === BlockEnum.VariableAggregator && backendConfig.variables) { + const backendVariables = backendConfig.variables as Array + const repairedVariables: string[][] = [] + let repaired = false + + for (const varItem of backendVariables) { + if (Array.isArray(varItem)) { + // Already in correct format + repairedVariables.push(varItem) + } + else if (typeof varItem === 'object' && varItem !== null) { + // Convert dict format to array format + const valueSelector = varItem.value_selector || varItem.selector || varItem.path + if (Array.isArray(valueSelector) && valueSelector.length > 0) { + repairedVariables.push(valueSelector) + repaired = true + } + else { + // Try to extract from name field - LLM may generate {"name": "node_id.field"} + const name = varItem.name + if (typeof name === 'string' && name.includes('.')) { + const parts = name.split('.', 2) + if (parts.length === 2) { + repairedVariables.push([parts[0], parts[1]]) + repaired = true + } + } + // If still can't parse, skip this variable (don't add empty array) + } + } + } + + if (repaired || repairedVariables.length !== backendVariables.length) { + mergedConfig.variables = repairedVariables + } + } + + // For any node with model config, validate against user's available models + // Only fallback to default if backend generated an invalid/unavailable model + // This prevents "Model not exist" errors while trusting valid backend model selections + if (backendConfig.model) { + const backendModel = backendConfig.model as { provider?: string, name?: string, mode?: string } + const backendProvider = backendModel.provider + const backendName = backendModel.name + + // Check if backend model exists in user's available models + const isValidModel = backendProvider && backendName && modelList?.some(provider => + provider.provider === backendProvider + && provider.models.some(m => m.model === backendName), + ) + + if (!isValidModel) { + // Backend model is invalid or not available - fallback to user's default + const fallbackModel = modelList?.[0]?.models?.[0] + const modelProvider = defaultModel?.provider?.provider || modelList?.[0]?.provider + const modelName = defaultModel?.model || fallbackModel?.model + + if (modelProvider && modelName) { + mergedConfig.model = { + provider: modelProvider, + name: modelName, + mode: 'chat', + } + } + } + // else: backend model is valid, keep it as-is + } + + const data = { + ...(defaultValue as Record), + title, + desc, + type: nodeType, + selected: false, + ...(toolDefaultValue || {}), + // Apply backend-generated config (url, method, headers, etc.) + ...mergedConfig, + } + + const newNode = generateNewNode({ + id: uuid4(), + type: getNodeCustomTypeByNodeDataType(nodeType), + data, + position: nodeSpec.position || { x: 0, y: 0 }, + }).newNode + + newNodes.push(newNode) + nodeIdMap.set(nodeSpec.id, newNode) + } + + // Replace variable references in all node configs using the nodeIdMap + // This converts {{#old_id.field#}} to {{#new_uuid.field#}} + + for (const node of newNodes) { + node.data = replaceVariableReferences(node.data, nodeIdMap) as typeof node.data + } + + // Use Dify's standard node initialization to handle all node types generically + // This sets up _targetBranches for question-classifier/if-else, _children for iteration/loop, etc. + const initializedNodes = initializeNodeData(newNodes, []) + + // Update newNodes with initialized data + newNodes.splice(0, newNodes.length, ...initializedNodes) + + if (!newNodes.length) { + Toast.notify({ type: 'error', message: t('vibe.invalidFlowchart', { ns: 'workflow' }) }) + return { nodes: [], edges: [] } + } + + const newEdges: Edge[] = [] + for (const edgeSpec of backendEdges) { + const sourceNode = nodeIdMap.get(edgeSpec.source) + const targetNode = nodeIdMap.get(edgeSpec.target) + + if (!sourceNode || !targetNode) { + console.warn(`[VIBE] Edge skipped: source=${edgeSpec.source} (found=${!!sourceNode}), target=${edgeSpec.target} (found=${!!targetNode})`) + continue + } + + let sourceHandle = edgeSpec.sourceHandle || 'source' + // Handle IfElse branch handles + if (sourceNode.data.type === BlockEnum.IfElse && !edgeSpec.sourceHandle) { + sourceHandle = 'source' + } + + newEdges.push(buildEdge(sourceNode, targetNode, sourceHandle, edgeSpec.targetHandle || 'target')) + } + + // Layout nodes + const bounds = nodes.reduce( + (acc, node) => { + const width = node.width ?? NODE_WIDTH + acc.maxX = Math.max(acc.maxX, node.position.x + width) + acc.minY = Math.min(acc.minY, node.position.y) + return acc + }, + { maxX: 0, minY: 0 }, + ) + + const baseX = nodes.length ? bounds.maxX + NODE_WIDTH_X_OFFSET : 0 + const baseY = Number.isFinite(bounds.minY) ? bounds.minY : 0 + const branchOffset = Math.max(120, NODE_WIDTH_X_OFFSET / 2) + + const layoutNodeIds = new Set(newNodes.map(node => node.id)) + const layoutEdges = newEdges.filter(edge => + layoutNodeIds.has(edge.source) && layoutNodeIds.has(edge.target), + ) + + try { + const layout = await getLayoutByDagre(newNodes, layoutEdges) + const layoutedNodes = newNodes.map((node) => { + const info = layout.nodes.get(node.id) + if (!info) + return node + return { + ...node, + position: { + x: baseX + info.x, + y: baseY + info.y, + }, + } + }) + newNodes.splice(0, newNodes.length, ...layoutedNodes) + } + catch { + newNodes.forEach((node, index) => { + const row = Math.floor(index / 4) + const col = index % 4 + node.position = { + x: baseX + col * NODE_WIDTH_X_OFFSET, + y: baseY + row * branchOffset, + } + }) + } + + return { + nodes: newNodes, + edges: newEdges, + } + }, [ + defaultModel, + modelList, + nodeTypeLookup, + nodesMetaDataMap, + store, + t, + toolLookup, + ]) + + // Apply backend-provided nodes directly (bypasses mermaid parsing) + const applyBackendNodesToWorkflow = useCallback(async ( + backendNodes: BackendNodeSpec[], + backendEdges: BackendEdgeSpec[], + ) => { + const { getNodes, setNodes, edges, setEdges } = store.getState() + const nodes = getNodes() + const { + setShowVibePanel, + } = workflowStore.getState() + + const { nodes: newNodes, edges: newEdges } = await createGraphFromBackendNodes(backendNodes, backendEdges) + + if (newNodes.length === 0) { + setShowVibePanel(false) + return + } + + const allNodes = [...nodes, ...newNodes] + const nodesConnectedMap = getNodesConnectedSourceOrTargetHandleIdsMap( + newEdges.map(edge => ({ type: 'add', edge })), + allNodes, + ) + + const updatedNodes = allNodes.map((node) => { + const connected = nodesConnectedMap[node.id] + if (!connected) + return node + + return { + ...node, + data: { + ...node.data, + ...connected, + _connectedSourceHandleIds: dedupeHandles(connected._connectedSourceHandleIds), + _connectedTargetHandleIds: dedupeHandles(connected._connectedTargetHandleIds), + }, + } + }) + + setNodes(updatedNodes) + setEdges([...edges, ...newEdges]) + saveStateToHistory(WorkflowHistoryEvent.NodeAdd, { nodeId: newNodes[0].id }) + handleSyncWorkflowDraft() + + workflowStore.setState(state => ({ + ...state, + showVibePanel: false, + vibePanelMermaidCode: '', + })) + }, [ + createGraphFromBackendNodes, + handleSyncWorkflowDraft, + saveStateToHistory, + store, + ]) + + const flowchartToWorkflowGraph = useCallback(async (mermaidCode: string): Promise => { + const { getNodes } = store.getState() + const nodes = getNodes() + + const parseResultToUse = parseMermaidFlowchart(mermaidCode, nodeTypeLookup, toolLookup) + const emptyGraph = { + nodes: [], + edges: [], + } + if ('error' in parseResultToUse) { + switch (parseResultToUse.error) { + case 'missingNodeType': + case 'missingNodeDefinition': + Toast.notify({ type: 'error', message: t('vibe.invalidFlowchart', { ns: 'workflow' }) }) + return emptyGraph + case 'unknownNodeId': + Toast.notify({ type: 'error', message: t('vibe.unknownNodeId', { ns: 'workflow', id: parseResultToUse.detail }) }) + return emptyGraph + case 'unknownNodeType': + Toast.notify({ type: 'error', message: t('vibe.nodeTypeUnavailable', { ns: 'workflow', type: parseResultToUse.detail }) }) + return emptyGraph + case 'unknownTool': + Toast.notify({ type: 'error', message: t('vibe.toolUnavailable', { ns: 'workflow', tool: parseResultToUse.detail }) }) + return emptyGraph + case 'unsupportedEdgeLabel': + Toast.notify({ type: 'error', message: t('vibe.unsupportedEdgeLabel', { ns: 'workflow', label: parseResultToUse.detail }) }) + return emptyGraph + default: + Toast.notify({ type: 'error', message: t('vibe.invalidFlowchart', { ns: 'workflow' }) }) + return emptyGraph + } + } + + if (!nodesMetaDataMap) { + Toast.notify({ type: 'error', message: t('vibe.nodesUnavailable', { ns: 'workflow' }) }) + return emptyGraph + } + + const existingStartNode = nodes.find(node => node.data.type === BlockEnum.Start) + const newNodes: Node[] = [] + const nodeIdMap = new Map() + + parseResultToUse.nodes.forEach((nodeSpec) => { + if (nodeSpec.type === BlockEnum.Start && existingStartNode) { + nodeIdMap.set(nodeSpec.id, existingStartNode) + return + } + + const nodeDefault = nodesMetaDataMap![nodeSpec.type] + if (!nodeDefault) + return + + const defaultValue = nodeDefault.defaultValue || {} + const title = nodeSpec.title?.trim() || nodeDefault.metaData.title || defaultValue.title || nodeSpec.type + + const toolDefaultValue = nodeSpec.toolKey ? toolLookup.get(nodeSpec.toolKey) : undefined + const desc = (toolDefaultValue?.tool_description || (defaultValue as { desc?: string }).desc || '') as string + + const data = { + ...(defaultValue as Record), + title, + desc, + type: nodeSpec.type, + selected: false, + ...(toolDefaultValue || {}), + } + + const newNode = generateNewNode({ + id: uuid4(), + type: getNodeCustomTypeByNodeDataType(nodeSpec.type), + data, + position: { x: 0, y: 0 }, + }).newNode + + newNodes.push(newNode) + nodeIdMap.set(nodeSpec.id, newNode) + }) + + if (!newNodes.length) { + Toast.notify({ type: 'error', message: t('vibe.invalidFlowchart', { ns: 'workflow' }) }) + return emptyGraph + } + + const newEdges: Edge[] = [] + for (const edgeSpec of parseResultToUse.edges) { + const sourceNode = nodeIdMap.get(edgeSpec.sourceId) + const targetNode = nodeIdMap.get(edgeSpec.targetId) + if (!sourceNode || !targetNode) + continue + + let sourceHandle = 'source' + if (sourceNode.data.type === BlockEnum.IfElse) { + const branchLabel = normalizeBranchLabel(edgeSpec.label) + if (branchLabel === 'true') { + sourceHandle = (sourceNode.data as { cases?: { case_id: string }[] })?.cases?.[0]?.case_id || 'true' + } + if (branchLabel === 'false') { + sourceHandle = 'false' + } + } + + newEdges.push(buildEdge(sourceNode, targetNode, sourceHandle)) + } + + const bounds = nodes.reduce( + (acc, node) => { + const width = node.width ?? NODE_WIDTH + acc.maxX = Math.max(acc.maxX, node.position.x + width) + acc.minY = Math.min(acc.minY, node.position.y) + return acc + }, + { maxX: 0, minY: 0 }, + ) + + const baseX = nodes.length ? bounds.maxX + NODE_WIDTH_X_OFFSET : 0 + const baseY = Number.isFinite(bounds.minY) ? bounds.minY : 0 + const branchOffset = Math.max(120, NODE_WIDTH_X_OFFSET / 2) + + const layoutNodeIds = new Set(newNodes.map(node => node.id)) + const layoutEdges = newEdges.filter(edge => + layoutNodeIds.has(edge.source) && layoutNodeIds.has(edge.target), + ) + + try { + const layout = await getLayoutByDagre(newNodes, layoutEdges) + const layoutedNodes = newNodes.map((node) => { + const info = layout.nodes.get(node.id) + if (!info) + return node + return { + ...node, + position: { + x: baseX + info.x, + y: baseY + info.y, + }, + } + }) + newNodes.splice(0, newNodes.length, ...layoutedNodes) + } + catch { + newNodes.forEach((node, index) => { + const row = Math.floor(index / 4) + const col = index % 4 + node.position = { + x: baseX + col * NODE_WIDTH_X_OFFSET, + y: baseY + row * branchOffset, + } + }) + } + + const allNodes = [...nodes, ...newNodes] + const nodesConnectedMap = getNodesConnectedSourceOrTargetHandleIdsMap( + newEdges.map(edge => ({ type: 'add', edge })), + allNodes, + ) + + const updatedNodes = allNodes.map((node) => { + const connected = nodesConnectedMap[node.id] + if (!connected) + return node + + return { + ...node, + data: { + ...node.data, + ...connected, + _connectedSourceHandleIds: dedupeHandles(connected._connectedSourceHandleIds), + _connectedTargetHandleIds: dedupeHandles(connected._connectedTargetHandleIds), + }, + } + }) + return { + nodes: updatedNodes, + edges: newEdges, + } + }, [nodeTypeLookup, nodesMetaDataMap, store, t, toolLookup]) + + const applyFlowchartToWorkflow = useCallback(() => { + const currentFlowGraph = workflowStore.getState().currentVibeFlow + + if (!currentFlowGraph || !currentFlowGraph.nodes || currentFlowGraph.nodes.length === 0) { + Toast.notify({ type: 'error', message: t('vibe.invalidFlowchart', { ns: 'workflow' }) }) + return + } + + const { setNodes, setEdges } = store.getState() + const vibePanelPreviewNodes = currentFlowGraph.nodes || [] + const vibePanelPreviewEdges = currentFlowGraph.edges || [] + + setNodes(vibePanelPreviewNodes) + setEdges(vibePanelPreviewEdges) + saveStateToHistory(WorkflowHistoryEvent.NodeAdd, { nodeId: vibePanelPreviewNodes[0].id }) + handleSyncWorkflowDraft(true, true) + + workflowStore.setState(state => ({ + ...state, + showVibePanel: false, + vibePanelMermaidCode: '', + })) + }, [ + handleSyncWorkflowDraft, + saveStateToHistory, + store, + t, + toolLookup, + workflowStore, + ]) + + const handleVibeCommand = useCallback(async ( + dsl?: string, + skipPanelPreview = false, + regenerateMode = false, + ) => { + if (getNodesReadOnly()) { + Toast.notify({ type: 'error', message: t('vibe.readOnly', { ns: 'workflow' }) }) + return + } + + const trimmed = dsl?.trim() || '' + if (!trimmed) { + Toast.notify({ type: 'error', message: t('vibe.missingInstruction', { ns: 'workflow' }) }) + return + } + + if (!nodesMetaDataMap || Object.keys(nodesMetaDataMap).length === 0) { + Toast.notify({ type: 'error', message: t('vibe.nodesUnavailable', { ns: 'workflow' }) }) + return + } + + const latestModelConfig = getLatestModelConfig() + if (!latestModelConfig && !isMermaidFlowchart(trimmed)) { + Toast.notify({ type: 'error', message: t('vibe.modelUnavailable', { ns: 'workflow' }) }) + return + } + + if (isGeneratingRef.current) + return + isGeneratingRef.current = true + + if (!isMermaidFlowchart(trimmed)) + lastInstructionRef.current = trimmed + + workflowStore.setState(state => ({ + ...state, + showVibePanel: true, + isVibeGenerating: true, + vibePanelMermaidCode: '', + vibePanelInstruction: trimmed, + vibePanelIntent: '', + vibePanelMessage: '', + vibePanelSuggestions: [], + })) + + try { + const { getNodes } = store.getState() + const _nodes = getNodes() + const { + setIsVibeGenerating, + vibePanelBackendNodes: _vibePanelBackendNodes, + vibePanelBackendEdges: _vibePanelBackendEdges, + } = workflowStore.getState() + + // Refinement mode removed - always start fresh + const existingNodesPayload: Array<{ id: string, type: string, title: string }> = [] + + const toolsPayload = toolOptions.map(tool => ({ + provider_id: tool.provider_id, + provider_name: tool.provider_name, + provider_type: tool.provider_type, + tool_name: tool.tool_name, + tool_label: tool.tool_label, + tool_key: `${tool.provider_id}/${tool.tool_name}`, + tool_description: tool.tool_description, + is_team_authorization: tool.is_team_authorization, + // Include parameter schemas so backend can inform model how to use tools + parameters: tool.paramSchemas, + output_schema: tool.output_schema, + })) + + // Refinement mode removed - always use empty edges + const existingEdgesPayload: Array<{ source: string, target: string, sourceHandle: string }> = [] + + const availableNodesPayload = availableNodesList.map(node => ({ + type: node.type, + title: node.title, + description: node.description, + })) + + let mermaidCode = '' + let backendNodes: BackendNodeSpec[] | undefined + let backendEdges: BackendEdgeSpec[] | undefined + + if (!isMermaidFlowchart(trimmed)) { + // Build previous workflow context if regenerating + const { vibePanelBackendNodes, vibePanelBackendEdges, vibePanelLastWarnings } = workflowStore.getState() + const previousWorkflow = regenerateMode && vibePanelBackendNodes && vibePanelBackendNodes.length > 0 + ? { + nodes: vibePanelBackendNodes, + edges: vibePanelBackendEdges || [], + warnings: vibePanelLastWarnings || [], + } + : undefined + + // Map language code to human-readable language name for LLM + const languageNameMap: Record = { + en_US: 'English', + zh_Hans: 'Chinese', + zh_Hant: 'Traditional Chinese', + ja_JP: 'Japanese', + ko_KR: 'Korean', + pt_BR: 'Portuguese', + es_ES: 'Spanish', + fr_FR: 'French', + de_DE: 'German', + it_IT: 'Italian', + ru_RU: 'Russian', + uk_UA: 'Ukrainian', + vi_VN: 'Vietnamese', + pl_PL: 'Polish', + ro_RO: 'Romanian', + tr_TR: 'Turkish', + fa_IR: 'Persian', + hi_IN: 'Hindi', + } + const preferredLanguage = languageNameMap[language] || 'English' + + // Extract available models from user's configured model providers + const availableModelsPayload = modelList?.flatMap(provider => + provider.models.map(model => ({ + provider: provider.provider, + model: model.model, + })), + ) || [] + + const requestPayload = { + instruction: trimmed, + model_config: latestModelConfig, + available_nodes: availableNodesPayload, + existing_nodes: existingNodesPayload, + existing_edges: existingEdgesPayload, + available_tools: toolsPayload, + selected_node_ids: [], + previous_workflow: previousWorkflow, + regenerate_mode: regenerateMode, + language: preferredLanguage, + available_models: availableModelsPayload, + } + + const response = await generateFlowchart(requestPayload) + + const { error, flowchart, nodes, edges, intent, message, warnings, suggestions } = response + + if (error) { + Toast.notify({ type: 'error', message: error }) + workflowStore.setState(state => ({ + ...state, + vibePanelMessage: `${error} ${t('vibe.regenerateReminder', { ns: 'workflow' })}`, + isVibeGenerating: false, + })) + return + } + + // Handle off_topic intent - show rejection message and suggestions + if (intent === 'off_topic') { + workflowStore.setState(state => ({ + ...state, + vibePanelMermaidCode: '', + vibePanelMessage: message || t('vibe.offTopicDefault', { ns: 'workflow' }), + vibePanelSuggestions: suggestions || [], + vibePanelIntent: 'off_topic', + isVibeGenerating: false, + })) + return + } + + if (!flowchart) { + Toast.notify({ type: 'error', message: t('vibe.missingFlowchart', { ns: 'workflow' }) }) + setIsVibeGenerating(false) + return + } + + // Show warnings if any (includes tool sanitization warnings) + const responseWarnings = warnings || [] + if (responseWarnings.length > 0) { + responseWarnings.forEach((warning) => { + Toast.notify({ type: 'warning', message: warning }) + }) + } + + mermaidCode = flowchart + // Store backend nodes/edges for direct use (bypasses mermaid re-parsing) + backendNodes = nodes + backendEdges = edges + // Store warnings for regeneration context + workflowStore.setState(state => ({ + ...state, + vibePanelLastWarnings: responseWarnings, + })) + + workflowStore.setState(state => ({ + ...state, + vibePanelMermaidCode: mermaidCode, + vibePanelBackendNodes: backendNodes, + vibePanelBackendEdges: backendEdges, + vibePanelMessage: '', + vibePanelSuggestions: [], + vibePanelIntent: 'generate', + isVibeGenerating: false, + })) + } + + setIsVibeGenerating(false) + + // Add version for preview + if (backendNodes && backendNodes.length > 0 && backendEdges) { + const graph = await createGraphFromBackendNodes(backendNodes, backendEdges) + workflowStore.getState().addVibeFlowVersion(graph) + } + else if (mermaidCode) { + const graph = await flowchartToWorkflowGraph(mermaidCode) + workflowStore.getState().addVibeFlowVersion(graph) + } + + if (skipPanelPreview) { + // Prefer backend nodes (already sanitized) over mermaid re-parsing + if (backendNodes && backendNodes.length > 0 && backendEdges) { + console.log('[VIBE] Applying backend nodes directly to workflow') + console.log('[VIBE] Backend nodes:', backendNodes.length) + console.log('[VIBE] Backend edges:', backendEdges.length) + await applyBackendNodesToWorkflow(backendNodes, backendEdges) + console.log('[VIBE] Backend nodes applied successfully') + } + else { + console.log('[VIBE] Applying mermaid flowchart to workflow') + await applyFlowchartToWorkflow() + console.log('[VIBE] Mermaid flowchart applied successfully') + } + } + } + catch (error: unknown) { + // Handle API errors (e.g., network errors, server errors) + const { setIsVibeGenerating } = workflowStore.getState() + setIsVibeGenerating(false) + + // Extract error message from Response object or Error + let errorMessage = t('vibe.generateError', { ns: 'workflow' }) + if (error instanceof Response) { + try { + const errorData = await error.json() + errorMessage = errorData?.message || errorMessage + } + catch { + // If we can't parse the response, use the default error message + } + } + else if (error instanceof Error) { + errorMessage = error.message || errorMessage + } + + Toast.notify({ type: 'error', message: errorMessage }) + workflowStore.setState(state => ({ + ...state, + vibePanelMessage: `${errorMessage} ${t('vibe.regenerateReminder', { ns: 'workflow' })}`, + isVibeGenerating: false, + })) + } + finally { + isGeneratingRef.current = false + } + }, [ + applyBackendNodesToWorkflow, + applyFlowchartToWorkflow, + createGraphFromBackendNodes, + flowchartToWorkflowGraph, + getLatestModelConfig, + getNodesReadOnly, + nodeTypeLookup, + nodesMetaDataMap, + store, + t, + toolOptions, + ]) + + const handleAccept = useCallback(async () => { + // Prefer backend nodes (already sanitized) over mermaid re-parsing + const { vibePanelBackendNodes, vibePanelBackendEdges } = workflowStore.getState() + if (vibePanelBackendNodes && vibePanelBackendNodes.length > 0 && vibePanelBackendEdges) { + await applyBackendNodesToWorkflow(vibePanelBackendNodes, vibePanelBackendEdges) + } + else { + // Use applyFlowchartToWorkflow which uses currentFlowGraph (populated by addVersion) + applyFlowchartToWorkflow() + } + }, [applyBackendNodesToWorkflow, applyFlowchartToWorkflow]) + + useEffect(() => { + const handler = (event: CustomEvent) => { + handleVibeCommand(event.detail?.dsl, false) + } + + const acceptHandler = () => { + handleAccept() + } + + document.addEventListener(VIBE_COMMAND_EVENT, handler as EventListener) + document.addEventListener(VIBE_APPLY_EVENT, acceptHandler as EventListener) + + return () => { + document.removeEventListener(VIBE_COMMAND_EVENT, handler as EventListener) + document.removeEventListener(VIBE_APPLY_EVENT, acceptHandler as EventListener) + } + }, [handleVibeCommand, handleAccept]) + + return null +} diff --git a/web/app/components/workflow/panel/vibe-panel/index.spec.tsx b/web/app/components/workflow/panel/vibe-panel/index.spec.tsx new file mode 100644 index 0000000000..5c98a171f6 --- /dev/null +++ b/web/app/components/workflow/panel/vibe-panel/index.spec.tsx @@ -0,0 +1,333 @@ +/** + * VibePanel Component Tests + * + * Covers rendering states, user interactions, and edge cases for the vibe panel. + */ + +import type { Shape as WorkflowState } from '@/app/components/workflow/store/workflow' +import type { Edge, Node } from '@/app/components/workflow/types' +import { fireEvent, render, screen, waitFor } from '@testing-library/react' +import userEvent from '@testing-library/user-event' +import Toast from '@/app/components/base/toast' +import { WorkflowContext } from '@/app/components/workflow/context' +import { HooksStoreContext } from '@/app/components/workflow/hooks-store/provider' +import { createHooksStore } from '@/app/components/workflow/hooks-store/store' +import { createWorkflowStore } from '@/app/components/workflow/store/workflow' +import { BlockEnum } from '@/app/components/workflow/types' +import { VIBE_APPLY_EVENT, VIBE_COMMAND_EVENT } from '../../constants' +import VibePanel from './index' + +// ============================================================================ +// Mocks +// ============================================================================ + +const mockCopy = vi.hoisted(() => vi.fn()) +const mockUseVibeFlowData = vi.hoisted(() => vi.fn()) + +vi.mock('copy-to-clipboard', () => ({ + default: mockCopy, +})) + +vi.mock('@/app/components/header/account-setting/model-provider-page/hooks', () => ({ + useModelListAndDefaultModelAndCurrentProviderAndModel: () => ({ defaultModel: null }), +})) + +vi.mock('@/app/components/header/account-setting/model-provider-page/model-parameter-modal', () => ({ + __esModule: true, + default: ({ modelId, provider }: { modelId: string, provider: string }) => ( +
+ ), +})) + +vi.mock('@/app/components/workflow/hooks/use-workflow-vibe', () => ({ + useVibeFlowData: () => mockUseVibeFlowData(), +})) + +vi.mock('@/app/components/workflow/workflow-preview', () => ({ + __esModule: true, + default: ({ nodes, edges }: { nodes: Node[], edges: Edge[] }) => ( +
+ ), +})) + +// ============================================================================ +// Test Utilities +// ============================================================================ + +type FlowGraph = { + nodes: Node[] + edges: Edge[] +} + +type VibeFlowData = { + versions: FlowGraph[] + currentVersionIndex: number + setCurrentVersionIndex: (index: number) => void + current?: FlowGraph +} + +const createMockNode = (overrides: Partial = {}): Node => ({ + id: 'node-1', + type: 'custom', + position: { x: 0, y: 0 }, + data: { + title: 'Start', + desc: '', + type: BlockEnum.Start, + }, + ...overrides, +}) + +const createMockEdge = (overrides: Partial = {}): Edge => ({ + id: 'edge-1', + source: 'node-1', + target: 'node-2', + data: { + sourceType: BlockEnum.Start, + targetType: BlockEnum.End, + }, + ...overrides, +}) + +const createFlowGraph = (overrides: Partial = {}): FlowGraph => ({ + nodes: [], + edges: [], + ...overrides, +}) + +const createVibeFlowData = (overrides: Partial = {}): VibeFlowData => ({ + versions: [], + currentVersionIndex: 0, + setCurrentVersionIndex: vi.fn(), + current: undefined, + ...overrides, +}) + +const renderVibePanel = ({ + workflowState, + vibeFlowData, +}: { + workflowState?: Partial + vibeFlowData?: VibeFlowData +} = {}) => { + if (vibeFlowData) + mockUseVibeFlowData.mockReturnValue(vibeFlowData) + + const workflowStore = createWorkflowStore({}) + const vibeFlowState = vibeFlowData + ? { + vibeFlowVersions: vibeFlowData.versions, + vibeFlowCurrentIndex: vibeFlowData.currentVersionIndex, + currentVibeFlow: vibeFlowData.current, + } + : {} + + workflowStore.setState({ + showVibePanel: true, + isVibeGenerating: false, + vibePanelInstruction: '', + vibePanelMermaidCode: '', + ...vibeFlowState, + ...workflowState, + }) + + const hooksStore = createHooksStore({}) + + return { + workflowStore, + ...render( + + + + + , + ), + } +} + +const getCopyButton = () => { + const buttons = screen.getAllByRole('button') + const copyButton = buttons.find(button => button.textContent?.trim() === '' && button.querySelector('svg')) + if (!copyButton) + throw new Error('Copy button not found') + return copyButton +} + +// ============================================================================ +// Tests +// ============================================================================ + +describe('VibePanel', () => { + let toastNotifySpy: ReturnType + + beforeEach(() => { + vi.clearAllMocks() + mockUseVibeFlowData.mockReturnValue(createVibeFlowData()) + toastNotifySpy = vi.spyOn(Toast, 'notify').mockImplementation(() => ({ clear: vi.fn() })) + }) + + afterEach(() => { + toastNotifySpy.mockRestore() + }) + + // -------------------------------------------------------------------------- + // Rendering: default visibility and primary view states. + // -------------------------------------------------------------------------- + describe('Rendering', () => { + it('should render nothing when panel is hidden', () => { + renderVibePanel({ workflowState: { showVibePanel: false } }) + + expect(screen.queryByText(/app\.gotoAnything\.actions\.vibeTitle/i)).not.toBeInTheDocument() + }) + + it('should render placeholder when no preview data and not generating', () => { + renderVibePanel({ + workflowState: { showVibePanel: true, isVibeGenerating: false }, + vibeFlowData: createVibeFlowData({ current: undefined }), + }) + + expect(screen.getByText(/appDebug\.generate\.newNoDataLine1/i)).toBeInTheDocument() + }) + + it('should render loading state when generating', () => { + renderVibePanel({ + workflowState: { showVibePanel: true, isVibeGenerating: true }, + }) + + expect(screen.getByText(/workflow\.vibe\.generatingFlowchart/i)).toBeInTheDocument() + expect(screen.getByRole('button', { name: 'appDebug.generate.generate' })).toBeDisabled() + }) + + it('should render preview panel when nodes exist', () => { + const flowGraph = createFlowGraph({ + nodes: [createMockNode()], + edges: [createMockEdge()], + }) + + renderVibePanel({ + vibeFlowData: createVibeFlowData({ + current: flowGraph, + versions: [flowGraph], + }), + }) + + expect(screen.getByTestId('workflow-preview')).toBeInTheDocument() + expect(screen.getByRole('button', { name: 'workflow.vibe.apply' })).toBeInTheDocument() + expect(screen.getByText(/appDebug\.generate\.version/i)).toBeInTheDocument() + }) + }) + + // -------------------------------------------------------------------------- + // Props: store-driven inputs that toggle behavior. + // -------------------------------------------------------------------------- + describe('Props', () => { + it('should render modal content when showVibePanel is true', () => { + renderVibePanel({ workflowState: { showVibePanel: true } }) + + expect(screen.getByText(/app\.gotoAnything\.actions\.vibeTitle/i)).toBeInTheDocument() + }) + }) + + // -------------------------------------------------------------------------- + // User Interactions: input edits and action triggers. + // -------------------------------------------------------------------------- + describe('User Interactions', () => { + it('should update instruction in store when typing', async () => { + const { workflowStore } = renderVibePanel() + + const textarea = screen.getByPlaceholderText('workflow.vibe.missingInstruction') + fireEvent.change(textarea, { target: { value: 'Build a vibe flow' } }) + + await waitFor(() => { + expect(workflowStore.getState().vibePanelInstruction).toBe('Build a vibe flow') + }) + }) + + it('should dispatch command event with instruction when generate clicked', async () => { + const user = userEvent.setup() + const { workflowStore } = renderVibePanel({ + workflowState: { vibePanelInstruction: 'Generate a workflow' }, + }) + + const handler = vi.fn() + document.addEventListener(VIBE_COMMAND_EVENT, handler) + + await user.click(screen.getByRole('button', { name: 'appDebug.generate.generate' })) + + expect(handler).toHaveBeenCalledTimes(1) + const event = handler.mock.calls[0][0] as CustomEvent<{ dsl?: string }> + expect(event.detail).toEqual({ dsl: workflowStore.getState().vibePanelInstruction }) + + document.removeEventListener(VIBE_COMMAND_EVENT, handler) + }) + + it('should close panel when dismiss clicked', async () => { + const user = userEvent.setup() + const { workflowStore } = renderVibePanel({ + workflowState: { + vibePanelMermaidCode: 'graph TD', + isVibeGenerating: true, + }, + }) + + await user.click(screen.getByRole('button', { name: 'appDebug.generate.dismiss' })) + + const state = workflowStore.getState() + expect(state.showVibePanel).toBe(false) + expect(state.vibePanelMermaidCode).toBe('') + expect(state.isVibeGenerating).toBe(false) + }) + + it('should dispatch apply event and close panel when apply clicked', async () => { + const user = userEvent.setup() + const flowGraph = createFlowGraph({ + nodes: [createMockNode()], + edges: [createMockEdge()], + }) + const { workflowStore } = renderVibePanel({ + workflowState: { vibePanelMermaidCode: 'graph TD' }, + vibeFlowData: createVibeFlowData({ + current: flowGraph, + versions: [flowGraph], + }), + }) + + const handler = vi.fn() + document.addEventListener(VIBE_APPLY_EVENT, handler) + + await user.click(screen.getByRole('button', { name: 'workflow.vibe.apply' })) + + expect(handler).toHaveBeenCalledTimes(1) + const state = workflowStore.getState() + expect(state.showVibePanel).toBe(false) + expect(state.vibePanelMermaidCode).toBe('') + expect(state.isVibeGenerating).toBe(false) + + document.removeEventListener(VIBE_APPLY_EVENT, handler) + }) + + it('should copy mermaid and notify when copy clicked', async () => { + const user = userEvent.setup() + const flowGraph = createFlowGraph({ + nodes: [createMockNode()], + edges: [createMockEdge()], + }) + + renderVibePanel({ + workflowState: { vibePanelMermaidCode: 'graph TD' }, + vibeFlowData: createVibeFlowData({ + current: flowGraph, + versions: [flowGraph], + }), + }) + + await user.click(getCopyButton()) + + expect(mockCopy).toHaveBeenCalledWith('graph TD') + expect(toastNotifySpy).toHaveBeenCalledWith(expect.objectContaining({ + type: 'success', + message: 'common.actionMsg.copySuccessfully', + })) + }) + }) +}) diff --git a/web/app/components/workflow/panel/vibe-panel/index.tsx b/web/app/components/workflow/panel/vibe-panel/index.tsx new file mode 100644 index 0000000000..f2f9440d99 --- /dev/null +++ b/web/app/components/workflow/panel/vibe-panel/index.tsx @@ -0,0 +1,332 @@ +'use client' + +import type { FC } from 'react' +import type { FormValue } from '@/app/components/header/account-setting/model-provider-page/declarations' +import type { CompletionParams, Model } from '@/types/app' +import { RiClipboardLine } from '@remixicon/react' +import copy from 'copy-to-clipboard' +import { useCallback, useMemo, useState } from 'react' +import { useTranslation } from 'react-i18next' +import { z } from 'zod' +import ResPlaceholder from '@/app/components/app/configuration/config/automatic/res-placeholder' +import VersionSelector from '@/app/components/app/configuration/config/automatic/version-selector' +import Button from '@/app/components/base/button' +import { Generator } from '@/app/components/base/icons/src/vender/other' +import Loading from '@/app/components/base/loading' +import Modal from '@/app/components/base/modal' +import Textarea from '@/app/components/base/textarea' +import Toast from '@/app/components/base/toast' +import { ModelTypeEnum } from '@/app/components/header/account-setting/model-provider-page/declarations' +import { useModelListAndDefaultModelAndCurrentProviderAndModel } from '@/app/components/header/account-setting/model-provider-page/hooks' +import ModelParameterModal from '@/app/components/header/account-setting/model-provider-page/model-parameter-modal' +import { ModelModeType } from '@/types/app' +import { VIBE_APPLY_EVENT, VIBE_COMMAND_EVENT } from '../../constants' +import { useStore, useWorkflowStore } from '../../store' +import WorkflowPreview from '../../workflow-preview' + +const CompletionParamsSchema = z.object({ + max_tokens: z.number(), + temperature: z.number(), + top_p: z.number(), + echo: z.boolean(), + stop: z.array(z.string()), + presence_penalty: z.number(), + frequency_penalty: z.number(), +}) + +const ModelSchema = z.object({ + provider: z.string(), + name: z.string(), + mode: z.nativeEnum(ModelModeType), + completion_params: CompletionParamsSchema, +}) + +const VibePanel: FC = () => { + const { t } = useTranslation() + const workflowStore = useWorkflowStore() + const showVibePanel = useStore(s => s.showVibePanel) + const setShowVibePanel = useStore(s => s.setShowVibePanel) + const isVibeGenerating = useStore(s => s.isVibeGenerating) + const setIsVibeGenerating = useStore(s => s.setIsVibeGenerating) + const vibePanelInstruction = useStore(s => s.vibePanelInstruction) + const vibePanelMermaidCode = useStore(s => s.vibePanelMermaidCode) + const setVibePanelMermaidCode = useStore(s => s.setVibePanelMermaidCode) + const currentFlowGraph = useStore(s => s.currentVibeFlow) + const versions = useStore(s => s.vibeFlowVersions) + const currentVersionIndex = useStore(s => s.vibeFlowCurrentIndex) + + const vibePanelPreviewNodes = currentFlowGraph?.nodes || [] + const vibePanelPreviewEdges = currentFlowGraph?.edges || [] + + const setVibePanelInstruction = useStore(s => s.setVibePanelInstruction) + const vibePanelIntent = useStore(s => s.vibePanelIntent) + const setVibePanelIntent = useStore(s => s.setVibePanelIntent) + const vibePanelMessage = useStore(s => s.vibePanelMessage) + const setVibePanelMessage = useStore(s => s.setVibePanelMessage) + const vibePanelSuggestions = useStore(s => s.vibePanelSuggestions) + const setVibePanelSuggestions = useStore(s => s.setVibePanelSuggestions) + + const { defaultModel } = useModelListAndDefaultModelAndCurrentProviderAndModel(ModelTypeEnum.textGeneration) + + // Track user's explicit model selection (from localStorage) + const [userModel, setUserModel] = useState(() => { + try { + const stored = localStorage.getItem('auto-gen-model') + if (stored) { + const parsed = JSON.parse(stored) + const result = ModelSchema.safeParse(parsed) + if (result.success) + return result.data + + // If validation fails, clear the invalid data + localStorage.removeItem('auto-gen-model') + } + } + catch { + // ignore parse errors + } + return null + }) + + // Derive the actual model from user selection or default + const model: Model = useMemo(() => { + if (userModel) + return userModel + if (defaultModel) { + return { + name: defaultModel.model, + provider: defaultModel.provider.provider, + mode: ModelModeType.chat, + completion_params: {} as CompletionParams, + } + } + return { + name: '', + provider: '', + mode: ModelModeType.chat, + completion_params: {} as CompletionParams, + } + }, [userModel, defaultModel]) + + const setModel = useCallback((newModel: Model) => { + setUserModel(newModel) + localStorage.setItem('auto-gen-model', JSON.stringify(newModel)) + }, []) + + const handleModelChange = useCallback((newValue: { modelId: string, provider: string, mode?: string, features?: string[] }) => { + setModel({ + ...model, + provider: newValue.provider, + name: newValue.modelId, + mode: newValue.mode as ModelModeType, + }) + }, [model, setModel]) + + const handleCompletionParamsChange = useCallback((newParams: FormValue) => { + setModel({ + ...model, + completion_params: newParams as CompletionParams, + }) + }, [model, setModel]) + + const handleInstructionChange = useCallback((e: React.ChangeEvent) => { + workflowStore.setState(state => ({ + ...state, + vibePanelInstruction: e.target.value, + })) + }, [workflowStore]) + + const handleClose = useCallback(() => { + setShowVibePanel(false) + setVibePanelMermaidCode('') + setIsVibeGenerating(false) + setVibePanelIntent('') + setVibePanelMessage('') + setVibePanelSuggestions([]) + }, [setShowVibePanel, setVibePanelMermaidCode, setIsVibeGenerating, setVibePanelIntent, setVibePanelMessage, setVibePanelSuggestions]) + + const handleGenerate = useCallback(() => { + const event = new CustomEvent(VIBE_COMMAND_EVENT, { + detail: { dsl: vibePanelInstruction }, + }) + document.dispatchEvent(event) + }, [vibePanelInstruction]) + + const handleAccept = useCallback(() => { + const event = new CustomEvent(VIBE_APPLY_EVENT) + document.dispatchEvent(event) + handleClose() + }, [handleClose]) + + const handleCopyMermaid = useCallback(() => { + copy(vibePanelMermaidCode) + Toast.notify({ type: 'success', message: t('actionMsg.copySuccessfully', { ns: 'common' }) }) + }, [vibePanelMermaidCode, t]) + + const handleSuggestionClick = useCallback((suggestion: string) => { + setVibePanelInstruction(suggestion) + // Trigger generation with the suggestion + const event = new CustomEvent(VIBE_COMMAND_EVENT, { + detail: { dsl: suggestion }, + }) + document.dispatchEvent(event) + }, [setVibePanelInstruction]) + + const handleVersionChange = useCallback((index: number) => { + const { setVibeFlowCurrentIndex } = workflowStore.getState() + setVibeFlowCurrentIndex(index) + }, [workflowStore]) + + // Button label - always use "Generate" (refinement mode removed) + const generateButtonLabel = useMemo(() => { + return t('generate.generate', { ns: 'appDebug' }) + }, [t]) + + if (!showVibePanel) + return null + + const renderLoading = ( +
+ +
{t('vibe.generatingFlowchart', { ns: 'workflow' })}
+
+ ) + + const renderOffTopic = ( +
+
+
+ {t('vibe.offTopicTitle', { ns: 'workflow' })} +
+
+ {vibePanelMessage || t('vibe.offTopicDefault', { ns: 'workflow' })} +
+ {vibePanelSuggestions.length > 0 && ( +
+
+ {t('vibe.trySuggestion', { ns: 'workflow' })} +
+
+ {vibePanelSuggestions.map(suggestion => ( + + ))} +
+
+ )} +
+
+ ) + + return ( + +
+
+
+
{t('gotoAnything.actions.vibeTitle', { ns: 'app' })}
+
{t('gotoAnything.actions.vibeDesc', { ns: 'app' })}
+
+
+ +
+
+
{t('generate.instruction', { ns: 'appDebug' })}
+