William Valentin
1189 lines
42 KiB
TypeScript
1189 lines
42 KiB
TypeScript
import { describe, it, expect, vi, afterEach } from 'vitest';
|
|
import { AgentRouter } from '../agents/router.js';
|
|
import { AgentConfigRegistry } from '../agents/registry.js';
|
|
import type { ModelTier } from '../models/router.js';
|
|
import { createMessageRouter } from './routing.js';
|
|
import { AgentOrchestrator } from '../backends/index.js';
|
|
import { CommandRegistry, registerBuiltinCommands } from '../commands/index.js';
|
|
import { ComponentRegistry } from '../intents/index.js';
|
|
import { RoutingPolicy } from '../routing/index.js';
|
|
import type { OutboundMessage } from '../channels/index.js';
|
|
import { initAuditLogger } from '../audit/index.js';
|
|
|
|
type MessageRouterDeps = Parameters<typeof createMessageRouter>[0];
|
|
type MessageRouterInput = Parameters<ReturnType<typeof createMessageRouter>['handler']>[0];
|
|
|
|
describe('daemon agent routing integration', () => {
|
|
it('resolves agent config for channel messages', () => {
|
|
const registry = new AgentConfigRegistry();
|
|
registry.loadFromConfig({
|
|
assistant: { system_prompt: 'Be helpful.', model_tier: 'default', tool_profile: 'messaging', sandbox: false },
|
|
coder: { system_prompt: 'Write code.', model_tier: 'complex', tool_profile: 'coding', sandbox: true },
|
|
});
|
|
|
|
const router = new AgentRouter({
|
|
default_agent: 'assistant',
|
|
channels: { discord: 'coder' },
|
|
senders: { 'telegram:admin': 'coder' },
|
|
});
|
|
|
|
// Discord user gets coder
|
|
const discordAgent = router.resolve('discord', 'user123');
|
|
expect(discordAgent).toBe('coder');
|
|
expect(discordAgent).toBeDefined();
|
|
const discordAgentConfig = discordAgent ? registry.get(discordAgent) : undefined;
|
|
expect(discordAgentConfig?.systemPrompt).toBe('Write code.');
|
|
|
|
// Telegram admin gets coder
|
|
const telegramAdmin = router.resolve('telegram', 'admin');
|
|
expect(telegramAdmin).toBe('coder');
|
|
|
|
// Random telegram user gets assistant
|
|
const telegramUser = router.resolve('telegram', 'random');
|
|
expect(telegramUser).toBe('assistant');
|
|
expect(telegramUser).toBeDefined();
|
|
const telegramUserConfig = telegramUser ? registry.get(telegramUser) : undefined;
|
|
expect(telegramUserConfig?.systemPrompt).toBe('Be helpful.');
|
|
});
|
|
|
|
it('uses default agent when no routing configured', () => {
|
|
const router = new AgentRouter({ channels: {}, senders: {} });
|
|
expect(router.resolve('telegram', '123')).toBeUndefined();
|
|
});
|
|
|
|
it('model tier precedence: metadata > metadata modelFor > agent config > global default', () => {
|
|
// This test documents the tier resolution precedence used by createMessageRouter.
|
|
// The actual resolution logic:
|
|
// tierFromMetadata ?? tierFromMetadataModelFor ?? agentConfig?.modelTier ?? primary_tier ?? 'default'
|
|
function resolveTier(
|
|
metadataTier: ModelTier | undefined,
|
|
metadataForTier: ModelTier | undefined,
|
|
agentTier: ModelTier | undefined,
|
|
globalTier: ModelTier | undefined,
|
|
): ModelTier {
|
|
return metadataTier ?? metadataForTier ?? agentTier ?? globalTier ?? 'default';
|
|
}
|
|
|
|
// With all three set, metadata wins
|
|
expect(resolveTier('fast', 'default', 'complex', 'default')).toBe('fast');
|
|
|
|
// Without explicit metadata tier, modelFor-resolved tier wins
|
|
expect(resolveTier(undefined, 'complex', 'default', 'fast')).toBe('complex');
|
|
|
|
// Without metadata, agent config wins
|
|
expect(resolveTier(undefined, undefined, 'complex', 'default')).toBe('complex');
|
|
|
|
// Without metadata or agent config, global wins
|
|
expect(resolveTier(undefined, undefined, undefined, 'default')).toBe('default');
|
|
|
|
// Without anything, falls back to 'default'
|
|
expect(resolveTier(undefined, undefined, undefined, undefined)).toBe('default');
|
|
});
|
|
|
|
it('uses metadata.modelFor tags to select tier', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process').mockResolvedValue('ok');
|
|
const session = {
|
|
id: 'telegram:model-for',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: {
|
|
default: { provider: 'anthropic', model: 'claude', for: ['chat'] },
|
|
fast: { provider: 'anthropic', model: 'haiku', for: ['search'] },
|
|
},
|
|
} as unknown as MessageRouterDeps['config'],
|
|
});
|
|
|
|
await router.handler({
|
|
id: 'm-model-for',
|
|
channel: 'telegram',
|
|
senderId: 'model-for',
|
|
text: 'find this quickly',
|
|
timestamp: Date.now(),
|
|
metadata: { modelFor: 'search' },
|
|
} as MessageRouterInput, vi.fn(async () => {}));
|
|
|
|
const keys = Array.from(router.agents.keys());
|
|
expect(keys.some((key) => key.endsWith(':fast'))).toBe(true);
|
|
expect(processSpy).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('daemon command fast-path integration', () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it('handles known reset command without calling agent.process', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
|
|
const session = {
|
|
id: 'telegram:user-1',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
await router.handler({
|
|
id: 'm1',
|
|
channel: 'telegram',
|
|
senderId: 'user-1',
|
|
text: '/reset',
|
|
timestamp: Date.now(),
|
|
metadata: { isCommand: true, command: 'reset' },
|
|
} as MessageRouterInput, reply);
|
|
|
|
expect(processSpy).not.toHaveBeenCalled();
|
|
expect(session.deleteConfig).toHaveBeenCalledWith('modelTier');
|
|
});
|
|
|
|
it('emits user.action audit events for channel messages', async () => {
|
|
const mockAuditLogger = {
|
|
userAction: vi.fn(),
|
|
};
|
|
initAuditLogger(mockAuditLogger as any);
|
|
|
|
const session = {
|
|
id: 'telegram:user-audit',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
});
|
|
|
|
await router.handler({
|
|
id: 'm-audit',
|
|
channel: 'telegram',
|
|
senderId: 'user-audit',
|
|
text: '/reset',
|
|
metadata: { isCommand: true, command: 'reset' },
|
|
} as unknown as MessageRouterInput, vi.fn(async (_: OutboundMessage) => {}));
|
|
|
|
expect(mockAuditLogger.userAction).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
source: 'channel',
|
|
action_type: 'command',
|
|
channel: 'telegram',
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('handles model command via fast-path and persists tier override', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
|
|
const setModelTierSpy = vi.spyOn(AgentOrchestrator.prototype, 'setModelTier');
|
|
const session = {
|
|
id: 'telegram:user-4',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
await router.handler({
|
|
id: 'm4',
|
|
channel: 'telegram',
|
|
senderId: 'user-4',
|
|
text: '/model fast',
|
|
timestamp: Date.now(),
|
|
metadata: { isCommand: true, command: 'model', commandArgs: 'fast' },
|
|
} as MessageRouterInput, reply);
|
|
|
|
expect(processSpy).not.toHaveBeenCalled();
|
|
expect(setModelTierSpy).toHaveBeenCalledWith('fast');
|
|
expect(session.setConfig).toHaveBeenCalledWith('modelTier', 'fast');
|
|
});
|
|
|
|
it('handles queue command via fast-path and persists queue override', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
|
|
const session = {
|
|
id: 'telegram:user-queue',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
server: {
|
|
queue: {
|
|
mode: 'collect',
|
|
cap: 50,
|
|
overflow: 'drop_old',
|
|
debounce_ms: 0,
|
|
summarize_overflow: true,
|
|
},
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
await router.handler({
|
|
id: 'q1',
|
|
channel: 'telegram',
|
|
senderId: 'user-queue',
|
|
text: '/queue set mode followup',
|
|
timestamp: Date.now(),
|
|
metadata: { isCommand: true, command: 'queue', commandArgs: 'set mode followup' },
|
|
} as MessageRouterInput, reply);
|
|
|
|
expect(processSpy).not.toHaveBeenCalled();
|
|
expect(session.setConfig).toHaveBeenCalledWith('queue.mode', 'followup');
|
|
});
|
|
|
|
it('uses intent match to override agent target', async () => {
|
|
const session = {
|
|
id: 'telegram:user-2',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const intentRegistry = new ComponentRegistry({ matchThreshold: 0.5 });
|
|
intentRegistry.register({
|
|
name: 'deploy-route',
|
|
patterns: ['deploy *'],
|
|
target: { type: 'agent', name: 'coder' },
|
|
priority: 10,
|
|
enabled: true,
|
|
});
|
|
|
|
const agentConfigRegistry = new AgentConfigRegistry();
|
|
agentConfigRegistry.loadFromConfig({
|
|
assistant: { model_tier: 'default', sandbox: false },
|
|
coder: { model_tier: 'complex', sandbox: false },
|
|
});
|
|
|
|
const agentRouter = new AgentRouter({
|
|
default_agent: 'assistant',
|
|
channels: {},
|
|
senders: {},
|
|
});
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
intents: { enabled: true },
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
intentRegistry,
|
|
agentConfigRegistry,
|
|
agentRouter,
|
|
});
|
|
|
|
await router.handler({
|
|
id: 'm2',
|
|
channel: 'telegram',
|
|
senderId: 'user-2',
|
|
text: 'deploy backend now',
|
|
timestamp: Date.now(),
|
|
metadata: { isCommand: true, command: 'reset' },
|
|
} as MessageRouterInput, vi.fn(async () => {}));
|
|
|
|
const keys = Array.from(router.agents.keys());
|
|
expect(keys.some(key => key.includes(':coder'))).toBe(true);
|
|
});
|
|
|
|
it('auto-routes research-prefixed messages to research agent when configured', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process').mockResolvedValue('ok');
|
|
const session = {
|
|
id: 'telegram:user-research',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const agentConfigRegistry = new AgentConfigRegistry();
|
|
agentConfigRegistry.loadFromConfig({
|
|
assistant: { model_tier: 'default', sandbox: false },
|
|
research: { model_tier: 'complex', sandbox: false },
|
|
});
|
|
|
|
const agentRouter = new AgentRouter({
|
|
default_agent: 'assistant',
|
|
channels: {},
|
|
senders: {},
|
|
});
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
intents: { enabled: false },
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
agentConfigRegistry,
|
|
agentRouter,
|
|
});
|
|
|
|
await router.handler({
|
|
id: 'm-research',
|
|
channel: 'telegram',
|
|
senderId: 'user-research',
|
|
text: 'research compare k0s vs k3s for a homelab',
|
|
timestamp: Date.now(),
|
|
} as MessageRouterInput, vi.fn(async () => {}));
|
|
|
|
const keys = Array.from(router.agents.keys());
|
|
expect(keys.some(key => key.includes(':research'))).toBe(true);
|
|
expect(processSpy).toHaveBeenCalledWith('compare k0s vs k3s for a homelab', undefined);
|
|
});
|
|
|
|
it('falls back to llm path when confidence is below fast threshold', async () => {
|
|
const session = {
|
|
id: 'telegram:user-3',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const intentRegistry = new ComponentRegistry({ matchThreshold: 0.5 });
|
|
intentRegistry.register({
|
|
name: 'deploy-route',
|
|
patterns: ['deploy *'],
|
|
target: { type: 'agent', name: 'coder' },
|
|
priority: 10,
|
|
enabled: true,
|
|
});
|
|
|
|
const routingPolicy = new RoutingPolicy({
|
|
enabled: true,
|
|
fastPathThreshold: 0.99,
|
|
llmThreshold: 0.2,
|
|
defaultPath: 'llm',
|
|
});
|
|
|
|
const agentConfigRegistry = new AgentConfigRegistry();
|
|
agentConfigRegistry.loadFromConfig({
|
|
assistant: { model_tier: 'default', sandbox: false },
|
|
coder: { model_tier: 'complex', sandbox: false },
|
|
});
|
|
|
|
const agentRouter = new AgentRouter({
|
|
default_agent: 'assistant',
|
|
channels: {},
|
|
senders: {},
|
|
});
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
intents: { enabled: true },
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
intentRegistry,
|
|
routingPolicy,
|
|
agentConfigRegistry,
|
|
agentRouter,
|
|
});
|
|
|
|
await router.handler({
|
|
id: 'm3',
|
|
channel: 'telegram',
|
|
senderId: 'user-3',
|
|
text: 'deploy backend now',
|
|
timestamp: Date.now(),
|
|
metadata: { isCommand: true, command: 'reset' },
|
|
} as MessageRouterInput, vi.fn(async () => {}));
|
|
|
|
const keys = Array.from(router.agents.keys());
|
|
expect(keys.some(key => key.includes(':assistant'))).toBe(true);
|
|
});
|
|
|
|
it('includes selected backend in status output', async () => {
|
|
const session = {
|
|
id: 'telegram:user-status',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
externalBackends: { codex: { name: 'codex', process: vi.fn(async () => 'unused') } } as unknown as MessageRouterDeps['externalBackends'],
|
|
defaultName: 'codex',
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
await router.handler({
|
|
id: 'm-status',
|
|
channel: 'telegram',
|
|
senderId: 'user-status',
|
|
text: '/status',
|
|
timestamp: Date.now(),
|
|
metadata: { isCommand: true, command: 'status' },
|
|
} as MessageRouterInput, reply);
|
|
|
|
const outbound = reply.mock.calls[0]?.[0] as OutboundMessage | undefined;
|
|
expect(outbound?.text).toContain('Backend: codex');
|
|
});
|
|
});
|
|
|
|
describe('daemon external backend integration', () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it('uses configured external backend for non-command messages', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
|
|
const history: Array<{ role: 'user' | 'assistant'; content: string }> = [];
|
|
const session = {
|
|
id: 'telegram:external-user',
|
|
addMessage: vi.fn((msg: { role: 'user' | 'assistant'; content: string }) => {
|
|
history.push(msg);
|
|
return msg;
|
|
}),
|
|
getHistory: vi.fn(() => [...history]),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const externalBackend = {
|
|
name: 'codex',
|
|
process: vi.fn(async () => 'external backend response'),
|
|
};
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
externalBackends: { codex: externalBackend } as unknown as MessageRouterDeps['externalBackends'],
|
|
defaultName: 'codex',
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
await router.handler({
|
|
id: 'm-external',
|
|
channel: 'telegram',
|
|
senderId: 'external-user',
|
|
text: 'hello from external path',
|
|
timestamp: Date.now(),
|
|
} as MessageRouterInput, reply);
|
|
|
|
expect(externalBackend.process).toHaveBeenCalled();
|
|
expect(processSpy).not.toHaveBeenCalled();
|
|
expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'external backend response' }));
|
|
});
|
|
|
|
it('falls back to native processing when external backend fails', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process')
|
|
.mockResolvedValue('native fallback response');
|
|
const history: Array<{ role: 'user' | 'assistant'; content: string }> = [];
|
|
const session = {
|
|
id: 'telegram:external-fail',
|
|
addMessage: vi.fn((msg: { role: 'user' | 'assistant'; content: string }) => {
|
|
history.push(msg);
|
|
return msg;
|
|
}),
|
|
getHistory: vi.fn(() => [...history]),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const externalBackend = {
|
|
name: 'codex',
|
|
process: vi.fn(async () => {
|
|
throw new Error('external failed');
|
|
}),
|
|
};
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
externalBackends: { codex: externalBackend } as unknown as MessageRouterDeps['externalBackends'],
|
|
defaultName: 'codex',
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
await router.handler({
|
|
id: 'm-external-fail',
|
|
channel: 'telegram',
|
|
senderId: 'external-fail',
|
|
text: 'hello fallback',
|
|
timestamp: Date.now(),
|
|
} as MessageRouterInput, reply);
|
|
|
|
expect(externalBackend.process).toHaveBeenCalled();
|
|
expect(processSpy).toHaveBeenCalled();
|
|
expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'native fallback response' }));
|
|
});
|
|
});
|
|
|
|
describe('daemon audio routing integration', () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it('fast-path replies for voice attachments when transcription is not configured and model does not support audio', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
|
|
|
|
const session = {
|
|
id: 'telegram:user-voice-1',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: { getSession: vi.fn(() => session) } as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['default'],
|
|
getAllLabels: () => ({ default: 'default' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: { clone() { return this; }, register: vi.fn() } as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'default',
|
|
memory_extraction: 'default',
|
|
classification: 'default',
|
|
tool_summarisation: 'default',
|
|
complex_reasoning: 'default',
|
|
},
|
|
max_delegation_depth: 1,
|
|
max_iterations: 3,
|
|
},
|
|
compaction: { enabled: false },
|
|
// Anthropic doesn't support native audio; ensures routing hits the non-audio path.
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
audio: { enabled: false },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
await router.handler({
|
|
id: 'v1',
|
|
channel: 'telegram',
|
|
senderId: 'user-voice-1',
|
|
text: '',
|
|
attachments: [{ mimeType: 'audio/ogg', data: 'ZGF0YQ==', filename: 'voice.ogg' }],
|
|
timestamp: Date.now(),
|
|
} as MessageRouterInput, reply);
|
|
|
|
expect(processSpy).not.toHaveBeenCalled();
|
|
expect(reply).toHaveBeenCalledTimes(1);
|
|
const firstReply = reply.mock.calls[0]?.[0] as OutboundMessage | undefined;
|
|
const msg = firstReply as { text?: string };
|
|
expect(String(msg.text)).toContain('audio transcription is not configured');
|
|
});
|
|
|
|
it('transcribes voice attachments when transcription is configured, then strips audio before calling agent.process', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process').mockResolvedValue('ok');
|
|
|
|
// Mock transcription endpoint call.
|
|
const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
|
|
ok: true,
|
|
status: 200,
|
|
statusText: 'OK',
|
|
json: async () => ({ text: 'hello world' }),
|
|
} as Response);
|
|
|
|
const session = {
|
|
id: 'telegram:user-voice-2',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const commandRegistry = new CommandRegistry();
|
|
registerBuiltinCommands(commandRegistry);
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: { getSession: vi.fn(() => session) } as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['default'],
|
|
getAllLabels: () => ({ default: 'default' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: { clone() { return this; }, register: vi.fn() } as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: {
|
|
compaction: 'default',
|
|
memory_extraction: 'default',
|
|
classification: 'default',
|
|
tool_summarisation: 'default',
|
|
complex_reasoning: 'default',
|
|
},
|
|
max_delegation_depth: 1,
|
|
max_iterations: 3,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
audio: {
|
|
enabled: true,
|
|
provider: { type: 'openai', endpoint: 'https://example.com/v1/audio/transcriptions', api_key: 'sk-test', model: 'whisper-1' },
|
|
},
|
|
} as unknown as MessageRouterDeps['config'],
|
|
commandRegistry,
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
await router.handler({
|
|
id: 'v2',
|
|
channel: 'telegram',
|
|
senderId: 'user-voice-2',
|
|
text: 'caption',
|
|
attachments: [
|
|
{ mimeType: 'audio/ogg', data: 'ZGF0YQ==', filename: 'voice.ogg' },
|
|
{ mimeType: 'image/jpeg', data: 'aW1n', filename: 'img.jpg' },
|
|
],
|
|
timestamp: Date.now(),
|
|
} as MessageRouterInput, reply);
|
|
|
|
expect(fetchSpy).toHaveBeenCalled();
|
|
expect(processSpy).toHaveBeenCalledTimes(1);
|
|
const [calledText, calledAttachments] = processSpy.mock.calls[0] ?? [];
|
|
expect(String(calledText)).toContain('[Voice message]: hello world');
|
|
expect(String(calledText)).toContain('caption');
|
|
const atts = calledAttachments as Array<{ mimeType: string }> | undefined;
|
|
expect(atts?.some(a => a.mimeType === 'audio/ogg')).toBe(false);
|
|
expect(atts?.some(a => a.mimeType === 'image/jpeg')).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('daemon auto-escalate integration', () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it('retries on complex tier when auto_escalate is enabled', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process')
|
|
.mockRejectedValueOnce(new Error('primary tier failed'))
|
|
.mockResolvedValueOnce('complex-tier response');
|
|
const setModelTierSpy = vi.spyOn(AgentOrchestrator.prototype, 'setModelTier');
|
|
|
|
const session = {
|
|
id: 'telegram:auto-escalate',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: {
|
|
getSession: vi.fn(() => session),
|
|
} as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: {
|
|
clone() { return this; },
|
|
register: vi.fn(),
|
|
} as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
auto_escalate: true,
|
|
delegation: {
|
|
compaction: 'fast',
|
|
memory_extraction: 'fast',
|
|
classification: 'fast',
|
|
tool_summarisation: 'fast',
|
|
complex_reasoning: 'complex',
|
|
},
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
await router.handler({
|
|
id: 'm-auto-escalate',
|
|
channel: 'telegram',
|
|
senderId: 'auto-escalate',
|
|
text: 'do something hard',
|
|
timestamp: Date.now(),
|
|
} as MessageRouterInput, reply);
|
|
|
|
expect(processSpy).toHaveBeenCalledTimes(2);
|
|
expect(setModelTierSpy).toHaveBeenCalledWith('complex');
|
|
expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'complex-tier response' }));
|
|
});
|
|
});
|
|
|
|
describe('daemon talk mode (voice wake) integration', () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it('ignores messages until wake phrase is used', async () => {
|
|
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process').mockResolvedValue('ok');
|
|
const session = {
|
|
id: 'telegram:user-talk-1',
|
|
addMessage: vi.fn(),
|
|
getHistory: vi.fn(() => []),
|
|
clear: vi.fn(),
|
|
replaceHistory: vi.fn(),
|
|
getConfig: vi.fn(() => undefined),
|
|
setConfig: vi.fn(),
|
|
deleteConfig: vi.fn(),
|
|
};
|
|
|
|
const router = createMessageRouter({
|
|
sessionManager: { getSession: vi.fn(() => session) } as unknown as MessageRouterDeps['sessionManager'],
|
|
modelRouter: {
|
|
getAvailableTiers: () => ['fast', 'default', 'complex', 'local'],
|
|
getAllLabels: () => ({ fast: 'fast', default: 'default', complex: 'complex', local: 'local' }),
|
|
getLabel: (tier: string) => tier,
|
|
} as unknown as MessageRouterDeps['modelRouter'],
|
|
systemPrompt: 'test prompt',
|
|
toolRegistry: { clone() { return this; }, register: vi.fn() } as unknown as MessageRouterDeps['toolRegistry'],
|
|
toolExecutor: {} as unknown as MessageRouterDeps['toolExecutor'],
|
|
config: {
|
|
agents: {
|
|
primary_tier: 'default',
|
|
delegation: { compaction: 'fast', memory_extraction: 'fast', classification: 'fast', tool_summarisation: 'fast', complex_reasoning: 'complex' },
|
|
max_delegation_depth: 3,
|
|
max_iterations: 10,
|
|
},
|
|
compaction: { enabled: false },
|
|
models: { default: { provider: 'anthropic', model: 'claude' } },
|
|
audio: { talk_mode: { enabled: true, wake_phrase: 'hey flynn', timeout_ms: 120000, allow_manual_toggle: true } },
|
|
} as unknown as MessageRouterDeps['config'],
|
|
});
|
|
|
|
const reply = vi.fn(async (_message: OutboundMessage) => {});
|
|
|
|
await router.handler({
|
|
id: 'm-talk-1',
|
|
channel: 'telegram',
|
|
senderId: 'user-talk-1',
|
|
text: 'hello there',
|
|
timestamp: Date.now(),
|
|
} as MessageRouterInput, reply);
|
|
expect(processSpy).not.toHaveBeenCalled();
|
|
|
|
await router.handler({
|
|
id: 'm-talk-2',
|
|
channel: 'telegram',
|
|
senderId: 'user-talk-1',
|
|
text: 'hey flynn what time is it?',
|
|
timestamp: Date.now(),
|
|
} as MessageRouterInput, reply);
|
|
expect(processSpy).toHaveBeenCalledOnce();
|
|
expect(processSpy).toHaveBeenCalledWith('what time is it?', undefined);
|
|
});
|
|
});
|