RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
feat(go-models): unify OpenAI-compatible token usage extraction (#17634)
jay77721fe02c9b95f8e
diff --git a/internal/entity/models/base_model.go b/internal/entity/models/base_model.goindex aa84385a6e..ea154153f7 100644--- a/internal/entity/models/base_model.go+++ b/internal/entity/models/base_model.go@@ -148,6 +148,86 @@ func (b *BaseModel) APIConfigCheck(apiConfig *APIConfig) error {return nil}+func newJSONPostRequest(ctx context.Context, url string, apiConfig *APIConfig, reqBody map[string]any) (*http.Request, error) {+ jsonData, err := json.Marshal(reqBody)+ if err != nil {+ return nil, fmt.Errorf("failed to marshal request: %w", err)+ }++ req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))+ if err != nil {+ return nil, fmt.Errorf("failed to create request: %w", err)+ }++ req.Header.Set("Content-Type", "application/json")+ if auth := BearerAuth(apiConfig); auth != "" {+ req.Header.Set("Authorization", auth)+ }++ return req, nil+}++// doRequest sends a JSON POST request and returns the response body.+func (b *BaseModel) doRequest(ctx context.Context, url string, apiConfig *APIConfig, reqBody map[string]any, timeout time.Duration) ([]byte, error) {+ ctx, cancel := context.WithTimeout(ctx, timeout)+ defer cancel()++ req, err := newJSONPostRequest(ctx, url, apiConfig, reqBody)+ if err != nil {+ return nil, err+ }++ resp, err := b.httpClient.Do(req)+ if err != nil {+ return nil, fmt.Errorf("failed to send request: %w", err)+ }+ defer resp.Body.Close()++ body, err := io.ReadAll(resp.Body)+ if err != nil {+ return nil, fmt.Errorf("failed to read response: %w", err)+ }++ if resp.StatusCode != http.StatusOK {+ return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))+ }++ return body, nil+}++// mustMarshal marshals v to JSON, panicking on error.+func mustMarshal(v any) []byte {+ b, err := json.Marshal(v)+ if err != nil {+ panic(fmt.Sprintf("failed to marshal: %v", err))+ }+ return b+}++// doStreamRequest sends a JSON POST request and calls handler with the response body.+func (b *BaseModel) doStreamRequest(ctx context.Context, url string, apiConfig *APIConfig, reqBody map[string]any, timeout time.Duration, handler func(io.ReadCloser) error) error {+ ctx, cancel := context.WithTimeout(ctx, timeout)+ defer cancel()++ req, err := newJSONPostRequest(ctx, url, apiConfig, reqBody)+ if err != nil {+ return err+ }++ resp, err := b.httpClient.Do(req)+ if err != nil {+ return fmt.Errorf("failed to send request: %w", err)+ }+ defer resp.Body.Close()++ if resp.StatusCode != http.StatusOK {+ body, _ := io.ReadAll(resp.Body)+ return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))+ }++ return handler(resp.Body)+}+// BearerAuth returns the Bearer token for Authorization header,// or empty string if apiConfig or its ApiKey is nil/empty.func BearerAuth(apiConfig *APIConfig) string {diff --git a/internal/entity/models/common_test.go b/internal/entity/models/common_test.goindex 09d5ca50b3..22fbf5b74e 100644--- a/internal/entity/models/common_test.go+++ b/internal/entity/models/common_test.go@@ -1,6 +1,14 @@package models-import "testing"+import (+ "context"+ "fmt"+ "io"+ "net/http"+ "net/http/httptest"+ "testing"+ "time"+)func TestNormalizeModelFamily(t *testing.T) {tests := []struct {@@ -97,6 +105,58 @@ func TestGetThinkingAndAnswerHandlesNilInputs(t *testing.T) {}}+func TestBaseModelDoRequestAuthorizationHeader(t *testing.T) {+ tests := []struct {+ name string+ apiConfig *APIConfig+ wantHeader string+ }{+ {name: "nil api config"},+ {name: "nil api key", apiConfig: &APIConfig{}},+ {name: "blank api key", apiConfig: &APIConfig{ApiKey: modelFamilyTestString(" ")}},+ {name: "api key", apiConfig: &APIConfig{ApiKey: modelFamilyTestString(" key-1 ")}, wantHeader: "Bearer key-1"},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if got := r.Header.Get("Authorization"); got != tt.wantHeader {+ t.Fatalf("Authorization = %q, want %q", got, tt.wantHeader)+ }+ if got := r.Header.Get("Content-Type"); got != "application/json" {+ t.Fatalf("Content-Type = %q, want application/json", got)+ }+ fmt.Fprint(w, `{"ok":true}`)+ }))+ defer server.Close()++ model := &BaseModel{httpClient: server.Client(), AllowEmptyAPIKey: true}+ if _, err := model.doRequest(context.Background(), server.URL, tt.apiConfig, map[string]any{"ok": true}, time.Second); err != nil {+ t.Fatalf("doRequest() error = %v", err)+ }+ })+ }+}++func TestBaseModelDoStreamRequestAllowsMissingAPIKey(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if got := r.Header.Get("Authorization"); got != "" {+ t.Fatalf("Authorization = %q, want empty", got)+ }+ fmt.Fprint(w, `data: {"ok":true}`)+ }))+ defer server.Close()++ model := &BaseModel{httpClient: server.Client(), AllowEmptyAPIKey: true}+ err := model.doStreamRequest(context.Background(), server.URL, nil, map[string]any{"ok": true}, time.Second, func(body io.ReadCloser) error {+ _, err := io.ReadAll(body)+ return err+ })+ if err != nil {+ t.Fatalf("doStreamRequest() error = %v", err)+ }+}+func modelFamilyTestString(value string) *string {return &value}diff --git a/internal/entity/models/deepseek.go b/internal/entity/models/deepseek.goindex 2ab0212bfe..bb8b0dde14 100644--- a/internal/entity/models/deepseek.go+++ b/internal/entity/models/deepseek.go@@ -100,7 +100,6 @@ func (d *DeepSeekModel) ChatWithMessages(ctx context.Context, modelName string,}url := fmt.Sprintf("%s/%s", resolvedBaseURL, d.baseModel.URLSuffix.Chat)- // Build request bodyreqBody := buildRequestBody(chatModelConfig, modelName, messages, false)if chatModelConfig != nil && chatModelConfig.Thinking != nil && *chatModelConfig.Thinking {var thinkingFlag string@@ -111,25 +110,19 @@ func (d *DeepSeekModel) ChatWithMessages(ctx context.Context, modelName string,switch effort {case "none":thinkingFlag = "disabled"- breakcase "low":thinkingFlag = "disabled"- breakcase "medium":thinkingFlag = "disabled"- breakcase "high":thinkingFlag = "enabled"reqBody["reasoning_effort"] = "high"- breakcase "default":thinkingFlag = "enabled"reqBody["reasoning_effort"] = "high"- breakcase "max":thinkingFlag = "enabled"reqBody["reasoning_effort"] = "max"- break}reqBody["thinking"] = map[string]interface{}{"type": thinkingFlag,@@ -140,67 +133,12 @@ func (d *DeepSeekModel) ChatWithMessages(ctx context.Context, modelName string,}}- jsonData, err := json.Marshal(reqBody)+ body, err := d.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := d.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- body, err := io.ReadAll(resp.Body)- if err != nil {- return nil, fmt.Errorf("failed to read response: %w", err)- }-- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))+ return nil, err}- return parseChatCompletionResponse(body, chatModelConfig, modelUsage, func(body []byte, _ *ChatConfig) (chatResponseParts, error) {- var result DeepSeekChatResponse- if err := json.Unmarshal(body, &result); err != nil {- return chatResponseParts{}, fmt.Errorf("failed to parse response: %w", err)- }-- if len(result.Choices) == 0 {- return chatResponseParts{}, fmt.Errorf("no choices in response")- }-- choice := &result.Choices[0]- reasonContent := choice.Message.ReasoningContent- // DeepSeek may prefix reasoning content with a newline in non-streaming- // responses; keep the existing provider behavior of removing that prefix.- if reasonContent != "" && reasonContent[0] == '\n' {- reasonContent = reasonContent[1:]- }-- return chatResponseParts{- RequestID: result.ID,- Content: &choice.Message.Content,- ReasonContent: &reasonContent,- ToolCalls: choice.Message.ToolCalls,- Usage: &TokenUsage{- PromptTokens: result.Usage.PromptTokens,- CompletionTokens: result.Usage.CompletionTokens,- TotalTokens: result.Usage.TotalTokens,- },- }, nil- })+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}// ChatStreamlyWithSender sends messages and streams response via sender function (best performance, no channel)@@ -219,7 +157,6 @@ func (d *DeepSeekModel) ChatStreamlyWithSender(ctx context.Context, modelName st}url := fmt.Sprintf("%s/chat/completions", resolvedBaseURL)- // Build request body with streaming enabledreqBody := buildRequestBody(chatModelConfig, modelName, messages, true)if chatModelConfig != nil && chatModelConfig.Thinking != nil && *chatModelConfig.Thinking {var thinkingFlag string@@ -282,68 +219,7 @@ func (d *DeepSeekModel) ChatStreamlyWithSender(ctx context.Context, modelName streturn fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))}- sawTerminal := false- accumulatedToolCalls := make(map[int]map[string]interface{})- done, err := ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- common.Info(fmt.Sprintf("%v", event))-- tokenUsage, found, usageErr := decodeOpenAICompatibleStreamUsage(event)- if usageErr != nil {- return usageErr- }- if found {- applyStreamUsage(chatModelConfig, modelUsage, tokenUsage)- }-- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- accumulateToolCallDeltas(delta, accumulatedToolCalls)-- content, ok := delta["content"].(string)- if ok && content != "" {- if err := sender(&content, nil); err != nil {- return err- }- }-- reasoningContent, ok := delta["reasoning_content"].(string)- if ok && reasoningContent != "" {- if err := sender(nil, &reasoningContent); err != nil {- return err- }- }-- finishReason, ok := firstChoice["finish_reason"].(string)- if ok && finishReason != "" {- sawTerminal = true- }- return nil- })- if err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }- if !done && !sawTerminal {- return fmt.Errorf("deepseek: stream ended before [DONE] or finish_reason")- }-- setSortedToolCallsResult(chatModelConfig, accumulatedToolCalls)-- // Send [DONE] marker for OpenAI compatibility- endOfStream := "[DONE]"- return sender(&endOfStream, nil)+ return HandleStreamingResponse(resp.Body, modelUsage, chatModelConfig, OpenAIParserConfig, sender)}// Embed embeds a list of texts into embeddingsdiff --git a/internal/entity/models/parser_config.go b/internal/entity/models/parser_config.gonew file mode 100644index 0000000000..28f7530212--- /dev/null+++ b/internal/entity/models/parser_config.go@@ -0,0 +1,36 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package models++// ParserConfig maps a protocol to its usage parsers. Drivers select a+// ParserConfig instead of implementing usage extraction individually.+type ParserConfig struct {+ // Protocol is the protocol identifier (e.g. "openai", "claude").+ Protocol string+ // ResponseParser extracts usage from a non-streaming response body.+ ResponseParser func(map[string]any) (*TokenUsage, bool)+ // StreamParser extracts usage from one streaming event.+ StreamParser func(map[string]any) (*TokenUsage, bool)+}++// OpenAIParserConfig is the ParserConfig for OpenAI-compatible APIs+// (NVIDIA NIM, DeepSeek, Aliyun, Moonshot, xAI, OpenRouter, ...).+var OpenAIParserConfig = &ParserConfig{+ Protocol: "openai",+ ResponseParser: extractOpenAIUsage,+ StreamParser: extractOpenAIStreamUsage,+}diff --git a/internal/entity/models/response_handler.go b/internal/entity/models/response_handler.gonew file mode 100644index 0000000000..f21e93aa83--- /dev/null+++ b/internal/entity/models/response_handler.go@@ -0,0 +1,235 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package models++import (+ "encoding/json"+ "fmt"+ "io"+ "ragflow/internal/common"++ "go.uber.org/zap"+)++// HandleNonStreamingResponse processes a complete non-streaming chat+// response using the ParserConfig's ResponseParser to extract usage.+func HandleNonStreamingResponse(+ body []byte,+ modelUsage *common.ModelUsage,+ chatConfig *ChatConfig,+ cfg *ParserConfig,+) (*ChatResponse, error) {+ var result map[string]any+ if err := json.Unmarshal(body, &result); err != nil {+ return nil, fmt.Errorf("failed to parse response: %w", err)+ }++ // Extract usage via the protocol-specific parser.+ var usage *TokenUsage+ if u, ok := cfg.ResponseParser(result); ok {+ usage = u+ }++ // Extract content / reasoning_content / tool_calls.+ content, reasonContent, toolCalls := extractContentAndChoices(result)++ if content == nil && len(toolCalls) == 0 {+ return nil, fmt.Errorf("no choices in response")+ }++ if usage != nil {+ recordResponseUsage(modelUsage, extractRequestID(result), usage, "chat")+ if chatConfig != nil {+ chatConfig.UsageResult = usage+ model, _ := result["model"].(string)+ common.Info("StreamUsage", zap.String("model", model), zap.Int("prompt", usage.PromptTokens), zap.Int("completion", usage.CompletionTokens), zap.Int("total", usage.TotalTokens))+ }+ }++ return &ChatResponse{+ Answer: content,+ ReasonContent: reasonContent,+ ToolCalls: toolCalls,+ Usage: usage,+ }, nil+}++// HandleStreamingResponse processes a streaming chat response using the+// ParserConfig's StreamParser to extract usage from each event.+func HandleStreamingResponse(+ body io.Reader,+ modelUsage *common.ModelUsage,+ chatConfig *ChatConfig,+ cfg *ParserConfig,+ sender func(*string, *string) error,+) error {+ if sender == nil {+ return fmt.Errorf("sender is required")+ }++ var streamUsage *TokenUsage+ accumulatedToolCalls := make(map[int]map[string]any)+ sawTerminal := false++ var streamModel string+ done, err := ParseSSEStream[map[string]any](body, func(event map[string]any) error {+ if u, ok := cfg.StreamParser(event); ok {+ streamUsage = u+ }+ if m, ok := event["model"].(string); ok {+ streamModel = m+ }++ if apiErr, ok := event["error"]; ok && apiErr != nil {+ return fmt.Errorf("upstream stream error: %v", apiErr)+ }++ choices, ok := event["choices"].([]any)+ if !ok || len(choices) == 0 {+ return nil+ }++ firstChoice, ok := choices[0].(map[string]any)+ if !ok {+ return nil+ }++ delta, ok := firstChoice["delta"].(map[string]any)+ if !ok {+ return nil+ }++ accumulateToolCallDeltas(delta, accumulatedToolCalls)++ if reasoningContent, ok := delta["reasoning_content"].(string); ok && reasoningContent != "" {+ if err := sender(nil, &reasoningContent); err != nil {+ return err+ }+ }++ if content, ok := delta["content"].(string); ok && content != "" {+ if err := sender(&content, nil); err != nil {+ return err+ }+ }++ if finishReason, ok := firstChoice["finish_reason"].(string); ok && finishReason != "" {+ sawTerminal = true+ }++ return nil+ })+ if err != nil {+ return fmt.Errorf("failed to scan response body: %w", err)+ }++ if chatConfig != nil {+ setSortedToolCallsResult(chatConfig, accumulatedToolCalls)+ }++ if !done && !sawTerminal {+ return fmt.Errorf("stream ended before [DONE] or finish_reason")+ }++ if streamUsage != nil {+ recordResponseUsage(modelUsage, "", streamUsage, "chat")+ if chatConfig != nil {+ chatConfig.UsageResult = streamUsage+ common.Info("StreamUsage", zap.String("model", streamModel), zap.Int("prompt", streamUsage.PromptTokens), zap.Int("completion", streamUsage.CompletionTokens), zap.Int("total", streamUsage.TotalTokens))+ }+ }++ endOfStream := "[DONE]"+ return sender(&endOfStream, nil)+}++// extractContentAndChoices extracts content, reasoning_content, and tool_calls+// from a parsed non-streaming response.+func extractContentAndChoices(result map[string]any) (*string, *string, []map[string]any) {+ choices, ok := result["choices"].([]any)+ if !ok || len(choices) == 0 {+ return nil, nil, nil+ }++ firstChoice, ok := choices[0].(map[string]any)+ if !ok {+ return nil, nil, nil+ }++ messageMap, ok := firstChoice["message"].(map[string]any)+ if !ok {+ return nil, nil, nil+ }++ var content *string+ if c, ok := messageMap["content"].(string); ok {+ cc := c+ content = &cc+ } else if _, ok := messageMap["tool_calls"].([]any); ok {+ // content may be nil when the response only carries tool calls.+ // Return an empty-string pointer so callers can rely on a non-nil Answer.+ empty := ""+ content = &empty+ } else if rc, ok := messageMap["reasoning_content"].(string); ok && rc != "" {+ // content may be nil when the response only carries reasoning_content.+ empty := ""+ content = &empty+ }++ var reasonContent *string+ if rc, ok := messageMap["reasoning_content"].(string); ok {+ reason := rc+ if reason != "" && reason[0] == '\n' {+ reason = reason[1:]+ }+ reasonContent = &reason+ } else {+ // Always return a non-nil pointer so callers can rely on it.+ empty := ""+ reasonContent = &empty+ }++ // Some providers (e.g. SiliconFlow) embed thinking inline via <think> tags.+ // Extract reasoning into ReasonContent and strip it from Answer.+ if content != nil {+ if reasoning, answer := extractThinkContent(content); reasoning != nil {+ rc := *reasoning+ reasonContent = &rc+ a := *answer+ content = &a+ }+ }++ var toolCalls []map[string]any+ if tcs, ok := messageMap["tool_calls"].([]any); ok {+ for _, tc := range tcs {+ if tcMap, ok := tc.(map[string]any); ok {+ toolCalls = append(toolCalls, tcMap)+ }+ }+ }++ return content, reasonContent, toolCalls+}++// extractRequestID extracts the request ID from a parsed response.+func extractRequestID(result map[string]any) string {+ if id, ok := result["id"].(string); ok {+ return id+ }+ return ""+}diff --git a/internal/entity/models/usage_parser.go b/internal/entity/models/usage_parser.gonew file mode 100644index 0000000000..6282e21773--- /dev/null+++ b/internal/entity/models/usage_parser.go@@ -0,0 +1,77 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package models++import "encoding/json"++// extractOpenAIUsage extracts token usage from an OpenAI-compatible+// non-streaming response body. Returns (nil, false) when the response+// carries no usable usage block.+func extractOpenAIUsage(body map[string]any) (*TokenUsage, bool) {+ rawUsage, ok := body["usage"].(map[string]any)+ if !ok {+ return nil, false+ }++ return tokenUsageFromRaw(rawUsage), true+}++// extractOpenAIStreamUsage extracts token usage from one OpenAI-compatible+// streaming event. A missing or null usage field is not an error.+func extractOpenAIStreamUsage(event map[string]any) (*TokenUsage, bool) {+ rawUsage, ok := event["usage"].(map[string]any)+ if !ok || rawUsage == nil {+ return nil, false+ }++ return tokenUsageFromRaw(rawUsage), true+}++func tokenUsageFromRaw(rawUsage map[string]any) *TokenUsage {+ usage := &TokenUsage{}+ usage.PromptTokens = extractToken(rawUsage, "prompt_tokens", "input_tokens")+ usage.CompletionTokens = extractToken(rawUsage, "completion_tokens", "output_tokens")+ usage.TotalTokens = extractToken(rawUsage, "total_tokens")++ if usage.TotalTokens == 0 {+ usage.TotalTokens = usage.PromptTokens + usage.CompletionTokens+ }++ return usage+}++// extractToken reads a numeric field from a map, trying each key in order.+// Returns 0 when no key is present or the value is not a number.+func extractToken(m map[string]any, keys ...string) int {+ for _, k := range keys {+ if v, ok := m[k]; ok {+ switch val := v.(type) {+ case float64:+ return int(val)+ case int:+ return val+ case int64:+ return int(val)+ case json.Number:+ if n, err := val.Int64(); err == nil {+ return int(n)+ }+ }+ }+ }+ return 0+}diff --git a/internal/entity/models/usage_parser_test.go b/internal/entity/models/usage_parser_test.gonew file mode 100644index 0000000000..674eca7709--- /dev/null+++ b/internal/entity/models/usage_parser_test.go@@ -0,0 +1,153 @@+package models++import (+ "testing"+)++func TestExtractOpenAIUsage(t *testing.T) {+ cases := []struct {+ name string+ body map[string]any+ want *TokenUsage+ wantOK bool+ }{+ {+ name: "standard openai",+ body: map[string]any{+ "usage": map[string]any{+ "prompt_tokens": float64(10),+ "completion_tokens": float64(20),+ "total_tokens": float64(30),+ },+ },+ want: &TokenUsage{PromptTokens: 10, CompletionTokens: 20, TotalTokens: 30},+ wantOK: true,+ },+ {+ name: "total missing falls back to sum",+ body: map[string]any{+ "usage": map[string]any{+ "prompt_tokens": float64(10),+ "completion_tokens": float64(20),+ },+ },+ want: &TokenUsage{PromptTokens: 10, CompletionTokens: 20, TotalTokens: 30},+ wantOK: true,+ },+ {+ name: "no usage key",+ body: map[string]any{+ "choices": []any{map[string]any{"message": map[string]any{"content": "hi"}}},+ },+ want: nil,+ wantOK: false,+ },+ {+ name: "cohere style input_tokens/output_tokens",+ body: map[string]any{+ "usage": map[string]any{+ "input_tokens": float64(100),+ "output_tokens": float64(50),+ },+ },+ want: &TokenUsage{PromptTokens: 100, CompletionTokens: 50, TotalTokens: 150},+ wantOK: true,+ },+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ got, ok := extractOpenAIUsage(tc.body)+ if ok != tc.wantOK {+ t.Fatalf("extractOpenAIUsage() ok = %v, want %v", ok, tc.wantOK)+ }+ if !tc.wantOK {+ return+ }+ if got.PromptTokens != tc.want.PromptTokens ||+ got.CompletionTokens != tc.want.CompletionTokens ||+ got.TotalTokens != tc.want.TotalTokens {+ t.Fatalf("extractOpenAIUsage() = %+v, want %+v", got, tc.want)+ }+ })+ }+}++func TestExtractOpenAIStreamUsage(t *testing.T) {+ cases := []struct {+ name string+ event map[string]any+ want *TokenUsage+ wantOK bool+ }{+ {+ name: "standard streaming event",+ event: map[string]any{+ "usage": map[string]any{+ "prompt_tokens": float64(100),+ "completion_tokens": float64(50),+ "total_tokens": float64(150),+ },+ },+ want: &TokenUsage{PromptTokens: 100, CompletionTokens: 50, TotalTokens: 150},+ wantOK: true,+ },+ {+ name: "null usage",+ event: map[string]any{+ "usage": nil,+ },+ want: nil,+ wantOK: false,+ },+ {+ name: "no usage key",+ event: map[string]any{+ "choices": []any{map[string]any{"delta": map[string]any{"content": "hi"}}},+ },+ want: nil,+ wantOK: false,+ },+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ got, ok := extractOpenAIStreamUsage(tc.event)+ if ok != tc.wantOK {+ t.Fatalf("extractOpenAIStreamUsage() ok = %v, want %v", ok, tc.wantOK)+ }+ if !tc.wantOK {+ return+ }+ if got.PromptTokens != tc.want.PromptTokens ||+ got.CompletionTokens != tc.want.CompletionTokens ||+ got.TotalTokens != tc.want.TotalTokens {+ t.Fatalf("extractOpenAIStreamUsage() = %+v, want %+v", got, tc.want)+ }+ })+ }+}++func TestExtractToken(t *testing.T) {+ m := map[string]any{+ "a": float64(1),+ "b": int(2),+ "c": int64(3),+ }++ if got := extractToken(m, "a"); got != 1 {+ t.Fatalf("extractToken(a) = %d, want 1", got)+ }+ if got := extractToken(m, "b"); got != 2 {+ t.Fatalf("extractToken(b) = %d, want 2", got)+ }+ if got := extractToken(m, "c"); got != 3 {+ t.Fatalf("extractToken(c) = %d, want 3", got)+ }+ if got := extractToken(m, "missing"); got != 0 {+ t.Fatalf("extractToken(missing) = %d, want 0", got)+ }+ if got := extractToken(m, "missing", "a"); got != 1 {+ t.Fatalf("extractToken(missing, a) = %d, want 1", got)+ }+}