@axon-ai/openai-tracer 1.0.3

package/dist/index.js

@@ -0,0 +1,425 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OpenAITracer: () => OpenAITracer,
+  TracedOpenAI: () => TracedOpenAI,
+  createOpenAITracer: () => createOpenAITracer,
+  default: () => OpenAITracer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/OpenAITracer.ts
+var import_events = require("events");
+var import_uuid = require("uuid");
+var OpenAITracer = class extends import_events.EventEmitter {
+  /**
+   * Creates a new OpenAI tracer instance
+   * 
+   * @param config - Configuration object for the tracer
+   * @param config.projectName - Project name for organizing traces (default: 'openai-agent')
+   * @param config.endpoint - Backend server endpoint (default: 'http://localhost:3000')
+   * @param config.metadata - Additional metadata to include with all events
+   * @param config.autoConnect - Whether to automatically connect to the server (default: true)
+   */
+  constructor(config = {}) {
+    super();
+    this.eventQueue = [];
+    this.isConnected = false;
+    this.client = null;
+    this.flushInterval = null;
+    this.traceId = (0, import_uuid.v4)();
+    this.projectName = config.projectName || "openai-agent";
+    this.endpoint = config.endpoint || "http://localhost:3000";
+    this.metadata = config.metadata || {};
+    if (config.autoConnect !== false) {
+      this.connect();
+    }
+  }
+  /**
+   * Establishes WebSocket connection to the trace server
+   * 
+   * This method creates a Socket.IO client connection to the backend server,
+   * sets up event listeners for connection status, and starts the periodic
+   * event flushing mechanism.
+   * 
+   * @throws Error if connection fails
+   */
+  async connect() {
+    try {
+      const { io } = await import("socket.io-client");
+      this.client = io(this.endpoint, {
+        transports: ["websocket", "polling"],
+        timeout: 5e3
+      });
+      this.client.on("connect", () => {
+        this.isConnected = true;
+        this.emit("connected");
+        console.log(`[OpenAI Tracer] Connected to ${this.endpoint}`);
+      });
+      this.client.on("disconnect", () => {
+        this.isConnected = false;
+        this.emit("disconnected");
+        console.log("[OpenAI Tracer] Disconnected from server");
+      });
+      this.client.on("connect_error", (error) => {
+        console.error("[OpenAI Tracer] Connection error:", error);
+        this.emit("error", error);
+      });
+      this.flushInterval = setInterval(() => {
+        this.flushQueue();
+      }, 1e3);
+    } catch (error) {
+      console.error("[OpenAI Tracer] Connection failed:", error);
+      this.emit("error", error);
+    }
+  }
+  /**
+   * Disconnect from the trace server
+   */
+  disconnect() {
+    this.isConnected = false;
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+      this.flushInterval = null;
+    }
+    if (this.client) {
+      this.client.disconnect();
+      this.client = null;
+    }
+    this.emit("disconnected");
+  }
+  /**
+   * Records the start of a function call execution
+   * 
+   * This method creates and queues a function call start event, capturing
+   * the function name, arguments, model, messages, and available tools.
+   * It returns an event ID that can be used to correlate with the end event.
+   * 
+   * @param functionName - Name of the function being called
+   * @param functionArguments - Arguments passed to the function
+   * @param model - OpenAI model being used (e.g., 'gpt-4', 'gpt-3.5-turbo')
+   * @param messages - Array of conversation messages
+   * @param tools - Optional array of available tools
+   * @returns Event ID for correlating with the corresponding end event
+   */
+  traceFunctionCallStart(functionName, functionArguments, model, messages, tools) {
+    const eventId = (0, import_uuid.v4)();
+    const event = {
+      eventId,
+      traceId: this.traceId,
+      timestamp: Date.now(),
+      type: "function_call_start",
+      data: {
+        functionName,
+        arguments: JSON.stringify(functionArguments),
+        model,
+        messageCount: messages.length,
+        availableTools: tools?.map((t) => t.function.name) || [],
+        conversationContext: this.extractConversationContext(messages)
+      },
+      metadata: {
+        ...this.metadata,
+        projectName: this.projectName
+      }
+    };
+    this.addEvent(event);
+    return eventId;
+  }
+  /**
+   * Track function call end
+   */
+  traceFunctionCallEnd(eventId, result, cost, latency, tokens) {
+    const event = {
+      eventId: (0, import_uuid.v4)(),
+      traceId: this.traceId,
+      timestamp: Date.now(),
+      type: "function_call_end",
+      data: {
+        originalEventId: eventId,
+        result: typeof result === "string" ? result : JSON.stringify(result),
+        cost,
+        latency,
+        tokens: tokens || { prompt: 0, completion: 0, total: 0 },
+        success: true
+      },
+      metadata: {
+        ...this.metadata,
+        projectName: this.projectName
+      }
+    };
+    this.addEvent(event);
+  }
+  /**
+   * Track tool selection
+   */
+  traceToolSelection(availableTools, selectedTool, reasoning, confidence) {
+    const event = {
+      eventId: (0, import_uuid.v4)(),
+      traceId: this.traceId,
+      timestamp: Date.now(),
+      type: "tool_selection",
+      data: {
+        availableTools: availableTools.map((t) => ({
+          name: t.function.name,
+          description: t.function.description
+        })),
+        selectedTool: {
+          name: selectedTool.function.name,
+          description: selectedTool.function.description
+        },
+        reasoning,
+        confidence,
+        selectionTime: Date.now()
+      },
+      metadata: {
+        ...this.metadata,
+        projectName: this.projectName
+      }
+    };
+    this.addEvent(event);
+  }
+  /**
+   * Track conversation turn
+   */
+  traceConversationTurn(userMessage, assistantResponse, model, tokens, cost) {
+    const event = {
+      eventId: (0, import_uuid.v4)(),
+      traceId: this.traceId,
+      timestamp: Date.now(),
+      type: "conversation_turn",
+      data: {
+        userMessage,
+        assistantResponse,
+        model,
+        tokens: tokens || { prompt: 0, completion: 0, total: 0 },
+        cost: cost || 0,
+        turnNumber: this.getTurnNumber()
+      },
+      metadata: {
+        ...this.metadata,
+        projectName: this.projectName
+      }
+    };
+    this.addEvent(event);
+  }
+  /**
+   * Track error
+   */
+  traceError(error, context, functionName, functionArguments) {
+    const event = {
+      eventId: (0, import_uuid.v4)(),
+      traceId: this.traceId,
+      timestamp: Date.now(),
+      type: "error",
+      data: {
+        error: {
+          message: error.message,
+          stack: error.stack,
+          name: error.name
+        },
+        context,
+        functionName,
+        arguments: functionArguments ? JSON.stringify(functionArguments) : void 0
+      },
+      metadata: {
+        ...this.metadata,
+        projectName: this.projectName
+      }
+    };
+    this.addEvent(event);
+  }
+  /**
+   * Add event to queue
+   */
+  addEvent(event) {
+    this.eventQueue.push(event);
+    this.emit("event", event);
+  }
+  /**
+   * Flush events to server
+   */
+  async flushQueue() {
+    if (this.eventQueue.length === 0 || !this.isConnected || !this.client) {
+      return;
+    }
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    try {
+      console.log(`[OpenAI Tracer] Flushing ${events.length} events`);
+      this.client.emit("openai_events", {
+        traceId: this.traceId,
+        projectName: this.projectName,
+        events,
+        metadata: this.metadata
+      });
+      this.emit("events_sent", events);
+    } catch (error) {
+      console.error("[OpenAI Tracer] Failed to flush events:", error);
+      this.eventQueue.unshift(...events);
+    }
+  }
+  /**
+   * Extract conversation context from messages
+   */
+  extractConversationContext(messages) {
+    return {
+      messageCount: messages.length,
+      lastUserMessage: messages.filter((m) => m.role === "user").pop()?.content,
+      hasSystemMessage: messages.some((m) => m.role === "system"),
+      hasToolCalls: messages.some((m) => m.tool_calls && m.tool_calls.length > 0)
+    };
+  }
+  /**
+   * Get current turn number
+   */
+  getTurnNumber() {
+    return this.eventQueue.filter((e) => e.type === "conversation_turn").length + 1;
+  }
+  /**
+   * Calculate cost based on tokens and model
+   */
+  calculateCost(tokens, model) {
+    const pricing = {
+      "gpt-4": { prompt: 0.03, completion: 0.06 },
+      "gpt-4-turbo": { prompt: 0.01, completion: 0.03 },
+      "gpt-3.5-turbo": { prompt: 1e-3, completion: 2e-3 },
+      "gpt-3.5-turbo-16k": { prompt: 3e-3, completion: 4e-3 }
+    };
+    const prices = pricing[model] || pricing["gpt-3.5-turbo"];
+    return (tokens.prompt * prices.prompt + tokens.completion * prices.completion) / 1e3;
+  }
+  /**
+   * Get trace ID
+   */
+  getTraceId() {
+    return this.traceId;
+  }
+  /**
+   * Check if connected
+   */
+  isConnectedToServer() {
+    return this.isConnected;
+  }
+  /**
+   * Get current event queue size
+   */
+  getQueueSize() {
+    return this.eventQueue.length;
+  }
+  /**
+   * Clear event queue
+   */
+  clearQueue() {
+    this.eventQueue = [];
+  }
+  /**
+   * Shutdown tracer
+   */
+  async shutdown() {
+    await this.flushQueue();
+    this.disconnect();
+  }
+};
+function createOpenAITracer(config) {
+  return new OpenAITracer(config);
+}
+var TracedOpenAI = class {
+  constructor(openaiClient, tracer) {
+    this.openai = openaiClient;
+    this.tracer = tracer;
+  }
+  /**
+   * Traced chat completion with function calling
+   */
+  async createChatCompletion(params) {
+    const startTime = Date.now();
+    const eventId = this.tracer.traceFunctionCallStart(
+      "createChatCompletion",
+      params,
+      params.model,
+      params.messages,
+      params.tools
+    );
+    try {
+      const response = await this.openai.chat.completions.create(params);
+      const endTime = Date.now();
+      const latency = endTime - startTime;
+      const tokens = response.usage ? {
+        prompt: response.usage.prompt_tokens,
+        completion: response.usage.completion_tokens,
+        total: response.usage.total_tokens
+      } : { prompt: 0, completion: 0, total: 0 };
+      const cost = this.tracer.calculateCost(tokens, params.model);
+      this.tracer.traceFunctionCallEnd(eventId, response, cost, latency, tokens);
+      if (response.choices[0]?.message?.tool_calls) {
+        const selectedTool = params.tools?.find(
+          (t) => t.function.name === response.choices[0].message.tool_calls[0].function.name
+        );
+        if (selectedTool) {
+          this.tracer.traceToolSelection(
+            params.tools || [],
+            selectedTool,
+            "Model selected tool based on user request",
+            0.9
+            // High confidence for model selection
+          );
+        }
+      }
+      const userMessage = params.messages.filter((m) => m.role === "user").pop()?.content || "";
+      const assistantResponse = response.choices[0]?.message?.content || "";
+      if (userMessage && assistantResponse) {
+        this.tracer.traceConversationTurn(
+          userMessage,
+          assistantResponse,
+          params.model,
+          tokens,
+          cost
+        );
+      }
+      return response;
+    } catch (error) {
+      this.tracer.traceError(
+        error,
+        "createChatCompletion",
+        "createChatCompletion",
+        params
+      );
+      throw error;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenAITracer,
+  TracedOpenAI,
+  createOpenAITracer
+});