@adobe/llm-apps-runtime 0.2.0

package/src/index.js

@@ -0,0 +1,350 @@
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * @adobe/llm-apps-runtime
+ *
+ * Creates an Adobe I/O Runtime main() function for an Adobe LLM Apps server.
+ *
+ * Usage in consumer app entry.js (webpack entry):
+ *
+ *   const { createMain } = require('@adobe/llm-apps-runtime')
+ *
+ *   const moduleContext = require.context('./actions', true, /index\.js$/)
+ *   const htmlContext   = require.context('./actions', true, /widget\.html$/)
+ *   let actionsConfig = {}
+ *   try { actionsConfig = require('./actions.json') } catch (e) {}
+ *
+ *   module.exports = createMain({ moduleContext, htmlContext, actionsConfig })
+ *
+ * Usage in Jest tests (fs-based, no webpack):
+ *
+ *   const { createMain } = require('@adobe/llm-apps-runtime')
+ *   const { main } = createMain({ actionsDir: path.join(__dirname, '..', 'actions') })
+ */
+
+const { Core } = require('@adobe/aio-sdk')
+const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp')
+const { WebStandardStreamableHTTPServerTransport } = require('@modelcontextprotocol/sdk/server/webStandardStreamableHttp')
+const {
+    resolveActions,
+    registerAction,
+    // re-exported as public API
+    loadActionsFromContexts,
+    loadActionsFromFs,
+    loadActionsConfig
+} = require('./loader.js')
+const { createBuffer, readAnalyticsConfig } = require('./analytics.js')
+const crypto = require('crypto')
+const path = require('path')
+
+if (!global.crypto) {
+    global.crypto = crypto
+}
+
+/**
+ * Create the Adobe I/O Runtime main() function for an Adobe LLM Apps server.
+ *
+ * @param {object} options
+ *   Webpack path (from entry.js):
+ *     moduleContext  {object}  webpack require.context for actions/..../index.js
+ *     htmlContext    {object}  webpack require.context for actions/..../widget.html
+ *     actionsConfig  {object}  parsed actions.json keyed by action name
+ *   Fs path (Jest / plain Node):
+ *     actionsDir     {string}  absolute path to the actions/ directory
+ *   Common:
+ *     serverName     {string}  MCP server name (default: 'adobe-llm-apps')
+ *     serverVersion  {string}  MCP server version (default: '1.0.0')
+ *
+ * @returns {{ main: Function }}
+ */
+function createMain (options = {}) {
+    const serverName = options.serverName || 'adobe-llm-apps'
+    const serverVersion = options.serverVersion || '1.0.0'
+
+    let logger = null
+
+    // Resolve actions once at startup (cold start). Logs fire here.
+    // Per-request server creation reuses this resolved list silently.
+    const resolvedActions = resolveActions(options)
+
+    function createMcpServer (analyticsConfig) {
+        const server = new McpServer(
+            { name: serverName, version: serverVersion },
+            { capabilities: { logging: {}, tools: {}, resources: {} } }
+        )
+
+        for (const { name, action, widgetHtml, config } of resolvedActions) {
+            registerAction(server, name, action, widgetHtml, config, analyticsConfig)
+        }
+
+        return server
+    }
+
+    function parseRequestBody (params) {
+        if (!params.__ow_body) return null
+
+        try {
+            if (typeof params.__ow_body === 'string') {
+                try {
+                    const decoded = Buffer.from(params.__ow_body, 'base64').toString('utf8')
+                    return JSON.parse(decoded)
+                } catch (e) {
+                    return JSON.parse(params.__ow_body)
+                }
+            }
+            return params.__ow_body
+        } catch (error) {
+            logger?.error('Failed to parse request body:', error)
+            throw new Error(`Failed to parse request body: ${error.message}`)
+        }
+    }
+
+    function handleHealthCheck () {
+        return {
+            statusCode: 200,
+            headers: {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS, DELETE',
+                'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization, x-api-key, mcp-session-id, Last-Event-ID',
+                'Access-Control-Expose-Headers': 'Content-Type, mcp-session-id, Last-Event-ID',
+                'Access-Control-Max-Age': '86400',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                status: 'healthy',
+                server: serverName,
+                version: serverVersion,
+                description: 'Adobe I/O Runtime Adobe LLM Apps Server',
+                timestamp: new Date().toISOString(),
+                transport: 'StreamableHTTP',
+                sdk: '@modelcontextprotocol/sdk'
+            })
+        }
+    }
+
+    function handleOptionsRequest () {
+        return {
+            statusCode: 200,
+            headers: {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS, DELETE',
+                'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization, x-api-key, mcp-session-id, Last-Event-ID',
+                'Access-Control-Expose-Headers': 'Content-Type, mcp-session-id, Last-Event-ID',
+                'Access-Control-Max-Age': '86400'
+            },
+            body: ''
+        }
+    }
+
+    /**
+     * Best-effort flush of the per-invocation analytics buffer. Errors are
+     * swallowed so analytics failure can never break an MCP response. The
+     * underlying flush() also enforces a tight timeout and circuit breaker.
+     */
+    async function flushAnalyticsSafe (analyticsConfig) {
+        if (!analyticsConfig || !analyticsConfig.buffer) return
+        try {
+            const result = await analyticsConfig.buffer.flush(analyticsConfig)
+            if (result && result.ok) {
+                logger?.info(`Analytics flushed: sent=${result.sent} dropped=${result.dropped || 0}`)
+            } else if (result && !result.ok) {
+                logger?.warn(`Analytics flush did not succeed: ${result.skipped || result.error || result.status}`)
+            }
+        } catch (e) {
+            logger?.warn(`Analytics flush threw: ${e.message}`)
+        }
+    }
+
+    async function handleMcpRequest (params) {
+        // Per-request analytics config + buffer. If config is null
+        // (unconfigured deploy or no enabled actions) the wrapper short-circuits
+        // to a no-op so unconfigured deploys cost zero overhead.
+        const cfg = readAnalyticsConfig(params)
+        const analyticsConfig = cfg ? { ...cfg, buffer: createBuffer({ logger }) } : null
+
+        const server = createMcpServer(analyticsConfig)
+
+        try {
+            logger?.info('Creating fresh MCP server and transport')
+
+            const body = parseRequestBody(params)
+            logger?.info('Request method:', body?.method)
+
+            const url = `https://${params.__ow_headers?.host || 'localhost'}/mcp-server`
+            const request = new Request(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...params.__ow_headers
+                },
+                body: JSON.stringify(body)
+            })
+
+            const transport = new WebStandardStreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                enableJsonResponse: true
+            })
+
+            await server.connect(transport)
+
+            const response = await transport.handleRequest(request)
+
+            const responseBody = await response.text()
+            const responseHeaders = {}
+            response.headers.forEach((value, key) => {
+                responseHeaders[key] = value
+            })
+
+            logger?.info('MCP request processed by SDK')
+
+            await flushAnalyticsSafe(analyticsConfig)
+
+            return {
+                statusCode: response.status,
+                headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS, DELETE',
+                    'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization, x-api-key, mcp-session-id, Last-Event-ID',
+                    'Access-Control-Expose-Headers': 'Content-Type, mcp-session-id, Last-Event-ID',
+                    ...responseHeaders
+                },
+                body: responseBody
+            }
+        } catch (error) {
+            logger?.error('Error in handleMcpRequest:', error)
+
+            try { server.close() } catch (e) { /* ignore cleanup errors */ }
+
+            // Flush whatever we managed to buffer before the failure so
+            // partial telemetry isn't lost on the error path.
+            await flushAnalyticsSafe(analyticsConfig)
+
+            return {
+                statusCode: 500,
+                headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    error: { code: -32603, message: `Internal server error: ${error.message}` },
+                    id: null
+                })
+            }
+        }
+    }
+
+    async function main (params) {
+        try {
+            console.log('=== Adobe LLM Apps Server ===')
+            console.log('Method:', params.__ow_method)
+
+            try {
+                logger = Core.Logger(serverName, { level: params.LOG_LEVEL || 'info' })
+            } catch (loggerError) {
+                console.error('Logger creation error:', loggerError)
+                return {
+                    statusCode: 500,
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ error: `Logger creation error: ${loggerError.message}` })
+                }
+            }
+
+            logger.info('Adobe LLM Apps Server started')
+            logger.info(`Request method: ${params.__ow_method}`)
+
+            const incomingHeaders = {}
+            if (params.__ow_headers) {
+                for (const key in params.__ow_headers) {
+                    incomingHeaders[key.toLowerCase()] = params.__ow_headers[key]
+                }
+            }
+
+            switch (params.__ow_method?.toLowerCase()) {
+            case 'get':
+                if (incomingHeaders.accept && incomingHeaders.accept.includes('text/event-stream')) {
+                    logger.info('SSE stream requested — not supported in serverless')
+                    return {
+                        statusCode: 200,
+                        headers: {
+                            'Access-Control-Allow-Origin': '*',
+                            'Content-Type': 'text/event-stream',
+                            'Cache-Control': 'no-cache',
+                            Connection: 'close'
+                        },
+                        body: 'event: error\ndata: {"error": "SSE not supported in serverless. Use HTTP transport."}\n\n'
+                    }
+                }
+                logger.info('Health check request')
+                return handleHealthCheck()
+
+            case 'options':
+                logger.info('CORS preflight request')
+                return handleOptionsRequest()
+
+            case 'post':
+                logger.info('MCP protocol request - delegating to SDK')
+                return await handleMcpRequest(params)
+
+            default:
+                logger.warn(`Method not allowed: ${params.__ow_method}`)
+                return {
+                    statusCode: 405,
+                    headers: {
+                        'Access-Control-Allow-Origin': '*',
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32000,
+                            message: `Method '${params.__ow_method}' not allowed. Supported: GET, POST, OPTIONS`
+                        },
+                        id: null
+                    })
+                }
+            }
+        } catch (error) {
+            if (logger) {
+                logger.error('Uncaught error in main:', error)
+            } else {
+                console.error('Uncaught error in main:', error)
+            }
+
+            return {
+                statusCode: 500,
+                headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    error: { code: -32603, message: `Unhandled server error: ${error.message}` },
+                    id: null
+                })
+            }
+        }
+    }
+
+    return { main }
+}
+
+const { createLocalServer } = require('./local')
+
+module.exports = {
+    createMain,
+    createLocalServer,
+    loadActionsFromContexts,
+    loadActionsFromFs,
+    loadActionsConfig
+}