symposium 2.4.3 → 3.0.0

package/test/helpers/mockSdk.js

@@ -0,0 +1,52 @@
+// Helpers that build canned async iterables mirroring the SDK shapes used by each provider.
+
+export function asyncIterable(events) {
+	return {
+		[Symbol.asyncIterator]() {
+			let i = 0;
+			return {
+				async next() {
+					if (i >= events.length)
+						return {done: true, value: undefined};
+					return {done: false, value: events[i++]};
+				},
+			};
+		},
+	};
+}
+
+// OpenAI Responses API streaming object: async iterable + .finalResponse()
+export function openAiResponsesStream(events, finalResponse) {
+	return {
+		...asyncIterable(events),
+		async finalResponse() {
+			return finalResponse;
+		},
+	};
+}
+
+// Anthropic messages.stream() object: async iterable + .finalMessage()
+export function anthropicMessagesStream(events, finalMessage) {
+	return {
+		...asyncIterable(events),
+		async finalMessage() {
+			return finalMessage;
+		},
+	};
+}
+
+// A fake thread that exposes whatever Model.generate() looks at.
+export function fakeThread({messages = [], state = {model: 'fake'}} = {}) {
+	return {messages, state};
+}
+
+// Drain a generator: collect yielded deltas and the final return value.
+export async function drain(it) {
+	const deltas = [];
+	let step = await it.next();
+	while (!step.done) {
+		deltas.push(step.value);
+		step = await it.next();
+	}
+	return {deltas, value: step.value};
+}

package/test/mcp.test.js

@@ -0,0 +1,216 @@
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+
+import Agent from '../Agent.js';
+import Symposium from '../Symposium.js';
+import Model from '../Model.js';
+import Message from '../Message.js';
+import Thread from '../Thread.js';
+import MCPServer from '../MCPServer.js';
+
+class FakeMCPClient {
+	constructor({tools = [], resources = [], resourceContents = {}} = {}) {
+		this._tools = tools;
+		this._resources = resources;
+		this._resourceContents = resourceContents;
+		this.callToolCalls = [];
+		this.closed = false;
+	}
+
+	async listTools() {
+		return {tools: this._tools};
+	}
+
+	async listResources() {
+		return {resources: this._resources};
+	}
+
+	async callTool(args) {
+		this.callToolCalls.push(args);
+		const text = this._resourceContents[args.name] ?? ('ok:' + args.name);
+		return {content: [{type: 'text', text}]};
+	}
+
+	async readResource({uri}) {
+		const text = this._resourceContents[uri] ?? ('contents of ' + uri);
+		return {contents: [{uri, text}]};
+	}
+
+	async close() {
+		this.closed = true;
+	}
+}
+
+class FakeMCPServer extends MCPServer {
+	constructor(config, fakeClient) {
+		super(config);
+		this._fakeClient = fakeClient;
+	}
+
+	async _connect() {
+		return this._fakeClient;
+	}
+}
+
+// Minimal scripted model so the agent can be instantiated and getTools() probed
+// without needing real provider SDKs.
+class ScriptedModel extends Model {
+	constructor(label, script = []) {
+		super();
+		this.label = label;
+		this.script = script;
+		this.calls = 0;
+	}
+	async getModels() {
+		return new Map([[this.label, {name: this.label, tokens: 1000, tools: true, structured_output: false}]]);
+	}
+	async *generate(_model, _thread, _functions, _options) {
+		const turn = this.script[this.calls++];
+		if (!turn) throw new Error('No more scripted turns');
+		for (const delta of turn.deltas || []) yield delta;
+		return turn.messages;
+	}
+}
+
+async function makeAgent(label = 'fake-mcp') {
+	await Symposium.loadModel(new ScriptedModel(label, [{
+		deltas: [],
+		messages: [new Message('assistant', [{type: 'text', content: 'noop'}])],
+	}]));
+	const agent = new Agent();
+	agent.default_model = label;
+	await agent.init();
+	return agent;
+}
+
+test('MCPServer prefixes tool names with the server name', async () => {
+	const agent = await makeAgent('fake-mcp-prefix');
+	const client = new FakeMCPClient({
+		tools: [
+			{name: 'search', description: 'search the repo', inputSchema: {type: 'object', properties: {q: {type: 'string'}}}},
+			{name: 'read_file', description: 'read a file', inputSchema: {type: 'object', properties: {path: {type: 'string'}}}},
+		],
+	});
+	const server = new FakeMCPServer({name: 'github', transport: 'stdio', command: 'noop'}, client);
+	await agent.addToolkit(server);
+
+	const fns = await server.getTools();
+	const names = fns.map(f => f.name).sort();
+	assert.deepEqual(names, ['github__read_file', 'github__search']);
+
+	const search = fns.find(f => f.name === 'github__search');
+	assert.equal(search.description, 'search the repo');
+	assert.deepEqual(search.parameters, {type: 'object', properties: {q: {type: 'string'}}});
+});
+
+test('two MCPServers with colliding raw tool names coexist via prefixing', async () => {
+	const agent = await makeAgent('fake-mcp-collide');
+
+	const ghClient = new FakeMCPClient({tools: [{name: 'search', description: 'gh search'}]});
+	const fsClient = new FakeMCPClient({tools: [{name: 'search', description: 'fs search'}]});
+
+	const gh = new FakeMCPServer({name: 'github', transport: 'stdio', command: 'noop'}, ghClient);
+	const fs = new FakeMCPServer({name: 'fs', transport: 'stdio', command: 'noop'}, fsClient);
+
+	await agent.addToolkit(gh);
+	await agent.addToolkit(fs);
+
+	const tools = await agent.getTools(false);
+	assert.ok(tools.has('github__search'));
+	assert.ok(tools.has('fs__search'));
+
+	const thread = new Thread('test-collide', agent);
+	thread.state = {model: 'fake-mcp-collide'};
+
+	await tools.get('github__search').toolkit.callTool(thread, 'github__search', {q: 'hi'});
+	await tools.get('fs__search').toolkit.callTool(thread, 'fs__search', {q: 'hi'});
+
+	assert.deepEqual(ghClient.callToolCalls, [{name: 'search', arguments: {q: 'hi'}}]);
+	assert.deepEqual(fsClient.callToolCalls, [{name: 'search', arguments: {q: 'hi'}}]);
+});
+
+test('MCPServer.callTool strips the prefix and forwards to client.callTool', async () => {
+	const agent = await makeAgent('fake-mcp-forward');
+	const client = new FakeMCPClient({tools: [{name: 'do_thing', description: '', inputSchema: {type: 'object', properties: {}}}]});
+	const server = new FakeMCPServer({name: 'svc', transport: 'stdio', command: 'noop'}, client);
+	await agent.addToolkit(server);
+
+	const thread = new Thread('test-forward', agent);
+	thread.state = {model: 'fake-mcp-forward'};
+
+	const result = await server.callTool(thread, 'svc__do_thing', {x: 1});
+
+	assert.deepEqual(client.callToolCalls, [{name: 'do_thing', arguments: {x: 1}}]);
+	assert.ok(result.content);
+	assert.equal(result.content[0].text, 'ok:do_thing');
+});
+
+test('MCPServer.callTool throws when MCP result has isError', async () => {
+	const agent = await makeAgent('fake-mcp-error');
+	const client = new FakeMCPClient({tools: [{name: 'broken'}]});
+	client.callTool = async () => ({isError: true, content: [{type: 'text', text: 'boom'}]});
+
+	const server = new FakeMCPServer({name: 'svc', transport: 'stdio', command: 'noop'}, client);
+	await agent.addToolkit(server);
+
+	const thread = new Thread('test-error', agent);
+	thread.state = {model: 'fake-mcp-error'};
+
+	await assert.rejects(
+		() => server.callTool(thread, 'svc__broken', {}),
+		/boom/,
+	);
+});
+
+test('addMCPServer with resources:true registers each resource as an on_request context and auto-injects get_context', async () => {
+	const agent = await makeAgent('fake-mcp-res');
+	const client = new FakeMCPClient({
+		tools: [{name: 'noop_tool', description: '', inputSchema: {type: 'object', properties: {}}}],
+		resources: [
+			{uri: 'mem://a', name: 'doc-a', description: 'first doc'},
+			{uri: 'mem://b', name: 'doc-b', description: 'second doc'},
+		],
+		resourceContents: {'mem://a': 'AAA', 'mem://b': 'BBB'},
+	});
+
+	// Replicate addMCPServer manually but with the test subclass so we can inject the fake client.
+	const server = new FakeMCPServer({name: 'svc', transport: 'stdio', command: 'noop', resources: true}, client);
+	await agent.addToolkit(server);
+	const {default: MCPResource} = await import('../Contexts/MCPResource.js');
+	for (const res of await server.listResources()) {
+		await agent.addContext(new MCPResource(server, res), {
+			type: 'on_request',
+			description: res.description || '',
+		});
+	}
+
+	const thread = new Thread('test-res', agent);
+	thread.state = {model: 'fake-mcp-res'};
+	await agent.initThread(thread);
+
+	assert.ok(agent.toolkits.has('get_context'), 'get_context toolkit should be auto-injected');
+
+	const titles = agent.context.map(c => c.title).sort();
+	assert.deepEqual(titles, ['doc-a', 'doc-b']);
+
+	const docA = agent.context.find(c => c.title === 'doc-a');
+	assert.equal(docA.options.type, 'on_request');
+	assert.equal(docA.options.description, 'first doc');
+	assert.equal(await docA.context.getText(), 'AAA');
+});
+
+test('MCPServer.close() shuts the client down', async () => {
+	const agent = await makeAgent('fake-mcp-close');
+	const client = new FakeMCPClient({tools: [{name: 'x'}]});
+	const server = new FakeMCPServer({name: 'svc', transport: 'stdio', command: 'noop'}, client);
+	await agent.addToolkit(server);
+
+	await server.close();
+	assert.equal(client.closed, true);
+	assert.equal(server.client, null);
+});
+
+test('MCPServer constructor validates config', () => {
+	assert.throws(() => new MCPServer({}), /config\.name is required/);
+	assert.throws(() => new MCPServer(null), /config must be an object/);
+});

package/test/models/anthropic.test.js

@@ -0,0 +1,135 @@
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+
+import AnthropicModel from '../../Models/AnthropicModel.js';
+import Message from '../../Message.js';
+import {anthropicMessagesStream, fakeThread, drain} from '../helpers/mockSdk.js';
+
+function buildModelDef(overrides = {}) {
+	return {
+		name: 'claude-haiku-4-5-20251001',
+		tokens: 200000,
+		tools: true,
+		...overrides,
+	};
+}
+
+function installFakeAnthropic(modelInstance, stream) {
+	modelInstance.getAnthropic = () => ({
+		beta: {
+			messages: {
+				stream() {
+					return stream;
+				},
+			},
+		},
+	});
+}
+
+test('AnthropicModel streams text deltas and assembles a text Message[]', async () => {
+	const m = new AnthropicModel();
+	const finalMessage = {
+		content: [{type: 'text', text: 'Hello world'}],
+	};
+	const stream = anthropicMessagesStream(
+		[
+			{type: 'content_block_start', index: 0, content_block: {type: 'text'}},
+			{type: 'content_block_delta', index: 0, delta: {type: 'text_delta', text: 'Hello'}},
+			{type: 'content_block_delta', index: 0, delta: {type: 'text_delta', text: ' world'}},
+			{type: 'content_block_stop', index: 0},
+		],
+		finalMessage,
+	);
+	installFakeAnthropic(m, stream);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{type: 'text_delta', content: 'Hello'},
+		{type: 'text_delta', content: ' world'},
+	]);
+
+	assert.equal(value.length, 1);
+	assert.ok(value[0] instanceof Message);
+	assert.deepEqual(value[0].content, [{type: 'text', content: 'Hello world'}]);
+});
+
+test('AnthropicModel buffers input_json_delta and yields a complete tool_call', async () => {
+	const m = new AnthropicModel();
+	const finalMessage = {
+		content: [
+			{
+				type: 'tool_use',
+				id: 'tool_1',
+				name: 'do_thing',
+				input: {a: 1, b: 'x'},
+			},
+		],
+	};
+	const stream = anthropicMessagesStream(
+		[
+			{
+				type: 'content_block_start',
+				index: 0,
+				content_block: {type: 'tool_use', id: 'tool_1', name: 'do_thing'},
+			},
+			{type: 'content_block_delta', index: 0, delta: {type: 'input_json_delta', partial_json: '{"a":1,'}},
+			{type: 'content_block_delta', index: 0, delta: {type: 'input_json_delta', partial_json: '"b":"x"}'}},
+			{type: 'content_block_stop', index: 0},
+		],
+		finalMessage,
+	);
+	installFakeAnthropic(m, stream);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{
+			type: 'tool_call',
+			content: {id: 'tool_1', name: 'do_thing', arguments: {a: 1, b: 'x'}},
+		},
+	]);
+
+	assert.deepEqual(value[0].content, [
+		{
+			type: 'tool_call',
+			content: [{id: 'tool_1', name: 'do_thing', arguments: {a: 1, b: 'x'}}],
+		},
+	]);
+});
+
+test('AnthropicModel emits reasoning_delta from thinking_delta', async () => {
+	const m = new AnthropicModel();
+	const thinkingBlock = {type: 'thinking', thinking: 'reasoning text'};
+	const finalMessage = {
+		content: [thinkingBlock, {type: 'text', text: 'done'}],
+	};
+	const stream = anthropicMessagesStream(
+		[
+			{type: 'content_block_start', index: 0, content_block: {type: 'thinking'}},
+			{type: 'content_block_delta', index: 0, delta: {type: 'thinking_delta', thinking: 'reasoning '}},
+			{type: 'content_block_delta', index: 0, delta: {type: 'thinking_delta', thinking: 'text'}},
+			{type: 'content_block_stop', index: 0},
+			{type: 'content_block_start', index: 1, content_block: {type: 'text'}},
+			{type: 'content_block_delta', index: 1, delta: {type: 'text_delta', text: 'done'}},
+			{type: 'content_block_stop', index: 1},
+		],
+		finalMessage,
+	);
+	installFakeAnthropic(m, stream);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{type: 'reasoning_delta', content: 'reasoning '},
+		{type: 'reasoning_delta', content: 'text'},
+		{type: 'text_delta', content: 'done'},
+	]);
+
+	assert.deepEqual(value[0].content[0], {
+		type: 'reasoning',
+		content: 'reasoning text',
+		original: thinkingBlock,
+	});
+	assert.deepEqual(value[0].content[1], {type: 'text', content: 'done'});
+});

package/test/models/groq.test.js

@@ -0,0 +1,71 @@
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+
+import GroqModel from '../../Models/GroqModel.js';
+import Message from '../../Message.js';
+import {asyncIterable, fakeThread, drain} from '../helpers/mockSdk.js';
+
+function buildModelDef() {
+	return {
+		name: 'llama-3.3-70b-versatile',
+		tokens: 128000,
+		tools: true,
+	};
+}
+
+function installFakeGroq(modelInstance, chunks) {
+	modelInstance.getGroq = () => ({
+		chat: {
+			completions: {
+				async create(_payload) {
+					return asyncIterable(chunks);
+				},
+			},
+		},
+	});
+}
+
+test('GroqModel streams text chunks and assembles a text Message[]', async () => {
+	const m = new GroqModel();
+	installFakeGroq(m, [
+		{choices: [{delta: {content: 'Hi'}}]},
+		{choices: [{delta: {content: ' there'}}]},
+		{choices: [{delta: {}, finish_reason: 'stop'}]},
+	]);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{type: 'text_delta', content: 'Hi'},
+		{type: 'text_delta', content: ' there'},
+	]);
+
+	assert.equal(value.length, 1);
+	assert.ok(value[0] instanceof Message);
+	assert.deepEqual(value[0].content, [{type: 'text', content: 'Hi there'}]);
+});
+
+test('GroqModel accumulates tool_call deltas across chunks', async () => {
+	const m = new GroqModel();
+	installFakeGroq(m, [
+		{choices: [{delta: {tool_calls: [{index: 0, id: 'c1', type: 'function', function: {name: 'sum', arguments: '{"x":'}}]}}]},
+		{choices: [{delta: {tool_calls: [{index: 0, function: {arguments: '5}'}}]}}]},
+		{choices: [{delta: {}, finish_reason: 'tool_calls'}]},
+	]);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{
+			type: 'tool_call',
+			content: {id: 'c1', name: 'sum', arguments: {x: 5}},
+		},
+	]);
+
+	assert.deepEqual(value[0].content, [
+		{
+			type: 'tool_call',
+			content: [{id: 'c1', name: 'sum', arguments: {x: 5}}],
+		},
+	]);
+});

package/test/models/legacyOpenai.test.js

@@ -0,0 +1,87 @@
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+
+import LegacyOpenAIModel from '../../Models/LegacyOpenAIModel.js';
+import Message from '../../Message.js';
+import {asyncIterable, fakeThread, drain} from '../helpers/mockSdk.js';
+
+function buildModelDef() {
+	return {
+		name: 'gpt-3.5-turbo',
+		tokens: 16000,
+		tools: true,
+	};
+}
+
+function installFakeOpenAi(modelInstance, chunks) {
+	modelInstance.getOpenAi = () => ({
+		chat: {
+			completions: {
+				async create(_payload) {
+					return asyncIterable(chunks);
+				},
+			},
+		},
+	});
+}
+
+test('LegacyOpenAIModel streams text chunks and assembles a text Message[]', async () => {
+	const m = new LegacyOpenAIModel();
+	installFakeOpenAi(m, [
+		{choices: [{delta: {content: 'Hello'}}]},
+		{choices: [{delta: {content: ' world'}}]},
+		{choices: [{delta: {}, finish_reason: 'stop'}]},
+	]);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{type: 'text_delta', content: 'Hello'},
+		{type: 'text_delta', content: ' world'},
+	]);
+
+	assert.equal(value.length, 1);
+	assert.ok(value[0] instanceof Message);
+	assert.deepEqual(value[0].content, [{type: 'text', content: 'Hello world'}]);
+});
+
+test('LegacyOpenAIModel accumulates tool_call deltas across chunks and yields a complete tool_call', async () => {
+	const m = new LegacyOpenAIModel();
+	installFakeOpenAi(m, [
+		{choices: [{delta: {tool_calls: [{index: 0, id: 'call_xyz', type: 'function', function: {name: 'do_thing', arguments: '{"a":'}}]}}]},
+		{choices: [{delta: {tool_calls: [{index: 0, function: {arguments: '1}'}}]}}]},
+		{choices: [{delta: {}, finish_reason: 'tool_calls'}]},
+	]);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{
+			type: 'tool_call',
+			content: {id: 'call_xyz', name: 'do_thing', arguments: {a: 1}},
+		},
+	]);
+
+	assert.deepEqual(value[0].content, [
+		{
+			type: 'tool_call',
+			content: [{id: 'call_xyz', name: 'do_thing', arguments: {a: 1}}],
+		},
+	]);
+});
+
+test('LegacyOpenAIModel combines text + tool_calls in one Message', async () => {
+	const m = new LegacyOpenAIModel();
+	installFakeOpenAi(m, [
+		{choices: [{delta: {content: 'Calling now'}}]},
+		{choices: [{delta: {tool_calls: [{index: 0, id: 'c1', type: 'function', function: {name: 'f', arguments: '{}'}}]}}]},
+		{choices: [{delta: {}, finish_reason: 'tool_calls'}]},
+	]);
+
+	const {value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.equal(value[0].content.length, 2);
+	assert.deepEqual(value[0].content[0], {type: 'text', content: 'Calling now'});
+	assert.equal(value[0].content[1].type, 'tool_call');
+	assert.equal(value[0].content[1].content[0].name, 'f');
+});

package/test/models/ollama.test.js

@@ -0,0 +1,90 @@
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+
+import OllamaModel from '../../Models/OllamaModel.js';
+import Message from '../../Message.js';
+import {asyncIterable, fakeThread, drain} from '../helpers/mockSdk.js';
+
+function buildModelDef() {
+	return {
+		name: 'llama3',
+		tools: true,
+		structured_output: true,
+	};
+}
+
+function installFakeOllama(modelInstance, chunks) {
+	modelInstance.getOllama = () => ({
+		async chat(_payload) {
+			return asyncIterable(chunks);
+		},
+		async list() {
+			return {models: []};
+		},
+	});
+}
+
+test('OllamaModel streams text + thinking chunks and assembles a Message[]', async () => {
+	const m = new OllamaModel();
+	installFakeOllama(m, [
+		{message: {thinking: 'reasoning '}},
+		{message: {thinking: 'step'}},
+		{message: {content: 'Hello'}},
+		{message: {content: ' world'}, done: true},
+	]);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{type: 'reasoning_delta', content: 'reasoning '},
+		{type: 'reasoning_delta', content: 'step'},
+		{type: 'text_delta', content: 'Hello'},
+		{type: 'text_delta', content: ' world'},
+	]);
+
+	assert.equal(value.length, 1);
+	assert.ok(value[0] instanceof Message);
+	assert.deepEqual(value[0].content, [
+		{type: 'reasoning', content: 'reasoning step'},
+		{type: 'text', content: 'Hello world'},
+	]);
+});
+
+test('OllamaModel yields tool_call from final chunk', async () => {
+	const m = new OllamaModel();
+	installFakeOllama(m, [
+		{
+			message: {
+				tool_calls: [{function: {name: 'do_thing', arguments: {a: 1}}}],
+			},
+			done: true,
+		},
+	]);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{type: 'tool_call', content: {name: 'do_thing', arguments: {a: 1}}},
+	]);
+
+	assert.deepEqual(value[0].content, [
+		{
+			type: 'tool_call',
+			content: [{name: 'do_thing', arguments: {a: 1}}],
+		},
+	]);
+});
+
+test('OllamaModel emulates streaming when only a single full chunk arrives', async () => {
+	const m = new OllamaModel();
+	installFakeOllama(m, [
+		{message: {content: 'One shot response'}, done: true},
+	]);
+
+	const {deltas, value} = await drain(m.generate(buildModelDef(), fakeThread()));
+
+	assert.deepEqual(deltas, [
+		{type: 'text_delta', content: 'One shot response'},
+	]);
+	assert.deepEqual(value[0].content, [{type: 'text', content: 'One shot response'}]);
+});