Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.
Python agent-orchestrationaiai-agentschatopsdiscordlangchainmcpmicrosoft-teamsmulti-agentopen-sourceopenaiself-hostedslack
import { describe, expect, it, vi } from 'vitest';
import type { ProviderSessionStartInput, RuntimeMode } from '../adapter';
import { EventRecorder } from '../testing/event-recorder';
import { mcpConfigFor, parseModelId, permissionConfigFor, permissionRulesFor } from './config';
import {
createFakeTransport,
type FakeSession,
type FakeTransport,
messageUpdated,
opencodeEvent,
sessionStatus,
textDelta,
textPart,
toolPart,
} from './fake-transport';
import {
createOpencodeAdapter,
fromPermissionReply,
type OpencodeAdapter,
mcpToolOf,
permissionTitle,
subagentName,
toolItemType,
toPermissionReply,
toQuestionAnswers,
toRequestType,
} from './opencode-adapter';
const NATIVE = 'ses_fake';
function startInput(overrides: Partial<ProviderSessionStartInput> = {}): ProviderSessionStartInput {
return {
sessionId: 'switch-session',
cwd: '/tmp/switch-opencode',
runtimeMode: 'full-access',
env: { PATH: '/usr/bin', HOME: '/home/switch' },
mcpServers: {},
connectorMcpServers: [],
model: { id: 'opencode/big-pickle' },
...overrides,
};
}
async function setup(
runtimeMode: RuntimeMode = 'full-access',
overrides: Partial<ProviderSessionStartInput> = {}
): Promise<{
adapter: OpencodeAdapter;
transport: FakeTransport;
session: FakeSession;
recorder: EventRecorder;
}> {
const transport = createFakeTransport(NATIVE);
const adapter = createOpencodeAdapter({ transport });
const recorder = new EventRecorder(adapter);
await adapter.startSession(startInput({ runtimeMode, ...overrides }));
return { adapter, transport, session: transport.last(), recorder };
}
describe('OpencodeAdapter turn lifecycle', () => {
it("reports the turn's tokens per model, counting a streamed message once", async () => {
const { adapter, session, recorder } = await setup();
const tokens = (input: number, output: number, reasoning: number, read: number) => ({
input,
output,
reasoning,
cache: { read, write: 0 },
});
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hello' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant', tokens(10, 2, 0, 100)));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant', tokens(10, 8, 3, 100)));
session.push(
messageUpdated(NATIVE, 'msg2', 'assistant', tokens(4, 1, 0, 0), {
providerID: 'anthropic',
modelID: 'haiku',
})
);
session.push(sessionStatus(NATIVE, 'idle'));
const one = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't2', text: 'again' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg3', 'assistant', tokens(5, 5, 0, 110)));
session.push(sessionStatus(NATIVE, 'idle'));
const two = await recorder.waitFor('turn.completed', (event) => event.turnId === 't2', 1_000);
expect(one.usage).toEqual([
{
model: 'opencode/big-pickle',
inputTokens: 10,
outputTokens: 11,
cacheReadTokens: 100,
cacheWriteTokens: 0,
},
{
model: 'anthropic/haiku',
inputTokens: 4,
outputTokens: 1,
cacheReadTokens: 0,
cacheWriteTokens: 0,
},
]);
expect(two.usage).toEqual([
{
model: 'opencode/big-pickle',
inputTokens: 5,
outputTokens: 5,
cacheReadTokens: 110,
cacheWriteTokens: 0,
},
]);
});
it("counts what a subagent's child session spends, and nothing from unrelated sessions", async () => {
const { adapter, session, recorder } = await setup();
const tokens = (input: number, output: number) => ({
input,
output,
reasoning: 0,
cache: { read: 0, write: 0 },
});
const sessionCreated = (id: string, parentID?: string) =>
opencodeEvent('session.created', {
sessionID: id,
info: { id, ...(parentID ? { parentID } : {}) },
});
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hello' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant', tokens(10, 2)));
session.push(sessionCreated('ses_child', NATIVE));
session.push(sessionCreated('ses_grandchild', 'ses_child'));
session.push(sessionCreated('ses_other'));
session.push(messageUpdated('ses_child', 'msg2', 'assistant', tokens(7, 3)));
session.push(messageUpdated('ses_grandchild', 'msg3', 'assistant', tokens(1, 1)));
session.push(messageUpdated('ses_other', 'msg4', 'assistant', tokens(1000, 1000)));
session.push(sessionStatus(NATIVE, 'idle'));
const one = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
expect(one.usage).toEqual([
{
model: 'opencode/big-pickle',
inputTokens: 18,
outputTokens: 6,
cacheReadTokens: 0,
cacheWriteTokens: 0,
},
]);
});
it('completes a turn on the idle that follows the prompt busy', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hello' });
await recorder.waitFor('turn.started', (event) => event.turnId === 't1', 1_000);
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant'));
session.push(textPart(NATIVE, 'msg1', 'prt1', ''));
session.push(textDelta(NATIVE, 'msg1', 'prt1', 'hi there'));
session.push(textPart(NATIVE, 'msg1', 'prt1', 'hi there', true));
session.push(sessionStatus(NATIVE, 'idle'));
const done = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
expect(done.outcome).toBe('completed');
expect(recorder.assistantText('t1')).toBe('hi there');
expect(recorder.ofType('turn.completed')).toHaveLength(1);
});
it('ignores an idle that OpenCode queued before the prompt was admitted', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hello' });
session.push(sessionStatus(NATIVE, 'idle'));
session.push(sessionStatus(NATIVE, 'busy'));
await recorder.waitFor('session.state.changed', (event) => event.status === 'running', 1_000);
expect(recorder.ofType('turn.completed')).toHaveLength(0);
session.push(sessionStatus(NATIVE, 'idle'));
const done = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
expect(done.outcome).toBe('completed');
expect(recorder.ofType('turn.completed')).toHaveLength(1);
});
it('steers a mid-turn message into the running turn and completes it once', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'count' });
session.push(sessionStatus(NATIVE, 'busy'));
await recorder.waitFor('session.state.changed', (event) => event.status === 'running', 1_000);
const steer = await adapter.sendTurn({
sessionId: 'switch-session',
turnId: 't2',
text: 'stop counting',
});
expect(steer).toEqual({ turnId: 't2', steeredInto: 't1' });
expect(recorder.ofType('turn.started').map((event) => event.turnId)).toEqual(['t1']);
// The steer re-arms the busy gate, so an idle already in flight is ignored.
session.push(sessionStatus(NATIVE, 'idle'));
session.push(sessionStatus(NATIVE, 'busy'));
await recorder.waitFor('session.state.changed', (event) => event.status === 'running', 1_000);
expect(recorder.ofType('turn.completed')).toHaveLength(0);
session.push(sessionStatus(NATIVE, 'idle'));
const done = await recorder.waitFor('turn.completed', () => true, 1_000);
expect(done.turnId).toBe('t1');
expect(recorder.ofType('turn.completed')).toHaveLength(1);
});
it('reports an interrupt once and swallows the abort error OpenCode echoes back', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'count' });
session.push(sessionStatus(NATIVE, 'busy'));
await recorder.waitFor('session.state.changed', (event) => event.status === 'running', 1_000);
await adapter.interruptTurn('switch-session');
const done = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
expect(done.outcome).toBe('interrupted');
expect(session.calls.some((call) => call.method === 'abort')).toBe(true);
session.push(
opencodeEvent('session.error', {
sessionID: NATIVE,
error: { name: 'MessageAbortedError', data: { message: 'aborted' } },
})
);
session.push(sessionStatus(NATIVE, 'idle'));
session.push(sessionStatus(NATIVE, 'busy'));
await recorder.waitFor('session.state.changed', (event) => event.status === 'running', 1_000);
expect(recorder.ofType('runtime.error')).toHaveLength(0);
expect(recorder.ofType('turn.completed')).toHaveLength(1);
});
it('settles interrupted tools even if idle arrives before abort returns', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'work' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(
toolPart(NATIVE, 'm1', 'command', 'bash', {
status: 'running',
input: { command: 'sleep 120' },
time: { start: 0 },
})
);
await recorder.waitFor('item.started', (e) => e.item.id === 'command', 1_000);
vi.spyOn(session, 'abort').mockImplementation(async () => {
session.push(sessionStatus(NATIVE, 'idle'));
await new Promise((resolve) => setTimeout(resolve, 10));
});
await adapter.interruptTurn('switch-session');
expect(recorder.ofType('turn.completed').map((e) => e.outcome)).toEqual(['interrupted']);
expect(
recorder.ofType('item.completed').find((e) => e.item.id === 'command')?.item
).toMatchObject({ status: 'failed', text: 'Interrupted.' });
expect(recorder.ofType('session.state.changed').at(-1)?.status).toBe('ready');
});
it('keeps work active when abort fails', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'work' });
vi.spyOn(session, 'abort').mockRejectedValue(new Error('unreachable'));
await expect(adapter.interruptTurn('switch-session')).rejects.toThrow('could not interrupt');
expect(recorder.ofType('turn.completed')).toHaveLength(0);
});
it('fails the turn when the prompt is rejected', async () => {
const { adapter, session, recorder } = await setup();
session.promptRejection = new Error('prompt rejected');
await expect(
adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hello' })
).rejects.toThrow(/prompt was rejected/);
const done = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
expect(done.outcome).toBe('error');
});
it('surfaces a session error as a runtime error and fails the turn', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hello' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(
opencodeEvent('session.error', {
sessionID: NATIVE,
error: { name: 'ApiError', data: { message: 'upstream exploded' } },
})
);
const done = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
expect(done.outcome).toBe('error');
const failure = await recorder.waitFor('runtime.error', () => true, 1_000);
expect(failure.message).toContain('upstream exploded');
});
it('fails only the items of the turn that failed', async () => {
const { adapter, session, recorder } = await setup();
const running = { status: 'running', input: { command: 'sleep 1' }, time: { start: 0 } };
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'first' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant'));
session.push(toolPart(NATIVE, 'msg1', 'c1', 'bash', running));
session.push(sessionStatus(NATIVE, 'idle'));
const first = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
expect(first.outcome).toBe('completed');
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't2', text: 'second' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg2', 'assistant'));
session.push(toolPart(NATIVE, 'msg2', 'c2', 'bash', running));
session.push(
opencodeEvent('session.error', {
sessionID: NATIVE,
error: { name: 'ApiError', data: { message: 'upstream exploded' } },
})
);
const second = await recorder.waitFor(
'turn.completed',
(event) => event.turnId === 't2',
1_000
);
expect(second.outcome).toBe('error');
const failed = recorder
.ofType('item.completed')
.filter((event) => event.item.status === 'failed');
expect(failed.map((event) => event.item.id)).toEqual(['c2']);
expect(failed.every((event) => event.turnId === 't2')).toBe(true);
});
});
describe('OpencodeAdapter item translation', () => {
it('maps tool parts onto the shared item vocabulary', async () => {
const { adapter, session, recorder } = await setup('full-access', {
mcpServers: {
switch_echo: { transport: 'stdio', command: 'node', args: ['echo.mjs'] },
},
});
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'work' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant'));
session.push(
toolPart(NATIVE, 'msg1', 'c1', 'bash', {
status: 'running',
input: { command: 'ls -la' },
time: { start: 0 },
})
);
session.push(
toolPart(NATIVE, 'msg1', 'c2', 'task', {
status: 'pending',
input: {},
raw: '',
})
);
session.push(
toolPart(NATIVE, 'msg1', 'c2', 'task', {
status: 'completed',
input: { description: 'read the readme' },
output: 'first line',
title: 'read the readme',
metadata: {},
time: { start: 0, end: 1 },
})
);
session.push(
toolPart(NATIVE, 'msg1', 'c3', 'switch_echo_switch_echo', {
status: 'completed',
input: { text: 'hi' },
output: 'hi',
title: 'echo',
metadata: {},
time: { start: 0, end: 1 },
})
);
const mcp = await recorder.waitFor(
'item.completed',
(event) => event.item.type === 'mcp_tool_call',
1_000
);
expect(mcp.item.toolName).toBe('switch_echo_switch_echo');
const started = recorder.ofType('item.started');
expect(started.find((event) => event.item.id === 'c1')?.item).toMatchObject({
type: 'command_execution',
title: 'ls -la',
});
const subagentStart = started.find((event) => event.item.id === 'c2');
expect(subagentStart?.item.type).toBe('subagent');
expect(subagentStart?.item.title.length).toBeGreaterThan(0);
const subagentDone = recorder.ofType('item.completed').find((event) => event.item.id === 'c2');
expect(subagentDone?.item.status).toBe('completed');
});
it('emits assistant text but not reasoning as content deltas', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'think' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant'));
session.push(
opencodeEvent('message.part.updated', {
sessionID: NATIVE,
time: 0,
part: {
id: 'prt_reason',
sessionID: NATIVE,
messageID: 'msg1',
type: 'reasoning',
text: 'pondering',
time: { start: 0, end: 1 },
},
})
);
session.push(textPart(NATIVE, 'msg1', 'prt_text', ''));
session.push(textDelta(NATIVE, 'msg1', 'prt_text', 'answer'));
await recorder.waitFor('content.delta', () => true, 1_000);
expect(recorder.assistantText('t1')).toBe('answer');
expect(recorder.ofType('item.completed').map((event) => event.item.type)).toContain(
'reasoning'
);
});
it('re-sends only the tail when OpenCode replays whole text after deltas', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hi' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant'));
session.push(textPart(NATIVE, 'msg1', 'prt1', ''));
session.push(textDelta(NATIVE, 'msg1', 'prt1', 'one '));
session.push(textPart(NATIVE, 'msg1', 'prt1', 'one two', true));
await recorder.waitFor('item.completed', (event) => event.item.id === 'prt1', 1_000);
expect(recorder.assistantText('t1')).toBe('one two');
});
it('ignores events for a session other than its own', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hi' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(sessionStatus('ses_someone_else', 'idle'));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant'));
session.push(textPart(NATIVE, 'msg1', 'prt1', 'mine', true));
await recorder.waitFor('item.completed', () => true, 1_000);
expect(recorder.ofType('turn.completed')).toHaveLength(0);
});
});
describe('OpencodeAdapter approvals and questions', () => {
it('opens a request under approval-required and resolves it from the reply event', async () => {
const { adapter, session, recorder } = await setup('approval-required');
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'run it' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(
opencodeEvent('permission.asked', {
id: 'per_1',
sessionID: NATIVE,
permission: 'bash',
patterns: ['echo hi'],
metadata: { command: 'echo hi' },
always: ['echo *'],
})
);
const opened = await recorder.waitFor('request.opened', () => true, 1_000);
expect(opened.requestType).toBe('command_execution_approval');
expect(opened.title).toBe('echo hi');
// The pattern already *is* the command; repeating it as the detail put the
// same string on the card twice, reading as two things to check.
expect(opened.detail).toBeUndefined();
expect(opened.options.map((option) => option.decision)).toContain('acceptForSession');
await adapter.respondToRequest('switch-session', 'per_1', 'acceptForSession');
expect(session.calls).toContainEqual({
method: 'replyPermission',
args: ['per_1', 'always'],
});
session.push(
opencodeEvent('permission.replied', {
sessionID: NATIVE,
requestID: 'per_1',
reply: 'always',
})
);
const resolved = await recorder.waitFor('request.resolved', () => true, 1_000);
expect(resolved.decision).toBe('acceptForSession');
});
it.each(['full-access', 'auto'] as const)(
'never opens a request in %s and allows the ask once instead',
async (mode) => {
const { adapter, session, recorder } = await setup(mode);
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'run it' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(
opencodeEvent('permission.asked', {
id: 'per_1',
sessionID: NATIVE,
permission: 'doom_loop',
patterns: ['*'],
metadata: {},
always: [],
})
);
session.push(sessionStatus(NATIVE, 'idle'));
await recorder.waitFor('turn.completed', () => true, 1_000);
expect(recorder.ofType('request.opened')).toHaveLength(0);
expect(session.calls).toContainEqual({ method: 'replyPermission', args: ['per_1', 'once'] });
}
);
it('answers questions positionally', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'ask me' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(
opencodeEvent('question.asked', {
id: 'qst_1',
sessionID: NATIVE,
questions: [
{
question: 'Which color?',
header: 'Color',
options: [
{ label: 'red', description: 'warm' },
{ label: 'green', description: 'cool' },
],
},
],
})
);
const asked = await recorder.waitFor('user-input.requested', () => true, 1_000);
expect(asked.questions[0]?.id).toBe('0');
expect(asked.questions[0]?.options.map((option) => option.value)).toEqual(['red', 'green']);
await adapter.respondToUserInput('switch-session', 'qst_1', { '0': 'green' });
expect(session.calls).toContainEqual({
method: 'replyQuestion',
args: ['qst_1', [['green']]],
});
session.push(
opencodeEvent('question.replied', {
sessionID: NATIVE,
requestID: 'qst_1',
answers: [['green']],
})
);
await recorder.waitFor('user-input.resolved', (event) => event.requestId === 'qst_1', 1_000);
});
it('rejects an answer for a request it never opened', async () => {
const { adapter } = await setup();
await expect(
adapter.respondToRequest('switch-session', 'per_missing', 'accept')
).rejects.toThrow(/no pending approval/);
await expect(adapter.respondToUserInput('switch-session', 'qst_missing', {})).rejects.toThrow(
/no pending question/
);
});
});
describe('OpencodeAdapter session lifecycle', () => {
it('cancels pending requests and exits on stop', async () => {
const { adapter, session, recorder } = await setup('approval-required');
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'run it' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(
opencodeEvent('permission.asked', {
id: 'per_1',
sessionID: NATIVE,
permission: 'bash',
patterns: ['echo hi'],
metadata: {},
always: [],
})
);
await recorder.waitFor('request.opened', () => true, 1_000);
await adapter.stopSession('switch-session');
const resolved = await recorder.waitFor('request.resolved', () => true, 1_000);
expect(resolved.decision).toBe('cancel');
const exited = await recorder.waitFor('session.exited', () => true, 1_000);
expect(exited.reason).toContain('stopped');
expect(adapter.hasSession('switch-session')).toBe(false);
});
it('emits session.exited when the event stream dies', async () => {
const { session, recorder } = await setup();
session.fail('server went away');
const exited = await recorder.waitFor('session.exited', () => true, 1_000);
expect(exited.reason).toContain('server went away');
});
it('throws for an unknown session rather than returning a flag', async () => {
const adapter = createOpencodeAdapter({ transport: createFakeTransport() });
await expect(adapter.sendTurn({ sessionId: 'nope', turnId: 't1', text: 'hi' })).rejects.toThrow(
/unknown session/
);
await expect(adapter.stopSession('nope')).rejects.toThrow(/unknown session/);
});
it('passes the resumed native session id through to the transport', async () => {
const transport = createFakeTransport();
const adapter = createOpencodeAdapter({ transport });
const session = await adapter.startSession(
startInput({ resume: { nativeSessionId: 'ses_prior' } })
);
expect(session.nativeSessionId).toBe('ses_prior');
expect(transport.last().opened.resumeNativeSessionId).toBe('ses_prior');
});
it('sends systemContext as the prompt system field', async () => {
const transport = createFakeTransport();
const adapter = createOpencodeAdapter({ transport });
await adapter.startSession(startInput({ systemContext: 'you are in a Switch room' }));
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hi' });
expect(transport.last().calls[0]).toEqual({
method: 'prompt',
args: [
{
text: 'hi',
system: 'you are in a Switch room',
model: { providerID: 'opencode', modelID: 'big-pickle' },
},
],
});
});
});
describe('OpencodeAdapter mappings', () => {
it('maps decisions onto OpenCode replies in both directions', () => {
expect(toPermissionReply('accept')).toBe('once');
expect(toPermissionReply('acceptForSession')).toBe('always');
expect(toPermissionReply('decline')).toBe('reject');
expect(toPermissionReply('cancel')).toBe('reject');
expect(fromPermissionReply('once')).toBe('accept');
expect(fromPermissionReply('always')).toBe('acceptForSession');
expect(fromPermissionReply('reject')).toBe('decline');
});
it('fills gaps in positional question answers', () => {
expect(toQuestionAnswers({ '0': 'a', '2': ['b', 'c'] })).toEqual([['a'], [], ['b', 'c']]);
expect(toQuestionAnswers({})).toEqual([]);
});
it('classifies tools and permissions', () => {
expect(toolItemType('bash', [])).toBe('command_execution');
expect(toolItemType('write', [])).toBe('file_change');
expect(toolItemType('task', [])).toBe('subagent');
expect(toolItemType('webfetch', [])).toBe('web_search');
expect(toolItemType('switch_echo_ping', ['switch_echo'])).toBe('mcp_tool_call');
expect(toolItemType('glob', [])).toBe('tool_call');
expect(toRequestType('bash', [])).toBe('command_execution_approval');
expect(toRequestType('edit', [])).toBe('file_change_approval');
expect(toRequestType('external_directory', [])).toBe('directory_access_approval');
expect(toRequestType('switch_echo_ping', ['switch_echo'])).toBe('mcp_tool_approval');
});
it('maps runtime modes onto permissions that never ask in full access', () => {
expect(permissionConfigFor('full-access', [])['*']).toBe('allow');
expect(permissionConfigFor('approval-required', [])['bash']).toBe('ask');
expect(permissionConfigFor('approval-required', [])['edit']).toBe('ask');
expect(permissionConfigFor('auto-accept-edits', [])['edit']).toBe('allow');
expect(permissionConfigFor('auto-accept-edits', [])['bash']).toBe('ask');
expect(permissionRulesFor('full-access', []).every((rule) => rule.action === 'allow')).toBe(
true
);
expect(
permissionRulesFor('auto-accept-edits', []).find((rule) => rule.permission === 'edit')?.action
).toBe('allow');
});
it("keeps the person's own rules in auto mode: no catch-all, no asks, only Switch's allows", () => {
const rules = permissionRulesFor('auto', ['switch']);
expect(rules.every((rule) => rule.action === 'allow')).toBe(true);
expect(rules.some((rule) => rule.permission === '*')).toBe(false);
expect(rules.find((rule) => rule.permission === 'switch_*')?.action).toBe('allow');
expect(rules.some((rule) => rule.permission === 'bash' || rule.permission === 'edit')).toBe(
false
);
const config = permissionConfigFor('auto', ['switch']);
expect(config['*']).toBeUndefined();
expect(config['bash']).toBeUndefined();
expect(config['edit']).toBeUndefined();
expect(config['switch_*']).toBe('allow');
});
it('never asks about a tool from an MCP server the caller registered', () => {
// A session's MCP servers are the ones Switch put there — for Switch
// Console, the room protocol. An agent that must ask the room before it may
// speak in the room cannot deliver the question either.
expect(permissionConfigFor('approval-required', ['switch'])['switch_*']).toBe('allow');
expect(
permissionRulesFor('approval-required', ['switch']).find(
(rule) => rule.permission === 'switch_*'
)?.action
).toBe('allow');
expect(permissionConfigFor('approval-required', ['switch'])['bash']).toBe('ask');
});
it('names the agent a task delegates to, and nothing when the input does not', () => {
// `task` is the mechanism, not the agent — putting it in `toolName` left
// the activity row reading "Subagent · task".
expect(subagentName({ subagent_type: 'general' })).toEqual({ toolName: 'general' });
expect(subagentName({ agent: 'reviewer' })).toEqual({ toolName: 'reviewer' });
expect(subagentName({ description: 'read the readme' })).toEqual({});
expect(subagentName({ agent: ' ' })).toEqual({});
});
it('titles an approval with the pattern only when the pattern names something', () => {
expect(permissionTitle('bash', ['rm -rf /'])).toBe('rm -rf /');
expect(permissionTitle('switch_connect_to_room', ['*'])).toBe('switch_connect_to_room');
expect(permissionTitle('webfetch', [])).toBe('webfetch');
});
it('maps MCP specs onto OpenCode server entries', () => {
expect(
mcpConfigFor({
local: { transport: 'stdio', command: 'node', args: ['s.mjs'], env: { A: '1' } },
remote: { transport: 'http', url: 'https://example.test/mcp', headers: { A: '1' } },
})
).toEqual({
local: {
type: 'local',
command: ['node', 's.mjs'],
enabled: true,
timeout: 60000,
environment: { A: '1' },
},
remote: {
type: 'remote',
url: 'https://example.test/mcp',
enabled: true,
headers: { A: '1' },
},
});
});
it('rejects a model id that is not provider/model', () => {
expect(parseModelId('opencode/big-pickle')).toEqual({
providerID: 'opencode',
modelID: 'big-pickle',
});
expect(() => parseModelId('big-pickle')).toThrow(/provider\/model/);
});
});
describe('OpenCode native compaction', () => {
it('waits for native busy and idle after the HTTP acknowledgement', async () => {
const { adapter, session, recorder } = await setup();
session.compact = vi.fn(async () => {});
let completed = false;
const operation = adapter.compactSession('switch-session').then(() => {
completed = true;
});
session.push(sessionStatus(NATIVE, 'idle'));
await new Promise((resolve) => setTimeout(resolve, 0));
expect(completed).toBe(false);
session.push(sessionStatus(NATIVE, 'busy'));
await recorder.waitFor('session.state.changed', (event) => event.status === 'running', 1_000);
expect(completed).toBe(false);
session.push(sessionStatus(NATIVE, 'idle'));
await operation;
expect(session.compact).toHaveBeenCalledOnce();
expect(recorder.ofType('turn.started')).toHaveLength(0);
await adapter.stopAll();
});
it('does not report success when stopped before native completion', async () => {
const { adapter, session } = await setup();
session.compact = vi.fn(async () => {});
const operation = adapter.compactSession('switch-session');
const outcome = expect(operation).rejects.toThrow('interrupted');
await adapter.stopAll();
await outcome;
});
});
it('sends the native model variant and clears it when returning to defaults', async () => {
const { adapter, session } = await setup();
await adapter.setModel('switch-session', { id: 'example/model', options: { variant: 'high' } });
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 'first', text: 'first' });
expect(session.calls.find((call) => call.method === 'prompt')?.args[0]).toMatchObject({
model: { providerID: 'example', modelID: 'model' },
variant: 'high',
});
await adapter.setModel('switch-session', { id: 'example/model', options: {} });
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 'second', text: 'second' });
expect(
session.calls.filter((call) => call.method === 'prompt').at(-1)?.args[0]
).not.toHaveProperty('variant');
await adapter.stopAll();
});
describe('OpencodeAdapter connector tools', () => {
const stdio = { transport: 'stdio' as const, command: 'node', args: ['server.mjs'] };
const servers = { switch: stdio, atlassian: stdio, gws: stdio, other: stdio };
const action = (rules: { permission: string; action: string }[], permission: string) =>
rules.find((rule) => rule.permission === permission)?.action;
it.each(['approval-required', 'auto-accept-edits'] as const)(
"in %s a connector gets no allow rule and asks under '*', while Switch's own never asks",
async (mode) => {
const { session } = await setup(mode, {
mcpServers: servers,
connectorMcpServers: ['atlassian', 'gws'],
});
const { permission, config } = session.opened;
expect(action(permission, '*')).toBe('ask');
expect(action(permission, 'switch_*')).toBe('allow');
expect(action(permission, 'other_*')).toBe('allow');
expect(action(permission, 'atlassian_*')).toBeUndefined();
expect(action(permission, 'gws_*')).toBeUndefined();
expect(config.permission['switch_*']).toBe('allow');
expect(config.permission['atlassian_*']).toBeUndefined();
expect(config.permission['*']).toBe('ask');
expect(Object.keys(config.mcp).sort()).toEqual(['atlassian', 'gws', 'other', 'switch']);
}
);
it('allows everything in full access', async () => {
const { session } = await setup('full-access', {
mcpServers: servers,
connectorMcpServers: ['atlassian', 'gws'],
});
expect(session.opened.permission.every((rule) => rule.action === 'allow')).toBe(true);
});
it("in auto mode a connector gets no rule of Switch's, and its ask is allowed once", async () => {
const { adapter, session, recorder } = await setup('auto', {
mcpServers: servers,
connectorMcpServers: ['atlassian', 'gws'],
});
const { permission, config } = session.opened;
expect(action(permission, '*')).toBeUndefined();
expect(action(permission, 'switch_*')).toBe('allow');
expect(action(permission, 'atlassian_*')).toBeUndefined();
expect(config.permission['*']).toBeUndefined();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'search' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(
opencodeEvent('permission.asked', {
id: 'per_1',
sessionID: NATIVE,
permission: 'atlassian_search',
patterns: ['*'],
metadata: {},
always: [],
})
);
session.push(sessionStatus(NATIVE, 'idle'));
await recorder.waitFor('turn.completed', () => true, 1_000);
expect(recorder.ofType('request.opened')).toHaveLength(0);
expect(session.calls).toContainEqual({ method: 'replyPermission', args: ['per_1', 'once'] });
});
it("still types a connector's tools as MCP tool approvals", () => {
expect(toRequestType('atlassian_search', ['switch', 'atlassian'])).toBe('mcp_tool_approval');
});
it('names the connector on the card it opens', async () => {
const { adapter, session, recorder } = await setup('approval-required', {
mcpServers: servers,
connectorMcpServers: ['atlassian', 'gws'],
});
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'search' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(
opencodeEvent('permission.asked', {
id: 'per_1',
sessionID: NATIVE,
permission: 'atlassian_search',
patterns: ['*'],
metadata: {},
always: ['*'],
})
);
const opened = await recorder.waitFor('request.opened', () => true, 1_000);
expect(opened).toMatchObject({ requestType: 'mcp_tool_approval', connector: 'atlassian' });
});
it('says which server wants to run which tool, with the input it will run', async () => {
const { adapter, session, recorder } = await setup('approval-required', {
mcpServers: servers,
connectorMcpServers: ['atlassian', 'gws'],
});
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'comment' });
session.push(sessionStatus(NATIVE, 'busy'));
session.push(messageUpdated(NATIVE, 'msg1', 'assistant'));
session.push(
toolPart(NATIVE, 'msg1', 'c1', 'atlassian_addCommentToJiraIssue', {
status: 'running',
input: { issueIdOrKey: 'PROJ-1', commentBody: 'Shipped in 1.2.' },
time: { start: 0 },
})
);
session.push(
opencodeEvent('permission.asked', {
id: 'per_1',
sessionID: NATIVE,
permission: 'atlassian_addCommentToJiraIssue',
patterns: ['*'],
metadata: {},
always: ['*'],
tool: { messageID: 'msg1', callID: 'c1' },
})
);
const opened = await recorder.waitFor('request.opened', () => true, 1_000);
expect(opened).toMatchObject({
title: 'atlassian wants to run addCommentToJiraIssue',
detail: '{"issueIdOrKey":"PROJ-1","commentBody":"Shipped in 1.2."}',
});
});
it('splits a tool name by the longest server it starts with', () => {
expect(mcpToolOf('switch_echo_run', ['switch', 'switch_echo'])).toEqual({
server: 'switch_echo',
tool: 'run',
});
expect(mcpToolOf('bash', ['switch'])).toBeUndefined();
});
});