feat(stats): add endpoint domain extraction for provider identification in dashboard

Author: k1yt

packages/types/src/usage-stats.ts

@@ -45,6 +45,14 @@ export const UsageEventV1 = z.object({
 	provider: z.string(),
 	model: z.string(),
 	mode: z.string(),
+	/**
+	 * Domain extracted from the provider's custom base URL (e.g. "kimi.ai",
+	 * "localhost:1234"). Only set when the user configured a custom base URL
+	 * that differs from the provider's default. Absent for default endpoints
+	 * and for providers without a base URL field. Backward compatible:
+	 * events recorded before this field was introduced remain valid.
+	 */
+	endpoint: z.string().optional(),
 	usage: z.object({
 		inputTokens: SourcedNumber.optional(),
 		outputTokens: SourcedNumber.optional(),

src/core/task/Task.ts

@@ -142,6 +142,100 @@ const DEFAULT_USAGE_COLLECTION_TIMEOUT_MS = 5000 // 5 seconds
 const FORCED_CONTEXT_REDUCTION_PERCENT = 75 // Keep 75% of context (remove 25%) on context window errors
 const MAX_CONTEXT_WINDOW_RETRIES = 3 // Maximum retries for context window errors
 
+// ── Usage Stats: endpoint domain extraction ──────────────────────────────────
+
+/**
+ * Default base URLs per provider. Only providers with a user-configurable
+ * base URL field are listed. When the user's configured URL matches the
+ * default, `endpoint` is left undefined to keep events clean.
+ */
+const PROVIDER_DEFAULT_BASE_URLS: Partial<Record<string, string>> = {
+	openai: "https://api.openai.com/v1",
+	"openai-native": "https://api.openai.com",
+	openrouter: "https://openrouter.ai/api/v1",
+	deepseek: "https://api.deepseek.com",
+	litellm: "http://localhost:4000",
+	ollama: "http://127.0.0.1:11434",
+	lmstudio: "http://localhost:1234/v1",
+	requesty: "https://router.requesty.ai/v1",
+}
+
+/**
+ * Maps a provider name to the corresponding base URL field on ProviderSettings.
+ * Returns the raw configured value (may be undefined if the user hasn't
+ * customized it). Providers not in this map have no user-configurable base URL.
+ */
+function getProviderBaseUrlField(provider: string, config: ProviderSettings): string | undefined {
+	switch (provider) {
+		case "anthropic":
+			return config.anthropicBaseUrl
+		case "openai":
+			return config.openAiBaseUrl
+		case "openai-native":
+			return config.openAiNativeBaseUrl
+		case "openrouter":
+			return config.openRouterBaseUrl
+		case "deepseek":
+			return config.deepSeekBaseUrl
+		case "litellm":
+			return config.litellmBaseUrl
+		case "ollama":
+			return config.ollamaBaseUrl
+		case "lmstudio":
+			return config.lmStudioBaseUrl
+		case "requesty":
+			return config.requestyBaseUrl
+		case "zoo-gateway":
+			return config.zooGatewayBaseUrl
+		default:
+			return undefined
+	}
+}
+
+/**
+ * Extracts a display-friendly endpoint domain from the provider's base URL.
+ *
+ * Only returns a value when the user has configured a CUSTOM base URL that
+ * differs from the provider's default. For localhost / 127.0.0.1 hosts the
+ * port is included (e.g. "localhost:1234") so distinct local servers can be
+ * distinguished. Returns undefined for default endpoints, providers without
+ * a base URL field, or malformed URLs.
+ */
+function resolveEndpoint(config: ProviderSettings): string | undefined {
+	const provider = config.apiProvider
+	if (!provider) return undefined
+
+	const configuredUrl = getProviderBaseUrlField(provider, config)
+	if (!configuredUrl) return undefined
+
+	// Only record endpoint when the user customized the base URL.
+	const defaultUrl = PROVIDER_DEFAULT_BASE_URLS[provider]
+	if (configuredUrl === defaultUrl) return undefined
+
+	// zoo-gateway default is dynamic — skip when it matches the derived default.
+	if (provider === "zoo-gateway") {
+		// The dynamic default is `${getZooCodeBaseUrl()}/api/gateway/v1`.
+		// We can't import getZooCodeBaseUrl here without a circular dependency,
+		// so we compare against the known suffix pattern. If the configured URL
+		// ends with /api/gateway/v1 and starts with a zoocode host, treat as default.
+		if (/^https?:\/\/[^/]*zoocode\.dev\/api\/gateway\/v1\/?$/.test(configuredUrl)) {
+			return undefined
+		}
+	}
+
+	try {
+		const url = new URL(configuredUrl)
+		const hostname = url.hostname
+		// Include port for localhost / 127.0.0.1 so distinct local servers differ.
+		if ((hostname === "localhost" || hostname === "127.0.0.1") && url.port) {
+			return `${hostname}:${url.port}`
+		}
+		return hostname
+	} catch {
+		return undefined
+	}
+}
+
 export interface TaskOptions extends CreateTaskOptions {
 	provider: ClineProvider
 	apiConfiguration: ProviderSettings
@@ -3168,6 +3262,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 									reasoningInOutput: "unknown",
 									costSource: "provider",
 									tokenSource: "provider",
+									endpoint: resolveEndpoint(this.apiConfiguration),
 								}
 								// Fire-and-forget: store error must not block task
 								this.usageRecorder
@@ -3314,6 +3409,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 								reasoningInOutput: "unknown",
 								costSource: "provider",
 								tokenSource: "provider",
+								endpoint: resolveEndpoint(this.apiConfiguration),
 							}
 							// Fire-and-forget: store error must not block task
 							this.usageRecorder

src/services/stats/UsageAggregator.ts

@@ -380,7 +380,10 @@ export class UsageAggregator {
 			case "month":
 				return item.monthBucket ? [item.monthBucket] : []
 			case "provider":
-				return [event.provider]
+				// When an endpoint domain is recorded (custom base URL), append it
+				// to the provider key so distinct servers appear as separate rows.
+				// e.g. "openai (kimi.ai)" vs plain "openai" for the default endpoint.
+				return [event.endpoint ? `${event.provider} (${event.endpoint})` : event.provider]
 			case "model":
 				return [event.model]
 			case "mode":

src/services/stats/UsageRecorder.ts

@@ -37,6 +37,12 @@ export interface UsageRecordingContext {
 	// source
 	costSource: UsageValueSource
 	tokenSource: UsageValueSource
+	/**
+	 * Domain extracted from the provider's custom base URL. Only set when the
+	 * user configured a custom base URL that differs from the provider default.
+	 * Absent for default endpoints. See resolveEndpoint() in Task.ts.
+	 */
+	endpoint?: string
 }
 
 // ── UsageRecorder ────────────────────────────────────────────────────────────
@@ -96,6 +102,7 @@ export class UsageRecorder {
 			provider: ctx.provider,
 			model: ctx.model,
 			mode: ctx.mode,
+			endpoint: ctx.endpoint,
 			usage: {
 				inputTokens: ctx.inputTokens > 0 ? { value: ctx.inputTokens, source: ctx.tokenSource } : undefined,
 				outputTokens: ctx.outputTokens > 0 ? { value: ctx.outputTokens, source: ctx.tokenSource } : undefined,

src/services/stats/__tests__/UsageAggregator.spec.ts

@@ -207,6 +207,22 @@ describe("UsageAggregator", () => {
 			expect(providers).toEqual(["anthropic", "openai"])
 		})
 
+		it("should separate provider buckets by endpoint domain", () => {
+			const events = [
+				makeEvent({ eventId: "evt-1", idempotencyKey: "idem-1", provider: "openai", endpoint: "kimi.ai" }),
+				makeEvent({ eventId: "evt-2", idempotencyKey: "idem-2", provider: "openai", endpoint: "kimi.ai" }),
+				makeEvent({ eventId: "evt-3", idempotencyKey: "idem-3", provider: "openai" }), // default endpoint
+				makeEvent({ eventId: "evt-4", idempotencyKey: "idem-4", provider: "openai", endpoint: "localhost:1234" }),
+			]
+			const query = makeQuery({ groupBy: ["provider"] })
+
+			const result = aggregator.query(events, query)
+
+			expect(result.buckets).toHaveLength(3)
+			const keys = result.buckets.map((b) => b.key.provider).sort()
+			expect(keys).toEqual(["openai", "openai (kimi.ai)", "openai (localhost:1234)"])
+		})
+
 		it("should group by model", () => {
 			const events = [
 				makeEvent({ eventId: "evt-1", idempotencyKey: "idem-1", model: "claude-sonnet-4-20250514" }),

src/services/stats/__tests__/UsageEventStore.spec.ts

@@ -147,6 +147,24 @@ describe("UsageEventStore", () => {
 			expect(parsed.eventId).toBe(event.eventId)
 		})
 
+		it("should persist optional endpoint field when provided", async () => {
+			const event = makeEvent({ endpoint: "kimi.ai" })
+			await store.append(event)
+
+			const events = await store.readAll()
+			expect(events).toHaveLength(1)
+			expect(events[0].endpoint).toBe("kimi.ai")
+		})
+
+		it("should not require endpoint field (backward compatible)", async () => {
+			const event = makeEvent()
+			await store.append(event)
+
+			const events = await store.readAll()
+			expect(events).toHaveLength(1)
+			expect(events[0].endpoint).toBeUndefined()
+		})
+
 		it("should serialize concurrent appends via promise queue", async () => {
 			const events = Array.from({ length: 10 }, (_, i) =>
 				makeEvent({ eventId: `evt-${i}`, idempotencyKey: `idem-${i}` }),