@dthink/bloop-sdk 0.4.0 → 0.5.0

package/dist/client.d.ts

@@ -78,6 +78,8 @@ export declare class BloopClient {
     _sendTrace(data: TraceData): void;
     wrapOpenAI<T>(openaiClient: T): T;
     wrapAnthropic<T>(anthropicClient: T): T;
+    wrapPiAiComplete(completeFn: Function): Function;
+    wrapPiAiStream(streamFn: Function): Function;
     flush(): void;
     close(): void;
     private _flushErrors;

package/dist/client.js

@@ -73,6 +73,14 @@ class BloopClient {
         const { wrapAnthropic } = require("./integrations/anthropic");
         return wrapAnthropic(anthropicClient, this);
     }
+    wrapPiAiComplete(completeFn) {
+        const { wrapPiAiComplete } = require("./integrations/pi-ai");
+        return wrapPiAiComplete(completeFn, this);
+    }
+    wrapPiAiStream(streamFn) {
+        const { wrapPiAiStream } = require("./integrations/pi-ai");
+        return wrapPiAiStream(streamFn, this);
+    }
     // ── Flush & Transport ──
     flush() {
         this._flushErrors();

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export { BloopClient, Trace, Span } from "./client";
 export type { BloopClientOptions, TraceData, SpanData } from "./client";
 export { wrapOpenAI } from "./integrations/openai";
 export { wrapAnthropic } from "./integrations/anthropic";
+export { wrapPiAiComplete, wrapPiAiStream } from "./integrations/pi-ai";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapAnthropic = exports.wrapOpenAI = exports.Span = exports.Trace = exports.BloopClient = void 0;
+exports.wrapPiAiStream = exports.wrapPiAiComplete = exports.wrapAnthropic = exports.wrapOpenAI = exports.Span = exports.Trace = exports.BloopClient = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "BloopClient", { enumerable: true, get: function () { return client_1.BloopClient; } });
 Object.defineProperty(exports, "Trace", { enumerable: true, get: function () { return client_1.Trace; } });
@@ -9,3 +9,6 @@ var openai_1 = require("./integrations/openai");
 Object.defineProperty(exports, "wrapOpenAI", { enumerable: true, get: function () { return openai_1.wrapOpenAI; } });
 var anthropic_1 = require("./integrations/anthropic");
 Object.defineProperty(exports, "wrapAnthropic", { enumerable: true, get: function () { return anthropic_1.wrapAnthropic; } });
+var pi_ai_1 = require("./integrations/pi-ai");
+Object.defineProperty(exports, "wrapPiAiComplete", { enumerable: true, get: function () { return pi_ai_1.wrapPiAiComplete; } });
+Object.defineProperty(exports, "wrapPiAiStream", { enumerable: true, get: function () { return pi_ai_1.wrapPiAiStream; } });

package/dist/integrations/index.d.ts

@@ -1,2 +1,3 @@
 export { wrapOpenAI } from "./openai";
 export { wrapAnthropic } from "./anthropic";
+export { wrapPiAiComplete, wrapPiAiStream } from "./pi-ai";

package/dist/integrations/index.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapAnthropic = exports.wrapOpenAI = void 0;
+exports.wrapPiAiStream = exports.wrapPiAiComplete = exports.wrapAnthropic = exports.wrapOpenAI = void 0;
 var openai_1 = require("./openai");
 Object.defineProperty(exports, "wrapOpenAI", { enumerable: true, get: function () { return openai_1.wrapOpenAI; } });
 var anthropic_1 = require("./anthropic");
 Object.defineProperty(exports, "wrapAnthropic", { enumerable: true, get: function () { return anthropic_1.wrapAnthropic; } });
+var pi_ai_1 = require("./pi-ai");
+Object.defineProperty(exports, "wrapPiAiComplete", { enumerable: true, get: function () { return pi_ai_1.wrapPiAiComplete; } });
+Object.defineProperty(exports, "wrapPiAiStream", { enumerable: true, get: function () { return pi_ai_1.wrapPiAiStream; } });

package/dist/integrations/pi-ai.d.ts

@@ -0,0 +1,34 @@
+/**
+ * pi-ai (@mariozechner/pi-ai) auto-instrumentation for bloop LLM tracing.
+ *
+ * Wraps `complete()` and `stream()` to automatically capture:
+ * - Model, provider, tokens, latency, TTFT (streaming), errors
+ * - Cost is always 0 -- calculated server-side from pricing table
+ *
+ * Works with all pi-ai providers: OpenAI, Anthropic, Google, Mistral,
+ * OpenRouter, Groq, xAI, Cerebras, Azure, Bedrock, and any
+ * OpenAI-compatible endpoint.
+ */
+import type { BloopClient } from "../client";
+/**
+ * Wrap pi-ai's `complete()` function for automatic tracing.
+ *
+ * Usage:
+ *   import { complete, getModel } from "@mariozechner/pi-ai";
+ *   const tracedComplete = bloop.wrapPiAiComplete(complete);
+ *   const model = getModel("openai", "gpt-4o");
+ *   const response = await tracedComplete(model, context);
+ */
+export declare function wrapPiAiComplete(completeFn: Function, bloopClient: BloopClient): Function;
+/**
+ * Wrap pi-ai's `stream()` function for automatic tracing.
+ *
+ * Usage:
+ *   import { stream, getModel } from "@mariozechner/pi-ai";
+ *   const tracedStream = bloop.wrapPiAiStream(stream);
+ *   const model = getModel("openai", "gpt-4o");
+ *   const eventStream = tracedStream(model, context);
+ *   for await (const event of eventStream) { ... }
+ *   const result = await eventStream.result();
+ */
+export declare function wrapPiAiStream(streamFn: Function, bloopClient: BloopClient): Function;

package/dist/integrations/pi-ai.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * pi-ai (@mariozechner/pi-ai) auto-instrumentation for bloop LLM tracing.
+ *
+ * Wraps `complete()` and `stream()` to automatically capture:
+ * - Model, provider, tokens, latency, TTFT (streaming), errors
+ * - Cost is always 0 -- calculated server-side from pricing table
+ *
+ * Works with all pi-ai providers: OpenAI, Anthropic, Google, Mistral,
+ * OpenRouter, Groq, xAI, Cerebras, Azure, Bedrock, and any
+ * OpenAI-compatible endpoint.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapPiAiComplete = wrapPiAiComplete;
+exports.wrapPiAiStream = wrapPiAiStream;
+/**
+ * Wrap pi-ai's `complete()` function for automatic tracing.
+ *
+ * Usage:
+ *   import { complete, getModel } from "@mariozechner/pi-ai";
+ *   const tracedComplete = bloop.wrapPiAiComplete(complete);
+ *   const model = getModel("openai", "gpt-4o");
+ *   const response = await tracedComplete(model, context);
+ */
+function wrapPiAiComplete(completeFn, bloopClient) {
+    return async function tracedComplete(model, context, options) {
+        const modelName = model?.name || model?.id || "unknown";
+        const provider = model?.provider || "unknown";
+        const startMs = Date.now();
+        const trace = bloopClient.trace({ name: `${provider}/${modelName}` });
+        const span = trace.span({
+            spanType: "generation",
+            name: "complete",
+            model: modelName,
+            provider,
+        });
+        try {
+            const response = await completeFn(model, context, options);
+            const endMs = Date.now();
+            // pi-ai AssistantMessage has usage.input, usage.output, usage.totalTokens
+            const usage = response?.usage;
+            if (usage) {
+                span.setTokens(usage.input || 0, usage.output || 0);
+            }
+            span.setLatency(endMs - startMs);
+            span.cost = 0; // Server-side pricing
+            span.end();
+            trace.end();
+            return response;
+        }
+        catch (err) {
+            const endMs = Date.now();
+            span.setLatency(endMs - startMs);
+            span.setError(err.message);
+            span.end();
+            trace.status = "error";
+            trace.end();
+            throw err;
+        }
+    };
+}
+/**
+ * Wrap pi-ai's `stream()` function for automatic tracing.
+ *
+ * Usage:
+ *   import { stream, getModel } from "@mariozechner/pi-ai";
+ *   const tracedStream = bloop.wrapPiAiStream(stream);
+ *   const model = getModel("openai", "gpt-4o");
+ *   const eventStream = tracedStream(model, context);
+ *   for await (const event of eventStream) { ... }
+ *   const result = await eventStream.result();
+ */
+function wrapPiAiStream(streamFn, bloopClient) {
+    return function tracedStream(model, context, options) {
+        const modelName = model?.name || model?.id || "unknown";
+        const provider = model?.provider || "unknown";
+        const startMs = Date.now();
+        const trace = bloopClient.trace({ name: `${provider}/${modelName}` });
+        const span = trace.span({
+            spanType: "generation",
+            name: "stream",
+            model: modelName,
+            provider,
+        });
+        const originalStream = streamFn(model, context, options);
+        let firstTokenSeen = false;
+        // Wrap the async iterable to intercept events
+        const wrappedStream = {
+            [Symbol.asyncIterator]: async function* () {
+                try {
+                    for await (const event of originalStream) {
+                        if (!firstTokenSeen && (event?.type === "text" || event?.type === "thinking")) {
+                            firstTokenSeen = true;
+                            span.timeToFirstTokenMs = Date.now() - startMs;
+                        }
+                        yield event;
+                    }
+                }
+                catch (err) {
+                    const endMs = Date.now();
+                    span.setLatency(endMs - startMs);
+                    span.setError(err.message);
+                    span.end();
+                    trace.status = "error";
+                    trace.end();
+                    throw err;
+                }
+            },
+            // Preserve the result() method that returns the final AssistantMessage
+            result: async () => {
+                const message = await originalStream.result();
+                const endMs = Date.now();
+                const usage = message?.usage;
+                if (usage) {
+                    span.setTokens(usage.input || 0, usage.output || 0);
+                }
+                span.setLatency(endMs - startMs);
+                span.cost = 0;
+                span.end();
+                trace.end();
+                return message;
+            },
+        };
+        return wrappedStream;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dthink/bloop-sdk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Bloop error reporting and LLM tracing SDK for TypeScript/Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client.ts

@@ -144,6 +144,16 @@ export class BloopClient {
     return wrapAnthropic(anthropicClient, this);
   }
 
+  wrapPiAiComplete(completeFn: Function): Function {
+    const { wrapPiAiComplete } = require("./integrations/pi-ai");
+    return wrapPiAiComplete(completeFn, this);
+  }
+
+  wrapPiAiStream(streamFn: Function): Function {
+    const { wrapPiAiStream } = require("./integrations/pi-ai");
+    return wrapPiAiStream(streamFn, this);
+  }
+
   // ── Flush & Transport ──
 
   flush(): void {

package/src/index.ts

@@ -2,3 +2,4 @@ export { BloopClient, Trace, Span } from "./client";
 export type { BloopClientOptions, TraceData, SpanData } from "./client";
 export { wrapOpenAI } from "./integrations/openai";
 export { wrapAnthropic } from "./integrations/anthropic";
+export { wrapPiAiComplete, wrapPiAiStream } from "./integrations/pi-ai";

package/src/integrations/index.ts

@@ -1,2 +1,3 @@
 export { wrapOpenAI } from "./openai";
 export { wrapAnthropic } from "./anthropic";
+export { wrapPiAiComplete, wrapPiAiStream } from "./pi-ai";

package/src/integrations/pi-ai.ts

@@ -0,0 +1,144 @@
+/**
+ * pi-ai (@mariozechner/pi-ai) auto-instrumentation for bloop LLM tracing.
+ *
+ * Wraps `complete()` and `stream()` to automatically capture:
+ * - Model, provider, tokens, latency, TTFT (streaming), errors
+ * - Cost is always 0 -- calculated server-side from pricing table
+ *
+ * Works with all pi-ai providers: OpenAI, Anthropic, Google, Mistral,
+ * OpenRouter, Groq, xAI, Cerebras, Azure, Bedrock, and any
+ * OpenAI-compatible endpoint.
+ */
+
+import type { BloopClient } from "../client";
+
+/**
+ * Wrap pi-ai's `complete()` function for automatic tracing.
+ *
+ * Usage:
+ *   import { complete, getModel } from "@mariozechner/pi-ai";
+ *   const tracedComplete = bloop.wrapPiAiComplete(complete);
+ *   const model = getModel("openai", "gpt-4o");
+ *   const response = await tracedComplete(model, context);
+ */
+export function wrapPiAiComplete(
+  completeFn: Function,
+  bloopClient: BloopClient,
+): Function {
+  return async function tracedComplete(model: any, context: any, options?: any) {
+    const modelName: string = model?.name || model?.id || "unknown";
+    const provider: string = model?.provider || "unknown";
+    const startMs = Date.now();
+
+    const trace = bloopClient.trace({ name: `${provider}/${modelName}` });
+    const span = trace.span({
+      spanType: "generation",
+      name: "complete",
+      model: modelName,
+      provider,
+    });
+
+    try {
+      const response = await completeFn(model, context, options);
+      const endMs = Date.now();
+
+      // pi-ai AssistantMessage has usage.input, usage.output, usage.totalTokens
+      const usage = response?.usage;
+      if (usage) {
+        span.setTokens(
+          usage.input || 0,
+          usage.output || 0,
+        );
+      }
+
+      span.setLatency(endMs - startMs);
+      span.cost = 0; // Server-side pricing
+      span.end();
+      trace.end();
+      return response;
+    } catch (err: any) {
+      const endMs = Date.now();
+      span.setLatency(endMs - startMs);
+      span.setError(err.message);
+      span.end();
+      trace.status = "error";
+      trace.end();
+      throw err;
+    }
+  };
+}
+
+/**
+ * Wrap pi-ai's `stream()` function for automatic tracing.
+ *
+ * Usage:
+ *   import { stream, getModel } from "@mariozechner/pi-ai";
+ *   const tracedStream = bloop.wrapPiAiStream(stream);
+ *   const model = getModel("openai", "gpt-4o");
+ *   const eventStream = tracedStream(model, context);
+ *   for await (const event of eventStream) { ... }
+ *   const result = await eventStream.result();
+ */
+export function wrapPiAiStream(
+  streamFn: Function,
+  bloopClient: BloopClient,
+): Function {
+  return function tracedStream(model: any, context: any, options?: any) {
+    const modelName: string = model?.name || model?.id || "unknown";
+    const provider: string = model?.provider || "unknown";
+    const startMs = Date.now();
+
+    const trace = bloopClient.trace({ name: `${provider}/${modelName}` });
+    const span = trace.span({
+      spanType: "generation",
+      name: "stream",
+      model: modelName,
+      provider,
+    });
+
+    const originalStream = streamFn(model, context, options);
+    let firstTokenSeen = false;
+
+    // Wrap the async iterable to intercept events
+    const wrappedStream = {
+      [Symbol.asyncIterator]: async function* () {
+        try {
+          for await (const event of originalStream) {
+            if (!firstTokenSeen && (event?.type === "text" || event?.type === "thinking")) {
+              firstTokenSeen = true;
+              span.timeToFirstTokenMs = Date.now() - startMs;
+            }
+            yield event;
+          }
+        } catch (err: any) {
+          const endMs = Date.now();
+          span.setLatency(endMs - startMs);
+          span.setError(err.message);
+          span.end();
+          trace.status = "error";
+          trace.end();
+          throw err;
+        }
+      },
+
+      // Preserve the result() method that returns the final AssistantMessage
+      result: async () => {
+        const message = await originalStream.result();
+        const endMs = Date.now();
+
+        const usage = message?.usage;
+        if (usage) {
+          span.setTokens(usage.input || 0, usage.output || 0);
+        }
+
+        span.setLatency(endMs - startMs);
+        span.cost = 0;
+        span.end();
+        trace.end();
+        return message;
+      },
+    };
+
+    return wrappedStream;
+  };
+}