@orka-js/devtools 1.1.0

package/dist/index.cjs

@@ -0,0 +1,857 @@
+"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 src_exports = {};
+__export(src_exports, {
+  DevToolsServer: () => DevToolsServer,
+  Trace: () => Trace,
+  TraceCollector: () => TraceCollector,
+  createDevToolsHook: () => createDevToolsHook,
+  createTracerWithDevTools: () => createTracerWithDevTools,
+  devtools: () => devtools,
+  getCollector: () => getCollector,
+  resetCollector: () => resetCollector,
+  trace: () => trace,
+  withTrace: () => withTrace
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/collector.ts
+var import_core = require("@orka-js/core");
+var TraceCollector = class {
+  sessions = /* @__PURE__ */ new Map();
+  activeSessionId;
+  runStack = /* @__PURE__ */ new Map();
+  maxTraces;
+  retentionMs;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(config = {}) {
+    this.maxTraces = config.maxTraces ?? 1e3;
+    this.retentionMs = config.retentionMs ?? 24 * 60 * 60 * 1e3;
+  }
+  /**
+   * Start a new trace session
+   */
+  startSession(name) {
+    const sessionId = (0, import_core.generateId)();
+    const session = {
+      id: sessionId,
+      name: name ?? `Session ${this.sessions.size + 1}`,
+      startTime: Date.now(),
+      runs: []
+    };
+    this.sessions.set(sessionId, session);
+    this.activeSessionId = sessionId;
+    this.runStack.set(sessionId, []);
+    this.emit({
+      type: "session:start",
+      timestamp: Date.now(),
+      sessionId
+    });
+    this.cleanup();
+    return sessionId;
+  }
+  /**
+   * End the current session
+   */
+  endSession(sessionId) {
+    const id = sessionId ?? this.activeSessionId;
+    if (!id) return;
+    const session = this.sessions.get(id);
+    if (session) {
+      session.endTime = Date.now();
+      this.emit({
+        type: "session:end",
+        timestamp: Date.now(),
+        sessionId: id
+      });
+    }
+    if (this.activeSessionId === id) {
+      this.activeSessionId = void 0;
+    }
+  }
+  /**
+   * Start a new trace run
+   */
+  startRun(type, name, input, metadata) {
+    const sessionId = this.activeSessionId ?? this.startSession();
+    const session = this.sessions.get(sessionId);
+    const stack = this.runStack.get(sessionId);
+    const run = {
+      id: (0, import_core.generateId)(),
+      parentId: stack.length > 0 ? stack[stack.length - 1].id : void 0,
+      type,
+      name,
+      startTime: Date.now(),
+      status: "running",
+      input,
+      metadata,
+      children: []
+    };
+    if (stack.length > 0) {
+      stack[stack.length - 1].children.push(run);
+    } else {
+      session.runs.push(run);
+    }
+    stack.push(run);
+    this.emit({
+      type: "run:start",
+      timestamp: Date.now(),
+      sessionId,
+      run
+    });
+    return run.id;
+  }
+  /**
+   * End a trace run
+   */
+  endRun(runId, output, metadata) {
+    const sessionId = this.activeSessionId;
+    if (!sessionId) return;
+    const stack = this.runStack.get(sessionId);
+    if (!stack) return;
+    const runIndex = stack.findIndex((r) => r.id === runId);
+    if (runIndex === -1) return;
+    const run = stack[runIndex];
+    run.endTime = Date.now();
+    run.latencyMs = run.endTime - run.startTime;
+    run.status = "success";
+    run.output = output;
+    if (metadata) {
+      run.metadata = { ...run.metadata, ...metadata };
+    }
+    stack.splice(runIndex, 1);
+    this.emit({
+      type: "run:end",
+      timestamp: Date.now(),
+      sessionId,
+      run
+    });
+  }
+  /**
+   * Mark a run as errored
+   */
+  errorRun(runId, error) {
+    const sessionId = this.activeSessionId;
+    if (!sessionId) return;
+    const stack = this.runStack.get(sessionId);
+    if (!stack) return;
+    const runIndex = stack.findIndex((r) => r.id === runId);
+    if (runIndex === -1) return;
+    const run = stack[runIndex];
+    run.endTime = Date.now();
+    run.latencyMs = run.endTime - run.startTime;
+    run.status = "error";
+    run.error = error instanceof Error ? error.message : error;
+    stack.splice(runIndex, 1);
+    this.emit({
+      type: "run:error",
+      timestamp: Date.now(),
+      sessionId,
+      run,
+      error: run.error
+    });
+  }
+  /**
+   * Get all sessions
+   */
+  getSessions() {
+    return Array.from(this.sessions.values());
+  }
+  /**
+   * Get a specific session
+   */
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  /**
+   * Get metrics for a session or all sessions
+   */
+  getMetrics(sessionId) {
+    const sessions = sessionId ? [this.sessions.get(sessionId)].filter(Boolean) : Array.from(this.sessions.values());
+    const metrics = {
+      totalRuns: 0,
+      totalLatencyMs: 0,
+      avgLatencyMs: 0,
+      totalTokens: 0,
+      totalCost: 0,
+      errorRate: 0,
+      runsByType: {},
+      tokensByModel: {},
+      costByModel: {}
+    };
+    let errorCount = 0;
+    const processRun = (run) => {
+      metrics.totalRuns++;
+      metrics.totalLatencyMs += run.latencyMs ?? 0;
+      if (run.status === "error") errorCount++;
+      metrics.runsByType[run.type] = (metrics.runsByType[run.type] ?? 0) + 1;
+      if (run.metadata) {
+        const { totalTokens, cost, model } = run.metadata;
+        if (totalTokens) {
+          metrics.totalTokens += totalTokens;
+          if (model) {
+            metrics.tokensByModel[model] = (metrics.tokensByModel[model] ?? 0) + totalTokens;
+          }
+        }
+        if (cost) {
+          metrics.totalCost += cost;
+          if (model) {
+            metrics.costByModel[model] = (metrics.costByModel[model] ?? 0) + cost;
+          }
+        }
+      }
+      for (const child of run.children) {
+        processRun(child);
+      }
+    };
+    for (const session of sessions) {
+      for (const run of session.runs) {
+        processRun(run);
+      }
+    }
+    metrics.avgLatencyMs = metrics.totalRuns > 0 ? metrics.totalLatencyMs / metrics.totalRuns : 0;
+    metrics.errorRate = metrics.totalRuns > 0 ? errorCount / metrics.totalRuns : 0;
+    return metrics;
+  }
+  /**
+   * Find a run by ID
+   */
+  findRun(runId, sessionId) {
+    const sessions = sessionId ? [this.sessions.get(sessionId)].filter(Boolean) : Array.from(this.sessions.values());
+    const findInRuns = (runs) => {
+      for (const run of runs) {
+        if (run.id === runId) return run;
+        const found = findInRuns(run.children);
+        if (found) return found;
+      }
+      return void 0;
+    };
+    for (const session of sessions) {
+      const found = findInRuns(session.runs);
+      if (found) return found;
+    }
+    return void 0;
+  }
+  /**
+   * Subscribe to trace events
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Emit an event to all listeners
+   */
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Cleanup old sessions
+   */
+  cleanup() {
+    const now = Date.now();
+    const cutoff = now - this.retentionMs;
+    for (const [id, session] of this.sessions) {
+      if (session.endTime && session.endTime < cutoff) {
+        this.sessions.delete(id);
+        this.runStack.delete(id);
+      }
+    }
+    if (this.sessions.size > this.maxTraces) {
+      const sorted = Array.from(this.sessions.entries()).sort((a, b) => a[1].startTime - b[1].startTime);
+      const toDelete = sorted.slice(0, this.sessions.size - this.maxTraces);
+      for (const [id] of toDelete) {
+        this.sessions.delete(id);
+        this.runStack.delete(id);
+      }
+    }
+  }
+  /**
+   * Clear all traces
+   */
+  clear() {
+    this.sessions.clear();
+    this.runStack.clear();
+    this.activeSessionId = void 0;
+  }
+  /**
+   * Export traces as JSON
+   */
+  export() {
+    return JSON.stringify({
+      sessions: Array.from(this.sessions.values()),
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2);
+  }
+  /**
+   * Import traces from JSON
+   */
+  import(json) {
+    const data = JSON.parse(json);
+    for (const session of data.sessions) {
+      this.sessions.set(session.id, session);
+    }
+  }
+};
+var globalCollector;
+function getCollector(config) {
+  if (!globalCollector) {
+    globalCollector = new TraceCollector(config);
+  }
+  return globalCollector;
+}
+function resetCollector() {
+  globalCollector = void 0;
+}
+
+// src/server.ts
+var DevToolsServer = class {
+  collector;
+  config;
+  server;
+  clients = /* @__PURE__ */ new Set();
+  constructor(collector, config = {}) {
+    this.collector = collector;
+    this.config = {
+      port: config.port ?? 3001,
+      host: config.host ?? "localhost",
+      cors: config.cors ?? true
+    };
+  }
+  /**
+   * Start the DevTools server
+   */
+  async start() {
+    let expressModule;
+    let httpModule;
+    try {
+      expressModule = await import("express");
+      httpModule = await import("http");
+    } catch {
+      throw new Error(
+        "Express is required for DevTools server. Install it with: npm install express"
+      );
+    }
+    const app = expressModule.default();
+    if (this.config.cors) {
+      app.use((_req, res, next) => {
+        res.header("Access-Control-Allow-Origin", "*");
+        res.header("Access-Control-Allow-Headers", "Content-Type");
+        res.header("Access-Control-Allow-Methods", "GET, POST, DELETE");
+        next();
+      });
+    }
+    app.use(expressModule.json());
+    this.setupRoutes(app);
+    this.server = httpModule.createServer(app);
+    await new Promise((resolve) => {
+      this.server.listen(this.config.port, this.config.host, () => {
+        console.log(`
+\u{1F50D} OrkaJS DevTools running at http://${this.config.host}:${this.config.port}
+`);
+        resolve();
+      });
+    });
+    this.collector.subscribe((event) => {
+      this.broadcastEvent(event);
+    });
+  }
+  /**
+   * Stop the server
+   */
+  async stop() {
+    if (this.server) {
+      await new Promise((resolve, reject) => {
+        this.server.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+      this.server = void 0;
+    }
+  }
+  /**
+   * Setup API routes
+   */
+  setupRoutes(app) {
+    app.get("/api/health", (_req, res) => {
+      res.json({ status: "ok", timestamp: Date.now() });
+    });
+    app.get("/api/sessions", (_req, res) => {
+      const sessions = this.collector.getSessions();
+      res.json(sessions);
+    });
+    app.get("/api/sessions/:id", (req, res) => {
+      const session = this.collector.getSession(req.params.id);
+      if (!session) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      res.json(session);
+    });
+    app.get("/api/metrics", (req, res) => {
+      const sessionId = req.query.sessionId;
+      const metrics = this.collector.getMetrics(sessionId);
+      res.json(metrics);
+    });
+    app.get("/api/runs/:id", (req, res) => {
+      const sessionId = req.query.sessionId;
+      const run = this.collector.findRun(req.params.id, sessionId);
+      if (!run) {
+        res.status(404).json({ error: "Run not found" });
+        return;
+      }
+      res.json(run);
+    });
+    app.delete("/api/sessions", (_req, res) => {
+      this.collector.clear();
+      res.json({ success: true });
+    });
+    app.get("/api/export", (_req, res) => {
+      const data = this.collector.export();
+      res.setHeader("Content-Type", "application/json");
+      res.setHeader("Content-Disposition", "attachment; filename=orka-traces.json");
+      res.send(data);
+    });
+    app.post("/api/import", (req, res) => {
+      try {
+        this.collector.import(JSON.stringify(req.body));
+        res.json({ success: true });
+      } catch {
+        res.status(400).json({ error: "Invalid trace data" });
+      }
+    });
+    app.get("/api/events", (req, res) => {
+      res.setHeader("Content-Type", "text/event-stream");
+      res.setHeader("Cache-Control", "no-cache");
+      res.setHeader("Connection", "keep-alive");
+      this.clients.add(res);
+      req.on("close", () => {
+        this.clients.delete(res);
+      });
+    });
+    app.get("/", (_req, res) => {
+      res.send(this.getDashboardHTML());
+    });
+  }
+  /**
+   * Broadcast event to all SSE clients
+   */
+  broadcastEvent(event) {
+    const data = JSON.stringify(event);
+    for (const client of this.clients) {
+      client.write(`data: ${data}
+
+`);
+    }
+  }
+  /**
+   * Get embedded dashboard HTML
+   */
+  getDashboardHTML() {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OrkaJS DevTools</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+  <style>
+    .tree-line { border-left: 2px solid #e2e8f0; }
+    .dark .tree-line { border-left-color: #334155; }
+  </style>
+</head>
+<body class="bg-slate-50 dark:bg-slate-900 text-slate-900 dark:text-white min-h-screen">
+  <div id="app" class="max-w-7xl mx-auto p-6">
+    <header class="flex items-center justify-between mb-8">
+      <div class="flex items-center gap-3">
+        <div class="w-10 h-10 bg-gradient-to-br from-purple-500 to-pink-500 rounded-lg flex items-center justify-center">
+          <svg class="w-6 h-6 text-white" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9.75 17L9 20l-1 1h8l-1-1-.75-3M3 13h18M5 17h14a2 2 0 002-2V5a2 2 0 00-2-2H5a2 2 0 00-2 2v10a2 2 0 002 2z"/>
+          </svg>
+        </div>
+        <div>
+          <h1 class="text-2xl font-bold">OrkaJS DevTools</h1>
+          <p class="text-sm text-slate-500">Real-time LLM observability</p>
+        </div>
+      </div>
+      <div class="flex items-center gap-4">
+        <span id="status" class="flex items-center gap-2 text-sm">
+          <span class="w-2 h-2 bg-green-500 rounded-full animate-pulse"></span>
+          Connected
+        </span>
+        <button onclick="clearTraces()" class="px-3 py-1.5 text-sm bg-red-500/10 text-red-500 rounded-lg hover:bg-red-500/20">
+          Clear
+        </button>
+        <button onclick="exportTraces()" class="px-3 py-1.5 text-sm bg-purple-500/10 text-purple-500 rounded-lg hover:bg-purple-500/20">
+          Export
+        </button>
+      </div>
+    </header>
+
+    <!-- Metrics -->
+    <div id="metrics" class="grid grid-cols-4 gap-4 mb-8">
+      <div class="bg-white dark:bg-slate-800 rounded-xl p-4 shadow-sm">
+        <p class="text-sm text-slate-500 mb-1">Total Runs</p>
+        <p id="metric-runs" class="text-2xl font-bold">0</p>
+      </div>
+      <div class="bg-white dark:bg-slate-800 rounded-xl p-4 shadow-sm">
+        <p class="text-sm text-slate-500 mb-1">Avg Latency</p>
+        <p id="metric-latency" class="text-2xl font-bold">0ms</p>
+      </div>
+      <div class="bg-white dark:bg-slate-800 rounded-xl p-4 shadow-sm">
+        <p class="text-sm text-slate-500 mb-1">Total Tokens</p>
+        <p id="metric-tokens" class="text-2xl font-bold">0</p>
+      </div>
+      <div class="bg-white dark:bg-slate-800 rounded-xl p-4 shadow-sm">
+        <p class="text-sm text-slate-500 mb-1">Error Rate</p>
+        <p id="metric-errors" class="text-2xl font-bold">0%</p>
+      </div>
+    </div>
+
+    <!-- Sessions & Traces -->
+    <div class="grid grid-cols-3 gap-6">
+      <div class="col-span-1">
+        <h2 class="text-lg font-semibold mb-4">Sessions</h2>
+        <div id="sessions" class="space-y-2"></div>
+      </div>
+      <div class="col-span-2">
+        <h2 class="text-lg font-semibold mb-4">Trace Viewer</h2>
+        <div id="traces" class="bg-white dark:bg-slate-800 rounded-xl p-4 shadow-sm min-h-[400px]">
+          <p class="text-slate-500 text-center py-8">Select a session to view traces</p>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    let selectedSession = null;
+
+    // SSE connection
+    const events = new EventSource('/api/events');
+    events.onmessage = (e) => {
+      const event = JSON.parse(e.data);
+      console.log('Event:', event);
+      refreshData();
+    };
+    events.onerror = () => {
+      document.getElementById('status').innerHTML = '<span class="w-2 h-2 bg-red-500 rounded-full"></span> Disconnected';
+    };
+
+    async function refreshData() {
+      // Fetch metrics
+      const metrics = await fetch('/api/metrics').then(r => r.json());
+      document.getElementById('metric-runs').textContent = metrics.totalRuns;
+      document.getElementById('metric-latency').textContent = Math.round(metrics.avgLatencyMs) + 'ms';
+      document.getElementById('metric-tokens').textContent = metrics.totalTokens.toLocaleString();
+      document.getElementById('metric-errors').textContent = (metrics.errorRate * 100).toFixed(1) + '%';
+
+      // Fetch sessions
+      const sessions = await fetch('/api/sessions').then(r => r.json());
+      renderSessions(sessions);
+
+      if (selectedSession) {
+        const session = await fetch('/api/sessions/' + selectedSession).then(r => r.json());
+        renderTraces(session.runs);
+      }
+    }
+
+    function renderSessions(sessions) {
+      const container = document.getElementById('sessions');
+      container.innerHTML = sessions.map(s => \`
+        <div onclick="selectSession('\${s.id}')" class="p-3 rounded-lg cursor-pointer \${selectedSession === s.id ? 'bg-purple-500/20 border border-purple-500' : 'bg-white dark:bg-slate-800 hover:bg-slate-100 dark:hover:bg-slate-700'}">
+          <p class="font-medium">\${s.name || 'Session'}</p>
+          <p class="text-xs text-slate-500">\${s.runs.length} runs \u2022 \${new Date(s.startTime).toLocaleTimeString()}</p>
+        </div>
+      \`).join('');
+    }
+
+    function selectSession(id) {
+      selectedSession = id;
+      refreshData();
+    }
+
+    function renderTraces(runs, depth = 0) {
+      if (!runs || runs.length === 0) {
+        document.getElementById('traces').innerHTML = '<p class="text-slate-500 text-center py-8">No traces in this session</p>';
+        return;
+      }
+
+      const html = runs.map(run => renderRun(run, depth)).join('');
+      document.getElementById('traces').innerHTML = html;
+    }
+
+    function renderRun(run, depth) {
+      const statusColor = run.status === 'success' ? 'bg-green-500' : run.status === 'error' ? 'bg-red-500' : 'bg-yellow-500';
+      const typeColors = {
+        llm: 'text-purple-500',
+        agent: 'text-blue-500',
+        tool: 'text-orange-500',
+        retrieval: 'text-green-500',
+        chain: 'text-pink-500',
+      };
+
+      return \`
+        <div class="mb-2" style="margin-left: \${depth * 20}px">
+          <div class="flex items-center gap-2 p-2 rounded-lg hover:bg-slate-100 dark:hover:bg-slate-700">
+            <span class="w-2 h-2 rounded-full \${statusColor}"></span>
+            <span class="text-xs font-medium \${typeColors[run.type] || 'text-slate-500'}">\${run.type.toUpperCase()}</span>
+            <span class="font-medium">\${run.name}</span>
+            <span class="text-xs text-slate-500 ml-auto">\${run.latencyMs ? run.latencyMs + 'ms' : 'running...'}</span>
+            \${run.metadata?.totalTokens ? '<span class="text-xs text-slate-400">' + run.metadata.totalTokens + ' tokens</span>' : ''}
+          </div>
+          \${run.children.map(c => renderRun(c, depth + 1)).join('')}
+        </div>
+      \`;
+    }
+
+    async function clearTraces() {
+      await fetch('/api/sessions', { method: 'DELETE' });
+      selectedSession = null;
+      refreshData();
+    }
+
+    function exportTraces() {
+      window.open('/api/export', '_blank');
+    }
+
+    // Initial load
+    refreshData();
+  </script>
+</body>
+</html>`;
+  }
+};
+
+// src/tracer-hook.ts
+function mapEventType(type) {
+  const typeMap = {
+    "llm": "llm",
+    "llm_call": "llm",
+    "embedding": "embedding",
+    "retrieval": "retrieval",
+    "tool": "tool",
+    "tool_call": "tool",
+    "agent": "agent",
+    "agent_step": "agent",
+    "chain": "chain",
+    "workflow": "workflow",
+    "graph": "graph",
+    "node": "node"
+  };
+  return typeMap[type.toLowerCase()] ?? "custom";
+}
+function createDevToolsHook() {
+  const collector = getCollector();
+  const traceToSession = /* @__PURE__ */ new Map();
+  const eventToRun = /* @__PURE__ */ new Map();
+  return {
+    onTraceStart(trace2) {
+      const sessionId = collector.startSession(trace2.name);
+      traceToSession.set(trace2.id, sessionId);
+    },
+    onTraceEnd(trace2) {
+      const sessionId = traceToSession.get(trace2.id);
+      if (sessionId) {
+        collector.endSession(sessionId);
+        traceToSession.delete(trace2.id);
+      }
+    },
+    onEvent(event) {
+      const runType = mapEventType(event.type);
+      const metadata = {
+        ...event.metadata
+      };
+      if (event.usage) {
+        metadata.promptTokens = event.usage.promptTokens;
+        metadata.completionTokens = event.usage.completionTokens;
+        metadata.totalTokens = event.usage.totalTokens;
+      }
+      if (event.startTime && event.endTime) {
+        const runId = collector.startRun(runType, event.name, event.input, metadata);
+        collector.endRun(runId, event.output, {
+          ...metadata
+          // Override latency calculation since we have actual times
+        });
+        eventToRun.set(event.id, runId);
+      } else if (event.startTime && !event.endTime) {
+        const runId = collector.startRun(runType, event.name, event.input, metadata);
+        eventToRun.set(event.id, runId);
+      } else {
+        const runId = eventToRun.get(event.id);
+        if (runId) {
+          collector.endRun(runId, event.output, metadata);
+          eventToRun.delete(event.id);
+        }
+      }
+    },
+    onError(error, context) {
+      const sessions = collector.getSessions();
+      if (sessions.length > 0) {
+        const lastSession = sessions[sessions.length - 1];
+        if (lastSession.runs.length > 0) {
+          const findRunningRun = (runs) => {
+            for (const run of runs) {
+              if (run.status === "running") return run.id;
+              const childRun = findRunningRun(run.children);
+              if (childRun) return childRun;
+            }
+            return void 0;
+          };
+          const runningRunId = findRunningRun(lastSession.runs);
+          if (runningRunId) {
+            collector.errorRun(runningRunId, error);
+          }
+        }
+      }
+      if (context) {
+        console.error("[DevTools] Error context:", context);
+      }
+    }
+  };
+}
+function createTracerWithDevTools(options = {}) {
+  const hook = createDevToolsHook();
+  return {
+    hook,
+    config: {
+      ...options,
+      hooks: [hook]
+    }
+  };
+}
+
+// src/index.ts
+async function devtools(config = {}) {
+  const collector = getCollector(config);
+  const server = new DevToolsServer(collector, config);
+  await server.start();
+  if (config.open !== false) {
+    const url = `http://${config.host ?? "localhost"}:${config.port ?? 3001}`;
+    try {
+      const { exec } = await import("child_process");
+      const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      exec(`${command} ${url}`);
+    } catch {
+    }
+  }
+  return {
+    collector,
+    server,
+    stop: () => server.stop()
+  };
+}
+function withTrace(fn, options = {}) {
+  const collector = options.collector ?? getCollector();
+  const name = options.name ?? fn.name ?? "anonymous";
+  const type = options.type ?? "custom";
+  return (async (...args) => {
+    const runId = collector.startRun(type, name, args);
+    try {
+      const result = await fn(...args);
+      collector.endRun(runId, result);
+      return result;
+    } catch (error) {
+      collector.errorRun(runId, error);
+      throw error;
+    }
+  });
+}
+function Trace(options = {}) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const name = options.name ?? propertyKey;
+    const type = options.type ?? "custom";
+    descriptor.value = async function(...args) {
+      const collector = getCollector();
+      const runId = collector.startRun(type, name, args);
+      try {
+        const result = await originalMethod.apply(this, args);
+        collector.endRun(runId, result);
+        return result;
+      } catch (error) {
+        collector.errorRun(runId, error);
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+var trace = {
+  start(type, name, input, metadata) {
+    return getCollector().startRun(type, name, input, metadata);
+  },
+  end(runId, output, metadata) {
+    getCollector().endRun(runId, output, metadata);
+  },
+  error(runId, error) {
+    getCollector().errorRun(runId, error);
+  },
+  session(name) {
+    return getCollector().startSession(name);
+  },
+  endSession(sessionId) {
+    getCollector().endSession(sessionId);
+  },
+  /**
+   * Wrap an async function with tracing
+   */
+  async wrap(type, name, fn, metadata) {
+    const runId = getCollector().startRun(type, name, void 0, metadata);
+    try {
+      const result = await fn();
+      getCollector().endRun(runId, result);
+      return result;
+    } catch (error) {
+      getCollector().errorRun(runId, error);
+      throw error;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevToolsServer,
+  Trace,
+  TraceCollector,
+  createDevToolsHook,
+  createTracerWithDevTools,
+  devtools,
+  getCollector,
+  resetCollector,
+  trace,
+  withTrace
+});
+//# sourceMappingURL=index.cjs.map