@llmbridge/plugin-logging 0.1.1 → 0.1.3

package/dist/index.d.mts

@@ -15,14 +15,24 @@ declare function generateRandomDigits(length: number): string;
 declare class LoggingPlugin implements LLMBridge.Plugin<void, string, void, void> {
     private options;
     private logger;
+    private runSessions;
     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>;
     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 writeSessionXml;
+    private logError;
+    private getDailyFolder;
+    private buildSessionXml;
+    private parseArguments;
+    private appendCdata;
+    private appendArguments;
+    private appendToolCalls;
+    private appendRawArguments;
+    private sanitizeAttribute;
+    private cleanXmlString;
 }
 
 export { type Logger, LoggingPlugin, type LoggingPluginOptions, generateRandomDigits };

package/dist/index.d.ts

@@ -15,14 +15,24 @@ declare function generateRandomDigits(length: number): string;
 declare class LoggingPlugin implements LLMBridge.Plugin<void, string, void, void> {
     private options;
     private logger;
+    private runSessions;
     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>;
     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 writeSessionXml;
+    private logError;
+    private getDailyFolder;
+    private buildSessionXml;
+    private parseArguments;
+    private appendCdata;
+    private appendArguments;
+    private appendToolCalls;
+    private appendRawArguments;
+    private sanitizeAttribute;
+    private cleanXmlString;
 }
 
 export { type Logger, LoggingPlugin, type LoggingPluginOptions, generateRandomDigits };

package/dist/index.js

@@ -36,15 +36,17 @@ __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.runSessions = /* @__PURE__ */ new Map();
     this.options = options;
     this.logger = options.logger;
   }
@@ -59,60 +61,239 @@ var LoggingPlugin = class {
   }
   async wrapRun(next, context) {
     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));
-    return response;
+    const session = {
+      startTime: (0, import_moment.default)(),
+      requestId: generateRandomDigits(4),
+      model: context.model,
+      turns: []
+    };
+    this.runSessions.set(context, session);
+    try {
+      const response = await next();
+      const lastResponsePath = import_node_path.default.join(this.options.folder, "last_response.json");
+      import_node_fs.default.writeFileSync(lastResponsePath, JSON.stringify(response, null, 2));
+      this.writeSessionXml(session);
+      return response;
+    } catch (error) {
+      this.writeSessionXml(session);
+      throw error;
+    } finally {
+      this.runSessions.delete(context);
+    }
   }
   async wrapExec(next, params, context) {
     const requestId = generateRandomDigits(4);
-    this.createLogFiles(requestId, "request", params);
+    const requestTime = (0, import_moment.default)();
+    const session = this.runSessions.get(context);
+    const turn = { request: params, response: void 0, toolExecutions: [] };
+    this.writeJsonLog(requestTime, requestId, "request", params);
+    if (session) {
+      session.turns.push(turn);
+      this.writeSessionXml(session);
+    }
     const response = await next(params);
-    this.createLogFiles(requestId, "response", response);
+    this.writeJsonLog((0, import_moment.default)(), requestId, "response", response);
+    if (session) {
+      turn.response = response;
+      this.writeSessionXml(session);
+    }
     return response;
   }
   async wrapToolExec(next, tool, counter, input, context) {
     this.log(`run (${counter + 1}/${context.options.tools?.usesLimit}) tool ${tool.name} ${JSON.stringify(input)}`);
     const result = await next(tool, counter, input);
     this.log(`tool response ${JSON.stringify(result)}`);
+    const session = this.runSessions.get(context);
+    if (session && session.turns.length > 0) {
+      const lastTurn = session.turns[session.turns.length - 1];
+      lastTurn.toolExecutions.push({ toolName: tool.name, counter, input, result });
+      this.writeSessionXml(session);
+    }
     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);
-    }
-  }
-  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}
-
-`;
+    const filePath = import_node_path.default.join(dailyDir, fileName);
+    import_node_fs.default.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  }
+  writeSessionXml(session) {
+    try {
+      const { dailyDir, timeString } = this.getDailyFolder(session.startTime);
+      const xmlFileName = `${timeString}_${session.requestId}.session.xml`;
+      const xmlPath = import_node_path.default.join(dailyDir, xmlFileName);
+      const xml = this.buildSessionXml(session);
+      import_node_fs.default.writeFileSync(xmlPath, xml);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logError(`[LLM] Error saving session 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 = 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 };
+  }
+  buildSessionXml(session) {
+    const root = (0, import_xmlbuilder2.create)({ version: "1.0", encoding: "UTF-8" }).ele("session", { model: this.sanitizeAttribute(session.model) });
+    let toolsUsed = false;
+    for (let i = 0; i < session.turns.length; i++) {
+      const turn = session.turns[i];
+      const turnElem = root.ele("turn", { number: String(i + 1) });
+      const requestElem = turnElem.ele("request");
+      const messages = Array.isArray(turn.request?.messages) ? turn.request.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;
+          this.appendToolCalls(messageElem, message.tool_calls);
+        }
+      }
+      if (turn.response) {
+        const responseElem = turnElem.ele("response");
+        const responseMessageElem = responseElem.ele("message", { role: "assistant" });
+        const responseMessage = turn.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;
+          this.appendToolCalls(responseMessageElem, responseToolCalls);
+        }
+      }
+      if (turn.toolExecutions.length > 0) {
+        toolsUsed = true;
+        const toolExecsElem = turnElem.ele("tool_executions");
+        for (const exec of turn.toolExecutions) {
+          const execElem = toolExecsElem.ele("tool_execution", {
+            name: this.sanitizeAttribute(exec.toolName),
+            counter: String(exec.counter)
+          });
+          const inputElem = execElem.ele("input");
+          if (exec.input && typeof exec.input === "object" && !Array.isArray(exec.input)) {
+            for (const [key, value] of Object.entries(exec.input)) {
+              const argElem = inputElem.ele("arg", { name: this.sanitizeAttribute(key) });
+              this.appendCdata(argElem, value);
+            }
+          } else {
+            this.appendCdata(inputElem, typeof exec.input === "object" ? JSON.stringify(exec.input) : exec.input);
+          }
+          const outputElem = execElem.ele("output");
+          this.appendCdata(outputElem, typeof exec.result === "object" ? JSON.stringify(exec.result) : exec.result);
+        }
       }
     }
-    return result;
+    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);
+    }
+  }
+  appendToolCalls(parentElem, toolCalls) {
+    const toolCallsElem = parentElem.ele("tool_calls");
+    for (const toolCall of toolCalls) {
+      if (!toolCall || typeof toolCall !== "object") {
+        continue;
+      }
+      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);
+      }
+    }
+  }
+  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,13 +1,15 @@
 // 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.runSessions = /* @__PURE__ */ new Map();
     this.options = options;
     this.logger = options.logger;
   }
@@ -22,60 +24,239 @@ var LoggingPlugin = class {
   }
   async wrapRun(next, context) {
     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;
+    const session = {
+      startTime: moment(),
+      requestId: generateRandomDigits(4),
+      model: context.model,
+      turns: []
+    };
+    this.runSessions.set(context, session);
+    try {
+      const response = await next();
+      const lastResponsePath = path.join(this.options.folder, "last_response.json");
+      fs.writeFileSync(lastResponsePath, JSON.stringify(response, null, 2));
+      this.writeSessionXml(session);
+      return response;
+    } catch (error) {
+      this.writeSessionXml(session);
+      throw error;
+    } finally {
+      this.runSessions.delete(context);
+    }
   }
   async wrapExec(next, params, context) {
     const requestId = generateRandomDigits(4);
-    this.createLogFiles(requestId, "request", params);
+    const requestTime = moment();
+    const session = this.runSessions.get(context);
+    const turn = { request: params, response: void 0, toolExecutions: [] };
+    this.writeJsonLog(requestTime, requestId, "request", params);
+    if (session) {
+      session.turns.push(turn);
+      this.writeSessionXml(session);
+    }
     const response = await next(params);
-    this.createLogFiles(requestId, "response", response);
+    this.writeJsonLog(moment(), requestId, "response", response);
+    if (session) {
+      turn.response = response;
+      this.writeSessionXml(session);
+    }
     return response;
   }
   async wrapToolExec(next, tool, counter, input, context) {
     this.log(`run (${counter + 1}/${context.options.tools?.usesLimit}) tool ${tool.name} ${JSON.stringify(input)}`);
     const result = await next(tool, counter, input);
     this.log(`tool response ${JSON.stringify(result)}`);
+    const session = this.runSessions.get(context);
+    if (session && session.turns.length > 0) {
+      const lastTurn = session.turns[session.turns.length - 1];
+      lastTurn.toolExecutions.push({ toolName: tool.name, counter, input, result });
+      this.writeSessionXml(session);
+    }
     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));
+  }
+  writeSessionXml(session) {
+    try {
+      const { dailyDir, timeString } = this.getDailyFolder(session.startTime);
+      const xmlFileName = `${timeString}_${session.requestId}.session.xml`;
+      const xmlPath = path.join(dailyDir, xmlFileName);
+      const xml = this.buildSessionXml(session);
+      fs.writeFileSync(xmlPath, xml);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logError(`[LLM] Error saving session 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);
-    }
-  }
-  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}
-
-`;
+    return { dailyDir, timeString };
+  }
+  buildSessionXml(session) {
+    const root = create({ version: "1.0", encoding: "UTF-8" }).ele("session", { model: this.sanitizeAttribute(session.model) });
+    let toolsUsed = false;
+    for (let i = 0; i < session.turns.length; i++) {
+      const turn = session.turns[i];
+      const turnElem = root.ele("turn", { number: String(i + 1) });
+      const requestElem = turnElem.ele("request");
+      const messages = Array.isArray(turn.request?.messages) ? turn.request.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;
+          this.appendToolCalls(messageElem, message.tool_calls);
+        }
+      }
+      if (turn.response) {
+        const responseElem = turnElem.ele("response");
+        const responseMessageElem = responseElem.ele("message", { role: "assistant" });
+        const responseMessage = turn.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;
+          this.appendToolCalls(responseMessageElem, responseToolCalls);
+        }
+      }
+      if (turn.toolExecutions.length > 0) {
+        toolsUsed = true;
+        const toolExecsElem = turnElem.ele("tool_executions");
+        for (const exec of turn.toolExecutions) {
+          const execElem = toolExecsElem.ele("tool_execution", {
+            name: this.sanitizeAttribute(exec.toolName),
+            counter: String(exec.counter)
+          });
+          const inputElem = execElem.ele("input");
+          if (exec.input && typeof exec.input === "object" && !Array.isArray(exec.input)) {
+            for (const [key, value] of Object.entries(exec.input)) {
+              const argElem = inputElem.ele("arg", { name: this.sanitizeAttribute(key) });
+              this.appendCdata(argElem, value);
+            }
+          } else {
+            this.appendCdata(inputElem, typeof exec.input === "object" ? JSON.stringify(exec.input) : exec.input);
+          }
+          const outputElem = execElem.ele("output");
+          this.appendCdata(outputElem, typeof exec.result === "object" ? JSON.stringify(exec.result) : exec.result);
+        }
       }
     }
-    return result;
+    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);
+    }
+  }
+  appendToolCalls(parentElem, toolCalls) {
+    const toolCallsElem = parentElem.ele("tool_calls");
+    for (const toolCall of toolCalls) {
+      if (!toolCall || typeof toolCall !== "object") {
+        continue;
+      }
+      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);
+      }
+    }
+  }
+  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.1",
+  "version": "0.1.3",
   "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",