@illuma-ai/agents 1.1.21 → 1.1.22

package/src/agents/AgentContext.test.js

@@ -1,421 +0,0 @@
-// src/agents/AgentContext.test.ts
-import { AgentContext } from './AgentContext';
-import { Providers } from '@/common';
-describe('AgentContext', () => {
-    describe('structured output', () => {
-        const baseConfig = {
-            agentId: 'test-agent',
-            provider: Providers.OPENAI,
-            clientOptions: {
-                model: 'gpt-4',
-                streaming: true,
-            },
-        };
-        describe('isStructuredOutputMode', () => {
-            it('should return false when structuredOutput is not configured', () => {
-                const context = AgentContext.fromConfig(baseConfig);
-                expect(context.isStructuredOutputMode).toBe(false);
-            });
-            it('should return false when structuredOutput has no schema', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: undefined,
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.isStructuredOutputMode).toBe(false);
-            });
-            it('should return false when structuredOutput schema is null', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: null,
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.isStructuredOutputMode).toBe(false);
-            });
-            it('should return true when structuredOutput has a valid schema', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: {
-                            type: 'object',
-                            properties: {
-                                answer: { type: 'string' },
-                            },
-                        },
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.isStructuredOutputMode).toBe(true);
-            });
-            it('should return true with minimal schema', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: { type: 'string' },
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.isStructuredOutputMode).toBe(true);
-            });
-            // Snake_case structured_output tests (database/API format)
-            it('should return true when structured_output (snake_case) is enabled with schema', () => {
-                const config = {
-                    ...baseConfig,
-                    structured_output: {
-                        enabled: true,
-                        schema: {
-                            type: 'object',
-                            properties: {
-                                result: { type: 'string' },
-                            },
-                        },
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.isStructuredOutputMode).toBe(true);
-            });
-            it('should return false when structured_output is not enabled', () => {
-                const config = {
-                    ...baseConfig,
-                    structured_output: {
-                        enabled: false,
-                        schema: {
-                            type: 'object',
-                            properties: {
-                                result: { type: 'string' },
-                            },
-                        },
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.isStructuredOutputMode).toBe(false);
-            });
-            it('should return false when structured_output has no schema', () => {
-                const config = {
-                    ...baseConfig,
-                    structured_output: {
-                        enabled: true,
-                        // No schema
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.isStructuredOutputMode).toBe(false);
-            });
-            it('should prefer structuredOutput (camelCase) over structured_output (snake_case)', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: {
-                            type: 'object',
-                            properties: { camel: { type: 'string' } },
-                        },
-                        name: 'CamelSchema',
-                    },
-                    structured_output: {
-                        enabled: true,
-                        schema: {
-                            type: 'object',
-                            properties: { snake: { type: 'string' } },
-                        },
-                        name: 'SnakeSchema',
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.isStructuredOutputMode).toBe(true);
-                expect(context.structuredOutput?.name).toBe('CamelSchema');
-            });
-            it('should convert structured_output properties correctly', () => {
-                const config = {
-                    ...baseConfig,
-                    structured_output: {
-                        enabled: true,
-                        schema: {
-                            type: 'object',
-                            properties: { data: { type: 'string' } },
-                        },
-                        name: 'TestResponse',
-                        description: 'A test response',
-                        mode: 'provider',
-                        strict: true,
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.structuredOutput).toEqual({
-                    schema: {
-                        type: 'object',
-                        properties: { data: { type: 'string' } },
-                    },
-                    name: 'TestResponse',
-                    description: 'A test response',
-                    mode: 'provider',
-                    strict: true,
-                });
-            });
-        });
-        describe('getStructuredOutputSchema', () => {
-            it('should return undefined when structuredOutput is not configured', () => {
-                const context = AgentContext.fromConfig(baseConfig);
-                expect(context.getStructuredOutputSchema()).toBeUndefined();
-            });
-            it('should return undefined when schema is not set', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {},
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.getStructuredOutputSchema()).toBeUndefined();
-            });
-            it('should return the schema as-is when properly configured', () => {
-                const schema = {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string' },
-                        age: { type: 'number' },
-                    },
-                };
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: { schema },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result).toMatchObject(schema);
-            });
-            it('should add type: object when properties exist but type is missing', () => {
-                const schema = {
-                    properties: {
-                        name: { type: 'string' },
-                    },
-                };
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: { schema },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.type).toBe('object');
-            });
-            it('should add title from config name', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: { type: 'object' },
-                        name: 'ResponseSchema',
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.title).toBe('ResponseSchema');
-            });
-            it('should not override existing title', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: { type: 'object', title: 'ExistingTitle' },
-                        name: 'NewName',
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.title).toBe('ExistingTitle');
-            });
-            it('should add description from config', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: { type: 'object' },
-                        description: 'A structured response',
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.description).toBe('A structured response');
-            });
-            it('should not override existing description', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: { type: 'object', description: 'Original description' },
-                        description: 'New description',
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.description).toBe('Original description');
-            });
-            it('should set additionalProperties: false in strict mode by default', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: { type: 'object', properties: {} },
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.additionalProperties).toBe(false);
-            });
-            it('should set additionalProperties: false when strict is explicitly true', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: { type: 'object', properties: {} },
-                        strict: true,
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.additionalProperties).toBe(false);
-            });
-            it('should not set additionalProperties when strict is false', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: { type: 'object', properties: {} },
-                        strict: false,
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.additionalProperties).toBeUndefined();
-            });
-            it('should preserve existing additionalProperties value', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: {
-                            type: 'object',
-                            properties: {},
-                            additionalProperties: true,
-                        },
-                        strict: true,
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.additionalProperties).toBe(true);
-            });
-            it('should not affect non-object types', () => {
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: { type: 'array', items: { type: 'string' } },
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                const result = context.getStructuredOutputSchema();
-                expect(result?.additionalProperties).toBeUndefined();
-                expect(result?.type).toBe('array');
-            });
-            it('should not mutate the original schema', () => {
-                const originalSchema = {
-                    type: 'object',
-                    properties: { name: { type: 'string' } },
-                };
-                const config = {
-                    ...baseConfig,
-                    structuredOutput: {
-                        schema: originalSchema,
-                        name: 'TestSchema',
-                        description: 'Test description',
-                    },
-                };
-                const context = AgentContext.fromConfig(config);
-                context.getStructuredOutputSchema();
-                // Original should not have been modified
-                expect(originalSchema).not.toHaveProperty('title');
-                expect(originalSchema).not.toHaveProperty('description');
-                expect(originalSchema).not.toHaveProperty('additionalProperties');
-            });
-        });
-        describe('fromConfig with structuredOutput', () => {
-            it('should properly initialize structuredOutput from config', () => {
-                const structuredOutput = {
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            response: { type: 'string' },
-                            confidence: { type: 'number' },
-                        },
-                        required: ['response'],
-                    },
-                    name: 'AnalysisResult',
-                    description: 'The analysis result',
-                    mode: 'auto',
-                    strict: true,
-                };
-                const config = {
-                    ...baseConfig,
-                    structuredOutput,
-                };
-                const context = AgentContext.fromConfig(config);
-                expect(context.isStructuredOutputMode).toBe(true);
-                expect(context.structuredOutput).toEqual(structuredOutput);
-            });
-            it('should handle all mode options', () => {
-                const modes = [
-                    'auto',
-                    'tool',
-                    'provider',
-                ];
-                for (const mode of modes) {
-                    const config = {
-                        ...baseConfig,
-                        structuredOutput: {
-                            schema: { type: 'object' },
-                            mode,
-                        },
-                    };
-                    const context = AgentContext.fromConfig(config);
-                    expect(context.structuredOutput?.mode).toBe(mode);
-                }
-            });
-        });
-    });
-    describe('summarizeCallback', () => {
-        const baseConfig = {
-            agentId: 'test-agent',
-            provider: Providers.OPENAI,
-            clientOptions: {
-                model: 'gpt-4',
-                streaming: true,
-            },
-        };
-        it('should not have summarizeCallback by default', () => {
-            const context = AgentContext.fromConfig(baseConfig);
-            expect(context.summarizeCallback).toBeUndefined();
-        });
-        it('should set summarizeCallback when provided in config', () => {
-            const config = {
-                ...baseConfig,
-                summarizeCallback: async () => 'summary',
-            };
-            const context = AgentContext.fromConfig(config);
-            expect(context.summarizeCallback).toBeDefined();
-        });
-        it('should preserve summarizeCallback function reference', () => {
-            const mockCallback = jest.fn(async () => 'mock summary');
-            const config = {
-                ...baseConfig,
-                summarizeCallback: mockCallback,
-            };
-            const context = AgentContext.fromConfig(config);
-            expect(context.summarizeCallback).toBe(mockCallback);
-        });
-        it('should allow summarizeCallback to be called', async () => {
-            const mockCallback = jest.fn(async () => 'summarized content');
-            const config = {
-                ...baseConfig,
-                summarizeCallback: mockCallback,
-            };
-            const context = AgentContext.fromConfig(config);
-            const result = await context.summarizeCallback([]);
-            expect(result).toBe('summarized content');
-            expect(mockCallback).toHaveBeenCalledTimes(1);
-        });
-    });
-});
-//# sourceMappingURL=AgentContext.test.js.map