portos-ai-toolkit 0.3.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portos-ai-toolkit",
-  "version": "0.3.0",
+  "version": "0.4.2",
   "description": "Shared AI provider, model, and prompt template patterns for PortOS-style applications",
   "author": "Adam Eivy <adam@eivy.com> (https://atomantic.com)",
   "license": "MIT",

package/src/defaults/providers.sample.json

@@ -0,0 +1,104 @@
+{
+  "activeProvider": "claude-code",
+  "providers": {
+    "claude-code": {
+      "id": "claude-code",
+      "name": "Claude Code CLI",
+      "type": "cli",
+      "command": "claude",
+      "args": ["--print"],
+      "models": ["claude-haiku-4-5-20251001", "claude-sonnet-4-20250514", "claude-opus-4-20250514"],
+      "defaultModel": "claude-sonnet-4-20250514",
+      "lightModel": "claude-haiku-4-5-20251001",
+      "mediumModel": "claude-sonnet-4-20250514",
+      "heavyModel": "claude-opus-4-20250514",
+      "timeout": 300000,
+      "enabled": true,
+      "envVars": {}
+    },
+    "claude-code-bedrock": {
+      "id": "claude-code-bedrock",
+      "name": "Claude Code CLI: Bedrock",
+      "type": "cli",
+      "command": "claude",
+      "args": ["--print"],
+      "models": ["us.anthropic.claude-sonnet-4-5-20250929-v1:0", "global.anthropic.claude-opus-4-5-20251101-v1:0"],
+      "defaultModel": "global.anthropic.claude-opus-4-5-20251101-v1:0",
+      "lightModel": "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+      "mediumModel": "global.anthropic.claude-opus-4-5-20251101-v1:0",
+      "heavyModel": "global.anthropic.claude-opus-4-5-20251101-v1:0",
+      "timeout": 300000,
+      "enabled": false,
+      "envVars": {
+        "CLAUDE_CODE_USE_BEDROCK": "1"
+      }
+    },
+    "codex": {
+      "id": "codex",
+      "name": "Codex CLI",
+      "type": "cli",
+      "command": "codex",
+      "args": [],
+      "models": ["gpt-5.1-codex-mini", "gpt-5.1-codex-max"],
+      "defaultModel": "gpt-5.1-codex-max",
+      "lightModel": "gpt-5.1-codex-mini",
+      "mediumModel": "gpt-5.1-codex-max",
+      "heavyModel": "gpt-5.1-codex-max",
+      "timeout": 300000,
+      "enabled": true,
+      "envVars": {}
+    },
+    "gemini-cli": {
+      "id": "gemini-cli",
+      "name": "Gemini CLI",
+      "type": "cli",
+      "command": "gemini",
+      "args": [],
+      "models": [],
+      "defaultModel": null,
+      "timeout": 300000,
+      "enabled": true,
+      "envVars": {}
+    },
+    "nvidia-kimi": {
+      "id": "nvidia-kimi",
+      "name": "NVIDIA Kimi K2.5",
+      "type": "api",
+      "endpoint": "https://integrate.api.nvidia.com/v1",
+      "apiKey": "",
+      "models": ["moonshotai/kimi-k2-5", "moonshotai/kimi-k2-instruct", "moonshotai/kimi-k2-thinking"],
+      "defaultModel": "moonshotai/kimi-k2-5",
+      "lightModel": "moonshotai/kimi-k2-instruct",
+      "mediumModel": "moonshotai/kimi-k2-5",
+      "heavyModel": "moonshotai/kimi-k2-thinking",
+      "fallbackProvider": null,
+      "timeout": 300000,
+      "enabled": false,
+      "envVars": {}
+    },
+    "lmstudio": {
+      "id": "lmstudio",
+      "name": "LM Studio",
+      "type": "api",
+      "endpoint": "http://localhost:1234/v1",
+      "apiKey": "lm-studio",
+      "models": [],
+      "defaultModel": null,
+      "timeout": 300000,
+      "enabled": false,
+      "envVars": {}
+    },
+    "ollama": {
+      "id": "ollama",
+      "name": "Ollama",
+      "type": "api",
+      "endpoint": "http://localhost:11434/v1",
+      "apiKey": "",
+      "models": [],
+      "defaultModel": null,
+      "timeout": 300000,
+      "enabled": false,
+      "envVars": {}
+    }
+  }
+}

package/src/server/index.js

@@ -11,6 +11,22 @@ import { createProvidersRoutes } from './routes/providers.js';
 import { createRunsRoutes } from './routes/runs.js';
 import { createPromptsRoutes } from './routes/prompts.js';
 import { createProviderStatusRoutes } from './routes/providerStatus.js';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Path to the default providers sample file included with the toolkit.
+ * Use this as the sampleProvidersFile config option to get preconfigured providers:
+ * - claude-code (CLI)
+ * - codex (CLI)
+ * - gemini-cli (CLI)
+ * - nvidia-kimi (API - NVIDIA's free Kimi K2.5 models)
+ * - lmstudio (API)
+ * - ollama (API)
+ */
+export const DEFAULT_PROVIDERS_SAMPLE = join(__dirname, 'defaults/providers.sample.json');
 
 export * from './validation.js';
 export * from './errorDetection.js';
@@ -44,7 +60,7 @@ export function createAIToolkit(config = {}) {
 
     // Provider status config
     enableProviderStatus = true,
-    defaultFallbackPriority = ['claude-code', 'codex', 'lmstudio', 'local-lm-studio', 'ollama', 'gemini-cli']
+    defaultFallbackPriority = ['claude-code', 'codex', 'nvidia-kimi', 'lmstudio', 'ollama', 'gemini-cli']
   } = config;
 
   // Create services

package/src/server/providers.js

@@ -226,25 +226,33 @@ export function createProviderService(config = {}) {
     },
 
     /**
-     * Refresh models from API provider
+     * Refresh models from provider using provider-specific strategies
      */
     async refreshProviderModels(id) {
       const data = await loadProviders();
       const provider = data.providers[id];
 
-      if (!provider || provider.type !== 'api') {
+      if (!provider) {
         return null;
       }
 
-      const modelsUrl = `${provider.endpoint}/models`;
-      const response = await fetch(modelsUrl, {
-        headers: provider.apiKey ? { 'Authorization': `Bearer ${provider.apiKey}` } : {}
-      }).catch(() => null);
+      let models = [];
 
-      if (!response?.ok) return null;
+      try {
+        // Provider-specific refresh strategies
+        if (provider.type === 'api') {
+          models = await this._refreshAPIProviderModels(provider);
+        } else if (provider.type === 'cli') {
+          models = await this._refreshCLIProviderModels(provider);
+        }
+      } catch (error) {
+        console.error(`Failed to refresh models for ${provider.name}:`, error.message);
+        return null;
+      }
 
-      const responseData = await response.json().catch(() => ({ data: [] }));
-      const models = responseData.data?.map(m => m.id) || [];
+      if (!models || models.length === 0) {
+        return null;
+      }
 
       const updatedProvider = {
         ...data.providers[id],
@@ -254,6 +262,128 @@ export function createProviderService(config = {}) {
       data.providers[id] = updatedProvider;
       await saveProviders(data);
       return updatedProvider;
+    },
+
+    /**
+     * Refresh models from API providers
+     * Supports OpenAI-compatible endpoints (OpenAI, LM Studio, etc.)
+     * and Ollama-style endpoints
+     */
+    async _refreshAPIProviderModels(provider) {
+      // Try Ollama format first if endpoint suggests it
+      if (provider.endpoint?.includes('ollama') || provider.endpoint?.includes(':11434')) {
+        const ollamaUrl = `${provider.endpoint}/api/tags`;
+        const response = await fetch(ollamaUrl).catch(() => null);
+
+        if (response?.ok) {
+          const data = await response.json().catch(() => null);
+          if (data?.models) {
+            return data.models.map(m => m.name || m.model);
+          }
+        }
+      }
+
+      // Try OpenAI-compatible format (default)
+      const modelsUrl = `${provider.endpoint}/models`;
+      const headers = {};
+
+      if (provider.apiKey) {
+        headers['Authorization'] = `Bearer ${provider.apiKey}`;
+      }
+
+      const response = await fetch(modelsUrl, { headers }).catch(() => null);
+
+      if (!response?.ok) {
+        throw new Error(`HTTP ${response?.status || 'error'}`);
+      }
+
+      const responseData = await response.json().catch(() => ({ data: [] }));
+
+      // OpenAI format: { data: [{ id: "model-name" }] }
+      if (responseData.data && Array.isArray(responseData.data)) {
+        return responseData.data.map(m => m.id);
+      }
+
+      // Alternative format: { models: ["model-name"] }
+      if (responseData.models && Array.isArray(responseData.models)) {
+        return responseData.models;
+      }
+
+      return [];
+    },
+
+    /**
+     * Refresh models from CLI providers using provider-specific APIs
+     */
+    async _refreshCLIProviderModels(provider) {
+      const providerName = provider.name.toLowerCase();
+
+      // Claude/Anthropic - fetch from Anthropic API
+      if (providerName.includes('claude') || provider.command === 'claude') {
+        return await this._fetchAnthropicModels(provider);
+      }
+
+      // Gemini - fetch from Google AI API
+      if (providerName.includes('gemini') || provider.command === 'gemini') {
+        return await this._fetchGeminiModels(provider);
+      }
+
+      // For other CLI providers, we can't refresh models
+      throw new Error('Model refresh not supported for this CLI provider');
+    },
+
+    /**
+     * Fetch available Claude models from Anthropic API
+     */
+    async _fetchAnthropicModels(provider) {
+      // Check for API key in provider or environment
+      const apiKey = provider.apiKey || process.env.ANTHROPIC_API_KEY;
+
+      if (!apiKey) {
+        throw new Error('Anthropic API key required for model refresh');
+      }
+
+      // Known Claude models as of January 2025
+      // Anthropic doesn't have a public models list endpoint yet
+      return [
+        'claude-opus-4-6',
+        'claude-opus-4',
+        'claude-sonnet-4-6',
+        'claude-sonnet-4',
+        'claude-3-7-sonnet-20250219',
+        'claude-3-5-sonnet-20241022',
+        'claude-3-5-sonnet-20240620',
+        'claude-3-5-haiku-20241022',
+        'claude-3-opus-20240229',
+        'claude-3-sonnet-20240229',
+        'claude-3-haiku-20240307'
+      ];
+    },
+
+    /**
+     * Fetch available Gemini models from Google AI API
+     */
+    async _fetchGeminiModels(provider) {
+      const apiKey = provider.apiKey || process.env.GOOGLE_API_KEY;
+
+      if (!apiKey) {
+        throw new Error('Google API key required for model refresh');
+      }
+
+      const response = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+      ).catch(() => null);
+
+      if (!response?.ok) {
+        throw new Error(`HTTP ${response?.status || 'error'}`);
+      }
+
+      const data = await response.json().catch(() => ({ models: [] }));
+
+      // Filter to only generative models
+      return (data.models || [])
+        .filter(m => m.supportedGenerationMethods?.includes('generateContent'))
+        .map(m => m.name.replace('models/', ''));
     }
   };
 }

package/src/server/runner.js

@@ -188,6 +188,7 @@ export function createRunnerService(config = {}) {
       await writeFile(join(runDir, 'output.txt'), '');
 
       hooks.onRunCreated?.(metadata);
+      console.log(`🤖 AI run [${source}]: ${provider.name}/${metadata.model}`);
 
       const effectiveTimeout = timeout || provider.timeout;