@agenthippo-ai/agenthippo 0.1.0

package/out/session.js

@@ -0,0 +1,272 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONVERSATION_LOCK_TIMEOUT_MS = void 0;
+exports.initSessionStore = initSessionStore;
+exports.initSessionStoreWithStore = initSessionStoreWithStore;
+exports._getSessionStore = _getSessionStore;
+exports._resetSessionStore = _resetSessionStore;
+exports.upsertPersistedSession = upsertPersistedSession;
+exports.touchPersistedSession = touchPersistedSession;
+exports.getPersistedSession = getPersistedSession;
+exports.runSessionMaintenance = runSessionMaintenance;
+exports.buildConversationKey = buildConversationKey;
+exports.withConversationLock = withConversationLock;
+const crypto = __importStar(require("crypto"));
+const utils_1 = require("./utils");
+const vscode_session_store_1 = require("./runtime/vscode/vscode-session-store");
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+const PERSISTED_SESSIONS_KEY = 'agentide.providerSessions.v1';
+const PERSISTED_MAX_ENTRIES = 200;
+const PERSISTED_TTL_MS = 1000 * 60 * 60 * 24 * 14; // 14 days
+let _persistedSessions = {};
+let _sessionStore;
+/**
+ * Initialize session store with a VS Code extension context.
+ * This is the standard initialization for the VS Code extension.
+ */
+function initSessionStore(context) {
+    initSessionStoreWithStore(new vscode_session_store_1.VSCodeSessionStore(context.globalState));
+}
+/**
+ * Initialize session store with a custom SessionStore implementation.
+ * Useful for testing or alternative runtime environments.
+ */
+function initSessionStoreWithStore(store) {
+    _sessionStore = store;
+    const value = store.get(PERSISTED_SESSIONS_KEY);
+    _persistedSessions = value ?? {};
+    prunePersistedSessions(Date.now());
+    void flushPersistedSessionsToStore();
+}
+/**
+ * Get the current session store for testing or advanced use cases.
+ * @internal
+ */
+function _getSessionStore() {
+    return _sessionStore;
+}
+/**
+ * Reset the session store (for testing).
+ * @internal
+ */
+function _resetSessionStore() {
+    _sessionStore = undefined;
+    _persistedSessions = {};
+}
+function prunePersistedSessions(nowMs) {
+    // TTL prune first
+    for (const [key, entry] of Object.entries(_persistedSessions)) {
+        if (nowMs - entry.lastUsedAt > PERSISTED_TTL_MS) {
+            delete _persistedSessions[key];
+        }
+    }
+    // Size prune (oldest lastUsedAt first)
+    const keys = Object.keys(_persistedSessions);
+    if (keys.length <= PERSISTED_MAX_ENTRIES) {
+        return;
+    }
+    keys.sort((a, b) => _persistedSessions[a].lastUsedAt - _persistedSessions[b].lastUsedAt);
+    for (let i = 0; i < keys.length - PERSISTED_MAX_ENTRIES; i++) {
+        delete _persistedSessions[keys[i]];
+    }
+}
+async function flushPersistedSessionsToStore() {
+    if (!_sessionStore) {
+        return;
+    }
+    try {
+        await _sessionStore.set(PERSISTED_SESSIONS_KEY, _persistedSessions);
+    }
+    catch {
+        // Best-effort persistence only; don't fail requests if storage can't persist state.
+    }
+}
+async function upsertPersistedSession(conversationKey, entry) {
+    _persistedSessions[conversationKey] = entry;
+    prunePersistedSessions(Date.now());
+    await flushPersistedSessionsToStore();
+}
+async function touchPersistedSession(conversationKey) {
+    const existing = _persistedSessions[conversationKey];
+    if (!existing) {
+        return;
+    }
+    existing.lastUsedAt = Date.now();
+    prunePersistedSessions(existing.lastUsedAt);
+    await flushPersistedSessionsToStore();
+}
+function getPersistedSession(conversationKey) {
+    return _persistedSessions[conversationKey];
+}
+function runSessionMaintenance() {
+    prunePersistedSessions(Date.now());
+    void flushPersistedSessionsToStore();
+}
+// -----------------------------------------------------------------------------
+// Conversation Key Building
+// -----------------------------------------------------------------------------
+/**
+ * Build a signature that captures the "environment" of a session.
+ *
+ * **Intentionally EXCLUDED from signature:**
+ * - `modelId` -- conversation history can be replayed to any compatible model
+ * - `useLiteLLM` / `baseUrl` -- these are routing details, not session identity.
+ *   Both Codex and Claude store their session/thread data locally (in CODEX_HOME
+ *   and CLAUDE_CONFIG_DIR respectively), so the API endpoint doesn't affect persistence.
+ *
+ * **Included in signature:**
+ * - `workspaceRoot` -- defines what files the agent can access
+ * - `additionalDirectories` -- multi-root workspace context
+ * - `agentPackId` -- agent pack isolation (different packs = different sessions)
+ *
+ * This means:
+ * - Switching models mid-conversation: [OK] session resumes
+ * - Switching LiteLLM ↔ direct API: [OK] session resumes (same local storage)
+ * - Changing workspace/folders: [X] new session (different file context)
+ * - Changing agent pack: [X] new session (different pack = different agent)
+ */
+function buildSessionSignatureRaw(options) {
+    return JSON.stringify({
+        // NOTE: modelId, useLiteLLM, baseUrl are NOT included -- sessions persist across these changes
+        workspaceRoot: options.workspaceRoot,
+        additionalDirectories: (0, utils_1.stableAdditionalDirs)(options.additionalDirectories),
+        // AgentPack isolation: different packs get different sessions
+        agentPackId: options.agentPackId ?? 'default',
+    });
+}
+function buildConversationKey(engineId, options) {
+    const rawChatSessionId = options.sessionId?.trim();
+    // Prefer the context session id when provided so the UI can rotate backend memory
+    // without forcing a new VS Code chat UI session.
+    const conversationSessionId = options.contextSessionId?.trim() || rawChatSessionId;
+    const isEphemeral = !conversationSessionId;
+    const effectiveConversationSessionId = conversationSessionId || `ephemeral-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const chatSessionId = rawChatSessionId || effectiveConversationSessionId;
+    // Include agentPackId in session key for logical isolation
+    const agentPackId = options.agentPackId ?? 'default';
+    const signatureRaw = buildSessionSignatureRaw(options);
+    const signatureHash = crypto.createHash('sha256').update(signatureRaw).digest('hex').slice(0, 16);
+    // Key format: engine:chatSession:pack:signature
+    // This ensures different packs get different session keys even with same chatSessionId
+    return {
+        key: `${engineId}:${effectiveConversationSessionId}:${agentPackId}:${signatureHash}`,
+        chatSessionId,
+        isEphemeral,
+        signatureHash,
+        signatureRaw,
+        agentPackId,
+    };
+}
+// -----------------------------------------------------------------------------
+// Conversation Lock
+// -----------------------------------------------------------------------------
+/**
+ * Safety net timeout for a single conversation turn. Agent turns may run for hours, so keep this high.
+ * This is not meant to enforce an SLA only to prevent a permanently stuck lock from blocking forever.
+ */
+exports.DEFAULT_CONVERSATION_LOCK_TIMEOUT_MS = 1000 * 60 * 60 * 48; // 24 hours
+const _conversationLocks = new Map();
+function withConversationLock(key, fn, options) {
+    const prev = _conversationLocks.get(key) ?? Promise.resolve();
+    let release;
+    const gate = new Promise(resolve => {
+        release = resolve;
+    });
+    const current = prev.then(() => gate);
+    _conversationLocks.set(key, current);
+    const label = options?.label ? ` (${options.label})` : '';
+    const timeoutMs = typeof options?.timeoutMs === 'number' ? options.timeoutMs : undefined;
+    const signal = options?.signal;
+    let abortListener;
+    let timeoutHandle;
+    let timedOut = false;
+    const cancelPromise = signal
+        ? new Promise((_, reject) => {
+            if (signal.aborted) {
+                reject(new Error(`[AgentIDE] Cancelled while waiting for conversation lock${label}`));
+                return;
+            }
+            abortListener = () => reject(new Error(`[AgentIDE] Cancelled while waiting for conversation lock${label}`));
+            signal.addEventListener('abort', abortListener, { once: true });
+        })
+        : undefined;
+    const timeoutPromise = timeoutMs && timeoutMs > 0
+        ? new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                timedOut = true;
+                options?.onTimeout?.();
+                reject(new Error(`[AgentIDE] Conversation lock timed out after ${timeoutMs}ms${label}`));
+            }, timeoutMs);
+        })
+        : undefined;
+    const waiters = [prev, cancelPromise, timeoutPromise].filter(Boolean);
+    // Acquire lock (or fail fast on cancel/timeout), then run.
+    // Note: if cancel/timeout happens while `fn` is running, we also reject to unblock the lock.
+    const run = Promise.race(waiters).then(async () => {
+        if (signal?.aborted) {
+            throw new Error(`[AgentIDE] Cancelled before running conversation work${label}`);
+        }
+        if (timedOut) {
+            throw new Error(`[AgentIDE] Conversation lock timed out after ${timeoutMs}ms${label}`);
+        }
+        const work = fn();
+        // Important: do not race execution with cancellation here. Callers should pass the AbortSignal into the
+        // underlying SDK operations and let `fn` exit normally, so we don't release the lock while the SDK is still running.
+        const runners = [work, timeoutPromise].filter(Boolean);
+        return await Promise.race(runners);
+    });
+    return run.finally(() => {
+        try {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            if (signal && abortListener) {
+                signal.removeEventListener('abort', abortListener);
+            }
+        }
+        finally {
+            release();
+            if (_conversationLocks.get(key) === current) {
+                _conversationLocks.delete(key);
+            }
+        }
+    });
+}

package/out/shared/agentEngines.js

@@ -0,0 +1,170 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_ENGINES = void 0;
+exports.getAgentEngine = getAgentEngine;
+exports.getAllAgentEngines = getAllAgentEngines;
+exports.getAllAgentEngineIds = getAllAgentEngineIds;
+exports.getCompatibleProviders = getCompatibleProviders;
+exports.getEnginesCompatibleWithProvider = getEnginesCompatibleWithProvider;
+exports.isEngineCompatibleWithProvider = isEngineCompatibleWithProvider;
+exports.getEngineRulesFile = getEngineRulesFile;
+exports.getEngineWorkspaceDir = getEngineWorkspaceDir;
+const providers_1 = require("./providers");
+/**
+ * Agent Engine registry - single source of truth for all agent engine configurations.
+ */
+exports.AGENT_ENGINES = {
+    codex: {
+        id: 'codex',
+        displayName: 'Codex',
+        description: 'OpenAI Codex - code generation agent',
+        icon: 'sparkle',
+        nativeProvider: 'openai',
+        workspaceDir: '.codex',
+        rulesFile: 'AGENTS.md',
+        configEnvVar: 'CODEX_HOME',
+        managedPaths: ['skills', 'config.toml', 'agentide.runtime.md'],
+    },
+    claude: {
+        id: 'claude',
+        displayName: 'Claude',
+        description: 'Anthropic Claude - agentic coding assistant',
+        icon: 'beaker',
+        nativeProvider: 'anthropic',
+        workspaceDir: '.claude',
+        rulesFile: 'CLAUDE.md',
+        configEnvVar: 'CLAUDE_CONFIG_DIR',
+        // Claude config dir is managed as a whole, no specific files listed
+    },
+};
+// -----------------------------------------------------------------------------
+// Utility Functions
+// -----------------------------------------------------------------------------
+/**
+ * Get an agent engine by ID
+ */
+function getAgentEngine(id) {
+    return exports.AGENT_ENGINES[id];
+}
+/**
+ * Get all agent engines as an array
+ */
+function getAllAgentEngines() {
+    return Object.values(exports.AGENT_ENGINES);
+}
+/**
+ * Get all agent engine IDs
+ */
+function getAllAgentEngineIds() {
+    return Object.keys(exports.AGENT_ENGINES);
+}
+/**
+ * Get compatible providers for an engine.
+ * Compatibility is determined by:
+ * 1. The native provider (always compatible)
+ * 2. Gateway providers (OpenRouter, LiteLLM - they can route to any backend)
+ * 3. Provider type: Codex works with all non-Anthropic, Claude works only with Anthropic
+ */
+function getCompatibleProviders(engineId) {
+    const engine = exports.AGENT_ENGINES[engineId];
+    if (!engine) {
+        return [];
+    }
+    const compatible = [engine.nativeProvider];
+    for (const [providerId, provider] of Object.entries(providers_1.PROVIDERS)) {
+        if (compatible.includes(providerId)) {
+            continue;
+        }
+        // Gateway providers work with all engines
+        if (provider.isGateway) {
+            compatible.push(providerId);
+            continue;
+        }
+        // Codex (OpenAI-based) works with all non-Anthropic-family providers.
+        if (engine.nativeProvider === 'openai' && !(0, providers_1.isAnthropicProviderFamily)(providerId)) {
+            compatible.push(providerId);
+        }
+        // Claude works with Anthropic-family providers.
+        if (engine.nativeProvider === 'anthropic' && (0, providers_1.isAnthropicProviderFamily)(providerId)) {
+            compatible.push(providerId);
+        }
+    }
+    return compatible;
+}
+/**
+ * Get agent engines compatible with a provider.
+ * An engine is compatible if:
+ * 1. The provider is the engine's native provider
+ * 2. The provider is a gateway (can route to any backend)
+ * 3. Provider type: non-Anthropic providers work with Codex
+ */
+function getEnginesCompatibleWithProvider(providerId) {
+    const provider = providers_1.PROVIDERS[providerId];
+    if (!provider) {
+        return [];
+    }
+    // Gateway providers are compatible with all engines
+    if (provider.isGateway) {
+        return Object.values(exports.AGENT_ENGINES);
+    }
+    return Object.values(exports.AGENT_ENGINES).filter(engine => {
+        // Native provider
+        if (engine.nativeProvider === providerId) {
+            return true;
+        }
+        // Non-Anthropic-family providers work with Codex
+        if (engine.nativeProvider === 'openai' && !(0, providers_1.isAnthropicProviderFamily)(providerId)) {
+            return true;
+        }
+        // Anthropic-family providers work with Claude
+        if (engine.nativeProvider === 'anthropic' && (0, providers_1.isAnthropicProviderFamily)(providerId)) {
+            return true;
+        }
+        return false;
+    });
+}
+/**
+ * Check if an engine is compatible with a provider.
+ * Compatibility is determined by:
+ * 1. Native provider (always compatible)
+ * 2. Gateway providers (compatible with all engines)
+ * 3. Provider type: non-Anthropic providers work with Codex
+ */
+function isEngineCompatibleWithProvider(engineId, providerId) {
+    const engine = exports.AGENT_ENGINES[engineId];
+    if (!engine) {
+        return false;
+    }
+    // Native provider is always compatible
+    if (engine.nativeProvider === providerId) {
+        return true;
+    }
+    // Gateway providers are compatible with all engines
+    if ((0, providers_1.isGatewayProvider)(providerId)) {
+        return true;
+    }
+    // Non-Anthropic-family providers work with Codex (OpenAI-based engines)
+    if (engine.nativeProvider === 'openai' && !(0, providers_1.isAnthropicProviderFamily)(providerId)) {
+        return true;
+    }
+    // Anthropic-family providers work with Claude.
+    if (engine.nativeProvider === 'anthropic' && (0, providers_1.isAnthropicProviderFamily)(providerId)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get the rules file for an engine
+ */
+function getEngineRulesFile(engineId) {
+    return exports.AGENT_ENGINES[engineId]?.rulesFile;
+}
+/**
+ * Get the workspace directory for an engine
+ */
+function getEngineWorkspaceDir(engineId) {
+    return exports.AGENT_ENGINES[engineId]?.workspaceDir;
+}

package/out/shared/index.js

@@ -0,0 +1,109 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEngineWorkspaceDir = exports.getEngineRulesFile = exports.isEngineCompatibleWithProvider = exports.getEnginesCompatibleWithProvider = exports.getCompatibleProviders = exports.getAllAgentEngineIds = exports.getAllAgentEngines = exports.getAgentEngine = exports.AGENT_ENGINES = exports.getActiveModels = exports.getModelsWithCapability = exports.getRecommendedModels = exports.getModelsForProvider = exports.getModel = exports.getModelByRegistryKey = exports.isCompositeKey = exports.parseRegistryKey = exports.getRegistryKey = exports.REGISTRY_KEY_SEPARATOR = exports.BUILTIN_MODELS = exports.providerNotSupportAnthropicApi = exports.isAnthropicSetupToken = exports.normalizeAnthropicSetupToken = exports.ANTHROPIC_SETUP_TOKEN_PREFIX = exports.isAnthropicProviderFamily = exports.requiresBaseUrl = exports.getApiKeyProviders = exports.getLocalProviders = exports.getCloudProviders = exports.getAllProviderIds = exports.isLocalProvider = exports.requiresApiKey = exports.getProvider = exports.PROVIDERS = void 0;
+exports.getProviderForModel = getProviderForModel;
+exports.getEngineForModel = getEngineForModel;
+exports.getModelsForEngine = getModelsForEngine;
+exports.isModelFromProvider = isModelFromProvider;
+/**
+ * Shared types for AgentIDE Extension
+ *
+ * ⚠️ KEEP IN SYNC with: src/vs/workbench/contrib/agentide/common/shared/index.ts
+ *
+ * These types are duplicated because VS Code's extension host cannot
+ * import from the workbench. When modifying, update BOTH files.
+ *
+ * This module exports all shared type definitions for providers, models, and agent engines.
+ * These types are runtime-agnostic and can be used in:
+ * - VS Code workbench (main process)
+ * - VS Code extension host (Node.js)
+ * - Headless runtime (Node.js, no Electron)
+ * - Customer SDK (browser or Node.js)
+ */
+// Provider types and registry
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "PROVIDERS", { enumerable: true, get: function () { return providers_1.PROVIDERS; } });
+Object.defineProperty(exports, "getProvider", { enumerable: true, get: function () { return providers_1.getProvider; } });
+Object.defineProperty(exports, "requiresApiKey", { enumerable: true, get: function () { return providers_1.requiresApiKey; } });
+Object.defineProperty(exports, "isLocalProvider", { enumerable: true, get: function () { return providers_1.isLocalProvider; } });
+Object.defineProperty(exports, "getAllProviderIds", { enumerable: true, get: function () { return providers_1.getAllProviderIds; } });
+Object.defineProperty(exports, "getCloudProviders", { enumerable: true, get: function () { return providers_1.getCloudProviders; } });
+Object.defineProperty(exports, "getLocalProviders", { enumerable: true, get: function () { return providers_1.getLocalProviders; } });
+Object.defineProperty(exports, "getApiKeyProviders", { enumerable: true, get: function () { return providers_1.getApiKeyProviders; } });
+Object.defineProperty(exports, "requiresBaseUrl", { enumerable: true, get: function () { return providers_1.requiresBaseUrl; } });
+Object.defineProperty(exports, "isAnthropicProviderFamily", { enumerable: true, get: function () { return providers_1.isAnthropicProviderFamily; } });
+Object.defineProperty(exports, "ANTHROPIC_SETUP_TOKEN_PREFIX", { enumerable: true, get: function () { return providers_1.ANTHROPIC_SETUP_TOKEN_PREFIX; } });
+Object.defineProperty(exports, "normalizeAnthropicSetupToken", { enumerable: true, get: function () { return providers_1.normalizeAnthropicSetupToken; } });
+Object.defineProperty(exports, "isAnthropicSetupToken", { enumerable: true, get: function () { return providers_1.isAnthropicSetupToken; } });
+Object.defineProperty(exports, "providerNotSupportAnthropicApi", { enumerable: true, get: function () { return providers_1.providerNotSupportAnthropicApi; } });
+// Model types and registry
+var models_1 = require("./models");
+Object.defineProperty(exports, "BUILTIN_MODELS", { enumerable: true, get: function () { return models_1.BUILTIN_MODELS; } });
+// Registry key utilities
+Object.defineProperty(exports, "REGISTRY_KEY_SEPARATOR", { enumerable: true, get: function () { return models_1.REGISTRY_KEY_SEPARATOR; } });
+Object.defineProperty(exports, "getRegistryKey", { enumerable: true, get: function () { return models_1.getRegistryKey; } });
+Object.defineProperty(exports, "parseRegistryKey", { enumerable: true, get: function () { return models_1.parseRegistryKey; } });
+Object.defineProperty(exports, "isCompositeKey", { enumerable: true, get: function () { return models_1.isCompositeKey; } });
+Object.defineProperty(exports, "getModelByRegistryKey", { enumerable: true, get: function () { return models_1.getModelByRegistryKey; } });
+// Legacy utilities (deprecated, prefer registry key variants)
+Object.defineProperty(exports, "getModel", { enumerable: true, get: function () { return models_1.getModel; } });
+Object.defineProperty(exports, "getModelsForProvider", { enumerable: true, get: function () { return models_1.getModelsForProvider; } });
+Object.defineProperty(exports, "getRecommendedModels", { enumerable: true, get: function () { return models_1.getRecommendedModels; } });
+Object.defineProperty(exports, "getModelsWithCapability", { enumerable: true, get: function () { return models_1.getModelsWithCapability; } });
+Object.defineProperty(exports, "getActiveModels", { enumerable: true, get: function () { return models_1.getActiveModels; } });
+// Agent Engine types and registry
+var agentEngines_1 = require("./agentEngines");
+Object.defineProperty(exports, "AGENT_ENGINES", { enumerable: true, get: function () { return agentEngines_1.AGENT_ENGINES; } });
+Object.defineProperty(exports, "getAgentEngine", { enumerable: true, get: function () { return agentEngines_1.getAgentEngine; } });
+Object.defineProperty(exports, "getAllAgentEngines", { enumerable: true, get: function () { return agentEngines_1.getAllAgentEngines; } });
+Object.defineProperty(exports, "getAllAgentEngineIds", { enumerable: true, get: function () { return agentEngines_1.getAllAgentEngineIds; } });
+Object.defineProperty(exports, "getCompatibleProviders", { enumerable: true, get: function () { return agentEngines_1.getCompatibleProviders; } });
+Object.defineProperty(exports, "getEnginesCompatibleWithProvider", { enumerable: true, get: function () { return agentEngines_1.getEnginesCompatibleWithProvider; } });
+Object.defineProperty(exports, "isEngineCompatibleWithProvider", { enumerable: true, get: function () { return agentEngines_1.isEngineCompatibleWithProvider; } });
+Object.defineProperty(exports, "getEngineRulesFile", { enumerable: true, get: function () { return agentEngines_1.getEngineRulesFile; } });
+Object.defineProperty(exports, "getEngineWorkspaceDir", { enumerable: true, get: function () { return agentEngines_1.getEngineWorkspaceDir; } });
+// -----------------------------------------------------------------------------
+// Cross-Registry Utility Functions
+// -----------------------------------------------------------------------------
+const providers_2 = require("./providers");
+const models_2 = require("./models");
+const agentEngines_2 = require("./agentEngines");
+/**
+ * Get the provider for a model
+ */
+function getProviderForModel(modelId) {
+    const model = models_2.BUILTIN_MODELS.find(m => m.id === modelId);
+    return model ? providers_2.PROVIDERS[model.provider] : undefined;
+}
+/**
+ * Get the compatible engine for a model.
+ * Uses the model's provider to determine compatibility.
+ */
+function getEngineForModel(modelId) {
+    const model = models_2.BUILTIN_MODELS.find(m => m.id === modelId);
+    if (!model) {
+        return undefined;
+    }
+    return Object.values(agentEngines_2.AGENT_ENGINES).find(engine => (0, agentEngines_2.isEngineCompatibleWithProvider)(engine.id, model.provider));
+}
+/**
+ * Get all models that can be used with a specific engine.
+ * Uses the engine's compatibility logic to filter models.
+ */
+function getModelsForEngine(engineId) {
+    const engine = agentEngines_2.AGENT_ENGINES[engineId];
+    if (!engine) {
+        return [];
+    }
+    return models_2.BUILTIN_MODELS.filter(model => (0, agentEngines_2.isEngineCompatibleWithProvider)(engine.id, model.provider));
+}
+/**
+ * Check if a model is available through a specific provider
+ */
+function isModelFromProvider(modelId, providerId) {
+    const model = models_2.BUILTIN_MODELS.find(m => m.id === modelId);
+    return model?.provider === providerId;
+}