@illuma-ai/agents 1.0.81

package/src/agents/AgentContext.test.ts

@@ -0,0 +1,458 @@
+// src/agents/AgentContext.test.ts
+import { AgentContext } from './AgentContext';
+import { Providers } from '@/common';
+import type * as t from '@/types';
+
+describe('AgentContext', () => {
+  describe('structured output', () => {
+    const baseConfig: t.AgentInputs = {
+      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: t.AgentInputs = {
+          ...baseConfig,
+          structuredOutput: {
+            schema: undefined as unknown as Record<string, unknown>,
+          },
+        };
+        const context = AgentContext.fromConfig(config);
+        expect(context.isStructuredOutputMode).toBe(false);
+      });
+
+      it('should return false when structuredOutput schema is null', () => {
+        const config: t.AgentInputs = {
+          ...baseConfig,
+          structuredOutput: {
+            schema: null as unknown as Record<string, unknown>,
+          },
+        };
+        const context = AgentContext.fromConfig(config);
+        expect(context.isStructuredOutputMode).toBe(false);
+      });
+
+      it('should return true when structuredOutput has a valid schema', () => {
+        const config: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...baseConfig,
+          structuredOutput: {} as t.StructuredOutputConfig,
+        };
+        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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.AgentInputs = {
+          ...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: t.StructuredOutputConfig = {
+          schema: {
+            type: 'object',
+            properties: {
+              response: { type: 'string' },
+              confidence: { type: 'number' },
+            },
+            required: ['response'],
+          },
+          name: 'AnalysisResult',
+          description: 'The analysis result',
+          mode: 'auto',
+          strict: true,
+        };
+
+        const config: t.AgentInputs = {
+          ...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: Array<t.StructuredOutputMode> = [
+          'auto',
+          'tool',
+          'provider',
+        ];
+
+        for (const mode of modes) {
+          const config: t.AgentInputs = {
+            ...baseConfig,
+            structuredOutput: {
+              schema: { type: 'object' },
+              mode,
+            },
+          };
+          const context = AgentContext.fromConfig(config);
+          expect(context.structuredOutput?.mode).toBe(mode);
+        }
+      });
+    });
+  });
+
+  describe('summarizeCallback', () => {
+    const baseConfig: t.AgentInputs = {
+      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: t.AgentInputs = {
+        ...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: t.AgentInputs = {
+        ...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: t.AgentInputs = {
+        ...baseConfig,
+        summarizeCallback: mockCallback,
+      };
+      const context = AgentContext.fromConfig(config);
+      const result = await context.summarizeCallback!([]);
+      expect(result).toBe('summarized content');
+      expect(mockCallback).toHaveBeenCalledTimes(1);
+    });
+  });
+});