@agenthippo-ai/agenthippo 0.1.0

package/out/shared/models.js

@@ -0,0 +1,235 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTRY_KEY_SEPARATOR = exports.BUILTIN_MODELS = void 0;
+exports.getRegistryKey = getRegistryKey;
+exports.parseRegistryKey = parseRegistryKey;
+exports.isCompositeKey = isCompositeKey;
+exports.getModel = getModel;
+exports.getModelByRegistryKey = getModelByRegistryKey;
+exports.getModelsForProvider = getModelsForProvider;
+exports.getRecommendedModels = getRecommendedModels;
+exports.getModelsWithCapability = getModelsWithCapability;
+exports.getActiveModels = getActiveModels;
+exports.resolveModelAlias = resolveModelAlias;
+/**
+ * Built-in model definitions
+ * These models are available when users configure their API keys
+ */
+exports.BUILTIN_MODELS = [
+    // ===========================================
+    // AgentHippo Managed Gateway
+    // Shown when signed in to AgentHippo account
+    // ===========================================
+    {
+        id: 'ah-auto',
+        name: 'AH-Auto',
+        provider: 'agenthippo',
+        contextWindow: 200000,
+        maxOutputTokens: 8192,
+        capabilities: ['chat', 'vision', 'function-calling', 'code'],
+        description: 'AgentHippo automatically picks the best model for your request',
+        recommended: true,
+    },
+    // ===========================================
+    // OpenAI Models
+    // ===========================================
+    {
+        id: 'gpt-4.1-nano',
+        name: 'GPT-4.1 Nano',
+        provider: 'openai',
+        contextWindow: 128000,
+        maxOutputTokens: 2048,
+        capabilities: ['chat', 'vision', 'function-calling', 'code'],
+        description: 'Lightweight GPT-4.1 option for quick completions',
+    },
+    {
+        id: 'gpt-5.3-codex',
+        name: 'GPT-5.3 Codex (ChatGPT)',
+        provider: 'openai-codex',
+        contextWindow: 256000,
+        maxOutputTokens: 8192,
+        capabilities: ['chat', 'code', 'function-calling'],
+        description: 'Codex model authenticated via ChatGPT OAuth subscription',
+        recommended: true,
+    },
+    // ===========================================
+    // LiteLLM Proxy Models
+    // These route through your LiteLLM deployment
+    // ===========================================
+    {
+        id: 'litellm/gpt-4.1-nano',
+        name: 'LiteLLM GPT-4.1 Nano',
+        provider: 'litellm',
+        contextWindow: 128000,
+        maxOutputTokens: 2048,
+        capabilities: ['chat', 'vision', 'function-calling', 'code'],
+        description: 'GPT-4.1 Nano via LiteLLM proxy',
+    },
+    {
+        id: 'litellm/gpt-5-nano',
+        name: 'LiteLLM GPT-5 Nano',
+        provider: 'litellm',
+        contextWindow: 256000,
+        maxOutputTokens: 8192,
+        capabilities: ['chat', 'vision', 'function-calling', 'code'],
+        description: 'GPT-5 Nano via LiteLLM proxy',
+    },
+    // Claude Models: Claude Code will auto translate models into dated aliases
+    {
+        id: 'claude-sonnet-4-5-20250929',
+        name: 'Claude Sonnet 4.5 (SDK alias)',
+        provider: 'litellm',
+        contextWindow: 200000,
+        maxOutputTokens: 8192,
+        capabilities: ['chat', 'vision', 'artifacts', 'code'],
+        description: 'Compatibility alias used by Claude Agent SDK (maps to Claude 3.5 Sonnet)',
+    },
+    {
+        id: 'claude-haiku-4-5-20251001',
+        name: 'Claude Haiku 4.5 20251001',
+        provider: 'litellm',
+        contextWindow: 200000,
+        maxOutputTokens: 8192,
+        capabilities: ['chat', 'vision', 'artifacts', 'code'],
+        description: 'Compatibility alias used by Claude Agent SDK (maps to Claude 3 Haiku)',
+    },
+];
+// -----------------------------------------------------------------------------
+// Registry Key Functions
+// -----------------------------------------------------------------------------
+/**
+ * Separator used in composite registry keys.
+ * Format: "provider::modelId"
+ */
+exports.REGISTRY_KEY_SEPARATOR = '::';
+/**
+ * Generate a unique registry key for a model.
+ * Format: "provider::modelId" (e.g., "openai::gpt-4o", "litellm::gpt-4o")
+ *
+ * This ensures the same model served by different providers has distinct keys.
+ */
+function getRegistryKey(providerId, modelId) {
+    return `${providerId}${exports.REGISTRY_KEY_SEPARATOR}${modelId}`;
+}
+/**
+ * Parse a registry key into provider and model ID components.
+ * Returns undefined if the key doesn't contain the separator (legacy format).
+ */
+function parseRegistryKey(key) {
+    const separatorIndex = key.indexOf(exports.REGISTRY_KEY_SEPARATOR);
+    if (separatorIndex === -1) {
+        return undefined;
+    }
+    return {
+        providerId: key.substring(0, separatorIndex),
+        modelId: key.substring(separatorIndex + exports.REGISTRY_KEY_SEPARATOR.length)
+    };
+}
+/**
+ * Check if a key is in composite format (contains separator).
+ */
+function isCompositeKey(key) {
+    return key.includes(exports.REGISTRY_KEY_SEPARATOR);
+}
+// -----------------------------------------------------------------------------
+// Utility Functions
+// -----------------------------------------------------------------------------
+/**
+ * Get a model by ID (legacy - searches by model.id only)
+ * @deprecated Use getModelByRegistryKey for unambiguous lookup
+ */
+function getModel(id) {
+    return exports.BUILTIN_MODELS.find(model => model.id === id);
+}
+/**
+ * Get a model by registry key (provider::modelId format)
+ */
+function getModelByRegistryKey(key) {
+    return exports.BUILTIN_MODELS.find(model => getRegistryKey(model.provider, model.id) === key);
+}
+/**
+ * Get all models for a specific provider
+ */
+function getModelsForProvider(providerId) {
+    return exports.BUILTIN_MODELS.filter(model => model.provider === providerId);
+}
+/**
+ * Get recommended models
+ */
+function getRecommendedModels() {
+    return exports.BUILTIN_MODELS.filter(model => model.recommended === true);
+}
+/**
+ * Get models that support a specific capability
+ */
+function getModelsWithCapability(capability) {
+    return exports.BUILTIN_MODELS.filter(model => model.capabilities.includes(capability));
+}
+/**
+ * Get all non-deprecated models
+ */
+function getActiveModels() {
+    return exports.BUILTIN_MODELS.filter(model => !model.deprecated);
+}
+// -----------------------------------------------------------------------------
+// Model Resolution (for CLI)
+// -----------------------------------------------------------------------------
+/**
+ * Common model aliases that users might type.
+ * Maps short names to full SDK-compatible model IDs.
+ */
+const MODEL_ALIASES = {
+    // Claude aliases
+    'claude-sonnet-4': 'claude-sonnet-4-5-20250929',
+    'claude-sonnet': 'claude-sonnet-4-5-20250929',
+    'sonnet': 'claude-sonnet-4-5-20250929',
+    'claude-haiku-4': 'claude-haiku-4-5-20251001',
+    'claude-haiku': 'claude-haiku-4-5-20251001',
+    'haiku': 'claude-haiku-4-5-20251001',
+    'claude-opus-4': 'claude-opus-4-20250514',
+    'claude-opus': 'claude-opus-4-20250514',
+    'opus': 'claude-opus-4-20250514',
+    // OpenAI aliases (these work as-is with SDK, but include for consistency)
+    'gpt-4o': 'gpt-4o',
+    'gpt-4': 'gpt-4o',
+    'o3': 'o3',
+    'o1': 'o1',
+};
+/**
+ * Resolve a model alias to a full model ID.
+ *
+ * Resolution order:
+ * 1. Check if it's an exact match in BUILTIN_MODELS
+ * 2. Check if it's a known alias
+ * 3. Check if any model ID starts with the input (prefix match)
+ * 4. Return as-is (let SDK handle it)
+ *
+ * @param input - User-provided model name (e.g., 'claude-sonnet-4', 'sonnet')
+ * @returns Resolved model ID suitable for SDK
+ */
+function resolveModelAlias(input) {
+    if (!input) {
+        return input;
+    }
+    const normalized = input.toLowerCase().trim();
+    // 1. Exact match in BUILTIN_MODELS
+    const exactMatch = exports.BUILTIN_MODELS.find(m => m.id.toLowerCase() === normalized);
+    if (exactMatch) {
+        return exactMatch.id;
+    }
+    // 2. Known alias
+    const aliasMatch = MODEL_ALIASES[normalized];
+    if (aliasMatch) {
+        return aliasMatch;
+    }
+    // 3. Prefix match (e.g., 'claude-sonnet-4' matches 'claude-sonnet-4-5-20250929')
+    const prefixMatch = exports.BUILTIN_MODELS.find(m => m.id.toLowerCase().startsWith(normalized));
+    if (prefixMatch) {
+        return prefixMatch.id;
+    }
+    // 4. Return as-is
+    return input;
+}

package/out/shared/providers.js

@@ -0,0 +1,202 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANTHROPIC_SETUP_TOKEN_PREFIX = exports.PROVIDERS = void 0;
+exports.getProvider = getProvider;
+exports.requiresApiKey = requiresApiKey;
+exports.isLocalProvider = isLocalProvider;
+exports.getAllProviderIds = getAllProviderIds;
+exports.getCloudProviders = getCloudProviders;
+exports.getLocalProviders = getLocalProviders;
+exports.getApiKeyProviders = getApiKeyProviders;
+exports.requiresBaseUrl = requiresBaseUrl;
+exports.getGatewayProviders = getGatewayProviders;
+exports.isGatewayProvider = isGatewayProvider;
+exports.isAnthropicProviderFamily = isAnthropicProviderFamily;
+exports.normalizeAnthropicSetupToken = normalizeAnthropicSetupToken;
+exports.isAnthropicSetupToken = isAnthropicSetupToken;
+exports.providerNotSupportAnthropicApi = providerNotSupportAnthropicApi;
+/**
+ * Provider registry - single source of truth for all provider configurations
+ */
+exports.PROVIDERS = {
+    openai: {
+        id: 'openai',
+        displayName: 'OpenAI',
+        defaultEndpoint: 'https://api.openai.com/v1',
+        requiresApiKey: true,
+        showInAddApiKeyUI: true,
+        notSupportAnthropicApi: true, // OpenAI API doesn't support Anthropic models
+    },
+    'openai-codex': {
+        id: 'openai-codex',
+        displayName: 'OpenAI Codex (ChatGPT OAuth)',
+        defaultEndpoint: 'https://chatgpt.com/backend-api/codex',
+        requiresApiKey: true,
+        description: 'Use your ChatGPT/Codex subscription via native OAuth',
+        showInAddApiKeyUI: true,
+        notSupportAnthropicApi: true,
+    },
+    anthropic: {
+        id: 'anthropic',
+        displayName: 'Anthropic',
+        defaultEndpoint: 'https://api.anthropic.com/v1',
+        endpointSettingKey: 'agentide.providers.anthropic.baseUrl',
+        requiresApiKey: true,
+        apiKeyHeader: 'x-api-key',
+        staticHeaders: { 'anthropic-version': '2023-06-01' },
+        headerSettingKeys: { 'anthropic-version': 'agentide.providers.anthropic.version' },
+        showInAddApiKeyUI: true,
+    },
+    'anthropic-setup-token': {
+        id: 'anthropic-setup-token',
+        displayName: 'Anthropic (Claude Subscription)',
+        defaultEndpoint: 'https://api.anthropic.com/v1',
+        endpointSettingKey: 'agentide.providers.anthropic.baseUrl',
+        requiresApiKey: true,
+        apiKeyHeader: 'x-api-key',
+        staticHeaders: { 'anthropic-version': '2023-06-01' },
+        headerSettingKeys: { 'anthropic-version': 'agentide.providers.anthropic.version' },
+        description: 'Use Claude subscription setup-token from "claude setup-token"',
+        showInAddApiKeyUI: true,
+    },
+    openrouter: {
+        id: 'openrouter',
+        displayName: 'OpenRouter',
+        defaultEndpoint: 'https://openrouter.ai/api/v1',
+        requiresApiKey: true,
+        description: 'Fast model proxy via openrouter.ai that works with all agents',
+        showInAddApiKeyUI: true,
+        isGateway: true, // Can route to OpenAI, Anthropic, and other backends
+    },
+    litellm: {
+        id: 'litellm',
+        displayName: 'LiteLLM (Recommended)',
+        endpointSettingKey: 'agentide.providers.litellm.baseUrl',
+        requiresApiKey: true,
+        description: 'local adapter for agents to work with Spotlight and all models from OpenAI, Anthropic, Ollama etc.',
+        showInAddApiKeyUI: true,
+        isGateway: true, // Can route to any backend
+    },
+    ollama: {
+        id: 'ollama',
+        displayName: 'Ollama',
+        defaultEndpoint: 'http://localhost:11434/v1',
+        requiresApiKey: false,
+        enabledSettingKey: 'agentide.local.ollama.enabled',
+        defaultEnabled: true,
+        placeholderApiKey: 'ollama',
+        description: 'Local LLM server',
+        showInAddApiKeyUI: false,
+        notSupportAnthropicApi: true, // Ollama only supports OpenAI-compatible format
+    },
+    agenthippo: {
+        id: 'agenthippo',
+        displayName: 'AgentHippo Gateway',
+        defaultEndpoint: 'https://api.agenthippo.ai/v1',
+        endpointSettingKey: 'agentide.AgentHippoModelGateway.url',
+        requiresApiKey: true,
+        description: 'AgentHippo managed gateway — uses account JWT, picks model automatically',
+        showInAddApiKeyUI: false,
+        isGateway: true,
+        staticHeaders: { 'x-agenthippo-source': 'chat-ui' },
+    },
+};
+// -----------------------------------------------------------------------------
+// Utility Functions
+// -----------------------------------------------------------------------------
+/**
+ * Get a provider definition by ID
+ */
+function getProvider(id) {
+    return exports.PROVIDERS[id];
+}
+/**
+ * Check if a provider requires an API key
+ */
+function requiresApiKey(providerId) {
+    return exports.PROVIDERS[providerId]?.requiresApiKey ?? true;
+}
+/**
+ * Check if a provider is a local provider (doesn't require API key)
+ */
+function isLocalProvider(providerId) {
+    const provider = exports.PROVIDERS[providerId];
+    return provider ? !provider.requiresApiKey : false;
+}
+/**
+ * Get all provider IDs
+ */
+function getAllProviderIds() {
+    return Object.keys(exports.PROVIDERS);
+}
+/**
+ * Get all cloud providers (those requiring API keys)
+ */
+function getCloudProviders() {
+    return Object.values(exports.PROVIDERS).filter(p => p.requiresApiKey);
+}
+/**
+ * Get all local providers (those not requiring API keys)
+ */
+function getLocalProviders() {
+    return Object.values(exports.PROVIDERS).filter(p => !p.requiresApiKey);
+}
+/**
+ * Get providers that should be shown in the "Add API Key" UI
+ */
+function getApiKeyProviders() {
+    return Object.values(exports.PROVIDERS).filter(p => p.showInAddApiKeyUI === true);
+}
+/**
+ * Check if a provider requires a base URL to be configured
+ * (i.e., has endpointSettingKey but no defaultEndpoint)
+ */
+function requiresBaseUrl(providerId) {
+    const provider = exports.PROVIDERS[providerId];
+    return provider ? (!!provider.endpointSettingKey && !provider.defaultEndpoint) : false;
+}
+/**
+ * Get all gateway providers (those that can route to multiple backends)
+ */
+function getGatewayProviders() {
+    return Object.values(exports.PROVIDERS).filter(p => p.isGateway);
+}
+/**
+ * Check if a provider is a gateway
+ */
+function isGatewayProvider(providerId) {
+    return exports.PROVIDERS[providerId]?.isGateway ?? false;
+}
+/**
+ * Check if a provider belongs to the Anthropic provider family.
+ */
+function isAnthropicProviderFamily(providerId) {
+    return providerId === 'anthropic' || providerId === 'anthropic-setup-token';
+}
+exports.ANTHROPIC_SETUP_TOKEN_PREFIX = 'sk-ant-oat01-';
+function normalizeAnthropicSetupToken(token) {
+    return token.replace(/\s+/g, '').trim();
+}
+function isAnthropicSetupToken(apiKey) {
+    return typeof apiKey === 'string' && apiKey.trim().startsWith(exports.ANTHROPIC_SETUP_TOKEN_PREFIX);
+}
+/**
+ * Check if a provider does NOT support Anthropic API format.
+ * Returns true for providers like OpenAI, Ollama that only speak OpenAI format.
+ * Returns false for gateways and providers that can route to Anthropic.
+ *
+ * @param providerId - The provider ID to check
+ * @param customProviders - Optional custom provider config (for checking user-defined providers)
+ */
+function providerNotSupportAnthropicApi(providerId, customProviders) {
+    // Check built-in providers first
+    const builtIn = exports.PROVIDERS[providerId];
+    if (builtIn) {
+        return builtIn.notSupportAnthropicApi ?? false;
+    }
+    // Check custom providers (default to false - most custom providers are gateways)
+    return customProviders?.[providerId]?.notSupportAnthropicApi === true;
+}

package/out/skills/publish.js

@@ -0,0 +1,178 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------------------------
+ *  Skill validation and file collection for publishing.
+ *  Publishing uses the central store via publishToStore() in store/index.ts.
+ *--------------------------------------------------------------------------------------------*/
+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.parseSkillFrontmatter = parseSkillFrontmatter;
+exports.validateSkillForPublish = validateSkillForPublish;
+exports.collectSkillFiles = collectSkillFiles;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const utils_1 = require("../utils");
+// -----------------------------------------------------------------------------
+// Validation
+// -----------------------------------------------------------------------------
+/**
+ * Parse SKILL.md frontmatter to extract metadata.
+ */
+function parseSkillFrontmatter(content) {
+    // Match YAML frontmatter between --- markers
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match) {
+        return null;
+    }
+    const frontmatter = match[1];
+    const metadata = { name: '' };
+    // Simple YAML parsing (name: value)
+    const lines = frontmatter.split('\n');
+    for (const line of lines) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1) {
+            continue;
+        }
+        const key = line.slice(0, colonIdx).trim();
+        let value = line.slice(colonIdx + 1).trim();
+        // Remove quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith('\'') && value.endsWith('\''))) {
+            value = value.slice(1, -1);
+        }
+        switch (key) {
+            case 'name':
+                metadata.name = value;
+                break;
+            case 'version':
+                metadata.version = value;
+                break;
+            case 'description':
+                metadata.description = value;
+                break;
+            case 'author':
+                metadata.author = value;
+                break;
+            case 'tags':
+                // Parse array: [tag1, tag2] or - tag1 format
+                if (value.startsWith('[')) {
+                    metadata.tags = value.slice(1, -1).split(',').map(t => t.trim());
+                }
+                break;
+            case 'requires':
+                if (value.startsWith('[')) {
+                    metadata.requires = value.slice(1, -1).split(',').map(t => t.trim());
+                }
+                break;
+        }
+    }
+    // Only name is required, version is optional
+    return metadata.name ? metadata : null;
+}
+/**
+ * Validate a skill before publishing.
+ */
+async function validateSkillForPublish(skillDir) {
+    const errors = [];
+    const warnings = [];
+    // Check skill directory exists
+    if (!(await (0, utils_1.pathExists)(skillDir))) {
+        return { valid: false, errors: [`Skill directory not found: ${skillDir}`], warnings };
+    }
+    // Check SKILL.md exists
+    const skillMdPath = path.join(skillDir, 'SKILL.md');
+    if (!(await (0, utils_1.pathExists)(skillMdPath))) {
+        errors.push('Missing required file: SKILL.md');
+        return { valid: false, errors, warnings };
+    }
+    // Parse and validate frontmatter
+    const content = await fs_1.promises.readFile(skillMdPath, 'utf-8');
+    const metadata = parseSkillFrontmatter(content);
+    if (!metadata) {
+        errors.push('SKILL.md must have YAML frontmatter with name and version');
+        return { valid: false, errors, warnings };
+    }
+    if (!metadata.name) {
+        errors.push('SKILL.md frontmatter missing: name');
+    }
+    if (!metadata.description) {
+        errors.push('SKILL.md frontmatter missing: description');
+    }
+    // Version is optional, but if provided must be valid semver
+    if (metadata.version && !/^\d+\.\d+\.\d+/.test(metadata.version)) {
+        errors.push(`Invalid version format: ${metadata.version}. Use semver (e.g., 1.0.0)`);
+    }
+    if (!metadata.tags || metadata.tags.length === 0) {
+        warnings.push('Consider adding tags to SKILL.md frontmatter for discoverability');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        metadata: errors.length === 0 ? metadata : undefined,
+    };
+}
+// -----------------------------------------------------------------------------
+// Publishing
+// -----------------------------------------------------------------------------
+/**
+ * Collect all files from a skill directory.
+ */
+async function collectSkillFiles(skillDir) {
+    const files = [];
+    async function walk(dir, prefix) {
+        const entries = await fs_1.promises.readdir(dir);
+        for (const entry of entries) {
+            // Skip hidden files
+            if (entry.startsWith('.')) {
+                continue;
+            }
+            const fullPath = path.join(dir, entry);
+            const relativePath = prefix ? `${prefix}/${entry}` : entry;
+            const stat = await fs_1.promises.stat(fullPath);
+            if (stat.isDirectory()) {
+                await walk(fullPath, relativePath);
+            }
+            else if (stat.isFile()) {
+                const content = await fs_1.promises.readFile(fullPath, 'utf-8');
+                files.push({ path: relativePath, content });
+            }
+        }
+    }
+    await walk(skillDir, '');
+    return files;
+}