@xalia/agent 0.6.1 → 0.6.3

package/dist/agent/src/agent/agent.js

@@ -1,49 +1,16 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Agent = exports.AgentProfile = void 0;
+exports.Agent = exports.DEFAULT_LLM_URL = exports.AgentProfile = void 0;
 exports.createUserMessage = createUserMessage;
 exports.createUserMessageEnsure = createUserMessageEnsure;
-const dotenv = __importStar(require("dotenv"));
+exports.completionToAssistantMessageParam = completionToAssistantMessageParam;
 const mcpServerManager_1 = require("./mcpServerManager");
 const assert_1 = require("assert");
 const sdk_1 = require("@xalia/xmcp/sdk");
 var sdk_2 = require("@xalia/xmcp/sdk");
 Object.defineProperty(exports, "AgentProfile", { enumerable: true, get: function () { return sdk_2.AgentProfile; } });
+exports.DEFAULT_LLM_URL = "http://localhost:5001/v1";
 const MAX_TOOL_CALL_RESPONSE_LENGTH = 4000;
-dotenv.config();
 const logger = (0, sdk_1.getLogger)();
 class Agent {
     constructor(eventHandler, mcpServerManager, llm, contextManager) {
@@ -88,13 +55,24 @@ class Agent {
         return this.userMessagesRaw([userMessage]);
     }
     async userMessagesRaw(userMessages) {
+        // Image and audio handling
+        //
+        // `ChatCompletions` (responses from the LLM) can contain `audio` and
+        // `images` tags.  However, the `ChatCompletionMessageParam` type does not
+        // allow for "assistant" messages with images / audio.
+        //
+        // As such, our current approach is to extract all assistant-generated
+        // media and return it separately.
         // Note: `getLLMContext` returns a copy to we can mutate this array
         const context = this.contextManager.getLLMContext();
         const newMessagesIdx = context.length;
         // Add the new user messages
         context.push(...userMessages);
+        const images = [];
+        // We convert the `ChatCompletionsMessage` into a
+        // `ChatCompletionAssistantMessageParam` and extract image data.
         let completion = await this.chatCompletion(context);
-        let message = completion.choices[0].message;
+        let message = this.processCompletion(completion, images);
         context.push(message);
         // While there are tool calls to make, invoke them and loop
         while (message.tool_calls && message.tool_calls.length > 0) {
@@ -107,11 +85,15 @@ class Agent {
                 // `toolCallResults`.
                 const result = await this.doToolCall(toolCall);
                 toolCallResults.push([context.length, result]);
-                context.push({
+                const toolResult = {
                     role: "tool",
                     tool_call_id: toolCall.id,
                     content: result.response,
-                });
+                };
+                if (result.metadata) {
+                    toolResult.metadata = result.metadata;
+                }
+                context.push(toolResult);
                 // If the tool call requested that its args be redacted, this can be
                 // done now - before the next LLM invocation.
                 if (result.overwriteArgs) {
@@ -130,15 +112,15 @@ class Agent {
             // view of the conversation state.
             try {
                 completion = await this.chatCompletion(context); // CAN THROW
-                message = completion.choices[0].message;
+                message = this.processCompletion(completion, images);
                 context.push(message);
             }
             finally {
                 // Now that the tool call results have been passed to the LLM, perform
                 // any updates on them.  Pass the (updated) tool-call-result LLM
-                // messages to the event handler - note, we want to do this even if
-                // the an error occured, so that the caller has an up-to-date picture
-                // of the context state when the error occured.
+                // messages to the event handler - note, we want to do this even if an
+                // error occured, so that the caller has an up-to-date picture of the
+                // context state when the error occured.
                 toolCallResults.forEach(([indexInContext, tcr]) => {
                     const ctxMsg = context[indexInContext];
                     if (tcr.overwriteResponse) {
@@ -155,7 +137,7 @@ class Agent {
         this.eventHandler.onCompletion(message);
         // Add all new new messages to the context
         this.contextManager.addMessages(context.slice(newMessagesIdx));
-        return completion.choices[0].message;
+        return { message, images: images.length === 0 ? undefined : images };
     }
     userMessage(msg, imageB64) {
         void this.userMessageEx(msg, imageB64);
@@ -180,11 +162,13 @@ class Agent {
         // Compute the full list of available tools
         let tools;
         const mcpTools = this.mcpServerManager.getOpenAITools();
+        logger.debug(`[chatCompletion] mcpTools: ${JSON.stringify(mcpTools)}`);
         const enabledTools = this.tools.concat(mcpTools);
         if (enabledTools.length > 0) {
             tools = enabledTools;
         }
-        const completion = await this.llm.getConversationResponse(context, tools, this.eventHandler.onAgentMessage.bind(this.eventHandler));
+        logger.debug(`[chatCompletion] tools: ${JSON.stringify(tools)}`);
+        const completion = await this.llm.getConversationResponse(context, tools, this.eventHandler.onAgentMessage.bind(this.eventHandler), this.eventHandler.onReasoning.bind(this.eventHandler));
         logger.debug(`Received chat completion ${JSON.stringify(completion)}`);
         return completion;
     }
@@ -234,21 +218,27 @@ class Agent {
             const toolName = toolCall.function.name;
             const agentTool = this.agentTools.get(toolName);
             const isAgentTool = !!agentTool;
-            const approve = await this.eventHandler.onToolCall(toolCall, isAgentTool);
-            if (!approve) {
-                result = { response: "User denied tool request." };
-            }
-            else if (isAgentTool) {
+            if (isAgentTool) {
                 // Internal (agent) tool
-                const args = JSON.parse(toolCall.function.arguments);
-                result = await agentTool.handler(this, args);
+                if (!(await this.eventHandler.onToolCall(toolCall, true))) {
+                    result = { response: "User denied tool request." };
+                }
+                else {
+                    const args = JSON.parse(toolCall.function.arguments || "{}");
+                    result = await agentTool.handler(this, args);
+                }
             }
             else {
-                // McpServer tool call (agentTool === undefined)
-                const args = JSON.parse(toolCall.function.arguments);
-                result = {
-                    response: await this.mcpServerManager.invoke(toolName, args),
-                };
+                // McpServer tool call (agentTool === undefined).  Sanity check the
+                // tool call data, get approval, and then invoke.
+                const args = JSON.parse(toolCall.function.arguments || "{}");
+                const tc = this.mcpServerManager.verifyToolCall(toolName, args);
+                if (!(await this.eventHandler.onToolCall(toolCall, false))) {
+                    result = { response: "User denied tool request." };
+                }
+                else {
+                    result = { response: await this.mcpServerManager.invoke(tc) };
+                }
                 logger.debug(`tool call result ${JSON.stringify(result)}`);
             }
         }
@@ -278,6 +268,17 @@ class Agent {
         }
         return result;
     }
+    processCompletion(completion, images) {
+        // Add any images into the list, and call the event handler
+        const compMessage = completion.choices[0].message;
+        if (compMessage.images) {
+            for (const image of compMessage.images) {
+                this.eventHandler.onImage(image);
+                images.push(image);
+            }
+        }
+        return completionToAssistantMessageParam(compMessage);
+    }
 }
 exports.Agent = Agent;
 /**
@@ -324,3 +325,54 @@ function createUserMessageEnsure(msg, imageB64, name) {
     (0, assert_1.strict)(userMsg);
     return userMsg;
 }
+function completionToAssistantMessageParam(compMessage) {
+    // Strip down the `ChatCompletionMessage` to a
+    // `ChatCompletionAssistantMessageParam`, only including the non-null
+    // elements.  For reference:
+    //
+    // Response from the LLM:
+    //
+    //   export interface ChatCompletionMessage {
+    //     role: 'assistant';
+    //     audio?: ChatCompletionAudio | null;
+    //     content: string | null;
+    //     refusal: string | null;
+    //     tool_calls?: Array<ChatCompletionMessageToolCall>;
+    //
+    //     annotations?: Array<ChatCompletionMessage.Annotation>;
+    //     // openrouter
+    //     images?: Array<ChatCompletionContentPartImage>
+    //   }
+    //
+    // Input to the LLM
+    //
+    //   export interface ChatCompletionAssistantMessageParam {
+    //     role: "assistant";
+    //     audio?: ChatCompletionAssistantMessageParam.Audio | null;
+    //     content?:
+    //       | string
+    //       | Array<ChatCompletionContentPartText |
+    //               ChatCompletionContentPartRefusal>
+    //       | null;
+    //     refusal?: string | null;
+    //     tool_calls?: Array<ChatCompletionMessageToolCall>;
+    //
+    //     name?: string;
+    //   }
+    const message = {
+        role: "assistant",
+    };
+    if (compMessage.audio) {
+        message.audio = compMessage.audio;
+    }
+    if (compMessage.content) {
+        message.content = compMessage.content;
+    }
+    if (compMessage.refusal) {
+        message.refusal = compMessage.refusal;
+    }
+    if (compMessage.tool_calls) {
+        message.tool_calls = compMessage.tool_calls;
+    }
+    return message;
+}

package/dist/agent/src/agent/agentUtils.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XALIA_APP_HEADER = exports.DEFAULT_LLM_MODEL = exports.DEFAULT_LLM_URL = void 0;
 exports.createAgentWithoutSkills = createAgentWithoutSkills;
 exports.createAgentWithSkills = createAgentWithSkills;
 exports.createAgentFromSkillManager = createAgentFromSkillManager;
@@ -16,24 +15,16 @@ const dummyLLM_1 = require("./dummyLLM");
 const assert_1 = require("assert");
 const repeatLLM_1 = require("./repeatLLM");
 const context_1 = require("./context");
+const imageGenLLM_1 = require("./imageGenLLM");
 const logger = (0, sdk_1.getLogger)();
-exports.DEFAULT_LLM_URL = "http://localhost:5001/v1";
-// uses openrouter
-exports.DEFAULT_LLM_MODEL = process.env["DEFAULT_LLM_MODEL"] || "openai/gpt-4o";
-exports.XALIA_APP_HEADER = {
-    "HTTP-Referer": "xalia.ai",
-    "X-Title": "Xalia",
-};
-async function createAgentWithoutSkills(llmUrl, agentProfile, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream = false) {
+async function createAgentWithoutSkills(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream = false) {
     // Init SudoMcpServerManager
     logger.debug("[createAgentWithSkills] creating SudoMcpServerManager.");
     const sudoMcpServerManager = await sudoMcpServerManager_1.SkillManager.initialize((url, authResultP, displayName) => {
         platform.openUrl(url, authResultP, displayName);
     }, sudomcpConfig.backend_url, sudomcpConfig.api_key, authorizedUrl);
-    logger.debug("[createAgentWithoutSkills] restore mcp settings:" +
-        JSON.stringify(agentProfile.mcp_settings));
     // Create agent using the event handler
-    const agent = await createAgentFromSkillManager(llmUrl, agentProfile, eventHandler, platform, contextManager, llmApiKey, sudoMcpServerManager, stream);
+    const agent = await createAgentFromSkillManager(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, sudoMcpServerManager, stream);
     return [agent, sudoMcpServerManager];
 }
 /**
@@ -41,17 +32,16 @@ async function createAgentWithoutSkills(llmUrl, agentProfile, eventHandler, plat
  * IAgentEventHandler interface. This is the preferred way to create
  * agents.
  */
-async function createAgentWithSkills(llmUrl, agentProfile, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream = false) {
-    const [agent, sudoMcpServerManager] = await createAgentWithoutSkills(llmUrl, agentProfile, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream);
-    logger.debug("[createAgentWithSkills] restoring skills");
-    await sudoMcpServerManager.restoreMcpSettings(agentProfile.mcp_settings);
+async function createAgentWithSkills(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, mcpSettings, authorizedUrl, stream = false) {
+    const [agent, sudoMcpServerManager] = await createAgentWithoutSkills(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream);
+    logger.debug(`[createAgentWithSkills] skilles: ${JSON.stringify(mcpSettings)}`);
+    await sudoMcpServerManager.restoreMcpSettings(mcpSettings);
     return [agent, sudoMcpServerManager];
 }
-async function createAgentFromSkillManager(llmUrl, agentProfile, eventHandler, platform, contextManager, llmApiKey, skillManager, stream = false) {
+async function createAgentFromSkillManager(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, skillManager, stream = false) {
     // Create agent
     logger.debug("[createAgentFromSkillManager] creating agent ...");
-    const llm = await createLLM(llmUrl, llmApiKey, agentProfile.model, stream, platform);
-    contextManager.setAgentPrompt(agentProfile.system_prompt);
+    const llm = await createLLM(llmUrl, llmApiKey, model, stream, platform);
     const agent = agent_1.Agent.initializeWithLLM(eventHandler, llm, contextManager, skillManager);
     logger.debug("[createAgentFromSkillManager] done");
     return agent;
@@ -64,12 +54,16 @@ async function createLLM(llmUrl, llmApiKey, model, stream = false, platform) {
     else if (model === "repeat") {
         llm = new repeatLLM_1.RepeatLLM();
     }
+    else if (model == imageGenLLM_1.DEFAULT_IMAGE_GEN_MODEL) {
+        logger.info("ImageGenLLM");
+        llm = new imageGenLLM_1.ImageGenLLM(llmApiKey, llmUrl, model);
+    }
     else {
         // Regular Agent
         if (!llmApiKey) {
             throw new Error("Missing OpenAI API Key");
         }
-        logger.debug(`Initializing Agent: ${llmUrl ?? "unknown"} - ${model ?? "unknown"}`);
+        logger.debug(`Initializing Agent: ${llmUrl ?? "unknown"} - ${model}`);
         if (stream) {
             llm = new openAILLMStreaming_1.OpenAILLMStreaming(llmApiKey, llmUrl, model);
         }
@@ -86,11 +80,13 @@ async function createLLM(llmUrl, llmApiKey, model, stream = false, platform) {
  * messages are not used by the caller, the user does not need to approve tool
  * calls, etc).
  */
-async function createNonInteractiveAgent(url, agentProfile, conversation, platform, openaiApiKey, sudomcpConfig, approveToolsUpTo) {
+async function createNonInteractiveAgent(url, agentProfile, defaultModel, conversation, platform, openaiApiKey, sudomcpConfig, approveToolsUpTo) {
     let remainingToolCalls = approveToolsUpTo;
     const eventHandler = {
         onCompletion: () => { },
+        onImage: () => { },
         onAgentMessage: async () => { },
+        onReasoning: async () => { },
         // eslint-disable-next-line @typescript-eslint/require-await
         onToolCall: async () => {
             if (remainingToolCalls !== 0) {
@@ -102,25 +98,26 @@ async function createNonInteractiveAgent(url, agentProfile, conversation, platfo
         onToolCallResult: () => { },
     };
     const contextManager = new context_1.ContextManager(agentProfile.system_prompt, conversation || []);
-    const [agent, _] = await createAgentWithSkills(url, agentProfile, eventHandler, platform, contextManager, openaiApiKey, sudomcpConfig, undefined);
+    const [agent, _] = await createAgentWithSkills(url, agentProfile.model || defaultModel, eventHandler, platform, contextManager, openaiApiKey, sudomcpConfig, agentProfile.mcp_settings, undefined);
     return agent;
 }
 /**
  * Create an Agent (from the AgentProfile), pass it a single prompt and output
  * the response.
  */
-async function runOneShot(url, agentProfile, conversation, platform, prompt, image, llmApiKey, sudomcpConfig, approveToolsUpTo) {
+async function runOneShot(url, agentProfile, defaultModel, conversation, platform, prompt, image, llmApiKey, sudomcpConfig, approveToolsUpTo) {
     logger.debug("[runOneShot]: start");
     // Create a non-interactive agent and pass any prompt/ image to it.  Return
     // the first answer.
-    const agent = await createNonInteractiveAgent(url, agentProfile, conversation, platform, llmApiKey, sudomcpConfig, approveToolsUpTo);
-    const response = await agent.userMessageEx(prompt, image);
+    const agent = await createNonInteractiveAgent(url, agentProfile, defaultModel, conversation, platform, llmApiKey, sudomcpConfig, approveToolsUpTo);
+    const agentResponse = await agent.userMessageEx(prompt, image);
     await agent.shutdown();
     logger.debug("[runOneShot]: shutdown done");
-    if (!response) {
+    if (!agentResponse) {
         throw new Error("No message returned from agent");
     }
     // Handle different content types
+    const response = agentResponse.message;
     let responseText = "";
     if (typeof response.content === "string") {
         responseText = response.content;
@@ -146,5 +143,6 @@ async function runOneShot(url, agentProfile, conversation, platform, prompt, ima
     return {
         response: responseText,
         conversation: agent.getConversation(),
+        images: agentResponse.images,
     };
 }

package/dist/agent/src/agent/compressingContextManager.js

@@ -36,10 +36,11 @@ async function createCompressionAgent(compressionAgentUrl, compressionAgentModel
 }
 async function createSummary(compressionAgentUrl, compressionAgentModel, compressionAgentApiKey, conversation) {
     const agent = await createCompressionAgent(compressionAgentUrl, compressionAgentModel, compressionAgentApiKey);
-    const resp = await agent.userMessageEx(JSON.stringify(conversation));
-    if (!resp) {
+    const agentResp = await agent.userMessageEx(JSON.stringify(conversation));
+    if (!agentResp) {
         throw new Error("compression agent returned null");
     }
+    const resp = agentResp.message;
     (0, assert_1.strict)(resp.role === "assistant");
     (0, assert_1.strict)(typeof resp.content === "string", "expected string content from compression agent");
     return resp.content;

package/dist/agent/src/agent/dummyLLM.js

@@ -57,9 +57,7 @@ class DummyLLM {
         }
         if (onMessage) {
             const message = response.message;
-            if (message.content) {
-                void onMessage(message.content, true);
-            }
+            void onMessage(message.content || "", true);
         }
         return {
             id: String(this.idx),

package/dist/agent/src/agent/imageGenLLM.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageGenLLM = exports.DEFAULT_IMAGE_GEN_MODEL = void 0;
+const openai_1 = require("openai");
+const assert_1 = require("assert");
+const fs_1 = require("fs");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const llm_1 = require("./llm");
+const logger = (0, sdk_1.getLogger)();
+exports.DEFAULT_IMAGE_GEN_MODEL = "google/gemini-2.5-flash-image-preview";
+class ImageGenLLM {
+    constructor(apiKey, apiUrl, model) {
+        logger.debug(`here`);
+        this.openai = new openai_1.OpenAI({
+            apiKey,
+            baseURL: apiUrl,
+            dangerouslyAllowBrowser: true,
+            defaultHeaders: llm_1.XALIA_APP_HEADER,
+        });
+        this.model = model || exports.DEFAULT_IMAGE_GEN_MODEL;
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    getModel() {
+        return this.model;
+    }
+    getUrl() {
+        return this.openai.baseURL;
+    }
+    async getConversationResponse(messages, tools, onMessage) {
+        (0, assert_1.strict)(!tools || tools.length === 0, "tools not supported in ImageGenLLM");
+        // Designed for image generation using openrouter, which tweaks the Create
+        const params = {
+            model: this.model,
+            messages,
+            tools,
+            modalities: ["image", "text"],
+        };
+        logger.info(`[ImageGenLLM] params; ${JSON.stringify(params)}`);
+        const completion = (await this.openai.chat.completions.create(params));
+        // const completion = {} as unknown as ChatCompletion;
+        const filePath = "./completion.json";
+        logger.info(`[ImageGenLLM] writing ${filePath}`);
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(completion), "utf-8");
+        logger.info(`[ImageGenLLM] written`);
+        // logger.debug(
+        //   `[ImageGenLLM.getConversationResponse] completion:
+        //   ${JSON.stringify(completion)}`
+        // );
+        if (onMessage) {
+            const message = completion.choices[0].message;
+            if (message.content) {
+                await onMessage(message.content, true);
+            }
+            if (message.images) {
+                message.images.forEach((image, index) => {
+                    const imageUrl = image.image_url.url; // Base64 data URL
+                    const truncated = imageUrl.substring(0, 50);
+                    logger.info(`[ImageGenLLM] ${String(index + 1)}: ${truncated}...`);
+                });
+            }
+        }
+        return completion;
+    }
+}
+exports.ImageGenLLM = ImageGenLLM;

package/dist/agent/src/agent/imageGenerator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageGenerator = void 0;
+const agent_1 = require("./agent");
+const agentUtils_1 = require("./agentUtils");
+const context_1 = require("./context");
+const nullAgentEventHandler_1 = require("./nullAgentEventHandler");
+const nullPlatform_1 = require("./nullPlatform");
+const nodePlatform_1 = require("../tool/nodePlatform");
+const imageGenLLM_1 = require("./imageGenLLM");
+const IMAGE_GEN_SYSTEM_PROMPT = "You are an image generator";
+class ImageGenerator {
+    constructor(agent, contextManager) {
+        this.agent = agent;
+        this.contextManager = contextManager;
+    }
+    static async init(llmUrl, llmApiKey, model) {
+        const development = !!process.env.DEVELOPMENT;
+        const llm = await (0, agentUtils_1.createLLM)(llmUrl, llmApiKey, model || imageGenLLM_1.DEFAULT_IMAGE_GEN_MODEL, false /* stream */, development ? nodePlatform_1.NODE_PLATFORM : nullPlatform_1.NULL_PLATFORM // allow file loading
+        );
+        const contextManager = new context_1.ContextManager(IMAGE_GEN_SYSTEM_PROMPT, []);
+        const agent = agent_1.Agent.initializeWithLLM(nullAgentEventHandler_1.NULL_AGENT_EVENT_HANDLER, llm, contextManager);
+        return new ImageGenerator(agent, contextManager);
+    }
+    async generate(prompt, image) {
+        const userMessage = (0, agent_1.createUserMessage)(prompt, image);
+        if (!userMessage) {
+            throw new Error("invalid user message / input image");
+        }
+        const agentResponse = await this.agent.userMessageRaw(userMessage);
+        if (!agentResponse) {
+            throw new Error("invalid response from image gen agent");
+        }
+        if (!agentResponse.images || agentResponse.images.length === 0) {
+            throw new Error("invalid response from image gen agent");
+        }
+        // Clear the context
+        while (this.contextManager.popMessage())
+            ;
+        return agentResponse.images[0].image_url.url;
+    }
+}
+exports.ImageGenerator = ImageGenerator;

package/dist/agent/src/agent/llm.js

@@ -1,2 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.XALIA_APP_HEADER = void 0;
+exports.choiceDeltaExtractReasoning = choiceDeltaExtractReasoning;
+exports.XALIA_APP_HEADER = {
+    "HTTP-Referer": "xalia.ai",
+    "X-Title": "Xalia",
+};
+function choiceDeltaExtractReasoning(delta) {
+    if (delta.reasoning) {
+        return delta.reasoning;
+    }
+    if (delta.reasoning_details) {
+        let reasoning = "";
+        for (const details of delta.reasoning_details) {
+            if (details.type !== "reasoning.text") {
+                throw new Error(`unexpected details.type: ${details.type}`);
+            }
+            if (details.text) {
+                if (typeof details.text !== "string") {
+                    throw new Error(`unexpected typeof details.text: ${typeof details.text}`);
+                }
+                reasoning += details.text;
+            }
+        }
+        return reasoning;
+    }
+    return undefined;
+}

package/dist/agent/src/agent/mcpServerManager.js

@@ -203,11 +203,7 @@ class McpServerManager {
         }
         return this.enabledOpenAITools;
     }
-    /**
-     * Note the `qualifiedToolName` is the full `{mcpServerName}/{toolName}` as
-     * in the openai spec.
-     */
-    async invoke(qualifiedToolName, args) {
+    verifyToolCall(qualifiedToolName, args) {
         const [mcpServerName, toolName] = splitQualifiedName(qualifiedToolName);
         logger.debug(`invoke: qualified: ${qualifiedToolName}`);
         logger.debug(`invoke: mcpServerName: ${mcpServerName}, toolName: ${toolName}`);
@@ -217,7 +213,23 @@ class McpServerManager {
         if (!cb) {
             throw new Error(`Unknown tool ${qualifiedToolName}`);
         }
-        return cb(JSON.stringify(args));
+        return {
+            mcpServerName,
+            toolName,
+            args,
+        };
+    }
+    /**
+     * Note the `qualifiedToolName` is the full `{mcpServerName}/{toolName}` as
+     * in the openai spec.
+     */
+    async invoke(toolCall) {
+        const server = this.getMcpServerInternal(toolCall.mcpServerName);
+        const cb = server.getCallback(toolCall.toolName);
+        if (!cb) {
+            throw new Error(`Unknown tool ${toolCall.toolName}`);
+        }
+        return cb(JSON.stringify(toolCall.args));
     }
     /**
      * "Settings" refers to the set of added servers and enabled tools.

package/dist/agent/src/agent/nullAgentEventHandler.js

@@ -7,12 +7,18 @@ exports.NULL_AGENT_EVENT_HANDLER = void 0;
  */
 exports.NULL_AGENT_EVENT_HANDLER = {
     onCompletion: () => { },
+    onImage: () => { },
     onToolCallResult: () => { },
     onAgentMessage: () => {
         return new Promise((r) => {
             r();
         });
     },
+    onReasoning: () => {
+        return new Promise((r) => {
+            r();
+        });
+    },
     onToolCall: () => {
         return new Promise((r) => {
             r(false);

package/dist/agent/src/agent/openAILLM.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAILLM = void 0;
-const agentUtils_1 = require("./agentUtils");
+const llm_1 = require("./llm");
 const openai_1 = require("openai");
 class OpenAILLM {
     constructor(apiKey, apiUrl, model) {
@@ -9,9 +9,9 @@ class OpenAILLM {
             apiKey,
             baseURL: apiUrl,
             dangerouslyAllowBrowser: true,
-            defaultHeaders: agentUtils_1.XALIA_APP_HEADER,
+            defaultHeaders: llm_1.XALIA_APP_HEADER,
         });
-        this.model = model || agentUtils_1.DEFAULT_LLM_MODEL;
+        this.model = model;
     }
     setModel(model) {
         this.model = model;