@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/providers/context-discovery.js

@@ -0,0 +1,341 @@
+/**
+ * context-discovery.ts
+ *
+ * Multi-provider context window discovery with verbose-first endpoint probing.
+ *
+ * Implements a provider-agnostic discovery chain that probes endpoints from
+ * most-informative (verbose) to least-informative, returning the richest
+ * available context window data for each model.
+ *
+ * Discovery chain (ordered most-verbose to least-verbose):
+ *   1. /api/v1/models  — LM Studio rich format (key + max_context_length)
+ *   2. /api/tags       — Ollama list + per-model /api/show for context_length
+ *   3. /v1/models      — OpenAI compat (id, optionally max_model_len for vLLM)
+ *   4. /props          — llama.cpp server-level n_ctx (single context all models)
+ *   5. /info           — TGI format (max_input_tokens / max_total_tokens)
+ *
+ * Feature flag: `local-provider-context-ingestion`
+ */
+import { logger } from '../utils/logger.js';
+import { summarizeError } from '../utils/error-display.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Timeout per individual probe request. */
+const PROBE_TIMEOUT_MS = 5_000;
+/** Placeholder model ID used when a server-level endpoint has no model list. */
+export const SERVER_LEVEL_MODEL_ID = '__server__';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract the origin (scheme + host + port) from a base URL string.
+ * E.g. `http://192.168.0.85:1234/v1` → `http://192.168.0.85:1234`
+ */
+function extractOrigin(baseURL) {
+    try {
+        return new URL(baseURL).origin;
+    }
+    catch {
+        // Fallback: strip everything after the third slash component
+        const match = baseURL.match(/^(https?:\/\/[^/]+)/);
+        return match ? match[1] : baseURL;
+    }
+}
+/**
+ * Perform a timed fetch with optional Bearer auth.
+ * Returns the Response on success, or null on any error (timeout, network, 4xx/5xx).
+ */
+async function probe(url, options = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    try {
+        const headers = { Accept: 'application/json' };
+        if (options.apiKey)
+            headers['Authorization'] = `Bearer ${options.apiKey}`;
+        if (options.body)
+            headers['Content-Type'] = 'application/json';
+        const response = await fetch(url, {
+            method: options.method ?? 'GET',
+            headers,
+            body: options.body,
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            logger.debug('[context-discovery] Non-OK probe response', { url, status: response.status });
+            return null;
+        }
+        return response;
+    }
+    catch (err) {
+        const name = err?.name;
+        if (name === 'AbortError') {
+            logger.debug('[context-discovery] Probe timed out', { url });
+        }
+        else {
+            logger.debug('[context-discovery] Probe failed', { url, error: summarizeError(err) });
+        }
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Safely parse JSON from a Response. Returns null on parse error.
+ */
+async function parseJSON(response) {
+    try {
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Probe `/api/v1/models` (LM Studio rich format).
+ * Returns model_id → context_length map, or null if the endpoint is absent.
+ */
+async function probeLMStudio(origin, apiKey) {
+    const url = `${origin}/api/v1/models`;
+    const response = await probe(url, { apiKey });
+    if (!response)
+        return null;
+    const json = await parseJSON(response);
+    if (!Array.isArray(json?.models))
+        return null;
+    const result = new Map();
+    for (const model of json.models) {
+        if (typeof model.key !== 'string')
+            continue;
+        if (typeof model.max_context_length === 'number' && model.max_context_length > 0) {
+            result.set(model.key, model.max_context_length);
+        }
+    }
+    if (result.size > 0) {
+        logger.debug('[context-discovery] LM Studio probe succeeded', { url, count: result.size });
+        return result;
+    }
+    return null;
+}
+/**
+ * Extract context length from an Ollama `/api/show` response.
+ * Tries `model_info.context_length`, then parses `num_ctx` from modelfile.
+ */
+function extractOllamaContextLength(show) {
+    // Prefer structured model_info
+    if (show.model_info) {
+        const ctx = show.model_info['context_length'];
+        if (typeof ctx === 'number' && ctx > 0)
+            return ctx;
+        // Explicit key scan for context_length variants
+        for (const [key, val] of Object.entries(show.model_info)) {
+            if (/context[_.]?len/i.test(key) && typeof val === 'number' && val > 0) {
+                return val;
+            }
+        }
+    }
+    // Fallback: parse num_ctx from modelfile
+    if (typeof show.modelfile === 'string') {
+        const match = show.modelfile.match(/^\s*PARAMETER\s+num_ctx\s+(\d+)/im);
+        if (match) {
+            const ctx = parseInt(match[1], 10);
+            if (ctx > 0)
+                return ctx;
+        }
+    }
+    return null;
+}
+/**
+ * Probe `/api/tags` (Ollama model list) then per-model `/api/show`.
+ * Returns model_id → context_length map, or null if the endpoint is absent.
+ */
+async function probeOllama(origin, apiKey) {
+    const tagsUrl = `${origin}/api/tags`;
+    const tagsResponse = await probe(tagsUrl, { apiKey });
+    if (!tagsResponse)
+        return null;
+    const tagsJson = await parseJSON(tagsResponse);
+    if (!Array.isArray(tagsJson?.models))
+        return null;
+    const result = new Map();
+    // Fetch show data for each model in groups of SHOW_CONCURRENCY to bound parallelism.
+    const SHOW_CONCURRENCY = 10;
+    const names = tagsJson.models.filter((m) => typeof m.name === 'string').map((m) => m.name);
+    for (let i = 0; i < names.length; i += SHOW_CONCURRENCY) {
+        const batch = names.slice(i, i + SHOW_CONCURRENCY);
+        const batchResults = await Promise.allSettled(batch.map(async (name) => {
+            const showUrl = `${origin}/api/show`;
+            const showResponse = await probe(showUrl, {
+                apiKey,
+                method: 'POST',
+                body: JSON.stringify({ name }),
+            });
+            if (!showResponse)
+                return;
+            const showJson = await parseJSON(showResponse);
+            if (!showJson)
+                return;
+            const ctx = extractOllamaContextLength(showJson);
+            if (ctx !== null) {
+                result.set(name, ctx);
+            }
+        }));
+        // Log any individual show failures at debug level only
+        for (const r of batchResults) {
+            if (r.status === 'rejected') {
+                logger.debug('[context-discovery] Ollama /api/show error', { error: String(r.reason) });
+            }
+        }
+    }
+    if (result.size > 0) {
+        logger.debug('[context-discovery] Ollama probe succeeded', { url: tagsUrl, count: result.size });
+        return result;
+    }
+    return null;
+}
+function extractOpenAIContextLength(model) {
+    if (typeof model.max_model_len === 'number' && model.max_model_len > 0)
+        return model.max_model_len;
+    if (typeof model.max_context_length === 'number' && model.max_context_length > 0)
+        return model.max_context_length;
+    if (typeof model.context_length === 'number' && model.context_length > 0)
+        return model.context_length;
+    if (model.limits) {
+        if (typeof model.limits.max_context_length === 'number' && model.limits.max_context_length > 0) {
+            return model.limits.max_context_length;
+        }
+        if (typeof model.limits.context_length === 'number' && model.limits.context_length > 0) {
+            return model.limits.context_length;
+        }
+    }
+    return null;
+}
+/**
+ * Probe `/v1/models` (OpenAI-compatible endpoint).
+ * Returns model_id → context_length map (may be empty if no context fields present),
+ * or null if the endpoint is absent.
+ */
+async function probeOpenAICompat(baseURL, apiKey) {
+    const url = baseURL.replace(/\/$/, '') + '/models';
+    const response = await probe(url, { apiKey });
+    if (!response)
+        return null;
+    const json = await parseJSON(response);
+    if (!Array.isArray(json?.data))
+        return null;
+    const result = new Map();
+    for (const model of json.data) {
+        if (typeof model.id !== 'string')
+            continue;
+        const ctx = extractOpenAIContextLength(model);
+        if (ctx !== null) {
+            result.set(model.id, ctx);
+        }
+    }
+    // Return even if empty — the endpoint existing is meaningful
+    logger.debug('[context-discovery] OpenAI compat probe completed', { url, count: result.size });
+    return result;
+}
+/**
+ * Probe `/props` (llama.cpp server-level context).
+ * Returns a single-entry map keyed by SERVER_LEVEL_MODEL_ID, or null.
+ */
+async function probeLlamaCpp(origin, apiKey) {
+    const url = `${origin}/props`;
+    const response = await probe(url, { apiKey });
+    if (!response)
+        return null;
+    const json = await parseJSON(response);
+    if (typeof json?.n_ctx !== 'number' || json.n_ctx <= 0)
+        return null;
+    logger.debug('[context-discovery] llama.cpp /props probe succeeded', { url, n_ctx: json.n_ctx });
+    return new Map([[SERVER_LEVEL_MODEL_ID, json.n_ctx]]);
+}
+/**
+ * Probe `/info` (TGI single-model server info).
+ * Prefers max_total_tokens, falls back to max_input_tokens.
+ * Returns a single-entry map keyed by SERVER_LEVEL_MODEL_ID, or null.
+ */
+async function probeTGI(origin, apiKey) {
+    const url = `${origin}/info`;
+    const response = await probe(url, { apiKey });
+    if (!response)
+        return null;
+    const json = await parseJSON(response);
+    if (!json)
+        return null;
+    const ctx = (typeof json.max_total_tokens === 'number' && json.max_total_tokens > 0
+        ? json.max_total_tokens
+        : null) ??
+        (typeof json.max_input_tokens === 'number' && json.max_input_tokens > 0
+            ? json.max_input_tokens
+            : null);
+    if (ctx === null)
+        return null;
+    logger.debug('[context-discovery] TGI /info probe succeeded', { url, ctx });
+    return new Map([[SERVER_LEVEL_MODEL_ID, ctx]]);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Discover context window sizes for all models at the given provider base URL.
+ *
+ * Probes endpoints in verbose-first order:
+ *   1. LM Studio `/api/v1/models`
+ *   2. Ollama `/api/tags` + `/api/show`
+ *   3. OpenAI-compat `/v1/models`
+ *   4. llama.cpp `/props`
+ *   5. TGI `/info`
+ *
+ * The first probe that yields a non-null result populates the map. Subsequent
+ * probes only ADD entries for model IDs not yet present — they never overwrite
+ * data from a more-informative probe.
+ *
+ * @param baseURL - Provider base URL (e.g. `http://localhost:11434/v1`).
+ *   The `/v1` suffix is used for the OpenAI-compat probe; the origin is
+ *   derived automatically for all other probes.
+ * @param apiKey  - Optional Bearer token sent with every probe request.
+ * @returns Map of model ID → context window in tokens. Empty map if all
+ *          probes fail or none return context length data.
+ */
+export async function discoverContextWindows(baseURL, apiKey) {
+    const origin = extractOrigin(baseURL);
+    const result = new Map();
+    /**
+     * Merge entries from a probe result into the accumulator.
+     * Only adds entries not already present (verbose-first wins).
+     */
+    function merge(probeResult) {
+        if (!probeResult)
+            return;
+        for (const [id, ctx] of probeResult) {
+            if (!result.has(id)) {
+                result.set(id, ctx);
+            }
+        }
+    }
+    // Probes run sequentially (not in parallel) because of verbose-first ordering:
+    // each successful probe short-circuits by populating result, and merge() skips
+    // model IDs already present. Parallel probing would lose this precedence guarantee.
+    // Probe 1: LM Studio (richest — has max_context_length per model)
+    merge(await probeLMStudio(origin, apiKey));
+    // Probe 2: Ollama (per-model show with context_length / num_ctx)
+    merge(await probeOllama(origin, apiKey));
+    // Probe 3: OpenAI compat (id + optional max_model_len/max_context_length)
+    merge(await probeOpenAICompat(baseURL, apiKey));
+    // Probe 4: llama.cpp /props (server-level n_ctx)
+    merge(await probeLlamaCpp(origin, apiKey));
+    // Probe 5: TGI /info (server-level max_total_tokens)
+    merge(await probeTGI(origin, apiKey));
+    logger.debug('[context-discovery] Discovery complete', {
+        baseURL,
+        totalModels: result.size,
+    });
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Exports for testing
+// ---------------------------------------------------------------------------
+export { probeLMStudio as _probeLMStudio, probeOllama as _probeOllama, probeOpenAICompat as _probeOpenAICompat, probeLlamaCpp as _probeLlamaCpp, probeTGI as _probeTGI, extractOrigin as _extractOrigin, extractOllamaContextLength as _extractOllamaContextLength, extractOpenAIContextLength as _extractOpenAIContextLength, };

package/dist/_internal/platform/providers/effort-levels.d.ts

@@ -0,0 +1,7 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Shared effort level descriptions used across model picker, overlay renderer,
+ * and command handler. Single source of truth — import from here.
+ */
+export declare const EFFORT_DESCRIPTIONS: Record<string, string>;
+//# sourceMappingURL=effort-levels.d.ts.map

package/dist/_internal/platform/providers/effort-levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effort-levels.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/effort-levels.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAKtD,CAAC"}

package/dist/_internal/platform/providers/effort-levels.js

@@ -0,0 +1,11 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Shared effort level descriptions used across model picker, overlay renderer,
+ * and command handler. Single source of truth — import from here.
+ */
+export const EFFORT_DESCRIPTIONS = {
+    instant: 'Fastest, minimal reasoning',
+    low: 'Quick with light reasoning',
+    medium: 'Balanced speed and quality',
+    high: 'Thorough, deep reasoning',
+};

package/dist/_internal/platform/providers/favorites.d.ts

@@ -0,0 +1,34 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export interface FavoriteEntry {
+    modelId: string;
+    pinnedAt: string;
+}
+export interface UsageEntry {
+    modelId: string;
+    lastUsed: string;
+    count: number;
+}
+export interface FavoritesData {
+    pinned: FavoriteEntry[];
+    history: UsageEntry[];
+}
+export interface FavoritesStoreOptions {
+    readonly dir: string;
+}
+export declare class FavoritesStore {
+    private readonly dir;
+    private cache;
+    constructor(options: FavoritesStoreOptions);
+    getDirectory(): string;
+    getPath(): string;
+    load(): Promise<FavoritesData>;
+    save(data: FavoritesData): Promise<void>;
+    pinModel(id: string): Promise<void>;
+    unpinModel(id: string): Promise<void>;
+    getPinned(): Promise<string[]>;
+    isModelPinned(id: string): Promise<boolean>;
+    recordUsage(id: string): Promise<void>;
+    getRecentModels(n: number): Promise<string[]>;
+    private getData;
+}
+//# sourceMappingURL=favorites.d.ts.map

package/dist/_internal/platform/providers/favorites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"favorites.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/favorites.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAOrF,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAQD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,KAAK,CAA8B;gBAE/B,OAAO,EAAE,qBAAqB;IAI1C,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IAIX,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC;IAuB9B,IAAI,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IASxC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOnC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMrC,SAAS,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAK9B,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK3C,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBtC,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;YASrC,OAAO;CAItB"}

package/dist/_internal/platform/providers/favorites.js

@@ -0,0 +1,103 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import { randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { rename } from 'node:fs/promises';
+import { join } from 'node:path';
+const MAX_HISTORY = 100;
+function emptyData() {
+    return { pinned: [], history: [] };
+}
+export class FavoritesStore {
+    dir;
+    cache = null;
+    constructor(options) {
+        this.dir = options.dir;
+    }
+    getDirectory() {
+        return this.dir;
+    }
+    getPath() {
+        return join(this.dir, 'favorites.json');
+    }
+    async load() {
+        const file = Bun.file(this.getPath());
+        if (!await file.exists()) {
+            const empty = emptyData();
+            this.cache = empty;
+            return empty;
+        }
+        try {
+            const text = await file.text();
+            const parsed = JSON.parse(text);
+            const loaded = {
+                pinned: Array.isArray(parsed.pinned) ? parsed.pinned : [],
+                history: Array.isArray(parsed.history) ? parsed.history : [],
+            };
+            this.cache = loaded;
+            return loaded;
+        }
+        catch {
+            const empty = emptyData();
+            this.cache = empty;
+            return empty;
+        }
+    }
+    async save(data) {
+        mkdirSync(this.dir, { recursive: true });
+        const path = this.getPath();
+        const tmp = `${path}.tmp.${randomUUID()}`;
+        await Bun.write(tmp, JSON.stringify(data, null, 2));
+        await rename(tmp, path);
+        this.cache = data;
+    }
+    async pinModel(id) {
+        const data = await this.getData();
+        if (data.pinned.some((entry) => entry.modelId === id))
+            return;
+        data.pinned.push({ modelId: id, pinnedAt: new Date().toISOString() });
+        await this.save(data);
+    }
+    async unpinModel(id) {
+        const data = await this.getData();
+        data.pinned = data.pinned.filter((entry) => entry.modelId !== id);
+        await this.save(data);
+    }
+    async getPinned() {
+        const data = await this.getData();
+        return data.pinned.map((entry) => entry.modelId);
+    }
+    async isModelPinned(id) {
+        const data = await this.getData();
+        return data.pinned.some((entry) => entry.modelId === id);
+    }
+    async recordUsage(id) {
+        const data = await this.getData();
+        const now = new Date().toISOString();
+        const existing = data.history.find((entry) => entry.modelId === id);
+        if (existing) {
+            existing.count += 1;
+            existing.lastUsed = now;
+        }
+        else {
+            data.history.push({ modelId: id, lastUsed: now, count: 1 });
+        }
+        if (data.history.length > MAX_HISTORY) {
+            data.history.sort((a, b) => a.lastUsed.localeCompare(b.lastUsed));
+            data.history = data.history.slice(data.history.length - MAX_HISTORY);
+        }
+        await this.save(data);
+    }
+    async getRecentModels(n) {
+        const data = await this.getData();
+        return data.history
+            .slice()
+            .sort((a, b) => b.lastUsed.localeCompare(a.lastUsed))
+            .slice(0, n)
+            .map((entry) => entry.modelId);
+    }
+    async getData() {
+        if (this.cache)
+            return this.cache;
+        return this.load();
+    }
+}

package/dist/_internal/platform/providers/local-context-ingestion.d.ts

@@ -0,0 +1,89 @@
+/**
+ * local-context-ingestion.ts
+ *
+ * Local provider `max_context_length` ingestion.
+ *
+ * Fetches the /v1/models endpoint for local/custom providers and extracts
+ * per-model `max_context_length` values. Results are keyed by model ID and
+ * stored in an in-memory cache per provider.
+ *
+ * Feature flag: `local-provider-context-ingestion`
+ * When disabled, this module is a no-op and callers fall back to the
+ * statically-configured context window.
+ *
+ * Provenance ladder (highest to lowest):
+ *   provider_api     — value from /v1/models max_context_length
+ *   configured_cap   — explicit contextWindow in custom provider config
+ *   fallback         — DEFAULT_CONTEXT_WINDOW constant
+ */
+/**
+ * Provenance tag for a resolved context window value.
+ *
+ * - `provider_api`   — sourced from the provider's /v1/models endpoint
+ * - `configured_cap` — explicit value from the custom provider config file
+ * - `fallback`       — DEFAULT_CONTEXT_WINDOW (no config, no API response)
+ */
+export type ContextWindowProvenance = 'provider_api' | 'configured_cap' | 'fallback';
+/**
+ * A fully-resolved context window with its provenance and metadata.
+ */
+export interface ResolvedContextWindow {
+    /** Effective context window in tokens, ready for use in budgeting. */
+    tokens: number;
+    /** How this value was resolved. */
+    provenance: ContextWindowProvenance;
+    /**
+     * When provenance is `provider_api`, the raw value from the API.
+     * May differ from `tokens` when a configured_cap is applied.
+     */
+    apiReportedTokens?: number;
+    /**
+     * When provenance is `provider_api`, the safe cap that was applied
+     * (equal to `tokens` when no cap was enforced).
+     */
+    safeCap?: number;
+}
+/**
+ * Default fallback context window when neither the API nor the config
+ * provides a value.
+ */
+export declare const DEFAULT_CONTEXT_WINDOW = 8192;
+/**
+ * Ingest context window data from a local provider's /v1/models endpoint.
+ *
+ * Results are cached in-memory for `CACHE_TTL_MS`. Repeated calls within the
+ * TTL return the cached value immediately without making a network request.
+ *
+ * @param providerName - Unique provider name (used as cache key).
+ * @param baseURL      - Provider base URL (e.g. `http://localhost:11434/v1`).
+ * @param apiKey       - Optional API key sent as Bearer token.
+ * @returns Map of model ID → raw context length from the API, or null if
+ *          the provider is offline or returned an unrecognised response.
+ */
+export declare class LocalContextIngestionService {
+    private readonly providerCache;
+    ingestProviderContextWindows(providerName: string, baseURL: string, apiKey?: string): Promise<Map<string, number> | null>;
+    clearProviderCache(providerName: string): void;
+    clearAllCaches(): void;
+    getDiagnostics(): Array<{
+        providerName: string;
+        fetchedAt: number;
+        modelCount: number;
+        failed: boolean;
+    }>;
+}
+/**
+ * Resolve the effective context window for a single model with provenance.
+ *
+ * Priority ladder:
+ *   1. provider_api  — `apiContextLength` when valid (> 0)
+ *   2. configured_cap — `configuredContextWindow` when valid (> 0)
+ *   3. fallback      — `DEFAULT_CONTEXT_WINDOW`
+ *
+ * @param modelId                - Model ID (for logging).
+ * @param apiContextLength       - Context length from /v1/models (null if not available).
+ * @param configuredContextWindow - Context window from custom provider config (0 if not set).
+ * @returns Resolved context window with provenance metadata.
+ */
+export declare function resolveContextWindow(modelId: string, apiContextLength: number | null, configuredContextWindow: number): ResolvedContextWindow;
+//# sourceMappingURL=local-context-ingestion.d.ts.map

package/dist/_internal/platform/providers/local-context-ingestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-context-ingestion.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/local-context-ingestion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AASH;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,GAAG,cAAc,GAAG,gBAAgB,GAAG,UAAU,CAAC;AAErF;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,UAAU,EAAE,uBAAuB,CAAC;IACpC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAMD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,OAAQ,CAAC;AAyB5C;;;;;;;;;;;GAWG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiC;IAEzD,4BAA4B,CAChC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAoBtC,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAI9C,cAAc,IAAI,IAAI;IAItB,cAAc,IAAI,KAAK,CAAC;QACtB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;CAQH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,GAAG,IAAI,EAC/B,uBAAuB,EAAE,MAAM,GAC9B,qBAAqB,CAyBvB"}