@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/providers/lm-studio.js

@@ -0,0 +1,405 @@
+import { OpenAICompatProvider } from './openai-compat.js';
+import { ProviderError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { withRetry } from '@pellux/goodvibes-sdk/platform/utils/retry';
+import { buildHttpError, buildResponsesInput, buildResponsesReasoning, buildResponsesTools, consumeSSE, createResponsesClient, deriveNativeChatUrl, extractNativeMessageText, makeTranscriptKey, mapNativeReasoningEffort, mapResponsesStopReason, normalizeProviderError, parseJsonObject, shouldFallbackFromNative, shouldFallbackFromResponses, toNativeChatInput, toRecord, } from './lm-studio-helpers.js';
+export class LMStudioProvider {
+    name;
+    models;
+    capabilities;
+    defaultModel;
+    nativeChatUrl;
+    nativeFetch;
+    responsesClient;
+    fallbackProvider;
+    nativeResponseIds = new Map();
+    constructor(opts) {
+        this.name = opts.name;
+        this.models = opts.models;
+        this.capabilities = opts.capabilities;
+        this.defaultModel = opts.defaultModel;
+        this.nativeChatUrl = deriveNativeChatUrl(opts.baseURL);
+        this.nativeFetch = opts.nativeFetch ?? ((input, init) => fetch(input, init));
+        this.responsesClient = opts.responsesClient ?? createResponsesClient(opts.baseURL, opts.apiKey, opts.defaultHeaders);
+        this.fallbackProvider = opts.fallbackProvider ?? new OpenAICompatProvider(opts);
+    }
+    async chat(params) {
+        return withRetry(async () => {
+            const model = params.model || this.defaultModel;
+            const nativeContext = this.getNativeChatContext(model, params.systemPrompt, params.messages, params.tools);
+            if (nativeContext) {
+                try {
+                    return await this.chatViaNativeChat(params, model, nativeContext);
+                }
+                catch (err) {
+                    if (!shouldFallbackFromNative(err)) {
+                        throw normalizeProviderError(err, this.name, 'chat', 'request');
+                    }
+                }
+            }
+            try {
+                return await this.chatViaResponses(params, model);
+            }
+            catch (err) {
+                if (!shouldFallbackFromResponses(err)) {
+                    throw normalizeProviderError(err, this.name, 'chat', 'request');
+                }
+            }
+            return this.fallbackProvider.chat(params);
+        });
+    }
+    async embed(request) {
+        if (!this.fallbackProvider.embed) {
+            throw new ProviderError('LM Studio fallback provider does not support embeddings.', {
+                statusCode: 501,
+                provider: this.name,
+                operation: 'embed',
+                phase: 'response',
+            });
+        }
+        return this.fallbackProvider.embed(request);
+    }
+    async describeRuntime(deps) {
+        const { buildStandardProviderAuthRoutes } = await import('./runtime-metadata.js');
+        const authRoutes = await buildStandardProviderAuthRoutes({
+            providerId: this.name,
+            apiKeyEnvVars: ['LM_STUDIO_API_KEY'],
+            secretKeys: ['LM_STUDIO_API_KEY', 'OPENAI_COMPATIBLE_API_KEY', 'OPENAI_COMPAT_API_KEY'],
+            allowAnonymous: true,
+            anonymousConfigured: true,
+            anonymousDetail: 'LM Studio local servers can be used anonymously unless the host is configured with auth.',
+        }, deps);
+        return {
+            auth: {
+                mode: 'anonymous',
+                configured: true,
+                detail: 'LM Studio is treated as a local-first provider with optional API-key support.',
+                envVars: ['LM_STUDIO_API_KEY'],
+                routes: authRoutes,
+            },
+            models: {
+                defaultModel: this.defaultModel,
+                models: this.models,
+            },
+            usage: {
+                streaming: true,
+                toolCalling: true,
+                parallelTools: true,
+                promptCaching: false,
+                notes: ['LM Studio prefers native chat SSE when possible and falls back to the responses or OpenAI-compatible path when needed.'],
+            },
+            policy: {
+                local: true,
+                streamProtocol: 'lmstudio-native-or-responses',
+                reasoningMode: 'native-reasoning-events',
+                supportedReasoningEfforts: ['instant', 'low', 'medium', 'high'],
+                cacheStrategy: 'provider-managed',
+            },
+        };
+    }
+    getNativeChatContext(model, systemPrompt, messages, tools) {
+        if ((tools?.length ?? 0) > 0)
+            return null;
+        if (messages.length === 0)
+            return null;
+        if (messages.some((message) => (message.role === 'tool'
+            || (message.role === 'assistant' && (message.toolCalls?.length ?? 0) > 0)))) {
+            return null;
+        }
+        const lastMessage = messages[messages.length - 1];
+        if (!lastMessage || lastMessage.role !== 'user')
+            return null;
+        const previousMessages = messages.slice(0, -1);
+        let previousResponseId;
+        if (previousMessages.length > 0) {
+            const previousKey = makeTranscriptKey(model, systemPrompt, previousMessages);
+            previousResponseId = this.nativeResponseIds.get(previousKey);
+            if (!previousResponseId)
+                return null;
+        }
+        return {
+            input: toNativeChatInput(lastMessage.content),
+            ...(previousResponseId ? { previousResponseId } : {}),
+        };
+    }
+    rememberNativeResponse(model, systemPrompt, requestMessages, assistantContent, responseId) {
+        if (!responseId)
+            return;
+        const key = makeTranscriptKey(model, systemPrompt, [
+            ...requestMessages,
+            { role: 'assistant', content: assistantContent },
+        ]);
+        this.nativeResponseIds.set(key, responseId);
+    }
+    async chatViaNativeChat(params, model, context) {
+        const body = {
+            model,
+            input: context.input,
+            stream: true,
+            store: true,
+            ...(params.systemPrompt ? { system_prompt: params.systemPrompt } : {}),
+            ...(params.maxTokens ? { max_output_tokens: params.maxTokens } : {}),
+            ...(mapNativeReasoningEffort(params.reasoningEffort) ? { reasoning: mapNativeReasoningEffort(params.reasoningEffort) } : {}),
+            ...(context.previousResponseId ? { previous_response_id: context.previousResponseId } : {}),
+        };
+        let response;
+        try {
+            response = await this.nativeFetch(this.nativeChatUrl, {
+                method: 'POST',
+                headers: {
+                    accept: 'text/event-stream',
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify(body),
+                signal: params.signal,
+            });
+        }
+        catch (err) {
+            throw normalizeProviderError(err, this.name, 'chat', 'request');
+        }
+        if (!response.ok) {
+            throw await buildHttpError('LM Studio native chat', response, this.name, 'chat', 'request');
+        }
+        if (!response.body) {
+            throw new ProviderError('LM Studio native chat returned no response body.', {
+                statusCode: 502,
+                provider: this.name,
+                operation: 'chat',
+                phase: 'response',
+            });
+        }
+        let text = '';
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let finalResult;
+        let streamedError;
+        await consumeSSE(response.body, (eventType, payload) => {
+            if (eventType === 'reasoning.delta') {
+                const delta = typeof payload['content'] === 'string' ? payload['content'] : '';
+                if (delta)
+                    params.onDelta?.({ reasoning: delta });
+                return;
+            }
+            if (eventType === 'message.delta') {
+                const delta = typeof payload['content'] === 'string' ? payload['content'] : '';
+                if (!delta)
+                    return;
+                text += delta;
+                params.onDelta?.({ content: delta });
+                return;
+            }
+            if (eventType === 'error') {
+                const error = payload['error'];
+                if (error && typeof error === 'object') {
+                    const record = error;
+                    const message = typeof record['message'] === 'string' ? record['message'] : 'Unknown LM Studio streaming error';
+                    const code = typeof record['code'] === 'string' ? `${record['code']}: ` : '';
+                    streamedError = new ProviderError(`LM Studio native chat error: ${code}${message}`, {
+                        statusCode: 400,
+                        provider: this.name,
+                        operation: 'chat',
+                        phase: 'stream',
+                    });
+                }
+                else {
+                    streamedError = new ProviderError('LM Studio native chat returned a streaming error.', {
+                        statusCode: 400,
+                        provider: this.name,
+                        operation: 'chat',
+                        phase: 'stream',
+                    });
+                }
+                return;
+            }
+            if (eventType === 'chat.end') {
+                const result = payload['result'];
+                if (!result || typeof result !== 'object')
+                    return;
+                finalResult = result;
+                const stats = finalResult.stats;
+                inputTokens = typeof stats?.input_tokens === 'number' ? stats.input_tokens : inputTokens;
+                outputTokens = typeof stats?.total_output_tokens === 'number'
+                    ? stats.total_output_tokens
+                    : (typeof stats?.output_tokens === 'number' ? stats.output_tokens : outputTokens);
+            }
+        });
+        if (streamedError)
+            throw streamedError;
+        if (!finalResult) {
+            throw new ProviderError('LM Studio native chat stream ended without a final result.', {
+                statusCode: 502,
+                provider: this.name,
+                operation: 'chat',
+                phase: 'stream',
+            });
+        }
+        if (!text) {
+            text = extractNativeMessageText(finalResult.output);
+        }
+        this.rememberNativeResponse(model, params.systemPrompt, params.messages, text, finalResult.response_id);
+        return {
+            content: text,
+            toolCalls: [],
+            usage: {
+                inputTokens,
+                outputTokens,
+            },
+            stopReason: 'end',
+        };
+    }
+    async chatViaResponses(params, model) {
+        const tools = buildResponsesTools(params.tools);
+        const reasoning = buildResponsesReasoning(params.reasoningEffort);
+        const body = {
+            model,
+            input: buildResponsesInput(params.messages),
+            stream: true,
+            store: false,
+            ...(params.systemPrompt?.trim() ? { instructions: params.systemPrompt.trim() } : {}),
+            ...(params.maxTokens ? { max_output_tokens: params.maxTokens } : {}),
+            ...(tools ? { tools, tool_choice: 'auto', parallel_tool_calls: true } : {}),
+            ...(reasoning ? { reasoning } : {}),
+        };
+        let stream;
+        try {
+            stream = await this.responsesClient.create(body, { signal: params.signal });
+        }
+        catch (err) {
+            throw normalizeProviderError(err, this.name, 'chat', 'request');
+        }
+        let text = '';
+        let reasoningSummary = '';
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let cacheReadTokens = 0;
+        let status = 'completed';
+        const toolStarts = new Map();
+        const toolItemIds = new Map();
+        const toolArgs = new Map();
+        const toolCalls = new Map();
+        for await (const event of stream) {
+            const record = toRecord(event);
+            const type = typeof record['type'] === 'string' ? record['type'] : '';
+            if (type === 'response.output_item.added') {
+                const item = toRecord(record['item']);
+                if (item['type'] !== 'function_call')
+                    continue;
+                const callId = typeof item['call_id'] === 'string' ? item['call_id'] : '';
+                const itemId = typeof item['id'] === 'string' ? item['id'] : '';
+                if (!callId)
+                    continue;
+                const partial = {
+                    index: toolStarts.size,
+                    id: callId,
+                    name: typeof item['name'] === 'string' ? item['name'] : undefined,
+                };
+                toolStarts.set(callId, partial);
+                if (itemId)
+                    toolItemIds.set(itemId, callId);
+                params.onDelta?.({ toolCalls: [partial] });
+                continue;
+            }
+            if (type === 'response.output_text.delta') {
+                const delta = typeof record['delta'] === 'string' ? record['delta'] : '';
+                if (!delta)
+                    continue;
+                text += delta;
+                params.onDelta?.({ content: delta });
+                continue;
+            }
+            if (type === 'response.reasoning_text.delta') {
+                const delta = typeof record['delta'] === 'string' ? record['delta'] : '';
+                if (!delta)
+                    continue;
+                params.onDelta?.({ reasoning: delta });
+                continue;
+            }
+            if (type === 'response.reasoning_summary_text.delta') {
+                const delta = typeof record['delta'] === 'string' ? record['delta'] : '';
+                if (!delta)
+                    continue;
+                reasoningSummary += delta;
+                continue;
+            }
+            if (type === 'response.function_call_arguments.delta') {
+                const itemId = typeof record['item_id'] === 'string' ? record['item_id'] : '';
+                const delta = typeof record['delta'] === 'string' ? record['delta'] : '';
+                if (!itemId || !delta)
+                    continue;
+                const callId = toolItemIds.get(itemId);
+                if (!callId)
+                    continue;
+                const partial = toolStarts.get(callId);
+                if (!partial)
+                    continue;
+                toolArgs.set(callId, `${toolArgs.get(callId) ?? ''}${delta}`);
+                params.onDelta?.({
+                    toolCalls: [{
+                            index: partial.index,
+                            id: callId,
+                            name: partial.name,
+                            arguments: delta,
+                        }],
+                });
+                continue;
+            }
+            if (type === 'response.output_item.done') {
+                const item = toRecord(record['item']);
+                if (item['type'] !== 'function_call')
+                    continue;
+                const callId = typeof item['call_id'] === 'string' ? item['call_id'] : '';
+                const name = typeof item['name'] === 'string' ? item['name'] : '';
+                const argumentsText = typeof item['arguments'] === 'string'
+                    ? item['arguments']
+                    : (toolArgs.get(callId) ?? '{}');
+                if (!callId || !name)
+                    continue;
+                toolCalls.set(callId, {
+                    id: callId,
+                    name,
+                    arguments: parseJsonObject(argumentsText),
+                });
+                continue;
+            }
+            if (type === 'response.completed') {
+                const completed = toRecord(record['response']);
+                status = typeof completed['status'] === 'string' ? completed['status'] : status;
+                const usage = toRecord(completed['usage']);
+                const input = typeof usage['input_tokens'] === 'number' ? usage['input_tokens'] : 0;
+                const output = typeof usage['output_tokens'] === 'number' ? usage['output_tokens'] : 0;
+                const inputDetails = toRecord(usage['input_tokens_details']);
+                const cached = typeof inputDetails['cached_tokens'] === 'number' ? inputDetails['cached_tokens'] : 0;
+                inputTokens = Math.max(0, input - cached);
+                outputTokens = output;
+                cacheReadTokens = cached;
+                continue;
+            }
+            if (type === 'response.failed') {
+                const failed = toRecord(record['response']);
+                const error = toRecord(failed['error']);
+                const code = typeof error['code'] === 'string' ? `${error['code']}: ` : '';
+                const message = typeof error['message'] === 'string' ? error['message'] : 'Unknown failure';
+                throw new ProviderError(`LM Studio Responses error: ${code}${message}`, {
+                    statusCode: 400,
+                    provider: this.name,
+                    operation: 'chat',
+                    phase: 'stream',
+                });
+            }
+        }
+        const resolvedToolCalls = [...toolCalls.values()];
+        const response = {
+            content: text,
+            toolCalls: resolvedToolCalls,
+            usage: {
+                inputTokens,
+                outputTokens,
+                ...(cacheReadTokens > 0 ? { cacheReadTokens } : {}),
+            },
+            stopReason: mapResponsesStopReason(status, resolvedToolCalls),
+        };
+        if (reasoningSummary) {
+            response.reasoningSummary = reasoningSummary;
+        }
+        return response;
+    }
+}

package/dist/_internal/platform/providers/model-catalog-cache.d.ts

@@ -0,0 +1,19 @@
+import type { CatalogModel } from './model-catalog.js';
+interface CatalogCacheFile {
+    version: 1;
+    fetchedAt: number;
+    ttlMs: number;
+    models: CatalogModel[];
+}
+export declare function getCatalogCachePath(cacheDir: string): string;
+export declare function getCatalogTmpPath(cacheDir: string): string;
+declare function loadCatalogCache(cachePath: string): CatalogCacheFile | null;
+declare function saveCatalogCache(models: CatalogModel[], cachePath: string, tmpPath: string): void;
+declare function isCatalogCacheStale(cache: CatalogCacheFile): boolean;
+/**
+ * Fetch models.dev/api.json and parse into CatalogModel[].
+ * Uses a 30-second timeout.
+ */
+export declare function fetchCatalog(): Promise<CatalogModel[]>;
+export { loadCatalogCache, saveCatalogCache, isCatalogCacheStale, };
+//# sourceMappingURL=model-catalog-cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-catalog-cache.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/model-catalog-cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAgBvD,UAAU,gBAAgB;IACxB,OAAO,EAAE,CAAC,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,YAAY,EAAE,CAAC;CACxB;AA8BD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1D;AA4FD,iBAAS,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAepE;AAED,iBAAS,gBAAgB,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAc1F;AAED,iBAAS,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAE7D;AAED;;;GAGG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAqB5D;AAED,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,GACpB,CAAC"}

package/dist/_internal/platform/providers/model-catalog-cache.js

@@ -0,0 +1,160 @@
+import fs from 'node:fs';
+import { dirname, join } from 'node:path';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const MODELS_DEV_URL = 'https://models.dev/api.json';
+const CATALOG_FETCH_TIMEOUT_MS = 30_000;
+const CATALOG_TTL_MS = 86_400_000; // 24 hours
+export function getCatalogCachePath(cacheDir) {
+    return join(cacheDir, 'model-catalog.json');
+}
+export function getCatalogTmpPath(cacheDir) {
+    return `${getCatalogCachePath(cacheDir)}.tmp`;
+}
+function categorizeProvider(providerId) {
+    const subscriptionProviders = new Set([
+        'github-copilot',
+        'github-models',
+        'v0',
+        'vercel',
+        'gitlab',
+        'kimi-for-coding',
+        'llama',
+        'lmstudio',
+    ]);
+    const shutdownProviders = new Set(['iflow', 'iflowcn']);
+    if (providerId.includes('coding-plan'))
+        return 'subscription';
+    if (subscriptionProviders.has(providerId))
+        return 'subscription';
+    if (shutdownProviders.has(providerId))
+        return 'shutdown';
+    return 'normal';
+}
+function isFreeModel(modelId, cost, providerCategory) {
+    if (providerCategory === 'subscription')
+        return false;
+    if (modelId.includes('coding-plan'))
+        return false;
+    return (cost?.input ?? -1) === 0 && (cost?.output ?? -1) === 0;
+}
+function getStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === 'string');
+}
+function transformModelsDevResponse(json) {
+    const models = [];
+    for (const [providerId, providerData] of Object.entries(json)) {
+        if (!providerData || typeof providerData !== 'object')
+            continue;
+        const providerCategory = categorizeProvider(providerId);
+        if (providerCategory === 'shutdown')
+            continue;
+        const providerName = String(providerData.name ?? providerId);
+        const providerModels = providerData.models;
+        if (!providerModels || typeof providerModels !== 'object')
+            continue;
+        for (const [modelKey, modelData] of Object.entries(providerModels)) {
+            if (!modelData || typeof modelData !== 'object')
+                continue;
+            const modelId = String(modelData.id ?? modelKey);
+            const modelName = String(modelData.name ?? modelId);
+            const modelFamily = typeof modelData.family === 'string' ? modelData.family : undefined;
+            const cost = modelData.cost;
+            const limit = modelData.limit;
+            const supportsReasoning = modelData.reasoning === true;
+            const inputCost = typeof cost?.input === 'number' ? cost.input : 0;
+            const outputCost = typeof cost?.output === 'number' ? cost.output : 0;
+            const contextWindow = typeof limit?.context === 'number' ? limit.context : undefined;
+            let tier;
+            if (providerCategory === 'subscription') {
+                tier = 'subscription';
+            }
+            else if (isFreeModel(modelId, cost, providerCategory)) {
+                tier = 'free';
+            }
+            else {
+                tier = 'paid';
+            }
+            const maxOutputTokens = typeof limit?.output === 'number' ? limit.output : undefined;
+            models.push({
+                id: modelId,
+                name: modelName,
+                ...(modelFamily ? { family: modelFamily } : {}),
+                provider: providerName,
+                providerId,
+                providerEnvVars: getStringArray(providerData.env),
+                pricing: { input: inputCost, output: outputCost },
+                tier,
+                contextWindow,
+                maxOutputTokens,
+                ...(supportsReasoning ? { reasoning: true } : {}),
+            });
+        }
+    }
+    return models;
+}
+function loadCatalogCache(cachePath) {
+    try {
+        const raw = fs.readFileSync(cachePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1 || !Array.isArray(parsed.models))
+            return null;
+        return parsed;
+    }
+    catch (err) {
+        const msg = summarizeError(err);
+        if (msg.includes('ENOENT') || msg.includes('no such file')) {
+            logger.debug('[model-catalog] No cache file (first run)');
+        }
+        else {
+            logger.warn('[model-catalog] Cache load failed', { error: msg });
+        }
+        return null;
+    }
+}
+function saveCatalogCache(models, cachePath, tmpPath) {
+    try {
+        fs.mkdirSync(dirname(cachePath), { recursive: true });
+        const payload = {
+            version: 1,
+            fetchedAt: Date.now(),
+            ttlMs: CATALOG_TTL_MS,
+            models,
+        };
+        fs.writeFileSync(tmpPath, JSON.stringify(payload, null, 2), 'utf-8');
+        fs.renameSync(tmpPath, cachePath);
+    }
+    catch (err) {
+        logger.warn('[model-catalog] Cache write failed', { error: summarizeError(err) });
+    }
+}
+function isCatalogCacheStale(cache) {
+    return Date.now() - cache.fetchedAt > cache.ttlMs;
+}
+/**
+ * Fetch models.dev/api.json and parse into CatalogModel[].
+ * Uses a 30-second timeout.
+ */
+export async function fetchCatalog() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), CATALOG_FETCH_TIMEOUT_MS);
+    try {
+        const response = await fetch(MODELS_DEV_URL, {
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        if (!response.ok) {
+            throw new Error(`models.dev API returned ${response.status} ${response.statusText}`);
+        }
+        const json = await response.json();
+        const models = transformModelsDevResponse(json);
+        logger.debug('[model-catalog] Fetched models from models.dev', { count: models.length });
+        return models;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export { loadCatalogCache, saveCatalogCache, isCatalogCacheStale, };

package/dist/_internal/platform/providers/model-catalog-notifications.d.ts

@@ -0,0 +1,7 @@
+import type { FavoritesData } from '@pellux/goodvibes-sdk/platform/providers/favorites';
+import type { CatalogDiff, CatalogModel } from './model-catalog.js';
+export declare function diffCatalogs(oldCatalog: readonly CatalogModel[], newCatalog: readonly CatalogModel[]): CatalogDiff;
+export declare function filterRelevantChanges(diff: CatalogDiff, favorites: FavoritesData, topBenchmarkModelIds: readonly string[]): CatalogDiff;
+export declare function formatChangeNotifications(diff: CatalogDiff): string[];
+export declare function notifyCatalogChanges(oldModels: readonly CatalogModel[], newModels: readonly CatalogModel[], favorites: FavoritesData, topBenchmarkModelIds: readonly string[]): string[];
+//# sourceMappingURL=model-catalog-notifications.d.ts.map

package/dist/_internal/platform/providers/model-catalog-notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-catalog-notifications.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/model-catalog-notifications.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oDAAoD,CAAC;AACxF,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEpE,wBAAgB,YAAY,CAC1B,UAAU,EAAE,SAAS,YAAY,EAAE,EACnC,UAAU,EAAE,SAAS,YAAY,EAAE,GAClC,WAAW,CAwCb;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,aAAa,EACxB,oBAAoB,EAAE,SAAS,MAAM,EAAE,GACtC,WAAW,CAYb;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CAcrE;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,SAAS,YAAY,EAAE,EAClC,SAAS,EAAE,SAAS,YAAY,EAAE,EAClC,SAAS,EAAE,aAAa,EACxB,oBAAoB,EAAE,SAAS,MAAM,EAAE,GACtC,MAAM,EAAE,CAQV"}

package/dist/_internal/platform/providers/model-catalog-notifications.js

@@ -0,0 +1,78 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+export function diffCatalogs(oldCatalog, newCatalog) {
+    const oldMap = new Map(oldCatalog.map((model) => [model.id, model]));
+    const newMap = new Map(newCatalog.map((model) => [model.id, model]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [id, model] of newMap) {
+        if (!oldMap.has(id))
+            added.push(model);
+    }
+    for (const [id, model] of oldMap) {
+        if (!newMap.has(id))
+            removed.push(model);
+    }
+    for (const [id, oldModel] of oldMap) {
+        const nextModel = newMap.get(id);
+        if (!nextModel)
+            continue;
+        const changes = [];
+        if (oldModel.contextWindow !== nextModel.contextWindow) {
+            const format = (value) => (value != null ? `${Math.round(value / 1024)}K` : 'unknown');
+            changes.push(`context ${format(oldModel.contextWindow)} -> ${format(nextModel.contextWindow)}`);
+        }
+        if (oldModel.pricing.input !== nextModel.pricing.input) {
+            changes.push(`input price $${oldModel.pricing.input} -> $${nextModel.pricing.input} per 1M tokens`);
+        }
+        if (oldModel.pricing.output !== nextModel.pricing.output) {
+            changes.push(`output price $${oldModel.pricing.output} -> $${nextModel.pricing.output} per 1M tokens`);
+        }
+        if (oldModel.tier !== nextModel.tier) {
+            changes.push(`tier ${oldModel.tier} -> ${nextModel.tier}`);
+        }
+        if (changes.length > 0) {
+            changed.push({ model: nextModel, changes });
+        }
+    }
+    return { added, removed, changed };
+}
+export function filterRelevantChanges(diff, favorites, topBenchmarkModelIds) {
+    const relevantIds = new Set();
+    for (const entry of favorites.history)
+        relevantIds.add(entry.modelId);
+    for (const entry of favorites.pinned)
+        relevantIds.add(entry.modelId);
+    for (const id of topBenchmarkModelIds)
+        relevantIds.add(id);
+    const isRelevant = (model) => relevantIds.has(model.id);
+    return {
+        added: diff.added.filter(isRelevant),
+        removed: diff.removed.filter(isRelevant),
+        changed: diff.changed.filter((entry) => isRelevant(entry.model)),
+    };
+}
+export function formatChangeNotifications(diff) {
+    const notifications = [];
+    for (const model of diff.added) {
+        notifications.push(`New model: ${model.name} now available on ${model.provider}`);
+    }
+    for (const { model, changes } of diff.changed) {
+        for (const change of changes) {
+            notifications.push(`Model update: ${model.name} ${change}`);
+        }
+    }
+    for (const model of diff.removed) {
+        notifications.push(`Model removed: ${model.name} no longer available on ${model.provider}`);
+    }
+    return notifications;
+}
+export function notifyCatalogChanges(oldModels, newModels, favorites, topBenchmarkModelIds) {
+    const diff = diffCatalogs(oldModels, newModels);
+    const filtered = filterRelevantChanges(diff, favorites, topBenchmarkModelIds);
+    const notifications = formatChangeNotifications(filtered);
+    for (const message of notifications) {
+        logger.info(`[model-catalog] ${message}`);
+    }
+    return notifications;
+}