Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* Task 5: provider-neutral contextual synopsis model routing.
* Hermetic resolver coverage; no DB or provider credentials required.
*/
import { afterEach, describe, expect, test } from 'bun:test';
import { TIER_DEFAULTS, resolveModel } from '../src/core/model-config.ts';
import { runModels } from '../src/commands/models.ts';
import {
makeContextualReindexHandler,
resolveContextualSynopsisLeaseSettings,
resolveContextualSynopsisModel,
} from '../src/core/minions/handlers/contextual-reindex-per-chunk.ts';
import type { ReembedPageArgs } from '../src/core/contextual-retrieval-service.ts';
import {
__setGenerateTextTransportForTests,
chat,
configureGateway,
resetGateway,
validateModelId,
} from '../src/core/ai/gateway.ts';
import { withEnv } from './helpers/with-env.ts';
class StubConfigEngine {
private readonly config = new Map<string, string>();
readonly reads: string[] = [];
set(key: string, value: string): void {
this.config.set(key, value);
}
unset(key: string): void {
this.config.delete(key);
}
async getConfig(key: string): Promise<string | null> {
this.reads.push(key);
return this.config.get(key) ?? null;
}
async getPage(): Promise<{ source_id: string }> {
return { source_id: 'default' };
}
}
afterEach(() => {
__setGenerateTextTransportForTests(null);
resetGateway();
});
describe('contextual synopsis model resolution', () => {
test('isolates rate leases by resolved model', () => {
expect(resolveContextualSynopsisLeaseSettings('openai:gpt-5.2', {})).toMatchObject({
key: 'contextual-synopsis:openai:gpt-5.2',
});
expect(resolveContextualSynopsisLeaseSettings('anthropic:claude-haiku-4-5', {})).toMatchObject({
key: 'contextual-synopsis:anthropic:claude-haiku-4-5',
});
});
test('prefers the canonical synopsis RPM setting over the Haiku alias', () => {
expect(resolveContextualSynopsisLeaseSettings('openai:gpt-5.2', {
GBRAIN_CONTEXTUAL_SYNOPSIS_RPM: '17',
GBRAIN_CONTEXTUAL_HAIKU_RPM: '9',
})).toEqual({
key: 'contextual-synopsis:openai:gpt-5.2',
maxConcurrent: 17,
});
});
test('retains the Haiku RPM alias and the existing default', () => {
expect(resolveContextualSynopsisLeaseSettings('anthropic:claude-haiku-4-5', {
GBRAIN_CONTEXTUAL_HAIKU_RPM: '9',
})).toEqual({
key: 'contextual-synopsis:anthropic:claude-haiku-4-5',
maxConcurrent: 9,
});
expect(resolveContextualSynopsisLeaseSettings('openai:gpt-5.2', {})).toEqual({
key: 'contextual-synopsis:openai:gpt-5.2',
maxConcurrent: 50,
});
});
test('uses the canonical precedence and utility tier keeps caller fallback unreachable', async () => {
const engine = new StubConfigEngine();
engine.set('models.contextual_synopsis', 'codex-proxy:new-key');
engine.set('contextual_retrieval.haiku_model', 'codex-proxy:deprecated-key');
engine.set('models.default', 'codex-proxy:global-default');
engine.set('models.tier.utility', 'codex-proxy:utility-tier');
await withEnv({ GBRAIN_CONTEXTUAL_SYNOPSIS_MODEL: 'codex-proxy:env-model' }, async () => {
expect(await resolveContextualSynopsisModel(engine as never, 'codex-proxy:explicit')).toBe(
'codex-proxy:explicit',
);
expect(await resolveContextualSynopsisModel(engine as never)).toBe('codex-proxy:new-key');
engine.unset('models.contextual_synopsis');
expect(await resolveContextualSynopsisModel(engine as never)).toBe(
'codex-proxy:deprecated-key',
);
engine.unset('contextual_retrieval.haiku_model');
// #3873: models.tier.utility (specific) now beats models.default (generic).
expect(await resolveContextualSynopsisModel(engine as never)).toBe(
'codex-proxy:utility-tier',
);
engine.unset('models.tier.utility');
expect(await resolveContextualSynopsisModel(engine as never)).toBe(
'codex-proxy:global-default',
);
engine.unset('models.default');
expect(await resolveContextualSynopsisModel(engine as never)).toBe(
'codex-proxy:env-model',
);
});
expect(await resolveContextualSynopsisModel(engine as never)).toBe(TIER_DEFAULTS.utility);
expect(
await resolveModel(engine as never, {
configKey: 'models.contextual_synopsis',
deprecatedConfigKey: 'contextual_retrieval.haiku_model',
envVar: 'GBRAIN_CONTEXTUAL_SYNOPSIS_MODEL',
tier: 'utility',
fallback: 'codex-proxy:caller-fallback-must-not-win',
}),
).toBe(TIER_DEFAULTS.utility);
});
test('reports the contextual synopsis route in gbrain models JSON', async () => {
const engine = new StubConfigEngine();
engine.set('models.contextual_synopsis', 'codex-proxy:gpt-5.6-luna');
let stdout = '';
const originalWrite = process.stdout.write;
process.stdout.write = ((chunk: string | Uint8Array) => {
stdout += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString();
return true;
}) as typeof process.stdout.write;
try {
await runModels(engine as never, ['--json']);
} finally {
process.stdout.write = originalWrite;
}
const report = JSON.parse(stdout) as {
per_task: Array<{
key: string;
tier: string;
resolved: string;
source: string;
description: string;
}>;
};
expect(report.per_task).toContainEqual({
key: 'models.contextual_synopsis',
tier: 'utility',
resolved: 'codex-proxy:gpt-5.6-luna',
source: 'config: models.contextual_synopsis',
description: 'Per-chunk contextual synopsis generation',
});
});
test('models report honors the synopsis deprecated key and dedicated env', async () => {
const engine = new StubConfigEngine();
engine.set('contextual_retrieval.haiku_model', 'codex-proxy:deprecated-report');
await withEnv({
GBRAIN_CONTEXTUAL_SYNOPSIS_MODEL: 'codex-proxy:dedicated-env',
GBRAIN_MODEL: 'codex-proxy:wrong-generic-env',
}, async () => {
const deprecatedReport = await captureModelsReport(engine);
expect(deprecatedReport.per_task.find((entry) =>
entry.key === 'models.contextual_synopsis'
)).toMatchObject({
resolved: 'codex-proxy:deprecated-report',
source: 'config: contextual_retrieval.haiku_model',
});
engine.unset('contextual_retrieval.haiku_model');
const envReport = await captureModelsReport(engine);
expect(envReport.per_task.find((entry) =>
entry.key === 'models.contextual_synopsis'
)).toMatchObject({
resolved: 'codex-proxy:dedicated-env',
source: 'env: GBRAIN_CONTEXTUAL_SYNOPSIS_MODEL',
});
});
});
test('handler resolves once and passes synopsisModel to the service seam', async () => {
const engine = new StubConfigEngine();
engine.set('models.contextual_synopsis', 'codex-proxy:gpt-5.6-luna');
const serviceCalls: ReembedPageArgs[] = [];
const handler = makeContextualReindexHandler({
engine: engine as never,
reembedPage: async (args) => {
serviceCalls.push(args);
return {
kind: 'success',
mode_applied: 'per_chunk_synopsis',
chunks_embedded: 1,
corpus_generation: 'test-generation',
};
},
});
const controller = new AbortController();
const result = await handler({
id: 42,
name: 'contextual_reindex_per_chunk',
data: { page_slug: 'wiki/provider-neutral' },
signal: controller.signal,
} as never);
expect(result).toEqual({
ok: true,
mode_applied: 'per_chunk_synopsis',
chunks_embedded: 1,
});
expect(engine.reads.filter((key) => key === 'models.contextual_synopsis')).toHaveLength(1);
expect(serviceCalls).toHaveLength(1);
expect(serviceCalls[0]?.synopsisModel).toBe('codex-proxy:gpt-5.6-luna');
});
test('handler registers canonical native synopsis model before service gateway chat', async () => {
await expectHandlerRegistersNativeSynopsisRoute({
configKey: 'models.contextual_synopsis',
model: 'openai:gpt-5.6-luna-contextual-canonical',
});
});
test('handler registers deprecated native synopsis model before service gateway chat', async () => {
await expectHandlerRegistersNativeSynopsisRoute({
configKey: 'contextual_retrieval.haiku_model',
model: 'openai:gpt-5.6-luna-contextual-deprecated',
});
});
test('handler registers env native synopsis model before service gateway chat', async () => {
await expectHandlerRegistersNativeSynopsisRoute({
envModel: 'openai:gpt-5.6-luna-contextual-env',
});
});
});
async function expectHandlerRegistersNativeSynopsisRoute(opts: {
configKey?: string;
model?: string;
envModel?: string;
}): Promise<void> {
const engine = new StubConfigEngine();
const expectedModel = opts.envModel ?? opts.model;
if (!expectedModel) throw new Error('expectedModel required');
if (opts.configKey && opts.model) engine.set(opts.configKey, opts.model);
const generatedModels: string[] = [];
__setGenerateTextTransportForTests((async (callOpts: { model?: { modelId?: string } }) => {
generatedModels.push(`openai:${callOpts.model?.modelId ?? '<missing>'}`);
return {
text: 'ok',
content: [{ type: 'text', text: 'ok' }],
finishReason: 'stop',
usage: { inputTokens: 1, outputTokens: 1 },
providerMetadata: {},
};
}) as never);
await withEnv(
{
OPENAI_API_KEY: 'test-openai-key',
GBRAIN_CONTEXTUAL_SYNOPSIS_MODEL: opts.envModel,
GBRAIN_MODEL: 'openai:gpt-5.2',
},
async () => {
configureGateway({
chat_model: 'openai:gpt-5.2',
expansion_model: 'openai:gpt-5.2',
embedding_model: 'openai:text-embedding-3-small',
embedding_dimensions: 1536,
env: process.env as Record<string, string | undefined>,
});
const handler = makeContextualReindexHandler({
engine: engine as never,
reembedPage: async (args) => {
expect(args.synopsisModel).toBe(expectedModel);
const chatResult = await chat({
model: args.synopsisModel,
system: 'test',
messages: [{ role: 'user', content: 'test' }],
});
expect(chatResult.model).toBe(expectedModel);
return {
kind: 'success',
mode_applied: 'per_chunk_synopsis',
chunks_embedded: 1,
corpus_generation: 'test-generation',
};
},
});
await expect(handler({
id: 42,
name: 'contextual_reindex_per_chunk',
data: { page_slug: 'wiki/provider-neutral' },
signal: new AbortController().signal,
} as never)).resolves.toEqual({
ok: true,
mode_applied: 'per_chunk_synopsis',
chunks_embedded: 1,
});
},
);
expect(generatedModels).toEqual([expectedModel]);
expect(validateModelId(expectedModel, 'chat').ok).toBe(true);
}
async function captureModelsReport(engine: StubConfigEngine): Promise<{
per_task: Array<{ key: string; resolved: string; source: string }>;
}> {
let stdout = '';
const originalWrite = process.stdout.write;
process.stdout.write = ((chunk: string | Uint8Array) => {
stdout += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString();
return true;
}) as typeof process.stdout.write;
try {
await runModels(engine as never, ['--json']);
} finally {
process.stdout.write = originalWrite;
}
return JSON.parse(stdout) as {
per_task: Array<{ key: string; resolved: string; source: string }>;
};
}