@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/providers/custom-loader.js

@@ -0,0 +1,300 @@
+import * as fs from 'fs';
+import * as fsPromises from 'fs/promises';
+import * as path from 'path';
+import { emitProviderWarning } from '../runtime/emitters/index.js';
+import { OpenAICompatProvider } from './openai-compat.js';
+import { AnthropicCompatProvider } from './anthropic-compat.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { LocalContextIngestionService, resolveContextWindow, } from '@pellux/goodvibes-sdk/platform/providers/local-context-ingestion';
+/** Debounce delay for file watcher (ms). */
+const WATCH_DEBOUNCE_MS = 300;
+/**
+ * Resolve API key from config.
+ * Priority: explicit apiKey > env var (apiKeyEnv) > empty string.
+ */
+function resolveApiKey(config) {
+    if (config.apiKey)
+        return config.apiKey;
+    if (config.apiKeyEnv) {
+        const val = process.env[config.apiKeyEnv];
+        if (val)
+            return val;
+    }
+    return '';
+}
+/**
+ * Validate a single parsed JSON object against the CustomProviderConfig schema.
+ * Returns { valid, errors } — errors is empty when valid.
+ */
+function validateCustomProvider(data) {
+    const errors = [];
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        return { valid: false, errors: ['Root value must be a JSON object'] };
+    }
+    const obj = data;
+    if (typeof obj['name'] !== 'string' || obj['name'].trim() === '') {
+        errors.push('"name" must be a non-empty string');
+    }
+    if (typeof obj['displayName'] !== 'string' || obj['displayName'].trim() === '') {
+        errors.push('"displayName" must be a non-empty string');
+    }
+    if (obj['type'] !== 'openai-compat' && obj['type'] !== 'anthropic-compat') {
+        errors.push('"type" must be "openai-compat" or "anthropic-compat"');
+    }
+    if (typeof obj['baseURL'] !== 'string' || obj['baseURL'].trim() === '') {
+        errors.push('"baseURL" must be a non-empty string');
+    }
+    if (obj['reasoningFormat'] !== undefined) {
+        if (!['mercury', 'openrouter', 'llamacpp', 'none'].includes(obj['reasoningFormat'])) {
+            errors.push('"reasoningFormat" must be "mercury", "openrouter", "llamacpp", or "none"');
+        }
+    }
+    if (!Array.isArray(obj['models']) || obj['models'].length === 0) {
+        errors.push('"models" must be a non-empty array');
+    }
+    else {
+        const models = obj['models'];
+        models.forEach((m, i) => {
+            if (typeof m !== 'object' || m === null || Array.isArray(m)) {
+                errors.push(`models[${i}]: must be an object`);
+                return;
+            }
+            const model = m;
+            if (typeof model['id'] !== 'string' || model['id'].trim() === '') {
+                errors.push(`models[${i}]: "id" must be a non-empty string`);
+            }
+            if (typeof model['displayName'] !== 'string' || model['displayName'].trim() === '') {
+                errors.push(`models[${i}]: "displayName" must be a non-empty string`);
+            }
+            if (typeof model['contextWindow'] !== 'number' || model['contextWindow'] <= 0) {
+                errors.push(`models[${i}]: "contextWindow" must be a positive number`);
+            }
+            if (typeof model['capabilities'] !== 'object' || model['capabilities'] === null) {
+                errors.push(`models[${i}]: "capabilities" must be an object`);
+            }
+            else {
+                const caps = model['capabilities'];
+                for (const cap of ['toolCalling', 'codeEditing', 'reasoning', 'multimodal']) {
+                    if (typeof caps[cap] !== 'boolean') {
+                        errors.push(`models[${i}]: capabilities.${cap} must be a boolean`);
+                    }
+                }
+            }
+        });
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Ensure the providers directory exists, creating it if necessary.
+ */
+async function ensureProvidersDir(providersDir) {
+    try {
+        await fsPromises.mkdir(providersDir, { recursive: true });
+    }
+    catch (err) {
+        throw new Error(`[custom-loader] Failed to create providers directory '${providersDir}': ${summarizeError(err)}`);
+    }
+}
+/**
+ * Load all custom providers from an owned providers directory.
+ * Auto-creates the directory if it does not exist.
+ * Invalid files are skipped with a warning rather than failing the whole load.
+ *
+ * When `options.ingestContextWindows` is true, each provider's /v1/models
+ * endpoint is queried concurrently (via Promise.allSettled) to resolve
+ * `max_context_length` with `provider_api` provenance.
+ */
+export async function loadCustomProviders(options) {
+    const warnings = [];
+    const providers = [];
+    const models = [];
+    const { providersDir } = options;
+    await ensureProvidersDir(providersDir);
+    let entries;
+    try {
+        const dirents = await fsPromises.readdir(providersDir, { withFileTypes: true });
+        entries = dirents
+            .filter((d) => d.isFile() && d.name.endsWith('.json'))
+            .map((d) => d.name);
+    }
+    catch (err) {
+        warnings.push(`[custom-loader] Could not read providers directory: ${summarizeError(err)}`);
+        return { providers, models, warnings };
+    }
+    // Phase 1: Parse and validate all provider files, instantiate provider objects.
+    // Collect valid entries; skip invalid ones with warnings.
+    const validConfigs = [];
+    for (const filename of entries) {
+        const filepath = path.join(providersDir, filename);
+        let raw;
+        try {
+            raw = await fsPromises.readFile(filepath, 'utf-8');
+        }
+        catch (err) {
+            warnings.push(`[custom-loader] Could not read '${filename}': ${summarizeError(err)}`);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            warnings.push(`[custom-loader] Invalid JSON in '${filename}': ${summarizeError(err)}`);
+            continue;
+        }
+        const { valid, errors } = validateCustomProvider(parsed);
+        if (!valid) {
+            warnings.push(`[custom-loader] Skipping '${filename}' — validation errors:\n  ${errors.join('\n  ')}`);
+            continue;
+        }
+        const cfg = parsed;
+        const apiKey = resolveApiKey(cfg);
+        const modelIds = cfg.models.map((m) => m.id);
+        let provider;
+        try {
+            if (cfg.type === 'anthropic-compat') {
+                provider = new AnthropicCompatProvider({
+                    name: cfg.name,
+                    baseURL: cfg.baseURL,
+                    apiKey,
+                    defaultModel: modelIds[0],
+                    models: modelIds,
+                    ...(cfg.defaultHeaders ? { defaultHeaders: cfg.defaultHeaders } : {}),
+                });
+            }
+            else {
+                provider = new OpenAICompatProvider({
+                    name: cfg.name,
+                    baseURL: cfg.baseURL,
+                    apiKey,
+                    defaultModel: modelIds[0],
+                    models: modelIds,
+                    ...(cfg.defaultHeaders ? { defaultHeaders: cfg.defaultHeaders } : {}),
+                    reasoningFormat: cfg.reasoningFormat ?? 'none',
+                });
+            }
+        }
+        catch (err) {
+            warnings.push(`[custom-loader] Failed to instantiate provider from '${filename}': ${summarizeError(err)}`);
+            continue;
+        }
+        validConfigs.push({ cfg, provider, apiKey });
+    }
+    // Phase 2: Ingest context windows concurrently for all valid providers.
+    // Runs only when options.ingestContextWindows is true.
+    const ingestionResults = validConfigs.map(() => null);
+    if (options.ingestContextWindows && options.contextIngestion && validConfigs.length > 0) {
+        const ingestionPromises = validConfigs.map(({ cfg, apiKey }) => options.contextIngestion?.ingestProviderContextWindows(cfg.name, cfg.baseURL, apiKey || undefined));
+        const settled = await Promise.allSettled(ingestionPromises);
+        for (let i = 0; i < settled.length; i++) {
+            const result = settled[i];
+            if (result) {
+                ingestionResults[i] = result.status === 'fulfilled' ? (result.value ?? null) : null;
+            }
+        }
+    }
+    // Phase 3: Build model definitions and populate output arrays.
+    for (let i = 0; i < validConfigs.length; i++) {
+        const { cfg, provider } = validConfigs[i];
+        const apiContextMap = ingestionResults[i] ?? null;
+        const modelDefs = cfg.models.map((m) => {
+            const apiContextLength = apiContextMap?.get(m.id) ?? null;
+            const resolved = resolveContextWindow(m.id, apiContextLength, m.contextWindow);
+            return {
+                id: m.id,
+                provider: cfg.name,
+                registryKey: `${cfg.name}:${m.id}`,
+                displayName: m.displayName,
+                description: m.description ?? '',
+                contextWindow: resolved.tokens,
+                contextWindowProvenance: resolved.provenance,
+                selectable: m.selectable ?? true,
+                capabilities: {
+                    toolCalling: m.capabilities.toolCalling,
+                    codeEditing: m.capabilities.codeEditing,
+                    reasoning: m.capabilities.reasoning,
+                    multimodal: m.capabilities.multimodal,
+                },
+                ...(m.reasoningEffort ? { reasoningEffort: m.reasoningEffort } : {}),
+                ...(m.tier ? { tier: m.tier } : {}),
+            };
+        });
+        providers.push({ config: cfg, provider });
+        models.push(...modelDefs);
+    }
+    return { providers, models, warnings };
+}
+/**
+ * Start watching an owned providers directory for file changes.
+ * Debounces rapid events by 300ms before invoking the onChange callback.
+ * Emits typed provider warnings if the watcher cannot be started.
+ * Returns a handle with a `close()` method to stop watching.
+ */
+export function watchCustomProviders(runtimeBus, onChange, providersDir) {
+    let debounceTimer = null;
+    let watcher = null;
+    let closed = false;
+    const emitWarning = (message) => {
+        if (runtimeBus) {
+            emitProviderWarning(runtimeBus, {
+                sessionId: 'system',
+                traceId: `providers:warning:${Date.now()}`,
+                source: 'custom-provider-loader',
+            }, { message });
+        }
+    };
+    const startWatch = () => {
+        if (closed)
+            return;
+        try {
+            // Note: fs.watch() may miss atomic renames (e.g. editor save-via-rename) on
+            // some Linux filesystems. If that becomes a problem, consider replacing this
+            // with the 'chokidar' library which uses inotify directly.
+            watcher = fs.watch(providersDir, { persistent: false }, // Don't keep the Node process alive just for this watcher
+            (_eventType, _filename) => {
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(() => {
+                    debounceTimer = null;
+                    onChange();
+                }, WATCH_DEBOUNCE_MS);
+            });
+            watcher.on('error', (err) => {
+                if (closed)
+                    return;
+                emitWarning(`[custom-loader] Watcher error: ${err.message}`);
+            });
+        }
+        catch (err) {
+            if (closed)
+                return;
+            emitWarning(`[custom-loader] Could not watch providers directory: ${summarizeError(err)}`);
+        }
+    };
+    // Ensure the directory exists before starting the watcher
+    fsPromises
+        .mkdir(providersDir, { recursive: true })
+        .then(() => {
+        if (closed)
+            return;
+        startWatch();
+    })
+        .catch((err) => {
+        if (closed)
+            return;
+        emitWarning(`[custom-loader] Could not create/watch providers directory: ${summarizeError(err)}`);
+    });
+    return {
+        close() {
+            closed = true;
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+                debounceTimer = null;
+            }
+            if (watcher) {
+                watcher.close();
+                watcher = null;
+            }
+        },
+    };
+}

package/dist/_internal/platform/providers/discovered-compat.d.ts

@@ -0,0 +1,17 @@
+import type { OpenAICompatOptions } from './openai-compat.js';
+import { OpenAICompatProvider } from './openai-compat.js';
+export interface DiscoveredCompatOptions extends OpenAICompatOptions {
+}
+declare class DiscoveredCompatProvider extends OpenAICompatProvider {
+    constructor(opts: DiscoveredCompatOptions);
+}
+export declare class VLLMProvider extends DiscoveredCompatProvider {
+}
+export declare class LlamaCppProvider extends DiscoveredCompatProvider {
+}
+export declare class TGIProvider extends DiscoveredCompatProvider {
+}
+export declare class LocalAIProvider extends DiscoveredCompatProvider {
+}
+export {};
+//# sourceMappingURL=discovered-compat.d.ts.map

package/dist/_internal/platform/providers/discovered-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovered-compat.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/discovered-compat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D,MAAM,WAAW,uBAAwB,SAAQ,mBAAmB;CAAG;AAEvE,cAAM,wBAAyB,SAAQ,oBAAoB;gBAC7C,IAAI,EAAE,uBAAuB;CAG1C;AAED,qBAAa,YAAa,SAAQ,wBAAwB;CAAG;AAE7D,qBAAa,gBAAiB,SAAQ,wBAAwB;CAAG;AAEjE,qBAAa,WAAY,SAAQ,wBAAwB;CAAG;AAE5D,qBAAa,eAAgB,SAAQ,wBAAwB;CAAG"}

package/dist/_internal/platform/providers/discovered-compat.js

@@ -0,0 +1,14 @@
+import { OpenAICompatProvider } from './openai-compat.js';
+class DiscoveredCompatProvider extends OpenAICompatProvider {
+    constructor(opts) {
+        super(opts);
+    }
+}
+export class VLLMProvider extends DiscoveredCompatProvider {
+}
+export class LlamaCppProvider extends DiscoveredCompatProvider {
+}
+export class TGIProvider extends DiscoveredCompatProvider {
+}
+export class LocalAIProvider extends DiscoveredCompatProvider {
+}

package/dist/_internal/platform/providers/discovered-factory.d.ts

@@ -0,0 +1,5 @@
+import type { DiscoveredServer } from '@pellux/goodvibes-sdk/platform/discovery/scanner';
+import type { LLMProvider } from './interface.js';
+export declare function createDiscoveredProvider(server: DiscoveredServer): LLMProvider;
+export declare function getDiscoveredReasoningFormat(serverType: DiscoveredServer['serverType']): 'llamacpp' | 'none';
+//# sourceMappingURL=discovered-factory.d.ts.map

package/dist/_internal/platform/providers/discovered-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovered-factory.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/discovered-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AACzF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAQlD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,GAAG,WAAW,CA6C9E;AAED,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,gBAAgB,CAAC,YAAY,CAAC,GACzC,UAAU,GAAG,MAAM,CAErB"}

package/dist/_internal/platform/providers/discovered-factory.js

@@ -0,0 +1,54 @@
+import { getDiscoveredTraits } from './discovered-traits.js';
+import { LocalAIProvider, TGIProvider, VLLMProvider } from './discovered-compat.js';
+import { LlamaCppProvider } from './llama-cpp.js';
+import { LMStudioProvider } from './lm-studio.js';
+import { OpenAICompatProvider } from './openai-compat.js';
+import { OllamaProvider } from './ollama.js';
+export function createDiscoveredProvider(server) {
+    const traits = getDiscoveredTraits(server.serverType);
+    const common = {
+        name: server.name,
+        baseURL: server.baseURL,
+        apiKey: '',
+        defaultModel: server.models[0],
+        models: server.models,
+        capabilities: traits.providerCapabilities,
+    };
+    switch (traits.adapter) {
+        case 'lm-studio':
+            return new LMStudioProvider(common);
+        case 'ollama':
+            return new OllamaProvider({
+                ...common,
+                reasoningFormat: traits.reasoningFormat,
+            });
+        case 'vllm':
+            return new VLLMProvider({
+                ...common,
+                reasoningFormat: traits.reasoningFormat,
+            });
+        case 'llamacpp':
+            return new LlamaCppProvider({
+                ...common,
+                reasoningFormat: traits.reasoningFormat,
+            });
+        case 'tgi':
+            return new TGIProvider({
+                ...common,
+                reasoningFormat: traits.reasoningFormat,
+            });
+        case 'localai':
+            return new LocalAIProvider({
+                ...common,
+                reasoningFormat: traits.reasoningFormat,
+            });
+        default:
+            return new OpenAICompatProvider({
+                ...common,
+                reasoningFormat: traits.reasoningFormat,
+            });
+    }
+}
+export function getDiscoveredReasoningFormat(serverType) {
+    return getDiscoveredTraits(serverType).reasoningFormat;
+}

package/dist/_internal/platform/providers/discovered-traits.d.ts

@@ -0,0 +1,16 @@
+import type { ServerType } from '@pellux/goodvibes-sdk/platform/discovery/scanner';
+import type { ProviderCapability } from './capabilities.js';
+export interface DiscoveredServerTraits {
+    readonly adapter: 'lm-studio' | 'ollama' | 'vllm' | 'llamacpp' | 'tgi' | 'localai' | 'compat';
+    readonly reasoningFormat: 'llamacpp' | 'none';
+    readonly providerCapabilities?: Partial<ProviderCapability>;
+    readonly modelCapabilities: {
+        toolCalling: boolean;
+        codeEditing: boolean;
+        reasoning: boolean;
+        multimodal: boolean;
+    };
+    readonly reasoningEffort?: string[];
+}
+export declare function getDiscoveredTraits(serverType: ServerType): DiscoveredServerTraits;
+//# sourceMappingURL=discovered-traits.d.ts.map

package/dist/_internal/platform/providers/discovered-traits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovered-traits.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/discovered-traits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kDAAkD,CAAC;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EACZ,WAAW,GACX,QAAQ,GACR,MAAM,GACN,UAAU,GACV,KAAK,GACL,SAAS,GACT,QAAQ,CAAC;IACb,QAAQ,CAAC,eAAe,EAAE,UAAU,GAAG,MAAM,CAAC;IAC9C,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC5D,QAAQ,CAAC,iBAAiB,EAAE;QAC1B,WAAW,EAAE,OAAO,CAAC;QACrB,WAAW,EAAE,OAAO,CAAC;QACrB,SAAS,EAAE,OAAO,CAAC;QACnB,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;IACF,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CACrC;AAWD,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,sBAAsB,CAyGlF"}

package/dist/_internal/platform/providers/discovered-traits.js

@@ -0,0 +1,113 @@
+const DEFAULT_MODEL_CAPABILITIES = {
+    toolCalling: true,
+    codeEditing: true,
+    reasoning: false,
+    multimodal: false,
+};
+const HIGH_TIMEOUT_MS = 300_000;
+export function getDiscoveredTraits(serverType) {
+    switch (serverType) {
+        case 'lm-studio':
+            return {
+                adapter: 'lm-studio',
+                reasoningFormat: 'none',
+                providerCapabilities: {
+                    streaming: true,
+                    toolCalling: true,
+                    parallelTools: true,
+                    jsonMode: false,
+                    reasoningControls: true,
+                    timeoutMs: HIGH_TIMEOUT_MS,
+                },
+                modelCapabilities: {
+                    ...DEFAULT_MODEL_CAPABILITIES,
+                    reasoning: true,
+                },
+                reasoningEffort: ['instant', 'low', 'medium', 'high'],
+            };
+        case 'ollama':
+            return {
+                adapter: 'ollama',
+                reasoningFormat: 'llamacpp',
+                providerCapabilities: {
+                    streaming: true,
+                    toolCalling: true,
+                    parallelTools: false,
+                    jsonMode: true,
+                    reasoningControls: true,
+                    timeoutMs: HIGH_TIMEOUT_MS,
+                },
+                modelCapabilities: {
+                    ...DEFAULT_MODEL_CAPABILITIES,
+                    reasoning: true,
+                },
+                reasoningEffort: ['instant', 'low', 'medium', 'high'],
+            };
+        case 'vllm':
+            return {
+                adapter: 'vllm',
+                reasoningFormat: 'none',
+                providerCapabilities: {
+                    streaming: true,
+                    toolCalling: true,
+                    parallelTools: false,
+                    jsonMode: true,
+                    reasoningControls: false,
+                    timeoutMs: HIGH_TIMEOUT_MS,
+                },
+                modelCapabilities: DEFAULT_MODEL_CAPABILITIES,
+            };
+        case 'llamacpp':
+            return {
+                adapter: 'llamacpp',
+                reasoningFormat: 'llamacpp',
+                providerCapabilities: {
+                    streaming: true,
+                    toolCalling: true,
+                    parallelTools: false,
+                    jsonMode: true,
+                    reasoningControls: true,
+                    timeoutMs: HIGH_TIMEOUT_MS,
+                },
+                modelCapabilities: {
+                    ...DEFAULT_MODEL_CAPABILITIES,
+                    reasoning: true,
+                },
+                reasoningEffort: ['instant', 'low', 'medium', 'high'],
+            };
+        case 'tgi':
+            return {
+                adapter: 'tgi',
+                reasoningFormat: 'none',
+                providerCapabilities: {
+                    streaming: true,
+                    toolCalling: true,
+                    parallelTools: false,
+                    jsonMode: true,
+                    reasoningControls: false,
+                    timeoutMs: HIGH_TIMEOUT_MS,
+                },
+                modelCapabilities: DEFAULT_MODEL_CAPABILITIES,
+            };
+        case 'localai':
+            return {
+                adapter: 'localai',
+                reasoningFormat: 'none',
+                providerCapabilities: {
+                    streaming: true,
+                    toolCalling: true,
+                    parallelTools: false,
+                    jsonMode: true,
+                    reasoningControls: false,
+                    timeoutMs: HIGH_TIMEOUT_MS,
+                },
+                modelCapabilities: DEFAULT_MODEL_CAPABILITIES,
+            };
+        default:
+            return {
+                adapter: 'compat',
+                reasoningFormat: 'none',
+                modelCapabilities: DEFAULT_MODEL_CAPABILITIES,
+            };
+    }
+}

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

@@ -0,0 +1,32 @@
+import type { LLMProvider, ChatRequest, ChatResponse, ProviderEmbeddingRequest, ProviderEmbeddingResult, ProviderRuntimeMetadata, ProviderRuntimeMetadataDeps } from './interface.js';
+import type { CacheHitTracker } from '@pellux/goodvibes-sdk/platform/providers/cache-strategy';
+/**
+ * GeminiProvider — calls the Gemini generateContent API directly via fetch.
+ * Tools are `functionDeclarations` inside a `tools` array.
+ * Tool calls come as `functionCall` parts; results as `functionResponse` parts.
+ * Uses streamGenerateContent for real-time token delivery when onDelta is provided.
+ */
+export declare class GeminiProvider implements LLMProvider {
+    readonly name = "gemini";
+    /** Maps function call name → thoughtSignature for the current turn. */
+    private thoughtSignatures;
+    readonly models: string[];
+    private readonly apiKey;
+    private readonly embeddingModel;
+    private readonly cacheHitTracker;
+    /** Active cached content resource name (e.g., "cachedContents/abc123") */
+    private cachedContentName;
+    /** Hash of the content that was cached (systemPrompt + tools + model) */
+    private cachedContentHash;
+    /** When the cache expires (epoch ms) */
+    private cachedContentExpiry;
+    /** Hashes known to be below the 32K cache minimum — skip API call */
+    private uncacheableHashes;
+    constructor(apiKey: string, cacheHitTracker?: Pick<CacheHitTracker, 'recordTurn'>);
+    private computeCacheHash;
+    private ensureCachedContent;
+    chat(params: ChatRequest): Promise<ChatResponse>;
+    embed(request: ProviderEmbeddingRequest): Promise<ProviderEmbeddingResult>;
+    describeRuntime(deps: ProviderRuntimeMetadataDeps): Promise<ProviderRuntimeMetadata>;
+}
+//# sourceMappingURL=gemini.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/gemini.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,YAAY,EACZ,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,gBAAgB,CAAC;AAWxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yDAAyD,CAAC;AAuB/F;;;;;GAKG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,QAAQ,CAAC,IAAI,YAAY;IACzB,uEAAuE;IACvE,OAAO,CAAC,iBAAiB,CAA6B;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAM;IAE/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA0B;IACzD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsC;IAEtE,0EAA0E;IAC1E,OAAO,CAAC,iBAAiB,CAAuB;IAChD,yEAAyE;IACzE,OAAO,CAAC,iBAAiB,CAAuB;IAChD,wCAAwC;IACxC,OAAO,CAAC,mBAAmB,CAAa;IACxC,qEAAqE;IACrE,OAAO,CAAC,iBAAiB,CAAqB;gBAElC,MAAM,EAAE,MAAM,EAAE,eAAe,GAAE,IAAI,CAAC,eAAe,EAAE,YAAY,CAA0B;IAKzG,OAAO,CAAC,gBAAgB;YAWV,mBAAmB;IA2F3B,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAyMhD,KAAK,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAmD1E,eAAe,CAAC,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAmC3F"}