chore(rebase): realign duplicate backend/channel/schema files with main

This commit is contained in:
William Valentin
2026-02-17 15:44:47 -08:00
parent 03fa96583c
commit b0d06d0650
9 changed files with 0 additions and 691 deletions
-403
View File
@@ -423,78 +423,6 @@ describe('daemon command fast-path integration', () => {
expect(session.setConfig).toHaveBeenCalledWith('queue.mode', 'followup');
});
it('includes external backend in status fast-path output', async () => {
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
const session = {
id: 'telegram:user-status-backend',
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'],
defaultExternalBackendName: 'codex',
});
const reply = vi.fn(async (_message: OutboundMessage) => {});
await router.handler({
id: 'm-status-backend',
channel: 'telegram',
senderId: 'user-status-backend',
text: '/status',
timestamp: Date.now(),
metadata: { isCommand: true, command: 'status' },
} as MessageRouterInput, reply);
expect(processSpy).not.toHaveBeenCalled();
const outbound = reply.mock.calls[0]?.[0] as OutboundMessage | undefined;
expect(outbound?.text).toContain('Backend: codex');
});
it('uses intent match to override agent target', async () => {
const session = {
id: 'telegram:user-2',
@@ -1193,337 +1121,6 @@ describe('daemon auto-escalate integration', () => {
expect(setModelTierSpy).toHaveBeenCalledWith('complex');
expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'complex-tier 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,
auto_escalate: false,
},
compaction: { enabled: false },
models: { default: { provider: 'anthropic', model: 'claude' } },
} as unknown as MessageRouterDeps['config'],
externalBackends: { codex: externalBackend } as unknown as MessageRouterDeps['externalBackends'],
defaultExternalBackendName: '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' }));
});
it('fails over to another enabled external backend before native fallback', async () => {
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process')
.mockResolvedValue('native should not be used');
const session = {
id: 'telegram:external-failover',
addMessage: vi.fn(),
getHistory: vi.fn(() => []),
clear: vi.fn(),
replaceHistory: vi.fn(),
getConfig: vi.fn(() => undefined),
setConfig: vi.fn(),
deleteConfig: vi.fn(),
};
const codexBackend = {
name: 'codex',
process: vi.fn(async () => {
throw new Error('codex failed');
}),
};
const geminiBackend = {
name: 'gemini',
process: vi.fn(async () => 'gemini recovered'),
};
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,
auto_escalate: false,
},
compaction: { enabled: false },
models: { default: { provider: 'anthropic', model: 'claude' } },
} as unknown as MessageRouterDeps['config'],
externalBackends: {
codex: codexBackend,
gemini: geminiBackend,
} as unknown as MessageRouterDeps['externalBackends'],
defaultExternalBackendName: 'codex',
});
const reply = vi.fn(async (_message: OutboundMessage) => {});
await router.handler({
id: 'm-external-failover',
channel: 'telegram',
senderId: 'external-failover',
text: 'hello failover',
timestamp: Date.now(),
} as MessageRouterInput, reply);
expect(codexBackend.process).toHaveBeenCalled();
expect(geminiBackend.process).toHaveBeenCalled();
expect(processSpy).not.toHaveBeenCalled();
expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'gemini recovered' }));
});
it('uses per-agent backend override instead of default external backend', async () => {
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process');
const session = {
id: 'telegram:agent-backend-override',
addMessage: vi.fn(),
getHistory: vi.fn(() => []),
clear: vi.fn(),
replaceHistory: vi.fn(),
getConfig: vi.fn(() => undefined),
setConfig: vi.fn(),
deleteConfig: vi.fn(),
};
const codexBackend = {
name: 'codex',
process: vi.fn(async () => 'codex response'),
};
const geminiBackend = {
name: 'gemini',
process: vi.fn(async () => 'gemini response'),
};
const agentConfigRegistry = new AgentConfigRegistry();
agentConfigRegistry.loadFromConfig({
coder: {
model_tier: 'complex',
backend: 'gemini',
sandbox: false,
},
});
const agentRouter = new AgentRouter({
channels: { telegram: 'coder' },
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: {
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,
auto_escalate: false,
},
compaction: { enabled: false },
models: { default: { provider: 'anthropic', model: 'claude' } },
} as unknown as MessageRouterDeps['config'],
agentConfigRegistry,
agentRouter,
externalBackends: {
codex: codexBackend,
gemini: geminiBackend,
} as unknown as MessageRouterDeps['externalBackends'],
defaultExternalBackendName: 'codex',
});
const reply = vi.fn(async (_message: OutboundMessage) => {});
await router.handler({
id: 'm-agent-backend-override',
channel: 'telegram',
senderId: 'user-agent-override',
text: 'route to gemini backend',
timestamp: Date.now(),
} as MessageRouterInput, reply);
expect(geminiBackend.process).toHaveBeenCalled();
expect(codexBackend.process).not.toHaveBeenCalled();
expect(processSpy).not.toHaveBeenCalled();
expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'gemini response' }));
});
it('falls back to native when per-agent backend is configured but unavailable', async () => {
const processSpy = vi.spyOn(AgentOrchestrator.prototype, 'process')
.mockResolvedValue('native response (missing backend)');
const session = {
id: 'telegram:missing-agent-backend',
addMessage: vi.fn(),
getHistory: vi.fn(() => []),
clear: vi.fn(),
replaceHistory: vi.fn(),
getConfig: vi.fn(() => undefined),
setConfig: vi.fn(),
deleteConfig: vi.fn(),
};
const agentConfigRegistry = new AgentConfigRegistry();
agentConfigRegistry.loadFromConfig({
coder: {
model_tier: 'complex',
backend: 'gemini',
sandbox: false,
},
});
const agentRouter = new AgentRouter({
channels: { telegram: 'coder' },
senders: {},
});
const codexBackend = {
name: 'codex',
process: vi.fn(async () => 'codex 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,
auto_escalate: false,
},
compaction: { enabled: false },
models: { default: { provider: 'anthropic', model: 'claude' } },
} as unknown as MessageRouterDeps['config'],
agentConfigRegistry,
agentRouter,
externalBackends: {
codex: codexBackend,
} as unknown as MessageRouterDeps['externalBackends'],
defaultExternalBackendName: 'codex',
});
const reply = vi.fn(async (_message: OutboundMessage) => {});
await router.handler({
id: 'm-missing-agent-backend',
channel: 'telegram',
senderId: 'user-missing-backend',
text: 'fall back to native',
timestamp: Date.now(),
} as MessageRouterInput, reply);
expect(codexBackend.process).not.toHaveBeenCalled();
expect(processSpy).toHaveBeenCalled();
expect(reply).toHaveBeenCalledWith(expect.objectContaining({ text: 'native response (missing backend)' }));
});
});
describe('daemon talk mode (voice wake) integration', () => {