@xalia/agent 0.6.1 → 0.6.2

package/src/test/dbSessionFiles.test.ts

@@ -0,0 +1,258 @@
+import { expect } from "chai";
+
+import { Database } from "../chat/data/database";
+import { DbSessionFiles } from "../chat/data/dbSessionFiles";
+import {
+  SessionFileDescriptor,
+  SessionFileEntry,
+} from "../chat/data/dbSessionFileModels";
+import {
+  TestUserSpec,
+  cleanupTestUser,
+  createTestSession,
+  getLocalDB,
+  testUserSpec,
+} from "./dbTestTools";
+import { getMimeTypeFromDataUrl } from "../chat/data/mimeTypes";
+
+const TEST_FILES_A: SessionFileEntry[] = [
+  {
+    name: "file_1",
+    summary: "Some PDF",
+    mime_type: "application/pdf",
+    data_url: "data:application/pdf;base64,AAAA",
+  },
+  {
+    name: "file_2",
+    summary: "Some PNG",
+    mime_type: "image/png",
+    data_url: "data:image/png;base64,BBBB",
+  },
+];
+
+const TEST_FILE_A_1_ALT: SessionFileEntry = {
+  ...TEST_FILES_A[0],
+  summary: "Some other PDF",
+  data_url: "data:application/pdf;base64,CCCC",
+};
+
+const TEST_FILE_A_3_NEW: SessionFileEntry = {
+  name: "file_3",
+  summary: "Some markdown",
+  mime_type: "text/markdown",
+  data_url: "data:text/markdown,# TITLE\n## SUBSECTION\nA parapgraph\n",
+};
+
+const TEST_FILES_B: SessionFileEntry[] = [
+  {
+    name: "file_1",
+    summary: "Some other PDF",
+    mime_type: "application/pdf",
+    data_url: "data:application/pdf;base64,DDD",
+  },
+];
+
+function entryToDescriptor(entry: SessionFileEntry): SessionFileDescriptor {
+  return {
+    name: entry.name,
+    summary: entry.summary,
+    mime_type: entry.mime_type,
+  };
+}
+
+// async function cleanup(
+//   db: Database,
+//   user1: TestUserSpec
+//   // user2: TestUser
+// ): Promise<void> {
+//   await cleanupTestUser(db, user1);
+//   // await cleanupTestUser(db, user2.uuid, user2.api_key);
+// }
+
+async function setup(
+  db: Database,
+  user1: TestUserSpec
+): Promise<{
+  sf: DbSessionFiles;
+  session_id_A: string;
+  session_id_B: string;
+}> {
+  const { agentProfileId, sessionId: session_id_A } = await createTestSession(
+    db,
+    user1
+  );
+
+  const session_id_B = Database.sessionNewUUID();
+  await db.sessionCreate({
+    session_uuid: session_id_B,
+    user_uuid: user1.uuid,
+    title: "test_session_2",
+    agent_profile_uuid: agentProfileId,
+    agent_paused: false,
+  });
+
+  const sf = db.createTypedClient(DbSessionFiles);
+
+  await Promise.all(
+    TEST_FILES_A.map((tf) =>
+      sf.setFileContent(session_id_A, tf.name, tf.summary, tf.data_url)
+    )
+  );
+  await Promise.all(
+    TEST_FILES_B.map((tf) =>
+      sf.setFileContent(session_id_B, tf.name, tf.summary, tf.data_url)
+    )
+  );
+
+  return { sf, session_id_A, session_id_B };
+}
+
+function expectArraysEqual<T extends { name: string }>(a: T[], b: T[]): void {
+  const sortByName = (a: { name: string }, b: { name: string }) =>
+    a.name.localeCompare(b.name);
+  expect(a.sort(sortByName)).eql(b.sort(sortByName));
+}
+
+describe("DB Session Files", () => {
+  let db: Database;
+  let user: TestUserSpec;
+
+  beforeEach(() => {
+    db = getLocalDB();
+    user = testUserSpec();
+  });
+
+  afterEach(async () => {
+    await cleanupTestUser(db, user);
+  });
+
+  it("extract mime type from data url", function () {
+    const mimeTypeA = getMimeTypeFromDataUrl("data:image/png;base64,AAAAA");
+    const mimeTypeB = getMimeTypeFromDataUrl("data:text/markdown,# TITLE ...");
+
+    expect(mimeTypeA).eql("image/png");
+    expect(mimeTypeB).eql("text/markdown");
+  });
+
+  it("listing entries and getting data", async function () {
+    const { sf, session_id_A, session_id_B } = await setup(db, user);
+
+    const [list_A, list_B] = await Promise.all([
+      sf.getFilesForSession(session_id_A),
+      sf.getFilesForSession(session_id_B),
+    ]);
+    const [content_A_1, content_A_2, content_B_1] = await Promise.all([
+      sf.getFileContent(session_id_A, TEST_FILES_A[0].name),
+      sf.getFileContent(session_id_A, TEST_FILES_A[1].name),
+      sf.getFileContent(session_id_B, TEST_FILES_B[0].name),
+    ]);
+
+    expectArraysEqual(list_A, TEST_FILES_A.map(entryToDescriptor));
+    expectArraysEqual(list_B, TEST_FILES_B.map(entryToDescriptor));
+    expect(content_A_1).eql(TEST_FILES_A[0].data_url);
+    expect(content_A_2).eql(TEST_FILES_A[1].data_url);
+    expect(content_B_1).eql(TEST_FILES_B[0].data_url);
+  });
+
+  it("deleting files", async function () {
+    const { sf, session_id_A, session_id_B } = await setup(db, user);
+
+    const [list_A_2, list_B_2] = await Promise.all([
+      sf.getFilesForSession(session_id_A),
+      sf.getFilesForSession(session_id_B),
+    ]);
+
+    // Should do nothing
+    await sf.deleteFile(session_id_B, TEST_FILES_A[1].name);
+
+    const [list_A_0, list_B_0] = await Promise.all([
+      sf.getFilesForSession(session_id_A),
+      sf.getFilesForSession(session_id_B),
+    ]);
+
+    // Should delete a file
+    await sf.deleteFile(session_id_A, TEST_FILES_A[0].name);
+
+    const [list_A_1, list_B_1] = await Promise.all([
+      sf.getFilesForSession(session_id_A),
+      sf.getFilesForSession(session_id_B),
+    ]);
+
+    expectArraysEqual(list_A_2, TEST_FILES_A.map(entryToDescriptor));
+    expectArraysEqual(list_B_2, TEST_FILES_B.map(entryToDescriptor));
+    expectArraysEqual(list_A_0, TEST_FILES_A.map(entryToDescriptor));
+    expectArraysEqual(list_B_0, TEST_FILES_B.map(entryToDescriptor));
+    expectArraysEqual(list_A_1, TEST_FILES_A.slice(1).map(entryToDescriptor));
+    expectArraysEqual(list_B_1, TEST_FILES_B.map(entryToDescriptor));
+  });
+
+  it("deleting all", async function () {
+    const { sf, session_id_A, session_id_B } = await setup(db, user);
+
+    await sf.clearFiles(session_id_A);
+
+    const [list_A, list_B] = await Promise.all([
+      sf.getFilesForSession(session_id_A),
+      sf.getFilesForSession(session_id_B),
+    ]);
+    expectArraysEqual(list_A, []);
+    expectArraysEqual(list_B, TEST_FILES_B.map(entryToDescriptor));
+  });
+
+  it("file updates", async function () {
+    const { sf, session_id_A, session_id_B } = await setup(db, user);
+
+    await sf.setFileContent(
+      session_id_A,
+      TEST_FILE_A_1_ALT.name,
+      TEST_FILE_A_1_ALT.summary,
+      TEST_FILE_A_1_ALT.data_url
+    );
+
+    const expectFiles_A = [TEST_FILE_A_1_ALT, TEST_FILES_A[1]];
+
+    const list_A = await sf.getFilesForSession(session_id_A);
+    const list_B = await sf.getFilesForSession(session_id_B);
+    const [content_A_1, content_A_2, content_B_1] = await Promise.all([
+      sf.getFileContent(session_id_A, TEST_FILES_A[0].name),
+      sf.getFileContent(session_id_A, TEST_FILES_A[1].name),
+      sf.getFileContent(session_id_B, TEST_FILES_B[0].name),
+    ]);
+
+    expectArraysEqual(list_A, expectFiles_A.map(entryToDescriptor));
+    expectArraysEqual(list_B, TEST_FILES_B.map(entryToDescriptor));
+    expect(content_A_1).eql(TEST_FILE_A_1_ALT.data_url);
+    expect(content_A_2).eql(TEST_FILES_A[1].data_url);
+    expect(content_B_1).eql(TEST_FILES_B[0].data_url);
+  });
+
+  it("adding new files", async function () {
+    const { sf, session_id_A, session_id_B } = await setup(db, user);
+
+    await sf.setFileContent(
+      session_id_A,
+      TEST_FILE_A_3_NEW.name,
+      TEST_FILE_A_3_NEW.summary,
+      TEST_FILE_A_3_NEW.data_url
+    );
+
+    const list_A = await sf.getFilesForSession(session_id_A);
+    const list_B = await sf.getFilesForSession(session_id_B);
+    const [content_A_1, content_A_2, content_A_3, content_B_1] =
+      await Promise.all([
+        sf.getFileContent(session_id_A, TEST_FILES_A[0].name),
+        sf.getFileContent(session_id_A, TEST_FILES_A[1].name),
+        sf.getFileContent(session_id_A, TEST_FILE_A_3_NEW.name),
+        sf.getFileContent(session_id_B, TEST_FILES_B[0].name),
+      ]);
+
+    const expectFiles_A = [...TEST_FILES_A, TEST_FILE_A_3_NEW];
+
+    expectArraysEqual(list_A, expectFiles_A.map(entryToDescriptor));
+    expectArraysEqual(list_B, TEST_FILES_B.map(entryToDescriptor));
+    expect(content_A_1).eql(TEST_FILES_A[0].data_url);
+    expect(content_A_2).eql(TEST_FILES_A[1].data_url);
+    expect(content_A_3).eql(TEST_FILE_A_3_NEW.data_url);
+    expect(content_B_1).eql(TEST_FILES_B[0].data_url);
+  });
+});

package/src/test/dbSessionMessages.test.ts

@@ -0,0 +1,85 @@
+import { expect, beforeEach, afterEach, describe, it } from "vitest";
+import { Database } from "../chat/data/database";
+import { SessionMessage } from "../chat/data/dataModels";
+import { ChatCompletionMessageParam } from "../agent/llm";
+import {
+  TestUserSpec,
+  cleanupTestUser,
+  createTestSession,
+  getLocalDB,
+  testUserSpec,
+} from "./dbTestTools";
+import { DbSessionMessages } from "../chat/data/dbSessionMessages";
+
+describe("DB Session Messages", () => {
+  let db: Database;
+  let dbsm: DbSessionMessages;
+  let testUsers: TestUserSpec[];
+
+  beforeEach(() => {
+    // Generate unique test data for each test
+    db = getLocalDB();
+    dbsm = db.createTypedClient(DbSessionMessages);
+    testUsers = [testUserSpec()];
+  });
+
+  afterEach(async () => {
+    await Promise.all(testUsers.map((tu) => cleanupTestUser(db, tu)));
+    testUsers = [];
+  });
+
+  it("should update conversations", async () => {
+    const { sessionId } = await createTestSession(db, testUsers[0]);
+
+    const CONV_0: ChatCompletionMessageParam[] = [
+      { role: "user", content: "message 0" },
+      { role: "assistant", content: "message 1" },
+    ];
+    const CONV_1: ChatCompletionMessageParam[] = [
+      { role: "user", content: "message 2" },
+      { role: "assistant", content: "message 3" },
+    ];
+
+    const MESSGES_0: SessionMessage[] = [
+      {
+        message_idx: 0,
+        sender_uuid: testUsers[0].uuid,
+        is_for_llm: true,
+        content: CONV_0[0],
+      },
+      { message_idx: 1, is_for_llm: true, content: CONV_0[1] },
+    ];
+    const MESSGES_1: SessionMessage[] = [
+      {
+        message_idx: 2,
+        sender_uuid: testUsers[0].uuid,
+        is_for_llm: true,
+        content: CONV_1[0],
+      },
+      { message_idx: 3, is_for_llm: true, content: CONV_1[1] },
+    ];
+
+    // Append messages to empty conversation
+    await dbsm.append(sessionId, MESSGES_0);
+    const msgs0 = await dbsm.getConversation(sessionId, 10);
+    expect(msgs0).eql(MESSGES_0);
+
+    // Append further messages
+    await dbsm.append(sessionId, MESSGES_1);
+    const msgs1 = await dbsm.getConversation(sessionId, 10);
+    expect(msgs1).eql(MESSGES_0.concat(MESSGES_1));
+
+    // Partial conversation (most recent 2)
+    const msgs2 = await dbsm.getConversation(sessionId, 2);
+    expect(msgs2).eql(MESSGES_1);
+
+    // Partial conversation (next 2, start at 2)
+    const msgs3 = await dbsm.getConversation(sessionId, 2, 2);
+    expect(msgs3).eql(MESSGES_0);
+
+    // Delete messages and check conv is empty
+    await dbsm.clearConversation(sessionId);
+    const msgs4 = await dbsm.getConversation(sessionId, 10);
+    expect(msgs4).eql([]);
+  });
+});

package/src/test/dbTestTools.ts

@@ -78,7 +78,7 @@ export async function cleanupTestUser(
   // api_key: string
 ): Promise<void> {
   try {
-    await db.getClientForTesting().from("users").delete().eq("uuid", user.uuid);
+    await db.deleteUser(user.uuid);
   } catch (_error) {
     // Ignore cleanup errors
   }
@@ -107,6 +107,7 @@ export async function createTestSession(
     user_uuid: user1.uuid,
     title: "test_session",
     agent_profile_uuid: agentProfile.uuid,
+    agent_paused: false,
   });
   assert(sessionId);
 
@@ -122,11 +123,13 @@ export async function createTestTeamSession(
   sessionId: string;
   teamId: string;
 }> {
-  const [user1, _] = await Promise.all([
-    createTestUser(db, testUsers[0]),
-    createTestUser(db, testUsers[1]),
-  ]);
+  assert(testUsers.length > 0);
 
+  const [user1, _] = await Promise.all(
+    testUsers.map((tu) => createTestUser(db, tu))
+  );
+
+  // Profile for first user
   const agentProfile = await db.createAgentProfile(
     user1.uuid,
     undefined,
@@ -146,6 +149,7 @@ export async function createTestTeamSession(
     user_uuid: user1.uuid,
     title: "test_session",
     agent_profile_uuid: agentProfile.uuid,
+    agent_paused: false,
   });
   assert(sessionId);
 

package/src/test/imageLoad.test.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/require-await */
 import { describe, it, expect } from "vitest";
-import { loadImageB64OrUndefined } from "../tool/files";
+import { loadImageAsDataUrlOrUndefined } from "../tool/files";
 import { strict as assert } from "assert";
 
 describe("Image loading", () => {
   it("convert to data url", async () => {
-    const imageB64 = loadImageB64OrUndefined("test_data/frog.png");
+    const imageB64 = loadImageAsDataUrlOrUndefined("test_data/frog.png");
     console.log(`imageB64: ${imageB64 || ""}`);
 
     expect(imageB64).toBeTypeOf("string");

package/src/test/mcpServerManager.test.ts

@@ -56,7 +56,9 @@ describe("McpServerManager", () => {
     // Invoke
     {
       const qualifiedName = tm.getOpenAITools()[0].function.name;
-      const r = await tm.invoke(qualifiedName, { a: 1000, b: 10 });
+      const r = await tm.invoke(
+        tm.verifyToolCall(qualifiedName, { a: 1000, b: 10 })
+      );
       console.log(`response: ${r}`);
     }
 

package/src/test/multiAsyncQueue.test.ts

@@ -122,4 +122,62 @@ describe("MultiAsyncQueue", () => {
     expect(processedBatches).toHaveLength(2);
     expect(processedBatches[1]).toEqual([2]);
   });
+
+  it("should not process elements while paused", async () => {
+    // Place a 1 on the queue. Inside the process fn, place a 2 and 3 on the
+    // queue.  Next invocation of process should see BOTH 2 AND 3.
+
+    const context = { q: undefined as MultiAsyncQueue<number> | undefined };
+    const seen: number[] = [];
+    let paused: number = 0;
+    const process = (elements: number[]): Promise<void> => {
+      console.log(`elements: ${JSON.stringify(elements)}`);
+      expect(context.q).toBeDefined();
+
+      for (const e of elements) {
+        seen.push(e);
+      }
+      if (seen.length === 1) {
+        context.q?.pause(); // Pause after first element
+        paused++;
+        expect(context.q?.tryEnqueue(2)).toBe(true);
+        expect(context.q?.tryEnqueue(3)).toBe(true);
+      } else if (seen.length === 3) {
+        expect(seen[1]).toBe(2);
+        expect(seen[2]).toBe(3);
+      } else {
+        throw new Error("unexpected elements");
+      }
+
+      return Promise.resolve();
+    };
+
+    context.q = new MultiAsyncQueue<number>(process);
+    expect(context.q).toBeDefined();
+    expect(context.q.tryEnqueue(1)).toBe(true);
+
+    await new Promise<void>((r) => {
+      setTimeout(() => {
+        expect(seen).toEqual([1]);
+        r();
+      }, 100);
+    });
+
+    expect(context.q).toBeDefined();
+    expect(seen).toEqual([1]);
+    expect(paused).toEqual(1);
+
+    context.q.unpause();
+
+    await new Promise<void>((r) => {
+      setTimeout(() => {
+        expect(seen).toEqual([1, 2, 3]);
+        r();
+      }, 100);
+    });
+
+    expect(context.q).toBeDefined();
+    expect(seen).toEqual([1, 2, 3]);
+    expect(paused).toEqual(1);
+  });
 });

package/src/test/testTools.ts

@@ -5,7 +5,7 @@ import {
   ChatCompletionMessageParam,
   ChatCompletionMessageToolCall,
   ChatCompletionToolMessageParam,
-} from "../agent/agent";
+} from "../agent/llm";
 import { IAgentEventHandler } from "../agent/iAgentEventHandler";
 import { IPlatform } from "../agent/iplatform";
 import { DummyLLM } from "../agent/dummyLLM";
@@ -29,7 +29,9 @@ export const DUMMY_PLATFORM: IPlatform = {
 export class TestAgentEventHandler implements IAgentEventHandler {
   private all: ChatCompletionMessageParam[] = [];
   private completions: ChatCompletionAssistantMessageParam[] = [];
+  private images: OpenAI.Chat.Completions.ChatCompletionContentPartImage[] = [];
   private agentMessages: string[] = [""];
+  private reasoning: string[] = [""];
   private toolCalls: ChatCompletionMessageToolCall[] = [];
   private agentToolCalls: ChatCompletionMessageToolCall[] = [];
   private toolCallResults: OpenAI.ChatCompletionToolMessageParam[] = [];
@@ -39,6 +41,10 @@ export class TestAgentEventHandler implements IAgentEventHandler {
     this.all.push(result);
   }
 
+  onImage(image: OpenAI.Chat.Completions.ChatCompletionContentPartImage) {
+    this.images.push(image);
+  }
+
   onToolCallResult(result: ChatCompletionToolMessageParam): void {
     this.toolCallResults.push(result);
     this.all.push(result);
@@ -48,12 +54,20 @@ export class TestAgentEventHandler implements IAgentEventHandler {
     this.agentMessages[this.agentMessages.length - 1] += chunk;
     if (isEnd) {
       this.agentMessages.push("");
+      this.reasoning.push("");
     }
     return new Promise<void>((r) => {
       r();
     });
   }
 
+  onReasoning(reasoning: string): Promise<void> {
+    this.reasoning[this.reasoning.length - 1] += reasoning;
+    return new Promise<void>((r) => {
+      r();
+    });
+  }
+
   onToolCall(
     toolCall: ChatCompletionMessageToolCall,
     isAgentTool: boolean

package/src/tool/agentChat.ts

@@ -10,14 +10,18 @@ import { AgentProfile } from "../agent/agent";
 import { createAgentWithSkills } from "../agent/agentUtils";
 import { IAgentEventHandler } from "../agent/iAgentEventHandler";
 
-import { loadImageB64OrUndefined } from "./files";
+import { loadImageAsDataUrlOrUndefined } from "./files";
 import { NODE_PLATFORM } from "./nodePlatform";
 import { CommandPrompt } from "./commandPrompt";
 import { IPrompt, Prompt } from "./prompt";
 import { ContextManager } from "../agent/context";
+import { ChatCompletionMessageParam } from "../agent/llm";
 
 const logger = getLogger();
 
+export const DEFAULT_AGENT_LLM_MODEL =
+  process.env["DEFAULT_LLM_MODEL"] || "anthropic/claude-sonnet-4.5";
+
 async function write(msg: string): Promise<void> {
   return new Promise((resolve, err) => {
     process.stdout.write(msg, (e) => {
@@ -33,7 +37,7 @@ async function write(msg: string): Promise<void> {
 export async function runChat(
   llmUrl: string,
   agentProfile: AgentProfile,
-  conversation: OpenAI.ChatCompletionMessageParam[] | undefined,
+  conversation: ChatCompletionMessageParam[] | undefined,
   prompt: string | undefined,
   image: string | undefined,
   llmApiKey: string | undefined,
@@ -46,15 +50,18 @@ export async function runChat(
 
   const spinner: Spinner = yocto();
   let first = true;
+  let reasoningFirst = true;
 
   const onAgentMessage = async (msg: string, msgEnd: boolean) => {
     if (first) {
       first = false;
-      await write("AGENT: ");
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (spinner) {
-        spinner.stop().clear();
+
+      if (!reasoningFirst) {
+        await write(`${chalk.grey("]")}\n`);
       }
+
+      await write("AGENT: ");
+      spinner.stop().clear();
     }
 
     if (msg) {
@@ -64,9 +71,20 @@ export async function runChat(
     if (msgEnd) {
       await write("\n");
       first = true;
+      reasoningFirst = true;
     }
   };
 
+  const onReasoning = async (reasoning: string) => {
+    logger.debug(`[AgentChat.onReasoning]: ${reasoning}`);
+    if (reasoningFirst) {
+      spinner.stop().clear();
+      await write(chalk.grey("[REASONING: "));
+      reasoningFirst = false;
+    }
+    await write(chalk.grey(reasoning));
+  };
+
   const repl: IPrompt = new Prompt();
   const cmdPrompt = new CommandPrompt(repl);
 
@@ -88,10 +106,19 @@ export async function runChat(
     logger.debug(`Tool call result: ${JSON.stringify(result)}`);
   };
 
+  const onImage = (
+    image: OpenAI.Chat.Completions.ChatCompletionContentPartImage
+  ) => {
+    const dataUrl = image.image_url.url;
+    void NODE_PLATFORM.renderHTML(`<img src="${dataUrl}" />`);
+  };
+
   // Create event handler for CLI agent
   const eventHandler: IAgentEventHandler = {
     onCompletion: () => {},
+    onImage,
     onAgentMessage,
+    onReasoning,
     onToolCall,
     onToolCallResult,
   };
@@ -101,6 +128,7 @@ export async function runChat(
   const [agent, sudoMcpServerManager] = await createAgentWithSkills(
     llmUrl,
     agentProfile,
+    DEFAULT_AGENT_LLM_MODEL,
     eventHandler,
     NODE_PLATFORM,
     new ContextManager(agentProfile.system_prompt, conversation || []),
@@ -136,7 +164,7 @@ export async function runChat(
       image = img;
     }
 
-    image = loadImageB64OrUndefined(image);
+    image = loadImageAsDataUrlOrUndefined(image);
 
     // Pass the prompt and image to the Agent
     try {

package/src/tool/agentMain.ts

@@ -1,7 +1,6 @@
 import * as fs from "fs";
 import * as dotenv from "dotenv";
 import { command, option, flag, optional, string } from "cmd-ts";
-import OpenAI from "openai";
 import { strict as assert } from "assert";
 
 import { configuration, utils } from "@xalia/xmcp/tool";
@@ -22,10 +21,11 @@ import {
 import {
   loadFileOrUndefined,
   loadFileOrStdin,
-  loadImageB64OrUndefined,
+  loadImageAsDataUrlOrUndefined,
 } from "./files";
-import { runChat } from "./agentChat";
+import { DEFAULT_AGENT_LLM_MODEL, runChat } from "./agentChat";
 import { NODE_PLATFORM } from "./nodePlatform";
+import { ChatCompletionMessageParam } from "../agent/llm";
 
 dotenv.config();
 
@@ -128,9 +128,8 @@ export const agentMain = command({
 
     // Restore conversation from value or file.
 
-    const startingConversation:
-      | OpenAI.ChatCompletionMessageParam[]
-      | undefined = utils.loadContentOrFileOrUndefined(conversationFile);
+    const startingConversation: ChatCompletionMessageParam[] | undefined =
+      utils.loadContentOrFileOrUndefined(conversationFile);
     logger.debug(
       `startingConversation: ${JSON.stringify(startingConversation)}`
     );
@@ -146,10 +145,11 @@ export const agentMain = command({
       const { response, conversation } = await runOneShot(
         llmUrl,
         agentProfile,
+        DEFAULT_AGENT_LLM_MODEL,
         startingConversation,
         NODE_PLATFORM,
         prompt,
-        loadImageB64OrUndefined(imageFile),
+        loadImageAsDataUrlOrUndefined(imageFile),
         llmApiKey,
         sudomcpConfig,
         approveToolsUpTo