@jeffusion/bungee-llms 3.2.1 → 3.3.0

package/dist/token-accounting/capabilities.d.ts

@@ -0,0 +1,47 @@
+import type { LLMProvider } from '../core/types';
+import type { ProviderTokenAccountingCapabilities } from './types';
+export declare const PROVIDER_TOKEN_ACCOUNTING_CAPABILITY_MATRIX: {
+    readonly openai: {
+        readonly provider: "openai";
+        readonly supportsOfficialResponseUsage: true;
+        readonly supportsStreamingResponseUsage: true;
+        readonly supportsDedicatedCountEndpoint: true;
+        readonly supportsLocalTokenizer: true;
+        readonly supportsHeuristicFallback: true;
+        readonly dedicatedCountEndpoint: {
+            readonly supported: true;
+            readonly mode: "input_estimate_only";
+            readonly defaultEnabled: false;
+            readonly endpoint: "/responses/input_tokens";
+            readonly livePathAuthority: false;
+        };
+    };
+    readonly anthropic: {
+        readonly provider: "anthropic";
+        readonly supportsOfficialResponseUsage: true;
+        readonly supportsStreamingResponseUsage: true;
+        readonly supportsDedicatedCountEndpoint: true;
+        readonly supportsLocalTokenizer: true;
+        readonly supportsHeuristicFallback: true;
+        readonly dedicatedCountEndpoint: {
+            readonly supported: true;
+            readonly mode: "input_estimate_only";
+            readonly livePathAuthority: false;
+            readonly endpoint: "/v1/messages/count_tokens";
+        };
+    };
+    readonly gemini: {
+        readonly provider: "gemini";
+        readonly supportsOfficialResponseUsage: true;
+        readonly supportsStreamingResponseUsage: true;
+        readonly supportsDedicatedCountEndpoint: true;
+        readonly supportsLocalTokenizer: true;
+        readonly supportsHeuristicFallback: true;
+        readonly countTokens: {
+            readonly supported: true;
+            readonly mode: "input_estimate_only";
+            readonly livePathAuthority: false;
+        };
+    };
+};
+export declare function getProviderTokenAccountingCapabilities(provider: LLMProvider): ProviderTokenAccountingCapabilities;

package/dist/token-accounting/helpers.d.ts

@@ -0,0 +1,16 @@
+import type { CanonicalTokenAccountingEventV2, TokenAccountingOutcome, TokenAccountingSessionState } from './types';
+type JsonRecord = Record<string, unknown>;
+export declare function isRecord(value: unknown): value is JsonRecord;
+export declare function asString(value: unknown): string | undefined;
+export declare function asFiniteNumber(value: unknown): number | undefined;
+export declare function readNumber(record: JsonRecord | undefined, key: string): number | undefined;
+export declare function readRecord(record: JsonRecord | undefined, key: string): JsonRecord | undefined;
+export declare function countTextTokens(text: string): number;
+export declare function countModelTextTokens(text: string, model?: string): number;
+export declare function countJsonLikeTokens(value: unknown): number;
+export declare function clampTokens(value: number | undefined): number | undefined;
+export declare function buildBaseEvent(state: TokenAccountingSessionState, overrides: Partial<CanonicalTokenAccountingEventV2>): CanonicalTokenAccountingEventV2;
+export declare function createPartialTokenAccountingEvent(state: TokenAccountingSessionState, overrides?: Partial<CanonicalTokenAccountingEventV2>): CanonicalTokenAccountingEventV2;
+export declare function finalizeTokenAccountingEvent(state: TokenAccountingSessionState, overrides?: Partial<CanonicalTokenAccountingEventV2>, outcome?: TokenAccountingOutcome): CanonicalTokenAccountingEventV2;
+export declare function assertCanonicalTokenAccountingEventV2(event: unknown): asserts event is CanonicalTokenAccountingEventV2;
+export {};

package/dist/token-accounting/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './helpers';
+export * from './capabilities';
+export * from './session';

package/dist/token-accounting/session.d.ts

@@ -0,0 +1,2 @@
+import type { TokenAccountingSession, TokenAccountingSessionInput } from './types';
+export declare function createTokenAccountingSession(input: TokenAccountingSessionInput): TokenAccountingSession;

package/dist/token-accounting/types.d.ts

@@ -0,0 +1,96 @@
+import type { LLMProvider } from '../core/types';
+export declare const SUPPORTED_TOKEN_ACCOUNTING_PROVIDERS: readonly ["openai", "anthropic", "gemini"];
+export type SupportedTokenAccountingProvider = typeof SUPPORTED_TOKEN_ACCOUNTING_PROVIDERS[number];
+export declare const TOKEN_ACCOUNTING_AUTHORITIES: readonly ["official", "local", "heuristic", "partial", "none"];
+export declare const TOKEN_ACCOUNTING_OUTCOMES: readonly ["completed", "aborted", "failed"];
+export type TokenAccountingAuthority = typeof TOKEN_ACCOUNTING_AUTHORITIES[number];
+export type TokenAccountingOutcome = typeof TOKEN_ACCOUNTING_OUTCOMES[number];
+export interface CanonicalTokenAccountingEventV2 {
+    requestId: string;
+    attemptId: string;
+    routeId: string;
+    upstreamId: string;
+    provider: LLMProvider;
+    model: string;
+    streaming: boolean;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    inputAuthority: TokenAccountingAuthority;
+    outputAuthority: TokenAccountingAuthority;
+    final: boolean;
+    outcome: TokenAccountingOutcome;
+    countedAt: string;
+}
+export interface TokenAccountingSessionInput {
+    provider: LLMProvider;
+    model?: string;
+    routeId: string;
+    upstreamId: string;
+    requestId: string;
+    attemptId: string;
+    streaming: boolean;
+}
+export interface TokenAccountingRequestInput {
+    body: Record<string, unknown>;
+}
+export interface TokenAccountingResponseInput {
+    body: Record<string, unknown>;
+}
+export interface TokenAccountingStreamChunkInput {
+    chunk: Record<string, unknown>;
+}
+export interface TokenAccountingSession {
+    consumeRequest(input: TokenAccountingRequestInput): void;
+    consumeResponse(input: TokenAccountingResponseInput): CanonicalTokenAccountingEventV2;
+    consumeStreamChunk(input: TokenAccountingStreamChunkInput): CanonicalTokenAccountingEventV2 | null;
+    finalizeAbortedStream(): CanonicalTokenAccountingEventV2;
+}
+export interface DedicatedCountEndpointCapability {
+    supported: boolean;
+    mode: 'input_estimate_only';
+    livePathAuthority: false;
+    defaultEnabled?: false;
+    endpoint?: string;
+}
+export interface ProviderTokenAccountingCapabilities {
+    provider: SupportedTokenAccountingProvider;
+    supportsOfficialResponseUsage: boolean;
+    supportsStreamingResponseUsage: boolean;
+    supportsDedicatedCountEndpoint: boolean;
+    supportsLocalTokenizer: boolean;
+    supportsHeuristicFallback: boolean;
+    dedicatedCountEndpoint?: DedicatedCountEndpointCapability;
+    countTokens?: {
+        supported: boolean;
+        mode: 'input_estimate_only';
+        livePathAuthority: false;
+    };
+}
+export type ProviderTokenAccountingCapabilityMatrix = Record<SupportedTokenAccountingProvider, ProviderTokenAccountingCapabilities>;
+export interface TokenAccountingSessionState {
+    provider: LLMProvider;
+    routeId: string;
+    upstreamId: string;
+    requestId: string;
+    attemptId: string;
+    streaming: boolean;
+    model?: string;
+    requestBody?: Record<string, unknown>;
+    estimatedInputTokens?: number;
+    estimatedInputAuthority?: TokenAccountingAuthority;
+    outputTokens?: number;
+    outputAuthority?: TokenAccountingAuthority;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    finalReceived: boolean;
+}
+export interface ProviderTokenAccountingAdapter {
+    readonly provider: LLMProvider;
+    readonly capabilities: ProviderTokenAccountingCapabilities;
+    consumeRequest(state: TokenAccountingSessionState, body: Record<string, unknown>): void;
+    consumeResponse(state: TokenAccountingSessionState, body: Record<string, unknown>): CanonicalTokenAccountingEventV2;
+    consumeStreamChunk(state: TokenAccountingSessionState, chunk: Record<string, unknown>): CanonicalTokenAccountingEventV2 | null;
+    finalizeAbortedStream(state: TokenAccountingSessionState): CanonicalTokenAccountingEventV2;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jeffusion/bungee-llms",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "description": "Extensible LLM adapters and protocol conversion package for Bungee",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@jeffusion/bungee-types": "^3.2.1"
+    "@jeffusion/bungee-types": "^3.3.0"
   },
   "devDependencies": {
     "bun-types": "^1.3.2",