@x12i/ai-gateway 10.4.4 → 11.0.0

package/dist-cjs/message-builder.cjs

@@ -5,19 +5,38 @@
  */
 import { parseTemplate } from './template-parser.js';
 import { mergeGatewayAndRequestTemplateRenderOptions } from './template-render-merge.js';
-// Type guard
-// AIRequest is distinguished by having primaryObjectType or objectTypes
-// ChatRequest does not have these fields
-function isAIRequest(request) {
-    return 'primaryObjectType' in request || ('objectTypes' in request && Array.isArray(request.objectTypes));
+function hasNonEmptyPrompt(prompt) {
+    return typeof prompt === 'string' && prompt.trim() !== '';
+}
+function getWorkingMemoryInput(workingMemory) {
+    if (workingMemory == null || typeof workingMemory !== 'object')
+        return undefined;
+    return workingMemory.input;
+}
+function hasResolvableInput(workingMemory) {
+    const input = getWorkingMemoryInput(workingMemory);
+    return input !== undefined && input !== null;
+}
+/**
+ * Serializes workingMemory.input when no prompt template is provided.
+ */
+export function formatInputFallback(input) {
+    if (input === undefined || input === null) {
+        return '';
+    }
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (typeof input === 'object') {
+        return JSON.stringify(input, null, 2);
+    }
+    return String(input);
 }
 /**
- * Builds user message (prompt + input)
+ * Builds user message from prompt template or workingMemory.input fallback.
  */
 async function buildUserMessage(request, config, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions) {
     const { logger } = config;
-    const parts = [];
-    // Validate that input field is not provided (removed - use workingMemory.input instead)
     if ('input' in request && request.input !== undefined) {
         const err = new Error(`The 'input' field has been removed. Use workingMemory.input instead for template rendering. Prompt templates should contain {{input}} which will be resolved from workingMemory.input.`);
         err.code = 'INPUT_FIELD_DEPRECATED';
@@ -32,213 +51,127 @@ async function buildUserMessage(request, config, shortTermMemory, experienceMemo
             errorCode: 'INPUT_FIELD_DEPRECATED',
             hasPrompt: !!request.prompt,
             hasWorkingMemory: !!request.workingMemory,
-            hasInputInWorkingMemory: !!request.workingMemory?.input
+            hasInputInWorkingMemory: hasResolvableInput(request.workingMemory)
         });
         throw err;
     }
-    // Determine if we have user content to process (prompt is required for user message)
-    const hasUserContent = isAIRequest(request) && request.prompt;
-    // Input prefix is no longer used - prompt templates handle all formatting
-    // If no prompt is provided, that's an error (prompt is required for user message)
-    if (isAIRequest(request) && !request.prompt) {
-        const err = new Error(`Prompt is required for AI requests. Provide prompt template text. The template should contain variables such as {{input}} resolved from workingMemory.input.`);
-        err.code = 'PROMPT_REQUIRED';
-        err.details = {
-            missingField: 'prompt',
-            hasWorkingMemory: !!request.workingMemory,
-            hasInputInWorkingMemory: !!request.workingMemory?.input
-        };
-        logger.error('Prompt is required for AI requests', {
+    if (hasNonEmptyPrompt(request.prompt)) {
+        if (typeof request.prompt !== 'string') {
+            throw new Error(`Prompt must be a string template, but received: ${typeof request.prompt}`);
+        }
+        logger.info('Parsing prompt template text', {
             jobId: request.identity.jobId,
             agentId: request.agentId,
-            errorCode: 'PROMPT_REQUIRED'
+            promptLength: request.prompt.length,
+            promptPreview: request.prompt.substring(0, 200),
+            hasWorkingMemory: !!request.workingMemory
         });
-        throw err;
-    }
-    // Add prompt if provided (always template text; parsed with memory context)
-    if (request.prompt) {
-        if (typeof request.prompt === 'string') {
-            logger.info('Parsing prompt template text', {
-                jobId: request.identity.jobId,
-                agentId: request.agentId,
-                promptLength: request.prompt.length,
-                promptPreview: request.prompt.substring(0, 200),
-                hasWorkingMemory: !!request.workingMemory
-            });
-            try {
-                if (!request.workingMemory) {
-                    const err = new Error(`workingMemory is required for prompt template rendering but was not provided.`);
-                    err.code = 'WORKING_MEMORY_REQUIRED';
-                    err.details = { requiresVariables: true };
-                    logger.error('workingMemory required for prompt template rendering', {
-                        jobId: request.identity.jobId,
-                        agentId: request.agentId,
-                        errorCode: 'WORKING_MEMORY_REQUIRED'
-                    });
-                    throw err;
-                }
-                const parsedPrompt = await parseTemplate(request.prompt, request.workingMemory, undefined, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
-                if (!parsedPrompt || parsedPrompt.trim() === '') {
-                    const workingMemoryObj = request.workingMemory;
-                    const err = new Error(`Prompt template rendered to empty string. This may indicate missing template variables or empty template content.`);
-                    err.code = 'PROMPT_RENDERED_EMPTY';
-                    err.details = {
-                        promptLength: request.prompt.length,
-                        renderedLength: 0,
-                        hasWorkingMemory: !!request.workingMemory,
-                        workingMemoryKeys: workingMemoryObj ? Object.keys(workingMemoryObj) : []
-                    };
-                    logger.error('Prompt template rendered to empty string', {
-                        jobId: request.identity.jobId,
-                        agentId: request.agentId,
-                        errorCode: 'PROMPT_RENDERED_EMPTY',
-                        hasWorkingMemory: !!request.workingMemory,
-                        workingMemoryKeys: workingMemoryObj ? Object.keys(workingMemoryObj) : []
-                    });
-                    throw err;
-                }
-                logger.info('Prompt text parsed successfully', {
+        try {
+            if (!request.workingMemory) {
+                const err = new Error(`workingMemory is required for prompt template rendering but was not provided.`);
+                err.code = 'WORKING_MEMORY_REQUIRED';
+                err.details = { requiresVariables: true };
+                logger.error('workingMemory required for prompt template rendering', {
                     jobId: request.identity.jobId,
                     agentId: request.agentId,
-                    originalLength: request.prompt.length,
-                    parsedLength: parsedPrompt.length,
-                    parsedPreview: parsedPrompt.substring(0, 200)
+                    errorCode: 'WORKING_MEMORY_REQUIRED'
                 });
-                parts.push(parsedPrompt);
+                throw err;
             }
-            catch (error) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                let errorCode = 'PROMPT_TEMPLATE_ERROR';
-                let errorMessage = `Failed to render prompt template: ${err.message}`;
-                if (err.message.includes('not found') || err.message.includes('does not exist')) {
-                    errorCode = 'PROMPT_NOT_FOUND';
-                    errorMessage = err.message;
-                }
-                else if (err.message.includes('rendered to empty')) {
-                    errorCode = 'PROMPT_RENDERED_EMPTY';
-                    errorMessage = err.message;
-                }
-                else if (err.name === 'TemplateResolutionError') {
-                    errorCode = 'TEMPLATE_RESOLUTION_ERROR';
-                    errorMessage = err.message;
-                }
-                else if (err.message.includes('Template variable') || err.message.includes('missing')) {
-                    errorCode = 'TEMPLATE_VARIABLE_MISSING';
-                    errorMessage = err.message;
-                }
-                logger.error('Failed to render prompt template', {
+            const parsedPrompt = await parseTemplate(request.prompt, request.workingMemory, undefined, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
+            if (!parsedPrompt || parsedPrompt.trim() === '') {
+                const workingMemoryObj = request.workingMemory;
+                const err = new Error(`Prompt template rendered to empty string. This may indicate missing template variables or empty template content.`);
+                err.code = 'PROMPT_RENDERED_EMPTY';
+                err.details = {
+                    promptLength: request.prompt.length,
+                    renderedLength: 0,
+                    hasWorkingMemory: !!request.workingMemory,
+                    workingMemoryKeys: workingMemoryObj ? Object.keys(workingMemoryObj) : []
+                };
+                logger.error('Prompt template rendered to empty string', {
                     jobId: request.identity.jobId,
                     agentId: request.agentId,
-                    errorCode,
-                    error: err.message,
-                    errorName: err.name,
-                    errorStack: err.stack
+                    errorCode: 'PROMPT_RENDERED_EMPTY',
+                    hasWorkingMemory: !!request.workingMemory,
+                    workingMemoryKeys: workingMemoryObj ? Object.keys(workingMemoryObj) : []
                 });
-                const structuredError = new Error(errorMessage);
-                structuredError.code = errorCode;
-                structuredError.details = {
-                    type: 'prompt',
-                    originalError: err.message
-                };
-                throw structuredError;
+                throw err;
             }
+            logger.info('Prompt text parsed successfully', {
+                jobId: request.identity.jobId,
+                agentId: request.agentId,
+                originalLength: request.prompt.length,
+                parsedLength: parsedPrompt.length,
+                parsedPreview: parsedPrompt.substring(0, 200)
+            });
+            return parsedPrompt;
         }
-        else {
-            const err = new Error(`Prompt must be a string template, but received: ${typeof request.prompt}`);
-            logger.error('Prompt provided as non-string - not supported', {
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            let errorCode = 'PROMPT_TEMPLATE_ERROR';
+            let errorMessage = `Failed to render prompt template: ${err.message}`;
+            if (err.message.includes('not found') || err.message.includes('does not exist')) {
+                errorCode = 'PROMPT_NOT_FOUND';
+                errorMessage = err.message;
+            }
+            else if (err.message.includes('rendered to empty')) {
+                errorCode = 'PROMPT_RENDERED_EMPTY';
+                errorMessage = err.message;
+            }
+            else if (err.name === 'TemplateResolutionError') {
+                errorCode = 'TEMPLATE_RESOLUTION_ERROR';
+                errorMessage = err.message;
+            }
+            else if (err.message.includes('Template variable') || err.message.includes('missing')) {
+                errorCode = 'TEMPLATE_VARIABLE_MISSING';
+                errorMessage = err.message;
+            }
+            logger.error('Failed to render prompt template', {
                 jobId: request.identity.jobId,
                 agentId: request.agentId,
-                promptType: typeof request.prompt
+                errorCode,
+                error: err.message,
+                errorName: err.name,
+                errorStack: err.stack
             });
-            throw err;
+            const structuredError = new Error(errorMessage);
+            structuredError.code = errorCode;
+            structuredError.details = {
+                type: 'prompt',
+                originalError: err.message
+            };
+            throw structuredError;
         }
     }
-    // Input field has been removed - all input must come from workingMemory.input
-    // Prompt templates should contain {{input}} which will be resolved from workingMemory.input
-    // No need to add input separately - it's already in the rendered prompt template
-    const userMessage = parts.join('\n\n');
-    // If prompt was provided, we MUST have a non-empty user message
-    if (request.prompt && (!userMessage || userMessage.trim() === '')) {
-        const err = new Error(`Prompt template was provided but resulted in empty user message. The template may have rendered to empty or failed to resolve.`);
-        err.code = 'PROMPT_NO_USER_MESSAGE';
-        err.details = {
-            promptPreview: typeof request.prompt === 'string' ? request.prompt.substring(0, 200) : request.prompt,
-            hasWorkingMemory: !!request.workingMemory,
-            workingMemoryKeys: request.workingMemory ? Object.keys(request.workingMemory) : [],
-            partsLength: parts.length
-        };
-        logger.error('Prompt provided but resulted in empty user message', {
+    if (hasResolvableInput(request.workingMemory)) {
+        const fallback = formatInputFallback(getWorkingMemoryInput(request.workingMemory));
+        if (!fallback.trim()) {
+            const err = new Error(`workingMemory.input is present but empty. Provide a prompt template or non-empty workingMemory.input.`);
+            err.code = 'USER_CONTENT_REQUIRED';
+            throw err;
+        }
+        logger.info('Using workingMemory.input fallback for user message', {
             jobId: request.identity.jobId,
             agentId: request.agentId,
-            prompt: request.prompt,
-            errorCode: 'PROMPT_NO_USER_MESSAGE',
-            partsLength: parts.length,
-            parts: parts.map(p => ({ length: p.length, preview: p.substring(0, 50) }))
+            fallbackLength: fallback.length,
+            fallbackPreview: fallback.substring(0, 200)
         });
-        throw err;
-    }
-    return userMessage;
-}
-/**
- * Checks if instructions already meet the required flex-md compliance level
- * Uses flex-md SDK to validate compliance
- *
- * @param instructionsText - Instructions to check
- * @param complianceLevel - Required compliance level (L0, L1, L2, L3)
- * @returns true if instructions meet the compliance level
- */
-async function hasFlexMdContract(instructionsText, complianceLevel = 'L0') {
-    if (!instructionsText || instructionsText.trim() === '') {
-        return false;
-    }
-    try {
-        // Try to use flex-md SDK to validate compliance
-        const { loadFlexMd } = await import('./flex-md-loader.js');
-        const flexMd = await loadFlexMd();
-        // Check if validateMarkdownAgainstOfs is available
-        if (flexMd.validateMarkdownAgainstOfs && typeof flexMd.validateMarkdownAgainstOfs === 'function') {
-            try {
-                // Try to validate - this might require a spec, so we catch errors
-                const result = flexMd.validateMarkdownAgainstOfs(instructionsText, { strictness: complianceLevel });
-                // If validation passes, instructions meet compliance
-                if (result && result.valid !== false) {
-                    return true;
-                }
-            }
-            catch (e) {
-                // Validation function might need more parameters, fall through to pattern matching
-            }
-        }
-    }
-    catch (error) {
-        // flex-md SDK not available or error - fall through to pattern matching
-    }
-    // Fallback: Pattern-based checking
-    const text = instructionsText.toLowerCase();
-    // Check for key flex-md enforcement phrases
-    const flexMdIndicators = [
-        'markdown',
-        'fenced block',
-        '```markdown',
-        '```json',
-        'reply in markdown',
-        'return your entire answer'
-    ];
-    // Check for enforcement language based on compliance level
-    const enforcementIndicators = [];
-    if (complianceLevel === 'L2' || complianceLevel === 'L3') {
-        // L2/L3 require fenced block container
-        enforcementIndicators.push('fenced block', '```markdown', 'single ```markdown', 'entire answer inside', 'nothing else');
-    }
-    if (complianceLevel === 'L1' || complianceLevel === 'L2' || complianceLevel === 'L3') {
-        // L1+ requires section headings
-        enforcementIndicators.push('section', 'heading', 'include these');
+        return fallback;
     }
-    // Must have at least one flex-md indicator AND appropriate enforcement indicators
-    const hasFlexMd = flexMdIndicators.some(indicator => text.includes(indicator));
-    const hasEnforcement = enforcementIndicators.length === 0 ||
-        enforcementIndicators.some(indicator => text.includes(indicator));
-    return hasFlexMd && hasEnforcement;
+    const err = new Error(`User message requires prompt template text or workingMemory.input. Provide prompt or workingMemory.input.`);
+    err.code = 'USER_CONTENT_REQUIRED';
+    err.details = {
+        hasPrompt: hasNonEmptyPrompt(request.prompt),
+        hasWorkingMemory: !!request.workingMemory,
+        hasInputInWorkingMemory: false
+    };
+    logger.error('No prompt or workingMemory.input for user message', {
+        jobId: request.identity.jobId,
+        agentId: request.agentId,
+        errorCode: 'USER_CONTENT_REQUIRED'
+    });
+    throw err;
 }
 /**
  * Main function to build messages
@@ -247,13 +180,11 @@ export async function buildMessages(request, config, options = {}) {
     const { parsedSnapshot } = options;
     const { logger } = config;
     const messages = [];
-    // Step 1: Instructions as template text (parsed with full memory context)
-    let instructionsText = '';
-    // Extract memory context from options
     const shortTermMemory = options.shortTermMemory;
     const experienceMemory = options.experienceMemory;
     const knowledgeMemory = options.knowledgeMemory;
     const templateRenderOptions = mergeGatewayAndRequestTemplateRenderOptions(config.templateRendering, request);
+    let instructionsText = '';
     if (request.instructions) {
         if (typeof request.instructions === 'string') {
             logger.info('Using instructions as template text', {
@@ -268,16 +199,9 @@ export async function buildMessages(request, config, options = {}) {
             instructionsText = JSON.stringify(request.instructions);
         }
     }
-    // NO SYSTEM CONTEXT FALLBACK - removed default instruction fallback
-    // Instructions must be provided explicitly - no defaults allowed
-    // If instructionsText is empty here, it's a bad request
-    // Step 2: Parse instructions template with full memory context
-    // Rendrix handles token resolution, so we just parse directly
     if (instructionsText) {
-        instructionsText = await parseTemplate(instructionsText, request.workingMemory, undefined, // taskConfig removed - no longer used
-        shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
+        instructionsText = await parseTemplate(instructionsText, request.workingMemory, undefined, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
     }
-    // Instructions must be provided explicitly — no packaged block injection
     if (!instructionsText || instructionsText.trim() === '') {
         const errorMessage = 'No instructions available - cannot proceed without clear instructions. This is a bad request.';
         logger.error(errorMessage, {
@@ -292,11 +216,9 @@ export async function buildMessages(request, config, options = {}) {
         role: 'system',
         content: instructionsText
     });
-    // Store resolved/parsed content for activity (parsed = content after resolution + Rendrix, not the key)
     if (parsedSnapshot) {
         parsedSnapshot.instructions = instructionsText;
     }
-    // Log the final system message for verification
     logger.info('Final system message constructed', {
         jobId: request.identity.jobId,
         agentId: request.agentId,
@@ -305,65 +227,34 @@ export async function buildMessages(request, config, options = {}) {
         hasFencedBlock: instructionsText.includes('```markdown'),
         hasJson: instructionsText.toLowerCase().includes('json'),
         messagePreview: instructionsText.substring(0, 500),
-        fullMessage: instructionsText // Log full message for debugging
+        fullMessage: instructionsText
     });
-    // Step 7: Add context (if provided) with full memory context
-    if (request.context) {
-        const contextText = typeof request.context === 'string' ? request.context : JSON.stringify(request.context);
-        const parsedContext = await parseTemplate(contextText, request.workingMemory, undefined, // taskConfig removed - no longer used
-        shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions, logger);
-        if (parsedContext && parsedContext.trim() !== '') {
-            messages.push({
-                role: 'assistant',
-                content: parsedContext
-            });
-        }
-    }
-    // Step 8: Build user message with full memory context
     const userMessage = await buildUserMessage(request, config, shortTermMemory, experienceMemory, knowledgeMemory, templateRenderOptions);
-    if (userMessage && userMessage.trim() !== '') {
-        messages.push({
-            role: 'user',
-            content: userMessage
-        });
-        // Store resolved/parsed prompt for activity (parsed = content after resolution + Rendrix, not the key)
-        if (parsedSnapshot) {
-            parsedSnapshot.prompt = userMessage;
-        }
-        // Log the user message for verification
-        logger.info('Final user message constructed', {
+    if (!userMessage || userMessage.trim() === '') {
+        const err = new Error(`User message is required but was empty after prompt render or input fallback.`);
+        err.code = 'USER_CONTENT_REQUIRED';
+        logger.error('User message empty after build', {
             jobId: request.identity.jobId,
             agentId: request.agentId,
-            messageLength: userMessage.length,
-            messagePreview: userMessage.substring(0, 200),
-            fullMessage: userMessage // Log full message for debugging
+            errorCode: 'USER_CONTENT_REQUIRED',
+            hasPrompt: hasNonEmptyPrompt(request.prompt)
         });
+        throw err;
     }
-    else {
-        // If prompt was provided, we MUST have a user message - this is an error
-        if (request.prompt) {
-            const err = new Error(`Prompt template was provided but no user message was created. The template may have rendered to empty or failed to resolve.`);
-            err.code = 'PROMPT_NO_USER_MESSAGE';
-            err.details = {
-                promptPreview: typeof request.prompt === 'string' ? request.prompt.substring(0, 200) : request.prompt,
-                hasWorkingMemory: !!request.workingMemory
-            };
-            logger.error('Prompt provided but no user message created', {
-                jobId: request.identity.jobId,
-                agentId: request.agentId,
-                prompt: request.prompt,
-                errorCode: 'PROMPT_NO_USER_MESSAGE'
-            });
-            throw err;
-        }
-        // If no prompt was provided, it's just a warning (input-only requests are valid)
-        logger.warn('No user message to add', {
-            jobId: request.identity.jobId,
-            agentId: request.agentId,
-            hasPrompt: !!request.prompt
-        });
+    messages.push({
+        role: 'user',
+        content: userMessage
+    });
+    if (parsedSnapshot) {
+        parsedSnapshot.prompt = userMessage;
     }
-    // Log complete message structure
+    logger.info('Final user message constructed', {
+        jobId: request.identity.jobId,
+        agentId: request.agentId,
+        messageLength: userMessage.length,
+        messagePreview: userMessage.substring(0, 200),
+        fullMessage: userMessage
+    });
     logger.info('Complete message structure', {
         jobId: request.identity.jobId,
         agentId: request.agentId,

package/dist-cjs/message-builder.d.ts

@@ -28,6 +28,10 @@ export interface BuiltMessages {
         hasObjectTypes?: boolean;
     };
 }
+/**
+ * Serializes workingMemory.input when no prompt template is provided.
+ */
+export declare function formatInputFallback(input: unknown): string;
 /**
  * Main function to build messages
  */

package/dist-cjs/troubleshooting-helper.cjs

@@ -195,7 +195,10 @@ export function validateAIRequest(request) {
         errors.push('instructions is required');
     }
     if (!request.prompt) {
-        errors.push('Prompt is required (input field has been removed - use workingMemory.input instead)');
+        const wmInput = request.workingMemory?.input;
+        if (wmInput === undefined || wmInput === null) {
+            errors.push('prompt or workingMemory.input is required for the user turn');
+        }
     }
     // Validate config
     if (!request.config) {
@@ -581,7 +584,7 @@ export function createValidationTestCases() {
             expectedErrors: ['instructions is required']
         },
         {
-            name: 'Missing prompt',
+            name: 'Missing prompt and workingMemory.input',
             request: {
                 aiRequestId: 'ai-no-prompt',
                 agentId: 'agent-1',
@@ -589,11 +592,11 @@ export function createValidationTestCases() {
                 actionRef: 'validation/x',
                 identity: sampleIdentity('test', 'agent-1'),
                 instructions: 'Test',
-                workingMemory: { input: 'Test' },
+                workingMemory: {},
                 config: { model: 'gpt-4o', provider: 'openai' }
             },
             shouldFail: true,
-            expectedErrors: ['Prompt is required (input field has been removed - use workingMemory.input instead)']
+            expectedErrors: ['prompt or workingMemory.input is required for the user turn']
         },
         {
             name: 'Missing actionRef',

package/dist-cjs/types.d.ts

@@ -933,15 +933,11 @@ interface BaseLLMRequest extends Omit<LLMRequest, 'messages' | 'input' | 'reques
      */
     coreSkillId?: string;
     /**
-     * Prompt template text (optional) — parsed with workingMemory and tier memories.
+     * Prompt template text (optional) — parsed with workingMemory and sent as the user turn.
+     * When omitted, workingMemory.input is serialized as the user message.
      * Use variables such as {{input}} resolved from workingMemory.input.
      */
     prompt?: string;
-    /**
-     * Context text (optional) - Template that can use workingMemory
-     * Added as system message between instructions and prompt
-     */
-    context?: string;
     /**
      * Working memory (optional) - Affects all template parsing
      * Passed to Rendrix (v4+) for template variable substitution.
@@ -1042,7 +1038,7 @@ interface BaseLLMRequest extends Omit<LLMRequest, 'messages' | 'input' | 'reques
  * - agentId: Required to identify the agent
  * - instructions: Required (template text)
  *
- * Minimum: instructions + prompt (prompt is required for user message)
+ * Minimum: instructions + (prompt or workingMemory.input)
  *
  * Note: objectTypes is NOT supported in ChatRequest.
  * Use {@link AIInvokeRequest} with invoke() for structured output requests.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x12i/ai-gateway",
-  "version": "10.4.4",
+  "version": "11.0.0",
   "description": "AI Gateway - Unified interface for LLM provider routing and management",
   "type": "module",
   "exports": {