@fluxgate/anthropic 0.0.1

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 [Your Name or Organization]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,238 @@
+# @fluxgate/anthropic
+
+![Status: In Development](https://img.shields.io/badge/status-in%20development-orange)
+
+Anthropic SDK wrapper for FluxGate token tracking. Automatically track token usage, costs, and latency for Anthropic Messages API calls.
+
+## 📦 Installation
+
+```bash
+npm install @fluxgate/sdk @fluxgate/anthropic @anthropic-ai/sdk
+```
+
+## 🚀 Quick Start
+
+```typescript
+import Anthropic from "@anthropic-ai/sdk";
+import { FluxGate } from "@fluxgate/sdk";
+import { createAnthropicCostTracker } from "@fluxgate/anthropic";
+
+const client = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+});
+
+const fluxgate = new FluxGate({
+  apiKey: process.env.FLUXGATE_API_KEY,
+});
+
+const anthropic = createAnthropicCostTracker(client, fluxgate);
+
+const message = await anthropic
+  .withContext({
+    feature: "chatbot",
+    user: "user-123",
+  })
+  .messages.create({
+    model: "claude-sonnet-4-6",
+    max_tokens: 1024,
+    messages: [{ role: "user", content: "Hello, Claude" }],
+  });
+
+console.log(message.content);
+console.log(message.fluxGateCostTrackingResponse);
+// {
+//   status: "SUCCESS",
+//   cost: 0.003,
+//   trackingId: "evt_...",
+//   createdAt: "2026-05-12T..."
+// }
+```
+
+## 📖 API Reference
+
+### `createAnthropicCostTracker(client, tracker)`
+
+Creates a tracked Anthropic client with context support.
+
+**Parameters:**
+
+- `client`: Anthropic client instance
+- `fluxgate`: FluxGate instance
+
+**Returns:** Object with:
+
+- `withContext(metadata)`: Returns tracked client with context
+- `client`: Default tracked client (no context)
+
+### Tracked Methods
+
+- ✅ `messages.create()` — non-streaming responses
+- ✅ `messages.create({ stream: true })` — streaming responses
+
+## 💡 Usage Examples
+
+### Non-Streaming
+
+```typescript
+import Anthropic from "@anthropic-ai/sdk";
+import { FluxGate } from "@fluxgate/sdk";
+import { createAnthropicCostTracker } from "@fluxgate/anthropic";
+
+const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+const fluxgate = new FluxGate({ apiKey: process.env.FLUXGATE_API_KEY });
+const anthropic = createAnthropicCostTracker(client, fluxgate);
+
+const message = await anthropic
+  .withContext({ feature: "summarization", user: "user-123" })
+  .messages.create({
+    model: "claude-sonnet-4-6",
+    max_tokens: 1024,
+    messages: [
+      { role: "user", content: "Summarize the French Revolution in 3 sentences." },
+    ],
+  });
+
+console.log(message.content[0].text);
+console.log(message.fluxGateCostTrackingResponse);
+```
+
+### Streaming
+
+```typescript
+const stream = await anthropic
+  .withContext({ feature: "streaming-chat" })
+  .messages.create({
+    model: "claude-sonnet-4-6",
+    max_tokens: 1024,
+    messages: [{ role: "user", content: "Tell me a story" }],
+    stream: true,
+  });
+
+for await (const event of stream) {
+  if (
+    event.type === "content_block_delta" &&
+    event.delta.type === "text_delta"
+  ) {
+    process.stdout.write(event.delta.text);
+  }
+}
+
+// Access tracking data after stream completes
+console.log(stream.fluxGateCostTrackingResponse);
+```
+
+### Rich User Context
+
+```typescript
+const message = await anthropic
+  .withContext({
+    feature: "premium-chat",
+    user: {
+      id: "user-123",
+      name: "Jane Smith",
+      email: "jane@example.com",
+      monthlyRevenue: 49.99,
+    },
+    sessionId: "sess-abc123",
+    conversationId: "conv-xyz789",
+  })
+  .messages.create({
+    model: "claude-sonnet-4-6",
+    max_tokens: 1024,
+    messages: [{ role: "user", content: "Hello!" }],
+  });
+```
+
+### Error Handling
+
+Errors are automatically tracked with `status: "ERROR"`:
+
+```typescript
+try {
+  const message = await anthropic
+    .withContext({ feature: "chat" })
+    .messages.create({
+      model: "claude-sonnet-4-6",
+      max_tokens: 1024,
+      messages: [{ role: "user", content: "Hello!" }],
+    });
+} catch (error) {
+  // Error was tracked automatically with status: "ERROR"
+  console.error(error);
+}
+```
+
+### Without Context (Default)
+
+```typescript
+// Use client property for default tracking without metadata
+const message = await anthropic.client.messages.create({
+  model: "claude-sonnet-4-6",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Hello!" }],
+});
+
+console.log(message.fluxGateCostTrackingResponse);
+```
+
+## 📊 Tracking Data Structure
+
+Each response includes a `fluxGateCostTrackingResponse` property:
+
+```typescript
+interface FluxGateCostTrackingResponse {
+  status: AiEventStatus;
+  cost: number | null;
+  trackingId: string | null;
+  createdAt: string | null;
+  errorMessage?: string;
+}
+
+type AiEventStatus =
+  | "SUCCESS"
+  | "ERROR"
+  | "BLOCKED"
+  | "MAX_TOKENS"
+  | "CONTENT_FILTER"
+  | "RECITATION"
+  | "MALFORMED_REQUEST";
+```
+
+Tracked metrics include:
+
+- ✅ Input tokens (prompt)
+- ✅ Output tokens (completion)
+- ✅ Model name
+- ✅ Latency (milliseconds)
+- ✅ Stream duration (for streaming)
+- ✅ Stop reason (end_turn, max_tokens, content_filter, etc.)
+
+## 🎯 Type Safety
+
+Full TypeScript support with enhanced types:
+
+```typescript
+import type {
+  TrackedAnthropic,
+  WithTracking,
+  AiEventMetadata,
+  TrackedUser,
+  FluxGateCostTrackingResponse,
+} from "@fluxgate/anthropic";
+
+// TrackedAnthropic includes all Anthropic methods with tracking
+const anthropic: TrackedAnthropic = trackedClient.client;
+
+// WithTracking adds fluxGateCostTrackingResponse to any type
+type Message = WithTracking<Anthropic.Message>;
+```
+
+## 🔗 Related Packages
+
+- [@fluxgate/sdk](../sdk) - Core tracking library
+- [@fluxgate/openai](../openai) - OpenAI SDK wrapper
+- [@fluxgate/gemini](../gemini) - Gemini SDK wrapper
+
+## 📝 License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { AiEventMetadata, FluxGate } from "@fluxgate/sdk";
+import type Anthropic from "@anthropic-ai/sdk";
+import { TrackedAnthropic } from "./types/types.js";
+export type AnthropicTracker = {
+    withContext: (ctx: AiEventMetadata) => TrackedAnthropic;
+    get client(): TrackedAnthropic;
+};
+export declare function createAnthropicCostTracker(client: Anthropic, instance: FluxGate): AnthropicTracker;
+export type { AiEventMetadata, TrackedUser, FluxGateCostTrackingResponse, WithTracking, AiEventStatus, } from "@fluxgate/sdk";
+export * from "./types/types.js";
+export { TrackedStream } from "./wrappers/TrackedStream.js";

package/dist/index.js

@@ -0,0 +1,13 @@
+import { withAnthropicTracking } from "./wrappers/createWrappedClient.js";
+export function createAnthropicCostTracker(client, instance) {
+    return {
+        withContext(ctx) {
+            return withAnthropicTracking(client, instance, ctx);
+        },
+        get client() {
+            return withAnthropicTracking(client, instance);
+        },
+    };
+}
+export * from "./types/types.js";
+export { TrackedStream } from "./wrappers/TrackedStream.js";

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createAnthropicCostTracker } from "./index.js";
+import { FluxGate } from "@fluxgate/sdk";
+import Anthropic from "@anthropic-ai/sdk";
+describe("createAnthropicCostTracker", () => {
+    let mockClient;
+    let mockFluxGate;
+    beforeEach(() => {
+        mockClient = new Anthropic({
+            apiKey: "test-key",
+        });
+        mockFluxGate = new FluxGate({
+            apiKey: "tracker-key",
+            endpoint: "https://test.example.com",
+        });
+    });
+    describe("initialization", () => {
+        it("should create a tracker with withContext method", () => {
+            const tracker = createAnthropicCostTracker(mockClient, mockFluxGate);
+            expect(tracker).toHaveProperty("withContext");
+            expect(tracker).toHaveProperty("client");
+            expect(typeof tracker.withContext).toBe("function");
+        });
+        it("should return wrapped client with context", () => {
+            const tracker = createAnthropicCostTracker(mockClient, mockFluxGate);
+            const contextClient = tracker.withContext({ feature: "test-feature" });
+            expect(contextClient).toBeDefined();
+            expect(contextClient.messages).toBeDefined();
+            expect(contextClient.messages.create).toBeDefined();
+            expect(typeof contextClient.messages.create).toBe("function");
+        });
+        it("should return wrapped client without context", () => {
+            const tracker = createAnthropicCostTracker(mockClient, mockFluxGate);
+            const defaultClient = tracker.client;
+            expect(defaultClient).toBeDefined();
+            expect(defaultClient.messages).toBeDefined();
+            expect(defaultClient.messages.create).toBeDefined();
+            expect(typeof defaultClient.messages.create).toBe("function");
+        });
+    });
+    describe("context handling", () => {
+        it("should accept user context with string user", () => {
+            const tracker = createAnthropicCostTracker(mockClient, mockFluxGate);
+            const contextClient = tracker.withContext({
+                feature: "chat",
+                user: "user-123",
+                sessionId: "session-456",
+            });
+            expect(contextClient).toBeDefined();
+        });
+        it("should accept user context with TrackedUser object", () => {
+            const tracker = createAnthropicCostTracker(mockClient, mockFluxGate);
+            const contextClient = tracker.withContext({
+                feature: "chat",
+                user: {
+                    id: "user-123",
+                    name: "Test User",
+                    email: "test@example.com",
+                    monthlyRevenue: 99.99,
+                },
+                conversationId: "conv-789",
+            });
+            expect(contextClient).toBeDefined();
+        });
+        it("should accept metadata with custom fields", () => {
+            const tracker = createAnthropicCostTracker(mockClient, mockFluxGate);
+            const contextClient = tracker.withContext({
+                feature: "chat",
+                step: "generation",
+                customField: "custom value",
+                anotherField: 123,
+            });
+            expect(contextClient).toBeDefined();
+        });
+    });
+    describe("multiple contexts", () => {
+        it("should allow creating multiple wrapped clients with different contexts", () => {
+            const tracker = createAnthropicCostTracker(mockClient, mockFluxGate);
+            const chatContext = tracker.withContext({ feature: "chat" });
+            const summaryContext = tracker.withContext({ feature: "summary" });
+            expect(chatContext).toBeDefined();
+            expect(summaryContext).toBeDefined();
+            expect(chatContext).not.toBe(summaryContext);
+        });
+    });
+});

package/dist/types/types.d.ts

@@ -0,0 +1,13 @@
+import type Anthropic from "@anthropic-ai/sdk";
+import type { Message, MessageCreateParams, MessageCreateParamsNonStreaming, MessageCreateParamsStreaming, RawMessageStreamEvent } from "@anthropic-ai/sdk/resources/messages";
+import type { WithTracking } from "@fluxgate/sdk";
+import type { TrackedStream } from "../wrappers/TrackedStream.js";
+type MessageCreateOptions = Parameters<Anthropic["messages"]["create"]>[1];
+export type TrackedAnthropic = Omit<Anthropic, "messages"> & {
+    messages: Omit<Anthropic["messages"], "create"> & {
+        create(body: MessageCreateParamsNonStreaming, options?: MessageCreateOptions): Promise<WithTracking<Message>>;
+        create(body: MessageCreateParamsStreaming, options?: MessageCreateOptions): Promise<TrackedStream<RawMessageStreamEvent>>;
+        create(body: MessageCreateParams, options?: MessageCreateOptions): Promise<WithTracking<Message> | TrackedStream<RawMessageStreamEvent>>;
+    };
+};
+export {};

package/dist/types/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/extractUsage.d.ts

@@ -0,0 +1,9 @@
+import type { ExtractedUsage } from "@fluxgate/sdk";
+type AnthropicUsage = {
+    input_tokens: number | null;
+    output_tokens: number | null;
+    cache_creation_input_tokens?: number | null;
+    cache_read_input_tokens?: number | null;
+};
+export declare function extractAnthropicUsage(usage: AnthropicUsage | null | undefined): ExtractedUsage;
+export {};

package/dist/utils/extractUsage.js

@@ -0,0 +1,18 @@
+export function extractAnthropicUsage(usage) {
+    if (!usage) {
+        return {
+            inputTokens: 0,
+            outputTokens: 0,
+            cachedTokens: 0,
+            totalTokens: 0,
+        };
+    }
+    const cachedTokens = (usage.cache_creation_input_tokens ?? 0) +
+        (usage.cache_read_input_tokens ?? 0);
+    return {
+        inputTokens: usage.input_tokens ?? 0,
+        outputTokens: usage.output_tokens ?? 0,
+        cachedTokens,
+        totalTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+    };
+}

package/dist/utils/extractUsage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/extractUsage.test.js

@@ -0,0 +1,114 @@
+import { describe, it, expect } from "vitest";
+import { extractAnthropicUsage } from "./extractUsage.js";
+describe("extractAnthropicUsage", () => {
+    describe("valid usage data", () => {
+        it("should extract usage from complete usage object", () => {
+            const usage = {
+                input_tokens: 100,
+                output_tokens: 50,
+                cache_creation_input_tokens: 20,
+                cache_read_input_tokens: 10,
+            };
+            const result = extractAnthropicUsage(usage);
+            expect(result).toEqual({
+                inputTokens: 100,
+                outputTokens: 50,
+                cachedTokens: 30,
+                totalTokens: 150,
+            });
+        });
+        it("should handle missing cached token fields", () => {
+            const usage = {
+                input_tokens: 100,
+                output_tokens: 50,
+            };
+            const result = extractAnthropicUsage(usage);
+            expect(result).toEqual({
+                inputTokens: 100,
+                outputTokens: 50,
+                cachedTokens: 0,
+                totalTokens: 150,
+            });
+        });
+        it("should handle null cached token fields", () => {
+            const usage = {
+                input_tokens: 120,
+                output_tokens: 30,
+                cache_creation_input_tokens: null,
+                cache_read_input_tokens: null,
+            };
+            const result = extractAnthropicUsage(usage);
+            expect(result).toEqual({
+                inputTokens: 120,
+                outputTokens: 30,
+                cachedTokens: 0,
+                totalTokens: 150,
+            });
+        });
+    });
+    describe("missing or incomplete data", () => {
+        it("should return zero values for null usage", () => {
+            const result = extractAnthropicUsage(null);
+            expect(result).toEqual({
+                inputTokens: 0,
+                outputTokens: 0,
+                cachedTokens: 0,
+                totalTokens: 0,
+            });
+        });
+        it("should return zero values for undefined usage", () => {
+            const result = extractAnthropicUsage(undefined);
+            expect(result).toEqual({
+                inputTokens: 0,
+                outputTokens: 0,
+                cachedTokens: 0,
+                totalTokens: 0,
+            });
+        });
+        it("should handle partial usage object", () => {
+            const usage = {
+                input_tokens: 80,
+                output_tokens: undefined,
+            };
+            const result = extractAnthropicUsage(usage);
+            expect(result).toEqual({
+                inputTokens: 80,
+                outputTokens: 0,
+                cachedTokens: 0,
+                totalTokens: 80,
+            });
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle zero tokens", () => {
+            const usage = {
+                input_tokens: 0,
+                output_tokens: 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 0,
+            };
+            const result = extractAnthropicUsage(usage);
+            expect(result).toEqual({
+                inputTokens: 0,
+                outputTokens: 0,
+                cachedTokens: 0,
+                totalTokens: 0,
+            });
+        });
+        it("should handle very large token counts", () => {
+            const usage = {
+                input_tokens: 1000000,
+                output_tokens: 500000,
+                cache_creation_input_tokens: 200000,
+                cache_read_input_tokens: 100000,
+            };
+            const result = extractAnthropicUsage(usage);
+            expect(result).toEqual({
+                inputTokens: 1000000,
+                outputTokens: 500000,
+                cachedTokens: 300000,
+                totalTokens: 1500000,
+            });
+        });
+    });
+});

package/dist/utils/recordUsage.d.ts

@@ -0,0 +1,16 @@
+import { AiEventMetadata, AiEventStatus, ExtractedUsage, FluxGate, FluxGateCostTrackingResponse } from "@fluxgate/sdk";
+export declare function stopReasonToStatus(stopReason: string | null | undefined): AiEventStatus;
+export declare function recordUsage(params: {
+    instance: FluxGate;
+    model: string;
+    latencyMs: number;
+    streaming: boolean;
+    context: AiEventMetadata | undefined;
+    usage: ExtractedUsage;
+    status: AiEventStatus;
+    errorMessage?: string;
+}): Promise<FluxGateCostTrackingResponse>;
+export declare function extractResponseStatus(stopReason: string | null | undefined): {
+    status: AiEventStatus;
+    errorMessage?: string;
+};

package/dist/utils/recordUsage.js

@@ -0,0 +1,58 @@
+function normalizeMetadata(context) {
+    const { user, ...rest } = context ?? {};
+    const normalized = { ...rest };
+    if (typeof user === "string") {
+        normalized.user = user;
+    }
+    else if (user != null) {
+        normalized.user = user;
+    }
+    return normalized;
+}
+export function stopReasonToStatus(stopReason) {
+    if (!stopReason ||
+        stopReason === "end_turn" ||
+        stopReason === "stop_sequence") {
+        return "SUCCESS";
+    }
+    if (stopReason === "max_tokens") {
+        return "MAX_TOKENS";
+    }
+    if (stopReason === "content_filter") {
+        return "BLOCKED";
+    }
+    if (stopReason === "tool_use") {
+        return "SUCCESS";
+    }
+    return "ERROR";
+}
+export async function recordUsage(params) {
+    const { context, latencyMs, model, streaming, instance, usage, status, errorMessage, } = params;
+    const trackingData = await instance.recordEvent({
+        metadata: normalizeMetadata(context),
+        status: {
+            status,
+            errorMessage,
+        },
+        usage: {
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cachedTokens: usage.cachedTokens,
+            model,
+            isStreamed: streaming,
+            latencyInMs: latencyMs,
+            provider: "anthropic",
+            streamingDurationInMs: streaming ? latencyMs : undefined,
+        },
+    });
+    return {
+        status,
+        errorMessage,
+        cost: trackingData?.cost ?? null,
+        trackingId: trackingData?.id ?? null,
+        createdAt: trackingData?.createdAt ?? null,
+    };
+}
+export function extractResponseStatus(stopReason) {
+    return { status: stopReasonToStatus(stopReason) };
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1 @@
+export declare function isAsyncIterable<T>(obj: any): obj is AsyncIterable<T>;

package/dist/utils/utils.js

@@ -0,0 +1,3 @@
+export function isAsyncIterable(obj) {
+    return obj && typeof obj[Symbol.asyncIterator] === "function";
+}

package/dist/wrappers/TrackedStream.d.ts

@@ -0,0 +1,8 @@
+import { FluxGateCostTrackingResponse } from "@fluxgate/sdk";
+export declare class TrackedStream<T> implements AsyncIterable<T> {
+    private readonly source;
+    private readonly finalize;
+    fluxGateCostTrackingResponse: FluxGateCostTrackingResponse | undefined;
+    constructor(source: AsyncIterable<T>, finalize: (lastItem: T | undefined, error: Error | undefined) => Promise<FluxGateCostTrackingResponse>);
+    [Symbol.asyncIterator](): AsyncGenerator<T>;
+}

package/dist/wrappers/TrackedStream.js

@@ -0,0 +1,23 @@
+export class TrackedStream {
+    constructor(source, finalize) {
+        this.source = source;
+        this.finalize = finalize;
+    }
+    async *[Symbol.asyncIterator]() {
+        let last;
+        let streamError;
+        try {
+            for await (const item of this.source) {
+                last = item;
+                yield item;
+            }
+        }
+        catch (err) {
+            streamError = err;
+            throw err;
+        }
+        finally {
+            this.fluxGateCostTrackingResponse = await this.finalize(last, streamError);
+        }
+    }
+}

package/dist/wrappers/TrackedStream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/wrappers/TrackedStream.test.js

@@ -0,0 +1,168 @@
+import { describe, it, expect, vi } from "vitest";
+import { TrackedStream } from "./TrackedStream.js";
+describe("TrackedStream (Anthropic)", () => {
+    async function* createMockStream(items) {
+        for (const item of items) {
+            yield item;
+        }
+    }
+    async function* createErrorStream(items, errorAt) {
+        for (let i = 0; i < items.length; i++) {
+            if (i === errorAt) {
+                throw new Error("Stream error");
+            }
+            yield items[i];
+        }
+    }
+    describe("successful streams", () => {
+        it("should iterate through all items", async () => {
+            const items = [1, 2, 3, 4, 5];
+            const source = createMockStream(items);
+            const finalize = vi.fn().mockResolvedValue({
+                status: "SUCCESS",
+                cost: 0.001,
+                trackingId: "track-123",
+                createdAt: "2026-05-05T00:00:00Z",
+            });
+            const trackedStream = new TrackedStream(source, finalize);
+            const collected = [];
+            for await (const item of trackedStream) {
+                collected.push(item);
+            }
+            expect(collected).toEqual(items);
+        });
+        it("should call finalize with last item after stream completes", async () => {
+            const items = ["a", "b", "c"];
+            const source = createMockStream(items);
+            const finalize = vi.fn().mockResolvedValue({
+                status: "SUCCESS",
+                cost: 0.001,
+                trackingId: "track-123",
+                createdAt: "2026-05-05T00:00:00Z",
+            });
+            const trackedStream = new TrackedStream(source, finalize);
+            for await (const _ of trackedStream) {
+                // consume stream
+            }
+            expect(finalize).toHaveBeenCalledWith("c", undefined);
+        });
+        it("should set fluxGateCostTrackingResponse after stream completes", async () => {
+            const items = [1, 2, 3];
+            const source = createMockStream(items);
+            const mockResponse = {
+                status: "SUCCESS",
+                cost: 0.002,
+                trackingId: "track-456",
+                createdAt: "2026-05-05T00:00:00Z",
+            };
+            const finalize = vi.fn().mockResolvedValue(mockResponse);
+            const trackedStream = new TrackedStream(source, finalize);
+            expect(trackedStream.fluxGateCostTrackingResponse).toBeUndefined();
+            for await (const _ of trackedStream) {
+                // consume stream
+            }
+            expect(trackedStream.fluxGateCostTrackingResponse).toBeDefined();
+            expect(trackedStream.fluxGateCostTrackingResponse).toEqual(mockResponse);
+        });
+        it("should handle empty stream", async () => {
+            const source = createMockStream([]);
+            const finalize = vi.fn().mockResolvedValue({
+                status: "SUCCESS",
+                cost: 0,
+                trackingId: "track-789",
+                createdAt: "2026-05-05T00:00:00Z",
+            });
+            const trackedStream = new TrackedStream(source, finalize);
+            const collected = [];
+            for await (const item of trackedStream) {
+                collected.push(item);
+            }
+            expect(collected).toEqual([]);
+            expect(finalize).toHaveBeenCalledWith(undefined, undefined);
+        });
+    });
+    describe("error handling", () => {
+        it("should call finalize with error if stream throws", async () => {
+            const items = [1, 2, 3, 4, 5];
+            const source = createErrorStream(items, 2);
+            const finalize = vi.fn().mockResolvedValue({
+                status: "ERROR",
+                cost: null,
+                trackingId: "track-error",
+                createdAt: "2026-05-05T00:00:00Z",
+                errorMessage: "Stream error",
+            });
+            const trackedStream = new TrackedStream(source, finalize);
+            const collected = [];
+            try {
+                for await (const item of trackedStream) {
+                    collected.push(item);
+                }
+            }
+            catch (error) {
+                expect(error.message).toBe("Stream error");
+            }
+            expect(collected).toEqual([1, 2]);
+            expect(finalize).toHaveBeenCalledWith(2, expect.objectContaining({ message: "Stream error" }));
+        });
+        it("should set fluxGateCostTrackingResponse even when stream errors", async () => {
+            const items = [1, 2, 3];
+            const source = createErrorStream(items, 1);
+            const mockResponse = {
+                status: "ERROR",
+                cost: null,
+                trackingId: "track-error-2",
+                createdAt: "2026-05-05T00:00:00Z",
+                errorMessage: "Stream error",
+            };
+            const finalize = vi.fn().mockResolvedValue(mockResponse);
+            const trackedStream = new TrackedStream(source, finalize);
+            try {
+                for await (const _ of trackedStream) {
+                    // consume stream
+                }
+            }
+            catch (error) {
+                // expected error
+            }
+            expect(trackedStream.fluxGateCostTrackingResponse).toEqual(mockResponse);
+        });
+        it("should propagate the error after calling finalize", async () => {
+            const items = [1, 2, 3];
+            const source = createErrorStream(items, 1);
+            const finalize = vi.fn().mockResolvedValue({
+                status: "ERROR",
+                cost: null,
+                trackingId: null,
+                createdAt: null,
+                errorMessage: "Stream error",
+            });
+            const trackedStream = new TrackedStream(source, finalize);
+            await expect(async () => {
+                for await (const _ of trackedStream) {
+                    // consume stream
+                }
+            }).rejects.toThrow("Stream error");
+            expect(finalize).toHaveBeenCalled();
+        });
+    });
+    describe("multiple iterations", () => {
+        it("should track last item across full iteration", async () => {
+            const items = ["first", "second", "third", "last"];
+            const source = createMockStream(items);
+            const finalize = vi.fn().mockResolvedValue({
+                status: "SUCCESS",
+                cost: 0.003,
+                trackingId: "track-multi",
+                createdAt: "2026-05-05T00:00:00Z",
+            });
+            const trackedStream = new TrackedStream(source, finalize);
+            let lastSeen;
+            for await (const item of trackedStream) {
+                lastSeen = item;
+            }
+            expect(lastSeen).toBe("last");
+            expect(finalize).toHaveBeenCalledWith("last", undefined);
+        });
+    });
+});

package/dist/wrappers/createWrappedClient.d.ts

@@ -0,0 +1,9 @@
+import { AiEventMetadata, FluxGate, WithTracking } from "@fluxgate/sdk";
+import type Anthropic from "@anthropic-ai/sdk";
+import type { Message, RawMessageStreamEvent } from "@anthropic-ai/sdk/resources/messages";
+import { TrackedStream } from "./TrackedStream.js";
+import { TrackedAnthropic } from "../types/types.js";
+type OrigCreate = Anthropic["messages"]["create"];
+export declare function withAnthropicTracking(client: Anthropic, instance: FluxGate, context?: AiEventMetadata): TrackedAnthropic;
+export declare function createMessagesWrapper(original: OrigCreate, instance: FluxGate, context: AiEventMetadata | undefined): (params: Parameters<OrigCreate>[0], options?: Parameters<OrigCreate>[1]) => Promise<WithTracking<Message> | TrackedStream<RawMessageStreamEvent>>;
+export {};

package/dist/wrappers/createWrappedClient.js

@@ -0,0 +1,76 @@
+import { extractAnthropicUsage } from "../utils/extractUsage.js";
+import { isAsyncIterable } from "../utils/utils.js";
+import { TrackedStream } from "./TrackedStream.js";
+import { extractResponseStatus, recordUsage } from "../utils/recordUsage.js";
+export function withAnthropicTracking(client, instance, context) {
+    const wrappedClient = Object.create(Object.getPrototypeOf(client), Object.getOwnPropertyDescriptors(client));
+    wrappedClient.messages = Object.create(Object.getPrototypeOf(client.messages), Object.getOwnPropertyDescriptors(client.messages));
+    wrappedClient.messages.create = createMessagesWrapper(client.messages.create.bind(client.messages), instance, context);
+    return wrappedClient;
+}
+export function createMessagesWrapper(original, instance, context) {
+    return async function wrappedMessagesCreate(params, options) {
+        const start = performance.now();
+        let res;
+        try {
+            res = await original(params, options);
+        }
+        catch (err) {
+            await recordUsage({
+                instance,
+                model: params.model.toString(),
+                latencyMs: performance.now() - start,
+                streaming: !!params.stream,
+                context,
+                usage: extractAnthropicUsage(undefined),
+                status: "ERROR",
+                errorMessage: err.message,
+            });
+            throw err;
+        }
+        if (params.stream && isAsyncIterable(res)) {
+            let latestUsage;
+            let latestStopReason;
+            const trackingSource = (async function* () {
+                for await (const event of res) {
+                    if (event.type === "message_delta") {
+                        latestUsage = event.usage;
+                        latestStopReason = event.delta.stop_reason;
+                    }
+                    yield event;
+                }
+            })();
+            return new TrackedStream(trackingSource, (_last, streamError) => {
+                const { status, errorMessage } = streamError
+                    ? {
+                        status: "ERROR",
+                        errorMessage: streamError.message,
+                    }
+                    : extractResponseStatus(latestStopReason);
+                return recordUsage({
+                    instance,
+                    model: params.model.toString(),
+                    latencyMs: performance.now() - start,
+                    streaming: true,
+                    context,
+                    usage: extractAnthropicUsage(latestUsage),
+                    status,
+                    errorMessage,
+                });
+            });
+        }
+        const message = res;
+        const { status, errorMessage } = extractResponseStatus(message.stop_reason);
+        const fluxGateCostTrackingResponse = await recordUsage({
+            instance,
+            model: params.model.toString(),
+            latencyMs: performance.now() - start,
+            streaming: false,
+            context,
+            usage: extractAnthropicUsage(message.usage),
+            status,
+            errorMessage,
+        });
+        return Object.assign(message, { fluxGateCostTrackingResponse });
+    };
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@fluxgate/anthropic",
+  "version": "0.0.1",
+  "description": "Anthropic wrapper for FluxGate token usage, latency, and cost monitoring.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/types.d.ts"
+    }
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --root ../../",
+    "test:watch": "vitest --root ../../"
+  },
+  "keywords": [
+    "llm",
+    "tokens",
+    "tracker",
+    "anthropic",
+    "claude",
+    "monitoring",
+    "costs"
+  ],
+  "author": "FluxGate Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yehova73/fluxgate-npm.git",
+    "directory": "packages/anthropic"
+  },
+  "bugs": {
+    "url": "https://github.com/yehova73/fluxgate-npm/issues"
+  },
+  "homepage": "https://fluxgate.app",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@fluxgate/sdk": "^0.0.2-dev.0"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": "^0.50.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}