Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
import { describe, test, expect } from 'bun:test';
import { buildError, errorFor, serializeError, StructuredAgentError } from '../src/core/errors.ts';
import { providerContentBlockReason, normalizeAIError } from '../src/core/ai/errors.ts';
describe('providerContentBlockReason', () => {
const blocked = Object.assign(new Error('Invalid JSON response'), {
name: 'AI_APICallError', statusCode: 200,
responseBody: JSON.stringify({ promptFeedback: { blockReason: 'PROHIBITED_CONTENT' } }),
});
test('recognizes a blocked response through normalization', () => {
expect(providerContentBlockReason(blocked)).toBe('PROHIBITED_CONTENT');
expect(providerContentBlockReason(normalizeAIError(blocked, 'chat(google:x)'))).toBe('PROHIBITED_CONTENT');
expect(providerContentBlockReason({ responseBody: JSON.stringify({ candidates: [{ finishReason: 'SAFETY', content: { parts: [] } }] }) })).toBe('SAFETY');
});
test('ignores ordinary provider failures and malformed bodies', () => {
for (const err of [
{ statusCode: 500, responseBody: blocked.responseBody },
new Error('timeout'),
{ responseBody: 'not json' },
{ statusCode: 200 },
{ responseBody: JSON.stringify({ candidates: [{ finishReason: 'SAFETY', content: { parts: [{ text: 'answer' }] } }] }) },
]) expect(providerContentBlockReason(err)).toBeUndefined();
});
});
describe('buildError', () => {
test('returns envelope with required fields only', () => {
const e = buildError({ class: 'FooError', code: 'foo_bar', message: 'something went wrong' });
expect(e).toEqual({ class: 'FooError', code: 'foo_bar', message: 'something went wrong' });
});
test('includes hint when provided', () => {
const e = buildError({ class: 'X', code: 'y', message: 'm', hint: 'try --foo' });
expect(e.hint).toBe('try --foo');
});
test('includes docs_url when provided', () => {
const e = buildError({ class: 'X', code: 'y', message: 'm', docs_url: 'https://example.com/docs' });
expect(e.docs_url).toBe('https://example.com/docs');
});
test('omits undefined optional fields from shape', () => {
const e = buildError({ class: 'X', code: 'y', message: 'm' });
expect('hint' in e).toBe(false);
expect('docs_url' in e).toBe(false);
});
});
describe('StructuredAgentError', () => {
test('is throwable and catchable as Error', () => {
try {
throw errorFor({ class: 'FileTooLarge', code: 'too_big', message: 'file exceeds 10MB' });
} catch (e) {
expect(e).toBeInstanceOf(Error);
expect(e).toBeInstanceOf(StructuredAgentError);
}
});
test('carries the structured envelope', () => {
const err = errorFor({ class: 'X', code: 'y', message: 'z', hint: 'fix it' });
expect(err.envelope).toEqual({ class: 'X', code: 'y', message: 'z', hint: 'fix it' });
});
test('uses class name for Error.name', () => {
const err = errorFor({ class: 'FooBarError', code: 'x', message: 'y' });
expect(err.name).toBe('FooBarError');
});
test('Error.message composes class + message + hint', () => {
const err = errorFor({
class: 'ConfirmationRequired',
code: 'cost_preview_requires_yes',
message: 'cost preview requires --yes in non-interactive mode',
hint: 'pass --yes to proceed',
});
expect(err.message).toBe(
'ConfirmationRequired: cost preview requires --yes in non-interactive mode (pass --yes to proceed)',
);
});
});
describe('serializeError', () => {
test('unwraps StructuredAgentError envelope', () => {
const err = errorFor({ class: 'A', code: 'b', message: 'c', hint: 'd' });
expect(serializeError(err)).toEqual({ class: 'A', code: 'b', message: 'c', hint: 'd' });
});
test('normalizes plain Error', () => {
const err = new Error('boom');
err.name = 'MyError';
const env = serializeError(err);
expect(env.class).toBe('MyError');
expect(env.code).toBe('unknown');
expect(env.message).toBe('boom');
});
test('handles non-Error values', () => {
const env = serializeError('a string');
expect(env).toEqual({ class: 'Error', code: 'unknown', message: 'a string' });
});
test('handles null/undefined', () => {
expect(serializeError(null).message).toBe('null');
expect(serializeError(undefined).message).toBe('undefined');
});
});