cartethyia 2.7.9 → 2.8.0

package/src/providers/operations/model-discovery-cache.ts

@@ -1,34 +0,0 @@
-/**
- * TTL cache for credential-free model discovery.
- *
- * Only non-null, non-empty results are cached, so failed discovery stays
- * retryable. Concurrent misses for one key share one load through TtlCache.
- */
-import { TtlCacheFamily } from "../../persistence/ttl-cache";
-import type { ModelDefinition } from "../provider-model-definition";
-
-const MODEL_DISCOVERY_CACHE_TTL_MS = 10 * 60 * 1000;
-const discoveryCaches = new TtlCacheFamily<readonly ModelDefinition[]>({
-  defaultTtlMs: MODEL_DISCOVERY_CACHE_TTL_MS,
-});
-
-export interface CachedModelDiscoveryOptions {
-  readonly ttlMs?: number;
-}
-
-/** Returns cached models, retrying null/empty loads on the next call. */
-export async function getCachedModelDiscovery(
-  key: string,
-  loader: () => Promise<readonly ModelDefinition[] | null>,
-  options: CachedModelDiscoveryOptions = {},
-): Promise<readonly ModelDefinition[] | null> {
-  return discoveryCaches.for(options.ttlMs).load(key, loader, {
-    namespace: "model-discovery",
-    shouldCache: (models) => models.length > 0,
-  });
-}
-
-/** Drops all cached discoveries. Test-only. */
-export function resetModelDiscoveryCacheForTesting(): void {
-  discoveryCaches.clear();
-}

package/src/providers/operations/probe-fetch.ts

@@ -1,15 +0,0 @@
-import type { ValidatedOutboundFetch } from "../provider-contracts";
-
-/**
- * Probe fetch wrapper: merges `Request`-carried headers with per-call init
- * headers before delegating to the validated fetch. Required wherever the
- * fetch is handed to adapters as `outbound_fetch`, because adapters may call
- * it with a `Request` whose headers would otherwise be dropped.
- */
-export function createProbeFetch(fetcher: ValidatedOutboundFetch): ValidatedOutboundFetch {
-  return (input, init) => {
-    const headers = new Headers(input instanceof Request ? input.headers : undefined);
-    new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
-    return fetcher(input, { ...init, headers });
-  };
-}

package/src/providers/operations/provider-version-cache.ts

@@ -1,30 +0,0 @@
-/**
- * TTL cache for best-effort version discovery. Successful values are cached;
- * null results and failures remain retryable. Concurrent misses share a load.
- */
-import { TtlCacheFamily } from "../../persistence/ttl-cache";
-import { retryWithBackoff } from "../../network/retry";
-
-const VERSION_CACHE_TTL_MS = 5 * 60 * 1000;
-const versionCaches = new TtlCacheFamily<string>({ defaultTtlMs: VERSION_CACHE_TTL_MS });
-
-export interface CachedVersionOptions {
-  readonly ttlMs?: number;
-  readonly maxRetries?: number;
-}
-
-export async function getCachedVersion(
-  key: string,
-  loader: () => Promise<string | null>,
-  options: CachedVersionOptions = {},
-): Promise<string | null> {
-  const loadWithRetry = () => retryWithBackoff(loader, { maxRetries: options.maxRetries ?? 2 });
-  return versionCaches.for(options.ttlMs).load(key, loadWithRetry, {
-    namespace: "provider-version",
-  });
-}
-
-/** Drops all cached versions. Test-only. */
-export function resetVersionCacheForTesting(): void {
-  versionCaches.clear();
-}

package/src/providers/provider-capabilities.ts

@@ -1,33 +0,0 @@
-import type { ProviderModule, ProviderAuthentication } from "./provider-registry";
-import type { OAuthLoginClient } from "./authentication/oauth-flow-store";
-import type { QuotaFetcher } from "./quota/quota-support";
-
-/** Provider implementation fields composed with canonical metadata. */
-export type ProviderModuleCapabilities = Partial<Omit<ProviderModule, "loadAdapter">> &
-  Pick<ProviderModule, "loadAdapter">;
-
-/**
- * Creates a lazy authentication loader from a dynamic import and client export.
- * Most OAuth clients also refresh their own tokens.
- */
-export function oauthCapability<M, K extends keyof M>(
-  loader: () => Promise<M>,
-  exportName: K,
-  options: { readonly withRefresher?: boolean } = {},
-): () => Promise<ProviderAuthentication> {
-  return async () => {
-    const module = await loader();
-    const client = (module as Record<string, unknown>)[exportName as string] as OAuthLoginClient & { refresh: unknown };
-    return options.withRefresher
-      ? ({ client, refresher: client } as ProviderAuthentication)
-      : ({ client } as ProviderAuthentication);
-  };
-}
-
-/** Creates a lazy quota collector loader from a dynamic import and export name. */
-export function quotaCapability<M, K extends keyof M>(
-  loader: () => Promise<M>,
-  exportName: K,
-): () => Promise<QuotaFetcher> {
-  return () => loader().then((module) => (module as Record<string, unknown>)[exportName as string] as QuotaFetcher);
-}

package/src/providers/provider-credential-envelope.ts

@@ -1,43 +0,0 @@
-/**
- * Provider credential envelope handling.
- *
- * One implementation for stripping the token envelope a provider-issued
- * credential may carry, so adapters never emit `Bearer Bearer`. Kept in its
- * own module (rather than the provider registry) because the adapters that
- * consume it must not import the registry: the registry imports every
- * adapter, so the reverse edge is a cycle.
- */
-
-/** Envelope labels a stored credential may carry. */
-export type TokenEnvelope = "bearer" | "oauth" | "provider";
-
-const ENVELOPE_PREFIXES: Record<TokenEnvelope, string> = {
-  bearer: "Bearer ",
-  oauth: "OAuth ",
-  provider: "provider:",
-};
-
-/**
- * Removes one explicitly identified envelope so adapters never emit
- * `Bearer Bearer`. The bearer branch strips case-insensitively with
- * surrounding-whitespace normalization; oauth/provider envelopes keep their
- * exact byte slices. Input without the identified envelope passes through
- * untouched.
- */
-export function unwrapProviderToken(
-  value: string | Uint8Array,
-  envelope?: TokenEnvelope,
-): Uint8Array {
-  const bytes = typeof value === "string" ? new TextEncoder().encode(value) : value;
-  const text = new TextDecoder().decode(bytes);
-  if (envelope === "bearer") {
-    const trimmed = text.trim();
-    const match = /^bearer\s+(.+)$/is.exec(trimmed);
-    return new TextEncoder().encode((match?.[1] ?? trimmed).trim());
-  }
-  const prefix = envelope === undefined ? undefined : ENVELOPE_PREFIXES[envelope];
-  if (prefix !== undefined && text.toLowerCase().startsWith(prefix.toLowerCase())) {
-    return new TextEncoder().encode(text.slice(prefix.length));
-  }
-  return new Uint8Array(bytes);
-}