portos-ai-toolkit 0.4.2 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portos-ai-toolkit",
-  "version": "0.4.2",
+  "version": "0.6.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/client/pages/AIProviders.jsx

@@ -541,7 +541,7 @@ function ProviderForm({ provider, onClose, onSave, api, colorPrefix = 'app' }) {
                 type="text"
                 value={formData.defaultModel}
                 onChange={(e) => setFormData(prev => ({ ...prev, defaultModel: e.target.value }))}
-                placeholder="claude-sonnet-4-20250514"
+                placeholder="claude-sonnet-4-6"
                 className={`w-full px-3 py-2 bg-${colorPrefix}-bg border border-${colorPrefix}-border rounded-lg text-white focus:border-${colorPrefix}-accent focus:outline-none`}
               />
             )}

package/src/defaults/providers.sample.json

@@ -7,14 +7,15 @@
       "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",
+      "models": ["claude-haiku-4-5", "claude-sonnet-4-6", "claude-opus-4-6"],
+      "defaultModel": "claude-sonnet-4-6",
+      "lightModel": "claude-haiku-4-5",
+      "mediumModel": "claude-sonnet-4-6",
+      "heavyModel": "claude-opus-4-6",
       "timeout": 300000,
       "enabled": true,
-      "envVars": {}
+      "envVars": {},
+      "secretEnvVars": []
     },
     "claude-code-bedrock": {
       "id": "claude-code-bedrock",
@@ -22,16 +23,18 @@
       "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",
+      "models": ["us.anthropic.claude-sonnet-4-5-20250929-v1:0", "global.anthropic.claude-opus-4-5-20251101-v1:0", "us.anthropic.claude-opus-4-6-v1:0"],
+      "defaultModel": "us.anthropic.claude-opus-4-6-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",
+      "heavyModel": "us.anthropic.claude-opus-4-6-v1:0",
       "timeout": 300000,
       "enabled": false,
       "envVars": {
-        "CLAUDE_CODE_USE_BEDROCK": "1"
-      }
+        "CLAUDE_CODE_USE_BEDROCK": "1",
+        "AWS_BEARER_TOKEN_BEDROCK": ""
+      },
+      "secretEnvVars": ["AWS_BEARER_TOKEN_BEDROCK"]
     },
     "codex": {
       "id": "codex",
@@ -46,7 +49,8 @@
       "heavyModel": "gpt-5.1-codex-max",
       "timeout": 300000,
       "enabled": true,
-      "envVars": {}
+      "envVars": {},
+      "secretEnvVars": []
     },
     "gemini-cli": {
       "id": "gemini-cli",
@@ -58,7 +62,8 @@
       "defaultModel": null,
       "timeout": 300000,
       "enabled": true,
-      "envVars": {}
+      "envVars": {},
+      "secretEnvVars": []
     },
     "nvidia-kimi": {
       "id": "nvidia-kimi",
@@ -74,7 +79,8 @@
       "fallbackProvider": null,
       "timeout": 300000,
       "enabled": false,
-      "envVars": {}
+      "envVars": {},
+      "secretEnvVars": []
     },
     "lmstudio": {
       "id": "lmstudio",
@@ -86,7 +92,8 @@
       "defaultModel": null,
       "timeout": 300000,
       "enabled": false,
-      "envVars": {}
+      "envVars": {},
+      "secretEnvVars": []
     },
     "ollama": {
       "id": "ollama",
@@ -98,7 +105,8 @@
       "defaultModel": null,
       "timeout": 300000,
       "enabled": false,
-      "envVars": {}
+      "envVars": {},
+      "secretEnvVars": []
     }
   }
 }

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);
 
 /**
@@ -117,7 +121,8 @@ export function createProviderService(config = {}) {
         fallbackProvider: providerData.fallbackProvider || null,
         timeout: providerData.timeout || 300000,
         enabled: providerData.enabled !== false,
-        envVars: providerData.envVars || {}
+        envVars: providerData.envVars || {},
+        secretEnvVars: providerData.secretEnvVars || []
       };
 
       data.providers[id] = provider;
@@ -384,6 +389,33 @@ export function createProviderService(config = {}) {
       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/validation.js

@@ -14,7 +14,8 @@ export const providerSchema = z.object({
   defaultModel: z.string().nullable().optional(),
   timeout: z.number().int().min(1000).max(600000).optional(),
   enabled: z.boolean().optional(),
-  envVars: z.record(z.string()).optional()
+  envVars: z.record(z.string()).optional(),
+  secretEnvVars: z.array(z.string()).optional()
 });
 
 /**