portos-ai-toolkit 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portos-ai-toolkit",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "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

@@ -16,6 +16,23 @@
       "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",

package/src/server/index.d.ts

@@ -12,6 +12,7 @@ export interface ProviderService {
   deleteProvider(id: string): Promise<boolean>;
   testProvider(id: string): Promise<{ success: boolean; [key: string]: any }>;
   refreshProviderModels(id: string): Promise<any | null>;
+  getSampleProviders(): Promise<any[]>;
 }
 
 export interface RunnerService {

package/src/server/providers.js

@@ -1,9 +1,13 @@
 import { readFile, writeFile, mkdir } from 'fs/promises';
 import { existsSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_SAMPLE_PATH = join(__dirname, '../defaults/providers.sample.json');
+
 const execAsync = promisify(exec);
 
 /**
@@ -226,25 +230,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 +266,155 @@ 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/', ''));
+    },
+
+    /**
+     * Get sample providers not yet in user's configuration.
+     * Reads toolkit's built-in defaults and overlays with host app's sample file.
+     */
+    async getSampleProviders() {
+      const data = await loadProviders();
+      const existingIds = new Set(Object.keys(data.providers));
+
+      // Read toolkit's built-in sample
+      let sampleProviders = {};
+      if (existsSync(DEFAULT_SAMPLE_PATH)) {
+        const content = await readFile(DEFAULT_SAMPLE_PATH, 'utf-8');
+        const parsed = JSON.parse(content);
+        sampleProviders = { ...parsed.providers };
+      }
+
+      // Overlay with host app's sample (takes precedence)
+      if (sampleFile && existsSync(sampleFile)) {
+        const content = await readFile(sampleFile, 'utf-8');
+        const parsed = JSON.parse(content);
+        sampleProviders = { ...sampleProviders, ...parsed.providers };
+      }
+
+      // Filter out providers already in user's config
+      return Object.values(sampleProviders).filter(p => !existingIds.has(p.id));
     }
   };
 }

package/src/server/providers.test.js

@@ -117,4 +117,75 @@ describe('Provider Service', () => {
       })
     ).rejects.toThrow('Provider with this ID already exists');
   });
+
+  describe('getSampleProviders', () => {
+    it('should return sample providers from default sample file', async () => {
+      // No providers created yet — all samples should be returned
+      const samples = await providerService.getSampleProviders();
+      expect(Array.isArray(samples)).toBe(true);
+      expect(samples.length).toBeGreaterThan(0);
+      // Should include claude-code-bedrock from the default sample
+      const bedrock = samples.find(p => p.id === 'claude-code-bedrock');
+      expect(bedrock).toBeDefined();
+      expect(bedrock.name).toBe('Claude Code CLI: Bedrock');
+    });
+
+    it('should exclude providers already in user config', async () => {
+      // Create a provider with an ID that matches a sample
+      await providerService.createProvider({
+        id: 'claude-code',
+        name: 'Claude Code CLI',
+        type: 'cli',
+        command: 'claude'
+      });
+
+      const samples = await providerService.getSampleProviders();
+      const claudeCode = samples.find(p => p.id === 'claude-code');
+      expect(claudeCode).toBeUndefined();
+    });
+
+    it('should overlay host app sample over toolkit defaults', async () => {
+      // Pre-create providers.json with one existing provider so loadProviders
+      // doesn't bootstrap from sampleFile
+      const providersPath = join(TEST_DATA_DIR, 'providers-overlay.json');
+      await writeFile(providersPath, JSON.stringify({
+        activeProvider: 'existing',
+        providers: {
+          existing: { id: 'existing', name: 'Existing', type: 'cli', command: 'test' }
+        }
+      }));
+
+      // Create a host app sample with a unique provider
+      const samplePath = join(TEST_DATA_DIR, 'custom-sample.json');
+      await writeFile(samplePath, JSON.stringify({
+        activeProvider: 'custom-cli',
+        providers: {
+          'custom-cli': {
+            id: 'custom-cli',
+            name: 'Custom CLI',
+            type: 'cli',
+            command: 'custom',
+            args: [],
+            models: [],
+            timeout: 300000,
+            enabled: true
+          }
+        }
+      }));
+
+      const serviceWithSample = createProviderService({
+        dataDir: TEST_DATA_DIR,
+        providersFile: 'providers-overlay.json',
+        sampleFile: samplePath
+      });
+
+      const samples = await serviceWithSample.getSampleProviders();
+      const custom = samples.find(p => p.id === 'custom-cli');
+      expect(custom).toBeDefined();
+      expect(custom.name).toBe('Custom CLI');
+      // 'existing' should NOT appear (already in user's config)
+      const existing = samples.find(p => p.id === 'existing');
+      expect(existing).toBeUndefined();
+    });
+  });
 });

package/src/server/routes/providers.js

@@ -35,6 +35,12 @@ export function createProvidersRoutes(providerService, options = {}) {
     res.json(provider);
   }));
 
+  // GET /providers/samples - Get sample providers not yet in user's config
+  router.get('/samples', asyncHandler(async (req, res) => {
+    const providers = await providerService.getSampleProviders();
+    res.json({ providers });
+  }));
+
   // GET /providers/:id - Get provider by ID
   router.get('/:id', asyncHandler(async (req, res) => {
     const provider = await providerService.getProviderById(req.params.id);

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;