modelmix 5.1.10 → 5.1.15

package/lib/providers/openai.js

@@ -4,38 +4,35 @@ const {
     normalizeContentCache,
     stripContentCacheMetadata
 } = require('../content-cache');
+const { requireProviderApiKey } = require('../provider-api-key');
+const { normalizeOpenAIOptions } = require('./openai-options');
+const {
+    throwIfAborted,
+    validateProviderExecution
+} = require('../abort-signal');
 
 function createOpenAIProviders({
     ModelMix,
     MixCustom,
     MixOpenAI,
-    MixModeration
+    MixModeration,
+    rejectsAnthropicSamplingParams
 }) {
     const WebSocket = require('ws');
 
     class MixOpenAIResponses extends MixOpenAI {
-        async create({ config = {}, options = {} } = {}) {
-    
-            // Keep GPT/o-model option normalization behavior
-            if (options.model?.startsWith('o')) {
-                delete options.max_tokens;
-                delete options.temperature;
-            }
-            if (options.model?.includes('gpt-5')) {
-                if (options.max_tokens) {
-                    options.max_completion_tokens = options.max_tokens;
-                    delete options.max_tokens;
-                }
-                delete options.temperature;
-            }
-    
+        async create({ config = {}, options = {}, signal } = {}) {
+            validateProviderExecution(this, { config, options, signal });
+            normalizeOpenAIOptions(options);
             const responsesUrl = this.config.url.replace('/chat/completions', '/responses');
             const request = MixOpenAIResponses.buildResponsesRequest(options, config);
             const response = await fetchJsonResponse(responsesUrl, {
                 method: 'POST',
                 headers: this.headers,
-                body: JSON.stringify(request)
+                body: JSON.stringify(request),
+                signal
             });
+            throwIfAborted(signal);
     
             return MixOpenAIResponses.processResponsesResponse(response);
         }
@@ -246,10 +243,7 @@ function createOpenAIProviders({
     
     class MixOpenAIModeration extends MixModeration {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.OPENAI_API_KEY;
-            if (!apiKey) {
-                throw new Error('OpenAI API key not found. Please provide it in config or set OPENAI_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'OPENAI_API_KEY', 'OpenAI');
     
             return super.getDefaultConfig({
                 url: 'https://api.openai.com/v1/moderations',
@@ -258,7 +252,8 @@ function createOpenAIProviders({
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
+            validateProviderExecution(this, { config, options, signal });
             if (options.stream) {
                 throw new Error('Stream is not supported for OpenAI moderation');
             }
@@ -267,8 +262,10 @@ function createOpenAIProviders({
             const response = await fetchJsonResponse(this.config.url, {
                 method: 'POST',
                 headers: this.headers,
-                body: JSON.stringify({ model: options.model, input })
+                body: JSON.stringify({ model: options.model, input }),
+                signal
             });
+            throwIfAborted(signal);
     
             return {
                 moderation: response.data.results,
@@ -356,19 +353,9 @@ function createOpenAIProviders({
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
-            if (options.model?.startsWith('o')) {
-                delete options.max_tokens;
-                delete options.temperature;
-            }
-            if (options.model?.includes('gpt-5')) {
-                if (options.max_tokens) {
-                    options.max_completion_tokens = options.max_tokens;
-                    delete options.max_tokens;
-                }
-                delete options.temperature;
-            }
-    
+        async create({ config = {}, options = {}, signal } = {}) {
+            validateProviderExecution(this, { config, options, signal });
+            normalizeOpenAIOptions(options);
             const mergedConfig = { ...this.config, ...config };
             const realtimeUrl = `${mergedConfig.realtimeUrl}?model=${encodeURIComponent(options.model)}`;
             const timeoutMs = mergedConfig.websocketTimeoutMs || 120000;
@@ -396,7 +383,18 @@ function createOpenAIProviders({
                     });
                 }, timeoutMs);
     
-                const cleanUp = () => clearTimeout(timeout);
+                const cleanUp = () => {
+                    clearTimeout(timeout);
+                    signal?.removeEventListener('abort', onAbort);
+                };
+                const onAbort = () => {
+                    if (settled) return;
+                    settled = true;
+                    cleanUp();
+                    ws.terminate();
+                    reject(signal.reason);
+                };
+                signal?.addEventListener('abort', onAbort, { once: true });
     
                 ws.on('open', () => {
                     const session = {
@@ -556,10 +554,7 @@ function createOpenAIProviders({
     
     class MixOpenRouter extends MixOpenAI {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.OPENROUTER_API_KEY;
-            if (!apiKey) {
-                throw new Error('OpenRouter API key not found. Please provide it in config or set OPENROUTER_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'OPENROUTER_API_KEY', 'OpenRouter');
     
             return MixCustom.prototype.getDefaultConfig.call(this, {
                 url: 'https://openrouter.ai/api/v1/chat/completions',
@@ -567,14 +562,20 @@ function createOpenAIProviders({
                 ...customConfig
             });
         }
+
+        async create({ config = {}, options = {}, signal } = {}) {
+            if (rejectsAnthropicSamplingParams(options.model)) {
+                delete options.temperature;
+                delete options.top_p;
+                delete options.top_k;
+            }
+            return super.create({ config, options, signal });
+        }
     }
     
     class MixKimi extends MixOpenAI {
         getDefaultConfig(customConfig) {
-            const apiKey = customConfig.apiKey || process.env.MOONSHOT_API_KEY;
-            if (!apiKey) {
-                throw new Error('Moonshot API key not found. Please provide it in config or set MOONSHOT_API_KEY environment variable.');
-            }
+            const apiKey = requireProviderApiKey(customConfig, 'MOONSHOT_API_KEY', 'Moonshot');
     
             return MixCustom.prototype.getDefaultConfig.call(this, {
                 url: 'https://api.moonshot.ai/v1/chat/completions',
@@ -583,7 +584,7 @@ function createOpenAIProviders({
             });
         }
     
-        async create({ config = {}, options = {} } = {}) {
+        async create({ config = {}, options = {}, signal } = {}) {
             if (Object.hasOwn(options, 'max_tokens')) {
                 options.max_completion_tokens = options.max_tokens;
                 delete options.max_tokens;
@@ -595,7 +596,7 @@ function createOpenAIProviders({
             delete options.presence_penalty;
             delete options.frequency_penalty;
     
-            return super.create({ config, options });
+            return super.create({ config, options, signal });
         }
     
         extractDelta(data) {

package/lib/providers.js

@@ -1,12 +1,15 @@
 const createBaseProviders = require('./providers/base');
 const createOpenAIProviders = require('./providers/openai');
-const createAnthropicProviders = require('./providers/anthropic');
+const {
+    createAnthropicProviders,
+    rejectsAnthropicSamplingParams
+} = require('./providers/anthropic');
 const createCompatibleProviders = require('./providers/openai-compatible');
 const createGoogleProviders = require('./providers/google');
 
 function createProviders({ ModelMix, log }) {
     const base = createBaseProviders({ ModelMix });
-    const openai = createOpenAIProviders({ ModelMix, ...base });
+    const openai = createOpenAIProviders({ ModelMix, rejectsAnthropicSamplingParams, ...base });
     const anthropic = createAnthropicProviders({ ModelMix, MixCustom: base.MixCustom, log });
     const compatible = createCompatibleProviders({
         MixCustom: base.MixCustom,

package/lib/token-usage.js

@@ -35,6 +35,8 @@ const MODEL_PRICING = {
     'gpt-5.3-codex': { input: 1.75, cachedInput: 0.175, output: 14.00 },
     'gpt-5.2': { input: 1.75, cachedInput: 0.175, output: 14.00 },
     'gpt-5.2-chat-latest': { input: 1.75, cachedInput: 0.175, output: 14.00 },
+    'gpt-5.3-chat-latest': { input: 1.75, cachedInput: 0.175, output: 14.00 },
+    'openai/gpt-5.3-chat': { input: 1.75, cachedInput: 0.175, output: 14.00 },
     'gpt-5.1': { input: 1.25, cachedInput: 0.125, output: 10.00 },
     'gpt-5': { input: 1.25, cachedInput: 0.125, output: 10.00 },
     'gpt-5-mini': { input: 0.25, cachedInput: 0.025, output: 2.00 },
@@ -47,6 +49,8 @@ const MODEL_PRICING = {
     'gpt-oss-120b': { input: 0.15, output: 0.60 },
     'accounts/fireworks/models/gpt-oss-120b': { input: 0.15, cachedInput: 0.014, output: 0.60 },
     // Anthropic
+    'claude-fable-5-1': { input: 10.00, cachedInput: 0.25, cacheWrite: 12.50, cacheWrite1h: 20.00, output: 50.00 },
+    'anthropic/claude-fable-5.1': { input: 10.00, cachedInput: 0.25, cacheWrite: 12.50, cacheWrite1h: 20.00, output: 50.00 },
     'claude-fable-5': { input: 10.00, cachedInput: 1.00, cacheWrite: 12.50, cacheWrite1h: 20.00, output: 50.00 },
     'claude-opus-5': { input: 5.00, cachedInput: 0.50, cacheWrite: 6.25, cacheWrite1h: 10.00, output: 25.00 },
     'claude-sonnet-5': { input: 3.00, cachedInput: 0.30, cacheWrite: 3.75, cacheWrite1h: 6.00, output: 15.00 },
@@ -75,10 +79,11 @@ const MODEL_PRICING = {
     'grok-4.20-0309': { input: 1.25, output: 2.50 },
     'grok-4.20-0309-reasoning': { input: 1.25, output: 2.50 },
     'grok-4.20-0309-non-reasoning': { input: 1.25, output: 2.50 },
-    // Muse Glimmer 30B (NVIDIA/OpenRouter, Fireworks, Together)
+    // Muse
     'meta/muse-glimmer-30b': { input: 0.35, cachedInput: 0.04, output: 1.50 },
     'accounts/fireworks/models/muse-glimmer-30b': { input: 0.35, cachedInput: 0.04, output: 1.50 },
     'meta-models/Muse-Glimmer-30B': { input: 0.35, cachedInput: 0.04, output: 1.50 },
+    'meta/muse-spark-1.2-contributor': { input: 0.10, cachedInput: 0.002, output: 0.20 },
     // Fireworks
     'accounts/fireworks/models/deepseek-v4-flash': { input: 0.14, output: 0.28 },
     'accounts/fireworks/models/deepseek-v4-pro': { input: 1.74, output: 3.48 },
@@ -200,7 +205,7 @@ function normalizeTokenUsage({ input = 0, output = 0, thinking = 0, total, cache
 }
 
 function calculateCostBreakdown(modelKey, tokens) {
-    const pricing = MODEL_PRICING[modelKey];
+    const pricing = getModelPricing(modelKey);
     if (!pricing) return normalizeTokenUsage().costBreakdown;
 
     const normalized = normalizeTokenUsage(tokens);
@@ -249,7 +254,7 @@ function calculateCostBreakdown(modelKey, tokens) {
 }
 
 function calculateCacheMetrics(modelKey, tokens) {
-    const pricing = MODEL_PRICING[modelKey];
+    const pricing = getModelPricing(modelKey);
     const emptyMetrics = {
         cacheSavings: 0,
         cacheWritePremium: 0,
@@ -296,7 +301,17 @@ function calculateCost(modelKey, tokens) {
 }
 
 function hasModelPricing(modelKey) {
-    return Object.prototype.hasOwnProperty.call(MODEL_PRICING, modelKey);
+    return getModelPricing(modelKey) !== undefined;
+}
+
+function getModelPricing(modelKey) {
+    if (Object.prototype.hasOwnProperty.call(MODEL_PRICING, modelKey)) {
+        return MODEL_PRICING[modelKey];
+    }
+    if (typeof modelKey === 'string' && modelKey.startsWith('openai/')) {
+        return MODEL_PRICING[modelKey.slice('openai/'.length)];
+    }
+    return undefined;
 }
 
 function extractCacheTokens(usage = {}) {

package/mcp-tools.js

@@ -36,14 +36,16 @@ class MCPToolsManager {
         }
     }
 
-    async executeTool(name, args) {
+    async executeTool(name, args, signal) {
         const callback = this.callbacks.get(name);
         if (!callback) {
             throw new Error(`Tool not found: ${name}`);
         }
 
         try {
-            const result = await callback(args);
+            signal?.throwIfAborted();
+            const result = await callback(args, signal);
+            signal?.throwIfAborted();
             // For primitive values (numbers, booleans), convert to string
             // For objects/arrays, stringify them
             let textResult;
@@ -62,6 +64,7 @@ class MCPToolsManager {
                 }]
             };
         } catch (error) {
+            signal?.throwIfAborted();
             log.error(`Error executing tool ${name}:`, error);
             return {
                 content: [{ 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "5.1.10",
+  "version": "5.1.15",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,6 +27,7 @@
     "gpt5",
     "opus50",
     "opus5",
+    "fable51",
     "fable50",
     "fable",
     "sonnet",
@@ -77,6 +78,6 @@
     "test:tokens": "mocha test/tokens.test.js --timeout 10000 --require test/setup.js",
     "test:plugins": "mocha test/plugins.test.js --timeout 10000 --require test/setup.js",
     "test:rlm": "mocha plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js",
-    "test:offline": "mocha test/json.test.js test/fallback.test.js test/templates.test.js test/images.test.js test/bottleneck.test.js test/tokens.test.js test/history.test.js test/anthropic.test.js test/effort.test.js test/grok.test.js test/moderation.test.js test/plugins.test.js plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js"
+    "test:offline": "mocha test/abort.test.js test/json.test.js test/fallback.test.js test/templates.test.js test/images.test.js test/bottleneck.test.js test/tokens.test.js test/history.test.js test/anthropic.test.js test/effort.test.js test/grok.test.js test/moderation.test.js test/plugins.test.js plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js"
   }
 }

package/plugins/rlm/index.d.ts

@@ -159,6 +159,7 @@ export interface RlmSandbox {
       parentExecutionId: string | null;
       depth: number;
     };
+    signal?: AbortSignal;
     timeoutMs: number;
   }): Promise<unknown>;
 }

package/plugins/rlm/lib/budget.js

@@ -1,3 +1,5 @@
+const { positiveInteger } = require('./validation');
+
 class RlmLimitError extends Error {
     constructor(limit, message) {
         super(message);
@@ -6,13 +8,6 @@ class RlmLimitError extends Error {
     }
 }
 
-function positiveInteger(value, name) {
-    if (!Number.isInteger(value) || value <= 0) {
-        throw new TypeError(`${name} must be a positive integer.`);
-    }
-    return value;
-}
-
 function validateRuntimeLimits(limits) {
     if (!limits || typeof limits !== 'object' || Array.isArray(limits)) {
         throw new TypeError('limits must be a plain object.');

package/plugins/rlm/lib/isolated-vm-sandbox.js

@@ -21,7 +21,8 @@ function sandboxSource(code) {
 
 function createIsolatedVmSandbox() {
     return {
-        async execute({ code, variables, query, limits, timeoutMs }) {
+        async execute({ code, variables, query, limits, signal, timeoutMs }) {
+            signal?.throwIfAborted();
             if (limits.sandboxMemoryBytes < MINIMUM_ISOLATE_MEMORY_BYTES) {
                 throw new TypeError(
                     `limits.sandboxMemoryBytes must be at least ${MINIMUM_ISOLATE_MEMORY_BYTES}.`
@@ -35,6 +36,10 @@ function createIsolatedVmSandbox() {
                 timedOut = true;
                 if (!isolate.isDisposed) isolate.dispose();
             }, timeoutMs);
+            const onAbort = () => {
+                if (!isolate.isDisposed) isolate.dispose();
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
 
             try {
                 const context = await isolate.createContext();
@@ -68,6 +73,7 @@ function createIsolatedVmSandbox() {
                     timeout: timeoutMs
                 });
             } catch (error) {
+                signal?.throwIfAborted();
                 if (memoryError(error)) {
                     throw new RlmLimitError(
                         'sandboxMemoryBytes',
@@ -78,6 +84,7 @@ function createIsolatedVmSandbox() {
                 throw error;
             } finally {
                 clearTimeout(timeout);
+                signal?.removeEventListener('abort', onAbort);
                 if (!isolate.isDisposed) isolate.dispose();
             }
         }

package/plugins/rlm/lib/planner-prompt.js

@@ -1,15 +1,9 @@
 const path = require('path');
 const { describeVariables } = require('./variable-descriptors');
+const { positiveInteger } = require('./validation');
 
 const PLANNER_SYSTEM_TEMPLATE = path.resolve(__dirname, '../prompts/planner.md');
 
-function positiveInteger(value, name) {
-    if (!Number.isInteger(value) || value <= 0) {
-        throw new TypeError(`${name} must be a positive integer.`);
-    }
-    return value;
-}
-
 function planningHint(name, descriptor, maxQueryBytes) {
     const payloadBytes = descriptor.utf8Bytes ?? descriptor.estimatedBytes;
     if (payloadBytes <= maxQueryBytes) {

package/plugins/rlm/lib/plugin.js

@@ -9,16 +9,11 @@ const {
     sumTokens
 } = require('./runtime');
 const { createWorkerCatalog } = require('./worker-catalog');
-
-function isPlainObject(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
+const { isPlainObject } = require('./validation');
 
 function validateSandbox(sandbox) {
     if (!sandbox || typeof sandbox !== 'object' || typeof sandbox.execute !== 'function') {
-        throw new TypeError('sandbox must define execute({ code, variables, query, limits }).');
+        throw new TypeError('sandbox must define execute({ code, variables, query, limits, signal }).');
     }
     return sandbox;
 }
@@ -96,9 +91,11 @@ function executionInput(context, configuredVariables) {
     };
 }
 
-function runWithTimeout(operation, timeoutMs) {
+function runWithTimeout(operation, timeoutMs, signal) {
+    signal?.throwIfAborted();
     let timeout;
-    return Promise.race([
+    let onAbort;
+    const promises = [
         operation(),
         new Promise((_, reject) => {
             timeout = setTimeout(() => reject(new RlmLimitError(
@@ -106,7 +103,17 @@ function runWithTimeout(operation, timeoutMs) {
                 'RLM wall-time limit exceeded.'
             )), timeoutMs);
         })
-    ]).finally(() => clearTimeout(timeout));
+    ];
+    if (signal) {
+        promises.push(new Promise((_, reject) => {
+            onAbort = () => reject(signal.reason);
+            signal.addEventListener('abort', onAbort, { once: true });
+        }));
+    }
+    return Promise.race(promises).finally(() => {
+        clearTimeout(timeout);
+        if (onAbort) signal.removeEventListener('abort', onAbort);
+    });
 }
 
 function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } = {}) {
@@ -127,6 +134,7 @@ function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } =
     return {
         name: 'rlm',
         async execute(context) {
+            context.signal?.throwIfAborted();
             if (context.request.outputMode === 'stream') {
                 throw new Error('RLM streaming is not supported; use a buffered output mode.');
             }
@@ -150,6 +158,7 @@ function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } =
                         outputSchema: context.request.config.schema || null
                     })
                 ));
+                context.signal?.throwIfAborted();
                 state.record('planner', plannerResult, {
                     worker: null,
                     elapsedMs: Date.now() - plannerStartedAt
@@ -172,10 +181,13 @@ function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } =
                         query,
                         limits: validatedLimits,
                         execution: context.execution,
+                        signal: context.signal,
                         timeoutMs
                     }),
-                    timeoutMs
+                    timeoutMs,
+                    context.signal
                 );
+                context.signal?.throwIfAborted();
                 const message = serializeResult(value);
                 state.budget.accountFinalOutput(message);
                 return {
@@ -184,6 +196,7 @@ function rlm({ maxDepth, variables = {}, documents, workers, limits, sandbox } =
                     rlm: state.diagnostics(context.execution)
                 };
             } catch (error) {
+                context.signal?.throwIfAborted();
                 error.rlm = state.diagnostics(
                     context.execution,
                     error.limit ? `limit:${error.limit}` : 'error'

package/plugins/rlm/lib/validation.js

@@ -0,0 +1,14 @@
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+
+function positiveInteger(value, name) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new TypeError(`${name} must be a positive integer.`);
+    }
+    return value;
+}
+
+module.exports = { isPlainObject, positiveInteger };

package/plugins/rlm/lib/variable-descriptors.js

@@ -1,8 +1,4 @@
-function isPlainObject(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
+const { isPlainObject } = require('./validation');
 
 function roundAverage(total, count) {
     return count === 0 ? 0 : Number((total / count).toFixed(2));

package/plugins/rlm/lib/worker-catalog.js

@@ -1,8 +1,4 @@
-function isPlainObject(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
+const { isPlainObject } = require('./validation');
 
 function finiteRating(value, path) {
     if (!Number.isFinite(value) || value < 0) {

package/plugins/rlm/test/isolated-vm-sandbox.test.js

@@ -69,6 +69,29 @@ describe('RLM isolated-vm sandbox', () => {
         expect(failure.limit).to.equal('maxWallTimeMs');
     });
 
+    it('disposes an in-flight isolate and preserves the abort reason', async () => {
+        const controller = new AbortController();
+        const reason = new Error('stop sandbox');
+        const execution = createIsolatedVmSandbox().execute({
+            code: '(async () => { while (true) {} })()',
+            variables: {},
+            query: async () => '',
+            limits: limits(),
+            signal: controller.signal,
+            timeoutMs: 1000
+        });
+
+        setTimeout(() => controller.abort(reason), 20);
+
+        let failure;
+        try {
+            await execution;
+        } catch (error) {
+            failure = error;
+        }
+        expect(failure).to.equal(reason);
+    });
+
     it('rejects memory limits below the isolated-vm minimum', async () => {
         let failure;
         try {

package/pnpm-workspace.yaml

@@ -6,11 +6,16 @@ allowBuilds:
 
 minimumReleaseAgeExclude:
   - ws@8.21.0
-  - hono@4.12.25
-  - js-yaml@4.1.2
-  - brace-expansion@5.0.8
+  - fast-uri@3.1.5
+  - hono@4.12.34
+  - ip-address@10.3.1
+  - js-yaml@4.3.1
+  - brace-expansion@5.0.9
 overrides:
-  brace-expansion@<=5.0.7: ^5.0.8
+  brace-expansion: 5.0.9
   diff: 8.0.4
-  ip-address: 10.2.0
+  fast-uri: 3.1.5
+  hono: 4.12.34
+  ip-address: 10.3.1
+  js-yaml: 4.3.1
   serialize-javascript: 7.0.5

package/schema.js

@@ -122,31 +122,3 @@ function generateJsonSchema(example, descriptions = {}) {
 }
 
 module.exports = generateJsonSchema;
-
-// const example = {
-//     name: 'Alice',
-//     age: 30,
-//     email: 'alice@example.com',
-//     birthDate: '1990-01-01',
-//     isAdmin: false,
-//     preferences: {
-//         theme: 'dark',
-//         notifications: true
-//     },
-//     tags: ['admin', 'user']
-// };
-
-// const descriptions = {
-//     name: 'Full name of the user',
-//     age: 'Age must be 0 or greater',
-//     email: 'User email address',
-//     // birthDate: 'User birth date in YYYY-MM-DD format',
-//     preferences: {
-//         theme: 'Theme preference (light/dark)',
-//         notifications: 'Whether notifications are enabled'
-//     }
-// };
-
-// const schema = generateJsonSchema(example);
-
-// console.log(JSON.stringify(schema, null, 2));