Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

4.3 KB
Raw Blame
import { AgentSpecSchema } from '../../src/agent-session/schemas/agentSpec';
import { EventType } from '../../src/agent-session/schemas/events';
import { Sessions } from '../../src/agent-session/Sessions';
import { InMemorySessionStore } from '../../src/agent-session/store/InMemorySessionStore';
import { TurnResourceResolver } from '../../src/agent-session/TurnResourceResolver';
import {
  makeAgentSpec,
  makeMockILLM,
  makeSilentLogger,
  makeTestResolver,
  mintTestTurnId,
  TEST_ACTIVE_EXECUTOR_ID,
} from './testHelpers';

describe('TurnResourceResolver.resolveAgentSpec', () => {
  it('fails closed when deps.agent is not wired for a named lookup', async () => {
    const resolver = new TurnResourceResolver({
      llm: () => Promise.resolve({ modelClient: makeMockILLM(), defaultModelParams: {} }),
      mcp: () => Promise.reject(new Error('unused')),
      mcpRequestTimeoutMs: 1_000,
      mcpConnectTimeoutMs: 1_000,
      logger: makeSilentLogger(),
    });

    await expect(resolver.resolveAgentSpec({ agent_id: 'missing' })).rejects.toThrow(/no agent lookup configured/);
  });
});

describe('TurnResourceResolver.resolveAgentDefinition', () => {
  it('allows existing model resolvers to omit an unknown context length', async () => {
    const resolver = new TurnResourceResolver({
      llm: () => Promise.resolve({ modelClient: makeMockILLM(), defaultModelParams: {} }),
      mcp: () => Promise.reject(new Error('unused')),
      mcpRequestTimeoutMs: 1_000,
      mcpConnectTimeoutMs: 1_000,
      logger: makeSilentLogger(),
    });

    const { definition } = await resolver.resolveAgentDefinition({
      spec: makeAgentSpec(),
      signal: new AbortController().signal,
      tracing: resolver.createTracing(),
    });

    expect(definition.modelProperties).toBeUndefined();
  });

  it.each([
    {
      name: 'uses the resolved model default when the agent omits max_tokens',
      resolvedModelParams: { max_tokens: 4096 },
      agentModelParams: undefined,
      expected: 4096,
    },
    {
      name: 'lets the agent max_tokens override the resolved model default',
      resolvedModelParams: { max_tokens: 4096 },
      agentModelParams: { max_tokens: 8192 },
      expected: 8192,
    },
  ])('$name', async ({ resolvedModelParams, agentModelParams, expected }) => {
    const resolver = new TurnResourceResolver({
      llm: () =>
        Promise.resolve({
          modelClient: makeMockILLM(),
          defaultModelParams: resolvedModelParams,
          modelProperties: { contextLength: 128_000 },
        }),
      mcp: () => Promise.reject(new Error('unused')),
      mcpRequestTimeoutMs: 1_000,
      mcpConnectTimeoutMs: 1_000,
      logger: makeSilentLogger(),
    });
    const spec = AgentSpecSchema.parse({
      model: {
        name: 'provider/model',
        ...(agentModelParams === undefined ? {} : { params: agentModelParams }),
      },
    });

    const { definition } = await resolver.resolveAgentDefinition({
      spec,
      signal: new AbortController().signal,
      tracing: resolver.createTracing(),
    });

    expect(definition.modelParams?.['max_tokens']).toBe(expected);
    expect(definition.modelName).toBe('provider/model');
    expect(definition.modelProperties?.contextLength).toBe(128_000);
  });
});

describe('SessionHandle.createTurn named resolve', () => {
  it('loads the live AgentSpec through resolver.agent for ref sessions', async () => {
    const store = new InMemorySessionStore();
    const sessions = new Sessions({ sessionStore: store });
    const session = await sessions.create({
      tenant_id: 'tenant-1',
      session_id: 's-named',
      created_by_subject: { subject_id: 'user-1', subject_type: 'user', subject_display_name: 'user-1' },
      agent: { type: 'reference', id: 'agent-abc', name: null },
      external_id: null,
    });

    const live = makeAgentSpec({ instructions: 'from-registry' });
    const agent = jest.fn().mockResolvedValue(live);
    const turn = await session.createTurn({
      turn_id: mintTestTurnId(),
      active_executor_id: TEST_ACTIVE_EXECUTOR_ID,
      input: [{ type: EventType.USER_MESSAGE, content: 'hi' }],
      previous_turn_id: 'none',
      signal: new AbortController().signal,
      resolver: makeTestResolver({ agent }),
    });

    expect(turn.state.status).toBe('running');
    expect(agent).toHaveBeenCalledWith('agent-abc');
  });
});