fix: fix thinking blocks in the messages

Author: gitsad

demo/src/validator-prompts.ts

@@ -41,7 +41,7 @@ export const VALIDATOR_PROMPT_VARIANTS: ValidatorPromptVariant[] = [
     key: 'structure',
     label: 'Structure & YAML',
     description: 'YAML correctness, duplicate IDs, ID format, schema conformance',
-    rules: ['yaml-correctness', 'schema-conformance', 'duplicate-ids', 'id-format'],
+    rules: ['yaml-correctness', 'schema-conformance', 'duplicate-ids', 'id-format', 'thinking-block'],
     prompt: `${PREAMBLE}
 
 Focus ONLY on structural and YAML issues. Generate an event registration system with these exact components, each with intentional structural problems:
@@ -94,7 +94,7 @@ IMPORTANT: Only generate \`\`\`mdma blocks when explicitly asked or on the first
     key: 'bindings',
     label: 'Bindings & References',
     description: 'Binding syntax, resolution, deep field validation, action references',
-    rules: ['binding-syntax', 'binding-resolution', 'action-references'],
+    rules: ['binding-syntax', 'binding-resolution', 'action-references', 'thinking-block'],
     prompt: `${PREAMBLE}
 
 Focus ONLY on binding and reference issues. Generate a contact submission workflow with these exact components, each with intentional binding/reference problems:
@@ -146,7 +146,7 @@ IMPORTANT: Only generate \`\`\`mdma blocks when explicitly asked or on the first
     key: 'pii',
     label: 'PII & Sensitive Data',
     description: 'Sensitive flags, required markers',
-    rules: ['sensitive-flags', 'required-markers'],
+    rules: ['sensitive-flags', 'required-markers', 'thinking-block'],
     prompt: `${PREAMBLE}
 
 Focus ONLY on PII and data sensitivity issues. Generate a KYC (Know Your Customer) verification form with these exact components, each missing sensitive/required flags:
@@ -192,7 +192,7 @@ IMPORTANT: Only generate \`\`\`mdma blocks when explicitly asked or on the first
     key: 'forms',
     label: 'Form Validation',
     description: 'Select options, field name typos, placeholder content, expected components',
-    rules: ['select-options', 'field-name-typos', 'placeholder-content', 'expected-components'],
+    rules: ['select-options', 'field-name-typos', 'placeholder-content', 'expected-components', 'thinking-block'],
     prompt: `${PREAMBLE}
 
 Focus ONLY on form-specific issues. Generate a single job application form with intentional problems:
@@ -232,7 +232,7 @@ IMPORTANT: Only generate \`\`\`mdma blocks when explicitly asked or on the first
     key: 'tables-charts',
     label: 'Tables & Charts',
     description: 'Table data keys, chart axis validation',
-    rules: ['table-data-keys', 'chart-validation'],
+    rules: ['table-data-keys', 'chart-validation', 'thinking-block'],
     prompt: `${PREAMBLE}
 
 Focus ONLY on table and chart data issues. Generate a sales dashboard with these exact components, each with intentional problems:
@@ -262,8 +262,8 @@ Generate all 4 components with the intentional mismatches described above.`,
   {
     key: 'flow',
     label: 'Stepper Flow',
-    description: 'Flow ordering, unreferenced components, action targets, expected components',
-    rules: ['flow-ordering', 'unreferenced-components', 'action-references', 'expected-components'],
+    description: 'Flow ordering, thinking block, action targets, expected components',
+    rules: ['flow-ordering', 'thinking-block', 'action-references', 'expected-components'],
     prompt: `${PREAMBLE}
 
 Focus ONLY on component flow and reference issues. Generate a user registration and approval workflow with ALL of these intentional problems:
@@ -307,7 +307,7 @@ IMPORTANT: Only generate \`\`\`mdma blocks when explicitly asked to generate a s
     key: 'approval',
     label: 'Approval & Webhooks',
     description: 'Field name typos on approval-gate, action references on webhooks',
-    rules: ['field-name-typos', 'action-references', 'schema-conformance'],
+    rules: ['field-name-typos', 'action-references', 'schema-conformance', 'thinking-block'],
     prompt: `${PREAMBLE}
 
 Focus ONLY on approval gate and webhook issues. Generate an expense approval workflow with these exact components, each with intentional problems:
@@ -611,21 +611,31 @@ export const SAMPLE_TABLE_DATA: Record<string, Record<string, Array<Record<strin
  */
 export const FLOW_EXPECTED_COMPONENTS: Record<string, Record<string, ExpectedComponent>[]> = {
   flow: [
-    // Step 1: Registration form
+    // Step 1: Registration form + success callout
     {
       'registration-form': {
         type: 'form',
         fields: ['full-name', 'email', 'department'],
+        actions: { onSubmit: 'registration-submitted' },
       },
+      'registration-submitted': { type: 'callout' },
     },
-    // Step 2: Approval gate
+    // Step 2: Approval gate + success callout
     {
-      'approval-gate': { type: 'approval-gate' },
+      'approval-gate': {
+        type: 'approval-gate',
+        actions: { onApprove: 'approval-complete' },
+      },
+      'approval-complete': { type: 'callout' },
     },
-    // Step 3: Webhook + button
+    // Step 3: Webhook + button + success callout
     {
-      'notify-webhook': { type: 'webhook' },
+      'notify-webhook': {
+        type: 'webhook',
+        actions: { trigger: 'send-notification' },
+      },
       'send-notification': { type: 'button' },
+      'workflow-complete': { type: 'callout' },
     },
   ],
 };

packages/validator/src/fixes/index.ts

@@ -5,6 +5,7 @@ import { fixBindingSyntax } from './binding-syntax.js';
 import { fixSensitiveFlags } from './sensitive-flags.js';
 import { fixSchemaDefaults } from './schema-defaults.js';
 import { fixActionReferences } from './action-references.js';
+import { fixThinkingBlock } from './thinking-block.js';
 
 /** Maps rule IDs to their fix functions. Rules without fixes are absent. */
 export const FIX_REGISTRY: Partial<Record<ValidationRuleId, FixFunction>> = {
@@ -14,20 +15,22 @@ export const FIX_REGISTRY: Partial<Record<ValidationRuleId, FixFunction>> = {
   'sensitive-flags': fixSensitiveFlags,
   'action-references': fixActionReferences,
   'schema-conformance': fixSchemaDefaults,
+  'thinking-block': fixThinkingBlock,
 };
 
 /**
  * Ordered list of fixes to apply.
  *
- * 1. id-format first (ID changes affect cross-references)
- * 2. duplicate-ids second (dedup after format normalization)
- * 3. binding-syntax third
- * 4. sensitive-flags fourth
- * 5. action-references fifth (remove invalid refs before schema check)
- * 6. schema-conformance sixth (re-validates after all fixes, applies Zod defaults)
- * 7. reference-conformance last (applies reference template corrections)
+ * 1. thinking-block first (merge + reorder before any other fixes)
+ * 2. id-format (ID changes affect cross-references)
+ * 3. duplicate-ids (dedup after format normalization)
+ * 4. binding-syntax
+ * 5. sensitive-flags
+ * 6. action-references (remove invalid refs before schema check)
+ * 7. schema-conformance last (re-validates after all fixes, applies Zod defaults)
  */
 export const FIX_ORDER: ValidationRuleId[] = [
+  'thinking-block',
   'id-format',
   'duplicate-ids',
   'binding-syntax',

packages/validator/src/fixes/thinking-block.ts

@@ -0,0 +1,55 @@
+import type { FixContext } from '../types.js';
+
+/**
+ * Merge multiple thinking blocks into a single one at the top of the document.
+ * Concatenates content from all thinking blocks, keeps the first one's metadata,
+ * and removes the extras.
+ */
+export function fixThinkingBlock(context: FixContext): void {
+  const thinkingIndices: number[] = [];
+  for (let i = 0; i < context.blocks.length; i++) {
+    if (context.blocks[i].data?.type === 'thinking') {
+      thinkingIndices.push(i);
+    }
+  }
+
+  if (thinkingIndices.length < 2) return;
+
+  // Merge all thinking content into the first block
+  const firstBlock = context.blocks[thinkingIndices[0]];
+  if (!firstBlock.data) return;
+
+  const mergedContent: string[] = [];
+  for (const idx of thinkingIndices) {
+    const block = context.blocks[idx];
+    if (block.data && typeof block.data.content === 'string') {
+      mergedContent.push(block.data.content.trim());
+    }
+  }
+  firstBlock.data.content = mergedContent.join('\n\n');
+  firstBlock.data.status = 'done';
+  firstBlock.data.collapsed = true;
+
+  // Remove extra thinking blocks (iterate in reverse to preserve indices)
+  for (let i = thinkingIndices.length - 1; i >= 1; i--) {
+    const idx = thinkingIndices[i];
+    context.blocks[idx].data = null;
+  }
+
+  // Move the merged thinking block to the top if it's not already first
+  const firstParsedIdx = context.blocks.findIndex((b) => b.data !== null);
+  if (firstParsedIdx !== thinkingIndices[0] && firstParsedIdx >= 0) {
+    // Swap: put thinking block data into the first parsed block position
+    const thinkingData = firstBlock.data;
+    const targetBlock = context.blocks[firstParsedIdx];
+    firstBlock.data = targetBlock.data;
+    targetBlock.data = thinkingData;
+  }
+
+  // Mark thinking-block issues as fixed
+  for (const issue of context.issues) {
+    if (issue.ruleId === 'thinking-block' && !issue.fixed) {
+      issue.fixed = true;
+    }
+  }
+}

packages/validator/tests/fixes/thinking-block.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { fixThinkingBlock } from '../../src/fixes/thinking-block.js';
+import type { FixContext, ParsedBlock, ValidationIssue } from '../../src/types.js';
+
+function createBlock(index: number, data: Record<string, unknown> | null): ParsedBlock {
+  return {
+    index,
+    rawYaml: '',
+    data,
+    startOffset: index * 100,
+    endOffset: index * 100 + 50,
+    yamlStartOffset: index * 100 + 10,
+    yamlEndOffset: index * 100 + 45,
+  };
+}
+
+function createFixContext(blocks: ParsedBlock[], issues: ValidationIssue[] = []): FixContext {
+  const idMap = new Map<string, number>();
+  for (const block of blocks) {
+    if (block.data && typeof block.data.id === 'string') {
+      idMap.set(block.data.id, block.index);
+    }
+  }
+  return { blocks, idMap, issues, options: {} };
+}
+
+describe('fixThinkingBlock', () => {
+  it('does nothing with a single thinking block', () => {
+    const ctx = createFixContext([
+      createBlock(0, { type: 'thinking', id: 't1', content: 'Reasoning...', status: 'done', collapsed: true }),
+      createBlock(1, { type: 'form', id: 'f1', fields: [] }),
+    ]);
+    fixThinkingBlock(ctx);
+    const thinkingBlocks = ctx.blocks.filter((b) => b.data?.type === 'thinking');
+    expect(thinkingBlocks).toHaveLength(1);
+    expect(thinkingBlocks[0].data?.content).toBe('Reasoning...');
+  });
+
+  it('merges two thinking blocks into one', () => {
+    const ctx = createFixContext([
+      createBlock(0, { type: 'thinking', id: 't1', content: 'First reasoning', status: 'done', collapsed: true }),
+      createBlock(1, { type: 'form', id: 'f1', fields: [] }),
+      createBlock(2, { type: 'thinking', id: 't2', content: 'Second reasoning', status: 'done', collapsed: true }),
+    ]);
+    fixThinkingBlock(ctx);
+    const thinkingBlocks = ctx.blocks.filter((b) => b.data?.type === 'thinking');
+    expect(thinkingBlocks).toHaveLength(1);
+    expect(thinkingBlocks[0].data?.content).toBe('First reasoning\n\nSecond reasoning');
+  });
+
+  it('merges three thinking blocks into one', () => {
+    const ctx = createFixContext([
+      createBlock(0, { type: 'thinking', id: 't1', content: 'A', status: 'done', collapsed: true }),
+      createBlock(1, { type: 'thinking', id: 't2', content: 'B', status: 'done', collapsed: true }),
+      createBlock(2, { type: 'thinking', id: 't3', content: 'C', status: 'done', collapsed: true }),
+    ]);
+    fixThinkingBlock(ctx);
+    const thinkingBlocks = ctx.blocks.filter((b) => b.data?.type === 'thinking');
+    expect(thinkingBlocks).toHaveLength(1);
+    expect(thinkingBlocks[0].data?.content).toBe('A\n\nB\n\nC');
+  });
+
+  it('moves merged thinking block to the top', () => {
+    const ctx = createFixContext([
+      createBlock(0, { type: 'form', id: 'f1', fields: [] }),
+      createBlock(1, { type: 'thinking', id: 't1', content: 'First', status: 'done', collapsed: true }),
+      createBlock(2, { type: 'thinking', id: 't2', content: 'Second', status: 'done', collapsed: true }),
+    ]);
+    fixThinkingBlock(ctx);
+    // First parsed block should now be thinking
+    const firstParsed = ctx.blocks.find((b) => b.data !== null);
+    expect(firstParsed?.data?.type).toBe('thinking');
+    expect(firstParsed?.data?.content).toBe('First\n\nSecond');
+  });
+
+  it('marks thinking-block issues as fixed', () => {
+    const issues: ValidationIssue[] = [
+      {
+        ruleId: 'thinking-block',
+        severity: 'warning',
+        message: 'Duplicate thinking block "t2"',
+        componentId: 't2',
+        blockIndex: 2,
+        fixed: false,
+      },
+    ];
+    const ctx = createFixContext(
+      [
+        createBlock(0, { type: 'thinking', id: 't1', content: 'A', status: 'done', collapsed: true }),
+        createBlock(1, { type: 'form', id: 'f1', fields: [] }),
+        createBlock(2, { type: 'thinking', id: 't2', content: 'B', status: 'done', collapsed: true }),
+      ],
+      issues,
+    );
+    fixThinkingBlock(ctx);
+    expect(issues[0].fixed).toBe(true);
+  });
+});