opik 0.0.4 → 0.0.6

package/README.md

@@ -0,0 +1,66 @@
+<h1 align="center" style="border-bottom: none">
+    <div>
+        <a href="https://www.comet.com/site/products/opik/?from=llm&utm_source=opik&utm_medium=github&utm_content=header_img&utm_campaign=opik"><picture>
+            <source media="(prefers-color-scheme: dark)" srcset="/apps/opik-documentation/documentation/static/img/logo-dark-mode.svg">
+            <source media="(prefers-color-scheme: light)" srcset="/apps/opik-documentation/documentation/static/img/opik-logo.svg">
+            <img alt="Comet Opik logo" src="/apps/opik-documentation/documentation/static/img/opik-logo.svg" width="200" />
+        </picture></a>
+        <br>
+        Opik
+    </div>
+    Open source LLM evaluation framework<br>
+</h1>
+
+## Installation
+
+You can install the `opik` package using your favorite package manager.
+
+```bash
+npm install opik
+```
+
+## Usage
+
+```typescript
+import { Opik } from "opik";
+
+// Create a new Opik client with your configuration
+const client = new Opik({
+  apiKey: "<your-api-key>",
+  host: "https://www.comet.com/opik/api",
+  projectName: "<your-project-name>",
+  workspaceName: "<your-workspace-name>",
+});
+
+// Log 10 traces
+for (let i = 0; i < 10; i++) {
+  const someTrace = client.trace({
+    name: `Trace ${i}`,
+  });
+
+  // For each trace, log 10 spans
+  for (let j = 0; j < 10; j++) {
+    const someSpan = someTrace.span({
+      name: `Span ${i}-${j}`,
+      type: "llm",
+    });
+
+    // Mark the span as ended
+    someSpan.end();
+  }
+
+  // Mark the trace as ended
+  someTrace.end();
+}
+
+// Flush the client to send all traces and spans
+await client.flush();
+```
+
+## Contributing
+
+Contributions are welcome! If you have any suggestions or improvements, please feel free to open an [issue](https://github.com/comet-ml/opik/issues) or submit a [pull request](https://github.com/comet-ml/opik/pulls).
+
+## License
+
+This project is licensed under the [Apache License 2.0](https://github.com/comet-ml/opik/blob/main/LICENSE).

package/dist/Node18UniversalStreamWrapper-RYU62PI4.js

@@ -0,0 +1,220 @@
+import "./chunk-MLKGABMK.js";
+
+// src/opik/rest_api/core/fetcher/stream-wrappers/Node18UniversalStreamWrapper.ts
+var Node18UniversalStreamWrapper = class _Node18UniversalStreamWrapper {
+  readableStream;
+  reader;
+  events;
+  paused;
+  resumeCallback;
+  encoding;
+  constructor(readableStream) {
+    this.readableStream = readableStream;
+    this.reader = this.readableStream.getReader();
+    this.events = {
+      data: [],
+      end: [],
+      error: [],
+      readable: [],
+      close: [],
+      pause: [],
+      resume: []
+    };
+    this.paused = false;
+    this.resumeCallback = null;
+    this.encoding = null;
+  }
+  on(event, callback) {
+    this.events[event]?.push(callback);
+  }
+  off(event, callback) {
+    this.events[event] = this.events[event]?.filter((cb) => cb !== callback);
+  }
+  pipe(dest) {
+    this.on("data", async (chunk) => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._write(chunk);
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.write(chunk).then(() => writer.releaseLock());
+      } else {
+        dest.write(chunk);
+      }
+    });
+    this.on("end", async () => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._end();
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.close();
+      } else {
+        dest.end();
+      }
+    });
+    this.on("error", async (error) => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._error(error);
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.abort(error);
+      } else {
+        dest.destroy(error);
+      }
+    });
+    this._startReading();
+    return dest;
+  }
+  pipeTo(dest) {
+    return this.pipe(dest);
+  }
+  unpipe(dest) {
+    this.off("data", async (chunk) => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._write(chunk);
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.write(chunk).then(() => writer.releaseLock());
+      } else {
+        dest.write(chunk);
+      }
+    });
+    this.off("end", async () => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._end();
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.close();
+      } else {
+        dest.end();
+      }
+    });
+    this.off("error", async (error) => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._error(error);
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.abort(error);
+      } else {
+        dest.destroy(error);
+      }
+    });
+  }
+  destroy(error) {
+    this.reader.cancel(error).then(() => {
+      this._emit("close");
+    }).catch((err) => {
+      this._emit("error", err);
+    });
+  }
+  pause() {
+    this.paused = true;
+    this._emit("pause");
+  }
+  resume() {
+    if (this.paused) {
+      this.paused = false;
+      this._emit("resume");
+      if (this.resumeCallback) {
+        this.resumeCallback();
+        this.resumeCallback = null;
+      }
+    }
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  async read() {
+    if (this.paused) {
+      await new Promise((resolve) => {
+        this.resumeCallback = resolve;
+      });
+    }
+    const { done, value } = await this.reader.read();
+    if (done) {
+      return void 0;
+    }
+    return value;
+  }
+  setEncoding(encoding) {
+    this.encoding = encoding;
+  }
+  async text() {
+    const chunks = [];
+    while (true) {
+      const { done, value } = await this.reader.read();
+      if (done) {
+        break;
+      }
+      if (value) {
+        chunks.push(value);
+      }
+    }
+    const decoder = new TextDecoder(this.encoding || "utf-8");
+    return decoder.decode(await new Blob(chunks).arrayBuffer());
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  _write(chunk) {
+    this._emit("data", chunk);
+  }
+  _end() {
+    this._emit("end");
+  }
+  _error(error) {
+    this._emit("error", error);
+  }
+  _emit(event, data) {
+    if (this.events[event]) {
+      for (const callback of this.events[event] || []) {
+        callback(data);
+      }
+    }
+  }
+  async _startReading() {
+    try {
+      this._emit("readable");
+      while (true) {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          this._emit("end");
+          this._emit("close");
+          break;
+        }
+        if (value) {
+          this._emit("data", value);
+        }
+      }
+    } catch (error) {
+      this._emit("error", error);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value };
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+};
+export {
+  Node18UniversalStreamWrapper
+};

package/dist/NodePre18StreamWrapper-U7T7ZEM6.js

@@ -0,0 +1,90 @@
+import "./chunk-MLKGABMK.js";
+
+// src/opik/rest_api/core/fetcher/stream-wrappers/NodePre18StreamWrapper.ts
+var NodePre18StreamWrapper = class {
+  readableStream;
+  encoding;
+  constructor(readableStream) {
+    this.readableStream = readableStream;
+  }
+  on(event, callback) {
+    this.readableStream.on(event, callback);
+  }
+  off(event, callback) {
+    this.readableStream.off(event, callback);
+  }
+  pipe(dest) {
+    this.readableStream.pipe(dest);
+    return dest;
+  }
+  pipeTo(dest) {
+    return this.pipe(dest);
+  }
+  unpipe(dest) {
+    if (dest) {
+      this.readableStream.unpipe(dest);
+    } else {
+      this.readableStream.unpipe();
+    }
+  }
+  destroy(error) {
+    this.readableStream.destroy(error);
+  }
+  pause() {
+    this.readableStream.pause();
+  }
+  resume() {
+    this.readableStream.resume();
+  }
+  get isPaused() {
+    return this.readableStream.isPaused();
+  }
+  async read() {
+    return new Promise((resolve, reject) => {
+      const chunk = this.readableStream.read();
+      if (chunk) {
+        resolve(chunk);
+      } else {
+        this.readableStream.once("readable", () => {
+          const chunk2 = this.readableStream.read();
+          resolve(chunk2);
+        });
+        this.readableStream.once("error", reject);
+      }
+    });
+  }
+  setEncoding(encoding) {
+    this.readableStream.setEncoding(encoding);
+    this.encoding = encoding;
+  }
+  async text() {
+    const chunks = [];
+    const encoder = new TextEncoder();
+    this.readableStream.setEncoding(this.encoding || "utf-8");
+    for await (const chunk of this.readableStream) {
+      chunks.push(encoder.encode(chunk));
+    }
+    const decoder = new TextDecoder(this.encoding || "utf-8");
+    return decoder.decode(Buffer.concat(chunks));
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  [Symbol.asyncIterator]() {
+    const readableStream = this.readableStream;
+    const iterator = readableStream[Symbol.asyncIterator]();
+    return {
+      async next() {
+        const { value, done } = await iterator.next();
+        return { value, done };
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+};
+export {
+  NodePre18StreamWrapper
+};

package/dist/UndiciStreamWrapper-E5ZREEPW.js

@@ -0,0 +1,208 @@
+import "./chunk-MLKGABMK.js";
+
+// src/opik/rest_api/core/fetcher/stream-wrappers/UndiciStreamWrapper.ts
+var UndiciStreamWrapper = class _UndiciStreamWrapper {
+  readableStream;
+  reader;
+  events;
+  paused;
+  resumeCallback;
+  encoding;
+  constructor(readableStream) {
+    this.readableStream = readableStream;
+    this.reader = this.readableStream.getReader();
+    this.events = {
+      data: [],
+      end: [],
+      error: [],
+      readable: [],
+      close: [],
+      pause: [],
+      resume: []
+    };
+    this.paused = false;
+    this.resumeCallback = null;
+    this.encoding = null;
+  }
+  on(event, callback) {
+    this.events[event]?.push(callback);
+  }
+  off(event, callback) {
+    this.events[event] = this.events[event]?.filter((cb) => cb !== callback);
+  }
+  pipe(dest) {
+    this.on("data", (chunk) => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._write(chunk);
+      } else {
+        const writer = dest.getWriter();
+        writer.write(chunk).then(() => writer.releaseLock());
+      }
+    });
+    this.on("end", () => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._end();
+      } else {
+        const writer = dest.getWriter();
+        writer.close();
+      }
+    });
+    this.on("error", (error) => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._error(error);
+      } else {
+        const writer = dest.getWriter();
+        writer.abort(error);
+      }
+    });
+    this._startReading();
+    return dest;
+  }
+  pipeTo(dest) {
+    return this.pipe(dest);
+  }
+  unpipe(dest) {
+    this.off("data", (chunk) => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._write(chunk);
+      } else {
+        const writer = dest.getWriter();
+        writer.write(chunk).then(() => writer.releaseLock());
+      }
+    });
+    this.off("end", () => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._end();
+      } else {
+        const writer = dest.getWriter();
+        writer.close();
+      }
+    });
+    this.off("error", (error) => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._error(error);
+      } else {
+        const writer = dest.getWriter();
+        writer.abort(error);
+      }
+    });
+  }
+  destroy(error) {
+    this.reader.cancel(error).then(() => {
+      this._emit("close");
+    }).catch((err) => {
+      this._emit("error", err);
+    });
+  }
+  pause() {
+    this.paused = true;
+    this._emit("pause");
+  }
+  resume() {
+    if (this.paused) {
+      this.paused = false;
+      this._emit("resume");
+      if (this.resumeCallback) {
+        this.resumeCallback();
+        this.resumeCallback = null;
+      }
+    }
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  async read() {
+    if (this.paused) {
+      await new Promise((resolve) => {
+        this.resumeCallback = resolve;
+      });
+    }
+    const { done, value } = await this.reader.read();
+    if (done) {
+      return void 0;
+    }
+    return value;
+  }
+  setEncoding(encoding) {
+    this.encoding = encoding;
+  }
+  async text() {
+    const chunks = [];
+    while (true) {
+      const { done, value } = await this.reader.read();
+      if (done) {
+        break;
+      }
+      if (value) {
+        chunks.push(value);
+      }
+    }
+    const decoder = new TextDecoder(this.encoding || "utf-8");
+    return decoder.decode(await new Blob(chunks).arrayBuffer());
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  _write(chunk) {
+    this._emit("data", chunk);
+  }
+  _end() {
+    this._emit("end");
+  }
+  _error(error) {
+    this._emit("error", error);
+  }
+  _emit(event, data) {
+    if (this.events[event]) {
+      for (const callback of this.events[event] || []) {
+        callback(data);
+      }
+    }
+  }
+  async _startReading() {
+    try {
+      this._emit("readable");
+      while (true) {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          this._emit("end");
+          this._emit("close");
+          break;
+        }
+        if (value) {
+          this._emit("data", value);
+        }
+      }
+    } catch (error) {
+      this._emit("error", error);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value };
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+};
+export {
+  UndiciStreamWrapper
+};

package/dist/index.cjs

@@ -560,6 +560,7 @@ var init_NodePre18StreamWrapper = __esm({
 var index_exports = {};
 __export(index_exports, {
   Opik: () => OpikClient,
+  flushAll: () => flushAll,
   track: () => track,
   trackOpikClient: () => trackOpikClient,
   withTrack: () => withTrack
@@ -12100,6 +12101,7 @@ var Span2 = class {
     this.update = (updates) => {
       var _a;
       const spanUpdates = {
+        parentSpanId: this.data.parentSpanId,
         projectName: (_a = this.data.projectName) != null ? _a : this.opik.config.projectName,
         traceId: this.data.traceId,
         ...updates
@@ -12284,12 +12286,7 @@ var SpanBatchQueue = class extends BatchQueue {
     this.api = api;
   }
   async createEntities(spans) {
-    const groupedSpans = groupSpansByDependency(spans);
-    for (const spansGroup of Object.values(groupedSpans)) {
-      await this.api.spans.createSpans({
-        spans: spansGroup
-      });
-    }
+    await this.api.spans.createSpans({ spans });
   }
   async getEntity(id) {
     return await this.api.spans.getSpanById(id);
@@ -12303,32 +12300,6 @@ var SpanBatchQueue = class extends BatchQueue {
     }
   }
 };
-function groupSpansByDependency(spans) {
-  const groups = [];
-  const executed = /* @__PURE__ */ new Set();
-  let remaining = [...spans];
-  while (remaining.length > 0) {
-    const executable = remaining.filter((span) => {
-      if (!span.parentSpanId) {
-        return true;
-      }
-      const parentExists = spans.some((s) => s.id === span.parentSpanId);
-      if (!parentExists) {
-        return true;
-      }
-      return executed.has(span.parentSpanId);
-    });
-    if (executable.length === 0) {
-      break;
-    }
-    groups.push(executable);
-    for (const span of executable) {
-      executed.add(span.id);
-    }
-    remaining = remaining.filter((span) => !executed.has(span.id));
-  }
-  return groups;
-}
 
 // src/opik/client/TraceBatchQueue.ts
 var TraceBatchQueue = class extends BatchQueue {
@@ -12351,6 +12322,7 @@ var TraceBatchQueue = class extends BatchQueue {
 };
 
 // src/opik/client/Client.ts
+var clients = [];
 var OpikClient = class {
   constructor(explicitConfig) {
     this.trace = (traceData) => {
@@ -12380,6 +12352,7 @@ var OpikClient = class {
     });
     this.spanBatchQueue = new SpanBatchQueue(this.api);
     this.traceBatchQueue = new TraceBatchQueue(this.api);
+    clients.push(this);
   }
 };
 
@@ -12389,6 +12362,28 @@ var trackStorage = new import_node_async_hooks.AsyncLocalStorage();
 function isPromise(obj) {
   return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
 }
+function logSpan({
+  name,
+  parentSpan,
+  projectName,
+  trace,
+  type = "llm"
+}) {
+  let spanTrace = trace;
+  if (!spanTrace) {
+    spanTrace = trackOpikClient.trace({
+      name,
+      projectName
+    });
+  }
+  const span = spanTrace.span({
+    name,
+    parentSpanId: parentSpan == null ? void 0 : parentSpan.data.id,
+    projectName,
+    type
+  });
+  return { span, trace: spanTrace };
+}
 function withTrack({
   name,
   projectName,
@@ -12408,7 +12403,7 @@ function withTrack({
       const fnThis = this;
       return trackStorage.run({ span, trace }, () => {
         try {
-          const result = originalFn.call(fnThis, args);
+          const result = originalFn.apply(fnThis, args);
           if (isPromise(result)) {
             return result.then(
               (res) => {
@@ -12444,42 +12439,37 @@ function withTrack({
     return wrappedFn;
   };
 }
-function track({
-  name,
-  projectName,
-  type
-} = {}) {
-  return function(target, propertyKey, descriptor) {
+function track(options = {}) {
+  return function(...args) {
+    if (args.length === 2 && typeof args[1] === "object" && args[1] !== null && "kind" in args[1]) {
+      const [originalMethod2, context] = args;
+      if (context.kind !== "method") {
+        throw new Error("track decorator is only applicable to methods");
+      }
+      return withTrack(options)(originalMethod2);
+    }
+    const [target, propertyKey, descriptor] = args;
+    if (!descriptor || typeof descriptor.value !== "function") {
+      throw new Error("track decorator can only be applied to methods");
+    }
     const originalMethod = descriptor.value;
-    descriptor.value = withTrack({ name, projectName, type })(descriptor.value);
+    descriptor.value = withTrack(options)(originalMethod);
+    return descriptor;
   };
 }
-function logSpan({
-  name,
-  parentSpan,
-  projectName,
-  trace,
-  type = "llm"
-}) {
-  let spanTrace = trace;
-  if (!spanTrace) {
-    spanTrace = trackOpikClient.trace({
-      name,
-      projectName
-    });
-  }
-  const span = spanTrace.span({
-    name,
-    parentSpanId: parentSpan == null ? void 0 : parentSpan.data.id,
-    projectName,
-    type
-  });
-  return { span, trace: spanTrace };
-}
 var trackOpikClient = new OpikClient();
+
+// src/opik/flushAll.ts
+var flushAll = async () => {
+  await Promise.all([
+    trackOpikClient.flush(),
+    ...clients.map((c) => c.flush())
+  ]);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Opik,
+  flushAll,
   track,
   trackOpikClient,
   withTrack

package/dist/index.d.cts

@@ -4627,11 +4627,13 @@ declare function withTrack({ name, projectName, type, }?: {
     projectName?: string;
     type?: SpanType;
 }): <T extends (...args: any[]) => any>(originalFn: T) => T;
-declare function track({ name, projectName, type, }?: {
+declare function track(options?: {
     name?: string;
     projectName?: string;
     type?: SpanType;
-}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+}): (...args: any[]) => any;
 declare const trackOpikClient: OpikClient;
 
-export { OpikClient as Opik, type OpikConfig, track, trackOpikClient, withTrack };
+declare const flushAll: () => Promise<void>;
+
+export { OpikClient as Opik, type OpikConfig, flushAll, track, trackOpikClient, withTrack };

package/dist/index.d.ts

@@ -4627,11 +4627,13 @@ declare function withTrack({ name, projectName, type, }?: {
     projectName?: string;
     type?: SpanType;
 }): <T extends (...args: any[]) => any>(originalFn: T) => T;
-declare function track({ name, projectName, type, }?: {
+declare function track(options?: {
     name?: string;
     projectName?: string;
     type?: SpanType;
-}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+}): (...args: any[]) => any;
 declare const trackOpikClient: OpikClient;
 
-export { OpikClient as Opik, type OpikConfig, track, trackOpikClient, withTrack };
+declare const flushAll: () => Promise<void>;
+
+export { OpikClient as Opik, type OpikConfig, flushAll, track, trackOpikClient, withTrack };

package/dist/index.js

@@ -11536,6 +11536,7 @@ var Span2 = class {
     this.update = (updates) => {
       var _a;
       const spanUpdates = {
+        parentSpanId: this.data.parentSpanId,
         projectName: (_a = this.data.projectName) != null ? _a : this.opik.config.projectName,
         traceId: this.data.traceId,
         ...updates
@@ -11720,12 +11721,7 @@ var SpanBatchQueue = class extends BatchQueue {
     this.api = api;
   }
   async createEntities(spans) {
-    const groupedSpans = groupSpansByDependency(spans);
-    for (const spansGroup of Object.values(groupedSpans)) {
-      await this.api.spans.createSpans({
-        spans: spansGroup
-      });
-    }
+    await this.api.spans.createSpans({ spans });
   }
   async getEntity(id) {
     return await this.api.spans.getSpanById(id);
@@ -11739,32 +11735,6 @@ var SpanBatchQueue = class extends BatchQueue {
     }
   }
 };
-function groupSpansByDependency(spans) {
-  const groups = [];
-  const executed = /* @__PURE__ */ new Set();
-  let remaining = [...spans];
-  while (remaining.length > 0) {
-    const executable = remaining.filter((span) => {
-      if (!span.parentSpanId) {
-        return true;
-      }
-      const parentExists = spans.some((s) => s.id === span.parentSpanId);
-      if (!parentExists) {
-        return true;
-      }
-      return executed.has(span.parentSpanId);
-    });
-    if (executable.length === 0) {
-      break;
-    }
-    groups.push(executable);
-    for (const span of executable) {
-      executed.add(span.id);
-    }
-    remaining = remaining.filter((span) => !executed.has(span.id));
-  }
-  return groups;
-}
 
 // src/opik/client/TraceBatchQueue.ts
 var TraceBatchQueue = class extends BatchQueue {
@@ -11787,6 +11757,7 @@ var TraceBatchQueue = class extends BatchQueue {
 };
 
 // src/opik/client/Client.ts
+var clients = [];
 var OpikClient = class {
   constructor(explicitConfig) {
     this.trace = (traceData) => {
@@ -11816,6 +11787,7 @@ var OpikClient = class {
     });
     this.spanBatchQueue = new SpanBatchQueue(this.api);
     this.traceBatchQueue = new TraceBatchQueue(this.api);
+    clients.push(this);
   }
 };
 
@@ -11825,6 +11797,28 @@ var trackStorage = new AsyncLocalStorage();
 function isPromise(obj) {
   return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
 }
+function logSpan({
+  name,
+  parentSpan,
+  projectName,
+  trace,
+  type = "llm"
+}) {
+  let spanTrace = trace;
+  if (!spanTrace) {
+    spanTrace = trackOpikClient.trace({
+      name,
+      projectName
+    });
+  }
+  const span = spanTrace.span({
+    name,
+    parentSpanId: parentSpan == null ? void 0 : parentSpan.data.id,
+    projectName,
+    type
+  });
+  return { span, trace: spanTrace };
+}
 function withTrack({
   name,
   projectName,
@@ -11844,7 +11838,7 @@ function withTrack({
       const fnThis = this;
       return trackStorage.run({ span, trace }, () => {
         try {
-          const result = originalFn.call(fnThis, args);
+          const result = originalFn.apply(fnThis, args);
           if (isPromise(result)) {
             return result.then(
               (res) => {
@@ -11880,41 +11874,36 @@ function withTrack({
     return wrappedFn;
   };
 }
-function track({
-  name,
-  projectName,
-  type
-} = {}) {
-  return function(target, propertyKey, descriptor) {
+function track(options = {}) {
+  return function(...args) {
+    if (args.length === 2 && typeof args[1] === "object" && args[1] !== null && "kind" in args[1]) {
+      const [originalMethod2, context] = args;
+      if (context.kind !== "method") {
+        throw new Error("track decorator is only applicable to methods");
+      }
+      return withTrack(options)(originalMethod2);
+    }
+    const [target, propertyKey, descriptor] = args;
+    if (!descriptor || typeof descriptor.value !== "function") {
+      throw new Error("track decorator can only be applied to methods");
+    }
     const originalMethod = descriptor.value;
-    descriptor.value = withTrack({ name, projectName, type })(descriptor.value);
+    descriptor.value = withTrack(options)(originalMethod);
+    return descriptor;
   };
 }
-function logSpan({
-  name,
-  parentSpan,
-  projectName,
-  trace,
-  type = "llm"
-}) {
-  let spanTrace = trace;
-  if (!spanTrace) {
-    spanTrace = trackOpikClient.trace({
-      name,
-      projectName
-    });
-  }
-  const span = spanTrace.span({
-    name,
-    parentSpanId: parentSpan == null ? void 0 : parentSpan.data.id,
-    projectName,
-    type
-  });
-  return { span, trace: spanTrace };
-}
 var trackOpikClient = new OpikClient();
+
+// src/opik/flushAll.ts
+var flushAll = async () => {
+  await Promise.all([
+    trackOpikClient.flush(),
+    ...clients.map((c) => c.flush())
+  ]);
+};
 export {
   OpikClient as Opik,
+  flushAll,
   track,
   trackOpikClient,
   withTrack

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opik",
   "description": "Opik TypeScript and JavaScript SDK",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/comet-ml/opik.git",
@@ -28,7 +28,8 @@
     "comet"
   ],
   "files": [
-    "dist/**/*"
+    "dist/**/*",
+    "README.md"
   ],
   "exports": {
     "./package.json": "./package.json",