tarsk 0.3.43 → 0.4.4

package/dist/features/models/model-info.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Model info and pricing by provider
+ *
+ * Fetches model information (name, description, pricing) for the list of
+ * supported models. OpenRouter and AIHubMix pricing are loaded from their APIs.
+ *
+ * OpenRouter API: https://openrouter.ai/docs/api/api-reference/models/get-models
+ * AIHubMix API: https://docs.aihubmix.com/api/models
+ */
+export interface ModelInfoPricing {
+    /** Cost per token in USD (input/prompt) */
+    prompt: number;
+    /** Cost per token in USD (output/completion) */
+    completion: number;
+}
+export interface ModelInfo {
+    /** Pricing is omitted when unknown */
+    pricing?: ModelInfoPricing;
+    name?: string;
+    description?: string;
+    supportedParameters?: {
+        tools?: boolean;
+    };
+}
+/**
+ * Fetch model info and pricing for a provider.
+ * - OpenRouter: calls GET https://openrouter.ai/api/v1/models and maps pricing for supported model IDs (requires apiKey).
+ * - AIHubMix: calls GET https://aihubmix.com/api/v1/models and maps pricing for supported model IDs (requires apiKey).
+ * - Other providers: returns empty info for each model ID.
+ *
+ * @param provider - Provider id (e.g. "openrouter", "aihubmix")
+ * @param modelIds - List of supported model IDs to return info for
+ * @param apiKey - Optional API key; required for OpenRouter and AIHubMix
+ * @returns Map of model ID -> ModelInfo (pricing, optional name/description)
+ */
+export declare function getModelInfoForProvider(provider: string, modelIds: string[], apiKey?: string): Promise<Map<string, ModelInfo>>;
+//# sourceMappingURL=model-info.d.ts.map

package/dist/features/models/model-info.js

@@ -0,0 +1,39 @@
+/**
+ * Model info and pricing by provider
+ *
+ * Fetches model information (name, description, pricing) for the list of
+ * supported models. OpenRouter and AIHubMix pricing are loaded from their APIs.
+ *
+ * OpenRouter API: https://openrouter.ai/docs/api/api-reference/models/get-models
+ * AIHubMix API: https://docs.aihubmix.com/api/models
+ */
+import { getOpenRouterModelInfo } from "./model-info-openrouter.js";
+import { getAIHubMixModelInfo } from "./model-info-aihubmix.js";
+/**
+ * Fetch model info and pricing for a provider.
+ * - OpenRouter: calls GET https://openrouter.ai/api/v1/models and maps pricing for supported model IDs (requires apiKey).
+ * - AIHubMix: calls GET https://aihubmix.com/api/v1/models and maps pricing for supported model IDs (requires apiKey).
+ * - Other providers: returns empty info for each model ID.
+ *
+ * @param provider - Provider id (e.g. "openrouter", "aihubmix")
+ * @param modelIds - List of supported model IDs to return info for
+ * @param apiKey - Optional API key; required for OpenRouter and AIHubMix
+ * @returns Map of model ID -> ModelInfo (pricing, optional name/description)
+ */
+export async function getModelInfoForProvider(provider, modelIds, apiKey) {
+    const result = new Map();
+    const emptyInfo = () => ({});
+    const providerLower = provider.toLowerCase();
+    if (providerLower === "openrouter" && apiKey && apiKey.trim().length > 0) {
+        return getOpenRouterModelInfo(modelIds, apiKey);
+    }
+    if (providerLower === "aihubmix" && apiKey && apiKey.trim().length > 0) {
+        return getAIHubMixModelInfo(modelIds, apiKey);
+    }
+    // Other providers: pricing unknown (to be filled later)
+    for (const id of modelIds) {
+        result.set(id, emptyInfo());
+    }
+    return result;
+}
+//# sourceMappingURL=model-info.js.map

package/dist/features/models/models-catalog.d.ts

@@ -0,0 +1,49 @@
+export interface CatalogModelCost {
+    input: number;
+    output: number;
+}
+export interface CatalogModelLimit {
+    context: number;
+    output: number;
+}
+export interface CatalogModel {
+    id: string;
+    name: string;
+    family: string;
+    attachment: boolean;
+    reasoning: boolean;
+    tool_call: boolean;
+    release_date: string;
+    last_updated: string;
+    modalities: {
+        input: string[];
+        output: string[];
+    };
+    open_weights: boolean;
+    cost: CatalogModelCost;
+    limit: CatalogModelLimit;
+    tarsk_use?: string[];
+    coding_index?: number;
+}
+export interface CatalogProvider {
+    id: string;
+    env: string[];
+    npm: string;
+    api: string;
+    name: string;
+    doc: string;
+    models: Record<string, CatalogModel>;
+}
+export type ModelsCatalog = Record<string, CatalogProvider>;
+/**
+ * Get the models catalog using stale-while-revalidate pattern.
+ * - If cache is fresh (< 15 min): returns cached data
+ * - If cache is stale (>= 15 min): returns cached data, revalidates in background
+ * - If no cache: fetches synchronously, caches, returns
+ */
+export declare function getModelsCatalog(): Promise<ModelsCatalog | null>;
+/**
+ * Get a specific provider from the catalog
+ */
+export declare function getCatalogProvider(providerId: string): Promise<CatalogProvider | null>;
+//# sourceMappingURL=models-catalog.d.ts.map

package/dist/features/models/models-catalog.js

@@ -0,0 +1,80 @@
+import { getDatabase } from "../../database/database.js";
+import { getState, setState } from "../../database/database.state.js";
+const CATALOG_URL = "http://models.tarsk.io/models.json";
+const CACHE_TTL_MS = 15 * 60 * 1000; // 15 minutes
+const STATE_KEY_CATALOG = "modelsCatalog";
+const STATE_KEY_TIMESTAMP = "modelsCatalogTimestamp";
+let isRevalidating = false;
+async function fetchCatalog() {
+    const random = Math.random();
+    const url = `${CATALOG_URL}?${random}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch models catalog: ${response.status}`);
+    }
+    return response.json();
+}
+async function getCachedCatalog() {
+    const db = await getDatabase();
+    const catalog = (await getState(db, STATE_KEY_CATALOG));
+    const timestamp = (await getState(db, STATE_KEY_TIMESTAMP)) || 0;
+    return { catalog, timestamp };
+}
+async function saveCatalogToCache(catalog) {
+    const db = await getDatabase();
+    await setState(db, STATE_KEY_CATALOG, catalog);
+    await setState(db, STATE_KEY_TIMESTAMP, Date.now());
+}
+async function revalidateInBackground() {
+    if (isRevalidating)
+        return;
+    isRevalidating = true;
+    try {
+        const catalog = await fetchCatalog();
+        await saveCatalogToCache(catalog);
+        console.log("[models-catalog] Background revalidation complete");
+    }
+    catch (error) {
+        console.error("[models-catalog] Background revalidation failed:", error);
+    }
+    finally {
+        isRevalidating = false;
+    }
+}
+/**
+ * Get the models catalog using stale-while-revalidate pattern.
+ * - If cache is fresh (< 15 min): returns cached data
+ * - If cache is stale (>= 15 min): returns cached data, revalidates in background
+ * - If no cache: fetches synchronously, caches, returns
+ */
+export async function getModelsCatalog() {
+    const { catalog, timestamp } = await getCachedCatalog();
+    const age = Date.now() - timestamp;
+    if (catalog) {
+        if (age >= CACHE_TTL_MS) {
+            // Stale - return cached but revalidate in background
+            void revalidateInBackground();
+        }
+        return catalog;
+    }
+    // No cache - fetch synchronously
+    try {
+        const freshCatalog = await fetchCatalog();
+        await saveCatalogToCache(freshCatalog);
+        return freshCatalog;
+    }
+    catch (error) {
+        console.error("[models-catalog] Failed to fetch catalog:", error);
+        return null;
+    }
+}
+/**
+ * Get a specific provider from the catalog
+ */
+export async function getCatalogProvider(providerId) {
+    const catalog = await getModelsCatalog();
+    if (!catalog)
+        return null;
+    return catalog[providerId] || null;
+}
+//# sourceMappingURL=models-catalog.js.map

package/dist/features/models/models-catalog.route.d.ts

@@ -0,0 +1,43 @@
+import { Context } from "hono";
+export declare function handleGetModelsCatalog(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 503, "json">) | (Response & import("hono").TypedResponse<{
+    [x: string]: {
+        id: string;
+        env: string[];
+        npm: string;
+        api: string;
+        name: string;
+        doc: string;
+        models: {
+            [x: string]: {
+                id: string;
+                name: string;
+                family: string;
+                attachment: boolean;
+                reasoning: boolean;
+                tool_call: boolean;
+                release_date: string;
+                last_updated: string;
+                modalities: {
+                    input: string[];
+                    output: string[];
+                };
+                open_weights: boolean;
+                cost: {
+                    input: number;
+                    output: number;
+                };
+                limit: {
+                    context: number;
+                    output: number;
+                };
+                tarsk_use?: string[] | undefined;
+                coding_index?: number | undefined;
+            };
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=models-catalog.route.d.ts.map

package/dist/features/models/models-catalog.route.js

@@ -0,0 +1,15 @@
+import { getModelsCatalog } from "./models-catalog.js";
+export async function handleGetModelsCatalog(c) {
+    try {
+        const catalog = await getModelsCatalog();
+        if (!catalog) {
+            return c.json({ error: "Models catalog unavailable" }, 503);
+        }
+        return c.json(catalog);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=models-catalog.route.js.map

package/dist/features/models/models-get-available.route.d.ts

@@ -0,0 +1,36 @@
+/**
+ * GET /api/models?provider=openrouter&supportedTools=true&useCase=coding
+ * Get available models for a provider
+ *
+ * Query parameters:
+ * - provider: Required. Provider name (e.g., "openrouter", "openai")
+ * - supportedTools: Optional. If "true", only return models with tools support
+ * - useCase: Optional. If "coding", only return models where tarsk_use includes 'coding'
+ */
+import { Context } from "hono";
+import { ModelManager } from "../models/models.manager.js";
+export declare function handleGetAvailableModels(c: Context, modelManager: ModelManager): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    provider: string;
+    models: {
+        id: string;
+        name: string;
+        description: string;
+        provider: string;
+        pricing?: {
+            prompt: number;
+            completion: number;
+        } | undefined;
+        supportedParameters?: {
+            tools?: boolean | undefined;
+        } | undefined;
+        tarsk_use?: string[] | undefined;
+        coding_index?: number | undefined;
+        supportsImages?: boolean | undefined;
+        contextWindow?: number | undefined;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=models-get-available.route.d.ts.map

package/dist/features/models/models-get-available.route.js

@@ -0,0 +1,66 @@
+/**
+ * GET /api/models?provider=openrouter&supportedTools=true&useCase=coding
+ * Get available models for a provider
+ *
+ * Query parameters:
+ * - provider: Required. Provider name (e.g., "openrouter", "openai")
+ * - supportedTools: Optional. If "true", only return models with tools support
+ * - useCase: Optional. If "coding", only return models where tarsk_use includes 'coding'
+ */
+export async function handleGetAvailableModels(c, modelManager) {
+    try {
+        const provider = c.req.query("provider");
+        const supportedTools = c.req.query("supportedTools");
+        const useCase = c.req.query("useCase");
+        if (!provider) {
+            return c.json({ error: "provider query parameter is required" }, 400);
+        }
+        let models = await modelManager.getAvailableModels(provider);
+        // Log models missing coding_index
+        models.forEach((m) => {
+            if (m.coding_index === undefined || m.coding_index === null) {
+                console.log(`Model ${m.name} (${m.id}) is missing coding_index`);
+            }
+        });
+        // Filter by supported tools if requested
+        if (supportedTools === "true" && provider.toLowerCase() === "openrouter") {
+            models = models.filter((m) => m.supportedParameters?.tools === true);
+        }
+        // Filter by use case if requested
+        if (useCase === "coding") {
+            models = models.filter((m) => {
+                const name = m.name.toLowerCase().trim();
+                const hasValidName = name !== "free" && name !== "auto";
+                // Filter to only include models where tarsk_use includes 'coding'
+                // Handle missing tarsk_use property gracefully - if missing, assume not a coding model
+                const hasCodingUse = Array.isArray(m.tarsk_use) && m.tarsk_use.includes("coding");
+                return hasValidName && hasCodingUse;
+            });
+            // If no models pass the filter, return all valid models (fallback for when data hasn't been updated)
+            if (models.length === 0) {
+                models = (await modelManager.getAvailableModels(provider)).filter((m) => {
+                    const name = m.name.toLowerCase().trim();
+                    return name !== "free" && name !== "auto";
+                });
+                // Re-apply supported tools filter if it was requested
+                if (supportedTools === "true" && provider.toLowerCase() === "openrouter") {
+                    models = models.filter((m) => m.supportedParameters?.tools === true);
+                }
+            }
+        }
+        // Sort models to put enabled ones at the top
+        const enabledModels = await modelManager.getEnabledModels(provider);
+        const enabledModelIds = new Set(enabledModels.map((m) => m.id));
+        models.sort((a, b) => {
+            const aEnabled = enabledModelIds.has(a.id) ? 0 : 1;
+            const bEnabled = enabledModelIds.has(b.id) ? 0 : 1;
+            return aEnabled - bEnabled;
+        });
+        return c.json({ provider, models });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=models-get-available.route.js.map

package/dist/features/models/models-get-enabled.route.d.ts

@@ -0,0 +1,33 @@
+/**
+ * GET /api/models/enabled?useCase=coding
+ * Get all enabled models across all providers
+ *
+ * Query parameters:
+ * - useCase: Optional. If "coding", only return models where tarsk_use includes 'coding'
+ */
+import { Context } from "hono";
+import { ModelManager } from "../models/models.manager.js";
+export declare function handleGetEnabledModels(c: Context, modelManager: ModelManager): Promise<(Response & import("hono").TypedResponse<{
+    enabledModels: {
+        [x: string]: {
+            id: string;
+            name: string;
+            description: string;
+            provider: string;
+            pricing?: {
+                prompt: number;
+                completion: number;
+            } | undefined;
+            supportedParameters?: {
+                tools?: boolean | undefined;
+            } | undefined;
+            tarsk_use?: string[] | undefined;
+            coding_index?: number | undefined;
+            supportsImages?: boolean | undefined;
+            contextWindow?: number | undefined;
+        }[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=models-get-enabled.route.d.ts.map

package/dist/features/models/models-get-enabled.route.js

@@ -0,0 +1,45 @@
+/**
+ * GET /api/models/enabled?useCase=coding
+ * Get all enabled models across all providers
+ *
+ * Query parameters:
+ * - useCase: Optional. If "coding", only return models where tarsk_use includes 'coding'
+ */
+export async function handleGetEnabledModels(c, modelManager) {
+    try {
+        const useCase = c.req.query("useCase");
+        let enabledModels = await modelManager.getAllEnabledModels();
+        // Filter by use case if requested
+        if (useCase === "coding") {
+            const filtered = {};
+            for (const [provider, models] of Object.entries(enabledModels)) {
+                // Filter to only include coding models
+                const filteredModels = models.filter((m) => {
+                    const name = m.name.toLowerCase().trim();
+                    const hasValidName = name !== "free" && name !== "auto";
+                    // Filter to only include models where tarsk_use includes 'coding'
+                    // Handle missing tarsk_use property gracefully - if missing, assume not a coding model
+                    const hasCodingUse = Array.isArray(m.tarsk_use) && m.tarsk_use.includes("coding");
+                    return hasValidName && hasCodingUse;
+                });
+                // If no models pass the filter, return all valid models (fallback for when data hasn't been updated)
+                if (filteredModels.length === 0) {
+                    filtered[provider] = models.filter((m) => {
+                        const name = m.name.toLowerCase().trim();
+                        return name !== "free" && name !== "auto";
+                    });
+                }
+                else {
+                    filtered[provider] = filteredModels;
+                }
+            }
+            enabledModels = filtered;
+        }
+        return c.json({ enabledModels });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=models-get-enabled.route.js.map

package/dist/features/models/models-get-model-info.route.d.ts

@@ -0,0 +1,31 @@
+/**
+ * GET /api/models/info?modelId=...
+ * Get detailed information about a specific model including context window
+ * The modelId must be provided as a query parameter (modelId).
+ */
+import { Context } from "hono";
+import { ModelManager } from "./models.manager.js";
+export declare function handleGetModelInfo(c: Context, modelManager: ModelManager): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    id: string;
+    name: string;
+    provider: string;
+    description: string;
+    contextWindow: number | undefined;
+    pricing: {
+        prompt: number;
+        completion: number;
+    } | undefined;
+    supportedParameters: {
+        tools?: boolean | undefined;
+    } | undefined;
+    tarsk_use: string[] | undefined;
+    coding_index: number | undefined;
+    supportsImages: boolean | undefined;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=models-get-model-info.route.d.ts.map

package/dist/features/models/models-get-model-info.route.js

@@ -0,0 +1,84 @@
+/**
+ * GET /api/models/info?modelId=...
+ * Get detailed information about a specific model including context window
+ * The modelId must be provided as a query parameter (modelId).
+ */
+export async function handleGetModelInfo(c, modelManager) {
+    try {
+        const modelId = c.req.query("modelId");
+        if (!modelId || typeof modelId !== "string") {
+            return c.json({ error: "modelId query parameter is required and must be a string" }, 400);
+        }
+        // Extract provider from modelId (e.g., "openrouter/anthropic/claude-haiku-4.5" -> "openrouter")
+        const parts = modelId.split("/");
+        if (parts.length < 2) {
+            return c.json({ error: 'modelId must be in format "provider/model"' }, 400);
+        }
+        const provider = parts[0];
+        const modelName = parts.slice(1).join("/");
+        try {
+            // First, let's see all enabled models across all providers
+            console.log(`[models] Checking all enabled models...`);
+            const enabledModels = await modelManager.getEnabledModels(provider);
+            console.log(`[models] Enabled models for provider "${provider}":`, enabledModels.map((m) => ({ id: m.id, name: m.name })));
+            console.log(`[models] Looking for model ID: "${modelName}" or full: "${modelId}"`);
+            // If no models found for this provider, let's check all providers
+            if (enabledModels.length === 0) {
+                console.log(`[models] No enabled models for provider "${provider}". Checking all providers...`);
+                // Try to get available models instead to see what's available
+                try {
+                    const availableModels = await modelManager.getAvailableModels(provider);
+                    console.log(`[models] Available models for provider "${provider}":`, availableModels.map((m) => ({
+                        id: m.id,
+                        name: m.name,
+                        contextWindow: m.contextWindow,
+                    })));
+                    // Try to find the model in available models
+                    const availableModel = availableModels.find((m) => m.id === modelName || m.id === modelId);
+                    if (availableModel) {
+                        console.log(`[models] Found model in available models:`, availableModel);
+                        return c.json({
+                            id: availableModel.id,
+                            name: availableModel.name,
+                            provider: availableModel.provider,
+                            description: availableModel.description,
+                            contextWindow: availableModel.contextWindow,
+                            pricing: availableModel.pricing,
+                            supportedParameters: availableModel.supportedParameters,
+                            tarsk_use: availableModel.tarsk_use,
+                            coding_index: availableModel.coding_index,
+                            supportsImages: availableModel.supportsImages,
+                        });
+                    }
+                }
+                catch (availError) {
+                    console.log(`[models] Failed to get available models for provider "${provider}":`, availError);
+                }
+            }
+            const model = enabledModels.find((m) => m.id === modelName || m.id === modelId);
+            if (!model) {
+                return c.json({ error: `Model "${modelId}" not found or not enabled` }, 404);
+            }
+            return c.json({
+                id: model.id,
+                name: model.name,
+                provider: model.provider,
+                description: model.description,
+                contextWindow: model.contextWindow,
+                pricing: model.pricing,
+                supportedParameters: model.supportedParameters,
+                tarsk_use: model.tarsk_use,
+                coding_index: model.coding_index,
+                supportsImages: model.supportsImages,
+            });
+        }
+        catch {
+            return c.json({ error: `Failed to get models from provider "${provider}"` }, 500);
+        }
+    }
+    catch (error) {
+        console.error("[models] Error getting model info:", error);
+        return c.json({ error: "Failed to retrieve model information" }, 500);
+    }
+}
+//# sourceMappingURL=models-get-model-info.route.js.map

package/dist/features/models/models-model-disable.route.d.ts

@@ -0,0 +1,15 @@
+/**
+ * POST /api/models/:provider/:modelId/disable
+ * Disable a model for a provider
+ */
+import { Context } from "hono";
+import { ModelManager } from "../models/models.manager.js";
+export declare function handleModelDisable(c: Context, modelManager: ModelManager): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=models-model-disable.route.d.ts.map

package/dist/features/models/models-model-disable.route.js

@@ -0,0 +1,20 @@
+/**
+ * POST /api/models/:provider/:modelId/disable
+ * Disable a model for a provider
+ */
+export async function handleModelDisable(c, modelManager) {
+    try {
+        const provider = c.req.param("provider");
+        const modelId = c.req.param("modelId");
+        if (!provider || !modelId) {
+            return c.json({ error: "provider and modelId are required" }, 400);
+        }
+        await modelManager.disableModel(provider, modelId);
+        return c.json({ success: true, message: `Model ${modelId} disabled for ${provider}` });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=models-model-disable.route.js.map

package/dist/features/models/models-model-enable.route.d.ts

@@ -0,0 +1,13 @@
+/**
+ * POST /api/models/:provider/:modelId/enable
+ * Enable a model for a provider
+ */
+import { Context } from "hono";
+import { ModelManager } from "../models/models.manager.js";
+export declare function handleModelEnable(c: Context, modelManager: ModelManager): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+//# sourceMappingURL=models-model-enable.route.d.ts.map

package/dist/features/models/models-model-enable.route.js

@@ -0,0 +1,20 @@
+/**
+ * POST /api/models/:provider/:modelId/enable
+ * Enable a model for a provider
+ */
+export async function handleModelEnable(c, modelManager) {
+    try {
+        const provider = c.req.param("provider");
+        const modelId = c.req.param("modelId");
+        if (!provider || !modelId) {
+            return c.json({ error: "provider and modelId are required" }, 400);
+        }
+        await modelManager.enableModel(provider, modelId);
+        return c.json({ success: true, message: `Model ${modelId} enabled for ${provider}` });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return c.json({ error: message }, 400);
+    }
+}
+//# sourceMappingURL=models-model-enable.route.js.map

package/dist/features/models/models-provider-refresh.route.d.ts

@@ -0,0 +1,17 @@
+/**
+ * POST /api/models/:provider/refresh
+ * Refresh the available models for a provider
+ * Note: With provider-data.ts, this is a no-op but kept for backward compatibility
+ */
+import { Context } from "hono";
+import { ModelManager } from "../models/models.manager.js";
+export declare function handleProviderRefresh(c: Context, modelManager: ModelManager): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    provider: string;
+    modelCount: number;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=models-provider-refresh.route.d.ts.map