@fluxgate/anthropic 0.0.1 → 0.0.2

package/dist/index.d.ts

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

package/dist/index.test.js

@@ -56,7 +56,7 @@ describe("createAnthropicCostTracker", () => {
                     id: "user-123",
                     name: "Test User",
                     email: "test@example.com",
-                    monthlyRevenue: 99.99,
+                    monthlyRevenue: "99.99",
                 },
                 conversationId: "conv-789",
             });
@@ -67,8 +67,7 @@ describe("createAnthropicCostTracker", () => {
             const contextClient = tracker.withContext({
                 feature: "chat",
                 step: "generation",
-                customField: "custom value",
-                anotherField: 123,
+                region: "us-east-1",
             });
             expect(contextClient).toBeDefined();
         });

package/dist/types/types.d.ts

@@ -1,13 +1,44 @@
 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 { Completion, CompletionCreateParams, CompletionCreateParamsNonStreaming, CompletionCreateParamsStreaming } from "@anthropic-ai/sdk/resources/completions";
+import type { BetaMessage, BetaRawMessageStreamEvent, MessageCreateParams as BetaMessageCreateParams, MessageCreateParamsNonStreaming as BetaMessageCreateParamsNonStreaming, MessageCreateParamsStreaming as BetaMessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/beta/messages/messages";
+import type { WithTracking, TrackedUser, AiEventMetadata, CostOverride } from "@fluxgate/sdk";
 import type { TrackedStream } from "../wrappers/TrackedStream.js";
 type MessageCreateOptions = Parameters<Anthropic["messages"]["create"]>[1];
-export type TrackedAnthropic = Omit<Anthropic, "messages"> & {
+type CompletionCreateOptions = Parameters<Anthropic["completions"]["create"]>[1];
+type BetaMessageCreateOptions = Parameters<Anthropic["beta"]["messages"]["create"]>[1];
+export type TrackedAnthropic = Omit<Anthropic, "messages" | "completions" | "beta"> & {
     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>>;
     };
+    completions: Omit<Anthropic["completions"], "create"> & {
+        create(body: CompletionCreateParamsNonStreaming, options?: CompletionCreateOptions): Promise<WithTracking<Completion>>;
+        create(body: CompletionCreateParamsStreaming, options?: CompletionCreateOptions): Promise<TrackedStream<Completion>>;
+        create(body: CompletionCreateParams, options?: CompletionCreateOptions): Promise<WithTracking<Completion> | TrackedStream<Completion>>;
+    };
+    beta: Omit<Anthropic["beta"], "messages"> & {
+        messages: Omit<Anthropic["beta"]["messages"], "create"> & {
+            create(params: BetaMessageCreateParamsNonStreaming, options?: BetaMessageCreateOptions): Promise<WithTracking<BetaMessage>>;
+            create(params: BetaMessageCreateParamsStreaming, options?: BetaMessageCreateOptions): Promise<TrackedStream<BetaRawMessageStreamEvent>>;
+            create(params: BetaMessageCreateParams, options?: BetaMessageCreateOptions): Promise<WithTracking<BetaMessage> | TrackedStream<BetaRawMessageStreamEvent>>;
+        };
+    };
+};
+export type FluxGateContext = {
+    user?: string | TrackedUser;
+    feature?: string;
+    step?: string;
+    sessionId?: string;
+    conversationId?: string;
+    timestamp?: number;
+    serviceTier?: AiEventMetadata["serviceTier"];
+    region?: string;
+    openrouterCost?: number;
+    cacheTtl?: string;
+    costOverride?: CostOverride;
+    /** Arbitrary key-value pairs forwarded to the metadata object (e.g. { language: "typescript", documentType: "article" }) */
+    metadata?: Record<string, unknown>;
 };
 export {};

package/dist/utils/extractUsage.d.ts

@@ -1,9 +1,9 @@
-import type { ExtractedUsage } from "@fluxgate/sdk";
+import type { AiEventUsage } 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 declare function extractAnthropicUsage(usage: AnthropicUsage | null | undefined): AiEventUsage;
 export {};

package/dist/utils/extractUsage.js

@@ -1,18 +1,14 @@
 export function extractAnthropicUsage(usage) {
     if (!usage) {
         return {
-            inputTokens: 0,
-            outputTokens: 0,
-            cachedTokens: 0,
-            totalTokens: 0,
+            promptTokens: 0,
+            completionTokens: 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),
+        promptTokens: usage.input_tokens ?? 0,
+        completionTokens: usage.output_tokens ?? 0,
+        cacheWriteTokens: usage.cache_creation_input_tokens || undefined,
+        cacheReadTokens: usage.cache_read_input_tokens || undefined,
     };
 }

package/dist/utils/extractUsage.test.js

@@ -11,10 +11,10 @@ describe("extractAnthropicUsage", () => {
             };
             const result = extractAnthropicUsage(usage);
             expect(result).toEqual({
-                inputTokens: 100,
-                outputTokens: 50,
-                cachedTokens: 30,
-                totalTokens: 150,
+                promptTokens: 100,
+                completionTokens: 50,
+                cacheWriteTokens: 20,
+                cacheReadTokens: 10,
             });
         });
         it("should handle missing cached token fields", () => {
@@ -24,10 +24,8 @@ describe("extractAnthropicUsage", () => {
             };
             const result = extractAnthropicUsage(usage);
             expect(result).toEqual({
-                inputTokens: 100,
-                outputTokens: 50,
-                cachedTokens: 0,
-                totalTokens: 150,
+                promptTokens: 100,
+                completionTokens: 50,
             });
         });
         it("should handle null cached token fields", () => {
@@ -39,10 +37,8 @@ describe("extractAnthropicUsage", () => {
             };
             const result = extractAnthropicUsage(usage);
             expect(result).toEqual({
-                inputTokens: 120,
-                outputTokens: 30,
-                cachedTokens: 0,
-                totalTokens: 150,
+                promptTokens: 120,
+                completionTokens: 30,
             });
         });
     });
@@ -50,19 +46,15 @@ describe("extractAnthropicUsage", () => {
         it("should return zero values for null usage", () => {
             const result = extractAnthropicUsage(null);
             expect(result).toEqual({
-                inputTokens: 0,
-                outputTokens: 0,
-                cachedTokens: 0,
-                totalTokens: 0,
+                promptTokens: 0,
+                completionTokens: 0,
             });
         });
         it("should return zero values for undefined usage", () => {
             const result = extractAnthropicUsage(undefined);
             expect(result).toEqual({
-                inputTokens: 0,
-                outputTokens: 0,
-                cachedTokens: 0,
-                totalTokens: 0,
+                promptTokens: 0,
+                completionTokens: 0,
             });
         });
         it("should handle partial usage object", () => {
@@ -72,10 +64,8 @@ describe("extractAnthropicUsage", () => {
             };
             const result = extractAnthropicUsage(usage);
             expect(result).toEqual({
-                inputTokens: 80,
-                outputTokens: 0,
-                cachedTokens: 0,
-                totalTokens: 80,
+                promptTokens: 80,
+                completionTokens: 0,
             });
         });
     });
@@ -89,10 +79,8 @@ describe("extractAnthropicUsage", () => {
             };
             const result = extractAnthropicUsage(usage);
             expect(result).toEqual({
-                inputTokens: 0,
-                outputTokens: 0,
-                cachedTokens: 0,
-                totalTokens: 0,
+                promptTokens: 0,
+                completionTokens: 0,
             });
         });
         it("should handle very large token counts", () => {
@@ -104,10 +92,10 @@ describe("extractAnthropicUsage", () => {
             };
             const result = extractAnthropicUsage(usage);
             expect(result).toEqual({
-                inputTokens: 1000000,
-                outputTokens: 500000,
-                cachedTokens: 300000,
-                totalTokens: 1500000,
+                promptTokens: 1000000,
+                completionTokens: 500000,
+                cacheWriteTokens: 200000,
+                cacheReadTokens: 100000,
             });
         });
     });

package/dist/utils/recordUsage.d.ts

@@ -1,12 +1,13 @@
-import { AiEventMetadata, AiEventStatus, ExtractedUsage, FluxGate, FluxGateCostTrackingResponse } from "@fluxgate/sdk";
+import { AiEventStatus, FluxGate, FluxGateCostTrackingResponse, AiEventUsage } from "@fluxgate/sdk";
+import { FluxGateContext } from "../types/types.js";
 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;
+    context: FluxGateContext | undefined;
+    usage: AiEventUsage;
     status: AiEventStatus;
     errorMessage?: string;
 }): Promise<FluxGateCostTrackingResponse>;

package/dist/utils/recordUsage.js

@@ -1,13 +1,7 @@
-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;
+function toPerformanceStatus(status) {
+    return status === "ERROR" || status === "MALFORMED_REQUEST"
+        ? "ERROR"
+        : "SUCCESS";
 }
 export function stopReasonToStatus(stopReason) {
     if (!stopReason ||
@@ -28,29 +22,46 @@ export function stopReasonToStatus(stopReason) {
 }
 export async function recordUsage(params) {
     const { context, latencyMs, model, streaming, instance, usage, status, errorMessage, } = params;
+    const resolvedServiceTier = context?.serviceTier;
+    const hasMetadata = resolvedServiceTier != null ||
+        context?.region != null ||
+        context?.openrouterCost != null ||
+        context?.cacheTtl != null ||
+        (context?.metadata != null && Object.keys(context.metadata).length > 0);
+    const metadata = hasMetadata
+        ? {
+            serviceTier: resolvedServiceTier,
+            region: context?.region,
+            openrouterCost: context?.openrouterCost,
+            cacheTtl: context?.cacheTtl,
+            ...context?.metadata,
+        }
+        : undefined;
     const trackingData = await instance.recordEvent({
-        metadata: normalizeMetadata(context),
-        status: {
-            status,
-            errorMessage,
-        },
-        usage: {
-            inputTokens: usage.inputTokens,
-            outputTokens: usage.outputTokens,
-            cachedTokens: usage.cachedTokens,
-            model,
+        provider: "anthropic",
+        model,
+        user: context?.user,
+        feature: context?.feature,
+        step: context?.step,
+        sessionId: context?.sessionId,
+        conversationId: context?.conversationId,
+        timestamp: context?.timestamp,
+        performance: {
+            latency: latencyMs,
+            status: toPerformanceStatus(status),
             isStreamed: streaming,
-            latencyInMs: latencyMs,
-            provider: "anthropic",
-            streamingDurationInMs: streaming ? latencyMs : undefined,
+            errorMessage: errorMessage ?? null,
         },
+        usage,
+        ...(metadata && { metadata }),
+        ...(context?.costOverride && { costOverride: context.costOverride }),
     });
     return {
         status,
         errorMessage,
-        cost: trackingData?.cost ?? null,
-        trackingId: trackingData?.id ?? null,
-        createdAt: trackingData?.createdAt ?? null,
+        cost: trackingData?.totalCost ?? null,
+        trackingId: trackingData?.recordId ?? null,
+        createdAt: null,
     };
 }
 export function extractResponseStatus(stopReason) {

package/dist/wrappers/betaMessages.d.ts

@@ -0,0 +1,8 @@
+import { FluxGate, WithTracking } from "@fluxgate/sdk";
+import { FluxGateContext } from "../types/types.js";
+import type Anthropic from "@anthropic-ai/sdk";
+import type { BetaMessage, BetaRawMessageStreamEvent } from "@anthropic-ai/sdk/resources/beta/messages/messages";
+import { TrackedStream } from "./TrackedStream.js";
+type OrigCreate = Anthropic["beta"]["messages"]["create"];
+export declare function createBetaMessagesWrapper(original: OrigCreate, instance: FluxGate, context: FluxGateContext | undefined): (params: Parameters<OrigCreate>[0], options?: Parameters<OrigCreate>[1]) => Promise<WithTracking<BetaMessage> | TrackedStream<BetaRawMessageStreamEvent>>;
+export {};

package/dist/wrappers/betaMessages.js

@@ -0,0 +1,70 @@
+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 createBetaMessagesWrapper(original, instance, context) {
+    return async function wrappedBetaMessagesCreate(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/dist/wrappers/completions.d.ts

@@ -0,0 +1,8 @@
+import { FluxGate, WithTracking } from "@fluxgate/sdk";
+import { FluxGateContext } from "../types/types.js";
+import type Anthropic from "@anthropic-ai/sdk";
+import type { Completion } from "@anthropic-ai/sdk/resources/completions";
+import { TrackedStream } from "./TrackedStream.js";
+type OrigCreate = Anthropic["completions"]["create"];
+export declare function createCompletionsWrapper(original: OrigCreate, instance: FluxGate, context: FluxGateContext | undefined): (params: Parameters<OrigCreate>[0], options?: Parameters<OrigCreate>[1]) => Promise<WithTracking<Completion> | TrackedStream<Completion>>;
+export {};

package/dist/wrappers/completions.js

@@ -0,0 +1,70 @@
+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 createCompletionsWrapper(original, instance, context) {
+    return async function wrappedCompletionsCreate(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 latestStopReason;
+            const trackingSource = (async function* () {
+                for await (const chunk of res) {
+                    if (chunk.stop_reason) {
+                        latestStopReason = chunk.stop_reason;
+                    }
+                    yield chunk;
+                }
+            })();
+            return new TrackedStream(trackingSource, (_last, streamError) => {
+                const { status, errorMessage } = streamError
+                    ? {
+                        status: "ERROR",
+                        errorMessage: streamError.message,
+                    }
+                    : extractResponseStatus(latestStopReason);
+                // The legacy completions API does not return token usage
+                return recordUsage({
+                    instance,
+                    model: params.model.toString(),
+                    latencyMs: performance.now() - start,
+                    streaming: true,
+                    context,
+                    usage: extractAnthropicUsage(undefined),
+                    status,
+                    errorMessage,
+                });
+            });
+        }
+        const completion = res;
+        const { status, errorMessage } = extractResponseStatus(completion.stop_reason);
+        // The legacy completions API does not return token usage
+        const fluxGateCostTrackingResponse = await recordUsage({
+            instance,
+            model: params.model.toString(),
+            latencyMs: performance.now() - start,
+            streaming: false,
+            context,
+            usage: extractAnthropicUsage(undefined),
+            status,
+            errorMessage,
+        });
+        return Object.assign(completion, { fluxGateCostTrackingResponse });
+    };
+}

package/dist/wrappers/createWrappedClient.d.ts

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

package/dist/wrappers/createWrappedClient.js

@@ -2,10 +2,17 @@ import { extractAnthropicUsage } from "../utils/extractUsage.js";
 import { isAsyncIterable } from "../utils/utils.js";
 import { TrackedStream } from "./TrackedStream.js";
 import { extractResponseStatus, recordUsage } from "../utils/recordUsage.js";
+import { createCompletionsWrapper } from "./completions.js";
+import { createBetaMessagesWrapper } from "./betaMessages.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);
+    wrappedClient.completions = Object.create(Object.getPrototypeOf(client.completions), Object.getOwnPropertyDescriptors(client.completions));
+    wrappedClient.completions.create = createCompletionsWrapper(client.completions.create.bind(client.completions), instance, context);
+    wrappedClient.beta = Object.create(Object.getPrototypeOf(client.beta), Object.getOwnPropertyDescriptors(client.beta));
+    wrappedClient.beta.messages = Object.create(Object.getPrototypeOf(client.beta.messages), Object.getOwnPropertyDescriptors(client.beta.messages));
+    wrappedClient.beta.messages.create = createBetaMessagesWrapper(client.beta.messages.create.bind(client.beta.messages), instance, context);
     return wrappedClient;
 }
 export function createMessagesWrapper(original, instance, context) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluxgate/anthropic",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Anthropic wrapper for FluxGate token usage, latency, and cost monitoring.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -50,7 +50,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@fluxgate/sdk": "^0.0.2-dev.0"
+    "@fluxgate/sdk": "^0.0.3-dev.0"
   },
   "peerDependencies": {
     "@anthropic-ai/sdk": "^0.50.0"