@far-world-labs/verblets 0.1.4 → 0.2.0

package/.github/workflows/ci.yml

@@ -72,50 +72,11 @@ jobs:
           echo "✅ ESLint checks completed"
           echo "✅ Library is ready for deployment"
 
-  # Version bump for PRs - creates commit in PR branch
-  version-bump:
-    name: 📦 Version Bump
-    runs-on: ubuntu-latest
-    needs: build
-    if: github.event_name == 'pull_request'
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-          ref: ${{ github.head_ref }}
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20.x
-          cache: 'npm'
-      - run: npm ci
-      
-      - name: Configure Git
-        run: |
-          git config --global user.name "github-actions[bot]"
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
-      
-      - name: Version Bump (No Publish)
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          # Ensure we're on the correct branch
-          git checkout ${{ github.head_ref }}
-          
-          # Use release-it to bump version and create tag, but skip npm publish
-          npx release-it --ci --no-npm.publish --no-github.release
-          
-          # Push the version bump back to the PR branch
-          git push origin ${{ github.head_ref }}
-
   # Required status check that gates merge operations
   pr-ready-to-merge:
     name: ✅ PR Ready to Merge
     runs-on: ubuntu-latest
-    needs: [lint, test, build, version-bump]
+    needs: [lint, test, build]
     if: github.event_name == 'pull_request'
     steps:
       - name: All checks passed
@@ -124,11 +85,11 @@ jobs:
           echo "✅ Linting: Passed"
           echo "✅ Tests: Passed on all LTS Node versions"
           echo "✅ Build: Successful"
-          echo "✅ Version: Bumped and ready"
+          echo "ℹ️ Version: Will be checked on merge (publish only if bumped)"
           echo ""
           echo "This PR is now ready for squash and merge."
 
-  # Publish the already-bumped version on merge to main
+  # Publish to NPM and create git tag - only if version was bumped
   release:
     name: 🚀 Publish to NPM
     runs-on: ubuntu-latest
@@ -149,14 +110,42 @@ jobs:
           cache: 'npm'
       - run: npm ci
       
+      - name: Check if version was bumped
+        id: version-check
+        run: |
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+          PUBLISHED_VERSION=$(npm view @far-world-labs/verblets version 2>/dev/null || echo "0.0.0")
+          
+          echo "📦 Current version in package.json: $CURRENT_VERSION"
+          echo "📦 Published version on npm: $PUBLISHED_VERSION"
+          
+          if [ "$CURRENT_VERSION" = "$PUBLISHED_VERSION" ]; then
+            echo "should-publish=false" >> $GITHUB_OUTPUT
+            echo "ℹ️ No version bump detected - skipping publish"
+          else
+            echo "should-publish=true" >> $GITHUB_OUTPUT
+            echo "✅ Version bump detected: $PUBLISHED_VERSION → $CURRENT_VERSION - will publish"
+          fi
+      
+      - name: Create Git Tag
+        if: steps.version-check.outputs.should-publish == 'true'
+        run: |
+          VERSION=$(node -p "require('./package.json').version")
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git tag -a "v$VERSION" -m "Release v$VERSION"
+          git push origin "v$VERSION"
+      
       - name: Publish to NPM
+        if: steps.version-check.outputs.should-publish == 'true'
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
         run: |
-          # Simple publish - version is already bumped in package.json from PR
+          # Version was manually bumped and validated in PR
           npm publish --access public
           
       - name: Create GitHub Release
+        if: steps.version-check.outputs.should-publish == 'true'
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
@@ -168,3 +157,9 @@ jobs:
             --title "Release v$VERSION" \
             --notes "Automated release of version $VERSION" \
             --latest
+      
+      - name: Skip publish
+        if: steps.version-check.outputs.should-publish == 'false'
+        run: |
+          echo "ℹ️ No version bump detected - publish skipped"
+          echo "This merge completed without triggering a release"

package/.vitest.config.examples.js

@@ -1,4 +1,8 @@
 import { configDefaults, defineConfig } from 'vitest/config'
+import dotenv from 'dotenv'
+
+// Load environment variables from .env file
+dotenv.config()
 
 export default defineConfig({
   test: {

package/DEVELOPING.md

@@ -54,7 +54,7 @@ npm run examples
 ### Cache Behavior
 - **Cache Hit**: Returns cached response instantly
 - **Cache Miss**: Makes LLM API call and caches the response
-- **TTL**: Cached responses expire based on `cacheTTL` configuration
+- **TTL**: Cached responses expire after 365 days (configurable via `CHATGPT_CACHE_TTL`)
 - **Fallback**: Gracefully handles Redis connection failures
 
 ## Development Workflow

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@far-world-labs/verblets",
-  "version": "0.1.4",
-  "description": "OpenAI Client",
+  "version": "0.2.0",
+  "description": "Verblets is a collection of tools for building LLM-powered applications.",
   "main": "src/index.js",
   "type": "module",
   "repository": {
@@ -15,20 +15,20 @@
     "--": "npm run script -- generate-verblet foo",
     "script": "./scripts/run.sh",
     "test": "vitest",
+    "clear-test-cache": "node scripts/clear-redis.js",
     "examples:warn": "source .env && LLM_EXPECT_MODE=info EXAMPLES=true vitest --config .vitest.config.examples.js",
-    "examples": "source .env && LLM_EXPECT_MODE=error EXAMPLES=true vitest --config .vitest.config.examples.js",
+    "examples": "source .env && LLM_EXPECT_MODE=error EXAMPLES=true ENABLE_LONG_EXAMPLES=false vitest --config .vitest.config.examples.js",
+    "examples:all": "source .env && LLM_EXPECT_MODE=error EXAMPLES=true ENABLE_LONG_EXAMPLES=true vitest --config .vitest.config.examples.js",
+    "examples:fresh": "npm run clear-test-cache && npm run examples:all",
     "lint": "eslint 'src/**/*.{js,jsx}'",
     "lint:fix": "eslint 'src/**/*.{js,jsx}' --fix",
     "check:deps": "npx npm-deprecated-check current",
     "husky:install": "husky install",
     "husky:uninstall": "husky uninstall",
     "prepare": "npx husky install",
-    "version:patch": "node scripts/version-bump.js patch",
-    "version:minor": "node scripts/version-bump.js minor",
-    "version:major": "node scripts/version-bump.js major",
-    "release:patch": "node scripts/version-bump.js patch",
-    "release:minor": "node scripts/version-bump.js minor",
-    "release:major": "node scripts/version-bump.js major"
+    "version:patch": "npm version patch",
+    "version:minor": "npm version minor",
+    "version:major": "npm version major"
   },
   "config": {
     "gen-script": "./scripts/run.sh gen-$1"

package/scripts/clear-redis.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import { getClient as getRedis } from '../src/services/redis/index.js';
+
+async function clearRedisKeys() {
+  let redis = null;
+  
+  try {
+    console.log('🔄 Connecting to Redis...');
+    redis = await getRedis();
+    
+    // Check if this is the NullRedisClient (in-memory fallback)
+    if (redis.store !== undefined) {
+      // This is the in-memory client
+      const keyCount = Object.keys(redis.store).length;
+      if (keyCount === 0) {
+        console.log('✅ In-memory cache is already empty - no keys to clear');
+        return;
+      }
+      
+      console.log(`🗑️  Found ${keyCount} keys in in-memory cache to clear`);
+      redis.store = {};
+      console.log(`✅ Successfully cleared ${keyCount} in-memory cache keys`);
+      console.log('🧹 In-memory cache has been cleared - tests can now run with fresh responses');
+      return;
+    }
+    
+    // This is the SafeRedisClient wrapper - access underlying Redis client
+    const underlyingClient = redis.redisClient;
+    if (!underlyingClient) {
+      console.log('⚠️  No underlying Redis client found - using fallback method');
+      return;
+    }
+    
+    // Get count of keys before clearing
+    const keys = await underlyingClient.keys('*');
+    const keyCount = keys.length;
+    
+    if (keyCount === 0) {
+      console.log('✅ Redis is already empty - no keys to clear');
+      return;
+    }
+    
+    console.log(`🗑️  Found ${keyCount} keys to clear`);
+    
+    // Use FLUSHDB to clear all keys in the current database
+    // This is more efficient and reliable than deleting individual keys
+    await underlyingClient.flushDb();
+    
+    console.log(`✅ Successfully cleared all ${keyCount} Redis keys`);
+    console.log('🧹 Redis cache has been cleared - tests can now run with fresh responses');
+    
+  } catch (error) {
+    if (error.message.includes('ECONNREFUSED') || error.message.includes('connection')) {
+      console.log('⚠️  Redis is not running or not accessible - nothing to clear');
+      console.log('   This is normal if you\'re using the in-memory cache fallback');
+    } else {
+      console.error('❌ Error clearing Redis keys:', error.message);
+      process.exit(1);
+    }
+  } finally {
+    if (redis && typeof redis.disconnect === 'function') {
+      try {
+        await redis.disconnect();
+        console.log('🔌 Disconnected from Redis');
+      } catch (disconnectError) {
+        // Ignore disconnect errors
+      }
+    }
+  }
+}
+
+// Run the script
+clearRedisKeys(); 

package/src/chains/conversation/README.md

@@ -0,0 +1,26 @@
+# Conversation
+
+A flexible engine that produces multi-speaker transcripts on demand. Provide a list of speakers and conversation rules. The chain manages turn taking, facilitator remarks, and closing summaries.
+
+```javascript
+import Conversation from './src/chains/conversation/index.js';
+
+const speakers = [
+  { id: 'fac', role: 'facilitator', bio: 'organizes community events' },
+  { id: 'max', bio: 'local baker' },
+  { id: 'lily', bio: 'youth soccer coach' },
+];
+
+const chain = new Conversation('neighborhood picnic', speakers, {
+  rules: { shouldContinue: (round) => round < 2 },
+});
+const transcript = await chain.run();
+console.log(transcript);
+```
+
+Each message in the transcript has the shape `{ id, name, comment, time }` where
+`time` is in `HH:MM` format.
+
+The conversation engine uses `conversation-turn-multi` and `conversation-turn` verblets internally to generate contextual responses. You can supply custom `bulkSpeakFn` and `speakFn` implementations for specialized conversation behaviors.
+
+Perfect for simulating realistic discussions, focus groups, team meetings, or any multi-participant dialogue where each speaker brings their unique perspective and expertise to the conversation.

package/src/chains/conversation/index.examples.js

@@ -0,0 +1,398 @@
+import { describe, it, expect } from 'vitest';
+import ConversationChain from './index.js';
+import { expect as aiExpected } from '../expect/index.js';
+import { longTestTimeout, shouldRunLongExamples } from '../../constants/common.js';
+import { roundRobin } from './turn-policies.js';
+
+describe('conversation chain examples', () => {
+  it.skipIf(!shouldRunLongExamples)(
+    'generates a debate on consciousness emergence in AI systems - a current open question',
+    async () => {
+      const speakers = [
+        {
+          id: 'turing',
+          name: 'Alan Turing',
+          bio: 'Father of computer science and artificial intelligence, creator of the Turing Test',
+          agenda:
+            'Argue that consciousness is fundamentally about behavior and computational processes, not substrate',
+        },
+        {
+          id: 'minsky',
+          name: 'Marvin Minsky',
+          bio: 'Co-founder of MIT AI Lab, pioneer in artificial intelligence and cognitive science',
+          agenda:
+            'Advocate that consciousness emerges from the interaction of simple, unconscious agents in a society of mind',
+        },
+        {
+          id: 'hinton',
+          name: 'Geoffrey Hinton',
+          bio: 'Godfather of deep learning, pioneer in neural networks and backpropagation',
+          agenda:
+            'Argue that consciousness could emerge from sufficiently complex neural networks through self-organizing principles',
+        },
+      ];
+
+      const topic =
+        'The Hard Problem of Machine Consciousness: Will AI systems develop genuine subjective experience?';
+
+      // Hook: Pre-conversation setup
+      expect(speakers.length).toBe(3);
+      expect(topic.toLowerCase()).toContain('consciousness');
+      // BREAKPOINT: Set breakpoint here to inspect speakers and topic
+
+      const shouldContinueWithHook = (round, _messages) => {
+        // Hook: Simple round tracking
+        // BREAKPOINT: Set breakpoint here to see round progression and messages
+        expect(round).toBeGreaterThanOrEqual(0);
+        return round < 3; // 3 rounds to ensure all speakers participate
+      };
+
+      const chain = new ConversationChain(topic, speakers, {
+        rules: {
+          shouldContinue: shouldContinueWithHook,
+          turnPolicy: roundRobin(speakers), // Use deterministic round-robin to ensure all speakers participate
+          customPrompt:
+            "This is a deep philosophical and scientific discussion. Draw on your expertise and engage with others' arguments. Be intellectually rigorous but concise.",
+        },
+      });
+
+      // Hook: Pre-run validation
+      expect(chain.speakers.length).toBe(3);
+      // BREAKPOINT: Set breakpoint here before conversation starts
+
+      const messages = await chain.run();
+
+      // Hook: Post-run analysis
+      // BREAKPOINT: Set breakpoint here to examine completed conversation
+      expect(messages.length).toBeGreaterThan(2); // At least 3 messages (one per speaker)
+
+      // Hook: Final participation check
+      const speakerIds = new Set(messages.map((m) => m.id));
+      expect(speakerIds.size).toBe(3);
+      // BREAKPOINT: Set breakpoint here for final analysis
+
+      // Basic validation
+      expect(Array.isArray(messages)).toBe(true);
+
+      // Hook: Speaker participation analysis
+      expect(speakerIds.has('turing')).toBe(true);
+      expect(speakerIds.has('minsky')).toBe(true);
+      expect(speakerIds.has('hinton')).toBe(true);
+
+      // Messages should have proper structure
+      for (const message of messages) {
+        expect(message).toHaveProperty('id');
+        expect(message).toHaveProperty('name');
+        expect(message).toHaveProperty('comment');
+        expect(message).toHaveProperty('time');
+        expect(typeof message.comment).toBe('string');
+        expect(message.comment.length).toBeGreaterThan(0);
+      }
+
+      // Hook: Content analysis
+      const allComments = messages
+        .map((m) => m.comment)
+        .join(' ')
+        .toLowerCase();
+      const consciousnessTerms = ['consciousness', 'subjective', 'experience', 'awareness'];
+      const foundTerms = consciousnessTerms.filter((term) => allComments.includes(term));
+
+      expect(foundTerms.length).toBeGreaterThan(0);
+
+      // AI validation of conversation quality
+      const [hasPhilosophicalDepth] = await aiExpected(
+        messages,
+        undefined,
+        'Should contain sophisticated philosophical discussion about machine consciousness with each pioneer contributing their unique perspective'
+      );
+
+      // Hook: Final validation
+      expect(hasPhilosophicalDepth).toBe(true);
+    },
+    longTestTimeout
+  );
+
+  it.skipIf(!shouldRunLongExamples)(
+    'generates a debate between modern AI researchers with debugging hooks',
+    async () => {
+      // Hook: Test initialization
+
+      const speakers = [
+        {
+          id: 'moderator',
+          name: 'AI Debate Moderator',
+          bio: 'Expert moderator facilitating discussions on AI research directions. Ask probing questions and guide the conversation.',
+          agenda: 'Keep the discussion focused and ensure all perspectives are heard',
+        },
+        {
+          id: 'hinton',
+          name: 'Geoffrey Hinton',
+          bio: 'Godfather of deep learning, pioneer in neural networks and backpropagation',
+          agenda: 'Advocate for deep learning and neural network approaches to AI',
+        },
+        {
+          id: 'li',
+          name: 'Fei-Fei Li',
+          bio: 'Pioneer in computer vision and AI ethics, former Chief Scientist at Google Cloud',
+          agenda: 'Emphasize the importance of visual intelligence and responsible AI development',
+        },
+      ];
+
+      const topic =
+        'Deep Learning vs Symbolic AI: Which approach will lead to artificial general intelligence?';
+
+      // Custom turn policy with hooks
+      const moderatedTurnPolicy = (round, _messages) => {
+        // Hook: Simple turn policy tracking
+        expect(round).toBeGreaterThanOrEqual(0);
+
+        if (round === 0) {
+          return ['moderator', 'hinton', 'li'];
+        } else {
+          return ['hinton', 'li', 'moderator'];
+        }
+      };
+
+      const chain = new ConversationChain(topic, speakers, {
+        rules: {
+          shouldContinue: (round, _messages) => {
+            // Hook: Simple continuation check
+            return round < 2; // Only 2 rounds
+          },
+          turnPolicy: moderatedTurnPolicy,
+        },
+      });
+
+      // Hook: Pre-execution state
+      expect(chain.speakers.length).toBe(3);
+
+      const messages = await chain.run();
+
+      // Hook: Simple results
+      expect(Array.isArray(messages)).toBe(true);
+      expect(messages.length).toBeGreaterThan(4);
+
+      // Hook: Moderator participation check
+      const moderatorMessages = messages.filter((m) => m.id === 'moderator');
+      expect(moderatorMessages.length).toBeGreaterThan(0);
+
+      // Hook: Researcher participation check
+      const researcherIds = ['hinton', 'li'];
+      researcherIds.forEach((id) => {
+        const count = messages.filter((m) => m.id === id).length;
+        expect(count).toBeGreaterThan(0);
+      });
+
+      // AI validation of moderated discussion
+      const [hasModeratedDiscussion] = await aiExpected(
+        messages,
+        undefined,
+        'Should contain a well-moderated discussion with the moderator guiding the conversation and researchers providing technical insights'
+      );
+
+      // Hook: Final assessment
+      expect(hasModeratedDiscussion).toBe(true);
+    },
+    longTestTimeout
+  );
+
+  it.skipIf(!shouldRunLongExamples)(
+    'generates a historical debate between early AI pioneers with custom turn policy',
+    async () => {
+      const speakers = [
+        {
+          id: 'turing',
+          name: 'Alan Turing',
+          bio: 'Father of computer science, proposed the Turing Test in 1950',
+          agenda: 'Argue that machines can think and exhibit intelligent behavior',
+        },
+        {
+          id: 'minsky',
+          name: 'Marvin Minsky',
+          bio: 'Co-founder of MIT AI Lab, expert in cognitive science and AI',
+          agenda: 'Discuss the society of mind and modular intelligence',
+        },
+        {
+          id: 'mccarthy',
+          name: 'John McCarthy',
+          bio: 'Inventor of LISP, advocate for logical AI approaches',
+          agenda: 'Promote formal logic and symbolic reasoning in AI',
+        },
+      ];
+
+      const topic = 'Can machines truly think, or do they merely simulate thinking?';
+
+      // Custom turn policy: alternate between Turing and others
+      const customTurnPolicy = (round) => {
+        if (round === 0) {
+          return ['turing', 'minsky', 'mccarthy'];
+        } else {
+          return ['minsky', 'mccarthy', 'turing'];
+        }
+      };
+
+      const chain = new ConversationChain(topic, speakers, {
+        rules: {
+          shouldContinue: (round) => round < 2, // Only 2 rounds
+          turnPolicy: customTurnPolicy,
+        },
+      });
+
+      const messages = await chain.run();
+
+      // Validate turn policy was followed
+      expect(messages.length).toBeGreaterThan(4);
+
+      // All speakers should contribute
+      expect(messages.some((m) => m.id === 'turing')).toBe(true);
+      expect(messages.some((m) => m.id === 'minsky')).toBe(true);
+      expect(messages.some((m) => m.id === 'mccarthy')).toBe(true);
+
+      // AI validation of philosophical depth
+      const [hasPhilosophicalDepth] = await aiExpected(
+        messages,
+        undefined,
+        'Should contain deep philosophical discussion about machine consciousness and the nature of thinking'
+      );
+      expect(hasPhilosophicalDepth).toBe(true);
+    },
+    longTestTimeout
+  );
+
+  it(
+    'handles conversation with custom prompts and includes a summarizer role',
+    async () => {
+      const speakers = [
+        {
+          id: 'hinton',
+          name: 'Geoffrey Hinton',
+          bio: 'Deep learning pioneer, recently left Google to warn about AI risks',
+          agenda: 'Discuss both the potential and dangers of advanced AI systems',
+        },
+        {
+          id: 'sutskever',
+          name: 'Ilya Sutskever',
+          bio: 'OpenAI co-founder, architect of GPT models',
+          agenda: 'Focus on the technical path to AGI and alignment challenges',
+        },
+        {
+          id: 'summarizer',
+          name: 'Discussion Summarizer',
+          bio: 'Expert at synthesizing complex technical discussions. Provide clear summaries of key points.',
+          agenda:
+            'Summarize the main arguments and highlight important insights from the discussion',
+        },
+      ];
+
+      const topic = 'AI Safety and the Race to AGI: Balancing Progress with Precaution';
+
+      const customPrompt =
+        'You are participating in a high-stakes debate about AI safety. Be thoughtful, cite specific examples, and acknowledge the complexity of the issues.';
+
+      // Turn policy: discussion round, then summarizer
+      const summaryTurnPolicy = (round) => {
+        if (round === 0) {
+          return ['hinton', 'sutskever'];
+        } else if (round === 1) {
+          return ['summarizer'];
+        } else {
+          return [];
+        }
+      };
+
+      const chain = new ConversationChain(topic, speakers, {
+        rules: {
+          shouldContinue: (round) => round < 2, // Only 2 rounds
+          turnPolicy: summaryTurnPolicy,
+          customPrompt,
+        },
+      });
+
+      const messages = await chain.run();
+
+      // Validate structure
+      expect(messages.length).toBeGreaterThan(2);
+      expect(messages.some((m) => m.id === 'hinton')).toBe(true);
+      expect(messages.some((m) => m.id === 'sutskever')).toBe(true);
+      expect(messages.some((m) => m.id === 'summarizer')).toBe(true);
+
+      // Summarizer should come last
+      const lastMessage = messages[messages.length - 1];
+      expect(lastMessage.id).toBe('summarizer');
+
+      // AI validation for safety-focused discussion with summary
+      const [focusesOnSafety] = await aiExpected(
+        messages,
+        undefined,
+        'Should contain substantive discussion about AI safety, risks, and responsible AGI development, concluding with a clear summary'
+      );
+      expect(focusesOnSafety).toBe(true);
+    },
+    longTestTimeout
+  );
+
+  it(
+    'demonstrates flexible speaker ordering and role definitions',
+    async () => {
+      const speakers = [
+        {
+          id: 'questioner',
+          name: 'Socratic Questioner',
+          bio: 'Ask probing questions about AI consciousness and challenge assumptions',
+          agenda: 'Use the Socratic method to explore deeper truths about machine intelligence',
+        },
+        {
+          id: 'turing',
+          name: 'Alan Turing',
+          bio: 'Father of computer science, creator of the Turing Test',
+          agenda: 'Defend the possibility of machine consciousness and thinking',
+        },
+        {
+          id: 'skeptic',
+          name: 'AI Skeptic',
+          bio: 'Philosopher who questions whether machines can truly understand or just manipulate symbols',
+          agenda: 'Challenge claims about machine consciousness and understanding',
+        },
+      ];
+
+      const topic = 'What does it mean for a machine to truly understand?';
+
+      // Dynamic turn policy based on conversation flow
+      const dynamicTurnPolicy = (round, _history) => {
+        if (round === 0) {
+          return ['questioner', 'turing', 'skeptic'];
+        } else {
+          // Final round: questioner gets last word
+          return ['turing', 'skeptic', 'questioner'];
+        }
+      };
+
+      const chain = new ConversationChain(topic, speakers, {
+        rules: {
+          shouldContinue: (round) => round < 2, // Only 2 rounds
+          turnPolicy: dynamicTurnPolicy,
+        },
+      });
+
+      const messages = await chain.run();
+
+      // Validate all speakers participated
+      expect(messages.some((m) => m.id === 'questioner')).toBe(true);
+      expect(messages.some((m) => m.id === 'turing')).toBe(true);
+      expect(messages.some((m) => m.id === 'skeptic')).toBe(true);
+
+      // Questioner should have the final word
+      const lastMessage = messages[messages.length - 1];
+      expect(lastMessage.id).toBe('questioner');
+
+      // AI validation of Socratic dialogue
+      const [hasSocraticDepth] = await aiExpected(
+        messages,
+        undefined,
+        'Should demonstrate Socratic questioning method with deep philosophical inquiry about machine understanding'
+      );
+      expect(hasSocraticDepth).toBe(true);
+    },
+    longTestTimeout
+  );
+});