@xalia/agent 0.6.8 → 0.6.10

package/src/chat/server/promptRefiner.ts

@@ -0,0 +1,106 @@
+import { getOpenAIClient } from "./openAIRouterLLM";
+import { getLogger } from "@xalia/xmcp/sdk";
+
+const logger = getLogger();
+
+const REFINER_MODEL = "google/gemini-2.5-flash";
+const REFINER_MAX_TOKENS = 2000;
+const REFINER_TEMPERATURE = 0.3;
+const REFINER_TIMEOUT_MS = 30000;
+
+// prettier-ignore
+const REFINEMENT_SYSTEM_PROMPT =
+`You are an expert at writing system prompts for AI assistants. Your task is \
+to refine and improve the given system prompt to make it more effective, \
+clear, and well-structured for an LLM to follow.
+
+Guidelines for refinement:
+1. Make instructions clear, specific, and actionable
+2. Use structured formatting (sections, bullet points) when appropriate
+3. Remove ambiguity and redundancy
+4. Add relevant context if missing
+5. Ensure the tone and style are consistent
+6. Preserve the original intent and personality
+7. Keep the prompt concise but comprehensive
+
+Return ONLY the refined system prompt, without any explanations or \
+meta-commentary.`;
+
+export interface IPromptRefiner {
+  refinePrompt(prompt: string): Promise<string>;
+}
+
+export class LLMPromptRefiner implements IPromptRefiner {
+  private model: string;
+
+  constructor(model: string = REFINER_MODEL) {
+    this.model = model;
+  }
+
+  async refinePrompt(prompt: string): Promise<string> {
+    if (!prompt || prompt.trim().length === 0) {
+      return prompt;
+    }
+
+    try {
+      const refined = await this.refineWithTimeout(prompt);
+      return refined.trim();
+    } catch (error) {
+      const errorMsg =
+        error instanceof Error ? error.message : String(error);
+      logger.warn(
+        `[PromptRefiner] LLM refinement failed: ${errorMsg}, returning original`
+      );
+      throw error;
+    }
+  }
+
+  private async refineWithTimeout(prompt: string): Promise<string> {
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => {
+        reject(new Error("Prompt refinement timeout"));
+      }, REFINER_TIMEOUT_MS);
+    });
+
+    const refinePromise = this.callLLM(prompt);
+
+    return Promise.race([refinePromise, timeoutPromise]);
+  }
+
+  private async callLLM(prompt: string): Promise<string> {
+    const client = getOpenAIClient(this.model);
+
+    const response = await client.chat.completions.create({
+      model: this.model,
+      messages: [
+        {
+          role: "system",
+          content: REFINEMENT_SYSTEM_PROMPT,
+        },
+        {
+          role: "user",
+          content: `Please refine this system prompt:\n\n${prompt}`,
+        },
+      ],
+      max_tokens: REFINER_MAX_TOKENS,
+      temperature: REFINER_TEMPERATURE,
+    });
+
+    const refined = response.choices[0]?.message?.content?.trim();
+
+    if (!refined) {
+      throw new Error("Empty response from LLM");
+    }
+
+    return refined;
+  }
+}
+
+let promptRefinerInstance: IPromptRefiner | undefined;
+
+export function getPromptRefiner(model?: string): IPromptRefiner {
+  if (!promptRefinerInstance) {
+    promptRefinerInstance = new LLMPromptRefiner(model);
+  }
+  return promptRefinerInstance;
+}

package/src/chat/server/server.ts

@@ -13,7 +13,15 @@ import { ChatFatalError } from "../protocol/errors";
 import { ServerToClient } from "../protocol/messages";
 import { SessionRegistry } from "./sessionRegistry";
 
+const DEVELOPMENT: boolean = process.env.DEVELOPMENT === "1";
+const TEST: boolean = process.env.TEST === "1";
+
 dotenv.config();
+if (TEST) {
+  dotenv.config({ path: ".env.test" });
+} else if (DEVELOPMENT) {
+  dotenv.config({ path: ".env.development" });
+}
 
 const logger = getLogger();
 
@@ -59,7 +67,6 @@ export async function runServer(
   port: number,
   supabaseUrl: string,
   supabaseKey: string,
-  llmUrl: string,
   xmcpUrl: string
 ): Promise<ws.Server> {
   return new Promise((r, _e) => {
@@ -68,7 +75,7 @@ export async function runServer(
     const createSessionRegistry = (
       connManager: IUserConnectionManager<ServerToClient>
     ) => {
-      return new SessionRegistry(db, connManager, llmUrl, xmcpUrl);
+      return new SessionRegistry(db, connManager, xmcpUrl);
     };
     const connectionManager = ConnectionManager.init(createSessionRegistry);
 

package/src/chat/server/sessionFileManager.ts

@@ -1,148 +1,22 @@
+/**
+ * Chat-specific file manager implementation backed by the database.
+ */
+
 import { v4 as uuidv4 } from "uuid";
 import { strict as assert } from "assert";
 
-import {
-  Agent,
-  IAgentToolProvider,
-  ToolCallResult,
-  ToolHandler,
-} from "../../agent/agent";
-import { makeParseArgsFn } from "./tools";
 import { Database } from "../data/database";
 import { DbSessionFiles } from "../data/dbSessionFiles";
 import {
-  FileMetaData,
+  ISessionFileManager,
+  ISessionFileManagerEventHandler,
   SessionFileDescriptor,
-  SessionFileEntry,
+  ParsedContent,
   getSessionFileMimeTypeFromDataUrl,
-} from "../data/dbSessionFileModels";
-import { ToolDescriptor } from "../../agent/llm";
-
-/**
- * Tool call result with specific form of metadata
- */
-export type ToolCallResultWithFileRef = ToolCallResult<FileMetaData>;
-
-/**
- * Calling code implements this to be informed of file changes.
- */
-export interface ISessionFileManagerEventHandler {
-  onFileChanged(entry: SessionFileEntry, new_file: boolean): void;
-  onFileDeleted(name: string): void;
-}
-
-/**
- * Interface to a set of files in a session.
- */
-export interface ISessionFileManager {
-  /**
-   * List file names, types and summaries,
-   */
-  listFiles(): SessionFileDescriptor[];
-
-  /**
-   * Retrieve file contents.
-   */
-  getFileContent(name: string): Promise<string>;
-
-  /**
-   * Delete a file
-   */
-  deleteFile(name: string): Promise<void>;
-
-  /**
-   * Create or update a file with the given name.  Returns the name (which is
-   * created if one is not passed in).
-   */
-  putFileContent(
-    name: string | undefined,
-    summary: string | undefined,
-    data_url: string
-  ): Promise<SessionFileDescriptor>;
-
-  addEventHandler(eventHandler: ISessionFileManagerEventHandler): void;
-}
-
-/**
- * In-memory implementation of ISessionFileManager
- */
-export class MemoryFileManager implements ISessionFileManager {
-  private readonly files: Map<string, SessionFileEntry>;
-  private eventHandlers: ISessionFileManagerEventHandler[];
-
-  constructor() {
-    this.files = new Map();
-    this.eventHandlers = [];
-  }
-
-  // ISessionFileManager.listFiles
-  listFiles(): SessionFileDescriptor[] {
-    return Array.from(this.files.values());
-  }
-
-  // ISessionFileManager.getFileContent
-  getFileContent(name: string): Promise<string> {
-    return new Promise((r, e) => {
-      const entry = this.files.get(name);
-      if (entry) {
-        r(entry.data_url);
-      } else {
-        e(new Error(`no such file ${name}`));
-      }
-    });
-  }
-
-  // ISessionFileManager.deleteFile
-  deleteFile(name: string): Promise<void> {
-    return new Promise((r, e) => {
-      if (this.files.has(name)) {
-        this.files.delete(name);
-        this.eventHandlers.forEach((eh) => {
-          eh.onFileDeleted(name);
-        });
-        r();
-      } else {
-        e(new Error(`no such file ${name}`));
-      }
-    });
-  }
-
-  // ISessionFileManager.addFile
-  putFileContent(
-    name: string | undefined,
-    summary: string | undefined,
-    data_url: string
-  ): Promise<SessionFileDescriptor> {
-    return new Promise((r, e) => {
-      if (!name) {
-        name = uuidv4();
-      }
-      if (!summary) {
-        summary = "";
-      }
-      if (!isSingleLine(summary)) {
-        e(new Error("summary must no contain new-lines"));
-      } else {
-        const mime_type = getSessionFileMimeTypeFromDataUrl(data_url);
-        const is_new = !this.files.has(name);
-        const entry: SessionFileEntry = { name, mime_type, summary, data_url };
-        this.eventHandlers.forEach((eh) => {
-          eh.onFileChanged(entry, is_new);
-        });
-        this.files.set(name, entry);
-        r({ name, mime_type, summary });
-      }
-    });
-  }
-
-  // ISessionFileManager.setEventHandler
-  addEventHandler(eventHandler: ISessionFileManagerEventHandler) {
-    this.eventHandlers.push(eventHandler);
-  }
-}
+} from "../../agent/tools/fileManager";
 
 /**
- * Implementation of ISessionFileManager which can store files in the DB.
+ * Implementation of ISessionFileManager which stores files in the DB.
  */
 export class ChatSessionFileManager implements ISessionFileManager {
   private readonly sessionUUID: string;
@@ -197,7 +71,15 @@ export class ChatSessionFileManager implements ISessionFileManager {
     return fileData;
   }
 
-  // ISessionFileManager.deleteFile
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getFileParsedContent(name: string): Promise<ParsedContent | undefined> {
+    const descriptor = this.fileMap.get(name);
+    if (!descriptor) {
+      throw new Error(`no file '${name}' in session '${this.sessionUUID}'`);
+    }
+    return descriptor.parsed_content;
+  }
+
   async deleteFile(name: string): Promise<void> {
     if (this.fileMap.has(name)) {
       this.fileMap.delete(name);
@@ -211,41 +93,44 @@ export class ChatSessionFileManager implements ISessionFileManager {
     }
   }
 
-  // ISessionFileManager.addFile
   async putFileContent(
     name: string | undefined,
     summary: string | undefined,
-    data_url: string
+    data_url: string,
+    parsed_content?: ParsedContent
   ): Promise<SessionFileDescriptor> {
     if (!name) {
-      // TODO: have the LLM fill in the name?
       name = uuidv4();
     }
-    // TODO: have the LLM create summary if missing?
-
-    // If we have an existing entry in the cache then update it, otherwise
-    // create a new one.
 
     const mime_type = getSessionFileMimeTypeFromDataUrl(data_url);
     const existingDesc = this.fileMap.get(name);
+    const is_new = !existingDesc;
     if (existingDesc) {
       existingDesc.summary = summary;
       existingDesc.mime_type = mime_type;
+      existingDesc.parsed_content = parsed_content;
     } else {
-      this.fileMap.set(name, { name, summary, mime_type });
+      this.fileMap.set(name, { name, summary, mime_type, parsed_content });
     }
-
-    const is_new = !this.fileMap.has(name);
     this.fileDataCache.set(name, data_url);
-    await this.sfc.setFileContent(this.sessionUUID, name, summary, data_url);
+    await this.sfc.setFileContent(
+      this.sessionUUID,
+      name,
+      summary,
+      data_url,
+      parsed_content
+    );
     this.eventHandlers.forEach((eh) => {
       assert(typeof name === "string");
-      eh.onFileChanged({ name, summary, mime_type, data_url }, is_new);
+      eh.onFileChanged(
+        { name, summary, mime_type, parsed_content, data_url },
+        is_new
+      );
     });
-    return { name, mime_type, summary };
+    return { name, mime_type, summary, parsed_content };
   }
 
-  // ISessionFileManager.setEventHandler
   addEventHandler(eventHandler: ISessionFileManagerEventHandler) {
     this.eventHandlers.push(eventHandler);
   }
@@ -264,159 +149,3 @@ export class ChatSessionFileManager implements ISessionFileManager {
     return `file+session://${this.sessionUUID}/${name}`;
   }
 }
-
-/**
- * Return the file list in a form easily parsable by the LLM.
- */
-export function createSessionFilesManagerPrompt(
-  fm: ISessionFileManager
-): string {
-  const files = fm.listFiles();
-  if (files.length === 0) {
-    return "";
-  }
-  let prompt =
-    "Files can be read/written as required. Create new files conservatively, " +
-    "usually when complex content is requested. Use base64 for binary (image," +
-    "pdf), ascii for text formats (html,markdown). " +
-    "Available files:\nname,type,summary\n";
-  for (const f of files) {
-    prompt += `${f.name},${f.mime_type},${f.summary || ""}\n`;
-  }
-  return prompt;
-}
-
-const GET_FILE_CONTENT_TOOL: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "get_file_content",
-    description: "Obtain contents of file listed in system prompt, as data-url",
-    parameters: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "File name",
-        },
-      },
-      required: ["name"],
-    },
-  },
-};
-
-const PUT_FILE_CONTENT_TOOL: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "put_file_content",
-    description: "Create or update file content",
-    parameters: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "File name",
-        },
-        summary: {
-          type: "string",
-          description: "Content summary",
-        },
-        data_url: {
-          type: "string",
-          description:
-            "Content data-url: `data:<mime-type>[;<format>],<encoding>`",
-        },
-      },
-      required: ["name", "summary", "data_url"],
-    },
-  },
-};
-
-const DELETE_FILE_CONTENT_TOOL: ToolDescriptor = {
-  type: "function",
-  function: {
-    name: "delete_file_content",
-    description: "Delete file",
-    parameters: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: "File name",
-        },
-      },
-      required: ["name"],
-    },
-  },
-};
-
-export function fileManagerTool(
-  fileManager: ChatSessionFileManager
-): IAgentToolProvider {
-  // `get_file_content` tool
-  //
-  // LLM can read data from the file.  To keep the context small, we overwrite
-  // the data with the session file url after the LLM has seen it.
-
-  const parseName = makeParseArgsFn(["name"] as const);
-  const getFileContentFn: ToolHandler = async (
-    _agent: Agent,
-    args: unknown
-  ): Promise<ToolCallResult> => {
-    const { name } = parseName(args);
-    const response = await fileManager.getFileContent(name);
-    const overwriteResponse = fileManager.getSessionFileRelativeUrl(name);
-    return { response, overwriteResponse };
-  };
-
-  // `set_file_content` tool
-  //
-  // Allows LLM to write data (as a data-url) to the session file manager. The
-  // data is replaced by a session file url after being saved.
-
-  const putArgs = ["name", "summary", "data_url"] as const;
-  const parseNameSummaryDataUrl = makeParseArgsFn(putArgs);
-  const putFileContentFn: ToolHandler = async (
-    _: Agent,
-    args: unknown
-  ): Promise<ToolCallResultWithFileRef> => {
-    const parsed = parseNameSummaryDataUrl(args);
-    const { name, summary, data_url } = parsed;
-    const desc = await fileManager.putFileContent(name, summary, data_url);
-    const mimeType = getSessionFileMimeTypeFromDataUrl(data_url);
-    parsed.data_url = fileManager.getSessionFileRelativeUrl(name);
-    return {
-      response: desc.name,
-      overwriteArgs: JSON.stringify(parsed),
-      _meta: {
-        "xalia/fileUri": parsed.data_url,
-        "xalia/fileMimeType": mimeType,
-      },
-    };
-  };
-
-  // `delete_file_content` tool
-  //
-  // Allows LLM to write data (as a data-url) to the session file manager. The
-  // data is replaced by a session file url after being saved.
-
-  const deleteFileFn: ToolHandler = async (_: Agent, args: unknown) => {
-    const { name } = parseName(args);
-    await fileManager.deleteFile(name);
-    return { response: "" };
-  };
-
-  return {
-    setup: (agent: Agent) => {
-      agent.addAgentTool(GET_FILE_CONTENT_TOOL, getFileContentFn);
-      agent.addAgentTool(PUT_FILE_CONTENT_TOOL, putFileContentFn);
-      agent.addAgentTool(DELETE_FILE_CONTENT_TOOL, deleteFileFn);
-      return new Promise<void>((r) => {
-        r();
-      });
-    },
-  };
-}
-
-function isSingleLine(str: string): boolean {
-  return !/[\r\n]/.test(str);
-}

package/src/chat/server/sessionRegistry.test.ts

@@ -49,7 +49,6 @@ describe("SessionRegistry", () => {
     sessionRegistry = new SessionRegistry(
       mockDatabase.mock,
       mockUserConnectionManager.mock,
-      "http://llm-api.test",
       "http://xmcp-api.test"
     );
   });