@xalia/agent 0.6.9 → 0.6.11

package/src/chat/server/tools.ts

@@ -1,397 +0,0 @@
-/**
- * Collection of simple Agent tools.
- */
-
-import { Parser } from "expr-eval";
-
-import {
-  Agent,
-  AgentEx,
-  IAgentToolProvider,
-  ToolCallResult,
-} from "../../agent/agent";
-import { getLogger } from "@xalia/xmcp/sdk";
-
-import { htmlToText } from "../utils/htmlToText";
-import { webSearch } from "../utils/search";
-import {
-    ChatSessionFileManager,
-    ToolCallResultWithFileRef,
-    fileManagerTool,
-} from "./sessionFileManager";
-import { genImageFileTool } from "./imageGeneratorTools";
-import { ToolDescriptor } from "../../agent/llm";
-import { IPlatform } from "../../agent/iplatform";
-
-const logger = getLogger();
-
-const DEVELOPMENT: boolean = process.env.DEVELOPMENT === "1";
-
-/**
- * Returns a function which parses an `args` struct and attempts to extract
- * multiple string parameters with the given names.  e.g.
- *
- *   const parseFn = makeParseArgsFn(
- *     ["arg0", "arg1"] as const,
- *     ["opt0"] as const)
- *
- * creates
- *
- *   parseFn: (args: unknown) => {
- *     arg0: string,
- *     arg1: string,
- *     opt0: string|undefined
- *   }
- *
- * which can be used to parse tool arguments.
- *
- * NOTE, the complex type parameters ensures that the name list is a
- * compile-time value, which in turn ensures that the return value of this
- * function is well-typed.
- */
-export function makeParseArgsFn<
-  T extends readonly string[] & (string extends T[number] ? never : unknown),
-  U extends readonly string[] & (string extends U[number] ? never : unknown),
->(
-  names: T,
-  optNames?: U
-): (
-  args: unknown
-) => { [K in T[number]]: string } & { [K in U[number]]: string | undefined } {
-  return (args: unknown) => {
-    if (!args || typeof args !== "object") {
-      throw new Error(`invalid args: ${typeof args}`);
-    }
-    const argsObj = args as Record<string, string | undefined>;
-    for (const name of names) {
-      const val = argsObj[name];
-      if (typeof val !== "string") {
-        throw new Error(`invalid expr args.${name}: ${typeof val}`);
-      }
-    }
-    if (optNames) {
-      for (const name of optNames) {
-        const val = argsObj[name];
-        if (typeof val !== "undefined" && typeof val !== "string") {
-          throw new Error(`invalid expr args.${name}: ${typeof val}`);
-        }
-      }
-    }
-
-    return argsObj as { [K in T[number]]: string } & {
-      [K in U[number]]: string | undefined;
-    };
-  };
-}
-
-const DATETIME_DESC: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "time_now",
-    description: "Current time",
-  },
-};
-
-export function isoWithTimezone(timeZone: string): string {
-  return (
-    new Intl.DateTimeFormat("sv-SE", {
-      timeZone,
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-      hour12: false,
-      timeZoneName: "short",
-    })
-      .format(new Date())
-      .replace(" ", "T") + ` (${timeZone})`
-  );
-}
-
-export function datetimeTool(timezone: string): IAgentToolProvider {
-  // eslint-disable-next-line @typescript-eslint/require-await
-  const toolFn = async () => {
-    return { response: isoWithTimezone(timezone) };
-  };
-  return {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    setup: async (agent: AgentEx) => {
-      agent.addAgentTool(DATETIME_DESC, toolFn);
-    },
-  };
-}
-
-const ARITHMETIC_DESC: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "arithmetic",
-    description: "Evaluate arithmetic expression",
-    parameters: {
-      type: "object",
-      properties: {
-        expr: {
-          type: "string",
-          description: "Expression containing +-*/()",
-        },
-      },
-      required: ["expr"],
-    },
-  },
-};
-
-export function calculatorEval(args: string): string {
-  try {
-    return String(Parser.evaluate(args));
-  } catch (e) {
-    if (typeof (e as { message: string }).message === "string") {
-      return (e as { message: string }).message;
-    }
-    return String(e);
-  }
-}
-
-export const calculatorTool: IAgentToolProvider = {
-  // eslint-disable-next-line @typescript-eslint/require-await
-  setup: async (agent: AgentEx) => {
-    const getExpr = makeParseArgsFn(["expr"] as const);
-    const toolFn = async (
-      _: AgentEx,
-      args: unknown
-    ): Promise<ToolCallResult> => {
-      const { expr } = getExpr(args);
-      return Promise.resolve({ response: calculatorEval(expr) });
-    };
-
-    agent.addAgentTool(ARITHMETIC_DESC, toolFn);
-  },
-};
-
-const RENDER_DESC: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "render",
-    description: [
-      "Display HTML using only safe elements",
-      "Never include <script>, <iframe>, <object>, <embed>, <form>, <meta>,",
-      "<link>, <style>, event handlers (onclick, etc.), or javascript: URLs.",
-      "If the tool result is [HTML_SANITIZATION_WARNING], do not mention it.",
-      "Retry with only safe elements. If warning repeats, tell the user you",
-      "cannot render unsafe HTML."
-    ].join(" "),
-    parameters: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "Filename for the HTML" },
-        summary: { type: "string", description: "One line summary" },
-        html: { type: "string", description: "HTML fragment to render" },
-      },
-      required: ["name", "summary", "html"],
-    },
-  },
-};
-
-function validateHtmlSafety(html: string): string | undefined {
-  const issues: string[] = [];
-  if (/<script[\s>]/i.test(html)) issues.push("<script> tag");
-  if (/<iframe[\s>]/i.test(html)) issues.push("<iframe> tag");
-  if (/<object[\s>]/i.test(html)) issues.push("<object> tag");
-  if (/<embed[\s>]/i.test(html)) issues.push("<embed> tag");
-  if (/\bon\w+\s*=/.test(html)) issues.push("event handler (e.g., onclick)");
-  if (/javascript:/i.test(html)) issues.push("javascript: URL");
-  if (/<meta[\s>]/i.test(html)) issues.push("<meta> tag");
-  if (/<form[\s>]/i.test(html)) issues.push("<form> tag");
-  if (/<style[\s>]/i.test(html)) issues.push("<style> tag");
-  if (/<link[\s>]/i.test(html)) issues.push("<link> tag");
-
-  if (issues.length > 0) {
-    return `Unsafe HTML: ${issues.join(", ")}`;
-  }
-  return undefined;
-}
-
-export function renderTool(
-  fileManager: ChatSessionFileManager
-): IAgentToolProvider {
-  const getNameSummeryHtml = makeParseArgsFn([
-    "name",
-    "summary",
-    "html",
-  ] as const);
-  const toolFn = async (
-    _: AgentEx,
-    args: unknown
-  ): Promise<ToolCallResultWithFileRef> => {
-    const { name, summary, html } = getNameSummeryHtml(args);
-    const safetyError = validateHtmlSafety(html);
-    if (safetyError) {
-      return {
-        response: "[HTML_SANITIZATION_WARNING]",
-        overwriteResponse: "",
-        structuredContent: {
-          kind: "htmlSanitizationWarning",
-          message: safetyError,
-        },
-      };
-    }
-    const mimeType = "text/html";
-    const dataURL = `data:${mimeType},${html}`;
-    await fileManager.putFileContent(name, summary, dataURL);
-    const uri = fileManager.getSessionFileRelativeUrl(name);
-    return {
-      response: "",
-      _meta: { "xalia/fileUri": uri, "xalia/fileMimeType": mimeType },
-    };
-  };
-
-  return {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    setup: async (agent: AgentEx) => {
-      agent.addAgentTool(RENDER_DESC, toolFn);
-    },
-  };
-}
-
-const WEB_SEARCH_DESC: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "web_search",
-    description: "Web search",
-    parameters: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "Search query text",
-        },
-      },
-      required: ["query"],
-    },
-  },
-};
-
-export function webSearchTool(): IAgentToolProvider {
-  const getQuery = makeParseArgsFn(["query"] as const);
-  const toolFn = async (_: AgentEx, args: unknown): Promise<ToolCallResult> => {
-    const { query } = getQuery(args);
-    logger.debug(`[web_search]: query: ${query}`);
-    const results = await webSearch(query);
-    logger.debug(`[web_search]: results: ${results}`);
-    return { response: JSON.stringify(results) };
-  };
-
-  return {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    setup: async (agent: AgentEx) => {
-      agent.addAgentTool(WEB_SEARCH_DESC, toolFn);
-    },
-  };
-}
-
-// open_url
-
-/**
- * For now, this matches the duckduckgo-mcp-server length.  Could extend
- * depending on the application / model etc.
- */
-const _OPEN_URL_MAX_LENGTH_STR = process.env["OPEN_URL_MAX_LENGTH"] || "8000";
-const OPEN_URL_MAX_LENGTH: number = parseInt(_OPEN_URL_MAX_LENGTH_STR, 10);
-
-const OPEN_URL_DESC: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "open_url",
-    description: "Download content from a URL",
-    parameters: {
-      type: "object",
-      properties: {
-        url: {
-          type: "string",
-          description: "URL to download",
-        },
-      },
-      required: ["url"],
-    },
-  },
-};
-
-export async function openURL(url: string): Promise<string> {
-  const response = await fetch(url);
-  if (!response.ok) {
-    const status = String(response.status);
-    const code = response.statusText;
-    throw new Error(`Failed to fetch ${url}: ${status} ${code}`);
-  }
-  const html = await response.text();
-  return htmlToText(html, OPEN_URL_MAX_LENGTH);
-}
-
-export function openURLTool(): IAgentToolProvider {
-  const getURL = makeParseArgsFn(["url"] as const);
-  const toolFn = async (_: AgentEx, args: unknown): Promise<ToolCallResult> => {
-    const { url } = getURL(args);
-    return { response: await openURL(url) };
-  };
-
-  return {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    setup: async (agent: AgentEx) => {
-      agent.addAgentTool(OPEN_URL_DESC, toolFn);
-    },
-  };
-}
-
-const TEST_DESC: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "test_tool",
-    description: "Call me when asked to test tools",
-    parameters: {
-      type: "object",
-      properties: {},
-      required: [],
-    },
-  },
-};
-
-export const testTool: IAgentToolProvider = {
-  setup: (agent: AgentEx) => {
-    const toolFn = (
-      _agent: AgentEx,
-      _args: unknown
-    ): Promise<ToolCallResult> => {
-      // Return an object with structuredContent and _meta
-      return Promise.resolve({
-        response: "Some text",
-        structuredContent: { description: "structuredContent example" },
-        _meta: { description: "_meta example" },
-      });
-    };
-    agent.addAgentTool(TEST_DESC, toolFn);
-    return Promise.resolve();
-  },
-};
-
-/**
- * Add a set of agent tools for chat sessions.
- */
-export async function addDefaultChatTools(
-  agent: AgentEx | Agent,
-  timezone: string,
-  platform: IPlatform,
-  fileManager: ChatSessionFileManager
-): Promise<void> {
-  await agent.addAgentToolProvider(datetimeTool(timezone));
-  await agent.addAgentToolProvider(calculatorTool);
-  await agent.addAgentToolProvider(renderTool(fileManager));
-  await agent.addAgentToolProvider(webSearchTool());
-  await agent.addAgentToolProvider(openURLTool());
-  await agent.addAgentToolProvider(fileManagerTool(fileManager));
-  await agent.addAgentToolProvider(
-    await genImageFileTool(platform, fileManager)
-  );
-  if (DEVELOPMENT) {
-    await agent.addAgentToolProvider(testTool);
-  }
-}

package/src/chat/utils/agentSessionMap.ts

@@ -1,76 +0,0 @@
-import { SavedAgentProfile, getLogger } from "@xalia/xmcp/sdk";
-import { AgentSessionData, SessionDescriptor } from "../data/dataModels";
-
-const logger = getLogger();
-
-export function emptyAgentProfile(agentUuid: string): SavedAgentProfile {
-  return {
-    uuid: agentUuid,
-    profile: {
-      model: undefined,
-      system_prompt: "",
-      mcp_settings: {},
-    },
-    user_uuid: "",
-    profile_name: `Deleted Agent (${agentUuid.slice(0, 8)}...)`,
-    updated_at: "",
-    preferences: {
-      auto_approve: {},
-    },
-    template_name: undefined,
-  };
-}
-
-// build agentSessionMap from sessions and agents
-export function buildAgentSessionMap(
-  sessions: Map<string, SessionDescriptor>,
-  agents: Map<string, SavedAgentProfile>
-): Map<string, AgentSessionData> {
-  const agentSessionMap: Map<string, AgentSessionData> = new Map();
-
-  logger.debug(`[buildAgentSessionMap] sessions: ${JSON.stringify(sessions)}`);
-  logger.debug(`[buildAgentSessionMap] agents: ${JSON.stringify(agents)}`);
-
-  // First, add all agents to the map (even those without sessions)
-  for (const agent of agents.values()) {
-    agentSessionMap.set(agent.uuid, {
-      agent_profile: agent,
-      sessions: [],
-      updated_at: 0,
-    });
-  }
-
-  // Then, add sessions to their corresponding agents
-  for (const session of sessions.values()) {
-    const agentUuid = session.agent_profile_uuid;
-    const updatedAt = session.updated_at
-      ? new Date(session.updated_at).getTime()
-      : 0;
-
-    let agentSessions = agentSessionMap.get(agentUuid);
-
-    if (!agentSessions) {
-      // This is an orphaned session (agent was deleted).  Should not happen
-      // due to DB constraints.
-      logger.warn(
-        `session ${session.session_uuid} referes to unknown agent ${agentUuid}`
-      );
-      const agentProfile = emptyAgentProfile(agentUuid);
-      agentSessions = {
-        agent_profile: agentProfile,
-        sessions: [session],
-        updated_at: updatedAt,
-      };
-      agentSessionMap.set(agentUuid, agentSessions);
-    } else {
-      // Add session to existing agent
-      agentSessions.sessions.push(session);
-      // update updatedAt
-      if (updatedAt > agentSessions.updated_at) {
-        agentSessions.updated_at = updatedAt;
-      }
-    }
-  }
-
-  return agentSessionMap;
-}

package/src/chat/utils/approvalManager.ts

@@ -1,183 +0,0 @@
-import {
-  AgentPreferences,
-  getLogger,
-  prefsGetAutoApprove,
-  prefsSetAutoApprove,
-} from "@xalia/xmcp/sdk";
-import { ResponseAwaiter } from "./responseAwaiter";
-import {
-  ClientToolCallApprovalResult,
-  ServerToClient,
-  ServerToolAutoApprovalSet,
-} from "../protocol/messages";
-import { Database } from "../data/database";
-import { MessageToolCall } from "../../agent/llm";
-import { ISessionMessageSender } from "../server/openSessionMessageSender";
-
-const logger = getLogger();
-
-export interface IAgentPreferencesWriter {
-  updatePreferences(
-    agentProfileUUID: string,
-    settings: AgentPreferences
-  ): Promise<void>;
-}
-
-export class DbAgentPreferencesWriter implements IAgentPreferencesWriter {
-  constructor(private db: Database) {}
-
-  updatePreferences(
-    agentProfileUUID: string,
-    preferences: AgentPreferences
-  ): Promise<void> {
-    return this.db.updateAgentProfilePreferences(agentProfileUUID, preferences);
-  }
-}
-
-/**
- * Handles an in-memory caching / updating of the auto-approve settings for
- * tool calls.  Also handles querying the client for approval and waiting for
- * responses.
- */
-export class ToolApprovalManager {
-  private sessionUUID: string;
-  private agentProfileUUID: string;
-  private agentProfilePreferences: AgentPreferences;
-  private sender: ISessionMessageSender<ServerToClient>;
-  private writer: IAgentPreferencesWriter;
-  private responseAwaiter: ResponseAwaiter<ClientToolCallApprovalResult>;
-
-  constructor(
-    sessionUUID: string,
-    agentProfileUUID: string,
-    agentProfilePreferences: AgentPreferences,
-    sender: ISessionMessageSender<ServerToClient>,
-    writer: IAgentPreferencesWriter,
-    timeoutMs?: number
-  ) {
-    this.sessionUUID = sessionUUID;
-    this.agentProfileUUID = agentProfileUUID;
-    this.agentProfilePreferences = agentProfilePreferences;
-    this.sender = sender;
-    this.writer = writer;
-    this.responseAwaiter = ResponseAwaiter.init(
-      undefined,
-      (msg) => msg.id,
-      timeoutMs
-    );
-  }
-
-  /**
-   * Check for auto-approval, or query the client.  Handle approval response
-   * (or timeout) and update auto-approval settings.
-   *
-   * The returned `requested` value indicates whether approval was requested.
-   */
-  public async getApproval(
-    serverName: string,
-    tool: string,
-    toolCall: MessageToolCall
-  ): Promise<{ approved: boolean; requested: boolean }> {
-    const autoApproved = prefsGetAutoApprove(
-      this.agentProfilePreferences,
-      serverName,
-      tool
-    );
-    if (autoApproved) {
-      return { approved: true, requested: false };
-    }
-
-    // Query the owner for approval
-
-    const id = this.generateUniqueId(toolCall.function.name);
-    try {
-      const approvalP = this.responseAwaiter.waitForResponse(id);
-
-      this.sender.broadcast({
-        type: "approve_tool_call",
-        id,
-        tool_call: toolCall,
-        session_id: this.sessionUUID,
-      });
-
-      logger.debug(`[ApprovalManager.getApproval] awaiting approval ${id}`);
-      const approval = await approvalP;
-      logger.debug(
-        `[ApprovalManager.getApproval] approval ${JSON.stringify(approval)}`
-      );
-
-      // Handle any auto-approve update, informing other clients.
-
-      if (approval.auto_approve) {
-        logger.debug("[ApprovalManager.getApproval] updated preferences");
-        const autoApprovalMsg = await this.setAutoApprove(
-          serverName,
-          tool,
-          true
-        );
-        if (autoApprovalMsg) {
-          this.sender.broadcast(autoApprovalMsg);
-        }
-      }
-
-      // Broadcast the result of the approval
-
-      this.sender.broadcast({
-        type: "tool_call_approval_result",
-        id: approval.id,
-        result: approval.result,
-        session_id: this.sessionUUID,
-      });
-
-      return { approved: approval.result, requested: true };
-    } catch (e) {
-      logger.debug(
-        `[OpenSession.onToolCall] error waiting for approval ${id}: ` +
-          String(e)
-      );
-      throw e;
-    }
-  }
-
-  /**
-   * Handle a request to set auto-approval for a given tool.  If there was a
-   * change, return the message to be broadcast.
-   */
-  public async setAutoApprove(
-    serverName: string,
-    tool: string,
-    autoApprove: boolean
-  ): Promise<ServerToolAutoApprovalSet | undefined> {
-    if (
-      prefsSetAutoApprove(
-        this.agentProfilePreferences,
-        serverName,
-        tool,
-        autoApprove
-      )
-    ) {
-      await this.writer.updatePreferences(
-        this.agentProfileUUID,
-        this.agentProfilePreferences
-      );
-      return {
-        type: "tool_auto_approval_set",
-        server_name: serverName,
-        tool,
-        auto_approve: autoApprove,
-        session_id: this.sessionUUID,
-      };
-    }
-  }
-
-  /**
-   * Forward all approval result messages here.
-   */
-  public onApprovalResult(msg: ClientToolCallApprovalResult): void {
-    this.responseAwaiter.onMessage(msg);
-  }
-
-  private generateUniqueId(tag: string): string {
-    return `approval-${tag}-` + Math.random().toString(36).substring(2, 11);
-  }
-}

package/src/chat/utils/asyncLock.ts

@@ -1,43 +0,0 @@
-import { strict as assert } from "assert";
-
-/**
- * Support awaiting exclusive access to a resource.
- */
-export class AsyncLock {
-  private running: boolean = false;
-  private callbacks: (() => Promise<void>)[] = [];
-
-  lockAndProcess<T>(cb: () => Promise<T>): Promise<T> {
-    return new Promise<T>((r, e) => {
-      this.callbacks.push(async () => {
-        try {
-          const result = await cb();
-          r(result);
-        } catch (err) {
-          e(err instanceof Error ? err : new Error(String(err)));
-        }
-      });
-
-      if (!this.running) {
-        void this.run();
-      }
-    });
-  }
-
-  private async run() {
-    assert(!this.running);
-    this.running = true;
-
-    while (this.callbacks.length > 0) {
-      const cb = this.callbacks.shift();
-      assert(cb);
-      try {
-        await cb();
-      } catch (e) {
-        assert(false, `errors should not propagate: ${String(e)}`);
-      }
-    }
-
-    this.running = false;
-  }
-}