The open-source agent harness - the runtime layer that turns an LLM into a working agent.
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');
});
});