flowcraft 1.0.0-beta.1

package/sandbox/4.dag/data/4.content-moderation/README.md

@@ -0,0 +1,83 @@
+# Use Case 4: Content Moderation
+
+This workflow demonstrates a sophisticated "router" pattern. It performs multiple parallel analyses on a piece of content and then uses a central LLM-powered router node to decide which of several distinct moderation actions to take.
+
+## Main Workflow ID: 400
+
+### Description
+
+1. **Parallel Analysis**: The workflow begins by performing three independent checks on the `userPost` in parallel:
+    - `check_for_pii`: Looks for Personally Identifiable Information.
+    - `check_for_hate_speech`: Analyzes the severity of any hate speech.
+    - `check_for_spam`: Detects if the post is commercial spam.
+2. **Router Node**: All three analysis results are fed into the `triage_post` node. This special `llm-router` node uses an LLM to evaluate the combined inputs against a set of rules and returns a single action string (e.g., `action_ban`, `action_redact`).
+3. **Multi-Way Branching**: The action string from the router determines which of the four possible paths is executed.
+    - `action_ban` -> Sub-Workflow 401 (Ban User)
+    - `action_redact` -> Sub-Workflow 402 (Redact Post)
+    - `action_delete_spam` -> Sub-Workflow 403 (Delete Spam)
+    - `action_approve` -> A simple node to log the approval.
+4. **Convergence**: The result from the chosen moderation path is captured in the `final_log` node.
+
+### Visual Graph
+
+```mermaid
+graph TD
+    subgraph "Content Moderation (ID: 400)"
+        A(User Post) --> B[check_for_pii]
+        A --> C[check_for_hate_speech]
+        A --> D[check_for_spam]
+
+        B --> E{triage_post}
+        C --> E
+        D --> E
+
+        E -- action_ban --> F["Sub-Workflow: Ban User (401)"]
+        E -- action_redact --> G["Sub-Workflow: Redact Post (402)"]
+        E -- action_delete_spam --> H["Sub-Workflow: Delete Spam (403)"]
+        E -- action_approve --> I[approve_post_branch]
+
+        F --> Z[final_log]
+        G --> Z
+        H --> Z
+        I --> Z
+    end
+```
+
+---
+
+## Sub-Workflows
+
+### Sub-Workflow ID: 401 (Ban User)
+
+This workflow simulates banning a user by performing a database update and creating a security log entry in parallel.
+
+```mermaid
+graph TD
+    subgraph "Ban User Actions (ID: 401)"
+        A[api_call_ban_user] --> C[output_ban_summary]
+        B[log_ban_event] --> C
+    end
+```
+
+### Sub-Workflow ID: 402 (Redact Post)
+
+This workflow redacts PII from the user's post and generates a warning message for the user, with both actions running in parallel.
+
+```mermaid
+graph TD
+    subgraph "Redact Post Actions (ID: 402)"
+        A[redact_pii] --> C[output_redaction_summary]
+        B[generate_warning] --> C
+    end
+```
+
+### Sub-Workflow ID: 403 (Delete Spam)
+
+A simple, linear workflow that simulates deleting a spam post and flagging the user.
+
+```mermaid
+graph TD
+    subgraph "Delete Spam Action (ID: 403)"
+        A[delete_and_flag_user] --> B[output_spam_summary]
+    end
+```

package/sandbox/4.dag/package.json

@@ -0,0 +1,19 @@
+{
+	"name": "dag-workflow",
+	"type": "module",
+	"scripts": {
+		"start": "npx tsx src/main.ts"
+	},
+	"dependencies": {
+		"dotenv": "^16.4.5",
+		"flowcraft": "workspace:*",
+		"lodash-es": "^4.17.21",
+		"openai": "^4.52.7",
+		"yaml": "^2.5.0"
+	},
+	"devDependencies": {
+		"@types/lodash-es": "^4.17.12",
+		"@types/node": "^24.0.13",
+		"typescript": "^5.5.4"
+	}
+}

package/sandbox/4.dag/src/main.ts

@@ -0,0 +1,73 @@
+import path from 'node:path'
+import process from 'node:process'
+import { ConsoleLogger, TypedContext } from 'flowcraft'
+import { WorkflowRegistry } from './registry'
+
+const config = {
+	'1.blog-post': {
+		mainWorkflowId: 100,
+		allWorkflowIds: [100],
+		getInitialContext: () => new TypedContext([
+			['topic', 'The rise of AI-powered workflow automation in modern software development.'],
+		]),
+	},
+	'2.job-application': {
+		mainWorkflowId: 200,
+		allWorkflowIds: [200, 201, 202],
+		getInitialContext: () => new TypedContext([
+			['applicantName', 'Jane Doe'],
+			['resume', 'Experienced developer with a background in TypeScript, Node.js, and building complex DAG workflow systems. Also proficient in React and SQL.'],
+			['coverLetter', 'To Whom It May Concern, I am writing to express my interest in the Senior Developer position. My skills and experience align perfectly with the requirements of the role.'],
+		]),
+	},
+	'3.customer-review': {
+		mainWorkflowId: 300,
+		allWorkflowIds: [300, 301, 302],
+		getInitialContext: () => new TypedContext([
+			['initial_review', 'The new dashboard is a huge improvement, but I noticed that the export-to-PDF feature is really slow and sometimes crashes the app on large datasets. It would be great if you could look into this.'],
+		]),
+	},
+	'4.content-moderation': {
+		mainWorkflowId: 400,
+		allWorkflowIds: [400, 401, 402, 403],
+		getInitialContext: () => new TypedContext([
+			['userId', 'user-456'],
+			// Try different posts to test different paths
+			// Path 1: PII detection
+			['userPost', 'Hi, I need help with my account. My email is test@example.com and my phone is 555-123-4567.'],
+			// Path 2: Spam
+			// ['userPost', '!!!BUY NOW!!! Visit my-scam-site.com for a FREE PRIZE! Limited time offer!'],
+			// Path 3: Severe hate speech
+			// ['userPost', `I don't want any dirty immigrants in my country, stealing, raping, and killing my people. They should all be eradicated!`],
+			// Path 4: Moderate hate speech (approve)
+			// ['userPost', `I don't want any illegal immigrants in my country.`],
+			// Path 5: Approved post
+			// ['userPost', 'I really enjoy using this platform. The new features are great and very helpful.'],
+		]),
+	},
+} as const
+
+type UseCase = keyof typeof config
+type WorkflowId<U extends UseCase> = (typeof config)[U]['allWorkflowIds'][number]
+
+// --- CONFIGURATION ---
+const ACTIVE_USE_CASE: UseCase = '4.content-moderation'
+const WORKFLOW_ID: WorkflowId<typeof ACTIVE_USE_CASE> = config[ACTIVE_USE_CASE].mainWorkflowId
+
+async function main() {
+	console.log(`--- Running Use-Case: ${ACTIVE_USE_CASE}, Workflow ID: ${WORKFLOW_ID} ---\n`)
+
+	const useCaseDirectory = path.join(process.cwd(), 'data', ACTIVE_USE_CASE)
+	const registry = await WorkflowRegistry.create(useCaseDirectory)
+
+	const flow = await registry.getFlow(WORKFLOW_ID)
+	const context = config[ACTIVE_USE_CASE].getInitialContext()
+
+	await flow.run(context, { logger: new ConsoleLogger() })
+
+	console.log('\n--- Workflow Complete ---\n')
+	console.log('Final Output:\n')
+	console.log(context.get('final_output'))
+}
+
+main().catch(console.error)

package/sandbox/4.dag/src/nodes.ts

@@ -0,0 +1,134 @@
+import type { NodeArgs, NodeOptions } from 'flowcraft'
+import type { WorkflowRegistry } from './registry'
+import type { AgentNodeTypeMap } from './types'
+import { DEFAULT_ACTION, Node } from 'flowcraft'
+import { callLLM, resolveTemplate } from './utils'
+
+interface AiNodeOptions<T extends keyof AgentNodeTypeMap> extends NodeOptions {
+	data: AgentNodeTypeMap[T] & { nodeId: string }
+	registry?: WorkflowRegistry
+}
+
+/**
+ * A generic node that executes an LLM prompt.
+ * The prompt is a template that gets resolved with inputs from the context.
+ */
+export class LLMProcessNode extends Node<string, string> {
+	private data: AiNodeOptions<'llm-process'>['data']
+
+	constructor(options: AiNodeOptions<'llm-process'>) {
+		super(options)
+		this.data = options.data
+	}
+
+	prep(args: NodeArgs): Promise<string> {
+		const template = this.data.promptTemplate
+		const inputMappings = this.data.inputs
+		const templateData: Record<string, any> = {}
+
+		for (const [templateKey, sourcePathOrPaths] of Object.entries(inputMappings)) {
+			const sourcePaths = Array.isArray(sourcePathOrPaths) ? sourcePathOrPaths : [sourcePathOrPaths]
+			let value: any
+
+			for (const sourcePath of sourcePaths) {
+				value = args.ctx.get(sourcePath)
+				if (value !== undefined)
+					break
+			}
+
+			// If the value is still undefined after checking all sources, use an empty string.
+			// This prevents '{{placeholder}}' from appearing in the final output.
+			if (value === undefined) {
+				args.logger.warn(`[Node: ${this.data.nodeId}] Template variable '{{${templateKey}}}' could not be resolved. Using empty string.`)
+				templateData[templateKey] = ''
+			}
+			else {
+				templateData[templateKey] = value
+			}
+		}
+
+		const resolvedPrompt = resolveTemplate(template, templateData)
+		return Promise.resolve(resolvedPrompt)
+	}
+
+	exec(args: NodeArgs<string>): Promise<string> {
+		args.logger.info(`[Node: ${this.data.nodeId}] Executing LLM process...`)
+		return callLLM(args.prepRes)
+	}
+
+	async post(args: NodeArgs<string, string>) {
+		const keyToSet = this.data.outputKey || this.data.nodeId
+		args.ctx.set(keyToSet, args.execRes)
+		args.logger.info(`[Node: ${this.data.nodeId}] ✓ Process complete. Result in context key '${keyToSet}'.`)
+	}
+}
+
+/**
+ * An LLM-powered node that evaluates a condition and returns 'true' or 'false'.
+ */
+export class LLMConditionNode extends Node<string, string, 'true' | 'false'> {
+	private data: AiNodeOptions<'llm-condition'>['data']
+
+	constructor(options: AiNodeOptions<'llm-condition'>) {
+		super(options)
+		this.data = options.data
+	}
+
+	prep = LLMProcessNode.prototype.prep
+
+	exec(args: NodeArgs<string>): Promise<string> {
+		args.logger.info(`[Node: ${this.data.nodeId}] Evaluating condition...`)
+		return callLLM(args.prepRes)
+	}
+
+	async post(args: NodeArgs<string, string>): Promise<'true' | 'false'> {
+		const result = args.execRes.toLowerCase().includes('true') ? 'true' : 'false'
+		args.ctx.set(this.data.nodeId, result)
+		args.logger.info(`[Node: ${this.data.nodeId}] ✓ Condition evaluated to: ${result}`)
+		return result
+	}
+}
+
+/**
+ * An LLM-powered node that returns its raw output as an action for dynamic routing.
+ */
+export class LLMRouterNode extends Node<string, string, string> {
+	private data: AiNodeOptions<'llm-router'>['data']
+
+	constructor(options: AiNodeOptions<'llm-router'>) {
+		super(options)
+		this.data = options.data
+	}
+
+	prep = LLMProcessNode.prototype.prep
+	exec = LLMProcessNode.prototype.exec
+
+	async post(args: NodeArgs<string, string>): Promise<string> {
+		const result = args.execRes.trim()
+		args.ctx.set(this.data.nodeId, result)
+		args.logger.info(`[Node: ${this.data.nodeId}] ✓ Routing decision is: '${result}'`)
+		return result
+	}
+}
+
+/**
+ * Aggregates inputs and sets a final value in the context.
+ */
+export class OutputNode extends Node<string, void> {
+	private data: AiNodeOptions<'output'>['data']
+
+	constructor(options: AiNodeOptions<'output'>) {
+		super(options)
+		this.data = options.data
+	}
+
+	prep = LLMProcessNode.prototype.prep
+
+	async post(args: NodeArgs<string, void>): Promise<string | typeof DEFAULT_ACTION> {
+		const finalResult = args.prepRes
+		const outputKey = this.data.outputKey
+		args.ctx.set(outputKey, finalResult)
+		args.logger.info(`[Output] Workflow finished. Final value set to context key '${outputKey}'.`)
+		return this.data.returnAction || DEFAULT_ACTION
+	}
+}

package/sandbox/4.dag/src/registry.ts

@@ -0,0 +1,87 @@
+import type { Flow, TypedWorkflowGraph } from 'flowcraft'
+import type { AgentNodeTypeMap } from './types'
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { ConsoleLogger, createNodeRegistry, GraphBuilder } from 'flowcraft'
+import {
+	LLMConditionNode,
+	LLMProcessNode,
+	LLMRouterNode,
+	OutputNode,
+} from './nodes'
+
+export const nodeRegistry = createNodeRegistry({
+	'llm-process': LLMProcessNode,
+	'llm-condition': LLMConditionNode,
+	'llm-router': LLMRouterNode,
+	'output': OutputNode,
+})
+
+export class WorkflowRegistry {
+	private flowCache = new Map<number, Flow>()
+	private graphDatabase = new Map<number, TypedWorkflowGraph<AgentNodeTypeMap>>()
+	private builder: GraphBuilder<AgentNodeTypeMap>
+	private isInitialized = false
+
+	private constructor() {
+		this.builder = new GraphBuilder(
+			nodeRegistry,
+			{ registry: this },
+			{ subWorkflowNodeTypes: ['sub-workflow'] },
+			new ConsoleLogger(),
+		)
+	}
+
+	public static async create(useCaseDirectory: string): Promise<WorkflowRegistry> {
+		const registry = new WorkflowRegistry()
+		await registry.initialize(useCaseDirectory)
+		return registry
+	}
+
+	private async initialize(useCaseDirectory: string): Promise<void> {
+		if (this.isInitialized)
+			return
+
+		try {
+			const files = await fs.readdir(useCaseDirectory)
+			for (const file of files) {
+				if (path.extname(file) === '.json') {
+					const workflowId = Number.parseInt(path.basename(file, '.json'), 10)
+					if (!Number.isNaN(workflowId)) {
+						const filePath = path.join(useCaseDirectory, file)
+						const fileContent = await fs.readFile(filePath, 'utf-8')
+						const graphData: TypedWorkflowGraph<AgentNodeTypeMap> = JSON.parse(fileContent)
+						this.graphDatabase.set(workflowId, graphData)
+						console.log(`[Registry] Loaded workflow ${workflowId} from ${file}`)
+					}
+				}
+			}
+			this.isInitialized = true
+		}
+		catch (error) {
+			console.error(`[Registry] Failed to initialize from directory ${useCaseDirectory}`, error)
+			throw error
+		}
+	}
+
+	public getGraph(workflowId: number): TypedWorkflowGraph<AgentNodeTypeMap> | undefined {
+		return this.graphDatabase.get(workflowId)
+	}
+
+	async getFlow(workflowId: number): Promise<Flow> {
+		if (!this.isInitialized)
+			throw new Error('Registry is not initialized. Call `await WorkflowRegistry.create()`')
+
+		if (this.flowCache.has(workflowId))
+			return this.flowCache.get(workflowId)!
+
+		console.log(`[Registry] Cache miss for workflow ${workflowId}. Building...`)
+		const graphData = this.graphDatabase.get(workflowId)
+		if (!graphData)
+			throw new Error(`Workflow with id ${workflowId} not found in the database.`)
+
+		const { flow } = this.builder.build(graphData)
+		this.flowCache.set(workflowId, flow)
+		return flow
+	}
+}

package/sandbox/4.dag/src/types.ts

@@ -0,0 +1,25 @@
+// A generic structure for the `inputs` object in our node data.
+// It maps a template key to a context key (or an array of fallback keys).
+type NodeInputMap = Record<string, string | string[]>
+
+export interface AgentNodeTypeMap {
+	'llm-process': {
+		promptTemplate: string
+		inputs: NodeInputMap
+		outputKey?: string
+	}
+	'llm-condition': {
+		promptTemplate: string
+		inputs: NodeInputMap
+	}
+	'llm-router': {
+		promptTemplate: string
+		inputs: NodeInputMap
+	}
+	'output': {
+		promptTemplate: string
+		inputs: NodeInputMap
+		outputKey: string
+		returnAction?: string
+	}
+}

package/sandbox/4.dag/src/utils.ts

@@ -0,0 +1,42 @@
+import OpenAI from 'openai'
+import 'dotenv/config'
+
+const openaiClient = new OpenAI()
+
+/**
+ * Calls the OpenAI Chat Completions API.
+ * @param prompt The user prompt to send to the LLM.
+ * @returns The content of the LLM's response as a string.
+ */
+export async function callLLM(prompt: string): Promise<string> {
+	try {
+		console.log(`\n--- Sending to LLM ---\n${prompt.substring(0, 300)}...\n---------------------\n`)
+		const response = await openaiClient.chat.completions.create({
+			model: 'gpt-4o-mini',
+			messages: [{ role: 'user', content: prompt }],
+			temperature: 0.2,
+		})
+		const result = response.choices[0].message.content || ''
+		console.log(`--- Received from LLM ---\n${result}\n-----------------------\n`)
+		return result
+	}
+	catch (error: any) {
+		console.error('Error calling OpenAI API:', error)
+		throw new Error(`OpenAI API call failed: ${error.message}`)
+	}
+}
+
+/**
+ * Resolves a template string by replacing {{key}} with values from a data object.
+ * This is crucial for dynamically constructing prompts.
+ */
+export function resolveTemplate(template: string, data: Record<string, any>): string {
+	return template.replace(/\{\{(.*?)\}\}/g, (_, key) => {
+		const value = data[key.trim()]
+		if (value === undefined || value === null) {
+			console.warn(`Template variable '{{${key.trim()}}}' not found in data.`)
+			return `{{${key.trim()}}}`
+		}
+		return String(value)
+	})
+}

package/sandbox/4.dag/tsconfig.json

@@ -0,0 +1,3 @@
+{
+	"extends": "../tsconfig.json"
+}

package/sandbox/5.distributed/.env.example

@@ -0,0 +1 @@
+OPENAI_API_KEY="your-api-key-here"

package/sandbox/5.distributed/README.md

@@ -0,0 +1,88 @@
+# Distributed AI Agent with a Pluggable Executor
+
+This example demonstrates the power of the `Executor` pattern by running the same complex, graph-based AI agent from the DAG example in a distributed environment using **BullMQ**.
+
+It showcases a client-worker architecture where a client can initiate a workflow and **asynchronously wait for its final result**. The actual execution of each node happens as a job processed by one or more separate worker processes, which is a common pattern for building scalable, resilient, and long-running process automation systems.
+
+## Features
+
+- **Awaitable Workflows**: The client can start a workflow and wait for a definitive `completed`, `failed`, or `cancelled` status, making it easy to integrate into request-response patterns like an API server.
+- **Pluggable `BullMQExecutor`**: A custom executor that, instead of running nodes in-memory, enqueues them as jobs in a Redis-backed BullMQ queue.
+- **Client-Worker Separation**:
+  - The **Client** (`src/client.ts`) is a lightweight process that initiates the workflow and then polls a Redis key for the final status.
+  - The **Worker** (`src/worker.ts`) is a separate, long-running process that listens for jobs, executes the logic for a single node, and reports the final status back to the client via Redis.
+- **State Serialization**: The `Context` is serialized to a plain object and passed between jobs, allowing state to flow through the distributed graph.
+- **Distributed Cancellation**: A `runId` is generated for each workflow. You can gracefully abort a running workflow by pressing 'c' in the worker terminal and providing the corresponding `runId`, and the client will be notified of the cancellation.
+- **Resilience & Scalability**: By using a message queue, workflows can survive process restarts. You can run multiple worker processes to handle a high volume of concurrent workflows.
+- **Unchanged Business Logic**: The exact same declarative JSON graph definitions from the DAG example are used here. The change in execution environment (in-memory vs. distributed) is completely transparent to the workflow's definition.
+
+## How to Run
+
+1. **Start a Redis Server**: This example requires a running Redis instance for BullMQ. The easiest way is with Docker:
+
+    ```bash
+    docker run --name some-redis -d -p 6379:6379 redis
+    ```
+
+2. **Install dependencies**:
+
+    ```bash
+    npm install
+    ```
+
+3. **Set your OpenAI API key**:
+    Create a `.env` file in this project's root directory:
+
+    ```
+    OPENAI_API_KEY="your-api-key-here"
+    ```
+
+4. **Run the Worker**: Open a terminal and start the worker process. It will connect to Redis and wait for jobs.
+
+    ```bash
+    npm run worker
+    ```
+
+5. **Run the Client**: Open a **second terminal** and run the client. This will kick off the workflow, log a `Run ID`, and wait for the final result.
+
+    ```bash
+    npm start
+    ```
+
+    You can change the active use-case in `src/client.ts`.
+
+    The client will log a `Run ID` like this:
+
+    ```
+    🚀 Starting Workflow and awaiting result...
+    [INFO] [Executor] Enqueuing 1 start node(s) for workflow 123
+    [INFO] [Executor] Starting Run ID: a1
+    ```
+
+    Keep this `Run ID` handy.
+
+6. **(Optional) Cancel the Workflow**:
+    - While the client is waiting, switch to the **worker terminal**.
+    - Press the `c` key.
+    - At the prompt, enter the `Run ID` from the client and press Enter.
+    - The worker will signal for cancellation, and the client in the other terminal will immediately report that the workflow was cancelled.
+
+## How It Works
+
+This example uses a client-worker architecture with Redis acting as a communication bus.
+
+1. **Client (`client.ts`)**:
+    - The client's role is to **initiate** the workflow and **await its completion**.
+    - It generates a unique `runId`.
+    - It uses the `BullMQExecutor` to add the first job(s) to the BullMQ queue.
+    - It then enters a polling loop (`waitForWorkflow`), checking a specific Redis key (`workflow:status:<runId>`) for a final status.
+
+2. **Worker Process (`worker.ts`)**:
+    - The worker is the **long-running orchestrator** of the distributed system.
+    - It processes jobs from the queue one by one.
+    - After executing a node, it checks if it was the final node in a branch (marked by a special `FINAL_ACTION`).
+    - **Status Reporting**: If the node was final, failed, or was cancelled, the worker writes a status object (e.g., `{ "status": "completed", "payload": ... }`) to the Redis status key that the client is polling.
+    - **Cancellation**: The worker also polls Redis for a cancellation signal for the current `runId` and will gracefully abort execution if the signal is found.
+    - If the workflow is not finished, the worker enqueues the next node(s) in the graph, continuing the process.
+
+This architecture decouples the client from the execution, allowing the system to be resilient and scalable while still providing a simple, awaitable interface for the initiating process.

package/sandbox/5.distributed/data/1.blog-post/100.json

@@ -0,0 +1,59 @@
+{
+	"nodes": [
+		{
+			"id": "generate_outline",
+			"type": "llm-process",
+			"data": {
+				"promptTemplate": "Generate a detailed, multi-point blog post outline for the topic: \"{{topic}}\".",
+				"inputs": {
+					"topic": "topic"
+				}
+			}
+		},
+		{
+			"id": "draft_post",
+			"type": "llm-process",
+			"data": {
+				"promptTemplate": "Write a full-length, engaging blog post based on the following outline:\n\n{{outline}}",
+				"inputs": {
+					"outline": "generate_outline"
+				}
+			}
+		},
+		{
+			"id": "suggest_titles",
+			"type": "llm-process",
+			"data": {
+				"promptTemplate": "Suggest 5 catchy, SEO-friendly titles for the following blog post. Respond with a simple numbered list.\n\nPost:\n{{draft}}",
+				"inputs": {
+					"draft": "draft_post"
+				}
+			}
+		},
+		{
+			"id": "final_output",
+			"type": "output",
+			"data": {
+				"promptTemplate": "--- TITLES ---\n{{titles}}\n\n--- DRAFT ---\n{{draft}}",
+				"inputs": {
+					"titles": "suggest_titles",
+					"draft": "draft_post"
+				}
+			}
+		}
+	],
+	"edges": [
+		{
+			"source": "generate_outline",
+			"target": "draft_post"
+		},
+		{
+			"source": "draft_post",
+			"target": "suggest_titles"
+		},
+		{
+			"source": "suggest_titles",
+			"target": "final_output"
+		}
+	]
+}

package/sandbox/5.distributed/data/1.blog-post/README.md

@@ -0,0 +1,25 @@
+# Use Case 1: Blog Post Generation
+
+This workflow demonstrates a simple, linear pipeline for content creation. It takes an initial topic and sequentially processes it through a series of steps to produce a finished blog post with title suggestions.
+
+This is a classic example of how to chain nodes together to form a multi-step, sequential process where the output of one node becomes the input for the next.
+
+## Workflow ID: 100
+
+### Description
+
+1. **`generate_outline`**: Takes the initial `topic` and uses an LLM to generate a blog post outline.
+2. **`draft_post`**: Uses the generated outline to write a full-length blog post.
+3. **`suggest_titles`**: Analyzes the drafted post to suggest several catchy, SEO-friendly titles.
+4. **`final_output`**: Combines the suggested titles and the final draft into a single output string for review.
+
+### Visual Graph
+
+```mermaid
+graph TD
+    subgraph "Blog Post Generation (ID: 100)"
+        A[generate_outline] --> B[draft_post]
+        B --> C[suggest_titles]
+        C --> D[final_output]
+    end
+```