@jeffusion/bungee-llms 3.2.1 → 3.3.1

package/dist/protocol-converters/anthropic-to-openai.converter.d.ts

@@ -16,33 +16,31 @@ export declare class AnthropicToOpenAIConverter implements AIConverter {
     readonly from = "anthropic";
     readonly to = "openai";
     private configuredApiMode?;
-    private readonly protocolConversion;
-    private readonly runtime;
-    constructor();
     setApiMode(mode: unknown): void;
     setRuntimeOptions(options: unknown): void;
-    private parseIntegerOption;
-    private resolveReasoningMaxCompletionTokens;
     private resolveTargetApiMode;
     /**
      * 修改请求：转换为 OpenAI Chat Completions 格式
      */
     onBeforeRequest(ctx: MutableRequestContext): Promise<void>;
-    private canUseRuntimeRequestConversion;
     private isAnthropicCountTokensPath;
     private buildOpenAICountTokensRequest;
     /**
      * 构建 OpenAI 请求
      */
     private buildOpenAIRequest;
-    private isAnthropicThinkingEnabled;
-    private resolveAnthropicThinkingEffort;
-    private resolveOutputConfigEffort;
-    private normalizeOpenAIReasoningEffort;
-    private supportsXHighReasoningEffort;
+    private isOpenAINumericOSeriesModel;
     private buildOpenAIResponsesRequest;
+    private convertAnthropicSystemToInstructions;
+    private convertAnthropicMessagesToResponsesInput;
+    private convertAnthropicImageSourceToUrl;
+    private mapAnthropicToolChoiceToResponses;
+    private resolveAnthropicReasoningEffort;
+    private supportsReasoningEffort;
     private convertSystemMessages;
-    private validateAndCleanToolCalls;
+    private sanitizeSystemText;
+    private extractTextFromOpenAIContent;
+    private normalizeOpenAISystemMessages;
     /**
      * 转换 User 消息
      */
@@ -53,10 +51,10 @@ export declare class AnthropicToOpenAIConverter implements AIConverter {
      * 转换 Assistant 消息
      */
     private convertAssistantMessage;
-    private normalizeToolCallId;
-    private mapAnthropicToolChoiceToOpenAI;
-    private parseOpenAIImageUrlSource;
+    private normalizeOpenAIMessageContent;
     private normalizeToolParametersSchema;
+    private cleanOpenAIToolSchema;
+    private resolvePromptCacheKey;
     private normalizeJsonSchema;
     /**
      * 处理非流式响应：OpenAI → Anthropic
@@ -70,25 +68,31 @@ export declare class AnthropicToOpenAIConverter implements AIConverter {
     private isLikelyOpenAISuccessBody;
     private isResponsesApiBody;
     private extractReasoningSummaryTexts;
-    private appendUniqueThinkingBlocks;
-    private appendParsedContent;
-    private extractChatCompletionReasoningTexts;
+    private extractStrictResponsesReasoningText;
     private extractReasoningTextFromDeltaContentPart;
     private extractChatThinkingDelta;
     private getChatUsedIndices;
     private allocateChatContentBlockIndex;
     private ensureChatTextBlockStarted;
     private ensureChatThinkingBlockStarted;
+    private closeChatNonToolBlock;
     private resolveChatToolIndex;
     private resolveResponsesReasoningIndex;
+    private nextResponsesContentIndex;
+    private resolveResponsesContentIndex;
+    private ensureResponsesTextBlockStarted;
+    private resolveResponsesToolIndex;
     private ensureResponsesThinkingBlockStarted;
     private emitResponsesThinkingDelta;
     private extractResponsesReasoningDeltaText;
     private convertOpenAIResponsesToAnthropic;
+    private mapResponsesStopReason;
+    private buildAnthropicUsageFromResponses;
     /**
      * 转换 OpenAI 响应为 Anthropic 格式
      */
     private convertOpenAIResponseToAnthropic;
+    private parseToolArguments;
     /**
      * 处理流式响应：OpenAI chunk → Anthropic SSE
      */

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.1",
   "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.1"
   },
   "devDependencies": {
     "bun-types": "^1.3.2",