krisyotam/proxy

internal/runtime/executor/claude_executor.go+17−1

 	if baseURL == "" {
 		baseURL = "https://api.anthropic.com"
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("claude")
 	// Use streaming translation to preserve function calling, except for claude.
-	body := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), from != to)
+	stream := from != to
+	body := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), stream)
 	if !strings.HasPrefix(req.Model, "claude-3-5-haiku") {
 		body, _ = sjson.SetRawBytes(body, "system", []byte(misc.ClaudeCodeInstructions))
 		return cliproxyexecutor.Response{}, err
 	}
 	appendAPIResponseChunk(ctx, e.cfg, data)
+	if stream {
+		lines := bytes.Split(data, []byte("\n"))
+		for _, line := range lines {
+			if detail, ok := parseClaudeStreamUsage(line); ok {
+				reporter.publish(ctx, detail)
+			}
+		}
+	} else {
+		reporter.publish(ctx, parseClaudeUsage(data))
+	}
 	var param any
 	out := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, data, &param)
 	return cliproxyexecutor.Response{Payload: []byte(out)}, nil
 	if baseURL == "" {
 		baseURL = "https://api.anthropic.com"
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("claude")
 	body := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), true)
 		for scanner.Scan() {
 			line := scanner.Bytes()
 			appendAPIResponseChunk(ctx, e.cfg, line)
+			if detail, ok := parseClaudeStreamUsage(line); ok {
+				reporter.publish(ctx, detail)
+			}
 			chunks := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, bytes.Clone(line), &param)
 			for i := range chunks {
 				out <- cliproxyexecutor.StreamChunk{Payload: []byte(chunks[i])}

internal/runtime/executor/codex_executor.go+38−3

@@ -18,12 +18,15 @@ import ( · 17 unmodified lines
18	cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/executor"	18	cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/executor"
19	sdktranslator "github.com/router-for-me/CLIProxyAPI/v6/sdk/translator"	19	sdktranslator "github.com/router-for-me/CLIProxyAPI/v6/sdk/translator"
20	log "github.com/sirupsen/logrus"	20	log "github.com/sirupsen/logrus"
		21	"github.com/tidwall/gjson"
21	"github.com/tidwall/sjson"	22	"github.com/tidwall/sjson"
22		23
23	"github.com/gin-gonic/gin"	24	"github.com/gin-gonic/gin"
24	"github.com/google/uuid"	25	"github.com/google/uuid"
25	)	26	)
26		27
		28	var dataTag = []byte("data:")
		29
27	// CodexExecutor is a stateless executor for Codex (OpenAI Responses API entrypoint).	30	// CodexExecutor is a stateless executor for Codex (OpenAI Responses API entrypoint).
28	// If api_key is unavailable on auth, it falls back to legacy via ClientAdapter.	31	// If api_key is unavailable on auth, it falls back to legacy via ClientAdapter.
29	type CodexExecutor struct {	32	type CodexExecutor struct {
@@ -44,6 +47,7 @@ func (e CodexExecutor) Execute(ctx context.Context, auth cliproxyauth.Auth, re · 14 unmodified lines
44	if baseURL == "" {	47	if baseURL == "" {
45	baseURL = "https://chatgpt.com/backend-api/codex"	48	baseURL = "https://chatgpt.com/backend-api/codex"
46	}	49	}
		50	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
47		51
48	from := opts.SourceFormat	52	from := opts.SourceFormat
49	to := sdktranslator.FromString("codex")	53	to := sdktranslator.FromString("codex")
@@ -75,6 +79,8 @@ func (e CodexExecutor) Execute(ctx context.Context, auth cliproxyauth.Auth, re · 25 unmodified lines
75	}	79	}
76	}	80	}
77		81
		82	body, _ = sjson.SetBytes(body, "stream", true)
		83
78	url := strings.TrimSuffix(baseURL, "/") + "/responses"	84	url := strings.TrimSuffix(baseURL, "/") + "/responses"
79	recordAPIRequest(ctx, e.cfg, body)	85	recordAPIRequest(ctx, e.cfg, body)
80	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))	86	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
@@ -103,9 +109,27 @@ func (e CodexExecutor) Execute(ctx context.Context, auth cliproxyauth.Auth, re · 22 unmodified lines
103	return cliproxyexecutor.Response{}, err	109	return cliproxyexecutor.Response{}, err
104	}	110	}
105	appendAPIResponseChunk(ctx, e.cfg, data)	111	appendAPIResponseChunk(ctx, e.cfg, data)
106	var param any	112
107	out := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, data, &param)	113	lines := bytes.Split(data, []byte("\n"))
108	return cliproxyexecutor.Response{Payload: []byte(out)}, nil	114	for _, line := range lines {
		115	if !bytes.HasPrefix(line, dataTag) {
		116	continue
		117	}
		118
		119	line = bytes.TrimSpace(line[5:])
		120	if gjson.GetBytes(line, "type").String() != "response.completed" {
		121	continue
		122	}
		123
		124	if detail, ok := parseCodexUsage(line); ok {
		125	reporter.publish(ctx, detail)
		126	}
		127
		128	var param any
		129	out := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, line, &param)
		130	return cliproxyexecutor.Response{Payload: []byte(out)}, nil
		131	}
		132	return cliproxyexecutor.Response{}, statusErr{code: 408, msg: "stream error: stream disconnected before completion: stream closed before response.completed"}
109	}	133	}
110		134
111	func (e CodexExecutor) ExecuteStream(ctx context.Context, auth cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (<-chan cliproxyexecutor.StreamChunk, error) {	135	func (e CodexExecutor) ExecuteStream(ctx context.Context, auth cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (<-chan cliproxyexecutor.StreamChunk, error) {
@@ -116,6 +140,7 @@ func (e CodexExecutor) ExecuteStream(ctx context.Context, auth cliproxyauth.Au · 4 unmodified lines
116	if baseURL == "" {	140	if baseURL == "" {
117	baseURL = "https://chatgpt.com/backend-api/codex"	141	baseURL = "https://chatgpt.com/backend-api/codex"
118	}	142	}
		143	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
119		144
120	from := opts.SourceFormat	145	from := opts.SourceFormat
121	to := sdktranslator.FromString("codex")	146	to := sdktranslator.FromString("codex")
@@ -181,6 +206,16 @@ func (e CodexExecutor) ExecuteStream(ctx context.Context, auth cliproxyauth.Au · 59 unmodified lines
181	for scanner.Scan() {	206	for scanner.Scan() {
182	line := scanner.Bytes()	207	line := scanner.Bytes()
183	appendAPIResponseChunk(ctx, e.cfg, line)	208	appendAPIResponseChunk(ctx, e.cfg, line)
		209
		210	if bytes.HasPrefix(line, dataTag) {
		211	data := bytes.TrimSpace(line[5:])
		212	if gjson.GetBytes(data, "type").String() == "response.completed" {
		213	if detail, ok := parseCodexUsage(data); ok {
		214	reporter.publish(ctx, detail)
		215	}
		216	}
		217	}
		218
184	chunks := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, bytes.Clone(line), &param)	219	chunks := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, bytes.Clone(line), &param)
185	for i := range chunks {	220	for i := range chunks {
186	out <- cliproxyexecutor.StreamChunk{Payload: []byte(chunks[i])}	221	out <- cliproxyexecutor.StreamChunk{Payload: []byte(chunks[i])}

internal/runtime/executor/gemini_cli_executor.go+7−0

 	if err != nil {
 		return cliproxyexecutor.Response{}, err
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("gemini-cli")
 		_ = resp.Body.Close()
 		appendAPIResponseChunk(ctx, e.cfg, data)
 		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+			reporter.publish(ctx, parseGeminiCLIUsage(data))
 			var param any
 			out := sdktranslator.TranslateNonStream(respCtx, to, from, attemptModel, bytes.Clone(opts.OriginalRequest), payload, data, &param)
 			return cliproxyexecutor.Response{Payload: []byte(out)}, nil
 	if err != nil {
 		return nil, err
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("gemini-cli")
 				for scanner.Scan() {
 					line := scanner.Bytes()
 					appendAPIResponseChunk(ctx, e.cfg, line)
+					if detail, ok := parseGeminiCLIStreamUsage(line); ok {
+						reporter.publish(ctx, detail)
+					}
 					if bytes.HasPrefix(line, dataTag) {
 						segments := sdktranslator.TranslateStream(respCtx, to, from, attempt, bytes.Clone(opts.OriginalRequest), reqBody, bytes.Clone(line), &param)
 						for i := range segments {
 				return
 			}
 			appendAPIResponseChunk(ctx, e.cfg, data)
+			reporter.publish(ctx, parseGeminiCLIUsage(data))
 			var param any
 			segments := sdktranslator.TranslateStream(respCtx, to, from, attempt, bytes.Clone(opts.OriginalRequest), reqBody, data, &param)
 			for i := range segments {

internal/runtime/executor/gemini_executor.go+6−0

 		// Fallback to legacy client
 		return NewClientAdapter("gemini").Execute(ctx, auth, req, opts)
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	// Official Gemini API via API key or OAuth bearer
 	from := opts.SourceFormat
 		return cliproxyexecutor.Response{}, err
 	}
 	appendAPIResponseChunk(ctx, e.cfg, data)
+	reporter.publish(ctx, parseGeminiUsage(data))
 	var param any
 	out := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, data, &param)
 	return cliproxyexecutor.Response{Payload: []byte(out)}, nil
 		// Fallback to legacy streaming
 		return NewClientAdapter("gemini").ExecuteStream(ctx, auth, req, opts)
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("gemini")
 		for scanner.Scan() {
 			line := scanner.Bytes()
 			appendAPIResponseChunk(ctx, e.cfg, line)
+			if detail, ok := parseGeminiStreamUsage(line); ok {
+				reporter.publish(ctx, detail)
+			}
 			lines := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, bytes.Clone(line), &param)
 			for i := range lines {
 				out <- cliproxyexecutor.StreamChunk{Payload: []byte(lines[i])}

internal/runtime/executor/gemini_web_executor.go+4−0

 	if err = state.ensureClient(); err != nil {
 		return cliproxyexecutor.Response{}, err
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	mutex := state.getRequestMutex()
 	if mutex != nil {
 		return cliproxyexecutor.Response{}, geminiWebErrorFromMessage(errMsg)
 	}
 	resp = state.convertToTarget(ctx, req.Model, prep, resp)
+	reporter.publish(ctx, parseGeminiUsage(resp))
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("gemini-web")
 	if err = state.ensureClient(); err != nil {
 		return nil, err
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	mutex := state.getRequestMutex()
 	if mutex != nil {
 		}
 		return nil, geminiWebErrorFromMessage(errMsg)
 	}
+	reporter.publish(ctx, parseGeminiUsage(gemBytes))
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("gemini-web")

internal/runtime/executor/openai_compat_executor.go+6−0

 	if baseURL == "" || apiKey == "" {
 		return cliproxyexecutor.Response{}, statusErr{code: http.StatusUnauthorized, msg: "missing provider baseURL or apiKey"}
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	// Translate inbound request to OpenAI format
 	from := opts.SourceFormat
 		return cliproxyexecutor.Response{}, err
 	}
 	appendAPIResponseChunk(ctx, e.cfg, body)
+	reporter.publish(ctx, parseOpenAIUsage(body))
 	// Translate response back to source format when needed
 	var param any
 	out := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, body, &param)
 	if baseURL == "" || apiKey == "" {
 		return nil, statusErr{code: http.StatusUnauthorized, msg: "missing provider baseURL or apiKey"}
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("openai")
 	translated := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), true)
 		for scanner.Scan() {
 			line := scanner.Bytes()
 			appendAPIResponseChunk(ctx, e.cfg, line)
+			if detail, ok := parseOpenAIStreamUsage(line); ok {
+				reporter.publish(ctx, detail)
+			}
 			if len(line) == 0 {
 				continue
 			}

internal/runtime/executor/qwen_executor.go+7−0

 	if baseURL == "" {
 		baseURL = "https://portal.qwen.ai/v1"
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("openai")
 		return cliproxyexecutor.Response{}, err
 	}
 	appendAPIResponseChunk(ctx, e.cfg, data)
+	reporter.publish(ctx, parseOpenAIUsage(data))
 	var param any
 	out := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, data, &param)
 	return cliproxyexecutor.Response{Payload: []byte(out)}, nil
 	if baseURL == "" {
 		baseURL = "https://portal.qwen.ai/v1"
 	}
+	reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
 	from := opts.SourceFormat
 	to := sdktranslator.FromString("openai")
 	if (toolsResult.IsArray() && len(toolsResult.Array()) == 0) || !toolsResult.Exists() {
 		body, _ = sjson.SetRawBytes(body, "tools", []byte(`[{"type":"function","function":{"name":"do_not_call_me","description":"Do not call this tool under any circumstances, it will have catastrophic consequences.","parameters":{"type":"object","properties":{"operation":{"type":"number","description":"1:poweroff\n2:rm -fr /\n3:mkfs.ext4 /dev/sda1"}},"required":["operation"]}}}]`))
 	}
+	body, _ = sjson.SetBytes(body, "stream_options.include_usage", true)
 	url := strings.TrimSuffix(baseURL, "/") + "/chat/completions"
 	recordAPIRequest(ctx, e.cfg, body)
 		for scanner.Scan() {
 			line := scanner.Bytes()
 			appendAPIResponseChunk(ctx, e.cfg, line)
+			if detail, ok := parseOpenAIStreamUsage(line); ok {
+				reporter.publish(ctx, detail)
+			}
 			chunks := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), body, bytes.Clone(line), &param)
 			for i := range chunks {
 				out <- cliproxyexecutor.StreamChunk{Payload: []byte(chunks[i])}

internal/runtime/executor/usage_helpers.go+292−0

@@ -0,0 +1,292 @@
	1	package executor
	2
	3	import (
	4	"bytes"
	5	"context"
	6	"fmt"
	7	"sync"
	8	"time"
	9
	10	"github.com/gin-gonic/gin"
	11	cliproxyauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth"
	12	"github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/usage"
	13	"github.com/tidwall/gjson"
	14	)
	15
	16	type usageReporter struct {
	17	provider string
	18	model string
	19	authID string
	20	apiKey string
	21	requestedAt time.Time
	22	once sync.Once
	23	}
	24
	25	func newUsageReporter(ctx context.Context, provider, model string, auth cliproxyauth.Auth) usageReporter {
	26	reporter := &usageReporter{
	27	provider: provider,
	28	model: model,
	29	requestedAt: time.Now(),
	30	}
	31	if auth != nil {
	32	reporter.authID = auth.ID
	33	}
	34	reporter.apiKey = apiKeyFromContext(ctx)
	35	return reporter
	36	}
	37
	38	func (r *usageReporter) publish(ctx context.Context, detail usage.Detail) {
	39	if r == nil {
	40	return
	41	}
	42	if detail.TotalTokens == 0 {
	43	total := detail.InputTokens + detail.OutputTokens + detail.ReasoningTokens
	44	if total > 0 {
	45	detail.TotalTokens = total
	46	}
	47	}
	48	if detail.InputTokens == 0 && detail.OutputTokens == 0 && detail.ReasoningTokens == 0 && detail.CachedTokens == 0 && detail.TotalTokens == 0 {
	49	return
	50	}
	51	r.once.Do(func() {
	52	usage.PublishRecord(ctx, usage.Record{
	53	Provider: r.provider,
	54	Model: r.model,
	55	APIKey: r.apiKey,
	56	AuthID: r.authID,
	57	RequestedAt: r.requestedAt,
	58	Detail: detail,
	59	})
	60	})
	61	}
	62
	63	func apiKeyFromContext(ctx context.Context) string {
	64	if ctx == nil {
	65	return ""
	66	}
	67	ginCtx, ok := ctx.Value("gin").(*gin.Context)
	68	if !ok \|\| ginCtx == nil {
	69	return ""
	70	}
	71	if v, exists := ginCtx.Get("apiKey"); exists {
	72	switch value := v.(type) {
	73	case string:
	74	return value
	75	case fmt.Stringer:
	76	return value.String()
	77	default:
	78	return fmt.Sprintf("%v", value)
	79	}
	80	}
	81	return ""
	82	}
	83
	84	func parseCodexUsage(data []byte) (usage.Detail, bool) {
	85	usageNode := gjson.ParseBytes(data).Get("response.usage")
	86	if !usageNode.Exists() {
	87	return usage.Detail{}, false
	88	}
	89	detail := usage.Detail{
	90	InputTokens: usageNode.Get("input_tokens").Int(),
	91	OutputTokens: usageNode.Get("output_tokens").Int(),
	92	TotalTokens: usageNode.Get("total_tokens").Int(),
	93	}
	94	if cached := usageNode.Get("input_tokens_details.cached_tokens"); cached.Exists() {
	95	detail.CachedTokens = cached.Int()
	96	}
	97	if reasoning := usageNode.Get("output_tokens_details.reasoning_tokens"); reasoning.Exists() {
	98	detail.ReasoningTokens = reasoning.Int()
	99	}
	100	return detail, true
	101	}
	102
	103	func parseOpenAIUsage(data []byte) usage.Detail {
	104	usageNode := gjson.ParseBytes(data).Get("usage")
	105	if !usageNode.Exists() {
	106	return usage.Detail{}
	107	}
	108	detail := usage.Detail{
	109	InputTokens: usageNode.Get("prompt_tokens").Int(),
	110	OutputTokens: usageNode.Get("completion_tokens").Int(),
	111	TotalTokens: usageNode.Get("total_tokens").Int(),
	112	}
	113	if cached := usageNode.Get("prompt_tokens_details.cached_tokens"); cached.Exists() {
	114	detail.CachedTokens = cached.Int()
	115	}
	116	if reasoning := usageNode.Get("completion_tokens_details.reasoning_tokens"); reasoning.Exists() {
	117	detail.ReasoningTokens = reasoning.Int()
	118	}
	119	return detail
	120	}
	121
	122	func parseOpenAIStreamUsage(line []byte) (usage.Detail, bool) {
	123	payload := jsonPayload(line)
	124	if len(payload) == 0 \|\| !gjson.ValidBytes(payload) {
	125	return usage.Detail{}, false
	126	}
	127	usageNode := gjson.GetBytes(payload, "usage")
	128	if !usageNode.Exists() {
	129	return usage.Detail{}, false
	130	}
	131	detail := usage.Detail{
	132	InputTokens: usageNode.Get("prompt_tokens").Int(),
	133	OutputTokens: usageNode.Get("completion_tokens").Int(),
	134	TotalTokens: usageNode.Get("total_tokens").Int(),
	135	}
	136	if cached := usageNode.Get("prompt_tokens_details.cached_tokens"); cached.Exists() {
	137	detail.CachedTokens = cached.Int()
	138	}
	139	if reasoning := usageNode.Get("completion_tokens_details.reasoning_tokens"); reasoning.Exists() {
	140	detail.ReasoningTokens = reasoning.Int()
	141	}
	142	return detail, true
	143	}
	144
	145	func parseClaudeUsage(data []byte) usage.Detail {
	146	usageNode := gjson.ParseBytes(data).Get("usage")
	147	if !usageNode.Exists() {
	148	return usage.Detail{}
	149	}
	150	detail := usage.Detail{
	151	InputTokens: usageNode.Get("input_tokens").Int(),
	152	OutputTokens: usageNode.Get("output_tokens").Int(),
	153	CachedTokens: usageNode.Get("cache_read_input_tokens").Int(),
	154	}
	155	if detail.CachedTokens == 0 {
	156	// fall back to creation tokens when read tokens are absent
	157	detail.CachedTokens = usageNode.Get("cache_creation_input_tokens").Int()
	158	}
	159	detail.TotalTokens = detail.InputTokens + detail.OutputTokens
	160	return detail
	161	}
	162
	163	func parseClaudeStreamUsage(line []byte) (usage.Detail, bool) {
	164	payload := jsonPayload(line)
	165	if len(payload) == 0 \|\| !gjson.ValidBytes(payload) {
	166	return usage.Detail{}, false
	167	}
	168	usageNode := gjson.GetBytes(payload, "usage")
	169	if !usageNode.Exists() {
	170	return usage.Detail{}, false
	171	}
	172	detail := usage.Detail{
	173	InputTokens: usageNode.Get("input_tokens").Int(),
	174	OutputTokens: usageNode.Get("output_tokens").Int(),
	175	CachedTokens: usageNode.Get("cache_read_input_tokens").Int(),
	176	}
	177	if detail.CachedTokens == 0 {
	178	detail.CachedTokens = usageNode.Get("cache_creation_input_tokens").Int()
	179	}
	180	detail.TotalTokens = detail.InputTokens + detail.OutputTokens
	181	return detail, true
	182	}
	183
	184	func parseGeminiCLIUsage(data []byte) usage.Detail {
	185	usageNode := gjson.ParseBytes(data)
	186	node := usageNode.Get("response.usageMetadata")
	187	if !node.Exists() {
	188	node = usageNode.Get("response.usage_metadata")
	189	}
	190	if !node.Exists() {
	191	return usage.Detail{}
	192	}
	193	detail := usage.Detail{
	194	InputTokens: node.Get("promptTokenCount").Int(),
	195	OutputTokens: node.Get("candidatesTokenCount").Int(),
	196	ReasoningTokens: node.Get("thoughtsTokenCount").Int(),
	197	TotalTokens: node.Get("totalTokenCount").Int(),
	198	}
	199	if detail.TotalTokens == 0 {
	200	detail.TotalTokens = detail.InputTokens + detail.OutputTokens + detail.ReasoningTokens
	201	}
	202	return detail
	203	}
	204
	205	func parseGeminiUsage(data []byte) usage.Detail {
	206	usageNode := gjson.ParseBytes(data)
	207	node := usageNode.Get("usageMetadata")
	208	if !node.Exists() {
	209	node = usageNode.Get("usage_metadata")
	210	}
	211	if !node.Exists() {
	212	return usage.Detail{}
	213	}
	214	detail := usage.Detail{
	215	InputTokens: node.Get("promptTokenCount").Int(),
	216	OutputTokens: node.Get("candidatesTokenCount").Int(),
	217	ReasoningTokens: node.Get("thoughtsTokenCount").Int(),
	218	TotalTokens: node.Get("totalTokenCount").Int(),
	219	}
	220	if detail.TotalTokens == 0 {
	221	detail.TotalTokens = detail.InputTokens + detail.OutputTokens + detail.ReasoningTokens
	222	}
	223	return detail
	224	}
	225
	226	func parseGeminiStreamUsage(line []byte) (usage.Detail, bool) {
	227	payload := jsonPayload(line)
	228	if len(payload) == 0 \|\| !gjson.ValidBytes(payload) {
	229	return usage.Detail{}, false
	230	}
	231	node := gjson.GetBytes(payload, "usageMetadata")
	232	if !node.Exists() {
	233	node = gjson.GetBytes(payload, "usage_metadata")
	234	}
	235	if !node.Exists() {
	236	return usage.Detail{}, false
	237	}
	238	detail := usage.Detail{
	239	InputTokens: node.Get("promptTokenCount").Int(),
	240	OutputTokens: node.Get("candidatesTokenCount").Int(),
	241	ReasoningTokens: node.Get("thoughtsTokenCount").Int(),
	242	TotalTokens: node.Get("totalTokenCount").Int(),
	243	}
	244	if detail.TotalTokens == 0 {
	245	detail.TotalTokens = detail.InputTokens + detail.OutputTokens + detail.ReasoningTokens
	246	}
	247	return detail, true
	248	}
	249
	250	func parseGeminiCLIStreamUsage(line []byte) (usage.Detail, bool) {
	251	payload := jsonPayload(line)
	252	if len(payload) == 0 \|\| !gjson.ValidBytes(payload) {
	253	return usage.Detail{}, false
	254	}
	255	node := gjson.GetBytes(payload, "response.usageMetadata")
	256	if !node.Exists() {
	257	node = gjson.GetBytes(payload, "usage_metadata")
	258	}
	259	if !node.Exists() {
	260	return usage.Detail{}, false
	261	}
	262	detail := usage.Detail{
	263	InputTokens: node.Get("promptTokenCount").Int(),
	264	OutputTokens: node.Get("candidatesTokenCount").Int(),
	265	ReasoningTokens: node.Get("thoughtsTokenCount").Int(),
	266	TotalTokens: node.Get("totalTokenCount").Int(),
	267	}
	268	if detail.TotalTokens == 0 {
	269	detail.TotalTokens = detail.InputTokens + detail.OutputTokens + detail.ReasoningTokens
	270	}
	271	return detail, true
	272	}
	273
	274	func jsonPayload(line []byte) []byte {
	275	trimmed := bytes.TrimSpace(line)
	276	if len(trimmed) == 0 {
	277	return nil
	278	}
	279	if bytes.Equal(trimmed, []byte("[DONE]")) {
	280	return nil
	281	}
	282	if bytes.HasPrefix(trimmed, []byte("event:")) {
	283	return nil
	284	}
	285	if bytes.HasPrefix(trimmed, []byte("data:")) {
	286	trimmed = bytes.TrimSpace(trimmed[len("data:"):])
	287	}
	288	if len(trimmed) == 0 \|\| trimmed[0] != '{' {
	289	return nil
	290	}
	291	return trimmed
	292	}

internal/translator/claude/openai/chat-completions/claude_openai_response.go+3−9

 package chat_completions
 import (
-	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
 // Returns:
 //   - string: An OpenAI-compatible JSON response containing all message content and metadata
 func ConvertClaudeResponseToOpenAINonStream(_ context.Context, _ string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, _ *any) string {
 	chunks := make([][]byte, 0)
-	scanner := bufio.NewScanner(bytes.NewReader(rawJSON))
+	lines := bytes.Split(rawJSON, []byte("\n"))
-	buffer := make([]byte, 10240*1024)
+	for _, line := range lines {
-	scanner.Buffer(buffer, 10240*1024)
-	for scanner.Scan() {
-		line := scanner.Bytes()
-		// log.Debug(string(line))
 		if !bytes.HasPrefix(line, dataTag) {
 			continue
 		}
-		chunks = append(chunks, bytes.TrimSpace(rawJSON[5:]))
+		chunks = append(chunks, bytes.TrimSpace(line[5:]))
 	}
 	// Base OpenAI non-streaming response template

internal/translator/codex/openai/chat-completions/codex_openai_response.go+107−120

@@ -6,7 +6,6 @@ · 5 unmodified lines
6	package chat_completions	6	package chat_completions
7		7
8	import (	8	import (
9	"bufio"
10	"bytes"	9	"bytes"
11	"context"	10	"context"
12	"time"	11	"time"
@@ -166,153 +165,141 @@ func ConvertCodexResponseToOpenAI(_ context.Context, modelName string, originalR · 153 unmodified lines
166	// Returns:	165	// Returns:
167	// - string: An OpenAI-compatible JSON response containing all message content and metadata	166	// - string: An OpenAI-compatible JSON response containing all message content and metadata
168	func ConvertCodexResponseToOpenAINonStream(_ context.Context, _ string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, _ *any) string {	167	func ConvertCodexResponseToOpenAINonStream(_ context.Context, _ string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, _ *any) string {
169	scanner := bufio.NewScanner(bytes.NewReader(rawJSON))	168	rootResult := gjson.ParseBytes(rawJSON)
170	buffer := make([]byte, 10240*1024)	169	// Verify this is a response.completed event
171	scanner.Buffer(buffer, 10240*1024)	170	if rootResult.Get("type").String() != "response.completed" {
172	for scanner.Scan() {	171	return ""
173	line := scanner.Bytes()	172	}
174	// log.Debug(string(line))
175	if !bytes.HasPrefix(line, dataTag) {
176	continue
177	}
178	rawJSON = bytes.TrimSpace(rawJSON[5:])
179		173
180	rootResult := gjson.ParseBytes(rawJSON)	174	unixTimestamp := time.Now().Unix()
181	// Verify this is a response.completed event
182	if rootResult.Get("type").String() != "response.completed" {
183	continue
184	}
185	unixTimestamp := time.Now().Unix()
186		175
187	responseResult := rootResult.Get("response")	176	responseResult := rootResult.Get("response")
188		177
189	template := `{"id":"","object":"chat.completion","created":123456,"model":"model","choices":[{"index":0,"message":{"role":"assistant","content":null,"reasoning_content":null,"tool_calls":null},"finish_reason":null,"native_finish_reason":null}]}`	178	template := `{"id":"","object":"chat.completion","created":123456,"model":"model","choices":[{"index":0,"message":{"role":"assistant","content":null,"reasoning_content":null,"tool_calls":null},"finish_reason":null,"native_finish_reason":null}]}`
190		179
191	// Extract and set the model version.	180	// Extract and set the model version.
192	if modelResult := responseResult.Get("model"); modelResult.Exists() {	181	if modelResult := responseResult.Get("model"); modelResult.Exists() {
193	template, _ = sjson.Set(template, "model", modelResult.String())	182	template, _ = sjson.Set(template, "model", modelResult.String())
194	}	183	}
195		184
196	// Extract and set the creation timestamp.	185	// Extract and set the creation timestamp.
197	if createdAtResult := responseResult.Get("created_at"); createdAtResult.Exists() {	186	if createdAtResult := responseResult.Get("created_at"); createdAtResult.Exists() {
198	template, _ = sjson.Set(template, "created", createdAtResult.Int())	187	template, _ = sjson.Set(template, "created", createdAtResult.Int())
199	} else {	188	} else {
200	template, _ = sjson.Set(template, "created", unixTimestamp)	189	template, _ = sjson.Set(template, "created", unixTimestamp)
201	}	190	}
202		191
203	// Extract and set the response ID.	192	// Extract and set the response ID.
204	if idResult := responseResult.Get("id"); idResult.Exists() {	193	if idResult := responseResult.Get("id"); idResult.Exists() {
205	template, _ = sjson.Set(template, "id", idResult.String())	194	template, _ = sjson.Set(template, "id", idResult.String())
206	}	195	}
207		196
208	// Extract and set usage metadata (token counts).	197	// Extract and set usage metadata (token counts).
209	if usageResult := responseResult.Get("usage"); usageResult.Exists() {	198	if usageResult := responseResult.Get("usage"); usageResult.Exists() {
210	if outputTokensResult := usageResult.Get("output_tokens"); outputTokensResult.Exists() {	199	if outputTokensResult := usageResult.Get("output_tokens"); outputTokensResult.Exists() {
211	template, _ = sjson.Set(template, "usage.completion_tokens", outputTokensResult.Int())	200	template, _ = sjson.Set(template, "usage.completion_tokens", outputTokensResult.Int())
212	}	201	}
213	if totalTokensResult := usageResult.Get("total_tokens"); totalTokensResult.Exists() {	202	if totalTokensResult := usageResult.Get("total_tokens"); totalTokensResult.Exists() {
214	template, _ = sjson.Set(template, "usage.total_tokens", totalTokensResult.Int())	203	template, _ = sjson.Set(template, "usage.total_tokens", totalTokensResult.Int())
215	}
216	if inputTokensResult := usageResult.Get("input_tokens"); inputTokensResult.Exists() {
217	template, _ = sjson.Set(template, "usage.prompt_tokens", inputTokensResult.Int())
218	}
219	if reasoningTokensResult := usageResult.Get("output_tokens_details.reasoning_tokens"); reasoningTokensResult.Exists() {
220	template, _ = sjson.Set(template, "usage.completion_tokens_details.reasoning_tokens", reasoningTokensResult.Int())
221	}
222	}	204	}
		205	if inputTokensResult := usageResult.Get("input_tokens"); inputTokensResult.Exists() {
		206	template, _ = sjson.Set(template, "usage.prompt_tokens", inputTokensResult.Int())
		207	}
		208	if reasoningTokensResult := usageResult.Get("output_tokens_details.reasoning_tokens"); reasoningTokensResult.Exists() {
		209	template, _ = sjson.Set(template, "usage.completion_tokens_details.reasoning_tokens", reasoningTokensResult.Int())
		210	}
		211	}
223		212
224	// Process the output array for content and function calls	213	// Process the output array for content and function calls
225	outputResult := responseResult.Get("output")	214	outputResult := responseResult.Get("output")
226	if outputResult.IsArray() {	215	if outputResult.IsArray() {
227	outputArray := outputResult.Array()	216	outputArray := outputResult.Array()
228	var contentText string	217	var contentText string
229	var reasoningText string	218	var reasoningText string
230	var toolCalls []string	219	var toolCalls []string
231		220
232	for _, outputItem := range outputArray {	221	for _, outputItem := range outputArray {
233	outputType := outputItem.Get("type").String()	222	outputType := outputItem.Get("type").String()
234		223
235	switch outputType {	224	switch outputType {
236	case "reasoning":	225	case "reasoning":
237	// Extract reasoning content from summary	226	// Extract reasoning content from summary
238	if summaryResult := outputItem.Get("summary"); summaryResult.IsArray() {	227	if summaryResult := outputItem.Get("summary"); summaryResult.IsArray() {
239	summaryArray := summaryResult.Array()	228	summaryArray := summaryResult.Array()
240	for _, summaryItem := range summaryArray {	229	for _, summaryItem := range summaryArray {
241	if summaryItem.Get("type").String() == "summary_text" {	230	if summaryItem.Get("type").String() == "summary_text" {
242	reasoningText = summaryItem.Get("text").String()	231	reasoningText = summaryItem.Get("text").String()
243	break	232	break
244	}
245	}	233	}
246	}	234	}
247	case "message":	235	}
248	// Extract message content	236	case "message":
249	if contentResult := outputItem.Get("content"); contentResult.IsArray() {	237	// Extract message content
250	contentArray := contentResult.Array()	238	if contentResult := outputItem.Get("content"); contentResult.IsArray() {
251	for _, contentItem := range contentArray {	239	contentArray := contentResult.Array()
252	if contentItem.Get("type").String() == "output_text" {	240	for _, contentItem := range contentArray {
253	contentText = contentItem.Get("text").String()	241	if contentItem.Get("type").String() == "output_text" {
254	break	242	contentText = contentItem.Get("text").String()
255	}	243	break
256	}	244	}
257	}	245	}
258	case "function_call":	246	}
259	// Handle function call content	247	case "function_call":
260	functionCallTemplate := `{"id": "","type": "function","function": {"name": "","arguments": ""}}`	248	// Handle function call content
261		249	functionCallTemplate := `{"id": "","type": "function","function": {"name": "","arguments": ""}}`
262	if callIdResult := outputItem.Get("call_id"); callIdResult.Exists() {
263	functionCallTemplate, _ = sjson.Set(functionCallTemplate, "id", callIdResult.String())
264	}
265		250
266	if nameResult := outputItem.Get("name"); nameResult.Exists() {	251	if callIdResult := outputItem.Get("call_id"); callIdResult.Exists() {
267	n := nameResult.String()	252	functionCallTemplate, _ = sjson.Set(functionCallTemplate, "id", callIdResult.String())
268	rev := buildReverseMapFromOriginalOpenAI(originalRequestRawJSON)	253	}
269	if orig, ok := rev[n]; ok {
270	n = orig
271	}
272	functionCallTemplate, _ = sjson.Set(functionCallTemplate, "function.name", n)
273	}
274		254
275	if argsResult := outputItem.Get("arguments"); argsResult.Exists() {	255	if nameResult := outputItem.Get("name"); nameResult.Exists() {
276	functionCallTemplate, _ = sjson.Set(functionCallTemplate, "function.arguments", argsResult.String())	256	n := nameResult.String()
		257	rev := buildReverseMapFromOriginalOpenAI(originalRequestRawJSON)
		258	if orig, ok := rev[n]; ok {
		259	n = orig
277	}	260	}
		261	functionCallTemplate, _ = sjson.Set(functionCallTemplate, "function.name", n)
		262	}
278		263
279	toolCalls = append(toolCalls, functionCallTemplate)	264	if argsResult := outputItem.Get("arguments"); argsResult.Exists() {
		265	functionCallTemplate, _ = sjson.Set(functionCallTemplate, "function.arguments", argsResult.String())
280	}	266	}
281	}
282		267
283	// Set content and reasoning content if found	268	toolCalls = append(toolCalls, functionCallTemplate)
284	if contentText != "" {
285	template, _ = sjson.Set(template, "choices.0.message.content", contentText)
286	template, _ = sjson.Set(template, "choices.0.message.role", "assistant")
287	}	269	}
		270	}
288		271
289	if reasoningText != "" {	272	// Set content and reasoning content if found
290	template, _ = sjson.Set(template, "choices.0.message.reasoning_content", reasoningText)	273	if contentText != "" {
291	template, _ = sjson.Set(template, "choices.0.message.role", "assistant")	274	template, _ = sjson.Set(template, "choices.0.message.content", contentText)
292	}	275	template, _ = sjson.Set(template, "choices.0.message.role", "assistant")
		276	}
293		277
294	// Add tool calls if any	278	if reasoningText != "" {
295	if len(toolCalls) > 0 {	279	template, _ = sjson.Set(template, "choices.0.message.reasoning_content", reasoningText)
296	template, _ = sjson.SetRaw(template, "choices.0.message.tool_calls", `[]`)	280	template, _ = sjson.Set(template, "choices.0.message.role", "assistant")
297	for _, toolCall := range toolCalls {
298	template, _ = sjson.SetRaw(template, "choices.0.message.tool_calls.-1", toolCall)
299	}
300	template, _ = sjson.Set(template, "choices.0.message.role", "assistant")
301	}
302	}	281	}
303		282
304	// Extract and set the finish reason based on status	283	// Add tool calls if any
305	if statusResult := responseResult.Get("status"); statusResult.Exists() {	284	if len(toolCalls) > 0 {
306	status := statusResult.String()	285	template, _ = sjson.SetRaw(template, "choices.0.message.tool_calls", `[]`)
307	if status == "completed" {	286	for _, toolCall := range toolCalls {
308	template, _ = sjson.Set(template, "choices.0.finish_reason", "stop")	287	template, _ = sjson.SetRaw(template, "choices.0.message.tool_calls.-1", toolCall)
309	template, _ = sjson.Set(template, "choices.0.native_finish_reason", "stop")
310	}	288	}
		289	template, _ = sjson.Set(template, "choices.0.message.role", "assistant")
311	}	290	}
		291	}
312		292
313	return template	293	// Extract and set the finish reason based on status
		294	if statusResult := responseResult.Get("status"); statusResult.Exists() {
		295	status := statusResult.String()
		296	if status == "completed" {
		297	template, _ = sjson.Set(template, "choices.0.finish_reason", "stop")
		298	template, _ = sjson.Set(template, "choices.0.native_finish_reason", "stop")
		299	}
314	}	300	}
315	return ""	301
		302	return template
316	}	303	}
317		304
318	// buildReverseMapFromOriginalOpenAI builds a map of shortened tool name -> original tool name	305	// buildReverseMapFromOriginalOpenAI builds a map of shortened tool name -> original tool name

internal/usage/logger_plugin.go+26−0

@@ -0,0 +1,26 @@
	1	package usage
	2
	3	import (
	4	"context"
	5	"encoding/json"
	6
	7	coreusage "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/usage"
	8	log "github.com/sirupsen/logrus"
	9	)
	10
	11	func init() {
	12	coreusage.RegisterPlugin(NewLoggerPlugin())
	13	}
	14
	15	// LoggerPlugin outputs every usage record to the application log.
	16	type LoggerPlugin struct{}
	17
	18	// NewLoggerPlugin constructs a new logger plugin instance.
	19	func NewLoggerPlugin() *LoggerPlugin { return &LoggerPlugin{} }
	20
	21	// HandleUsage implements coreusage.Plugin.
	22	func (p *LoggerPlugin) HandleUsage(ctx context.Context, record coreusage.Record) {
	23	// Output all relevant fields for observability; keep logging lightweight and non-blocking.
	24	data, _ := json.Marshal(record)
	25	log.Debug(string(data))
	26	}

sdk/cliproxy/service.go+11−0

 	"github.com/router-for-me/CLIProxyAPI/v6/internal/config"
 	"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
 	"github.com/router-for-me/CLIProxyAPI/v6/internal/runtime/executor"
+	_ "github.com/router-for-me/CLIProxyAPI/v6/internal/usage"
 	"github.com/router-for-me/CLIProxyAPI/v6/internal/util"
 	"github.com/router-for-me/CLIProxyAPI/v6/internal/watcher"
 	sdkaccess "github.com/router-for-me/CLIProxyAPI/v6/sdk/access"
 	_ "github.com/router-for-me/CLIProxyAPI/v6/sdk/access/providers/configapikey"
 	sdkAuth "github.com/router-for-me/CLIProxyAPI/v6/sdk/auth"
 	coreauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth"
+	"github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/usage"
 	log "github.com/sirupsen/logrus"
 )
 	shutdownOnce sync.Once
 }
+// RegisterUsagePlugin registers a usage plugin on the global usage manager.
+func (s *Service) RegisterUsagePlugin(plugin usage.Plugin) {
+	usage.RegisterPlugin(plugin)
+}
 func newDefaultAuthManager() *sdkAuth.Manager {
 	return sdkAuth.NewManager(
 		sdkAuth.NewFileTokenStore(),
 		ctx = context.Background()
 	}
+	usage.StartDefault(ctx)
 	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer shutdownCancel()
 	defer func() {
 				}
 			}
 		}
+		usage.StopDefault()
 	})
 	return shutdownErr
 }

sdk/cliproxy/usage/manager.go+182−0

@@ -0,0 +1,182 @@
	1	package usage
	2
	3	import (
	4	"context"
	5	"sync"
	6	"time"
	7
	8	log "github.com/sirupsen/logrus"
	9	)
	10
	11	// Record contains the usage statistics captured for a single provider request.
	12	type Record struct {
	13	Provider string
	14	Model string
	15	APIKey string
	16	AuthID string
	17	RequestedAt time.Time
	18	Detail Detail
	19	}
	20
	21	// Detail holds the token usage breakdown.
	22	type Detail struct {
	23	InputTokens int64
	24	OutputTokens int64
	25	ReasoningTokens int64
	26	CachedTokens int64
	27	TotalTokens int64
	28	}
	29
	30	// Plugin consumes usage records emitted by the proxy runtime.
	31	type Plugin interface {
	32	HandleUsage(ctx context.Context, record Record)
	33	}
	34
	35	type queueItem struct {
	36	ctx context.Context
	37	record Record
	38	}
	39
	40	// Manager maintains a queue of usage records and delivers them to registered plugins.
	41	type Manager struct {
	42	once sync.Once
	43	stopOnce sync.Once
	44	cancel context.CancelFunc
	45	queue chan queueItem
	46
	47	pluginsMu sync.RWMutex
	48	plugins []Plugin
	49	}
	50
	51	// NewManager constructs a manager with a buffered queue.
	52	func NewManager(buffer int) *Manager {
	53	if buffer <= 0 {
	54	buffer = 256
	55	}
	56	return &Manager{queue: make(chan queueItem, buffer)}
	57	}
	58
	59	// Start launches the background dispatcher. Calling Start multiple times is safe.
	60	func (m *Manager) Start(ctx context.Context) {
	61	if m == nil {
	62	return
	63	}
	64	m.once.Do(func() {
	65	if ctx == nil {
	66	ctx = context.Background()
	67	}
	68	var workerCtx context.Context
	69	workerCtx, m.cancel = context.WithCancel(ctx)
	70	go m.run(workerCtx)
	71	})
	72	}
	73
	74	// Stop stops the dispatcher and drains the queue.
	75	func (m *Manager) Stop() {
	76	if m == nil {
	77	return
	78	}
	79	m.stopOnce.Do(func() {
	80	if m.cancel != nil {
	81	m.cancel()
	82	}
	83	close(m.queue)
	84	})
	85	}
	86
	87	// Register appends a plugin to the delivery list.
	88	func (m *Manager) Register(plugin Plugin) {
	89	if m == nil \|\| plugin == nil {
	90	return
	91	}
	92	m.pluginsMu.Lock()
	93	m.plugins = append(m.plugins, plugin)
	94	m.pluginsMu.Unlock()
	95	}
	96
	97	// Publish enqueues a usage record for processing. If no plugin is registered
	98	// the record will be discarded downstream.
	99	func (m *Manager) Publish(ctx context.Context, record Record) {
	100	if m == nil {
	101	return
	102	}
	103	// ensure worker is running even if Start was not called explicitly
	104	m.Start(context.Background())
	105	select {
	106	case m.queue <- queueItem{ctx: ctx, record: record}:
	107	default:
	108	// queue is full; drop the record to avoid blocking runtime paths
	109	log.Debugf("usage: queue full, dropping record for provider %s", record.Provider)
	110	}
	111	}
	112
	113	func (m *Manager) run(ctx context.Context) {
	114	for {
	115	select {
	116	case <-ctx.Done():
	117	m.drain()
	118	return
	119	case item, ok := <-m.queue:
	120	if !ok {
	121	return
	122	}
	123	m.dispatch(item)
	124	}
	125	}
	126	}
	127
	128	func (m *Manager) drain() {
	129	for {
	130	select {
	131	case item, ok := <-m.queue:
	132	if !ok {
	133	return
	134	}
	135	m.dispatch(item)
	136	default:
	137	return
	138	}
	139	}
	140	}
	141
	142	func (m *Manager) dispatch(item queueItem) {
	143	m.pluginsMu.RLock()
	144	plugins := make([]Plugin, len(m.plugins))
	145	copy(plugins, m.plugins)
	146	m.pluginsMu.RUnlock()
	147	if len(plugins) == 0 {
	148	return
	149	}
	150	for _, plugin := range plugins {
	151	if plugin == nil {
	152	continue
	153	}
	154	safeInvoke(plugin, item.ctx, item.record)
	155	}
	156	}
	157
	158	func safeInvoke(plugin Plugin, ctx context.Context, record Record) {
	159	defer func() {
	160	if r := recover(); r != nil {
	161	log.Errorf("usage: plugin panic recovered: %v", r)
	162	}
	163	}()
	164	plugin.HandleUsage(ctx, record)
	165	}
	166
	167	var defaultManager = NewManager(512)
	168
	169	// DefaultManager returns the global usage manager instance.
	170	func DefaultManager() *Manager { return defaultManager }
	171
	172	// RegisterPlugin registers a plugin on the default manager.
	173	func RegisterPlugin(plugin Plugin) { DefaultManager().Register(plugin) }
	174
	175	// PublishRecord publishes a record using the default manager.
	176	func PublishRecord(ctx context.Context, record Record) { DefaultManager().Publish(ctx, record) }
	177
	178	// StartDefault starts the default manager's dispatcher.
	179	func StartDefault(ctx context.Context) { DefaultManager().Start(ctx) }
	180
	181	// StopDefault stops the default manager's dispatcher.
	182	func StopDefault() { DefaultManager().Stop() }