@llmbridge/plugin-logging 0.1.0 → 0.1.2

package/dist/index.d.mts

@@ -1,18 +1,36 @@
 import { LLMBridge } from '@llmbridge/core';
 
+interface Logger {
+    log?(message?: any, ...optionalParams: any[]): void;
+    info?(message?: any, ...optionalParams: any[]): void;
+    warn?(message?: any, ...optionalParams: any[]): void;
+    error?(message?: any, ...optionalParams: any[]): void;
+    debug?(message?: any, ...optionalParams: any[]): void;
+}
 interface LoggingPluginOptions {
     folder: string;
+    logger?: Logger;
 }
 declare function generateRandomDigits(length: number): string;
 declare class LoggingPlugin implements LLMBridge.Plugin<void, string, void, void> {
     private options;
+    private logger;
     constructor(options: LoggingPluginOptions);
+    private log;
     wrapRun(next: () => Promise<LLMBridge.Response>, context: LLMBridge.PluginCompletionContext): Promise<LLMBridge.Response>;
-    wrapExec(next: (params: any) => Promise<any>, params: any, context: LLMBridge.PluginCompletionContext): Promise<any>;
+    wrapExec(next: (params: any) => Promise<any>, params: any, _context: LLMBridge.PluginCompletionContext): Promise<any>;
     wrapToolExec(next: (tool: LLMBridge.Tool, counter: number, input: any) => Promise<any>, tool: LLMBridge.Tool, counter: number, input: any, context: LLMBridge.PluginCompletionContext): Promise<any>;
-    createLogFiles(requestId: string, type: 'request' | 'response', data: any): void;
-    createTxtFile(filePath: string, data: any): void;
-    objectToTxt(obj: any, prefix?: string): string;
+    private writeJsonLog;
+    private writeXmlLog;
+    private logError;
+    private getDailyFolder;
+    private buildXml;
+    private parseArguments;
+    private appendCdata;
+    private appendArguments;
+    private appendRawArguments;
+    private sanitizeAttribute;
+    private cleanXmlString;
 }
 
-export { LoggingPlugin, type LoggingPluginOptions, generateRandomDigits };
+export { type Logger, LoggingPlugin, type LoggingPluginOptions, generateRandomDigits };

package/dist/index.d.ts

@@ -1,18 +1,36 @@
 import { LLMBridge } from '@llmbridge/core';
 
+interface Logger {
+    log?(message?: any, ...optionalParams: any[]): void;
+    info?(message?: any, ...optionalParams: any[]): void;
+    warn?(message?: any, ...optionalParams: any[]): void;
+    error?(message?: any, ...optionalParams: any[]): void;
+    debug?(message?: any, ...optionalParams: any[]): void;
+}
 interface LoggingPluginOptions {
     folder: string;
+    logger?: Logger;
 }
 declare function generateRandomDigits(length: number): string;
 declare class LoggingPlugin implements LLMBridge.Plugin<void, string, void, void> {
     private options;
+    private logger;
     constructor(options: LoggingPluginOptions);
+    private log;
     wrapRun(next: () => Promise<LLMBridge.Response>, context: LLMBridge.PluginCompletionContext): Promise<LLMBridge.Response>;
-    wrapExec(next: (params: any) => Promise<any>, params: any, context: LLMBridge.PluginCompletionContext): Promise<any>;
+    wrapExec(next: (params: any) => Promise<any>, params: any, _context: LLMBridge.PluginCompletionContext): Promise<any>;
     wrapToolExec(next: (tool: LLMBridge.Tool, counter: number, input: any) => Promise<any>, tool: LLMBridge.Tool, counter: number, input: any, context: LLMBridge.PluginCompletionContext): Promise<any>;
-    createLogFiles(requestId: string, type: 'request' | 'response', data: any): void;
-    createTxtFile(filePath: string, data: any): void;
-    objectToTxt(obj: any, prefix?: string): string;
+    private writeJsonLog;
+    private writeXmlLog;
+    private logError;
+    private getDailyFolder;
+    private buildXml;
+    private parseArguments;
+    private appendCdata;
+    private appendArguments;
+    private appendRawArguments;
+    private sanitizeAttribute;
+    private cleanXmlString;
 }
 
-export { LoggingPlugin, type LoggingPluginOptions, generateRandomDigits };
+export { type Logger, LoggingPlugin, type LoggingPluginOptions, generateRandomDigits };

package/dist/index.js

@@ -36,73 +36,222 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/logging.ts
-var import_path = __toESM(require("path"));
-var import_fs = __toESM(require("fs"));
-var import_crypto = require("crypto");
+var import_node_path = __toESM(require("path"));
+var import_node_fs = __toESM(require("fs"));
+var import_node_crypto = require("crypto");
 var import_moment = __toESM(require("moment"));
+var import_xmlbuilder2 = require("xmlbuilder2");
 function generateRandomDigits(length) {
-  return (0, import_crypto.randomBytes)(Math.ceil(length / 2)).toString("hex").slice(0, length);
+  return (0, import_node_crypto.randomBytes)(Math.ceil(length / 2)).toString("hex").slice(0, length);
 }
 var LoggingPlugin = class {
   constructor(options) {
     this.options = options;
+    this.logger = options.logger;
+  }
+  log(message) {
+    if (!this.logger) {
+      return;
+    }
+    const logFn = this.logger.info || this.logger.log;
+    if (logFn) {
+      logFn.call(this.logger, message);
+    }
   }
   async wrapRun(next, context) {
-    console.log("run", context.model);
+    this.log(`run ${context.model}`);
     const response = await next();
-    const lastResponsePath = import_path.default.join(this.options.folder, "last_response.json");
-    import_fs.default.writeFileSync(lastResponsePath, JSON.stringify(response, null, 2));
+    const lastResponsePath = import_node_path.default.join(this.options.folder, "last_response.json");
+    import_node_fs.default.writeFileSync(lastResponsePath, JSON.stringify(response, null, 2));
     return response;
   }
-  async wrapExec(next, params, context) {
+  async wrapExec(next, params, _context) {
     const requestId = generateRandomDigits(4);
-    this.createLogFiles(requestId, "request", params);
+    const requestTime = (0, import_moment.default)();
+    this.writeJsonLog(requestTime, requestId, "request", params);
+    this.writeXmlLog(requestTime, requestId, params, void 0);
     const response = await next(params);
-    this.createLogFiles(requestId, "response", response);
+    this.writeJsonLog((0, import_moment.default)(), requestId, "response", response);
+    this.writeXmlLog(requestTime, requestId, params, response);
     return response;
   }
   async wrapToolExec(next, tool, counter, input, context) {
-    console.log(`run (${counter + 1}/${context.options.tools?.usesLimit}) tool ${tool.name}`, input);
+    this.log(`run (${counter + 1}/${context.options.tools?.usesLimit}) tool ${tool.name} ${JSON.stringify(input)}`);
     const result = await next(tool, counter, input);
-    console.log(`tool response`, result);
+    this.log(`tool response ${JSON.stringify(result)}`);
     return result;
   }
-  createLogFiles(requestId, type, data) {
-    const currentDate = (0, import_moment.default)();
-    const dateString = currentDate.format("YYYY_MM_DD");
-    const timeString = currentDate.format("YYYY_MM_DD_HH_mm_ss");
-    const dailyDir = import_path.default.join(this.options.folder, dateString);
-    if (!import_fs.default.existsSync(dailyDir)) {
-      import_fs.default.mkdirSync(dailyDir, { recursive: true });
-    }
+  writeJsonLog(date, requestId, type, data) {
+    const { dailyDir, timeString } = this.getDailyFolder(date);
     const fileName = `${timeString}_${requestId}.${type}.json`;
-    const filePath = import_path.default.join(dailyDir, fileName);
-    import_fs.default.writeFileSync(filePath, JSON.stringify(data, null, 2));
-    if (type === "request") {
-      this.createTxtFile(filePath, data);
+    const filePath = import_node_path.default.join(dailyDir, fileName);
+    import_node_fs.default.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  }
+  writeXmlLog(date, requestId, params, response) {
+    try {
+      const { dailyDir, timeString } = this.getDailyFolder(date);
+      const xmlFileName = `${timeString}_${requestId}.xml`;
+      const xmlPath = import_node_path.default.join(dailyDir, xmlFileName);
+      const xml = this.buildXml(params, response);
+      import_node_fs.default.writeFileSync(xmlPath, xml);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logError(`[LLM] Error saving XML log: ${errorMessage}`, error);
     }
   }
-  createTxtFile(filePath, data) {
-    const txtContent = this.objectToTxt(data);
-    const txtFilePath = filePath.replace(".json", ".txt");
-    import_fs.default.writeFileSync(txtFilePath, txtContent);
-  }
-  objectToTxt(obj, prefix = "") {
-    let result = "";
-    for (const [key, value] of Object.entries(obj)) {
-      const newPrefix = prefix ? `${prefix}${key}` : key;
-      if (typeof value === "object" && value !== null) {
-        result += `[${newPrefix}]
-${this.objectToTxt(value, `${newPrefix}.`)}
-`;
-      } else {
-        result += `[${newPrefix}]
-${value}
-
-`;
+  logError(message, error) {
+    if (!this.logger) {
+      return;
+    }
+    const stack = error instanceof Error && error.stack ? `
+${error.stack}` : "";
+    const fullMessage = `${message}${stack}`;
+    const logFn = this.logger.error || this.logger.warn || this.logger.log;
+    if (logFn) {
+      logFn.call(this.logger, fullMessage);
+    }
+  }
+  getDailyFolder(date) {
+    const dateString = date.format("YYYY_MM_DD");
+    const timeString = date.format("YYYY_MM_DD_HH_mm_ss");
+    const dailyDir = import_node_path.default.join(this.options.folder, dateString);
+    if (!import_node_fs.default.existsSync(dailyDir)) {
+      import_node_fs.default.mkdirSync(dailyDir, { recursive: true });
+    }
+    return { dailyDir, timeString };
+  }
+  buildXml(params, response) {
+    const root = (0, import_xmlbuilder2.create)({ version: "1.0", encoding: "UTF-8" }).ele("root");
+    let toolsUsed = false;
+    const requestElem = root.ele("request");
+    const messages = Array.isArray(params?.messages) ? params.messages : [];
+    for (const message of messages) {
+      if (!message || typeof message !== "object") {
+        continue;
+      }
+      const messageElem = requestElem.ele("message", { role: this.sanitizeAttribute(message.role) });
+      if (message.role === "tool" && message.tool_call_id !== void 0) {
+        messageElem.att("tool_call_id", this.sanitizeAttribute(message.tool_call_id));
+      }
+      const content = message.content;
+      if (typeof content === "string") {
+        this.appendCdata(messageElem, content);
+      } else if (Array.isArray(content)) {
+        const textParts = content.filter((part) => part && typeof part === "object" && part.type === "text").map((part) => part.text ?? "").filter((text) => text.length > 0);
+        if (textParts.length > 0) {
+          this.appendCdata(messageElem, textParts.join("\n"));
+        }
+      }
+      if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+        toolsUsed = true;
+        const toolCallsElem = messageElem.ele("tool_calls");
+        for (const toolCall of message.tool_calls) {
+          if (!toolCall || typeof toolCall !== "object") {
+            continue;
+          }
+          const toolElem = toolCallsElem.ele("tool_call");
+          if (toolCall.id) {
+            toolElem.att("id", this.sanitizeAttribute(toolCall.id));
+          }
+          const functionData = toolCall.function ?? {};
+          if (functionData.name) {
+            toolElem.att("function_name", this.sanitizeAttribute(functionData.name));
+          }
+          const args = this.parseArguments(functionData.arguments);
+          if (args && typeof args === "object") {
+            this.appendArguments(toolElem, args);
+          } else if (functionData.arguments !== void 0) {
+            this.appendRawArguments(toolElem, functionData.arguments);
+          }
+        }
       }
     }
-    return result;
+    if (response) {
+      const responseElem = root.ele("response");
+      const responseMessageElem = responseElem.ele("message", { role: "assistant" });
+      const responseMessage = response?.choices?.[0]?.message;
+      const responseContent = responseMessage?.content;
+      if (typeof responseContent === "string") {
+        this.appendCdata(responseMessageElem, responseContent);
+      }
+      const responseToolCalls = responseMessage?.tool_calls;
+      if (Array.isArray(responseToolCalls) && responseToolCalls.length > 0) {
+        toolsUsed = true;
+        const toolCallsElem = responseMessageElem.ele("tool_calls");
+        for (const toolCall of responseToolCalls) {
+          const functionData = toolCall?.function;
+          const functionName = functionData?.name;
+          if (!functionName || functionName === "null") {
+            continue;
+          }
+          const toolElem = toolCallsElem.ele("tool_call");
+          if (toolCall?.id) {
+            toolElem.att("id", this.sanitizeAttribute(toolCall.id));
+          }
+          toolElem.att("function_name", this.sanitizeAttribute(functionName));
+          const args = this.parseArguments(functionData?.arguments);
+          if (args && typeof args === "object") {
+            this.appendArguments(toolElem, args);
+          } else if (functionData?.arguments !== void 0) {
+            this.appendRawArguments(toolElem, functionData.arguments);
+          }
+        }
+      }
+    }
+    if (toolsUsed) {
+      root.att("tools_used", "true");
+    }
+    return root.end({ prettyPrint: true });
+  }
+  parseArguments(argumentsValue) {
+    if (typeof argumentsValue !== "string") {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(argumentsValue);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  appendCdata(target, value) {
+    const cleaned = this.cleanXmlString(value);
+    if (!cleaned) {
+      return;
+    }
+    const parts = cleaned.split("]]>");
+    parts.forEach((part, index) => {
+      if (part.length > 0) {
+        target.dat(part);
+      }
+      if (index < parts.length - 1) {
+        target.txt("]]>");
+      }
+    });
+  }
+  appendArguments(toolElem, args) {
+    const argsElem = toolElem.ele("arguments");
+    for (const [key, value] of Object.entries(args)) {
+      const argElem = argsElem.ele("arg", { name: this.sanitizeAttribute(key) });
+      this.appendCdata(argElem, value);
+    }
+  }
+  appendRawArguments(toolElem, argumentsValue) {
+    const argsElem = toolElem.ele("arguments");
+    this.appendCdata(argsElem, argumentsValue);
+  }
+  sanitizeAttribute(value) {
+    return this.cleanXmlString(value);
+  }
+  cleanXmlString(value) {
+    const text = typeof value === "string" ? value : String(value ?? "");
+    return [...text].filter((char) => {
+      const code = char.codePointAt(0) ?? 0;
+      return char === "	" || char === "\n" || char === "\r" || code >= 32 && code <= 55295 || code >= 57344 && code <= 65533 || code >= 65536 && code <= 1114111;
+    }).join("");
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.mjs

@@ -1,71 +1,220 @@
 // src/logging.ts
-import path from "path";
-import fs from "fs";
-import { randomBytes } from "crypto";
+import path from "node:path";
+import fs from "node:fs";
+import { randomBytes } from "node:crypto";
 import moment from "moment";
+import { create } from "xmlbuilder2";
 function generateRandomDigits(length) {
   return randomBytes(Math.ceil(length / 2)).toString("hex").slice(0, length);
 }
 var LoggingPlugin = class {
   constructor(options) {
     this.options = options;
+    this.logger = options.logger;
+  }
+  log(message) {
+    if (!this.logger) {
+      return;
+    }
+    const logFn = this.logger.info || this.logger.log;
+    if (logFn) {
+      logFn.call(this.logger, message);
+    }
   }
   async wrapRun(next, context) {
-    console.log("run", context.model);
+    this.log(`run ${context.model}`);
     const response = await next();
     const lastResponsePath = path.join(this.options.folder, "last_response.json");
     fs.writeFileSync(lastResponsePath, JSON.stringify(response, null, 2));
     return response;
   }
-  async wrapExec(next, params, context) {
+  async wrapExec(next, params, _context) {
     const requestId = generateRandomDigits(4);
-    this.createLogFiles(requestId, "request", params);
+    const requestTime = moment();
+    this.writeJsonLog(requestTime, requestId, "request", params);
+    this.writeXmlLog(requestTime, requestId, params, void 0);
     const response = await next(params);
-    this.createLogFiles(requestId, "response", response);
+    this.writeJsonLog(moment(), requestId, "response", response);
+    this.writeXmlLog(requestTime, requestId, params, response);
     return response;
   }
   async wrapToolExec(next, tool, counter, input, context) {
-    console.log(`run (${counter + 1}/${context.options.tools?.usesLimit}) tool ${tool.name}`, input);
+    this.log(`run (${counter + 1}/${context.options.tools?.usesLimit}) tool ${tool.name} ${JSON.stringify(input)}`);
     const result = await next(tool, counter, input);
-    console.log(`tool response`, result);
+    this.log(`tool response ${JSON.stringify(result)}`);
     return result;
   }
-  createLogFiles(requestId, type, data) {
-    const currentDate = moment();
-    const dateString = currentDate.format("YYYY_MM_DD");
-    const timeString = currentDate.format("YYYY_MM_DD_HH_mm_ss");
+  writeJsonLog(date, requestId, type, data) {
+    const { dailyDir, timeString } = this.getDailyFolder(date);
+    const fileName = `${timeString}_${requestId}.${type}.json`;
+    const filePath = path.join(dailyDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  }
+  writeXmlLog(date, requestId, params, response) {
+    try {
+      const { dailyDir, timeString } = this.getDailyFolder(date);
+      const xmlFileName = `${timeString}_${requestId}.xml`;
+      const xmlPath = path.join(dailyDir, xmlFileName);
+      const xml = this.buildXml(params, response);
+      fs.writeFileSync(xmlPath, xml);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logError(`[LLM] Error saving XML log: ${errorMessage}`, error);
+    }
+  }
+  logError(message, error) {
+    if (!this.logger) {
+      return;
+    }
+    const stack = error instanceof Error && error.stack ? `
+${error.stack}` : "";
+    const fullMessage = `${message}${stack}`;
+    const logFn = this.logger.error || this.logger.warn || this.logger.log;
+    if (logFn) {
+      logFn.call(this.logger, fullMessage);
+    }
+  }
+  getDailyFolder(date) {
+    const dateString = date.format("YYYY_MM_DD");
+    const timeString = date.format("YYYY_MM_DD_HH_mm_ss");
     const dailyDir = path.join(this.options.folder, dateString);
     if (!fs.existsSync(dailyDir)) {
       fs.mkdirSync(dailyDir, { recursive: true });
     }
-    const fileName = `${timeString}_${requestId}.${type}.json`;
-    const filePath = path.join(dailyDir, fileName);
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-    if (type === "request") {
-      this.createTxtFile(filePath, data);
+    return { dailyDir, timeString };
+  }
+  buildXml(params, response) {
+    const root = create({ version: "1.0", encoding: "UTF-8" }).ele("root");
+    let toolsUsed = false;
+    const requestElem = root.ele("request");
+    const messages = Array.isArray(params?.messages) ? params.messages : [];
+    for (const message of messages) {
+      if (!message || typeof message !== "object") {
+        continue;
+      }
+      const messageElem = requestElem.ele("message", { role: this.sanitizeAttribute(message.role) });
+      if (message.role === "tool" && message.tool_call_id !== void 0) {
+        messageElem.att("tool_call_id", this.sanitizeAttribute(message.tool_call_id));
+      }
+      const content = message.content;
+      if (typeof content === "string") {
+        this.appendCdata(messageElem, content);
+      } else if (Array.isArray(content)) {
+        const textParts = content.filter((part) => part && typeof part === "object" && part.type === "text").map((part) => part.text ?? "").filter((text) => text.length > 0);
+        if (textParts.length > 0) {
+          this.appendCdata(messageElem, textParts.join("\n"));
+        }
+      }
+      if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+        toolsUsed = true;
+        const toolCallsElem = messageElem.ele("tool_calls");
+        for (const toolCall of message.tool_calls) {
+          if (!toolCall || typeof toolCall !== "object") {
+            continue;
+          }
+          const toolElem = toolCallsElem.ele("tool_call");
+          if (toolCall.id) {
+            toolElem.att("id", this.sanitizeAttribute(toolCall.id));
+          }
+          const functionData = toolCall.function ?? {};
+          if (functionData.name) {
+            toolElem.att("function_name", this.sanitizeAttribute(functionData.name));
+          }
+          const args = this.parseArguments(functionData.arguments);
+          if (args && typeof args === "object") {
+            this.appendArguments(toolElem, args);
+          } else if (functionData.arguments !== void 0) {
+            this.appendRawArguments(toolElem, functionData.arguments);
+          }
+        }
+      }
+    }
+    if (response) {
+      const responseElem = root.ele("response");
+      const responseMessageElem = responseElem.ele("message", { role: "assistant" });
+      const responseMessage = response?.choices?.[0]?.message;
+      const responseContent = responseMessage?.content;
+      if (typeof responseContent === "string") {
+        this.appendCdata(responseMessageElem, responseContent);
+      }
+      const responseToolCalls = responseMessage?.tool_calls;
+      if (Array.isArray(responseToolCalls) && responseToolCalls.length > 0) {
+        toolsUsed = true;
+        const toolCallsElem = responseMessageElem.ele("tool_calls");
+        for (const toolCall of responseToolCalls) {
+          const functionData = toolCall?.function;
+          const functionName = functionData?.name;
+          if (!functionName || functionName === "null") {
+            continue;
+          }
+          const toolElem = toolCallsElem.ele("tool_call");
+          if (toolCall?.id) {
+            toolElem.att("id", this.sanitizeAttribute(toolCall.id));
+          }
+          toolElem.att("function_name", this.sanitizeAttribute(functionName));
+          const args = this.parseArguments(functionData?.arguments);
+          if (args && typeof args === "object") {
+            this.appendArguments(toolElem, args);
+          } else if (functionData?.arguments !== void 0) {
+            this.appendRawArguments(toolElem, functionData.arguments);
+          }
+        }
+      }
     }
+    if (toolsUsed) {
+      root.att("tools_used", "true");
+    }
+    return root.end({ prettyPrint: true });
   }
-  createTxtFile(filePath, data) {
-    const txtContent = this.objectToTxt(data);
-    const txtFilePath = filePath.replace(".json", ".txt");
-    fs.writeFileSync(txtFilePath, txtContent);
-  }
-  objectToTxt(obj, prefix = "") {
-    let result = "";
-    for (const [key, value] of Object.entries(obj)) {
-      const newPrefix = prefix ? `${prefix}${key}` : key;
-      if (typeof value === "object" && value !== null) {
-        result += `[${newPrefix}]
-${this.objectToTxt(value, `${newPrefix}.`)}
-`;
-      } else {
-        result += `[${newPrefix}]
-${value}
-
-`;
+  parseArguments(argumentsValue) {
+    if (typeof argumentsValue !== "string") {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(argumentsValue);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
       }
+      return null;
+    } catch (error) {
+      return null;
     }
-    return result;
+  }
+  appendCdata(target, value) {
+    const cleaned = this.cleanXmlString(value);
+    if (!cleaned) {
+      return;
+    }
+    const parts = cleaned.split("]]>");
+    parts.forEach((part, index) => {
+      if (part.length > 0) {
+        target.dat(part);
+      }
+      if (index < parts.length - 1) {
+        target.txt("]]>");
+      }
+    });
+  }
+  appendArguments(toolElem, args) {
+    const argsElem = toolElem.ele("arguments");
+    for (const [key, value] of Object.entries(args)) {
+      const argElem = argsElem.ele("arg", { name: this.sanitizeAttribute(key) });
+      this.appendCdata(argElem, value);
+    }
+  }
+  appendRawArguments(toolElem, argumentsValue) {
+    const argsElem = toolElem.ele("arguments");
+    this.appendCdata(argsElem, argumentsValue);
+  }
+  sanitizeAttribute(value) {
+    return this.cleanXmlString(value);
+  }
+  cleanXmlString(value) {
+    const text = typeof value === "string" ? value : String(value ?? "");
+    return [...text].filter((char) => {
+      const code = char.codePointAt(0) ?? 0;
+      return char === "	" || char === "\n" || char === "\r" || code >= 32 && code <= 55295 || code >= 57344 && code <= 65533 || code >= 65536 && code <= 1114111;
+    }).join("");
   }
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmbridge/plugin-logging",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Logging plugin for LLMBridge",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -24,7 +24,8 @@
     "access": "public"
   },
   "dependencies": {
-    "moment": "^2.30.1"
+    "moment": "^2.30.1",
+    "xmlbuilder2": "^3.1.1"
   },
   "peerDependencies": {
     "@llmbridge/core": ">=0.1.0 <0.2.0",