@layer-ai/core 2.0.12 → 2.0.14

package/dist/routes/tests/test-chat-structured-output.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Test structured output at the chat route level
+ * Tests that gate configuration flows correctly through resolveFinalRequest
+ */
+export {};
+//# sourceMappingURL=test-chat-structured-output.d.ts.map

package/dist/routes/tests/test-chat-structured-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-chat-structured-output.d.ts","sourceRoot":"","sources":["../../../src/routes/tests/test-chat-structured-output.ts"],"names":[],"mappings":";AACA;;;GAGG"}

package/dist/routes/tests/test-chat-structured-output.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env npx tsx
+/**
+ * Test structured output at the chat route level
+ * Tests that gate configuration flows correctly through resolveFinalRequest
+ */
+// We'll test the resolveFinalRequest function directly
+// This simulates what happens in the chat route
+console.log('='.repeat(80));
+console.log('STRUCTURED OUTPUT - CHAT ROUTE LEVEL TESTS');
+console.log('='.repeat(80));
+console.log('');
+// Mock gate config
+const baseGateConfig = {
+    id: 'test-gate-id',
+    name: 'Test Gate',
+    model: 'gpt-4o',
+    taskType: 'chat',
+    temperature: 0.7,
+    maxTokens: 100,
+    topP: 0.9,
+    systemPrompt: undefined,
+    routingStrategy: 'single',
+    responseFormatEnabled: false,
+    responseFormatType: 'text',
+    responseFormatSchema: undefined,
+    // Add other required fields for Gate
+    userId: 'test-user',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+};
+async function testOpenAIJsonObjectMode() {
+    console.log('Test 1: OpenAI - JSON Object Mode (Native)');
+    console.log('-'.repeat(80));
+    const gateConfig = {
+        ...baseGateConfig,
+        model: 'gpt-4o',
+        responseFormatEnabled: true,
+        responseFormatType: 'json_object',
+    };
+    const incomingRequest = {
+        gateId: 'test-gate',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Generate a user profile' }
+            ],
+        }
+    };
+    try {
+        // Import the function we need to test
+        const { resolveFinalRequest } = await import('../v3/chat.js');
+        const resolvedRequest = resolveFinalRequest(gateConfig, incomingRequest);
+        console.log('✓ Request resolved');
+        console.log('');
+        console.log('Resolved request model:', resolvedRequest.model);
+        console.log('Resolved request responseFormat:', resolvedRequest.data.responseFormat);
+        console.log('');
+        // Validate
+        if (resolvedRequest.data.responseFormat !== 'json_object') {
+            throw new Error(`Expected responseFormat 'json_object', got: ${resolvedRequest.data.responseFormat}`);
+        }
+        console.log('✅ OpenAI JSON Object Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ OpenAI JSON Object Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testOpenAIJsonSchemaMode() {
+    console.log('Test 2: OpenAI - JSON Schema Mode (Native)');
+    console.log('-'.repeat(80));
+    const schema = {
+        type: 'json_schema',
+        json_schema: {
+            name: 'user_profile',
+            strict: true,
+            schema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    age: { type: 'number' },
+                    city: { type: 'string' },
+                },
+                required: ['name', 'age', 'city'],
+                additionalProperties: false,
+            },
+        },
+    };
+    const gateConfig = {
+        ...baseGateConfig,
+        model: 'gpt-4o',
+        responseFormatEnabled: true,
+        responseFormatType: 'json_schema',
+        responseFormatSchema: schema,
+    };
+    const incomingRequest = {
+        gateId: 'test-gate',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Create a profile for John Doe, age 30, from New York' }
+            ],
+        }
+    };
+    try {
+        const { resolveFinalRequest } = await import('../v3/chat.js');
+        const resolvedRequest = resolveFinalRequest(gateConfig, incomingRequest);
+        console.log('✓ Request resolved');
+        console.log('');
+        console.log('Resolved request model:', resolvedRequest.model);
+        console.log('Resolved request responseFormat type:', resolvedRequest.data.responseFormat?.type);
+        console.log('');
+        // Validate
+        const responseFormat = resolvedRequest.data.responseFormat;
+        if (!responseFormat || responseFormat.type !== 'json_schema') {
+            throw new Error(`Expected responseFormat.type 'json_schema', got: ${responseFormat?.type}`);
+        }
+        if (!responseFormat.json_schema) {
+            throw new Error('Expected json_schema property in responseFormat');
+        }
+        console.log('✅ OpenAI JSON Schema Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ OpenAI JSON Schema Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testAnthropicBetaMode() {
+    console.log('Test 3: Anthropic - JSON Object Mode (Beta - Prompt Injection)');
+    console.log('-'.repeat(80));
+    const gateConfig = {
+        ...baseGateConfig,
+        model: 'claude-3-7-sonnet-20250219',
+        responseFormatEnabled: true,
+        responseFormatType: 'json_object',
+    };
+    const incomingRequest = {
+        gateId: 'test-gate',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Generate a user profile' }
+            ],
+        }
+    };
+    try {
+        const { resolveFinalRequest } = await import('../v3/chat.js');
+        const resolvedRequest = resolveFinalRequest(gateConfig, incomingRequest);
+        console.log('✓ Request resolved');
+        console.log('');
+        console.log('Resolved request model:', resolvedRequest.model);
+        console.log('System prompt length:', resolvedRequest.data.systemPrompt?.length || 0);
+        console.log('');
+        // Validate - should have JSON instructions in system prompt
+        const systemPrompt = resolvedRequest.data.systemPrompt || '';
+        if (!systemPrompt.includes('JSON')) {
+            throw new Error('Expected JSON instructions in system prompt for beta mode');
+        }
+        // Should NOT have responseFormat set (beta mode uses prompt injection)
+        if (resolvedRequest.data.responseFormat && resolvedRequest.data.responseFormat !== 'text') {
+            throw new Error('Beta mode should not set responseFormat');
+        }
+        console.log('✓ System prompt contains JSON instructions');
+        console.log('System prompt excerpt:');
+        console.log(systemPrompt.substring(0, 150) + '...');
+        console.log('');
+        console.log('✅ Anthropic Beta Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ Anthropic Beta Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testGoogleBetaMode() {
+    console.log('Test 4: Google - JSON Schema Mode (Beta - Prompt Injection)');
+    console.log('-'.repeat(80));
+    const schema = {
+        type: 'json_schema',
+        json_schema: {
+            name: 'user_profile',
+            strict: true,
+            schema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    age: { type: 'number' },
+                },
+                required: ['name', 'age'],
+                additionalProperties: false,
+            },
+        },
+    };
+    const gateConfig = {
+        ...baseGateConfig,
+        model: 'gemini-2.0-flash',
+        responseFormatEnabled: true,
+        responseFormatType: 'json_schema',
+        responseFormatSchema: schema,
+    };
+    const incomingRequest = {
+        gateId: 'test-gate',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Create a profile' }
+            ],
+        }
+    };
+    try {
+        const { resolveFinalRequest } = await import('../v3/chat.js');
+        const resolvedRequest = resolveFinalRequest(gateConfig, incomingRequest);
+        console.log('✓ Request resolved');
+        console.log('');
+        console.log('Resolved request model:', resolvedRequest.model);
+        console.log('System prompt length:', resolvedRequest.data.systemPrompt?.length || 0);
+        console.log('');
+        // Validate - should have schema in system prompt
+        const systemPrompt = resolvedRequest.data.systemPrompt || '';
+        if (!systemPrompt.includes('JSON')) {
+            throw new Error('Expected JSON instructions in system prompt');
+        }
+        if (!systemPrompt.includes('"name"') || !systemPrompt.includes('"age"')) {
+            throw new Error('Expected schema properties in system prompt');
+        }
+        console.log('✓ System prompt contains schema instructions');
+        console.log('✅ Google Beta Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ Google Beta Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testTextModeNoChanges() {
+    console.log('Test 5: Text Mode - No Modifications');
+    console.log('-'.repeat(80));
+    const gateConfig = {
+        ...baseGateConfig,
+        responseFormatEnabled: false,
+        responseFormatType: 'text',
+    };
+    const incomingRequest = {
+        gateId: 'test-gate',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Say hello' }
+            ],
+        }
+    };
+    try {
+        const { resolveFinalRequest } = await import('../v3/chat.js');
+        const resolvedRequest = resolveFinalRequest(gateConfig, incomingRequest);
+        console.log('✓ Request resolved');
+        console.log('');
+        // Validate - should NOT have responseFormat or JSON instructions
+        if (resolvedRequest.data.responseFormat && resolvedRequest.data.responseFormat !== 'text') {
+            throw new Error(`Expected no responseFormat, got: ${resolvedRequest.data.responseFormat}`);
+        }
+        const systemPrompt = resolvedRequest.data.systemPrompt || '';
+        if (systemPrompt.includes('JSON')) {
+            throw new Error('Should not have JSON instructions for text mode');
+        }
+        console.log('✓ No response format applied');
+        console.log('✅ Text Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ Text Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function runTests() {
+    const results = [];
+    results.push(await testOpenAIJsonObjectMode());
+    results.push(await testOpenAIJsonSchemaMode());
+    results.push(await testAnthropicBetaMode());
+    results.push(await testGoogleBetaMode());
+    results.push(await testTextModeNoChanges());
+    console.log('='.repeat(80));
+    console.log('RESULTS SUMMARY');
+    console.log('='.repeat(80));
+    console.log('');
+    const passed = results.filter(r => r).length;
+    const failed = results.filter(r => !r).length;
+    console.log(`Total Tests: ${results.length}`);
+    console.log(`Passed: ${passed}`);
+    console.log(`Failed: ${failed}`);
+    console.log('');
+    if (failed > 0) {
+        console.log('❌ Some tests failed');
+        process.exit(1);
+    }
+    else {
+        console.log('✅ All tests passed!');
+    }
+}
+runTests().catch(error => {
+    console.error('Test suite failed:', error);
+    process.exit(1);
+});
+export {};

package/dist/routes/v1/gates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gates.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/gates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AASpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AA8gBpC,eAAe,MAAM,CAAC"}
+{"version":3,"file":"gates.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/gates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AASpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AAuhBpC,eAAe,MAAM,CAAC"}

package/dist/routes/v1/gates.js

@@ -15,7 +15,7 @@ router.post('/', async (req, res) => {
         return;
     }
     try {
-        const { name, description, taskType, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels, costWeight, latencyWeight, qualityWeight, reanalysisPeriod, taskAnalysis } = req.body;
+        const { name, description, taskType, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels, costWeight, latencyWeight, qualityWeight, reanalysisPeriod, taskAnalysis, responseFormatEnabled, responseFormatType, responseFormatSchema } = req.body;
         if (!name || !model) {
             res.status(400).json({ error: 'bad_request', message: 'Missing required fields: name and model' });
             return;
@@ -47,6 +47,9 @@ router.post('/', async (req, res) => {
             qualityWeight,
             reanalysisPeriod,
             taskAnalysis,
+            responseFormatEnabled,
+            responseFormatType,
+            responseFormatSchema,
         });
         res.status(201).json(gate);
     }
@@ -193,7 +196,7 @@ router.patch('/:id', async (req, res) => {
         return;
     }
     try {
-        const { name, description, taskType, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels, costWeight, latencyWeight, qualityWeight, analysisMethod, reanalysisPeriod, taskAnalysis, autoApplyRecommendations } = req.body;
+        const { name, description, taskType, model, systemPrompt, allowOverrides, temperature, maxTokens, topP, tags, routingStrategy, fallbackModels, costWeight, latencyWeight, qualityWeight, analysisMethod, reanalysisPeriod, taskAnalysis, autoApplyRecommendations, responseFormatEnabled, responseFormatType, responseFormatSchema } = req.body;
         const existing = await db.getGateById(req.params.id);
         if (!existing) {
             res.status(404).json({ error: 'not_found', message: 'Gate not found' });
@@ -225,6 +228,9 @@ router.patch('/:id', async (req, res) => {
             analysisMethod,
             reanalysisPeriod,
             autoApplyRecommendations,
+            responseFormatEnabled,
+            responseFormatType,
+            responseFormatSchema,
         });
         const updated = await db.updateGate(req.params.id, {
             name,
@@ -246,6 +252,9 @@ router.patch('/:id', async (req, res) => {
             reanalysisPeriod,
             taskAnalysis,
             autoApplyRecommendations,
+            responseFormatEnabled,
+            responseFormatType,
+            responseFormatSchema,
         });
         // Only create history snapshot if significant changes were detected
         if (updated && changedFields.length > 0) {

package/dist/routes/v3/chat.d.ts

@@ -1,4 +1,6 @@
 import type { Router as RouterType } from 'express';
+import type { LayerRequest, Gate } from '@layer-ai/sdk';
 declare const router: RouterType;
+export declare function resolveFinalRequest(gateConfig: Gate, request: LayerRequest): LayerRequest;
 export default router;
 //# sourceMappingURL=chat.d.ts.map

package/dist/routes/v3/chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/routes/v3/chat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAOpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AAmTpC,eAAe,MAAM,CAAC"}
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/routes/v3/chat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAIpD,OAAO,KAAK,EAAE,YAAY,EAAiB,IAAI,EAA+C,MAAM,eAAe,CAAC;AAGpH,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AAiBpC,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,IAAI,EAChB,OAAO,EAAE,YAAY,GACpB,YAAY,CAkFd;AA6MD,eAAe,MAAM,CAAC"}

package/dist/routes/v3/chat.js

@@ -12,7 +12,7 @@ function isOverrideAllowed(allowOverrides, field) {
         return false;
     return allowOverrides[field] ?? false;
 }
-function resolveFinalRequest(gateConfig, request) {
+export function resolveFinalRequest(gateConfig, request) {
     let finalModel = gateConfig.model;
     if (request.model && isOverrideAllowed(gateConfig.allowOverrides, OverrideField.Model)) {
         try {

package/dist/services/providers/tests/test-json-response-format-anthropic.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Focused tests for JSON response format structure - Anthropic Provider
+ * Tests structured output with prompt engineering (beta mode)
+ */
+export {};
+//# sourceMappingURL=test-json-response-format-anthropic.d.ts.map

package/dist/services/providers/tests/test-json-response-format-anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-json-response-format-anthropic.d.ts","sourceRoot":"","sources":["../../../../src/services/providers/tests/test-json-response-format-anthropic.ts"],"names":[],"mappings":";AACA;;;GAGG"}

package/dist/services/providers/tests/test-json-response-format-anthropic.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env npx tsx
+/**
+ * Focused tests for JSON response format structure - Anthropic Provider
+ * Tests structured output with prompt engineering (beta mode)
+ */
+import { AnthropicAdapter } from '../anthropic-adapter.js';
+const adapter = new AnthropicAdapter();
+console.log('='.repeat(80));
+console.log('STRUCTURED OUTPUT - ANTHROPIC ADAPTER TESTS (BETA MODE)');
+console.log('='.repeat(80));
+console.log('');
+// Helper to extract JSON from markdown or plain text
+function extractJSON(content) {
+    const codeBlockMatch = content.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlockMatch) {
+        return JSON.parse(codeBlockMatch[1].trim());
+    }
+    return JSON.parse(content.trim());
+}
+async function testJsonObjectModeBeta() {
+    console.log('Test 1: JSON Object Mode (Beta - Prompt Engineering)');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'claude-3-7-sonnet-20250219',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Generate a user profile with name, age, and city fields' }
+            ],
+            systemPrompt: 'You MUST respond with ONLY a valid JSON object. Do not include ANY text before or after the JSON. Do not wrap it in markdown code blocks. Do not add explanations. ONLY output the raw JSON object.',
+            maxTokens: 150,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Raw response content:');
+        console.log(response.content);
+        console.log('');
+        // Try to parse as JSON (with markdown extraction fallback)
+        const parsed = extractJSON(response.content || '');
+        console.log('✓ Successfully parsed as JSON');
+        console.log('');
+        console.log('Parsed structure:');
+        console.log(JSON.stringify(parsed, null, 2));
+        console.log('');
+        console.log('✅ JSON Object Mode (Beta): PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ JSON Object Mode (Beta): FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testJsonSchemaModeBeta() {
+    console.log('Test 2: JSON Schema Mode (Beta - Prompt Engineering)');
+    console.log('-'.repeat(80));
+    const schema = {
+        type: 'object',
+        properties: {
+            name: { type: 'string' },
+            age: { type: 'number' },
+            city: { type: 'string' },
+        },
+        required: ['name', 'age', 'city'],
+        additionalProperties: false,
+    };
+    const systemPrompt = `You MUST respond with ONLY a valid JSON object matching this schema. Do not include ANY text before or after the JSON. Do not wrap it in markdown code blocks. Do not add explanations. ONLY output the raw JSON object.
+
+Required JSON Schema:
+${JSON.stringify(schema, null, 2)}`;
+    const request = {
+        gateId: 'test-gate',
+        model: 'claude-3-7-sonnet-20250219',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Create data for: name=Jane Smith, age=25, city=London' }
+            ],
+            systemPrompt,
+            maxTokens: 150,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Raw response content:');
+        console.log(response.content);
+        console.log('');
+        // Try to parse as JSON (with markdown extraction fallback)
+        const parsed = extractJSON(response.content || '');
+        console.log('✓ Successfully parsed as JSON');
+        console.log('');
+        console.log('Parsed structure:');
+        console.log(JSON.stringify(parsed, null, 2));
+        console.log('');
+        // Validate schema fields
+        const hasRequiredFields = parsed.name && typeof parsed.age === 'number' && parsed.city;
+        if (!hasRequiredFields) {
+            throw new Error('Missing required fields from schema');
+        }
+        console.log('✓ Schema validation passed');
+        console.log('');
+        console.log('✅ JSON Schema Mode (Beta): PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ JSON Schema Mode (Beta): FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testTextMode() {
+    console.log('Test 3: Text Mode (Control Test)');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'claude-3-7-sonnet-20250219',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Say hello' }
+            ],
+            maxTokens: 50,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Response content:');
+        console.log(response.content);
+        console.log('');
+        console.log('✅ Text Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ Text Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function runTests() {
+    const results = [];
+    results.push(await testJsonObjectModeBeta());
+    results.push(await testJsonSchemaModeBeta());
+    results.push(await testTextMode());
+    console.log('='.repeat(80));
+    console.log('RESULTS SUMMARY');
+    console.log('='.repeat(80));
+    console.log('');
+    const passed = results.filter(r => r).length;
+    const failed = results.filter(r => !r).length;
+    console.log(`Total Tests: ${results.length}`);
+    console.log(`Passed: ${passed}`);
+    console.log(`Failed: ${failed}`);
+    console.log('');
+    if (failed > 0) {
+        console.log('❌ Some tests failed');
+        process.exit(1);
+    }
+    else {
+        console.log('✅ All tests passed!');
+    }
+}
+runTests().catch(error => {
+    console.error('Test suite failed:', error);
+    process.exit(1);
+});

package/dist/services/providers/tests/test-json-response-format-google.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Focused tests for JSON response format structure - Google Provider
+ * Tests structured output with prompt engineering (beta mode)
+ */
+export {};
+//# sourceMappingURL=test-json-response-format-google.d.ts.map

package/dist/services/providers/tests/test-json-response-format-google.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-json-response-format-google.d.ts","sourceRoot":"","sources":["../../../../src/services/providers/tests/test-json-response-format-google.ts"],"names":[],"mappings":";AACA;;;GAGG"}

package/dist/services/providers/tests/test-json-response-format-google.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env npx tsx
+/**
+ * Focused tests for JSON response format structure - Google Provider
+ * Tests structured output with prompt engineering (beta mode)
+ */
+import { GoogleAdapter } from '../google-adapter.js';
+const adapter = new GoogleAdapter();
+console.log('='.repeat(80));
+console.log('STRUCTURED OUTPUT - GOOGLE ADAPTER TESTS (BETA MODE)');
+console.log('='.repeat(80));
+console.log('');
+// Helper to extract JSON from markdown or plain text
+function extractJSON(content) {
+    const codeBlockMatch = content.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlockMatch) {
+        return JSON.parse(codeBlockMatch[1].trim());
+    }
+    return JSON.parse(content.trim());
+}
+async function testJsonObjectModeBeta() {
+    console.log('Test 1: JSON Object Mode (Beta - Prompt Engineering)');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'gemini-2.0-flash',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Generate a user profile with name, age, and city fields' }
+            ],
+            systemPrompt: 'You MUST respond with ONLY a valid JSON object. Do not include ANY text before or after the JSON. Do not wrap it in markdown code blocks. Do not add explanations. ONLY output the raw JSON object.',
+            maxTokens: 150,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Raw response content:');
+        console.log(response.content);
+        console.log('');
+        // Try to parse as JSON (with markdown extraction fallback)
+        const parsed = extractJSON(response.content || '');
+        console.log('✓ Successfully parsed as JSON');
+        console.log('');
+        console.log('Parsed structure:');
+        console.log(JSON.stringify(parsed, null, 2));
+        console.log('');
+        console.log('✅ JSON Object Mode (Beta): PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ JSON Object Mode (Beta): FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testJsonSchemaModeBeta() {
+    console.log('Test 2: JSON Schema Mode (Beta - Prompt Engineering)');
+    console.log('-'.repeat(80));
+    const schema = {
+        type: 'object',
+        properties: {
+            name: { type: 'string' },
+            age: { type: 'number' },
+            city: { type: 'string' },
+        },
+        required: ['name', 'age', 'city'],
+        additionalProperties: false,
+    };
+    const systemPrompt = `You MUST respond with ONLY a valid JSON object matching this schema. Do not include ANY text before or after the JSON. Do not wrap it in markdown code blocks. Do not add explanations. ONLY output the raw JSON object.
+
+Required JSON Schema:
+${JSON.stringify(schema, null, 2)}`;
+    const request = {
+        gateId: 'test-gate',
+        model: 'gemini-2.0-flash',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Create data for: name=Alice Johnson, age=28, city=Tokyo' }
+            ],
+            systemPrompt,
+            maxTokens: 150,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Raw response content:');
+        console.log(response.content);
+        console.log('');
+        // Try to parse as JSON (with markdown extraction fallback)
+        const parsed = extractJSON(response.content || '');
+        console.log('✓ Successfully parsed as JSON');
+        console.log('');
+        console.log('Parsed structure:');
+        console.log(JSON.stringify(parsed, null, 2));
+        console.log('');
+        // Validate schema fields
+        const hasRequiredFields = parsed.name && typeof parsed.age === 'number' && parsed.city;
+        if (!hasRequiredFields) {
+            throw new Error('Missing required fields from schema');
+        }
+        console.log('✓ Schema validation passed');
+        console.log('');
+        console.log('✅ JSON Schema Mode (Beta): PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ JSON Schema Mode (Beta): FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testTextMode() {
+    console.log('Test 3: Text Mode (Control Test)');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'gemini-2.0-flash',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Say hello' }
+            ],
+            maxTokens: 50,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Response content:');
+        console.log(response.content);
+        console.log('');
+        console.log('✅ Text Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ Text Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function runTests() {
+    const results = [];
+    results.push(await testJsonObjectModeBeta());
+    results.push(await testJsonSchemaModeBeta());
+    results.push(await testTextMode());
+    console.log('='.repeat(80));
+    console.log('RESULTS SUMMARY');
+    console.log('='.repeat(80));
+    console.log('');
+    const passed = results.filter(r => r).length;
+    const failed = results.filter(r => !r).length;
+    console.log(`Total Tests: ${results.length}`);
+    console.log(`Passed: ${passed}`);
+    console.log(`Failed: ${failed}`);
+    console.log('');
+    if (failed > 0) {
+        console.log('❌ Some tests failed');
+        process.exit(1);
+    }
+    else {
+        console.log('✅ All tests passed!');
+    }
+}
+runTests().catch(error => {
+    console.error('Test suite failed:', error);
+    process.exit(1);
+});

package/dist/services/providers/tests/test-json-response-format-mistral.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Focused tests for JSON response format structure - Mistral Provider
+ * Tests structured output with prompt engineering (beta mode)
+ */
+export {};
+//# sourceMappingURL=test-json-response-format-mistral.d.ts.map

package/dist/services/providers/tests/test-json-response-format-mistral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-json-response-format-mistral.d.ts","sourceRoot":"","sources":["../../../../src/services/providers/tests/test-json-response-format-mistral.ts"],"names":[],"mappings":";AACA;;;GAGG"}

package/dist/services/providers/tests/test-json-response-format-mistral.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env npx tsx
+/**
+ * Focused tests for JSON response format structure - Mistral Provider
+ * Tests structured output with prompt engineering (beta mode)
+ */
+import { MistralAdapter } from '../mistral-adapter.js';
+const adapter = new MistralAdapter();
+console.log('='.repeat(80));
+console.log('STRUCTURED OUTPUT - MISTRAL ADAPTER TESTS (BETA MODE)');
+console.log('='.repeat(80));
+console.log('');
+// Helper to extract JSON from markdown or plain text
+function extractJSON(content) {
+    const codeBlockMatch = content.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlockMatch) {
+        return JSON.parse(codeBlockMatch[1].trim());
+    }
+    return JSON.parse(content.trim());
+}
+async function testJsonObjectModeBeta() {
+    console.log('Test 1: JSON Object Mode (Beta - Prompt Engineering)');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'mistral-medium-2508',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Generate a user profile with name, age, and city fields' }
+            ],
+            systemPrompt: 'You MUST respond with ONLY a valid JSON object. Do not include ANY text before or after the JSON. Do not wrap it in markdown code blocks. Do not add explanations. ONLY output the raw JSON object.',
+            maxTokens: 150,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Raw response content:');
+        console.log(response.content);
+        console.log('');
+        // Try to parse as JSON (with markdown extraction fallback)
+        const parsed = extractJSON(response.content || '');
+        console.log('✓ Successfully parsed as JSON');
+        console.log('');
+        console.log('Parsed structure:');
+        console.log(JSON.stringify(parsed, null, 2));
+        console.log('');
+        console.log('✅ JSON Object Mode (Beta): PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ JSON Object Mode (Beta): FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testJsonSchemaModeBeta() {
+    console.log('Test 2: JSON Schema Mode (Beta - Prompt Engineering)');
+    console.log('-'.repeat(80));
+    const schema = {
+        type: 'object',
+        properties: {
+            name: { type: 'string' },
+            age: { type: 'number' },
+            city: { type: 'string' },
+        },
+        required: ['name', 'age', 'city'],
+        additionalProperties: false,
+    };
+    const systemPrompt = `You MUST respond with ONLY a valid JSON object matching this schema. Do not include ANY text before or after the JSON. Do not wrap it in markdown code blocks. Do not add explanations. ONLY output the raw JSON object.
+
+Required JSON Schema:
+${JSON.stringify(schema, null, 2)}`;
+    const request = {
+        gateId: 'test-gate',
+        model: 'mistral-medium-2508',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Create data for: name=Bob Williams, age=35, city=Paris' }
+            ],
+            systemPrompt,
+            maxTokens: 150,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Raw response content:');
+        console.log(response.content);
+        console.log('');
+        // Try to parse as JSON (with markdown extraction fallback)
+        const parsed = extractJSON(response.content || '');
+        console.log('✓ Successfully parsed as JSON');
+        console.log('');
+        console.log('Parsed structure:');
+        console.log(JSON.stringify(parsed, null, 2));
+        console.log('');
+        // Validate schema fields
+        const hasRequiredFields = parsed.name && typeof parsed.age === 'number' && parsed.city;
+        if (!hasRequiredFields) {
+            throw new Error('Missing required fields from schema');
+        }
+        console.log('✓ Schema validation passed');
+        console.log('');
+        console.log('✅ JSON Schema Mode (Beta): PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ JSON Schema Mode (Beta): FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testTextMode() {
+    console.log('Test 3: Text Mode (Control Test)');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'mistral-medium-2508',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Say hello' }
+            ],
+            maxTokens: 50,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Response content:');
+        console.log(response.content);
+        console.log('');
+        console.log('✅ Text Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ Text Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function runTests() {
+    const results = [];
+    results.push(await testJsonObjectModeBeta());
+    results.push(await testJsonSchemaModeBeta());
+    results.push(await testTextMode());
+    console.log('='.repeat(80));
+    console.log('RESULTS SUMMARY');
+    console.log('='.repeat(80));
+    console.log('');
+    const passed = results.filter(r => r).length;
+    const failed = results.filter(r => !r).length;
+    console.log(`Total Tests: ${results.length}`);
+    console.log(`Passed: ${passed}`);
+    console.log(`Failed: ${failed}`);
+    console.log('');
+    if (failed > 0) {
+        console.log('❌ Some tests failed');
+        process.exit(1);
+    }
+    else {
+        console.log('✅ All tests passed!');
+    }
+}
+runTests().catch(error => {
+    console.error('Test suite failed:', error);
+    process.exit(1);
+});

package/dist/services/providers/tests/test-json-response-format-openai.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Focused tests for JSON response format structure
+ * Tests ONLY the structured output feature at the adapter level
+ */
+export {};
+//# sourceMappingURL=test-json-response-format-openai.d.ts.map

package/dist/services/providers/tests/test-json-response-format-openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-json-response-format-openai.d.ts","sourceRoot":"","sources":["../../../../src/services/providers/tests/test-json-response-format-openai.ts"],"names":[],"mappings":";AACA;;;GAGG"}

package/dist/services/providers/tests/test-json-response-format-openai.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env npx tsx
+/**
+ * Focused tests for JSON response format structure
+ * Tests ONLY the structured output feature at the adapter level
+ */
+import { OpenAIAdapter } from '../openai-adapter.js';
+const adapter = new OpenAIAdapter();
+console.log('='.repeat(80));
+console.log('STRUCTURED OUTPUT - ADAPTER LEVEL TESTS');
+console.log('='.repeat(80));
+console.log('');
+async function testJsonObjectMode() {
+    console.log('Test 1: JSON Object Mode');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'gpt-4o-mini',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Generate a JSON user profile with name, age, and city fields' }
+            ],
+            responseFormat: 'json_object',
+            maxTokens: 100,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Raw response content:');
+        console.log(response.content);
+        console.log('');
+        // Try to parse as JSON
+        const parsed = JSON.parse(response.content || '');
+        console.log('✓ Successfully parsed as JSON');
+        console.log('');
+        console.log('Parsed structure:');
+        console.log(JSON.stringify(parsed, null, 2));
+        console.log('');
+        console.log('✅ JSON Object Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ JSON Object Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testJsonSchemaMode() {
+    console.log('Test 2: JSON Schema Mode');
+    console.log('-'.repeat(80));
+    const schema = {
+        type: 'json_schema',
+        json_schema: {
+            name: 'user_profile',
+            strict: true,
+            schema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    age: { type: 'number' },
+                    city: { type: 'string' },
+                },
+                required: ['name', 'age', 'city'],
+                additionalProperties: false,
+            },
+        },
+    };
+    const request = {
+        gateId: 'test-gate',
+        model: 'gpt-4o',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Create a profile for John Doe, age 30, from New York' }
+            ],
+            responseFormat: schema,
+            maxTokens: 100,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Raw response content:');
+        console.log(response.content);
+        console.log('');
+        // Try to parse as JSON
+        const parsed = JSON.parse(response.content || '');
+        console.log('✓ Successfully parsed as JSON');
+        console.log('');
+        console.log('Parsed structure:');
+        console.log(JSON.stringify(parsed, null, 2));
+        console.log('');
+        // Validate schema fields
+        const hasRequiredFields = parsed.name && typeof parsed.age === 'number' && parsed.city;
+        if (!hasRequiredFields) {
+            throw new Error('Missing required fields from schema');
+        }
+        console.log('✓ Schema validation passed');
+        console.log('');
+        console.log('✅ JSON Schema Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ JSON Schema Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function testTextMode() {
+    console.log('Test 3: Text Mode (Control Test)');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'gpt-4o-mini',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Say hello' }
+            ],
+            responseFormat: 'text',
+            maxTokens: 50,
+        }
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('✓ Request completed');
+        console.log('');
+        console.log('Response content:');
+        console.log(response.content);
+        console.log('');
+        console.log('✅ Text Mode: PASSED');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        console.log('❌ Text Mode: FAILED');
+        console.log('Error:', error.message);
+        console.log('');
+        return false;
+    }
+}
+async function runTests() {
+    const results = [];
+    results.push(await testJsonObjectMode());
+    results.push(await testJsonSchemaMode());
+    results.push(await testTextMode());
+    console.log('='.repeat(80));
+    console.log('RESULTS SUMMARY');
+    console.log('='.repeat(80));
+    console.log('');
+    const passed = results.filter(r => r).length;
+    const failed = results.filter(r => !r).length;
+    console.log(`Total Tests: ${results.length}`);
+    console.log(`Passed: ${passed}`);
+    console.log(`Failed: ${failed}`);
+    console.log('');
+    if (failed > 0) {
+        console.log('❌ Some tests failed');
+        process.exit(1);
+    }
+    else {
+        console.log('✅ All tests passed!');
+    }
+}
+runTests().catch(error => {
+    console.error('Test suite failed:', error);
+    process.exit(1);
+});

package/dist/services/providers/tests/test-openai-adapter.js

@@ -209,6 +209,79 @@ async function testContentAndToolCalls() {
     }
     console.log('✅ Content + tool calls test passed\n');
 }
+async function testStructuredOutputJsonObject() {
+    console.log('Testing structured output - JSON Object mode...');
+    const request = {
+        gateId: 'test-gate',
+        model: 'gpt-4o',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Generate a JSON user profile with name, age, and city fields' }
+            ],
+            responseFormat: 'json_object',
+            maxTokens: 100,
+        }
+    };
+    const response = await adapter.call(request);
+    console.log('Response:', response.content);
+    // Try to parse as JSON
+    try {
+        const parsed = JSON.parse(response.content || '');
+        console.log('Parsed JSON:', parsed);
+        console.log('✅ JSON Object mode test passed\n');
+    }
+    catch (error) {
+        throw new Error(`Response was not valid JSON: ${response.content}`);
+    }
+}
+async function testStructuredOutputJsonSchema() {
+    console.log('Testing structured output - JSON Schema mode...');
+    const schema = {
+        type: 'json_schema',
+        json_schema: {
+            name: 'user_profile',
+            strict: true,
+            schema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    age: { type: 'number' },
+                    city: { type: 'string' },
+                },
+                required: ['name', 'age', 'city'],
+                additionalProperties: false,
+            },
+        },
+    };
+    const request = {
+        gateId: 'test-gate',
+        model: 'gpt-4o',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Create a profile for John Doe, age 30, from New York' }
+            ],
+            responseFormat: schema,
+            maxTokens: 100,
+        }
+    };
+    const response = await adapter.call(request);
+    console.log('Response:', response.content);
+    // Try to parse as JSON and validate schema
+    try {
+        const parsed = JSON.parse(response.content || '');
+        console.log('Parsed JSON:', parsed);
+        // Validate required fields
+        if (!parsed.name || typeof parsed.age !== 'number' || !parsed.city) {
+            throw new Error('Response does not match schema');
+        }
+        console.log('✅ JSON Schema mode test passed\n');
+    }
+    catch (error) {
+        throw new Error(`Schema validation failed: ${error}`);
+    }
+}
 async function runTests() {
     try {
         await testChatCompletion();
@@ -218,6 +291,9 @@ async function runTests() {
         await testToolCalling();
         console.log('Testing content + tool calls...');
         await testContentAndToolCalls();
+        console.log('Testing structured output...');
+        await testStructuredOutputJsonObject();
+        await testStructuredOutputJsonSchema();
         await testImageGeneration();
         await testEmbeddings();
         await testTextToSpeech();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layer-ai/core",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "description": "Core API routes and services for Layer AI",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,7 +36,7 @@
     "nanoid": "^5.0.4",
     "openai": "^4.24.0",
     "pg": "^8.11.3",
-    "@layer-ai/sdk": "^2.5.4"
+    "@layer-ai/sdk": "^2.5.5"
   },
   "devDependencies": {
     "@types/bcryptjs": "^2.4.6",