add mcp in and out nodes

Author: monteslu

src/context/RuntimeContext.jsx

@@ -19,6 +19,7 @@ export function RuntimeProvider({ children }) {
   const [isRunning, setIsRunning] = useState(false);
   const [nodeStatuses, setNodeStatuses] = useState({});
   const [mcpStatus, setMcpStatus] = useState('disabled'); // disabled, connecting, connected, error
+  const mcpMessagesRef = useRef([]); // Queue for mcp-output node messages
   const [hasCanvasNodes, setHasCanvasNodes] = useState(false);
   const [hasButtonsNodes, setHasButtonsNodes] = useState(false)
   const { addMessage, addDownload, addError, clear, clearErrors, messages, errors } = useDebug();
@@ -148,6 +149,19 @@ export function RuntimeProvider({ children }) {
         return;
       }
 
+      // Handle MCP message queue action
+      if (action === 'mcpQueueMessage') {
+        mcpMessagesRef.current.push(params);
+        // Keep queue from growing unbounded (max 1000 messages)
+        if (mcpMessagesRef.current.length > 1000) {
+          mcpMessagesRef.current = mcpMessagesRef.current.slice(-1000);
+        }
+        // Update status on the node with new count
+        const count = mcpMessagesRef.current.filter(m => m.nodeId === nodeId).length;
+        peerRef.current.methods.emitEvent(nodeId, 'queueUpdate', { count });
+        return;
+      }
+
       const nodeDef = nodeRegistry.get(nodeType);
       if (!nodeDef?.mainThread?.[action]) {
         logger.warn(`No mainThread handler for ${nodeType}.${action}`);
@@ -169,6 +183,11 @@ export function RuntimeProvider({ children }) {
         return await audioManager.handleMainThreadCall(nodeId, action, params);
       }
 
+      // Handle MCP queue count query
+      if (action === 'mcpGetQueueCount') {
+        return mcpMessagesRef.current.filter(m => m.nodeId === params.nodeId).length;
+      }
+
       const nodeDef = nodeRegistry.get(nodeType);
       if (!nodeDef?.mainThread?.[action]) {
         throw new Error(`No mainThread handler for ${nodeType}.${action}`);
@@ -760,6 +779,47 @@ export function RuntimeProvider({ children }) {
       return nodeStatusesRef.current;
     });
 
+    peerRef.current.addHandler('mcpGetMessages', (limit = 100, clear = true) => {
+      const messages = mcpMessagesRef.current.slice(0, limit);
+      if (clear && messages.length > 0) {
+        // Remove returned messages from queue
+        mcpMessagesRef.current = mcpMessagesRef.current.slice(messages.length);
+
+        // Notify mcp-output nodes that queue was cleared
+        // Group remaining messages by nodeId to get counts
+        const remainingByNode = {};
+        for (const msg of mcpMessagesRef.current) {
+          remainingByNode[msg.nodeId] = (remainingByNode[msg.nodeId] || 0) + 1;
+        }
+
+        // Find all mcp-output nodes and update their status
+        const state = flowStateRef.current;
+        const mcpOutputNodes = Object.values(state.nodes).filter(n => n._node.type === 'mcp-output');
+        for (const node of mcpOutputNodes) {
+          const count = remainingByNode[node._node.id] || 0;
+          peerRef.current.methods.emitEvent(node._node.id, 'queueUpdate', { count });
+        }
+      }
+      return messages;
+    });
+
+    peerRef.current.addHandler('mcpSendMessage', (payload, topic = '') => {
+      // Find all mcp-input nodes and send message to them
+      const state = flowStateRef.current;
+      const mcpInputNodes = Object.values(state.nodes).filter(n => n._node.type === 'mcp-input');
+
+      if (mcpInputNodes.length === 0) {
+        return { success: false, error: 'No mcp-input nodes found in flows' };
+      }
+
+      // Emit message to each mcp-input node
+      for (const node of mcpInputNodes) {
+        peerRef.current.methods.emitEvent(node._node.id, 'mcpMessage', { payload, topic });
+      }
+
+      return { success: true, nodeCount: mcpInputNodes.length };
+    });
+
     peerRef.current.addHandler('mcpGetCanvasSvg', () => {
       // Get the canvas SVG from the DOM
       const svgElement = document.querySelector('.canvas-svg');

src/nodes/ai/mcp-input.js

@@ -0,0 +1,46 @@
+/**
+ * MCP Input Node - Runtime implementation
+ *
+ * Receives messages from AI agents via MCP send_mcp_message tool
+ */
+export const mcpInputRuntime = {
+  type: 'mcp-input',
+
+  onInit() {
+    this.receivedCount = 0;
+    this.mcpConnected = false;
+    this.updateStatus();
+
+    // Listen for MCP connection status changes
+    this.on('mcpConnectionStatus', ({ status }) => {
+      this.mcpConnected = status === 'connected';
+      this.updateStatus();
+    });
+
+    // Listen for messages from main thread
+    this.on('mcpMessage', (msg) => {
+      // Filter by topic if configured
+      const topicFilter = this.config.topic || '';
+      if (topicFilter && msg.topic !== topicFilter) {
+        return; // Skip messages that don't match topic filter
+      }
+
+      this.receivedCount++;
+      this.updateStatus();
+      this.send({
+        payload: msg.payload,
+        topic: msg.topic || 'mcp-in'
+      });
+    });
+  },
+
+  updateStatus() {
+    if (!this.mcpConnected) {
+      this.status({ text: 'MCP disconnected', fill: 'red' });
+    } else if (this.receivedCount > 0) {
+      this.status({ text: `Received: ${this.receivedCount}`, fill: 'green' });
+    } else {
+      this.status({ text: 'Ready', fill: 'green' });
+    }
+  }
+};

src/nodes/ai/mcp-input.jsx

@@ -0,0 +1,64 @@
+/**
+ * MCP Input Node - Receives messages from AI agents via MCP
+ */
+export const mcpInputNode = {
+  type: 'mcp-input',
+  category: 'ai',
+  description: 'Receives messages from AI agents via MCP',
+  paletteLabel: 'mcp-in',
+  label: (node) => node._node.name || 'mcp-in',
+  color: '#a66bbf',  // Purple for AI nodes
+  fontColor: '#fff',
+  icon: true,
+  faChar: '\uf0e0',  // envelope
+  faColor: 'rgba(255,255,255,0.9)',
+
+  inputs: 0,
+  outputs: 1,
+
+  defaults: {
+    topic: { type: 'string', default: '', label: 'Topic filter', description: 'Only receive messages with this topic (empty = all)' }
+  },
+
+  messageInterface: {
+    writes: {
+      payload: {
+        type: 'any',
+        description: 'Message content from AI agent'
+      },
+      topic: {
+        type: 'string',
+        description: 'Message topic'
+      }
+    }
+  },
+
+  renderHelp() {
+    return (
+      <>
+        <p>Receives messages sent by AI agents via the MCP <code>send_mcp_message</code> tool.</p>
+
+        <h5>Use Cases</h5>
+        <ul>
+          <li>AI-initiated speech output</li>
+          <li>AI controlling flows and devices</li>
+          <li>Two-way AI conversation flows</li>
+        </ul>
+
+        <h5>Options</h5>
+        <ul>
+          <li><strong>Topic filter</strong> - Only receive messages with matching topic (leave empty to receive all)</li>
+        </ul>
+
+        <h5>Output</h5>
+        <ul>
+          <li><code>msg.payload</code> - Message content</li>
+          <li><code>msg.topic</code> - Message topic</li>
+        </ul>
+
+        <h5>Example</h5>
+        <p>Wire this node to a <strong>speech</strong> node to let AI agents speak to you.</p>
+      </>
+    );
+  }
+};

src/nodes/ai/mcp-output.js

@@ -0,0 +1,61 @@
+/**
+ * MCP Output Node - Runtime implementation
+ *
+ * Queues messages for MCP consumption via the mcp-messages tool
+ */
+export const mcpOutputRuntime = {
+  type: 'mcp-output',
+
+  async onInit() {
+    this.queueCount = 0;
+    this.mcpConnected = false;
+
+    // Listen for MCP connection status changes
+    this.on('mcpConnectionStatus', ({ status }) => {
+      this.mcpConnected = status === 'connected';
+      this.updateStatus();
+    });
+
+    // Listen for queue updates from main thread
+    this.on('queueUpdate', (data) => {
+      this.queueCount = data.count;
+      this.updateStatus();
+    });
+
+    // Get initial queue count from main thread
+    const initialCount = await this.mainThreadCall('mcpGetQueueCount', { nodeId: this.id });
+    this.queueCount = initialCount || 0;
+    this.updateStatus();
+  },
+
+  updateStatus() {
+    if (!this.mcpConnected) {
+      this.status({ text: 'MCP disconnected', fill: 'red' });
+    } else if (this.queueCount > 0) {
+      this.status({ text: `Queued: ${this.queueCount}`, fill: 'blue' });
+    } else {
+      this.status({ text: 'Ready', fill: 'green' });
+    }
+  },
+
+  onInput(msg) {
+    const text = typeof msg.payload === 'string'
+      ? msg.payload
+      : JSON.stringify(msg.payload);
+
+    const topic = msg.topic || this.config.topic || '';
+
+    if (!text || text.trim() === '') {
+      return;
+    }
+
+    // Send to MCP queue via the worker's MCP integration
+    this.mainThread('mcpQueueMessage', {
+      text: text.trim(),
+      topic,
+      nodeId: this.id,
+      nodeName: this.name || 'mcp-out',
+      timestamp: Date.now()
+    });
+  }
+};

src/nodes/ai/mcp-output.jsx

@@ -0,0 +1,65 @@
+/**
+ * MCP Output Node - Sends messages to the MCP queue for AI agent consumption
+ */
+export const mcpOutputNode = {
+  type: 'mcp-output',
+  category: 'ai',
+  description: 'Sends text to the MCP message queue for AI agents',
+  paletteLabel: 'mcp-out',
+  label: (node) => node._node.name || 'mcp-out',
+  color: '#a66bbf',  // Purple for AI nodes
+  fontColor: '#fff',
+  icon: true,
+  faChar: '\uf0e0',  // envelope
+  faColor: 'rgba(255,255,255,0.9)',
+
+  inputs: 1,
+  outputs: 0,
+
+  defaults: {
+    topic: { type: 'string', default: '', label: 'Topic' }
+  },
+
+  messageInterface: {
+    reads: {
+      payload: {
+        type: 'string',
+        description: 'Text message to send to MCP queue',
+        required: true
+      },
+      topic: {
+        type: 'string',
+        description: 'Optional topic/category for the message',
+        optional: true
+      }
+    }
+  },
+
+  renderHelp() {
+    return (
+      <>
+        <p>Sends text messages to a queue that AI agents can read via MCP.</p>
+
+        <h5>Use Cases</h5>
+        <ul>
+          <li>Voice recognition output to AI conversation</li>
+          <li>Sensor alerts for AI to respond to</li>
+          <li>Event notifications for AI processing</li>
+        </ul>
+
+        <h5>Input</h5>
+        <ul>
+          <li><code>msg.payload</code> - Text message to queue</li>
+          <li><code>msg.topic</code> - Optional topic (overrides node setting)</li>
+        </ul>
+
+        <h5>MCP Integration</h5>
+        <p>AI agents can retrieve messages using the <code>get_mcp_messages</code> tool,
+        which returns and clears the queue.</p>
+
+        <h5>Example</h5>
+        <p>Wire a <strong>voicerec</strong> node to this node to enable voice conversations with an AI agent.</p>
+      </>
+    );
+  }
+};

src/nodes/audio/oscillator.js

@@ -42,6 +42,24 @@ export const audioOscillatorRuntime = {
       });
     }
 
+    // Handle frequency ramp (for sweeps/glides)
+    if (msg.rampFrequency !== undefined) {
+      this.mainThread('rampAudioParam', {
+        param: 'frequency',
+        value: msg.rampFrequency,
+        duration: msg.rampTime || 0.1
+      });
+    }
+
+    // Handle detune ramp
+    if (msg.rampDetune !== undefined) {
+      this.mainThread('rampAudioParam', {
+        param: 'detune',
+        value: msg.rampDetune,
+        duration: msg.rampTime || 0.1
+      });
+    }
+
     // Handle PeriodicWave for custom waveforms (FFT-based synthesis)
     // realTable = real (cosine) coefficients, imagTable = imaginary (sine) coefficients
     if (Array.isArray(msg.realTable)) {
@@ -51,6 +69,17 @@ export const audioOscillatorRuntime = {
       });
     }
 
+    // Harmonics shorthand - array of harmonic amplitudes [fundamental, 2nd, 3rd, ...]
+    // Automatically builds imagTable for sine-phase harmonics
+    if (Array.isArray(msg.harmonics)) {
+      const imagTable = [0, ...msg.harmonics]; // DC offset of 0, then harmonics
+      const realTable = new Array(imagTable.length).fill(0); // All cosine terms zero
+      this.mainThread('setPeriodicWave', {
+        realTable,
+        imagTable
+      });
+    }
+
     // One-shot mode: play for a duration then stop
     if (msg.duration !== undefined) {
       this.mainThread('playAudioNode', {