node-red-contrib-copilot 0.0.1 → 0.0.2

package/nodes/copilot-config/copilot-config.js

@@ -45,6 +45,8 @@ module.exports = function (RED) {
         // this.credentials.githubToken populated by Node-RED when authMethod === 'token'
         this._client = null;
         this._startPromise = null;
+        this._modelsCache = null;
+        this._modelsCacheAt = 0;
 
         this.on('close', async (done) => {
             if (this._client) {
@@ -55,6 +57,8 @@ module.exports = function (RED) {
                 }
                 this._client = null;
                 this._startPromise = null;
+                this._modelsCache = null;
+                this._modelsCacheAt = 0;
             }
             done();
         });
@@ -107,20 +111,30 @@ module.exports = function (RED) {
         },
     });
 
+    const MODELS_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
     // Admin endpoint: GET /copilot/models?configId=<id>
     // Used by the prompt node editor to populate the model dropdown dynamically.
+    // Results are cached on the config node for MODELS_CACHE_TTL_MS to avoid
+    // hitting the SDK on every editor open.
     RED.httpAdmin.get('/copilot/models', RED.auth.needsPermission('copilot-config.read'), async (req, res) => {
         const configNode = RED.nodes.getNode(req.query.configId);
         if (!configNode) {
             return res.status(404).json({ error: 'Config node not found' });
         }
+        const now = Date.now();
+        if (configNode._modelsCache && (now - configNode._modelsCacheAt) < MODELS_CACHE_TTL_MS) {
+            return res.json(configNode._modelsCache);
+        }
         try {
             const client = await configNode.getClient();
             const models = await client.listModels();
-            res.json(models.map(m => ({
+            configNode._modelsCache = models.map(m => ({
                 id: m.id,
                 multiplier: m.billing ? m.billing.multiplier : null,
-            })));
+            }));
+            configNode._modelsCacheAt = now;
+            res.json(configNode._modelsCache);
         } catch (err) {
             res.status(500).json({ error: err.message });
         }

package/nodes/copilot-prompt/copilot-prompt.html

@@ -8,6 +8,8 @@
             model: { value: '' },
             reasoningEffort: { value: '' },
             timeout: { value: 60000 },
+            conversationId: { value: '' },
+            sessionTimeout: { value: 30 },
         },
         inputs: 1,
         outputs: 2,
@@ -81,10 +83,20 @@
         <label for="node-input-timeout"><i class="fa fa-clock-o"></i> Timeout (ms)</label>
         <input type="number" id="node-input-timeout" placeholder="60000" min="1000">
     </div>
+    <div class="form-row">
+        <label for="node-input-conversationId"><i class="fa fa-comments"></i> Conv. ID</label>
+        <input type="text" id="node-input-conversationId" placeholder="(leave blank to use node ID)">
+    </div>
+    <div class="form-row">
+        <label for="node-input-sessionTimeout"><i class="fa fa-hourglass-half"></i> Session idle (min)</label>
+        <input type="number" id="node-input-sessionTimeout" placeholder="30" min="0">
+    </div>
 </script>
 
 <script type="text/html" data-help-name="copilot-prompt">
-    <p>Send a prompt (with optional attachments) to GitHub Copilot and receive a response.</p>
+    <p>Send a prompt (with optional attachments) to GitHub Copilot and receive a response.
+    Conversations are stateful by default — context is preserved across messages in the same
+    conversation thread.</p>
 
     <h3>Inputs</h3>
     <dl class="message-properties">
@@ -102,6 +114,20 @@
         </dd>
         <dt class="optional">model <span class="property-type">string</span></dt>
         <dd>Override the model for this message (e.g. <code>"gpt-5"</code>).</dd>
+        <dt class="optional">conversationId <span class="property-type">string</span></dt>
+        <dd>
+            Identifies the conversation thread to use. If omitted, defaults to the node's
+            configured <em>Conv. ID</em>, or the node's own ID if that is also blank.
+            Set a per-user value (e.g. a user ID or session token) to maintain separate
+            conversation threads through a single node.
+        </dd>
+        <dt class="optional">reset <span class="property-type">boolean</span></dt>
+        <dd>
+            When <code>true</code>, destroys the active session for the resolved
+            <code>conversationId</code> and swallows the message — nothing is sent to
+            Copilot and no output is produced. Use this to start a conversation over
+            from scratch. The next message will open a fresh session.
+        </dd>
     </dl>
 
     <h3>Outputs</h3>
@@ -110,8 +136,8 @@
             <dl class="message-properties">
                 <dt>payload <span class="property-type">string</span></dt>
                 <dd>The assistant's response text.</dd>
-                <dt>sessionId <span class="property-type">string</span></dt>
-                <dd>The Copilot session ID.</dd>
+                <dt>conversationId <span class="property-type">string</span></dt>
+                <dd>The conversation thread key used for this message.</dd>
                 <dt>events <span class="property-type">array</span></dt>
                 <dd>All session events emitted during the request.</dd>
             </dl>
@@ -125,4 +151,17 @@
             </dl>
         </li>
     </ol>
+
+    <h3>Session lifecycle</h3>
+    <p>
+        Sessions are created on first use and kept alive between messages so that
+        conversation context is preserved. A session is closed when:
+    </p>
+    <ul>
+        <li>A message with <code>msg.reset = true</code> is received.</li>
+        <li>The session has been idle longer than the configured <em>Session idle</em>
+            timeout (default 30 min; set to <code>0</code> to disable).</li>
+        <li>An error occurs — the session is discarded so the next message starts fresh.</li>
+        <li>The node is redeployed or Node-RED shuts down.</li>
+    </ul>
 </script>

package/nodes/copilot-prompt/copilot-prompt.js

@@ -4,8 +4,30 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
-const DEFAULT_MODEL = 'claude-haiku-4.5';
+const DEFAULT_MODEL = 'gpt-4.1';
 const DEFAULT_TIMEOUT = 60000;
+const DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+
+/**
+ * Sniffs the file extension from a base64 string or Buffer by checking magic bytes.
+ * Returns e.g. '.jpg', '.png', '.gif', '.webp', '.pdf', or '' if unknown.
+ */
+function guessExtension(attachment) {
+    let buf;
+    if (attachment.type === 'base64' && attachment.data) {
+        buf = Buffer.from(attachment.data.slice(0, 16), 'base64');
+    } else if (attachment.type === 'buffer' && Buffer.isBuffer(attachment.data)) {
+        buf = attachment.data.slice(0, 16);
+    } else {
+        return '';
+    }
+    if (buf[0] === 0xFF && buf[1] === 0xD8) return '.jpg';
+    if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4E && buf[3] === 0x47) return '.png';
+    if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46) return '.gif';
+    if (buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46) return '.webp';
+    if (buf[0] === 0x25 && buf[1] === 0x50 && buf[2] === 0x44 && buf[3] === 0x46) return '.pdf';
+    return '';
+}
 
 /**
  * Normalises an attachment descriptor into an SDK-compatible `{ type, path }` object.
@@ -26,7 +48,9 @@ function normaliseAttachment(attachment) {
     }
 
     const tmpDir = os.tmpdir();
-    const name = attachment.name || 'attachment';
+    const rawName = attachment.name || 'attachment';
+    // If the name has no extension, sniff the format from magic bytes / base64 header
+    const name = path.extname(rawName) ? rawName : rawName + guessExtension(attachment);
     const tempFile = path.join(tmpDir, `nr-copilot-${Date.now()}-${Math.random().toString(36).slice(2)}-${name}`);
 
     if (attachment.type === 'base64') {
@@ -56,14 +80,53 @@ module.exports = function (RED) {
         this.model = config.model || DEFAULT_MODEL;
         this.reasoningEffort = config.reasoningEffort || undefined;
         this.timeout = parseInt(config.timeout, 10) || DEFAULT_TIMEOUT;
+        this.conversationId = config.conversationId || ''; // '' means use node.id
+        const sessionTimeoutMin = parseFloat(config.sessionTimeout);
+        this.sessionTimeoutMs = isFinite(sessionTimeoutMin) && sessionTimeoutMin > 0
+            ? sessionTimeoutMin * 60 * 1000
+            : (sessionTimeoutMin === 0 ? 0 : DEFAULT_SESSION_TIMEOUT_MS);
+
+        // Map of conversationId → { session, timer|null }
+        this._sessions = new Map();
 
         const node = this;
 
+        // Destroy a single session entry and clear its idle timer.
+        async function destroySession(key) {
+            const entry = node._sessions.get(key);
+            if (!entry) return;
+            node._sessions.delete(key);
+            clearTimeout(entry.timer);
+            try { await entry.session.destroy(); } catch (_) { /* ignore */ }
+        }
+
+        // Arm (or re-arm) the idle timer for a session.
+        function armTimer(key) {
+            if (node.sessionTimeoutMs === 0) return null;
+            return setTimeout(() => destroySession(key), node.sessionTimeoutMs);
+        }
+
+        this.on('close', async (done) => {
+            const keys = [...node._sessions.keys()];
+            await Promise.all(keys.map(destroySession));
+            done();
+        });
+
         this.on('input', async function (msg, send, done) {
             // Support both old (1-arg send) and new (2-arg) Node-RED APIs
             send = send || function () { node.send.apply(node, arguments); };
             done = done || function (err) { if (err) { node.error(err, msg); } };
 
+            // Resolve the conversation key: msg > node config > node.id
+            const convKey = msg.conversationId || node.conversationId || node.id;
+
+            // msg.reset = true: destroy the session and swallow the message
+            if (msg.reset) {
+                await destroySession(convKey);
+                node.status({ fill: 'grey', shape: 'ring', text: 'reset' });
+                return done();
+            }
+
             node.status({ fill: 'blue', shape: 'dot', text: 'sending…' });
 
             // --- Resolve config node ---
@@ -83,14 +146,16 @@ module.exports = function (RED) {
                 prompt = msg.payload;
             } else if (msg.payload && typeof msg.payload === 'object') {
                 prompt = msg.payload.prompt || '';
-                rawAttachments = msg.payload.attachments || [];
+                const pa = msg.payload.attachments;
+                rawAttachments = Array.isArray(pa) ? pa : (pa ? [pa] : []);
             } else {
                 prompt = String(msg.payload || '');
             }
 
             // msg.attachments can supplement / override
-            if (Array.isArray(msg.attachments)) {
-                rawAttachments = rawAttachments.concat(msg.attachments);
+            const ma = msg.attachments;
+            if (ma) {
+                rawAttachments = rawAttachments.concat(Array.isArray(ma) ? ma : [ma]);
             }
 
             // Model can be overridden per-message
@@ -112,19 +177,26 @@ module.exports = function (RED) {
                 return done();
             }
 
-            // --- Build session config ---
-            const { approveAll } = await import('@github/copilot-sdk');
-            const sessionConfig = { model, onPermissionRequest: approveAll };
-            if (node.reasoningEffort) {
-                sessionConfig.reasoningEffort = node.reasoningEffort;
-            }
-
-            // --- Send to Copilot ---
+            // --- Get or create a session for this conversation ---
             let client;
             let session;
             try {
                 client = await configNode.getClient();
-                session = await client.createSession(sessionConfig);
+
+                let entry = node._sessions.get(convKey);
+                if (entry) {
+                    // Re-arm the idle timer and reuse the live session
+                    clearTimeout(entry.timer);
+                    entry.timer = armTimer(convKey);
+                    session = entry.session;
+                } else {
+                    const { approveAll } = await import('@github/copilot-sdk');
+                    const sessionConfig = { model, onPermissionRequest: approveAll };
+                    if (node.reasoningEffort) sessionConfig.reasoningEffort = node.reasoningEffort;
+                    session = await client.createSession(sessionConfig);
+                    const timer = armTimer(convKey);
+                    node._sessions.set(convKey, { session, timer });
+                }
 
                 const messageOptions = { prompt };
                 if (sdkAttachments.length > 0) {
@@ -137,21 +209,19 @@ module.exports = function (RED) {
                 const response = await session.sendAndWait(messageOptions, node.timeout);
 
                 cleanupTempFiles(tempFiles);
-                await session.destroy();
 
                 const responseText = response ? response.data.content : '';
                 node.status({ fill: 'green', shape: 'dot', text: 'done' });
 
                 msg.payload = responseText;
-                msg.sessionId = session.sessionId;
+                msg.conversationId = convKey;
                 msg.events = events;
                 send([msg, null]);
                 done();
             } catch (err) {
                 cleanupTempFiles(tempFiles);
-                if (session) {
-                    try { await session.destroy(); } catch (_) { /* ignore */ }
-                }
+                // On error, discard the session so the next message starts fresh
+                await destroySession(convKey);
                 node.status({ fill: 'red', shape: 'ring', text: 'error' });
                 send([null, { payload: err.message, error: err, _msgid: msg._msgid }]);
                 done();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-copilot",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Node-RED nodes for GitHub Copilot via @github/copilot-sdk",
   "license": "ISC",
   "author": "George Talusan",