@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/providers/cache-capability.d.ts

@@ -0,0 +1,51 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/** Cache capability types for LLM providers. */
+export type CacheType = 'explicit' | 'automatic' | 'implicit' | 'none';
+export interface ExplicitCacheCapability {
+    type: 'explicit';
+    maxBreakpoints: number;
+    ttlOptions: Array<{
+        label: string;
+        seconds: number;
+        writeCostMultiplier: number;
+    }>;
+    readDiscount: number;
+    minCacheableTokens: number;
+}
+export interface AutomaticCacheCapability {
+    type: 'automatic';
+    readDiscount: number;
+    sessionAffinityHeader?: string;
+}
+export interface ImplicitCacheCapability {
+    type: 'implicit';
+    keepAliveParam?: string;
+    defaultKeepAliveSeconds?: number;
+}
+export interface NoCacheCapability {
+    type: 'none';
+}
+export type ProviderCacheCapability = ExplicitCacheCapability | AutomaticCacheCapability | ImplicitCacheCapability | NoCacheCapability;
+/**
+ * Get the cache capability for a provider.
+ * Returns 'none' for unknown providers.
+ */
+export declare function getCacheCapability(providerName: string): ProviderCacheCapability;
+/**
+ * Check if a provider supports any form of caching.
+ *
+ * @remarks Intentionally exported for future consumers such as UI display
+ * components and config validation that need a simple boolean check.
+ */
+export declare function supportsCaching(providerName: string): boolean;
+/** Get the best TTL option for stable content (system prompt + tools). */
+export declare function getStableTtl(cap: ProviderCacheCapability): {
+    label: string;
+    seconds: number;
+} | null;
+/** Get the default (shortest) TTL for dynamic content. */
+export declare function getDynamicTtl(cap: ProviderCacheCapability): {
+    label: string;
+    seconds: number;
+} | null;
+//# sourceMappingURL=cache-capability.d.ts.map

package/dist/_internal/platform/providers/cache-capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-capability.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/cache-capability.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,gDAAgD;AAEhD,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAEvE,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnF,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,WAAW,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,uBAAuB,GAC/B,uBAAuB,GACvB,wBAAwB,GACxB,uBAAuB,GACvB,iBAAiB,CAAC;AAiFtB;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,uBAAuB,CAoBhF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,GAAG,EAAE,uBAAuB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAKpG;AAED,0DAA0D;AAC1D,wBAAgB,aAAa,CAAC,GAAG,EAAE,uBAAuB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAIrG"}

package/dist/_internal/platform/providers/cache-capability.js

@@ -0,0 +1,124 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Priority-ordered alias map for provider name substring matching.
+ * More specific patterns must appear before more general ones.
+ * Used as a fallback when no direct match is found in the registry.
+ */
+const PROVIDER_ALIASES = [
+    // OpenRouter uses OpenAI-compatible caching
+    ['openrouter', 'openai'],
+    // anthropic-compat style providers map to anthropic caching
+    ['anthropic-compat', 'anthropic'],
+];
+// Registry of known provider capabilities
+// Map provider name -> capability
+const PROVIDER_CACHE_CAPABILITIES = {
+    anthropic: {
+        type: 'explicit',
+        maxBreakpoints: 4,
+        ttlOptions: [
+            { label: '5m', seconds: 300, writeCostMultiplier: 1.25 },
+            { label: '1h', seconds: 3600, writeCostMultiplier: 2.0 },
+        ],
+        readDiscount: 0.1,
+        minCacheableTokens: 1024,
+    },
+    gemini: {
+        type: 'explicit',
+        maxBreakpoints: 1, // Gemini uses cachedContents objects, effectively 1 cache object at a time
+        ttlOptions: [
+            { label: 'configurable', seconds: 3600, writeCostMultiplier: 1.0 }, // standard + storage/hr
+        ],
+        readDiscount: 0.25, // 75% off
+        minCacheableTokens: 32768,
+    },
+    openai: {
+        type: 'automatic',
+        readDiscount: 0.5,
+    },
+    deepseek: {
+        type: 'automatic',
+        readDiscount: 0.1,
+    },
+    groq: {
+        type: 'automatic',
+        readDiscount: 0.5,
+    },
+    fireworks: {
+        type: 'automatic',
+        readDiscount: 0.5,
+        sessionAffinityHeader: 'x-session-affinity',
+    },
+    together: {
+        type: 'automatic',
+        readDiscount: 0.5,
+    },
+    // Local runtimes
+    ollama: {
+        type: 'implicit',
+        keepAliveParam: 'keep_alive',
+        defaultKeepAliveSeconds: -1, // -1 = keep loaded indefinitely
+    },
+    lmstudio: {
+        type: 'implicit',
+    },
+    vllm: {
+        type: 'implicit', // Automatic prefix caching in GPU memory
+    },
+    'llama.cpp': {
+        type: 'implicit',
+    },
+    sglang: {
+        type: 'implicit', // RadixAttention — best automatic local caching
+    },
+    // No caching
+    mistral: {
+        type: 'none',
+    },
+};
+/**
+ * Get the cache capability for a provider.
+ * Returns 'none' for unknown providers.
+ */
+export function getCacheCapability(providerName) {
+    // Normalize provider name (lowercase, strip trailing whitespace)
+    const normalized = providerName.toLowerCase().trim();
+    // Check direct match
+    const normalizedKey = normalized;
+    if (PROVIDER_CACHE_CAPABILITIES[normalizedKey]) {
+        return PROVIDER_CACHE_CAPABILITIES[normalizedKey];
+    }
+    // Known aliases (priority-ordered: more specific patterns first)
+    for (const [alias, target] of PROVIDER_ALIASES) {
+        const aliasTarget = target;
+        if (normalized.includes(alias) && PROVIDER_CACHE_CAPABILITIES[aliasTarget]) {
+            return PROVIDER_CACHE_CAPABILITIES[aliasTarget];
+        }
+    }
+    // Unknown provider — no caching
+    return { type: 'none' };
+}
+/**
+ * Check if a provider supports any form of caching.
+ *
+ * @remarks Intentionally exported for future consumers such as UI display
+ * components and config validation that need a simple boolean check.
+ */
+export function supportsCaching(providerName) {
+    return getCacheCapability(providerName).type !== 'none';
+}
+/** Get the best TTL option for stable content (system prompt + tools). */
+export function getStableTtl(cap) {
+    if (cap.type !== 'explicit')
+        return null;
+    // Prefer the longest TTL for stable content
+    const sorted = [...cap.ttlOptions].sort((a, b) => b.seconds - a.seconds);
+    return sorted[0] ? { label: sorted[0].label, seconds: sorted[0].seconds } : null;
+}
+/** Get the default (shortest) TTL for dynamic content. */
+export function getDynamicTtl(cap) {
+    if (cap.type !== 'explicit')
+        return null;
+    const sorted = [...cap.ttlOptions].sort((a, b) => a.seconds - b.seconds);
+    return sorted[0] ? { label: sorted[0].label, seconds: sorted[0].seconds } : null;
+}

package/dist/_internal/platform/providers/cache-strategy.d.ts

@@ -0,0 +1,76 @@
+/** Position where a cache breakpoint should be placed. */
+export type BreakpointPosition = 'system_and_tools' | 'conversation_prefix' | 'last_tool_result' | 'dynamic';
+/** A single cache breakpoint instruction. */
+export interface CacheBreakpoint {
+    position: BreakpointPosition;
+    ttl: string;
+    ttlSeconds: number;
+    reason: string;
+}
+/** Complete cache strategy for a provider request. */
+export interface CacheStrategy {
+    /** Breakpoints to place (for explicit providers only). Ordered by position in content. */
+    breakpoints: CacheBreakpoint[];
+    /** Whether prefix stability should be enforced (universal — true for all caching providers). */
+    prefixStable: boolean;
+    /** Session affinity header to send (for providers like Fireworks). */
+    sessionAffinityHeader?: string;
+    /** Keep-alive duration hint for local runtimes (seconds, -1 = indefinite). */
+    keepAliveSeconds?: number;
+    /** Re-evaluate strategy after this many turns. */
+    refreshAfterTurns: number;
+}
+/** Context needed to generate a cache strategy. */
+export interface CacheContext {
+    providerName: string;
+    systemPromptTokens: number;
+    toolCount: number;
+    toolTokens: number;
+    conversationTurns: number;
+    conversationTokens: number;
+    /** Recent cache hit rate (0-1). Undefined if not yet tracked. */
+    recentCacheHitRate?: number;
+    /** Whether the user has configured a custom TTL preference. Accepts any TTL label string to accommodate future provider options. */
+    configuredTtl?: string;
+}
+/** Cache hit rate tracking. */
+export interface CacheHitMetrics {
+    totalInputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    /** Computed hit rate: cacheReadTokens / (totalInputTokens + cacheReadTokens) */
+    hitRate: number;
+    /** Number of turns tracked. */
+    turns: number;
+}
+/**
+ * Generate the default cache strategy for a provider based on its capabilities.
+ */
+export declare function getDefaultStrategy(context: CacheContext): CacheStrategy;
+/**
+ * CacheHitTracker — tracks cache hit rate over a sliding window of turns.
+ */
+export declare class CacheHitTracker {
+    private metrics;
+    /**
+     * Record usage from a single turn.
+     *
+     * @param usage.inputTokens - Non-cached input tokens for this turn (tokens NOT served from
+     *   cache). On Anthropic, this corresponds to `usage.input_tokens` (exclusive of cached
+     *   tokens). Do NOT include cache_read_input_tokens or cache_creation_input_tokens here.
+     * @param usage.cacheReadTokens - Tokens served from cache (cache hits).
+     * @param usage.cacheWriteTokens - Tokens written to cache this turn (cache creation).
+     */
+    recordTurn(usage: {
+        inputTokens: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+    }): void;
+    /** Get current metrics. */
+    getMetrics(): Readonly<CacheHitMetrics>;
+    /** Get current hit rate (0-1). */
+    getHitRate(): number;
+    /** Reset metrics (e.g., after strategy refresh). */
+    reset(): void;
+}
+//# sourceMappingURL=cache-strategy.d.ts.map

package/dist/_internal/platform/providers/cache-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-strategy.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/cache-strategy.ts"],"names":[],"mappings":"AAOA,0DAA0D;AAC1D,MAAM,MAAM,kBAAkB,GAC1B,kBAAkB,GAClB,qBAAqB,GACrB,kBAAkB,GAClB,SAAS,CAAC;AAEd,6CAA6C;AAC7C,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,sDAAsD;AACtD,MAAM,WAAW,aAAa;IAC5B,0FAA0F;IAC1F,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,gGAAgG;IAChG,YAAY,EAAE,OAAO,CAAC;IACtB,sEAAsE;IACtE,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,mDAAmD;AACnD,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oIAAoI;IACpI,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,+BAA+B;AAC/B,MAAM,WAAW,eAAe;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gFAAgF;IAChF,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAavE;AAuHD;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAMb;IAEF;;;;;;;;OAQG;IACH,UAAU,CAAC,KAAK,EAAE;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,GAAG,IAAI;IAgBR,2BAA2B;IAC3B,UAAU,IAAI,QAAQ,CAAC,eAAe,CAAC;IAIvC,kCAAkC;IAClC,UAAU,IAAI,MAAM;IAIpB,oDAAoD;IACpD,KAAK,IAAI,IAAI;CASd"}

package/dist/_internal/platform/providers/cache-strategy.js

@@ -0,0 +1,160 @@
+import { getCacheCapability, getStableTtl, getDynamicTtl } from './cache-capability.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Generate the default cache strategy for a provider based on its capabilities.
+ */
+export function getDefaultStrategy(context) {
+    const cap = getCacheCapability(context.providerName);
+    switch (cap.type) {
+        case 'explicit':
+            return buildExplicitStrategy(cap, context);
+        case 'automatic':
+            return buildAutomaticStrategy(cap, context);
+        case 'implicit':
+            return buildImplicitStrategy(cap, context);
+        case 'none':
+            return buildNoopStrategy();
+    }
+}
+/** Build strategy for explicit caching providers (Anthropic, Gemini). */
+function buildExplicitStrategy(cap, context) {
+    const breakpoints = [];
+    const stableTtl = getStableTtl(cap);
+    const dynamicTtl = getDynamicTtl(cap);
+    if (!stableTtl || !dynamicTtl) {
+        logger.warn('[CacheStrategy] No TTL options for explicit provider', { provider: context.providerName });
+        return buildNoopStrategy();
+    }
+    // Determine TTL for stable content (system + tools)
+    // Use configured TTL if set, otherwise use longest available for stable content
+    const stableTtlLabel = context.configuredTtl ?? stableTtl.label;
+    const stableTtlSeconds = context.configuredTtl === '5m' ? 300 :
+        context.configuredTtl === '1h' ? 3600 : stableTtl.seconds;
+    const totalStableTokens = context.systemPromptTokens + context.toolTokens;
+    // BP1: System prompt + tools (if above minimum)
+    if (totalStableTokens >= cap.minCacheableTokens) {
+        breakpoints.push({
+            position: 'system_and_tools',
+            ttl: stableTtlLabel,
+            ttlSeconds: stableTtlSeconds,
+            reason: `Cache stable prefix (${totalStableTokens} tokens, ${context.toolCount} tools)`,
+        });
+    }
+    // BP2: Conversation history prefix (if there's meaningful history)
+    // Only add if we have room for another breakpoint and conversation is substantial
+    if (breakpoints.length < cap.maxBreakpoints &&
+        context.conversationTurns >= 2 &&
+        context.conversationTokens >= cap.minCacheableTokens) {
+        breakpoints.push({
+            position: 'conversation_prefix',
+            ttl: dynamicTtl.label,
+            ttlSeconds: dynamicTtl.seconds,
+            reason: `Cache conversation prefix (${context.conversationTurns} turns, ~${context.conversationTokens} tokens)`,
+        });
+    }
+    // BP3: Last large tool result (if room and conversation has tool results)
+    // This is a heuristic — the actual placement happens at request time
+    if (breakpoints.length < cap.maxBreakpoints &&
+        context.conversationTurns >= 3) {
+        breakpoints.push({
+            position: 'last_tool_result',
+            ttl: dynamicTtl.label,
+            ttlSeconds: dynamicTtl.seconds,
+            reason: 'Cache last large tool result',
+        });
+    }
+    // BP4: Dynamic slot (reserved, only used if cache hit rate is poor)
+    if (breakpoints.length < cap.maxBreakpoints &&
+        context.recentCacheHitRate !== undefined &&
+        context.recentCacheHitRate < 0.3) {
+        breakpoints.push({
+            position: 'dynamic',
+            ttl: dynamicTtl.label,
+            ttlSeconds: dynamicTtl.seconds,
+            reason: `Dynamic breakpoint (hit rate: ${(context.recentCacheHitRate * 100).toFixed(0)}%)`,
+        });
+    }
+    return {
+        breakpoints,
+        prefixStable: true,
+        refreshAfterTurns: 10,
+    };
+}
+/** Build strategy for automatic caching providers (OpenAI, DeepSeek, Groq, etc.). */
+function buildAutomaticStrategy(cap, _context) {
+    return {
+        breakpoints: [], // No explicit breakpoints — provider handles it
+        prefixStable: true, // Critical: prefix stability maximizes automatic cache hits
+        sessionAffinityHeader: cap.sessionAffinityHeader,
+        refreshAfterTurns: 0, // No need to refresh — nothing to configure
+    };
+}
+/** Build strategy for implicit caching (local runtimes). */
+function buildImplicitStrategy(cap, _context) {
+    return {
+        breakpoints: [],
+        prefixStable: true, // KV cache reuse depends on prefix stability
+        keepAliveSeconds: cap.defaultKeepAliveSeconds,
+        refreshAfterTurns: 0,
+    };
+}
+/** Build a no-op strategy for providers without caching. */
+function buildNoopStrategy() {
+    return {
+        breakpoints: [],
+        prefixStable: false,
+        refreshAfterTurns: 0,
+    };
+}
+/**
+ * CacheHitTracker — tracks cache hit rate over a sliding window of turns.
+ */
+export class CacheHitTracker {
+    metrics = {
+        totalInputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        hitRate: 0,
+        turns: 0,
+    };
+    /**
+     * Record usage from a single turn.
+     *
+     * @param usage.inputTokens - Non-cached input tokens for this turn (tokens NOT served from
+     *   cache). On Anthropic, this corresponds to `usage.input_tokens` (exclusive of cached
+     *   tokens). Do NOT include cache_read_input_tokens or cache_creation_input_tokens here.
+     * @param usage.cacheReadTokens - Tokens served from cache (cache hits).
+     * @param usage.cacheWriteTokens - Tokens written to cache this turn (cache creation).
+     */
+    recordTurn(usage) {
+        this.metrics.totalInputTokens += usage.inputTokens;
+        this.metrics.cacheReadTokens += usage.cacheReadTokens ?? 0;
+        this.metrics.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
+        this.metrics.turns += 1;
+        // Hit rate: cacheReadTokens / (totalInputTokens + cacheReadTokens)
+        // Exclude cacheWriteTokens: writes are a one-time creation cost, not processed input.
+        const totalProcessed = this.metrics.totalInputTokens
+            + this.metrics.cacheReadTokens;
+        this.metrics.hitRate = totalProcessed > 0
+            ? this.metrics.cacheReadTokens / totalProcessed
+            : 0;
+    }
+    /** Get current metrics. */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    /** Get current hit rate (0-1). */
+    getHitRate() {
+        return this.metrics.hitRate;
+    }
+    /** Reset metrics (e.g., after strategy refresh). */
+    reset() {
+        this.metrics = {
+            totalInputTokens: 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+            hitRate: 0,
+            turns: 0,
+        };
+    }
+}

package/dist/_internal/platform/providers/context-discovery.d.ts

@@ -0,0 +1,99 @@
+/**
+ * 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`
+ */
+/** Placeholder model ID used when a server-level endpoint has no model list. */
+export declare const SERVER_LEVEL_MODEL_ID = "__server__";
+/**
+ * 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`
+ */
+declare function extractOrigin(baseURL: string): string;
+/**
+ * Probe `/api/v1/models` (LM Studio rich format).
+ * Returns model_id → context_length map, or null if the endpoint is absent.
+ */
+declare function probeLMStudio(origin: string, apiKey?: string): Promise<Map<string, number> | null>;
+interface OllamaShowResponse {
+    model_info?: Record<string, unknown>;
+    modelfile?: string;
+    [k: string]: unknown;
+}
+/**
+ * Extract context length from an Ollama `/api/show` response.
+ * Tries `model_info.context_length`, then parses `num_ctx` from modelfile.
+ */
+declare function extractOllamaContextLength(show: OllamaShowResponse): number | 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.
+ */
+declare function probeOllama(origin: string, apiKey?: string): Promise<Map<string, number> | null>;
+interface OpenAICompatModel {
+    id: string;
+    /** vLLM exposes this */
+    max_model_len?: number;
+    max_context_length?: number;
+    context_length?: number;
+    limits?: {
+        max_context_length?: number;
+        context_length?: number;
+    };
+    [k: string]: unknown;
+}
+declare function extractOpenAIContextLength(model: OpenAICompatModel): number | 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.
+ */
+declare function probeOpenAICompat(baseURL: string, apiKey?: string): Promise<Map<string, number> | null>;
+/**
+ * Probe `/props` (llama.cpp server-level context).
+ * Returns a single-entry map keyed by SERVER_LEVEL_MODEL_ID, or null.
+ */
+declare function probeLlamaCpp(origin: string, apiKey?: string): Promise<Map<string, number> | null>;
+/**
+ * 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.
+ */
+declare function probeTGI(origin: string, apiKey?: string): Promise<Map<string, number> | null>;
+/**
+ * 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 declare function discoverContextWindows(baseURL: string, apiKey?: string): Promise<Map<string, number>>;
+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, };
+//# sourceMappingURL=context-discovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context-discovery.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/context-discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAYH,gFAAgF;AAChF,eAAO,MAAM,qBAAqB,eAAe,CAAC;AAMlD;;;GAGG;AACH,iBAAS,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAqED;;;GAGG;AACH,iBAAe,aAAa,CAC1B,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CAqBrC;AAeD,UAAU,kBAAkB;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;AAED;;;GAGG;AACH,iBAAS,0BAA0B,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,GAAG,IAAI,CAuB3E;AAED;;;GAGG;AACH,iBAAe,WAAW,CACxB,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CAiDrC;AAMD,UAAU,iBAAiB;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,wBAAwB;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE;QACP,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;AAMD,iBAAS,0BAA0B,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,GAAG,IAAI,CAa3E;AAED;;;;GAIG;AACH,iBAAe,iBAAiB,CAC9B,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CAoBrC;AAWD;;;GAGG;AACH,iBAAe,aAAa,CAC1B,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CAUrC;AAYD;;;;GAIG;AACH,iBAAe,QAAQ,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CAoBrC;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA0C9B;AAMD,OAAO,EACL,aAAa,IAAI,cAAc,EAC/B,WAAW,IAAI,YAAY,EAC3B,iBAAiB,IAAI,kBAAkB,EACvC,aAAa,IAAI,cAAc,EAC/B,QAAQ,IAAI,SAAS,EACrB,aAAa,IAAI,cAAc,EAC/B,0BAA0B,IAAI,2BAA2B,EACzD,0BAA0B,IAAI,2BAA2B,GAC1D,CAAC"}