offrouter-core 0.2.0 → 0.2.2

package/src/providers/openai-compatible.ts

@@ -1,554 +0,0 @@
-/**
- * OpenAI-compatible HTTP adapter (OpenRouter / xAI / Ollama shapes).
- * Tests inject fetch; live network only when caller enables it.
- *
- * Auth is presence-only: we set Authorization when a key is provided.
- * Ollama accepts a dummy key when none is configured.
- */
-
-import type { AuthTier, RouteRequest } from "../types.js";
-import {
-  ProviderError,
-  mapHttpToProviderError,
-  type AuthStatus,
-  type CostEstimate,
-  type LimitSnapshot,
-  type ModelCapability,
-  type ProviderAdapter,
-  type ProviderEvent,
-  type ProviderInvokeRequest,
-} from "./adapter.js";
-import type { SecretStore } from "../secrets.js";
-import type { CredentialSource } from "../auth/credential-chain.js";
-
-export type OpenAiCompatibleFlavor = "openai" | "openrouter" | "xai" | "ollama";
-
-export interface OpenAiCompatibleOptions {
-  id: string;
-  baseUrl: string;
-  flavor?: OpenAiCompatibleFlavor;
-  /** Presence-only: empty string/undefined means unconfigured for api-key flavors. */
-  apiKey?: string;
-  /**
-   * Ollama and some local servers ignore auth; when true (default for ollama),
-   * send Bearer ollama or dummy if no key is set.
-   */
-  allowDummyKey?: boolean;
-  authTier?: AuthTier;
-  defaultHeaders?: Record<string, string>;
-  /** Injected fetch for tests. Defaults to globalThis.fetch. */
-  fetch?: typeof globalThis.fetch;
-  /** Optional static models for offline listModels. */
-  models?: ModelCapability[];
-  /** Opaque limits by default for remote SaaS; ollama is discoverable offline. */
-  opaqueLimits?: boolean;
-  estimatedCostUsdPer1kTokens?: number;
-  /**
-   * Optional credential chain sources for checkAuth resolution.
-   * When set, checkAuth will try these sources in order to find a credential.
-   */
-  credentialSources?: CredentialSource[];
-  /**
-   * Optional secret store for keychain-backed credential resolution.
-   * Required when credentialSources includes a keychain source.
-   */
-  secretStore?: SecretStore;
-}
-
-const OLLAMA_DUMMY_KEY = "ollama";
-
-function joinUrl(base: string, path: string): string {
-  const b = base.replace(/\/+$/, "");
-  const p = path.startsWith("/") ? path : `/${path}`;
-  return `${b}${p}`;
-}
-
-function headersFor(
-  options: OpenAiCompatibleOptions,
-  apiKey: string | undefined,
-): Record<string, string> {
-  const headers: Record<string, string> = {
-    "content-type": "application/json",
-    ...(options.defaultHeaders ?? {}),
-  };
-
-  const flavor = options.flavor ?? "openai";
-  const allowDummy = options.allowDummyKey ?? flavor === "ollama";
-
-  let key = apiKey?.trim() || undefined;
-  if (!key && allowDummy) {
-    key = OLLAMA_DUMMY_KEY;
-  }
-
-  if (key) {
-    headers.authorization = `Bearer ${key}`;
-  }
-
-  if (flavor === "openrouter") {
-    // OpenRouter recommended metadata; no secrets.
-    if (!headers["http-referer"]) {
-      headers["http-referer"] = "https://offrouter.dev";
-    }
-    if (!headers["x-title"]) {
-      headers["x-title"] = "OffRouter";
-    }
-  }
-
-  return headers;
-}
-
-export class OpenAiCompatibleAdapter implements ProviderAdapter {
-  readonly id: string;
-  private readonly options: OpenAiCompatibleOptions;
-  private readonly active = new Map<string, AbortController>();
-  private readonly cancelled = new Set<string>();
-
-  constructor(options: OpenAiCompatibleOptions) {
-    this.id = options.id;
-    this.options = options;
-  }
-
-  private get fetchImpl(): typeof globalThis.fetch {
-    return this.options.fetch ?? globalThis.fetch.bind(globalThis);
-  }
-
-  private offlineNetworkError(operation: string): ProviderError | null {
-    if (
-      process.env.OFFROUTER_LIVE_TESTS === "1" ||
-      this.options.fetch !== undefined
-    ) {
-      return null;
-    }
-    return new ProviderError({
-      code: "invalid_request",
-      message: `${operation} requires injected fetch or OFFROUTER_LIVE_TESTS=1`,
-      retryable: false,
-    });
-  }
-
-  private resolvedAuthTier(): AuthTier {
-    if (this.options.authTier) return this.options.authTier;
-    return this.options.flavor === "ollama" ? "local" : "api-key";
-  }
-
-  private hasConfiguredKey(): boolean {
-    const key = this.options.apiKey?.trim();
-    return Boolean(key);
-  }
-
-  async listModels(): Promise<ModelCapability[]> {
-    if (this.options.models) {
-      return this.options.models.map((m) => ({ ...m }));
-    }
-
-    // Live path only when models not injected.
-    const offlineError = this.offlineNetworkError("listModels");
-    if (offlineError) {
-      throw offlineError;
-    }
-
-    const res = await this.fetchImpl(joinUrl(this.options.baseUrl, "/models"), {
-      method: "GET",
-      headers: headersFor(this.options, this.options.apiKey),
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => undefined);
-      throw mapHttpToProviderError(res.status, text);
-    }
-    const json = (await res.json()) as {
-      data?: Array<{ id: string; owned_by?: string }>;
-    };
-    const data = json.data ?? [];
-    return data.map((m) => ({
-      modelId: m.id,
-      displayName: m.id,
-      supportsTools: true,
-      supportsStreaming: true,
-      supportsJson: true,
-      supportsImages: false,
-    }));
-  }
-
-  async checkAuth(): Promise<AuthStatus> {
-    const tier = this.resolvedAuthTier();
-    const flavor = this.options.flavor ?? "openai";
-    const allowDummy = this.options.allowDummyKey ?? flavor === "ollama";
-    const hasKey = this.hasConfiguredKey();
-
-    // Try credential chain resolution if sources are configured.
-    let credentialSource: AuthStatus["credentialSource"] = undefined;
-    let resolvedKey = false;
-
-    if (this.options.credentialSources && this.options.secretStore) {
-      const { resolveCredential } = await import("../auth/credential-chain.js");
-      const result = await resolveCredential(this.options.credentialSources, {
-        store: this.options.secretStore,
-      });
-      if (result !== null) {
-        credentialSource = result.source;
-        resolvedKey = true;
-      }
-    }
-
-    // If credential chain found nothing, check the configured key or dummy.
-    const configured = tier === "local" ? true : hasKey || resolvedKey || allowDummy;
-    const finalCredentialSource = credentialSource ?? (hasKey ? "config" : allowDummy ? "none" : "none");
-
-    // OAuth providers are subscription-eligible when tokens are present.
-    // For api-key providers, subscriptionEligible is always false.
-    const isOAuthProvider = flavor === "openai" || flavor === "openrouter";
-    const subscriptionEligible = isOAuthProvider && credentialSource === "oauth";
-
-    return {
-      authTier: tier,
-      authScope:
-        flavor === "openrouter"
-          ? "third-party"
-          : flavor === "ollama"
-            ? "first-party"
-            : "first-party",
-      configured,
-      hasApiKey: hasKey || resolvedKey,
-      subscriptionStatus: undefined,
-      limitsDiscoverable: !(this.options.opaqueLimits ?? tier !== "local"),
-      health: configured ? "healthy" : "dead",
-      detail: !hasKey && !resolvedKey && allowDummy ? "using_dummy_key" : undefined,
-      credentialSource: configured ? finalCredentialSource : "none",
-      subscriptionEligible,
-    };
-  }
-
-  async queryLimits(authTier: AuthTier): Promise<LimitSnapshot> {
-    const opaque =
-      this.options.opaqueLimits ?? this.resolvedAuthTier() !== "local";
-    if (opaque) {
-      return {
-        authTier,
-        discoverable: false,
-        opaque: true,
-        metadata: {
-          flavor: this.options.flavor ?? "openai",
-          note: "limits_not_exposed_by_provider",
-        },
-      };
-    }
-    return {
-      authTier,
-      discoverable: true,
-      opaque: false,
-      remaining: undefined,
-      limit: undefined,
-      unit: "unknown",
-      metadata: {
-        flavor: this.options.flavor ?? "openai",
-        source: "local_runtime",
-      },
-    };
-  }
-
-  async estimate(
-    request: RouteRequest,
-    model: string,
-    authTier: AuthTier,
-  ): Promise<CostEstimate> {
-    const previewLen = request.task.promptPreview.length;
-    const inputTokensEstimate = Math.max(1, Math.ceil(previewLen / 4));
-    const per1k = this.options.estimatedCostUsdPer1kTokens ?? 0.001;
-    const cost =
-      authTier === "api-key" ? (inputTokensEstimate / 1000) * per1k : 0;
-    return {
-      model,
-      authTier,
-      estimatedCostUsd: cost,
-      currency: "USD",
-      inputTokensEstimate,
-      note: "heuristic prompt-preview estimate",
-    };
-  }
-
-  async *invoke(request: ProviderInvokeRequest): AsyncIterable<ProviderEvent> {
-    if (this.cancelled.has(request.callId) || request.signal?.aborted) {
-      yield {
-        type: "error",
-        callId: request.callId,
-        error: new ProviderError({
-          code: "cancelled",
-          message: `call ${request.callId} cancelled`,
-          retryable: false,
-        }),
-      };
-      return;
-    }
-
-    const offlineError = this.offlineNetworkError("invoke");
-    if (offlineError) {
-      yield { type: "error", callId: request.callId, error: offlineError };
-      return;
-    }
-
-    const controller = new AbortController();
-    this.active.set(request.callId, controller);
-    const onExternalAbort = () => controller.abort();
-    request.signal?.addEventListener("abort", onExternalAbort, { once: true });
-
-    yield {
-      type: "start",
-      callId: request.callId,
-      model: request.model,
-    };
-
-    try {
-      const stream = request.stream ?? false;
-      const body = {
-        model: request.model,
-        messages: request.messages.map((m) => ({
-          role: m.role,
-          content: m.content,
-        })),
-        stream,
-        ...(request.maxOutputTokens !== undefined
-          ? { max_tokens: request.maxOutputTokens }
-          : {}),
-        ...(request.temperature !== undefined
-          ? { temperature: request.temperature }
-          : {}),
-      };
-
-      const res = await this.fetchImpl(
-        joinUrl(this.options.baseUrl, "/chat/completions"),
-        {
-          method: "POST",
-          headers: headersFor(this.options, this.options.apiKey),
-          body: JSON.stringify(body),
-          signal: controller.signal,
-        },
-      );
-
-      if (!res.ok) {
-        const text = await res.text().catch(() => undefined);
-        const err = mapHttpToProviderError(res.status, text);
-        yield { type: "error", callId: request.callId, error: err };
-        return;
-      }
-
-      if (stream) {
-        if (!res.body) {
-          yield {
-            type: "error",
-            callId: request.callId,
-            error: new ProviderError({
-              code: "stream_interrupted",
-              message: "streaming response missing body",
-              retryable: true,
-            }),
-          };
-          return;
-        }
-        yield* this.readSseStream(request.callId, res.body, controller.signal);
-        return;
-      }
-
-      const json = (await res.json()) as {
-        choices?: Array<{
-          message?: { content?: string };
-          finish_reason?: string;
-        }>;
-        usage?: {
-          prompt_tokens?: number;
-          completion_tokens?: number;
-          total_tokens?: number;
-        };
-      };
-      const text = json.choices?.[0]?.message?.content ?? "";
-      if (text) {
-        yield {
-          type: "text-delta",
-          callId: request.callId,
-          text,
-        };
-      }
-      if (json.usage) {
-        yield {
-          type: "usage",
-          callId: request.callId,
-          inputTokens: json.usage.prompt_tokens,
-          outputTokens: json.usage.completion_tokens,
-          totalTokens: json.usage.total_tokens,
-        };
-      }
-      yield {
-        type: "done",
-        callId: request.callId,
-        finishReason: json.choices?.[0]?.finish_reason ?? "stop",
-      };
-    } catch (err) {
-      if (controller.signal.aborted || this.cancelled.has(request.callId)) {
-        yield {
-          type: "error",
-          callId: request.callId,
-          error: new ProviderError({
-            code: "cancelled",
-            message: `call ${request.callId} cancelled`,
-            retryable: false,
-            cause: err,
-          }),
-        };
-        return;
-      }
-      if (err instanceof ProviderError) {
-        yield { type: "error", callId: request.callId, error: err };
-        return;
-      }
-      const message =
-        err instanceof Error ? err.message : "unknown network error";
-      yield {
-        type: "error",
-        callId: request.callId,
-        error: new ProviderError({
-          code: "network",
-          message,
-          retryable: true,
-          cause: err,
-        }),
-      };
-    } finally {
-      request.signal?.removeEventListener("abort", onExternalAbort);
-      this.active.delete(request.callId);
-    }
-  }
-
-  private async *readSseStream(
-    callId: string,
-    body: ReadableStream<Uint8Array>,
-    signal: AbortSignal,
-  ): AsyncIterable<ProviderEvent> {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const onAbort = () => {
-      void reader.cancel().catch(() => undefined);
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    try {
-      while (true) {
-        if (signal.aborted || this.cancelled.has(callId)) {
-          yield {
-            type: "error",
-            callId,
-            error: new ProviderError({
-              code: "cancelled",
-              message: `call ${callId} cancelled`,
-              retryable: false,
-            }),
-          };
-          return;
-        }
-        const { done, value } = await reader.read();
-        if (signal.aborted || this.cancelled.has(callId)) {
-          yield {
-            type: "error",
-            callId,
-            error: new ProviderError({
-              code: "cancelled",
-              message: `call ${callId} cancelled`,
-              retryable: false,
-            }),
-          };
-          return;
-        }
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const parts = buffer.split("\n");
-        buffer = parts.pop() ?? "";
-        for (const line of parts) {
-          const trimmed = line.trim();
-          if (!trimmed.startsWith("data:")) continue;
-          const payload = trimmed.slice(5).trim();
-          if (payload === "[DONE]") {
-            yield { type: "done", callId, finishReason: "stop" };
-            return;
-          }
-          try {
-            const json = JSON.parse(payload) as {
-              choices?: Array<{
-                delta?: { content?: string };
-                finish_reason?: string | null;
-              }>;
-              usage?: {
-                prompt_tokens?: number;
-                completion_tokens?: number;
-                total_tokens?: number;
-              };
-            };
-            const delta = json.choices?.[0]?.delta?.content;
-            if (delta) {
-              yield { type: "text-delta", callId, text: delta };
-            }
-            if (json.usage) {
-              yield {
-                type: "usage",
-                callId,
-                inputTokens: json.usage.prompt_tokens,
-                outputTokens: json.usage.completion_tokens,
-                totalTokens: json.usage.total_tokens,
-              };
-            }
-            const finish = json.choices?.[0]?.finish_reason;
-            if (finish) {
-              yield { type: "done", callId, finishReason: finish };
-              return;
-            }
-          } catch {
-            // ignore malformed sse lines
-          }
-        }
-      }
-      yield { type: "done", callId, finishReason: "stop" };
-    } catch (err) {
-      if (signal.aborted || this.cancelled.has(callId)) {
-        yield {
-          type: "error",
-          callId,
-          error: new ProviderError({
-            code: "cancelled",
-            message: `call ${callId} cancelled`,
-            retryable: false,
-            cause: err,
-          }),
-        };
-        return;
-      }
-      yield {
-        type: "error",
-        callId,
-        error: new ProviderError({
-          code: "stream_interrupted",
-          message: err instanceof Error ? err.message : "stream interrupted",
-          retryable: true,
-          cause: err,
-        }),
-      };
-    } finally {
-      signal.removeEventListener("abort", onAbort);
-      try {
-        reader.releaseLock();
-      } catch {
-        // ignore
-      }
-    }
-  }
-
-  async cancel(callId: string): Promise<void> {
-    this.cancelled.add(callId);
-    this.active.get(callId)?.abort();
-  }
-}
-
-export function createOpenAiCompatibleAdapter(
-  options: OpenAiCompatibleOptions,
-): OpenAiCompatibleAdapter {
-  return new OpenAiCompatibleAdapter(options);
-}
-
-/** Exported for tests that assert Ollama dummy key behavior. */
-export const OLLAMA_DUMMY_BEARER = `Bearer ${OLLAMA_DUMMY_KEY}`;