@flowfuse/nr-assistant 0.6.1-f8348b5-202509051340.0 → 0.6.1-fd37d56-202512091447.0

package/lib/assistant.js

@@ -2,6 +2,7 @@
 'use strict'
 
 const { z } = require('zod')
+const auth = require('./auth')
 const { getLongestUpstreamPath } = require('./flowGraph')
 const { hasProperty } = require('./utils')
 const semver = require('semver')
@@ -23,6 +24,7 @@ class Assistant {
         this.options = null
         this._loading = false // Flag to indicate if the Assistant is currently loading
         this._enabled = false // Flag to indicate if the Assistant is enabled
+        this._adminRoutesInitialized = false
 
         // MCP Client and Server and associated properties
         /** @type {import('@modelcontextprotocol/sdk/client/index.js').Client} */
@@ -54,38 +56,60 @@ class Assistant {
      */
     async init (RED, options = {}) {
         if (this._loading) {
-            RED.log.debug('FlowFuse Assistant is busy loading')
+            this.RED.log.debug('FlowFuse Expert is busy loading')
             return
         }
-        try {
-            this._loading = true // Set loading to true when initializing
-            await this.dispose() // Dispose of any existing instance before initializing a new one
-            this.RED = RED
-            this.options = options || {}
-            this.got = this.options.got || require('got') // got can be passed in for testing purposes
-
+        const wasStandaloneEnabled = !!this.options?.standalone && this.options?.enabled
+        await this.dispose() // Dispose of any existing instance before initializing a new one
+        this.RED = RED
+        this.options = options || {}
+        this.got = this.options.got || require('got') // got can be passed in for testing purposes
+
+        if (this.options.standalone) {
+            if (wasStandaloneEnabled && !this.options.enabled) {
+                // The assistant was previously enabled in standalone mode, but is now disabled (auth issue).
+                this.RED.log.info('FlowFuse Expert Plugin has been disabled')
+                RED.comms.publish('nr-assistant/mcp/ready', { enabled: false }, true /* retain */)
+                RED.comms.publish('nr-assistant/completions/ready', { enabled: false }, true /* retain */)
+            } else {
+                this.RED.log.info('FlowFuse Expert Plugin is running in standalone mode')
+            }
+            this.initAdminAuthEndpoints(RED)
+        } else {
             if (!this.options.enabled) {
-                RED.log.info('FlowFuse Assistant Plugin is not enabled')
+                RED.log.info('FlowFuse Expert Plugin is not enabled')
                 return
             }
             if (!this.options.url || !this.options.token) {
-                RED.log.warn('FlowFuse Assistant Plugin configuration is missing required options')
+                RED.log.warn('FlowFuse Expert Plugin configuration is missing required options')
                 throw new Error('Plugin configuration is missing required options')
             }
+        }
+        const clientSettings = {
+            enabled: this.options.enabled !== false && !!this.options.url,
+            tablesEnabled: this.options.tables?.enabled === true,
+            inlineCompletionsEnabled: this.options.completions?.inlineEnabled === true,
+            requestTimeout: this.options.requestTimeout || 60000
+        }
+        if (this.options.standalone) {
+            clientSettings.standalone = true
+        }
+        RED.comms.publish('nr-assistant/initialise', clientSettings, true /* retain */)
 
+        if (this.options.enabled) {
+            await this.completeInitialization(clientSettings)
+        }
+    }
+
+    async completeInitialization (clientSettings) {
+        const RED = this.RED
+        try {
+            this._loading = true // Set loading to true when initializing
             const nrVersion = this.RED.version()
             const nrMajorVersion = semver.major(nrVersion)
             const nrMinorVersion = semver.minor(nrVersion)
             const nodeMajorVersion = semver.major(process.versions.node)
 
-            const clientSettings = {
-                enabled: this.options.enabled !== false && !!this.options.url,
-                tablesEnabled: this.options.tables?.enabled === true,
-                inlineCompletionsEnabled: this.options.completions?.inlineEnabled === true,
-                requestTimeout: this.options.requestTimeout || 60000
-            }
-            RED.comms.publish('nr-assistant/initialise', clientSettings, true /* retain */)
-
             // ### Initialise Model Context Protocol (MCP)
             // TODO: If "feature" is disabled, skip loading MCP. See issue #57
             this.options.mcp = this.options.mcp || { enabled: true }
@@ -99,19 +123,19 @@ class Assistant {
                     this.mcpReady = true
                     // tell frontend that the MCP client is ready so it can add the action(s) to the Action List
                     RED.comms.publish('nr-assistant/mcp/ready', clientSettings, true /* retain */)
-                    RED.log.info('FlowFuse Assistant Model Context Protocol (MCP) loaded')
+                    RED.log.info('FlowFuse Expert Model Context Protocol (MCP) loaded')
                 } catch (error) {
                     this.mcpReady = false
                     // ESM Support in Node 20 is much better than versions v18-, so lets include a node version
                     // Write a warning to log as a hint/prompt
                     // NOTE: Node 18 is EOL as of writing this
-                    RED.log.warn('FlowFuse Assistant MCP could not be loaded. Assistant features that require MCP will not be available')
+                    RED.log.warn('FlowFuse Expert MCP could not be loaded. Expert features that require MCP will not be available')
                     if (nodeMajorVersion < 20) {
                         RED.log.debug(`Node.js version ${nodeMajorVersion} may not be supported by MCP Client / Server.`)
                     }
                 }
             } else if (!mcpFeatureEnabled) {
-                RED.log.info('FlowFuse Assistant MCP is disabled')
+                RED.log.info('FlowFuse Expert MCP is disabled')
             }
 
             // ### Initialise completions (depends on MCP so checks the mcpReady flag)
@@ -122,9 +146,9 @@ class Assistant {
             const completionsEnabled = completionsFeatureEnabled && this.isInitialized && this.isEnabled
 
             if (!completionsSupported) {
-                RED.log.warn('FlowFuse Assistant Completions require Node-RED 4.1 or greater')
+                RED.log.warn('FlowFuse Expert Completions require Node-RED 4.1 or greater')
             } else if (!completionsFeatureEnabled) {
-                RED.log.info('FlowFuse Assistant Completions are disabled')
+                RED.log.info('FlowFuse Expert Completions are disabled')
             } else if (this.mcpReady && completionsEnabled && completionsSupported) {
                 // if modelUrl is not set, use the default model URL from this.options.url + 'assets/completions/model.onnx'
                 this.options.completions.modelUrl = this.options.completions.modelUrl || new URL('assets/completions/model.onnx', this.options.url).href
@@ -134,21 +158,21 @@ class Assistant {
                 // RED.events.once('comms:message:nr-assistant/completions/load', async (opts) => {
                 RED.events.once('comms:message:nr-assistant/completions/load', async (opts) => {
                     try {
-                        RED.log.info('FlowFuse Assistant is Loading Advanced Completions...')
+                        RED.log.info('FlowFuse Expert is Loading Advanced Completions...')
                         await this.loadCompletions()
                         RED.comms.publish('nr-assistant/completions/ready', { enabled: true }, true /* retain */)
-                        RED.log.info('FlowFuse Assistant Completions Loaded')
+                        RED.log.info('FlowFuse Expert Completions Loaded')
                         this.completionsReady = true
                     } catch (error) {
                         this.completionsReady = false
-                        RED.log.warn('FlowFuse Assistant Advanced Completions could not be loaded.') // degraded functionality
+                        RED.log.warn('FlowFuse Expert Advanced Completions could not be loaded.') // degraded functionality
                         RED.log.debug(`Completions loading error: ${error.message}`)
                     }
                 })
             }
-            this.initAdminEndpoints(RED, { inlineCompletionsEnabled: clientSettings.inlineCompletionsEnabled }) // Initialize the admin endpoints for the Assistant
+            this.initAdminEndpoints(RED) // Initialize the admin endpoints for the Assistant
             const degraded = (mcpEnabled && !this.mcpReady)
-            RED.log.info('FlowFuse Assistant Plugin loaded' + (degraded ? ' (reduced functionality)' : ''))
+            RED.log.info('FlowFuse Expert Plugin loaded' + (degraded ? ' (reduced functionality)' : ''))
         } finally {
             this._loading = false // Set loading to false when initialization is complete
         }
@@ -190,7 +214,14 @@ class Assistant {
         if (!this.options) {
             return false
         }
-        return !!(this.options.enabled && this.options.url && this.options.token)
+        return !!(
+            this.options.enabled &&
+            this.options.url &&
+            (
+                (!this.options.standalone && this.options.token) ||
+                (this.options.standalone && auth.getUserToken())
+            )
+        )
     }
 
     async loadCompletions () {
@@ -209,7 +240,7 @@ class Assistant {
         const response = await this.got(url, {
             responseType: 'json',
             headers: {
-                Authorization: `Bearer ${this.options.token}`,
+                Authorization: `Bearer ${auth.getUserToken()}`,
                 'User-Agent': FF_ASSISTANT_USER_AGENT
             }
         })
@@ -247,7 +278,7 @@ class Assistant {
         try {
             const response = await this.got(url, {
                 headers: {
-                    Authorization: `Bearer ${this.options.token}`,
+                    Authorization: `Bearer ${auth.getUserToken()}`,
                     'User-Agent': FF_ASSISTANT_USER_AGENT
                 },
                 responseType: 'buffer' // Ensure we get raw binary
@@ -410,7 +441,7 @@ class Assistant {
 
     // #region Admin Endpoints & HTTP Handlers
 
-    initAdminEndpoints (RED, { inlineCompletionsEnabled }) {
+    initAdminEndpoints (RED) {
         // Hook up routes first ordered by static --> specific --> generic
 
         RED.httpAdmin.get('/nr-assistant/mcp/prompts', RED.auth.needsPermission('write'), async function (req, res) {
@@ -425,17 +456,23 @@ class Assistant {
             return assistant.handlePostToolRequest(req, res)
         })
 
-        if (inlineCompletionsEnabled) {
-            RED.httpAdmin.post('/nr-assistant/fim/:nodeModule/:nodeType', RED.auth.needsPermission('write'), function (req, res) {
-                return assistant.handlePostFimRequest(req, res)
-            })
-        }
+        RED.httpAdmin.post('/nr-assistant/fim/:nodeModule/:nodeType', RED.auth.needsPermission('write'), function (req, res) {
+            return assistant.handlePostFimRequest(req, res)
+        })
 
         RED.httpAdmin.post('/nr-assistant/:method', RED.auth.needsPermission('write'), function (req, res) {
             return assistant.handlePostMethodRequest(req, res)
         })
     }
 
+    initAdminAuthEndpoints (RED) {
+        if (!this._adminRoutesInitialized) {
+            // Only required in standalone mode
+            auth.setupRoutes(this, RED)
+            this._adminRoutesInitialized = true
+        }
+    }
+
     /**
      * Handles POST requests to the /nr-assistant/:method endpoint.
      * This is for handling custom methods that the Assistant can perform.
@@ -471,7 +508,7 @@ class Assistant {
             headers: {
                 Accept: '*/*',
                 'Accept-Language': 'en-GB,en-US;q=0.9,en;q=0.8,es;q=0.7',
-                Authorization: `Bearer ${this.options.token}`,
+                Authorization: `Bearer ${auth.getUserToken()}`,
                 'Content-Type': 'application/json',
                 'User-Agent': FF_ASSISTANT_USER_AGENT
             },
@@ -491,7 +528,7 @@ class Assistant {
                     // ignore
                 }
             }
-            let message = 'FlowFuse Assistant request was unsuccessful'
+            let message = 'FlowFuse Expert request was unsuccessful'
             const errorData = { status: 'error', message, body }
             const errorCode = (error.response && error.response.statusCode) || 500
             res.status(errorCode).json(errorData)
@@ -511,7 +548,10 @@ class Assistant {
      */
     async handlePostFimRequest (req, res) {
         if (!this.isInitialized || this.isLoading) {
-            return res.status(503).send('Assistant is not ready')
+            return res.status(503).send('Expert is not ready')
+        }
+        if (this.options.completions?.inlineEnabled !== true) {
+            return res.status(400).send('Inline completions are not enabled')
         }
 
         const nodeModule = req.params.nodeModule
@@ -544,7 +584,7 @@ class Assistant {
             headers: {
                 Accept: '*/*',
                 'Accept-Language': 'en-GB,en-US;q=0.9,en;q=0.8,es;q=0.7',
-                Authorization: `Bearer ${this.options.token}`,
+                Authorization: `Bearer ${auth.getUserToken()}`,
                 'Content-Type': 'application/json',
                 'User-Agent': FF_ASSISTANT_USER_AGENT
             },
@@ -557,7 +597,7 @@ class Assistant {
             })
         }).catch((_error) => {
             // fim requests are inline completion opportunities - lets not complain if they fail
-            const message = 'FlowFuse Assistant FIM request was unsuccessful'
+            const message = 'FlowFuse Expert FIM request was unsuccessful'
             this.RED.log.trace(message, _error)
         })
     }
@@ -636,7 +676,7 @@ class Assistant {
                 headers: {
                     Accept: '*/*',
                     'Accept-Language': 'en-GB,en-US;q=0.9,en;q=0.8,es;q=0.7',
-                    Authorization: `Bearer ${this.options.token}`,
+                    Authorization: `Bearer ${auth.getUserToken()}`,
                     'Content-Type': 'application/json'
                 },
                 json: body

package/lib/auth/index.js

@@ -0,0 +1,277 @@
+const crypto = require('node:crypto')
+const path = require('node:path')
+const { readFile, writeFile } = require('node:fs/promises')
+const { existsSync } = require('node:fs')
+
+const base64url = require('base64url')
+const store = require('./store')
+const got = require('got').default
+let baseURL = 'https://app.flowfuse.com'
+const authorizationURL = () => `${baseURL}/account/authorize`
+const tokenURL = () => `${baseURL}/account/token`
+
+let activeTokens = { }
+const activeTimers = { }
+let assistant = null
+let tokenFile
+let RED
+
+/**
+ * Initialise the auth handling for standalone FF Assistant mode
+ * @param {*} _RED
+ */
+async function init (_RED) {
+    RED = _RED
+    baseURL = RED.settings.flowfuse?.assistant?.url || 'https://app.flowfuse.com'
+    tokenFile = path.join(RED.settings.userDir, '.flowfuse-assistant.json')
+    if (existsSync(tokenFile)) {
+        try {
+            const data = await readFile(tokenFile, 'utf8')
+            if (data) {
+                activeTokens = JSON.parse(data)
+                // We currently only support a single user '_'
+                const token = activeTokens._
+                if (!token || token.expires_at < Date.now()) {
+                    RED.log.info('FlowFuse Assistant: access has expired, please log in again')
+                    await deleteUserToken('_')
+                } else {
+                    setupRefreshTimer('_')
+                }
+            }
+        } catch (err) {
+            RED.log.error('FlowFuse Assistant: Failed to load access tokens')
+        }
+    }
+}
+
+/**
+ * Write tokens to file
+ */
+async function saveTokens () {
+    await writeFile(tokenFile, JSON.stringify(activeTokens), 'utf8')
+}
+
+/**
+ * Update a user token, setup refresh timer and save to file
+ * @param {*} user
+ * @param {*} token
+ */
+async function setUserToken (user, token) {
+    activeTokens[user] = token
+    setupRefreshTimer(user)
+    await saveTokens()
+}
+
+/**
+ * Setup the refresh timer for the token. User tokens have a relatively short expiry time, but can be refreshed before expiry
+ * to provide a longer session.
+ * @param {*} user
+ */
+function setupRefreshTimer (user) {
+    const token = activeTokens[user]
+    if (!token.expires_at) {
+        token.expires_at = Date.now() + (token.expires_in * 1000)
+    }
+    const refreshInterval = token.expires_at - Date.now() - 10000 // refresh with 10 secs to spare
+    if (refreshInterval > 0) {
+        activeTimers[user] = setTimeout(async () => {
+            try {
+                const newTokens = await refreshToken(token)
+                newTokens.expires_at = Date.now() + (newTokens.expires_in * 1000)
+                await setUserToken(user, newTokens)
+            } catch (err) {
+                // Failed to refresh token - remove it and disable the agent
+                await deleteUserToken(user)
+                assistant.RED.log.warn('Failed to refresh FlowFuse Assistant access token')
+                reinitialiseAssistant()
+            }
+        }, refreshInterval)
+    }
+}
+
+/**
+ * When running in a managed FF environment, the tokens are provided statically via settings.
+ * This is used to insert the token into the auth table so we have a single place to retrieve
+ * tokens from.
+ * @param {*} token
+ */
+function setStaticToken (token) {
+    // A token provided by settings file - does not need refresh logic
+    activeTokens._ = {
+        access_token: token
+    }
+}
+
+/**
+ * Get the current user token
+ */
+function getUserToken () {
+    // Only single shared user supported currently
+    return activeTokens._?.access_token
+}
+
+/**
+ * Delete a users token, clears up refresh timers and updates saved tokens
+ * @param {*} user
+ */
+async function deleteUserToken (user) {
+    const token = activeTokens[user]
+    if (token) {
+        clearTimeout(activeTimers[user])
+    }
+    delete activeTokens[user]
+    delete activeTimers[user]
+    saveTokens()
+}
+
+/**
+ * Make an API request to refresh the user token
+ * @param {*} token
+ */
+async function refreshToken (token) {
+    const params = {
+        grant_type: 'refresh_token',
+        client_id: 'ff-plugin',
+        refresh_token: token.refresh_token
+    }
+    return got.post(tokenURL(), {
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        json: params
+    }).then(async (result) => {
+        return JSON.parse(result.body)
+    })
+}
+
+function setupRoutes (_assistant, RED) {
+    assistant = _assistant
+    RED.httpAdmin.get('/nr-assistant/auth/authorize', (request, response) => {
+        const existingRequest = store.getRequest(request.query.s)
+        if (!existingRequest) {
+            return response.send(404)
+        }
+        const verifier = base64url(crypto.randomBytes(32))
+        const scope = 'ff-assistant'
+        store.storeRequest({ ...existingRequest, verifier, scope })
+        const params = {}
+        params.client_id = 'ff-plugin'
+        params.scope = scope
+        params.response_type = 'code'
+        params.state = existingRequest.state
+        params.code_challenge = base64url(crypto.createHash('sha256').update(verifier).digest())
+        params.code_challenge_method = 'S256'
+        params.redirect_uri = existingRequest.redirect_uri
+        const authURL = new URL(authorizationURL())
+        authURL.search = new URLSearchParams(params)
+        response.redirect(authURL.toString())
+    })
+
+    RED.httpAdmin.get('/nr-assistant/auth/callback', async (request, response) => {
+        if (request.query.error) {
+            const postMessage = JSON.stringify({ code: 'flowfuse-auth-error', error: request.query.error, message: request.query.errorDescription })
+            response.send(`
+<html><head>
+<script>
+if (window.opener) {
+    window.opener.postMessage('${postMessage}', '*')
+    window.close()
+}
+</script>
+</head><body>Failed to complete authentication.</body></html>            
+`)
+            return
+        }
+        if (!request.query.code || !request.query.state) {
+            response.send('Failed to complete authentication')
+            return
+        }
+        const originalRequest = store.getRequest(request.query.state)
+        if (!originalRequest) {
+            response.send('Failed to complete authentication - unknown state')
+            return
+        }
+
+        const params = {}
+        params.grant_type = 'authorization_code'
+        params.code = request.query.code
+        params.redirect_uri = originalRequest.redirect_uri
+        params.client_id = 'ff-plugin'
+        params.code_verifier = originalRequest.verifier
+
+        got.post(tokenURL(), {
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            json: params
+        }).then(async (result) => {
+            const tokens = JSON.parse(result.body)
+            await setUserToken(originalRequest.user, tokens)
+            const postMessage = JSON.stringify({ code: 'flowfuse-auth-complete', state: originalRequest.state })
+            response.send(`
+<html><head>
+<script>
+if (window.opener) {
+    window.opener.postMessage('${postMessage}', '*')
+    window.close()
+}
+</script>
+</head><body>Success! You're connected to FlowFuse. You can now close this window to continue.</body></html>            
+`)
+            // Now we have a token for the user, reinitialise the assistant to enable it
+            reinitialiseAssistant()
+        }).catch((error) => {
+            console.warn('request failed', error)
+        })
+    })
+
+    RED.httpAdmin.use('/nr-assistant/*', RED.auth.needsPermission('flowfuse.write'))
+
+    RED.httpAdmin.post('/nr-assistant/auth/start', async (request, response) => {
+        // This request is made from the editor, so will have the Node-RED user attached.
+        // Generate the login url for the auth pop-up window
+        // if (request.body.forgeURL) {
+        //     request.body.forgeURL = request.body.forgeURL.replace(/\/$/, '')
+        //     settings.set('forgeURL', request.body.forgeURL)
+        // }
+
+        // Ping the server to check it is responsive and looks like a valid FF endpoint
+        got.get(`${baseURL}/api/v1/settings`).then(result => {
+            const state = base64url(crypto.randomBytes(16))
+            const redirect = request.body.editorURL + (request.body.editorURL.endsWith('/') ? '' : '/') + 'nr-assistant/auth/callback'
+            store.storeRequest({
+                user: '_',
+                state,
+                redirect_uri: redirect
+            })
+            const authPath = 'nr-assistant/auth/authorize?s=' + state
+            response.send({ path: authPath, state })
+        }).catch(err => {
+            RED.log.error(`[nr-assistant] Failed to connect to server: ${err.toString()}`)
+            response.send({ error: err.toString(), code: 'connect_failed' })
+        })
+    })
+    RED.httpAdmin.post('/nr-assistant/auth/disconnect', async (request, response) => {
+        deleteUserToken('_')
+        response.send({ })
+    })
+}
+
+async function reinitialiseAssistant () {
+    if (assistant && assistant.RED) {
+        const newSettings = await require('../settings').getSettings(assistant.RED)
+        assistant.init(assistant.RED, newSettings).then(() => {
+            // All good, the assistant is initialized.
+            // Any info messages made during initialization are logged in the assistant module
+        }).catch((error) => {
+            console.error(error)
+            assistant.RED.log.error('Failed to initialize FlowFuse Assistant Plugin:', error)
+        })
+    }
+}
+module.exports = {
+    init,
+    setupRoutes,
+    getUserToken,
+    setStaticToken
+}

package/lib/auth/store.js

@@ -0,0 +1,33 @@
+const pendingRequests = {}
+
+function storeRequest (request) {
+    pruneRequests()
+    request.ttl = Date.now() + 1000 * 60 * 5 // 5 minute ttl
+    pendingRequests[request.state] = request
+}
+function getRequest (state) {
+    pruneRequests()
+    const result = pendingRequests[state]
+    delete pendingRequests[state]
+    return result
+}
+
+function deleteRequest (state) {
+    pruneRequests()
+    delete pendingRequests[state]
+}
+function pruneRequests () {
+    const now = Date.now()
+    for (const [key, value] of Object.entries(pendingRequests)) {
+        if (value.ttl < now) {
+            delete pendingRequests[key]
+        }
+    }
+}
+
+module.exports = {
+    getRequest,
+    storeRequest,
+    deleteRequest,
+    export: () => { return { ...pendingRequests } }
+}

package/lib/settings.js

@@ -1,3 +1,5 @@
+const auth = require('./auth/index.js')
+
 /**
  * @typedef {Object} AssistantSettings
  * @property {boolean} enabled - Whether the Assistant is enabled
@@ -20,26 +22,61 @@ module.exports = {
      * @param {Object} RED - The RED instance
      * @returns {AssistantSettings} - The Assistant settings
      */
-    getSettings: (RED) => {
-        const assistantSettings = (RED.settings.flowforge && RED.settings.flowforge.assistant) || {}
-        if (assistantSettings.enabled !== true) {
-            assistantSettings.enabled = false
-            assistantSettings.completions = null // if the assistant is not enabled, completions should not be enabled
-        }
-        assistantSettings.mcp = assistantSettings.mcp || {
-            enabled: true // default to enabled
-        }
-        assistantSettings.completions = assistantSettings.completions || {
-            enabled: true, // default to enabled
-            modelUrl: null,
-            vocabularyUrl: null
-        }
-        assistantSettings.tables = {
-            enabled: !!(RED.settings.flowforge?.tables?.token) // for MVP, use the presence of a token is an indicator that tables are enabled
-        }
-        assistantSettings.inlineCompletions = {
-            enabled: !!assistantSettings.completions.inlineEnabled
+    getSettings: async (RED) => {
+        if (RED.settings.flowforge?.assistant === undefined) {
+            // No settings provided via settings.js; enable standalone mode
+            const token = auth.getUserToken()
+            if (token) {
+                // There is a locally stored token, so enable the assistant with default settings
+                const baseURL = RED.settings.flowfuse?.assistant?.url || 'https://app.flowfuse.com'
+                return {
+                    url: baseURL + '/api/v1/assistant/',
+                    enabled: true,
+                    standalone: true,
+                    mcp: { enabled: true },
+                    completions: {
+                        enabled: true,
+                        // TODO: what should these be?
+                        modelUrl: null,
+                        vocabularyUrl: null,
+                        inlineEnabled: true
+                    },
+                    // Tables is not available outside of FF
+                    tables: { enabled: false },
+                    inlineCompletions: { enabled: true }
+                }
+            } else {
+                // Not token, disable the assistant but in standalone mode
+                return {
+                    enabled: false,
+                    standalone: true
+                }
+            }
+        } else {
+            const assistantSettings = RED.settings.flowforge?.assistant || {}
+            if (assistantSettings.enabled !== true) {
+                assistantSettings.enabled = false
+                assistantSettings.completions = null // if the assistant is not enabled, completions should not be enabled
+            }
+            assistantSettings.mcp = assistantSettings.mcp || {
+                enabled: true // default to enabled
+            }
+            assistantSettings.completions = assistantSettings.completions || {
+                enabled: true, // default to enabled
+                modelUrl: null,
+                vocabularyUrl: null
+            }
+            assistantSettings.tables = {
+                enabled: !!(RED.settings.flowforge?.tables?.token) // for MVP, use the presence of a token is an indicator that tables are enabled
+            }
+            assistantSettings.inlineCompletions = {
+                enabled: !!assistantSettings.completions.inlineEnabled
+            }
+
+            if (assistantSettings.token) {
+                auth.setStaticToken(assistantSettings.token)
+            }
+            return assistantSettings
         }
-        return assistantSettings
     }
 }