@xalia/agent 0.6.9 → 0.6.11

package/src/chat/server/conversation.ts

@@ -1,316 +0,0 @@
-/// Abstraction of LLM messages (suitable for passing conversations to the
-/// LLM) and SessionMessage (saved in the DB)
-
-import { strict as assert } from "assert";
-
-import { createUserMessage } from "../../agent/agent";
-import {
-  AssistantMessageParam,
-  MessageParam,
-  ToolMessageParam,
-  UserMessageParam,
-} from "../../agent/llm";
-import { SessionMessage, UserMessageData } from "../data/dataModels";
-import {
-  ServerAgentMessage,
-  ServerToolCallResult,
-  ServerUserMessage,
-} from "../protocol/messages";
-import { ChatErrorMessage } from "../protocol/errors";
-
-export const MESSAGE_INDEX_START_VALUE = 0;
-export const MESSAGE_INDEX_FULL_INCREMENT = 100;
-export const MESSAGE_INDEX_SUB_INCREMENT = 1;
-
-//     MESSAGE_INDEX_START_VALUE = N * MESSAGE_INDEX_FULL_INCREMENT
-// <=> MESSAGE_INDEX_START_VALUE =
-//                floor(MESSAGE_INDEX_START_VALUE/MESSAGE_INDEX_FULL_INCREMENT)
-//                * MESSAGE_INDEX_FULL_INCREMENT
-assert(
-  MESSAGE_INDEX_START_VALUE ===
-    ((MESSAGE_INDEX_START_VALUE / MESSAGE_INDEX_FULL_INCREMENT) | 0) *
-      MESSAGE_INDEX_FULL_INCREMENT
-);
-
-export type ConversationMessage =
-  | ServerUserMessage
-  | ServerAgentMessage
-  | ServerToolCallResult;
-
-/**
- * Compute the next message index to assign.  Note, this is non-trivial since
- * we use a 'BIGINT with gaps' strategy to ensure that multi-part agent
- * messages can be inserted into the conversation.
- */
-export function sessionMessagesToNextIndex(
-  sessionMessages: SessionMessage[]
-): number {
-  const numMessages = sessionMessages.length;
-  if (numMessages === 0) {
-    return MESSAGE_INDEX_START_VALUE;
-  }
-
-  const lastIdx = sessionMessages[numMessages - 1].message_idx;
-
-  // We must compute lastIdx + 1 rounded up to the nearest
-  // MESSAGE_INDEX_FULL_INCREMENT
-  const numFullIncrements =
-    (lastIdx + MESSAGE_INDEX_FULL_INCREMENT) / MESSAGE_INDEX_FULL_INCREMENT;
-  const floorNumFullIncrements = numFullIncrements | 0;
-  return floorNumFullIncrements * MESSAGE_INDEX_FULL_INCREMENT;
-}
-
-/**
- * The conversation history may be truncated.  In this case, discard any
- * messages which do not make sense (e.g. leading Agent messages).  Inform the
- * caller of the first messages to be included in the conversation, so it can
- * request messages further back in history if required.
- */
-export function sessionMessagesToLLMConversation(
-  sessionMessages: SessionMessage[]
-): { firstIndex: number; conversation: MessageParam[] } {
-  const conversation = [];
-  let started = false;
-  let firstIndex: number = -1;
-
-  for (const msg of sessionMessages) {
-    if (!msg.is_for_llm) {
-      continue;
-    }
-
-    const llmMsg = msg.content;
-
-    // Skip leading messages which are not the users.  Record the index of the
-    // first message we actually use.
-
-    if (!started) {
-      if (llmMsg.role !== "user") {
-        continue;
-      }
-
-      started = true;
-      firstIndex = msg.message_idx;
-    }
-
-    conversation.push(llmMsg);
-  }
-
-  return { firstIndex, conversation };
-}
-
-/**
- * Convert the DB data (SessionMessage) for a ChatCompletionUserMessageParam
- * into a ServerUserMessage message.
- */
-export function userMessageToConversationMessage(
-  userMessage: UserMessageParam,
-  user_uuid: string,
-  message_idx: number,
-  session_id: string
-): ServerUserMessage {
-  // The name on the message should be the uuid
-
-  const userMsgData = llmUserMessageToUserMessageData(userMessage);
-  const user_nickname = userMessage.name;
-  assert(
-    user_nickname,
-    `ChatCompletionUserMessageParam without user ${JSON.stringify(userMessage)}`
-  );
-  const msg: ServerUserMessage = {
-    type: "user_msg",
-    message: userMsgData.message,
-    message_idx,
-    user_uuid,
-    user_nickname,
-    session_id,
-  };
-  if (userMsgData.imageB64) {
-    msg.imageB64 = userMsgData.imageB64;
-  }
-  return msg;
-}
-
-/**
- * Convert the DB data (SessionMessage) for a
- * ChatCompletionAssistantMessageParam into a ServerAgentMessage message.
- */
-export function assistantMessageToConversationMessage(
-  msg: AssistantMessageParam,
-  message_idx: number,
-  session_id: string
-): ServerAgentMessage {
-  assert(!msg.audio);
-  return {
-    type: "agent_msg",
-    message: msg,
-    message_idx,
-    session_id,
-  };
-}
-
-/**
- * Convert the DB data (SessionMessage) for a ChatCompletionToolMessageParam
- * into a ServerToolCallResult message.
- */
-export function toolResultToConversationMessage(
-  toolCall: ToolMessageParam,
-  message_idx: number,
-  session_id: string
-): ServerToolCallResult {
-  return {
-    type: "tool_call_result",
-    result: toolCall,
-    message_idx,
-    session_id,
-  };
-}
-
-/**
- * Convert a set of SessionMessages (stored in the DB) into Conversation
- * messages (protocol which can be sent over the wire).
- */
-export function sessionMessagesToConversationMessages(
-  sessionMessages: SessionMessage[],
-  defaultUserUuid: string,
-  session_id: string
-): ConversationMessage[] {
-  const msgs: ConversationMessage[] = [];
-  for (const sm of sessionMessages) {
-    const ccmp = sm.content;
-    const message_idx = sm.message_idx;
-    const msgRole = ccmp.role;
-    switch (msgRole) {
-      case "system":
-        throw new Error("cannot convert system to ConversationMessage");
-      case "assistant":
-        msgs.push(
-          assistantMessageToConversationMessage(ccmp, message_idx, session_id)
-        );
-        break;
-      case "user":
-        {
-          const user_uuid = sm.sender_uuid || defaultUserUuid;
-          msgs.push(
-            userMessageToConversationMessage(
-              ccmp,
-              user_uuid,
-              message_idx,
-              session_id
-            )
-          );
-        }
-        break;
-      case "tool":
-        msgs.push(
-          toolResultToConversationMessage(ccmp, message_idx, session_id)
-        );
-        break;
-      default: {
-        const _: never = ccmp;
-        throw new Error(`unexpected message role: ${msgRole as string}`);
-      }
-    }
-  }
-
-  return msgs;
-}
-
-export function llmUserMessageToUserMessageData(
-  userMessage: UserMessageParam
-): UserMessageData {
-  if (typeof userMessage.content === "string") {
-    return {
-      message: userMessage.content,
-    };
-  }
-
-  let message = "";
-  let image: string | undefined = undefined;
-  for (const content of userMessage.content) {
-    switch (content.type) {
-      case "text":
-        message += content.text;
-        break;
-      case "image_url":
-        assert(!image, "only one image per message supported");
-        image = content.image_url.url;
-        break;
-      case "input_audio":
-        throw new ChatErrorMessage(
-          "llmUserMessageToUserMessageData: audio content not supported"
-        );
-      case "file":
-        throw new ChatErrorMessage(
-          "llmUserMessageToUserMessageData: file content not supported"
-        );
-      default:
-        throw new ChatErrorMessage(
-          "llmUserMessageToUserMessageData: unexpected content.type"
-        );
-    }
-  }
-
-  const finalMsg: UserMessageData = {
-    message,
-  };
-  if (image) {
-    finalMsg.imageB64 = image;
-  }
-  return finalMsg;
-}
-
-export function chatToolResultMessageToSessionMessage(
-  chatMessage: ServerToolCallResult
-): SessionMessage {
-  return {
-    message_idx: chatMessage.message_idx,
-    is_for_llm: true,
-    content: chatMessage.result,
-  };
-}
-
-export function chatUserMessageToSessionMessage(
-  chatMessage: ServerUserMessage
-): SessionMessage {
-  const userMsg = createUserMessage(
-    chatMessage.message,
-    chatMessage.imageB64,
-    chatMessage.user_uuid
-  );
-  assert(userMsg);
-  return {
-    message_idx: chatMessage.message_idx,
-    is_for_llm: true,
-    sender_uuid: chatMessage.user_uuid,
-    content: userMsg,
-  };
-}
-
-export function chatAgentMessageToSessionMessage(
-  chatMessage: ServerAgentMessage
-): SessionMessage {
-  return {
-    message_idx: chatMessage.message_idx,
-    is_for_llm: true,
-    content: chatMessage.message,
-  };
-}
-
-export function chatMessagesToSessionMessages(
-  chatMessages: ConversationMessage[]
-): SessionMessage[] {
-  return chatMessages.map((c) => {
-    switch (c.type) {
-      case "user_msg":
-        return chatUserMessageToSessionMessage(c);
-      case "agent_msg":
-        return chatAgentMessageToSessionMessage(c);
-      case "tool_call_result":
-        return chatToolResultMessageToSessionMessage(c);
-      default: {
-        const exhaustive: never = c;
-        return exhaustive;
-      }
-    }
-  });
-}

package/src/chat/server/errorUtils.ts

@@ -1,28 +0,0 @@
-/**
- * Extract error string from an unknown error.  Handles raw strings, `Error`
- * objects, DB errors and falls back to outputting as String and JSON.
- */
-export function getErrorString(err: unknown): string {
-  if (typeof err === "string") {
-    return err;
-  }
-
-  if (err instanceof Error) {
-    // Generic Error.  For now just send messages, don't close.
-    return "internal server error: " + err.message;
-  }
-
-  const dbErr = err as {
-    code: string | undefined;
-    details: string | undefined;
-  };
-  if (dbErr.code && dbErr.details) {
-    return "db error: " + dbErr.details;
-  }
-
-  return (
-    `unknown err (${typeof err}, ${String(err?.constructor?.name)}) ` +
-    JSON.stringify(err) +
-    "String(err)"
-  );
-}

package/src/chat/server/imageGeneratorTools.ts

@@ -1,160 +0,0 @@
-import { getLogger } from "@xalia/xmcp/sdk";
-
-import { AgentEx, IAgentToolProvider, ToolCallResult } from "../../agent/agent";
-import { ToolDescriptor } from "../../agent/llm";
-import { ImageGenerator } from "../../agent/imageGenerator";
-import {
-  ChatSessionFileManager,
-  ToolCallResultWithFileRef,
-} from "./sessionFileManager";
-import { makeParseArgsFn } from "./tools";
-import { getSessionFileMimeTypeFromDataUrl } from "../data/dbSessionFileModels";
-import { getOpenAIClientParams } from "./openAIRouterLLM";
-import { DEFAULT_IMAGE_GEN_MODEL, ImageGenLLM } from "../../agent/imageGenLLM";
-import { createSpecializedLLM } from "../../agent/agentUtils";
-import { IPlatform } from "../../agent/iplatform";
-
-const logger = getLogger();
-
-async function createImageGenerator(
-  platform: IPlatform
-): Promise<ImageGenerator> {
-  const imageGenModel =
-    process.env["GEN_IMAGE_MODEL"] || DEFAULT_IMAGE_GEN_MODEL;
-
-  // Allow the image generator to use a "specialized" or "debug" LLM if
-  // requested.  Otherwise query the router maps for the url and api key and
-  // instantiate an ImageGenLLM.
-
-  let llm = await createSpecializedLLM(imageGenModel, platform);
-  if (!llm) {
-    const { apiKey, baseURL } = getOpenAIClientParams(imageGenModel);
-    logger.debug(
-      `[genImageFileTool] model: ${imageGenModel}, url: ${baseURL}"}`
-    );
-    llm = new ImageGenLLM(apiKey, baseURL, imageGenModel);
-  }
-  return ImageGenerator.init(llm);
-}
-
-// gen_image
-//
-// Simple tool to generate image output as tool output.  The user can then
-// decide how/whether to use the image.
-
-export async function genImageTool(
-  platform: IPlatform
-): Promise<IAgentToolProvider> {
-  const GEN_IMAGE_DESC: ToolDescriptor = {
-    type: "function",
-    function: {
-      name: "gen_image",
-      description: "Generate image",
-      parameters: {
-        type: "object",
-        properties: {
-          prompt: {
-            type: "string",
-            description: "Prompt/instructions for image generator",
-          },
-          input_img: {
-            type: "string",
-            description: "(Optional) input image data",
-          },
-        },
-        required: ["prompt"],
-      },
-    },
-  } as const;
-  const imageGenerator = await createImageGenerator(platform);
-  const getPromptInputImg = makeParseArgsFn(
-    ["prompt"] as const,
-    ["input_img"] as const
-  );
-  const toolFn = async (_: AgentEx, args: unknown): Promise<ToolCallResult> => {
-    const { prompt, input_img } = getPromptInputImg(args);
-    const image = await imageGenerator.generate(prompt, input_img);
-    return {
-      response: image,
-      overwriteArgs: JSON.stringify({ prompt }),
-      // overwriteResponse: "Image generated",
-      // // For now, let the UI see the image.
-      // passOriginalResponseToEventHandler: true,
-    };
-  };
-
-  return {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    setup: async (agent: AgentEx) => {
-      agent.addAgentTool(GEN_IMAGE_DESC, toolFn);
-    },
-  };
-}
-
-// gen_image_file
-
-export async function genImageFileTool(
-  platform: IPlatform,
-  fileManager: ChatSessionFileManager
-): Promise<IAgentToolProvider> {
-  const GEN_IMAGE_FILE_DESC: ToolDescriptor = {
-    type: "function",
-    function: {
-      name: "gen_image_file",
-      description: "Generate image (into session file manager)",
-      parameters: {
-        type: "object",
-        properties: {
-          prompt: {
-            type: "string",
-            description: "Prompt/instructions for image generator",
-          },
-          name: {
-            type: "string",
-            description: "Name of file to (over)write",
-          },
-          summary: {
-            type: "string",
-            description: "Summary (for file manager)",
-          },
-          input_name: {
-            type: "string",
-            description: "(Optional) input image filename",
-          },
-        },
-        required: ["prompt", "name", "summary"],
-      },
-    },
-  } as const;
-
-  const imageGenerator = await createImageGenerator(platform);
-  const getPromptNameSummary = makeParseArgsFn(
-    ["prompt", "name", "summary"] as const,
-    ["input_name"] as const
-  );
-  const toolFn = async (
-    _: AgentEx,
-    args: unknown
-  ): Promise<ToolCallResultWithFileRef> => {
-    const { prompt, name, summary, input_name } = getPromptNameSummary(args);
-    const input_image = input_name
-      ? await fileManager.getFileContent(input_name)
-      : undefined;
-
-    const image = await imageGenerator.generate(prompt, input_image);
-    const mimeType = getSessionFileMimeTypeFromDataUrl(image);
-    await fileManager.putFileContent(name, summary, image);
-    const uri = fileManager.getSessionFileRelativeUrl(name);
-    return {
-      response: uri,
-      _meta: { "xalia/fileUri": uri, "xalia/fileMimeType": mimeType },
-    };
-  };
-
-  return {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    setup: async (agent: AgentEx) => {
-      agent.addAgentTool(GEN_IMAGE_FILE_DESC, toolFn);
-    },
-  };
-}

package/src/chat/server/openAIRouterLLM.ts

@@ -1,171 +0,0 @@
-import { OpenAI } from "openai";
-
-import { getLogger } from "@xalia/xmcp/sdk";
-import { utils } from "@xalia/xmcp/tool";
-
-import { OpenAILLMStreaming } from "../../agent/openAILLMStreaming";
-import {
-  ILLM,
-  MessageParam,
-  ToolDescriptor,
-  Completion,
-  XALIA_APP_HEADER,
-} from "../../agent/llm";
-
-const logger = getLogger();
-
-// TODO: May be better to allow the calling code to determine this.
-
-const DEFAULT_PROVIDER_URLS: Record<string, string | undefined> = {
-  openrouter: "https://openrouter.ai/api/v1",
-  openai: "https://api.openai.com/v1",
-  anthropic: "https://api.anthropic.com/v1",
-  together: "https://api.together.xyz/v1",
-};
-
-const DEFAULT_MODEL_MAP: Record<string, string | undefined> = {
-  "gpt-4o-mini": "openai",
-  "gpt-4o": "openai",
-  "openai/gpt-4o-mini": "openrouter",
-  "openai/gpt-4o": "openrouter",
-  "google/gemini-2.5-flash": "openrouter",
-  "google/gemini-2.5-pro": "openrouter",
-  "google/gemini-2.5-flash-image-preview": "openrouter",
-  "anthropic/claude-3.7-sonnet": "openrouter",
-  "anthropic/claude-sonnet-4": "openrouter",
-  "anthropic/claude-sonnet-4.5": "openrouter",
-  "claude-3-7-sonnet-20250219": "anthropic",
-  "arcee-ai/AFM-4.5B-Preview": "together",
-  "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free": "together",
-};
-
-type CachedMaps = {
-  modelToProvider: Record<string, string | undefined>;
-  providerUrls: Record<string, string | undefined>;
-  providerApiKeys: Record<string, string | undefined>;
-};
-
-let cached_maps: CachedMaps | undefined = undefined;
-
-// TODO: Move this to the CLI command args?
-
-function decodeOrUseDefault(
-  stringOrFile: string | undefined,
-  defaultValue: Record<string, string | undefined>
-): Record<string, string | undefined> {
-  const value =
-    utils.loadContentOrFileOrUndefined<Record<string, string | undefined>>(
-      stringOrFile
-    );
-  if (value) {
-    return value;
-  }
-  return defaultValue;
-}
-
-function getMaps(): CachedMaps {
-  // global cached_maps;
-  if (!cached_maps) {
-    const providerApiKeys = utils.loadContentOrFileOrUndefined<
-      Record<string, string | undefined>
-    >(process.env.LLM_API_KEY_MAP);
-    if (!providerApiKeys) {
-      throw new Error("LLM_API_KEY_MAP not not given");
-    }
-    const providerUrls = decodeOrUseDefault(
-      process.env.LLM_PROVIDER_URLS,
-      DEFAULT_PROVIDER_URLS
-    );
-    const modelToProvider = decodeOrUseDefault(
-      process.env.LLM_MODEL_MAP,
-      DEFAULT_MODEL_MAP
-    );
-    cached_maps = {
-      modelToProvider,
-      providerUrls,
-      providerApiKeys,
-    };
-  }
-
-  return cached_maps;
-}
-
-export function getOpenAIClientParams(model: string): {
-  apiKey: string | undefined;
-  baseURL: string;
-} {
-  const maps = getMaps();
-  const provider = maps.modelToProvider[model];
-  if (!provider) {
-    throw new Error(`no provider registered for model ${model}`);
-  }
-  const baseURL = maps.providerUrls[provider];
-  if (!baseURL) {
-    throw new Error(`no provider url for provider ${provider}`);
-  }
-  const apiKey = maps.providerApiKeys[provider];
-  if (!apiKey) {
-    logger.warn(`No apiKey registered for provider ${provider}`);
-  }
-
-  return { apiKey, baseURL };
-}
-
-export function getOpenAIClient(model: string): OpenAI {
-  const { apiKey, baseURL } = getOpenAIClientParams(model);
-  return new OpenAI({
-    apiKey,
-    baseURL,
-    dangerouslyAllowBrowser: true,
-    defaultHeaders: XALIA_APP_HEADER,
-  });
-}
-
-/**
- * An ILLM implementation that accepts maps:
- *
- *   model-name => prover-name
- *   provider-name => url
- *   provider-name => api-key
- *
- * Requests are dynamically routed to the appropriate provider based on the
- * currently active model.
- */
-export class OpenAIRouterLLM implements ILLM {
-  private model: string;
-  private openai: OpenAI;
-
-  constructor(model: string) {
-    this.model = model;
-    this.openai = getOpenAIClient(model);
-  }
-
-  public setModel(model: string) {
-    this.model = model;
-    this.openai = getOpenAIClient(model);
-  }
-
-  public getModel(): string {
-    return this.model;
-  }
-
-  public getUrl(): string {
-    return this.openai.baseURL;
-  }
-
-  public async getConversationResponse(
-    messages: MessageParam[],
-    tools?: ToolDescriptor[],
-    onMessage?: (msg: string, end: boolean) => Promise<void>,
-    onReasoning?: (reasoning: string) => Promise<void>
-  ): Promise<Completion> {
-    return OpenAILLMStreaming.makeRequest(
-      this.openai,
-      this.model,
-      messages,
-      tools,
-      onMessage,
-      onReasoning
-    );
-  }
-}