@pellux/goodvibes-tui 0.18.10 → 0.18.12

package/src/providers/openai.ts

@@ -1,231 +0,0 @@
-import OpenAI from 'openai';
-import type {
-  LLMProvider,
-  ChatRequest,
-  ChatResponse,
-  ProviderEmbeddingRequest,
-  ProviderEmbeddingResult,
-  ProviderRuntimeMetadata,
-  ProviderRuntimeMetadataDeps,
-} from '@pellux/goodvibes-sdk/platform/providers/interface';
-import { ProviderError } from '@pellux/goodvibes-sdk/platform/types/errors';
-import { withRetry } from '@pellux/goodvibes-sdk/platform/utils/retry';
-import {
-  toOpenAITools,
-  toOpenAIMessages,
-  fromOpenAIToolCalls,
-  extractTextToolCalls,
-} from '@pellux/goodvibes-sdk/platform/providers/tool-formats';
-import type { OpenAIToolCall } from '@pellux/goodvibes-sdk/platform/providers/tool-formats';
-import type { CacheHitTracker } from '@pellux/goodvibes-sdk/platform/providers/cache-strategy';
-import { extractOpenAIStreamTextDelta } from '@pellux/goodvibes-sdk/platform/providers/openai-stream-delta';
-import { summarizeError, toProviderError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-const NOOP_CACHE_HIT_TRACKER: Pick<CacheHitTracker, 'recordTurn'> = {
-  recordTurn: () => {},
-};
-
-/**
- * OpenAIProvider — wraps the official `openai` npm package.
- * Supports GPT-5 family models with full function/tool calling.
- */
-export class OpenAIProvider implements LLMProvider {
-  readonly name = 'openai';
-  readonly models: string[] = [];
-
-  private client: OpenAI;
-  private readonly embeddingModel = 'text-embedding-3-small';
-  private readonly cacheHitTracker: Pick<CacheHitTracker, 'recordTurn'>;
-
-  constructor(apiKey: string, cacheHitTracker: Pick<CacheHitTracker, 'recordTurn'> = NOOP_CACHE_HIT_TRACKER) {
-    this.client = new OpenAI({ apiKey });
-    this.cacheHitTracker = cacheHitTracker;
-  }
-
-  async chat(params: ChatRequest): Promise<ChatResponse> {
-    const { messages, tools, model, maxTokens, signal, systemPrompt, onDelta, reasoningEffort: _reasoningEffort } = params;
-    // Note: OpenAI GPT-5 does not expose reasoning effort as a configurable API parameter
-
-    return withRetry(async () => {
-      let responseText = '';
-      let inputTokens = 0;
-      let outputTokens = 0;
-      let cacheReadTokens = 0;
-      let stopReason: ChatResponse['stopReason'] = 'end';
-      let rawToolCalls: OpenAIToolCall[] = [];
-
-      const openaiMessages = toOpenAIMessages(messages, systemPrompt);
-      const openaiTools = tools && tools.length > 0 ? toOpenAITools(tools) : undefined;
-
-      try {
-        const stream = await this.client.chat.completions.create(
-          {
-            model,
-            messages: openaiMessages as Parameters<typeof this.client.chat.completions.create>[0]['messages'],
-            ...(openaiTools ? { tools: openaiTools as Parameters<typeof this.client.chat.completions.create>[0]['tools'] } : {}),
-            ...(maxTokens ? { max_tokens: maxTokens } : {}),
-            stream: true,
-            stream_options: { include_usage: true },
-          },
-          { signal },
-        );
-
-        const accToolCalls: Map<number, { id: string; name: string; args: string }> = new Map();
-
-        for await (const chunk of stream) {
-          const delta = chunk.choices[0]?.delta;
-          const textDelta = extractOpenAIStreamTextDelta(chunk);
-          for (const contentDelta of textDelta.content) {
-            responseText += contentDelta;
-            if (onDelta) onDelta({ content: contentDelta });
-          }
-          for (const reasoningDelta of textDelta.reasoning) {
-            if (onDelta) onDelta({ reasoning: reasoningDelta });
-          }
-
-          // Accumulate streaming tool_calls deltas
-          if (delta?.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              const idx = tc.index;
-              if (!accToolCalls.has(idx)) {
-                accToolCalls.set(idx, { id: tc.id ?? '', name: tc.function?.name ?? '', args: '' });
-              }
-              const entry = accToolCalls.get(idx)!;
-              if (tc.id) entry.id = tc.id;
-              if (tc.function?.name) entry.name = tc.function.name;
-              if (tc.function?.arguments) entry.args += tc.function.arguments;
-              if (onDelta) {
-                onDelta({ toolCalls: [{ index: idx, id: tc.id, name: tc.function?.name, arguments: tc.function?.arguments }] });
-              }
-            }
-          }
-
-          const finishReason = chunk.choices[0]?.finish_reason;
-          if (finishReason === 'tool_calls') stopReason = 'tool_use';
-          else if (finishReason === 'length') stopReason = 'max_tokens';
-
-          const usage = (chunk as { usage?: { prompt_tokens?: number; completion_tokens?: number; prompt_tokens_details?: { cached_tokens?: number } } }).usage;
-          if (usage) {
-            inputTokens = usage.prompt_tokens ?? 0;
-            outputTokens = usage.completion_tokens ?? 0;
-            cacheReadTokens = usage.prompt_tokens_details?.cached_tokens ?? cacheReadTokens;
-          }
-        }
-
-        // Finalise accumulated tool calls
-        for (const [, tc] of [...accToolCalls.entries()].sort(([a], [b]) => a - b)) {
-          rawToolCalls.push({
-            id: tc.id,
-            type: 'function',
-            function: { name: tc.name, arguments: tc.args },
-          });
-        }
-      } catch (err: unknown) {
-        const { hasStatus } = await import('@pellux/goodvibes-sdk/platform/utils/retry');
-        const status = hasStatus(err) ? err.status : undefined;
-        throw toProviderError(err, {
-          ...(status !== undefined ? { statusCode: status } : {}),
-          provider: this.name,
-          operation: 'chat',
-          phase: 'stream',
-        });
-      }
-
-      // Some models may emit tool calls as raw text tokens instead of the
-      // OpenAI function-calling wire format. Fall back to text extraction.
-      let toolCalls = rawToolCalls.length > 0 ? fromOpenAIToolCalls(rawToolCalls) : [];
-      if (toolCalls.length === 0 && (responseText.includes('<|toolcallbegin|>') || responseText.includes('<|tool_call_begin|>'))) {
-        const extracted = extractTextToolCalls(responseText);
-        if (extracted.toolCalls.length > 0) {
-          toolCalls = extracted.toolCalls;
-          responseText = extracted.cleanedContent;
-          stopReason = 'tool_use';
-        }
-      }
-
-      this.cacheHitTracker.recordTurn({
-        inputTokens,
-        cacheReadTokens,
-      });
-
-      return {
-        content: responseText,
-        toolCalls,
-        usage: {
-          inputTokens,
-          outputTokens,
-          ...(cacheReadTokens > 0 ? { cacheReadTokens } : {}),
-        },
-        stopReason,
-      };
-    });
-  }
-
-  async embed(request: ProviderEmbeddingRequest): Promise<ProviderEmbeddingResult> {
-    let response;
-    try {
-      response = await this.client.embeddings.create(
-        {
-          model: request.model ?? this.embeddingModel,
-          input: request.text,
-          ...(request.dimensions ? { dimensions: request.dimensions } : {}),
-        },
-        request.signal ? { signal: request.signal } : undefined,
-      );
-    } catch (error: unknown) {
-      throw toProviderError(error, {
-        provider: this.name,
-        operation: 'embed',
-        phase: 'request',
-      });
-    }
-    const embedding = response.data[0]?.embedding ?? [];
-    return {
-      vector: Float32Array.from(embedding),
-      dimensions: embedding.length,
-      modelId: response.model,
-      metadata: {
-        usage: request.usage,
-        provider: this.name,
-      },
-    };
-  }
-
-  async describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata> {
-    const configured = Boolean(process.env.OPENAI_API_KEY || process.env.OPENAI_KEY);
-    const { buildStandardProviderAuthRoutes } = await import('./runtime-metadata.ts');
-    const authRoutes = await buildStandardProviderAuthRoutes({
-      providerId: 'openai',
-      apiKeyEnvVars: ['OPENAI_API_KEY', 'OPENAI_KEY'],
-      serviceNames: ['openai'],
-      subscriptionProviderId: 'openai',
-    }, deps);
-    return {
-      auth: {
-        mode: 'api-key',
-        configured,
-        detail: configured ? 'OpenAI API key available' : 'OPENAI_API_KEY or OPENAI_KEY not set',
-        envVars: ['OPENAI_API_KEY', 'OPENAI_KEY'],
-        routes: authRoutes,
-      },
-      models: {
-        models: this.models,
-        embeddingModel: this.embeddingModel,
-        embeddingDimensions: 384,
-      },
-      usage: {
-        streaming: true,
-        toolCalling: true,
-        parallelTools: true,
-        notes: ['Embeddings use the OpenAI embeddings API.'],
-      },
-      policy: {
-        local: false,
-        streamProtocol: 'openai-chat-completions',
-        reasoningMode: 'provider-default',
-        cacheStrategy: 'implicit-openai-cache-observation',
-        notes: ['OpenAI embedding usage is subject to OpenAI API terms.'],
-      },
-    };
-  }
-}

package/src/providers/optimizer.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/providers/optimizer';

package/src/providers/provider-api.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/providers/provider-api';

package/src/providers/registry-helpers.ts

@@ -1,34 +0,0 @@
-import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers/registry-types';
-
-export function withRegistryKey(model: ModelDefinition): ModelDefinition {
-  return model.registryKey ? model : { ...model, registryKey: `${model.provider}:${model.id}` };
-}
-
-export function splitModelRegistryKey(modelId: string): { providerId: string; resolvedModelId: string } {
-  if (!modelId.includes(':')) {
-    return { providerId: modelId, resolvedModelId: modelId };
-  }
-
-  return {
-    providerId: modelId.split(':')[0] ?? 'unknown',
-    resolvedModelId: modelId.split(':').slice(1).join(':'),
-  };
-}
-
-export function getBaseModelId(modelId: string): string {
-  return modelId.includes(':') ? modelId.split(':').slice(1).join(':') : modelId;
-}
-
-/**
- * Key-order-independent JSON serialisation used for model diff comparisons.
- * Recursively sorts object keys so that { a: 1, b: 2 } and { b: 2, a: 1 }
- * produce the same string.
- */
-export function stableStringify(value: unknown): string {
-  if (value === null || typeof value !== 'object') return JSON.stringify(value);
-  if (Array.isArray(value)) return '[' + value.map(stableStringify).join(',') + ']';
-  const sorted = Object.keys(value as Record<string, unknown>).sort();
-  return '{' + sorted.map((key) => (
-    JSON.stringify(key) + ':' + stableStringify((value as Record<string, unknown>)[key])
-  )).join(',') + '}';
-}

package/src/providers/registry-models.ts

@@ -1,77 +0,0 @@
-import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers/registry-types';
-import { splitModelRegistryKey, withRegistryKey } from '@pellux/goodvibes-sdk/platform/providers/registry-helpers';
-
-export function getProviderLookupCandidates(
-  providerName: string,
-  aliases: Readonly<Record<string, string>>,
-): string[] {
-  const candidates = new Set<string>([providerName]);
-  const directAlias = aliases[providerName];
-  if (directAlias) candidates.add(directAlias);
-  for (const [catalogName, registeredName] of Object.entries(aliases)) {
-    if (registeredName === providerName) candidates.add(catalogName);
-    if (directAlias && registeredName === directAlias) candidates.add(catalogName);
-  }
-  return [...candidates];
-}
-
-export function findModelDefinition(
-  modelId: string,
-  registry: readonly ModelDefinition[],
-): ModelDefinition | undefined {
-  if (modelId.includes(':')) {
-    return registry.find((model) => model.registryKey === modelId) ?? registry.find((model) => model.id === modelId);
-  }
-  return registry.find((model) => model.id === modelId);
-}
-
-export function findModelDefinitionForProvider(
-  modelId: string,
-  providerName: string,
-  registry: readonly ModelDefinition[],
-  aliases: Readonly<Record<string, string>>,
-): ModelDefinition | undefined {
-  const providerCandidates = new Set(getProviderLookupCandidates(providerName, aliases));
-  const resolvedModelId = modelId.includes(':') ? splitModelRegistryKey(modelId).resolvedModelId : modelId;
-  const registryMatch = modelId.includes(':')
-    ? findModelDefinition(modelId, registry)
-    : undefined;
-
-  if (registryMatch && providerCandidates.has(registryMatch.provider)) {
-    return registryMatch;
-  }
-
-  return registry.find((model) => model.id === resolvedModelId && providerCandidates.has(model.provider));
-}
-
-export function buildModelRegistry(input: {
-  readonly customModels: readonly ModelDefinition[];
-  readonly runtimeModels: readonly ModelDefinition[];
-  readonly syntheticModels: readonly ModelDefinition[];
-  readonly catalogModels: readonly ModelDefinition[];
-  readonly discoveredModels: readonly ModelDefinition[];
-  readonly suppressedCatalogIds: ReadonlySet<string>;
-}): ModelDefinition[] {
-  const catalogFiltered = input.catalogModels.filter(
-    (builtin) =>
-      !input.customModels.some((model) => model.id === builtin.id) &&
-      !input.runtimeModels.some((model) => model.id === builtin.id) &&
-      !input.suppressedCatalogIds.has(builtin.id) &&
-      !builtin.id.startsWith('hf:'),
-  );
-
-  const discoveredFiltered = input.discoveredModels.filter(
-    (discovered) =>
-      !input.catalogModels.some((model) => model.id === discovered.id) &&
-      !input.customModels.some((model) => model.id === discovered.id) &&
-      !input.runtimeModels.some((model) => model.id === discovered.id),
-  );
-
-  return [
-    ...input.customModels.map(withRegistryKey),
-    ...input.runtimeModels.map(withRegistryKey),
-    ...input.syntheticModels.map(withRegistryKey),
-    ...catalogFiltered.map(withRegistryKey),
-    ...discoveredFiltered.map(withRegistryKey),
-  ];
-}

package/src/providers/registry-types.ts

@@ -1,67 +0,0 @@
-import type { LLMProvider, ProviderRuntimeMetadataDeps } from '@pellux/goodvibes-sdk/platform/providers/interface';
-import type { ProviderCapabilityRegistry } from '@pellux/goodvibes-sdk/platform/providers/capabilities';
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
-import type { CacheHitTracker } from '@pellux/goodvibes-sdk/platform/providers/cache-strategy';
-import type { FeatureFlagManager } from '@pellux/goodvibes-sdk/platform/runtime/feature-flags/index';
-import type { FavoritesStore } from '@pellux/goodvibes-sdk/platform/providers/favorites';
-import type { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
-import type { ModelLimitsService } from '@pellux/goodvibes-sdk/platform/providers/model-limits';
-
-/** Model capability tier — controls system prompt verbosity. */
-export type ModelTier = 'free' | 'standard' | 'premium' | 'subscription';
-
-/** Per-model token limits for output, tool results, tool calls, and reasoning. */
-export interface TokenLimits {
-  maxOutputTokens?: number;
-  maxToolResultTokens?: number;
-  maxToolCalls?: number;
-  maxReasoningTokens?: number;
-}
-
-/** Provenance of a resolved context window value. */
-export type ContextWindowProvenance = 'provider_api' | 'configured_cap' | 'fallback';
-
-/** Describes a selectable model and its capabilities. */
-export interface ModelDefinition {
-  id: string;
-  provider: string;
-  /** Compound unique key: `${provider}:${id}`. Safe separator since model IDs use `/` not `:`. */
-  registryKey: string;
-  displayName: string;
-  description: string;
-  capabilities: {
-    toolCalling: boolean;
-    codeEditing: boolean;
-    reasoning: boolean;
-    multimodal: boolean;
-  };
-  contextWindow: number;
-  contextWindowProvenance?: ContextWindowProvenance;
-  selectable: boolean;
-  reasoningEffort?: string[];
-  tier?: ModelTier;
-  tokenLimits?: TokenLimits;
-}
-
-export interface RuntimeProviderRegistration {
-  readonly provider: LLMProvider;
-  readonly models?: readonly ModelDefinition[];
-  readonly suppressCatalogModels?: readonly string[];
-  readonly replace?: boolean;
-}
-
-export interface ProviderRegistryOptions {
-  readonly configManager: Pick<ConfigManager, 'get' | 'getCategory' | 'getControlPlaneConfigDir'>;
-  readonly subscriptionManager: Pick<SubscriptionManager, 'get' | 'getPending' | 'saveSubscription' | 'resolveAccessToken'>;
-  readonly secretsManager: ProviderRuntimeMetadataDeps['secretsManager'];
-  readonly serviceRegistry: ProviderRuntimeMetadataDeps['serviceRegistry'];
-  readonly capabilityRegistry: ProviderCapabilityRegistry;
-  readonly cacheHitTracker: CacheHitTracker;
-  readonly favoritesStore: Pick<FavoritesStore, 'load'>;
-  readonly benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks' | 'getTopBenchmarkModelIds'>;
-  readonly modelLimitsService?: ModelLimitsService;
-  readonly featureFlags?: Pick<FeatureFlagManager, 'isEnabled'> | null;
-  readonly runtimeBus?: RuntimeEventBus | null;
-}

package/src/providers/registry.ts

@@ -1 +0,0 @@
-export * from '@pellux/goodvibes-sdk/platform/providers/registry';

package/src/providers/runtime-metadata.ts

@@ -1,149 +0,0 @@
-import { listBuiltinSubscriptionProviders } from '../config/subscription-providers.ts';
-import type { ProviderAuthRouteDescriptor, ProviderRuntimeMetadataDeps } from '@pellux/goodvibes-sdk/platform/providers/interface';
-
-export interface StandardProviderAuthOptions {
-  readonly providerId: string;
-  readonly apiKeyEnvVars?: readonly string[];
-  readonly secretKeys?: readonly string[];
-  readonly serviceNames?: readonly string[];
-  readonly subscriptionProviderId?: string;
-  readonly allowAnonymous?: boolean;
-  readonly anonymousConfigured?: boolean;
-  readonly anonymousDetail?: string;
-}
-
-function determineFreshness(expiresAt?: number): 'healthy' | 'expiring' | 'expired' {
-  if (typeof expiresAt !== 'number' || !Number.isFinite(expiresAt)) return 'healthy';
-  if (expiresAt <= Date.now()) return 'expired';
-  if (expiresAt <= Date.now() + 24 * 60 * 60 * 1000) return 'expiring';
-  return 'healthy';
-}
-
-export async function buildStandardProviderAuthRoutes(
-  options: StandardProviderAuthOptions,
-  deps: ProviderRuntimeMetadataDeps,
-): Promise<readonly ProviderAuthRouteDescriptor[]> {
-  const secretKeys = [...new Set([...(options.secretKeys ?? []), ...(options.apiKeyEnvVars ?? [])])];
-  const detailedSecrets = await deps.secretsManager.listDetailed();
-  const matchingSecretRecords = detailedSecrets.filter((record) => secretKeys.includes(record.key) && record.source !== 'env');
-  const hasSecretRef = matchingSecretRecords.some((record) => Boolean(record.refSource));
-  const hasStoredDirectSecret = matchingSecretRecords.some((record) => !record.refSource);
-  const hasEnv = (options.apiKeyEnvVars ?? []).some((envVar) => {
-    const value = process.env[envVar];
-    return typeof value === 'string' && value.length > 0;
-  });
-  const builtinSubscriptions = new Set(listBuiltinSubscriptionProviders().map((entry) => entry.provider));
-  const subscriptionProviderId = options.subscriptionProviderId ?? options.providerId;
-  const subscription = deps.subscriptionManager.get(subscriptionProviderId);
-  const pendingSubscription = deps.subscriptionManager.getPending(subscriptionProviderId);
-  const hasSubscriptionRoute = builtinSubscriptions.has(subscriptionProviderId) || subscription != null || pendingSubscription != null;
-  const subscriptionFreshness = pendingSubscription
-    ? 'pending'
-    : subscription
-      ? determineFreshness(subscription.expiresAt)
-      : 'unconfigured';
-  const serviceNames = options.serviceNames && options.serviceNames.length > 0
-    ? [...new Set(options.serviceNames)]
-    : Object.values(deps.serviceRegistry.getAll())
-      .filter((service) => service.authType === 'oauth' && (service.providerId ?? service.name) === options.providerId)
-      .map((service) => service.name);
-  const serviceInspections = await Promise.all(serviceNames.map(async (name) => ({
-    name,
-    inspection: await deps.serviceRegistry.inspect(name),
-  })));
-  const hasServiceConfig = serviceInspections.some(({ inspection }) => inspection?.config.authType === 'oauth');
-  const hasUsableServiceOauth = serviceInspections.some(({ inspection }) => Boolean(inspection?.hasPrimaryCredential));
-
-  const routes: ProviderAuthRouteDescriptor[] = [];
-  if ((options.apiKeyEnvVars?.length ?? 0) > 0 || secretKeys.length > 0) {
-    routes.push({
-      route: 'api-key',
-      label: 'Ambient API key',
-      configured: hasEnv || hasStoredDirectSecret,
-      usable: hasEnv || hasStoredDirectSecret,
-      freshness: hasEnv || hasStoredDirectSecret ? 'healthy' : 'unconfigured',
-      detail: hasEnv
-        ? 'Environment-backed API key is available.'
-        : hasStoredDirectSecret
-          ? 'GoodVibes secret store contains a direct API key value.'
-          : 'No direct API key is configured.',
-      ...(options.apiKeyEnvVars?.length ? { envVars: options.apiKeyEnvVars } : {}),
-      ...(secretKeys.length > 0 ? { secretKeys } : {}),
-      repairHints: [
-        ...(options.apiKeyEnvVars?.length
-          ? [`Set ${options.apiKeyEnvVars.join(' or ')} or store one of those keys in /secrets.`]
-          : ['Store the provider API key in /secrets or the process environment.']),
-      ],
-    });
-    routes.push({
-      route: 'secret-ref',
-      label: 'SecretRef-backed API key',
-      configured: hasSecretRef,
-      usable: hasSecretRef,
-      freshness: hasSecretRef ? 'healthy' : 'unconfigured',
-      detail: hasSecretRef
-        ? 'A GoodVibes SecretRef is configured for this provider.'
-        : 'No SecretRef-backed credential is configured.',
-      ...(secretKeys.length > 0 ? { secretKeys } : {}),
-      repairHints: [
-        'Use /secrets link <KEY> <secret-ref> to attach Bitwarden, Vaultwarden, BWS, or another supported SecretRef.',
-      ],
-    });
-  }
-
-  if (hasServiceConfig || serviceNames.length > 0) {
-    routes.push({
-      route: 'service-oauth',
-      label: 'Service OAuth',
-      configured: hasServiceConfig,
-      usable: hasUsableServiceOauth,
-      freshness: hasUsableServiceOauth ? 'healthy' : 'unconfigured',
-      detail: hasUsableServiceOauth
-        ? 'A service-owned OAuth credential is available for this provider.'
-        : 'Service OAuth metadata exists, but the credential path is incomplete.',
-      ...(serviceNames.length > 0 ? { serviceNames } : {}),
-      repairHints: ['Repair the provider service credential in /services or the settings surface.'],
-    });
-  }
-
-  if (hasSubscriptionRoute) {
-    routes.push({
-      route: 'subscription-oauth',
-      label: 'Subscription OAuth',
-      configured: subscription != null || pendingSubscription != null || builtinSubscriptions.has(subscriptionProviderId),
-      usable: subscriptionFreshness !== 'expired' && subscriptionFreshness !== 'unconfigured',
-      freshness: subscriptionFreshness,
-      detail: pendingSubscription
-        ? 'Subscription OAuth login is pending completion.'
-        : subscription
-          ? 'A stored subscription OAuth session is available for this provider.'
-          : 'A built-in subscription OAuth adapter is available, but no session is stored yet.',
-      providerId: subscriptionProviderId,
-      repairHints: [`Use /subscription login ${subscriptionProviderId} start or refresh the stored subscription session.`],
-    });
-  }
-
-  if (options.allowAnonymous) {
-    routes.push({
-      route: 'anonymous',
-      label: 'Anonymous / local access',
-      configured: Boolean(options.anonymousConfigured),
-      usable: Boolean(options.anonymousConfigured),
-      freshness: options.anonymousConfigured ? 'healthy' : 'unconfigured',
-      detail: options.anonymousDetail ?? 'This provider can be used without an API key.',
-    });
-  }
-
-  if (routes.length === 0) {
-    return [{
-      route: 'none',
-      label: 'No auth route declared',
-      configured: false,
-      usable: false,
-      freshness: 'unconfigured',
-      detail: 'The provider did not declare any runtime auth routes.',
-    }];
-  }
-
-  return routes;
-}