// src/agents/__tests__/resolveStructuredOutputMode.test.ts
import { AgentContext } from '../AgentContext';
import { Providers } from '@/common';
import type * as t from '@/types';

describe('resolveStructuredOutputMode', () => {
  const createContext = (
    provider: Providers,
    mode?: t.StructuredOutputMode,
  ): AgentContext => {
    return AgentContext.fromConfig({
      agentId: 'test-agent',
      provider,
      instructions: 'Test',
      structuredOutput: {
        schema: { type: 'object', properties: { name: { type: 'string' } } },
        mode,
      },
    });
  };

  describe('auto mode resolution', () => {
    it('resolves to jsonSchema for Anthropic', () => {
      const ctx = createContext(Providers.ANTHROPIC, 'auto');
      const { method, warnings } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('jsonSchema');
      expect(warnings).toEqual([]);
    });

    it('resolves to jsonSchema for OpenAI', () => {
      const ctx = createContext(Providers.OPENAI, 'auto');
      const { method, warnings } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('jsonSchema');
      expect(warnings).toEqual([]);
    });

    it('resolves to jsonSchema for Azure', () => {
      const ctx = createContext(Providers.AZURE, 'auto');
      const { method, warnings } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('jsonSchema');
      expect(warnings).toEqual([]);
    });

    it('resolves to undefined (LangChain default) for Bedrock', () => {
      const ctx = createContext(Providers.BEDROCK, 'auto');
      const { method } = ctx.resolveStructuredOutputMode();
      expect(method).toBeUndefined();
    });

    it('resolves to undefined for Google', () => {
      const ctx = createContext(Providers.GOOGLE, 'auto');
      const { method } = ctx.resolveStructuredOutputMode();
      expect(method).toBeUndefined();
    });

    it('resolves to undefined for OpenRouter', () => {
      const ctx = createContext(Providers.OPENROUTER, 'auto');
      const { method } = ctx.resolveStructuredOutputMode();
      expect(method).toBeUndefined();
    });

    it('defaults to auto when mode is undefined', () => {
      const ctx = createContext(Providers.OPENAI, undefined);
      const { method } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('jsonSchema');
    });
  });

  describe('native mode resolution', () => {
    it('resolves to jsonSchema for Anthropic', () => {
      const ctx = createContext(Providers.ANTHROPIC, 'native');
      const { method, warnings } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('jsonSchema');
      expect(warnings).toEqual([]);
    });

    it('resolves to jsonSchema for OpenAI', () => {
      const ctx = createContext(Providers.OPENAI, 'native');
      const { method } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('jsonSchema');
    });

    it('falls back to functionCalling for Bedrock with warning', () => {
      const ctx = createContext(Providers.BEDROCK, 'native');
      const { method, warnings } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('functionCalling');
      expect(warnings.length).toBe(1);
      expect(warnings[0]).toContain('not supported');
      expect(warnings[0]).toContain('Falling back');
    });

    it('falls back to functionCalling for Google with warning', () => {
      const ctx = createContext(Providers.GOOGLE, 'native');
      const { method, warnings } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('functionCalling');
      expect(warnings.length).toBe(1);
    });
  });

  describe('tool mode resolution', () => {
    it('always resolves to functionCalling regardless of provider', () => {
      const providers = [
        Providers.ANTHROPIC,
        Providers.OPENAI,
        Providers.AZURE,
        Providers.BEDROCK,
        Providers.GOOGLE,
      ];

      for (const provider of providers) {
        const ctx = createContext(provider, 'tool');
        const { method } = ctx.resolveStructuredOutputMode();
        expect(method).toBe('functionCalling');
      }
    });
  });

  describe('provider mode resolution', () => {
    it('resolves to jsonMode for Anthropic', () => {
      const ctx = createContext(Providers.ANTHROPIC, 'provider');
      const { method } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('jsonMode');
    });

    it('resolves to jsonMode for OpenAI', () => {
      const ctx = createContext(Providers.OPENAI, 'provider');
      const { method } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('jsonMode');
    });

    it('resolves to functionCalling for Bedrock (no jsonMode support)', () => {
      const ctx = createContext(Providers.BEDROCK, 'provider');
      const { method } = ctx.resolveStructuredOutputMode();
      expect(method).toBe('functionCalling');
    });
  });
});