Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* Gateway adapter tests for runThink (#952 fix).
*
* Pre-v0.36, runThink instantiated `new Anthropic()` directly. Closing #952
* routed it through gateway.chat() so MCP stdio launches pick up
* `anthropic_api_key` from gbrain config instead of process.env.
*
* The adapter shape was determined by plan-eng-review D10 (cross-model
* tension D10 with codex C7+C8+C9+C10):
* - drop new Anthropic() entirely
* - real availability check (NOT a false-positive `getChatModel()` truthy)
* - model-id normalization (bare → provider-prefixed)
* - response-shape conversion (ChatResult → Anthropic.Message)
*
* These tests pin the four spec points. Hermetic — no real LLM call: the "unconfigured" fixtures use
* `__unconfigureGatewayForTests()` (since #3554 `resetGateway()` re-applies the preload's configured baseline, so
* it is NOT "unconfigured" and sent two real HTTPS requests to the provider with the fake key, #6514). Forced probe:
* `GBRAIN_TEST_NET_LOG=$L bun test --preload ./test/helpers/no-network-preload.ts test/think-gateway-adapter.test.ts`
* is 17/17 with an empty net log; the old fixtures were 16/17 with two provider URLs in the log.
*/
import { describe, test, expect, afterEach } from 'bun:test';
import { __thinkAdapter } from '../src/core/think/index.ts';
import { resetGateway, __unconfigureGatewayForTests } from '../src/core/ai/gateway.ts';
import { AIConfigError } from '../src/core/ai/errors.ts';
import { withEnv, emptyHome } from './helpers/with-env.ts';
// A filtered run must not leave the gateway empty for the next file's beforeAll (the #3554 baseline).
afterEach(() => { resetGateway(); });
describe('think gateway adapter — response shape conversion', () => {
test('chatResultToMessage maps ChatResult.text to Anthropic.Message content[0].text', () => {
const out = __thinkAdapter.chatResultToMessage(
{
text: '{"answer":"hi","citations":[],"gaps":[]}',
blocks: [],
stopReason: 'end',
usage: { input_tokens: 5, output_tokens: 2, cache_read_tokens: 0, cache_creation_tokens: 0 },
model: 'anthropic:claude-opus-4-7',
providerId: 'anthropic',
},
'anthropic:claude-opus-4-7',
);
expect(out.content[0].type).toBe('text');
expect(out.content[0].text).toBe('{"answer":"hi","citations":[],"gaps":[]}');
expect(out.usage.input_tokens).toBe(5);
expect(out.usage.output_tokens).toBe(2);
expect(out.stop_reason).toBe('end_turn');
expect(out.model).toBe('anthropic:claude-opus-4-7');
});
test('mapStopReason covers the full provider-neutral stop-reason set', () => {
expect(__thinkAdapter.mapStopReason('end')).toBe('end_turn');
expect(__thinkAdapter.mapStopReason('length')).toBe('max_tokens');
expect(__thinkAdapter.mapStopReason('tool_calls')).toBe('tool_use');
// 'refusal', 'content_filter', 'other' → end_turn (no Anthropic equivalent).
expect(__thinkAdapter.mapStopReason('refusal')).toBe('end_turn');
expect(__thinkAdapter.mapStopReason('content_filter')).toBe('end_turn');
expect(__thinkAdapter.mapStopReason('other')).toBe('end_turn');
});
});
describe('think gateway adapter — model-id normalization', () => {
test('tryBuildGatewayClient accepts bare anthropic model ids and prefixes anthropic:', async () => {
// Bare model: `claude-opus-4-7` → must resolve through `anthropic:` recipe.
// resolveRecipe will throw AIConfigError for unknown providers, so a
// successful build proves the prefix landed.
await withEnv({ ANTHROPIC_API_KEY: 'sk-test-fake' }, async () => {
const client = await __thinkAdapter.tryBuildGatewayClient('claude-opus-4-7');
expect(client).not.toBeNull();
});
});
test('tryBuildGatewayClient accepts already-prefixed provider:model strings', async () => {
await withEnv({ ANTHROPIC_API_KEY: 'sk-test-fake' }, async () => {
const client = await __thinkAdapter.tryBuildGatewayClient('anthropic:claude-sonnet-4-6');
expect(client).not.toBeNull();
});
});
test('tryBuildGatewayClient returns null on unknown provider (AIConfigError → graceful fallback)', async () => {
const client = await __thinkAdapter.tryBuildGatewayClient('nonexistent-provider:foo-1');
expect(client).toBeNull();
});
test('tryBuildGatewayClient returns null when ANTHROPIC_API_KEY is absent (preserves legacy NO_ANTHROPIC_API_KEY signal)', async () => {
await withEnv({ ANTHROPIC_API_KEY: undefined, GBRAIN_HOME: emptyHome() }, async () => {
const client = await __thinkAdapter.tryBuildGatewayClient('claude-opus-4-7');
expect(client).toBeNull();
});
});
test('hasAnthropicKey reads process.env', async () => {
await withEnv({ ANTHROPIC_API_KEY: 'sk-test-key' }, async () => {
expect(__thinkAdapter.hasAnthropicKey()).toBe(true);
});
await withEnv({ ANTHROPIC_API_KEY: undefined, GBRAIN_HOME: emptyHome() }, async () => {
expect(__thinkAdapter.hasAnthropicKey()).toBe(false);
});
});
});
describe('think gateway adapter — #1698 slash form + explicit-model fork', () => {
test('tryBuildGatewayClient accepts SLASH form (anthropic/claude-...) — the reported bug', async () => {
// Pre-fix the colon-only inline produced `anthropic:anthropic/claude-sonnet-4-6`
// and the client silently degraded. normalizeModelId fixes it → builds cleanly.
await withEnv({ ANTHROPIC_API_KEY: 'sk-test-fake' }, async () => {
const client = await __thinkAdapter.tryBuildGatewayClient('anthropic/claude-sonnet-4-6');
expect(client).not.toBeNull();
});
});
test('explicit unresolvable model THROWS (does not degrade to null)', async () => {
await expect(
__thinkAdapter.tryBuildGatewayClient('bogusprovider:foo-1', { explicitModel: true }),
).rejects.toThrow(/not usable.*unknown_provider/);
});
test('explicit chat-less-provider model THROWS (unknown_model)', async () => {
// voyage has no chat touchpoint. Unlisted ids on chat-capable providers
// pass local validation (no runtime allowlist) — the provider decides.
await expect(
__thinkAdapter.tryBuildGatewayClient('voyage:voyage-3', { explicitModel: true }),
).rejects.toThrow(/not usable.*unknown_model/);
});
test('explicit anthropic model with no key THROWS (unavailable)', async () => {
await withEnv({ ANTHROPIC_API_KEY: undefined, GBRAIN_HOME: emptyHome() }, async () => {
await expect(
__thinkAdapter.tryBuildGatewayClient('anthropic:claude-sonnet-4-6', { explicitModel: true }),
).rejects.toThrow(/not usable.*unavailable/);
});
});
test('NON-explicit unresolvable model returns null (graceful, unchanged)', async () => {
const client = await __thinkAdapter.tryBuildGatewayClient('bogusprovider:foo-1', { explicitModel: false });
expect(client).toBeNull();
});
test('create-callback fork: explicit rethrows AIConfigError; non-explicit returns the sentinel', async () => {
await withEnv({ ANTHROPIC_API_KEY: 'sk-test-fake' }, async () => {
// Build valid clients (key present → probe ok) but leave the gateway UNCONFIGURED
// so gateway.chat() throws AIConfigError (requireConfig) at create() time.
__unconfigureGatewayForTests();
const params: any = {
model: 'anthropic:claude-sonnet-4-6',
max_tokens: 16,
system: 'sys',
messages: [{ role: 'user', content: 'hi' }],
};
const explicitClient = await __thinkAdapter.tryBuildGatewayClient(
'anthropic:claude-sonnet-4-6', { explicitModel: true },
);
expect(explicitClient).not.toBeNull();
// Specifically the config error: a network/auth error from a configured gateway must not satisfy this fork.
await expect(explicitClient!.create(params)).rejects.toBeInstanceOf(AIConfigError);
const gracefulClient = await __thinkAdapter.tryBuildGatewayClient(
'anthropic:claude-sonnet-4-6', { explicitModel: false },
);
expect(gracefulClient).not.toBeNull();
const msg = await gracefulClient!.create(params);
const text = msg.content.find((b: any) => b.type === 'text');
expect(text && 'text' in text ? text.text : '').toContain('no LLM available');
});
});
// D1 BACKSTOP (codex #1, accepted-as-is): probeChatModel only PRE-checks the Anthropic
// key, so an explicit NON-anthropic model (deepseek/openai/...) passes the early gate and
// BUILDS a client even with no provider key — its key is checked lazily at chat time. The
// create-callback rethrow is then the ONLY thing standing between "explicit unusable model"
// and a silent degrade. This test locks that backstop into a contract: the client builds
// (proving the deviation), and create() HARD-ERRORS (proving it never degrades to the
// 'no LLM available' stub). A future refactor that turns this into a graceful path fails here.
test('D1 backstop: explicit non-anthropic model, no key → BUILDS then create() THROWS (never a stub)', async () => {
await withEnv(
{ ANTHROPIC_API_KEY: undefined, DEEPSEEK_API_KEY: undefined, OPENAI_API_KEY: undefined, GBRAIN_HOME: emptyHome() },
async () => {
__unconfigureGatewayForTests(); // unconfigured → gateway.chat() throws AIConfigError at create()
// deepseek:deepseek-chat passes validateModelId (real recipe + chat touchpoint) — the
// A9 non-anthropic model. probeChatModel returns ok (no anthropic key check) → builds.
const client = await __thinkAdapter.tryBuildGatewayClient(
'deepseek:deepseek-chat', { explicitModel: true },
);
expect(client).not.toBeNull(); // proves the early gate did NOT pre-reject non-anthropic
const params: any = {
model: 'deepseek:deepseek-chat',
max_tokens: 16,
system: 'sys',
messages: [{ role: 'user', content: 'hi' }],
};
// The backstop fires: explicit → AIConfigError rethrown, NOT the graceful sentinel.
await expect(client!.create(params)).rejects.toBeInstanceOf(AIConfigError);
},
);
});
});
describe('think gateway adapter — current-generation recipe models', () => {
test('builds clients for Opus 4.8 / Sonnet 5 / Fable 5 (recipe-list refresh)', async () => {
// Regression guard: these GA models were absent from the recipe allowlist,
// so a tier-configured deep model degraded think to the no-LLM stub.
await withEnv({ ANTHROPIC_API_KEY: 'sk-test-fake' }, async () => {
for (const id of [
'anthropic:claude-opus-4-8',
'anthropic:claude-sonnet-5',
'anthropic:claude-fable-5',
]) {
const client = await __thinkAdapter.tryBuildGatewayClient(id);
expect(client).not.toBeNull();
}
});
});
});
describe('think gateway adapter — graceful fallback shape', () => {
test('buildGracefulMessage produces a parseable Anthropic.Message-shaped object', () => {
const m = __thinkAdapter.buildGracefulMessage('anthropic:claude-opus-4-7');
expect(m.type).toBe('message');
expect(m.role).toBe('assistant');
expect(m.content[0].type).toBe('text');
expect(m.content[0].text).toContain('no LLM available');
expect(m.content[0].text).toContain('gbrain config');
expect(m.usage.input_tokens).toBe(0);
expect(m.usage.output_tokens).toBe(0);
expect(m.stop_reason).toBe('end_turn');
});
test('the sentinel surfaces the AIConfigError cause, not generic key advice', () => {
// With no runtime model allowlist, a nonexistent model id reaches the
// provider and comes back as a 4xx wrapped in AIConfigError. The sentinel
// must name that cause — the generic text key-blamed model problems.
const err = new AIConfigError(
'[chat(openai:gpt-bogus)] The model `gpt-bogus` does not exist',
'Check your model id + provider options match the provider API.',
);
const m = __thinkAdapter.buildGracefulMessage('openai:gpt-bogus', err);
expect(m.content[0].text).toContain('does not exist');
expect(m.content[0].text).toContain('Check your model id');
expect(m.content[0].text).not.toContain('ANTHROPIC_API_KEY');
});
});