refactor: share native streaming compat helpers

src/plugin-sdk/provider-catalog-shared.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import {
+  applyProviderNativeStreamingUsageCompat,
+  supportsNativeStreamingUsageCompat,
+} from "./provider-catalog-shared.js";
+import type { ModelDefinitionConfig } from "./provider-model-shared.js";
+
+function buildModel(id: string, supportsUsageInStreaming?: boolean): ModelDefinitionConfig {
+  return {
+    id,
+    name: id,
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 1024,
+    maxTokens: 1024,
+    ...(supportsUsageInStreaming === undefined ? {} : { compat: { supportsUsageInStreaming } }),
+  };
+}
+
+describe("provider-catalog-shared native streaming usage compat", () => {
+  it("detects native streaming usage compat from the endpoint capabilities", () => {
+    expect(
+      supportsNativeStreamingUsageCompat({
+        providerId: "custom-qwen",
+        baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+      }),
+    ).toBe(true);
+    expect(
+      supportsNativeStreamingUsageCompat({
+        providerId: "custom-kimi",
+        baseUrl: "https://api.moonshot.ai/v1",
+      }),
+    ).toBe(true);
+    expect(
+      supportsNativeStreamingUsageCompat({
+        providerId: "custom-proxy",
+        baseUrl: "https://proxy.example.com/v1",
+      }),
+    ).toBe(false);
+  });
+
+  it("opts models into streaming usage for native endpoints while preserving explicit overrides", () => {
+    const provider = applyProviderNativeStreamingUsageCompat({
+      providerId: "custom-qwen",
+      providerConfig: {
+        api: "openai-completions",
+        baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+        models: [buildModel("qwen-plus"), buildModel("qwen-max", false)],
+      },
+    });
+
+    expect(provider.models?.[0]?.compat?.supportsUsageInStreaming).toBe(true);
+    expect(provider.models?.[1]?.compat?.supportsUsageInStreaming).toBe(false);
+  });
+});

src/plugin-sdk/provider-catalog-shared.ts

@@ -3,6 +3,9 @@
 // Keep provider-owned exports out of this subpath so plugin loaders can import it
 // without recursing through provider-specific facades.
 
+import { resolveProviderRequestCapabilities } from "./provider-http.js";
+import type { ModelProviderConfig } from "./provider-model-shared.js";
+
 export type { ProviderCatalogContext, ProviderCatalogResult } from "../plugins/types.js";
 
 export {
@@ -10,3 +13,51 @@ export {
   buildSingleProviderApiKeyCatalog,
   findCatalogTemplate,
 } from "../plugins/provider-catalog.js";
+
+function withStreamingUsageCompat(provider: ModelProviderConfig): ModelProviderConfig {
+  if (!Array.isArray(provider.models) || provider.models.length === 0) {
+    return provider;
+  }
+
+  let changed = false;
+  const models = provider.models.map((model) => {
+    if (model.compat?.supportsUsageInStreaming !== undefined) {
+      return model;
+    }
+    changed = true;
+    return {
+      ...model,
+      compat: {
+        ...model.compat,
+        supportsUsageInStreaming: true,
+      },
+    };
+  });
+
+  return changed ? { ...provider, models } : provider;
+}
+
+export function supportsNativeStreamingUsageCompat(params: {
+  providerId: string;
+  baseUrl: string | undefined;
+}): boolean {
+  return resolveProviderRequestCapabilities({
+    provider: params.providerId,
+    api: "openai-completions",
+    baseUrl: params.baseUrl,
+    capability: "llm",
+    transport: "stream",
+  }).supportsNativeStreamingUsageCompat;
+}
+
+export function applyProviderNativeStreamingUsageCompat(params: {
+  providerId: string;
+  providerConfig: ModelProviderConfig;
+}): ModelProviderConfig {
+  return supportsNativeStreamingUsageCompat({
+    providerId: params.providerId,
+    baseUrl: params.providerConfig.baseUrl,
+  })
+    ? withStreamingUsageCompat(params.providerConfig)
+    : params.providerConfig;
+}