@axon-ai/openai-tracer 1.0.3

package/dist/index.mjs

@@ -0,0 +1,386 @@
+// src/OpenAITracer.ts
+import { EventEmitter } from "events";
+import { v4 as uuidv4 } from "uuid";
+var OpenAITracer = class extends 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 = uuidv4();
+    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 = uuidv4();
+    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: uuidv4(),
+      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: uuidv4(),
+      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: uuidv4(),
+      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: uuidv4(),
+      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;
+    }
+  }
+};
+export {
+  OpenAITracer,
+  TracedOpenAI,
+  createOpenAITracer,
+  OpenAITracer as default
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@axon-ai/openai-tracer",
+  "version": "1.0.3",
+  "description": "OpenAI Function Calling tracer for Axon",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "openai",
+    "function-calling",
+    "tracing",
+    "agents",
+    "ai",
+    "monitoring"
+  ],
+  "author": "Axon Team",
+  "license": "MIT",
+  "dependencies": {
+    "uuid": "^9.0.1",
+    "socket.io-client": "^4.7.4"
+  },
+  "devDependencies": {
+    "@types/uuid": "^9.0.7",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "openai": "^4.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}