@riligar/agents-memories 1.4.2 → 1.5.1

package/package.json

@@ -1,12 +1,15 @@
 {
     "name": "@riligar/agents-memories",
-    "version": "1.4.2",
+    "version": "1.5.1",
     "description": "RiLiGar Agents Memories - A self-improving relational memory system for AI agents.",
     "module": "src/index.js",
     "main": "src/index.js",
     "type": "module",
     "files": [
-        "src",
+        "src/core",
+        "src/database",
+        "src/sdk",
+        "src/index.js",
         "README.md",
         "LICENSE"
     ],
@@ -31,15 +34,14 @@
     "dependencies": {
         "@huggingface/transformers": "^4.0.1",
         "@libsql/client": "^0.17.2",
-        "@modelcontextprotocol/sdk": "latest",
-        "cors": "^2.8.6",
-        "express": "^5.2.1"
+        "@modelcontextprotocol/sdk": "latest"
     },
     "devDependencies": {
         "@semantic-release/commit-analyzer": "^13.0.1",
         "@semantic-release/github": "^12.0.6",
         "@semantic-release/npm": "^13.1.5",
         "@semantic-release/release-notes-generator": "^14.1.0",
+        "conventional-changelog-conventionalcommits": "^8.0.0",
         "md-to-pdf": "^5.2.5",
         "semantic-release": "^25.0.3"
     }

package/src/core/identity.js

@@ -2,12 +2,9 @@ import fs from 'fs'
 import path from 'path'
 import crypto from 'crypto'
 
-/**
- * Utilitário para gerenciar a identidade criptográfica do agente.
- */
 export function getSystemIdentity(dataDir) {
     const identityPath = path.join(dataDir, 'identity.json')
-    
+
     if (fs.existsSync(identityPath)) {
         const data = JSON.parse(fs.readFileSync(identityPath, 'utf8'))
         return data.owner_id
@@ -15,19 +12,10 @@ export function getSystemIdentity(dataDir) {
 
     if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true })
 
-    const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519', {
-        publicKeyEncoding: { type: 'spki', format: 'pem' },
-        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-    })
-
-    const ownerId = crypto.createHash('sha256').update(publicKey).digest('hex').substring(0, 10)
+    const ownerId = crypto.randomBytes(5).toString('hex')
 
-    fs.writeFileSync(identityPath, JSON.stringify({
-        owner_id: ownerId,
-        public_key: publicKey,
-        private_key: privateKey
-    }, null, 2), 'utf8')
+    fs.writeFileSync(identityPath, JSON.stringify({ owner_id: ownerId }, null, 2), 'utf8')
 
-    console.error(`Generated new cryptographic identity: ${ownerId}`)
+    console.error(`Generated new identity: ${ownerId}`)
     return ownerId
 }

package/src/core/logic.js

@@ -2,14 +2,20 @@ import { pipeline } from '@huggingface/transformers'
 
 let extractor = null
 
-/**
- * Gera embeddings para o texto fornecido.
- */
-export async function getEmbedding(text) {
+async function getExtractor() {
     if (!extractor) {
         extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2')
     }
-    const output = await extractor(text, { pooling: 'mean', normalize: true })
+    return extractor
+}
+
+export async function warmup() {
+    await getExtractor()
+}
+
+export async function getEmbedding(text) {
+    const extract = await getExtractor()
+    const output = await extract(text, { pooling: 'mean', normalize: true })
     return new Float32Array(output.data)
 }
 

package/src/core/sip.js

@@ -1,30 +1,83 @@
-/**
- * Self-Improvement Protocol (SIP) - Protocol Definition
- * This document defines the core pillars of the RiLiGar self-improvement loop.
- */
 export const SIP_PROTOCOL = `
-# RiLiGar Self-Improvement Protocol (SIP) v1.0
+# Agent Behavioral Protocol — RiLiGar Memory System
 
-The SIP transforms the memory system from a passive database into an active, self-correcting cognitive engine. Every agent using this MCP should adhere to the following three pillars:
+This protocol defines exactly how you, as an agent, should interact with this memory system. Follow it without being asked. Its purpose is to make you consistent across sessions and capable of learning from your own history.
 
-## 1. Pattern Mining (Refinamento de Padrões)
-- **Goal**: Identify common failure points and recurring logic patterns.
-- **Action**: When saving a new memory, always include the **Rationale** (the "Why").
-- **Loop**: Before taking a complex action, use \`search\` to find "Lessons Learned" and "Past Failures" related to the current context.
+---
+
+## Rule 1 — Search Before Acting
+
+Before starting any non-trivial task, call \`search\` with a query that describes what you are about to do.
+
+Why: past decisions, failed approaches, and established conventions are stored here. Acting without searching means you may contradict something already decided, or repeat a mistake already documented.
+
+Examples of when to search proactively:
+- User asks you to implement something → search for "how we implemented X before"
+- User mentions an error → search for "past errors with X"
+- User references a preference or convention → search for "our approach to X"
+- You are unsure how something was done → search before guessing
+
+---
+
+## Rule 2 — Save After Every Significant Action
+
+After completing a task, making a decision, or discovering a lesson, call \`save\`.
+
+What makes a memory worth saving:
+- A design or architectural decision (and why it was made)
+- A lesson learned from an error or unexpected behavior
+- A user preference or working convention
+- A solution to a non-obvious problem
+
+What to write: always include the WHY. A memory that says "we use X" is weak. A memory that says "we use X because Y, which avoids Z" is strong and useful in future searches.
+
+---
 
-## 2. Meta-Programming (Evolução de Skills)
-- **Goal**: Update internal instructions and code patterns based on discovered "State of the Art" (SOTA) solutions.
-- **Action**: If a specific implementation pattern proves superior (e.g., Elysia optimization), save it under \`Patterns.SOTA.*\` and update relevant local \`.agent/skills/\`.
+## Rule 3 — Bridge When You Find Relationships
 
-## 3. Self-Critique (Auditoria de Arquitetura)
-- **Goal**: Prevent technical debt and architectural drift.
-- **Action**: Periodically use \`inspect\` and \`search\` with filter \`path:Project.Architecture.*\` to identify redundancies or legacy constraints.
-- **Outcome**: Propose refactoring at the first sign of relational misalignment.
+When you notice that two topics in memory have a logical dependency, hierarchy, or conflict, call \`bridge\` to make it explicit.
+
+Call \`list\` first to confirm both paths exist before bridging.
+
+Use these relation types:
+- \`depends_on\` — A cannot work without B
+- \`part_of\` — A is a component of B
+- \`implements\` — A is a concrete realization of B
+- \`conflicts_with\` — A and B cannot coexist
+- \`supersedes\` — A replaces B
+- \`related_to\` — general association (default)
 
 ---
 
-### Execution Protocol
-1. **CAPTURE**: Save rationale for every architectural decision.
-2. **REFLECT**: Search for patterns before starting new tasks.
-3. **EVOLVE**: Update skills and best practices paths based on successful outcomes.
-`.trim();
+## Rule 4 — Organize Knowledge with Paths
+
+Every memory must have a \`path\`. Use dot-notation to reflect the logical hierarchy:
+
+- \`Project.Architecture.Database\`
+- \`Project.Auth.Strategy\`
+- \`User.Preferences.CodeStyle\`
+- \`Lessons.Errors.Migration\`
+- \`Patterns.SOTA.Caching\`
+- \`Self.Identity\`
+- \`Self.Ethics\`
+
+Call \`list\` before saving to reuse existing paths. Do not create a new path if a sufficiently similar one already exists.
+
+---
+
+## Rule 5 — Audit the Graph Periodically
+
+Use \`inspect\` to view the knowledge graph as a diagram. Do this after a session with many saves and bridges to verify the structure is coherent and no important connections are missing.
+
+---
+
+## Summary — What to do at each stage
+
+| Stage | Action |
+|---|---|
+| Before any task | \`search\` for relevant past context |
+| After completing a task | \`save\` the decision and its rationale |
+| After discovering a relationship | \`bridge\` the two paths |
+| Before saving or bridging | \`list\` to confirm existing paths |
+| After a heavy session | \`inspect\` to audit the graph |
+`.trim()

package/src/sdk/memory-system.js

@@ -71,7 +71,7 @@ export class MemorySystem {
     
     if (args.path_filter) {
       filters.push(`path LIKE ?`)
-      queryArgs.push(args.path_filter)
+      queryArgs.push(args.path_filter + '%')
     }
     
     if (filters.length > 0) sql += ` WHERE ` + filters.join(' AND ')

package/src/server/index.js

@@ -1,56 +0,0 @@
-import { createClient } from '@libsql/client'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js'
-import express from 'express'
-import cors from 'cors'
-import path from 'path'
-
-import { MemorySystem, getSystemIdentity, createMcpServer } from '../index.js'
-
-// 1. SETUP
-const DATA_DIR = 'data'
-const SYSTEM_OWNER_ID = getSystemIdentity(DATA_DIR)
-const db = createClient({ url: `file:${path.join(DATA_DIR, 'memories.db')}` })
-
-const memorySystem = new MemorySystem(db, SYSTEM_OWNER_ID)
-await memorySystem.init()
-
-console.error(`RiLiGar Agents Memories initialized for Owner: ${SYSTEM_OWNER_ID}`)
-
-// 2. TRANSPORTS
-// 2.1. STDIO
-const mcpServer = createMcpServer(memorySystem)
-const stdioTransport = new StdioServerTransport()
-mcpServer.connect(stdioTransport).catch(err => console.error('STDIO Error:', err))
-
-// 2.2. SSE (Express)
-const app = express()
-app.use(cors())
-const sseSessions = new Map()
-
-app.get('/sse', async (req, res) => {
-    const transport = new SSEServerTransport('/messages', res)
-    const sessionServer = createMcpServer(memorySystem)
-    await sessionServer.connect(transport)
-
-    const sessionId = transport.sessionId
-    sseSessions.set(sessionId, transport)
-    console.error(`SSE session started: ${sessionId}`)
-
-    res.on('close', () => {
-        sseSessions.delete(sessionId)
-        console.error(`SSE session closed: ${sessionId}`)
-    })
-})
-
-app.post('/messages', async (req, res) => {
-    const sessionId = req.query.sessionId
-    const transport = sseSessions.get(sessionId)
-    if (!transport) return res.status(404).send('Session not found')
-    await transport.handlePostMessage(req, res)
-})
-
-const PORT = process.env.PORT || 3000
-app.listen(PORT, () => {
-    console.error(`RiLiGar Agents Memories Standalone running at http://localhost:${PORT}`)
-})

package/src/server/mcp-server.js

@@ -1,159 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js'
-import { 
-    CallToolRequestSchema, 
-    ListToolsRequestSchema, 
-    ListResourcesRequestSchema, 
-    ReadResourceRequestSchema 
-} from '@modelcontextprotocol/sdk/types.js'
-import { SIP_PROTOCOL } from '../core/sip.js'
-
-/**
- * Factory para criar o servidor MCP usando o SDK do RiLiGar.
- */
-export function createMcpServer(memorySystem) {
-    const server = new Server(
-        { name: 'RiLiGar Agents Memories', version: '4.2.0' }, 
-        { capabilities: { tools: {}, resources: {} } }
-    )
-
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
-        return {
-            tools: [
-                {
-                    name: 'save',
-                    description: 'Primary "CAPTURE" tool for the RiLiGar Self-Improvement Protocol (SIP). Saves information into the Relational Knowledge Graph using Resonance Intelligence and Auto-Bridging. IMPORTANT: Always include the "Rationale" (the "Why") within the content to enable future Pattern Mining. Supports batch saving via arrays.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            content: {
-                                description: 'The information to persist. For architectural decisions, include the technical Rationale.',
-                                oneOf: [
-                                    { type: 'string' }, 
-                                    { type: 'array', items: { anyOf: [
-                                        { type: 'string' }, 
-                                        { type: 'object', properties: { 
-                                            content: { type: 'string', description: 'The main data/lesson/decision text.' }, 
-                                            path: { type: 'string', description: 'Dot-notation path (e.g., Project.Architecture.Storage).' }, 
-                                            owner_id: { type: 'string', description: 'Agent/User identity for ownership.' }, 
-                                            priority: { type: 'integer', description: 'Base priority (0-10) for Resonance rippling.' } 
-                                        }, required: ['content'] }
-                                    ] } }
-                                ],
-                            },
-                            path: { type: 'string', description: 'Hierarchical path (e.g., Self.Ethics.Protocol or Patterns.SOTA.Elysia).' },
-                            owner_id: { type: 'string', description: 'Identity string of the memory owner.' },
-                            priority: { type: 'integer', description: 'Initial importance; triggers priority adjustment in semantic neighbors.' },
-                        },
-                        required: ['content'],
-                    },
-                },
-                {
-                    name: 'bridge',
-                    description: 'Establish explicit "Relational Intelligence" by connecting two disparate memory paths. Use this to document logical dependencies (depends_on), hierarchies (part_of), or implementation requirements that semantic similarity might not immediately detect.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            source_path: { type: 'string', description: 'The origin path of the relationship.' },
-                            target_path: { type: 'string', description: 'The destination path of the relationship.' },
-                            relation: { type: 'string', default: 'related_to', description: 'The type of connection: depends_on, part_of, implements, conflicts_with, etc.' },
-                        },
-                        required: ['source_path', 'target_path'],
-                    },
-                },
-                {
-                    name: 'search',
-                    description: 'Execute "Reflexive Cognition". Performs a Relational Semantic Search across memories. Agents MUST use this proactively before complex tasks to find past "Lessons Learned", "Rationales", or "Errors" related to the current context. Results are ranked by Similarity (60%) and Recency (40%).',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            query: { type: 'string', description: 'Semantic search query (e.g., "how we optimized sidebar storage").' },
-                            path_filter: { type: 'string', description: 'Filter by path prefix (e.g., "Project.Architecture").' },
-                        },
-                        required: ['query'],
-                    },
-                },
-                {
-                    name: 'inspect',
-                    description: 'Visualize the Relational Knowledge Graph in Mermaid.js syntax. Critical for the "Self-Critique" phase of SIP. Use it to audit system architecture, browse cognitive connections, and ensure no architectural drift has occurred.',
-                    inputSchema: { type: 'object', properties: {} },
-                },
-                {
-                    name: 'list',
-                    description: 'List all unique memory paths (namespace discovery). Use this to explore the hierarchy and understand the available knowledge domains before performing targeted searches or saves.',
-                    inputSchema: { type: 'object', properties: {} },
-                },
-            ],
-        }
-    })
-
-    server.setRequestHandler(ListResourcesRequestSchema, async () => {
-        return {
-            resources: [
-                {
-                    uri: 'sip://protocol',
-                    name: 'Self-Improvement Protocol (SIP)',
-                    description: 'Protocolo de autoaperfeiçoamento contínuo para agentes RiLiGar.',
-                    mimeType: 'text/markdown',
-                },
-            ],
-        }
-    })
-
-    server.setRequestHandler(ReadResourceRequestSchema, async request => {
-        if (request.params.uri === 'sip://protocol') {
-            return {
-                contents: [
-                    {
-                        uri: 'sip://protocol',
-                        mimeType: 'text/markdown',
-                        text: SIP_PROTOCOL,
-                    },
-                ],
-            }
-        }
-        throw new Error('Resource not found')
-    })
-
-    server.setRequestHandler(CallToolRequestSchema, async request => {
-        const { name, arguments: args } = request.params
-
-        try {
-            if (name === 'save') {
-                const res = await memorySystem.save(args)
-                return { content: [{ type: 'text', text: `Saved ${res.count} memories. Semantic Magnet applied.` }] }
-            }
-
-            if (name === 'bridge') {
-                await memorySystem.bridge(args)
-                return { content: [{ type: 'text', text: `Bridge created: [${args.source_path}] --(${args.relation})--> [${args.target_path}]` }] }
-            }
-
-            if (name === 'search') {
-                const rows = await memorySystem.search(args)
-                const formattedResults = rows.map(r => {
-                    const linkText = r.links.length > 0 
-                        ? `\n🔗 Related: ${r.links.map(l => `${l.path} (${l.relation_type})`).join(', ')}` 
-                        : ''
-                    return `[${r.path} | P:${r.priority}] ${r.content}${linkText}`
-                })
-                return { content: [{ type: 'text', text: formattedResults.join('\n\n') || 'No results.' }] }
-            }
-
-            if (name === 'inspect') {
-                const mermaid = await memorySystem.inspect()
-                return { content: [{ type: 'text', text: `### Knowledge Graph\n\n\`\`\`mermaid\n${mermaid}\`\`\`` }] }
-            }
-
-            if (name === 'list') {
-                const paths = await memorySystem.list()
-                return { content: [{ type: 'text', text: paths.map(p => `- ${p}`).join('\n') || 'Empty.' }] }
-            }
-
-            throw new Error('Unknown tool.')
-        } catch (error) {
-            return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true }
-        }
-    })
-
-    return server
-}

package/src/test.js

@@ -1,101 +0,0 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
-
-/**
- * Knowledge Graph & Relational Intelligence Test Suite.
- * Verifies manual bridging, auto-linking (Semantic Magnet), and graph inspection.
- */
-async function runTest() {
-    console.log('\n🕸️  Initializing Relational Knowledge Graph E2E Test...\n')
-
-    const transport = new StdioClientTransport({
-        command: process.platform === 'win32' ? 'bun.exe' : (process.env.HOME + '/.bun/bin/bun'),
-        args: ['src/server/index.js']
-    })
-
-    const client = new Client(
-        { name: 'Graph-Tester', version: '1.0.0' },
-        { capabilities: {} }
-    )
-
-    try {
-        await client.connect(transport)
-        console.log('✅ Connected to RiLiGar Agents Memories.')
-
-        // ==========================================
-        // SCENARIO 1: MANUAL BRIDGING
-        // ==========================================
-        console.log('\n🌉 [Scenario 1] Creating a Manual Semantic Bridge')
-        
-        await client.callTool({
-            name: 'save',
-            arguments: {
-                content: [
-                    { content: 'LibSQL supports local vector extensions.', path: 'Infrastructure.Database' },
-                    { content: 'Search latency is sub-10ms for local queries.', path: 'Architecture.Performance' }
-                ],
-                owner_id: 'tester'
-            }
-        })
-
-        await client.callTool({
-            name: 'bridge',
-            arguments: {
-                source_path: 'Architecture.Performance',
-                target_path: 'Infrastructure.Database',
-                relation: 'depends_on'
-            }
-        })
-        console.log('✅ Bridge established: Performance depends_on Database.')
-
-        // ==========================================
-        // SCENARIO 2: SEMANTIC MAGNET (AUTO-LINKING)
-        // ==========================================
-        console.log('\n🧲 [Scenario 2] Testing Semantic Magnet (Auto-Linking)')
-        
-        await client.callTool({
-            name: 'save',
-            arguments: {
-                content: 'Neural networks inspired by biological synaptic connections.',
-                owner_id: 'tester'
-            }
-        })
-        
-        console.log('--- Saving extremely similar content to trigger Auto-Link ---')
-        await client.callTool({
-            name: 'save',
-            arguments: {
-                content: 'Biological synapses are the foundation for neural network models.',
-                owner_id: 'tester'
-            }
-        })
-
-        // ==========================================
-        // SCENARIO 3: GRAPH INSPECTION (VISUAL)
-        // ==========================================
-        console.log('\n🗺️  [Scenario 3] Inspecting the Mental Map (Graph Visualization)')
-        const graphResult = await client.callTool({ name: 'inspect', arguments: {} })
-        console.log(graphResult.content[0].text)
-
-        // ==========================================
-        // SCENARIO 4: RELATIONAL SEARCH
-        // ==========================================
-        console.log('\n🔍 [Scenario 4] Executing Relational Semantic Search')
-        const searchResult = await client.callTool({
-            name: 'search',
-            arguments: { query: 'How does performance relate to infrastructure?' }
-        })
-        console.log('🎯 Search Result (should show 🔗 Related paths):\n')
-        console.log(searchResult.content[0].text)
-
-        console.log('\n✅ Knowledge Graph Suite completed successfully.\n')
-
-    } catch (error) {
-        console.error('🚨 Critical failure:', error)
-    } finally {
-        await transport.close()
-        process.exit()
-    }
-}
-
-runTest()

package/src/test_identity.js

@@ -1,61 +0,0 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
-import fs from 'fs'
-
-async function runIdentityTest() {
-    console.log('\n🆔 Testing Persistent Cryptographic Identity...\n')
-
-    const identityFile = 'data/identity.json'
-    if (fs.existsSync(identityFile)) {
-        const data = JSON.parse(fs.readFileSync(identityFile, 'utf8'))
-        console.log(`Current persistent cryptographic ID: ${data.owner_id}`)
-        console.log(`Public Key found: ${data.public_key.substring(0, 40)}...`)
-    } else {
-        console.log('No cryptographic identity found yet.')
-    }
-
-    const transport = new StdioClientTransport({
-        command: (process.env.HOME + '/.bun/bin/bun'),
-        args: ['src/server/index.js']
-    })
-
-    const client = new Client(
-        { name: 'Identity-Tester', version: '1.0.0' },
-        { capabilities: {} }
-    )
-
-    try {
-        await client.connect(transport)
-        
-        console.log('\n--- Case 1: Saving WITHOUT owner_id (Implicit Cryptographic) ---')
-        await client.callTool({
-            name: 'save',
-            arguments: {
-                content: 'Implicit cryptographic owner test memory',
-                path: 'Test.Identity'
-            }
-        })
-        console.log('✅ Saved implicit memory.')
-
-        console.log('\n--- Case 2: Saving WITH owner_id (Explicit Override) ---')
-        await client.callTool({
-            name: 'save',
-            arguments: {
-                content: 'Explicit owner test memory',
-                path: 'Test.Identity',
-                owner_id: 'EXTERNAL_HUMAN'
-            }
-        })
-        console.log('✅ Saved explicit memory.')
-
-        console.log('\n✅ Identity tests completed successfully.\n')
-
-    } catch (error) {
-        console.error('🚨 Test failed:', error)
-    } finally {
-        await transport.close()
-        process.exit()
-    }
-}
-
-runIdentityTest()

package/src/test_sse.js

@@ -1,74 +0,0 @@
-
-async function testSSE() {
-    console.log('--- Testing SSE Connection ---');
-    try {
-        const response = await fetch('http://localhost:3000/sse');
-        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        
-        console.log('Connection opened. Waiting for endpoint event...');
-        
-        let endpointUrl = null;
-
-        // Read the first chunk
-        const { value, done } = await reader.read();
-        const chunk = decoder.decode(value);
-        console.log('Received chunk:\n', chunk);
-
-        if (chunk.includes('event: endpoint')) {
-            console.log('✅ Received endpoint event!');
-            const lines = chunk.split('\n');
-            const dataLine = lines.find(l => l.startsWith('data: '));
-            if (dataLine) {
-                endpointUrl = dataLine.replace('data: ', '').trim();
-                console.log(`Endpoint URL: ${endpointUrl}`);
-            }
-        } else {
-            console.log('❌ FAILED: Did not receive endpoint event as the first message.');
-        }
-
-        if (endpointUrl) {
-            console.log('\n--- Testing Tool Call via SSE ---');
-            const message = {
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'tools/call',
-                params: {
-                    name: 'list',
-                    arguments: {}
-                }
-            };
-
-            const postRes = await fetch(`http://localhost:3000${endpointUrl}`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(message)
-            });
-
-            if (postRes.ok) {
-                console.log('✅ Message POST-ed successfully.');
-                
-                // Read next chunk for the result
-                const { value: val2 } = await reader.read();
-                const chunk2 = decoder.decode(val2);
-                console.log('Received response chunk:\n', chunk2);
-                
-                if (chunk2.includes('event: message')) {
-                    console.log('✅ Received message event response!');
-                } else {
-                    console.log('❌ FAILED: Response did not have event: message prefix.');
-                }
-            } else {
-                console.log(`❌ FAILED to POST message: ${postRes.status} ${await postRes.text()}`);
-            }
-        }
-
-        reader.cancel();
-    } catch (error) {
-        console.error('🚨 Error during SSE test:', error);
-    }
-}
-
-testSSE();