symposium 1.3.4 → 1.4.0

package/models/Claude37Sonnet.js

@@ -1,6 +1,6 @@
 import AnthropicModel from "./AnthropicModel.js";
 
-export default class Claude35Sonnet extends AnthropicModel {
+export default class Claude37Sonnet extends AnthropicModel {
 	name = 'claude-3-7-sonnet-latest';
 	label = 'claude-3.7-sonnet';
 	tokens = 200000;

package/models/Claude45Haiku.js

@@ -0,0 +1,7 @@
+import AnthropicModel from "./AnthropicModel.js";
+
+export default class Claude45Haiku extends AnthropicModel {
+	name = 'claude-haiku-4-5-20251001';
+	label = 'claude-4.5-haiku';
+	tokens = 200000;
+}

package/models/OllamaModel.js

@@ -0,0 +1,148 @@
+import ollama from "ollama";
+import Model from "../Model.js";
+import Message from "../Message.js";
+
+export default class OllamaModel extends Model {
+	supports_functions = true;
+
+	async generate(thread, functions = [], options = {}) {
+		const parsed = this.parseOptions(options, functions);
+		options = parsed.options;
+		functions = parsed.functions;
+
+		let messages = thread.messages;
+
+		if (functions.length && !this.supports_functions) {
+			// Se il modello non supporta nativamente le funzioni, inserisco il prompt ad hoc come ultimo messaggio di sistema
+			const functions_prompt = this.promptFromFunctions(options, functions);
+			let system_messages = [], other_messages = [], first_found = false;
+			for (let message of messages) {
+				if (!first_found && message.role !== 'system')
+					first_found = true;
+
+				if (!first_found)
+					system_messages.push(message);
+				else
+					other_messages.push(message);
+			}
+
+			system_messages.push(new Message('system', functions_prompt));
+
+			messages = [...system_messages, ...other_messages];
+			functions = [];
+		}
+
+		const convertedMessages = [];
+		for (let m of messages)
+			convertedMessages.push(...this.convertMessage(m));
+
+		const completion_payload = {
+			model: this.name,
+			messages: convertedMessages,
+			tools: functions.map(f => ({
+				type: 'function',
+				function: f,
+			})),
+		};
+
+		if (options.force_function) {
+			completion_payload.tool_choice = {
+				type: 'function',
+				function: {name: options.force_function},
+			};
+		}
+
+		if (options.response_format)
+			completion_payload.response_format = options.response_format;
+
+		if (!completion_payload.tools.length)
+			delete completion_payload.tools;
+
+		const chatCompletion = await ollama.chat(completion_payload);
+		const completion = chatCompletion.message;
+
+		const message_content = [];
+		if (completion.content)
+			message_content.push({type: 'text', content: completion.content});
+
+		if (completion.tool_calls?.length) {
+			message_content.push({
+				type: 'function',
+				content: completion.tool_calls.map(tool_call => {
+					if (tool_call.function)
+						throw new Error('Unsupported tool type');
+
+					return {
+						name: tool_call.function.name,
+						arguments: tool_call.function.arguments ? JSON.parse(tool_call.function.arguments) : {},
+					};
+				}),
+			});
+		}
+
+		return [
+			new Message('assistant', message_content),
+		];
+	}
+
+	convertMessage(message) {
+		const messages = [],
+			role = message.role === 'system' ? this.system_role_name : message.role;
+
+		for (let c of message.content) {
+			switch (c.type) {
+				case 'text':
+					messages.push({
+						role,
+						content: c.content,
+						name: message.name,
+					});
+					break;
+
+				case 'function':
+					if (this.supports_functions) {
+						messages.push({
+							role,
+							name: message.name,
+							tool_calls: c.content.map(tool_call => ({
+								id: tool_call.id,
+								type: 'function',
+								function: {
+									name: tool_call.name,
+									arguments: tool_call.arguments ? JSON.stringify(tool_call.arguments) : '{}',
+								},
+							})),
+						});
+					} else {
+						messages.push({
+							role,
+							content: c.content.map(f => '```CALL \n' + f.name + '\n' + JSON.stringify(f.arguments || {}) + '\n```').join("\n\n"),
+							name: message.name,
+						});
+					}
+					break;
+
+				case 'function_response':
+					if (this.supports_functions) {
+						messages.push({
+							role: 'tool',
+							content: JSON.stringify(c.content.response),
+							tool_name: message.name,
+						});
+					} else {
+						messages.push({
+							role: 'user',
+							content: 'FUNCTION RESPONSE:\n' + JSON.stringify(c.content.response),
+							name: message.name,
+						});
+					}
+					break;
+
+				default:
+					throw new Error('Message type unsupported by this model');
+			}
+		}
+
+		return messages;
+	}
+}

package/package.json

@@ -1,14 +1,15 @@
 {
   "type": "module",
   "name": "symposium",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "description": "Agents",
   "main": "index.js",
   "author": "Domenico Giambra",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.65.0",
+    "@anthropic-ai/sdk": "^0.67.0",
     "groq-sdk": "^0.33.0",
+    "ollama": "^0.6.0",
     "openai": "^6.0.0",
     "tiktoken": "^1.0.10",
     "uuid": "^13.0.0"