feat(kbot): integrate specialist preferred provider routing for local hermes

Author: Your Name

packages/kbot/src/agent.ts

@@ -15,6 +15,7 @@ import {
   estimateCost, isLocalProvider, warmOllamaModelCache,
   routeModelForTask, anthropicThinkingConfig, resolveModelAlias,
   anthropicRefusalFallback, dataRetentionNotice, modelRequiresDataRetention,
+  isProviderConfigured, isProviderReachable, getProviderKey,
   type ByokProvider,
 } from './auth.js'
 import {
@@ -33,6 +34,7 @@ import {
 } from './tool-pipeline.js'
 import { formatContextForPrompt, type ProjectContext } from './context.js'
 import { getMatrixSystemPrompt, listAgents, createAgent, type MatrixAgent } from './matrix.js'
+import { getPreferredProvider } from './agents/specialists.js'
 import {
   buildLearningContext, buildFullLearningContext, findPattern, recordPattern, recordPatternFailure,
   cacheSolution, updateProfile, classifyTask, extractKeywords,
@@ -1173,6 +1175,17 @@ export async function runAgent(
     }
   }
 
+  // Step 1.75: Specialist preferred provider routing (NousResearch/Hermes Agent Integration, Phase 2)
+  if (options.agent) {
+    const preferred = getPreferredProvider(options.agent)
+    if (preferred && isProviderConfigured(preferred) && await isProviderReachable(preferred)) {
+      byokProvider = preferred
+      apiKey = getProviderKey(preferred)
+      isLocal = isLocalProvider(preferred)
+      ui.onInfo(`[routing] specialist ${options.agent} routed to preferred provider: ${preferred}`)
+    }
+  }
+
   const tier = options.tier || 'free'
 
   // Ensure lazy tools are loaded before building the tool list for the API.
@@ -1196,7 +1209,7 @@ export async function runAgent(
   }
 
   // OpenAI-compatible APIs cap at 128 tools per request
-  const providerConfig = getProvider(getByokProvider())
+  const providerConfig = getProvider(byokProvider)
   if (providerConfig.apiStyle === 'openai' && tools.length > 128) {
     // Prioritize core tools, then fill remaining slots
     const core = tools.filter(t => CORE_TOOLS.has(t.name))

packages/kbot/src/auth.test.ts

@@ -1,4 +1,3 @@
-// kbot Auth Tests
 import { describe, it, expect, afterEach } from 'vitest'
 import {
   detectProvider,
@@ -16,6 +15,9 @@ import {
   anthropicRefusalFallback,
   modelRequiresDataRetention,
   dataRetentionNotice,
+  isProviderConfigured,
+  isProviderReachable,
+  getProviderKey,
   PROVIDERS,
 } from './auth.js'
 
@@ -322,4 +324,21 @@ describe('Anthropic model capabilities', () => {
       expect(models).not.toContain('claude-mythos-1')
     })
   })
+
+  describe('Provider Configuration and Reachability', () => {
+    it('detects keyless providers as configured', () => {
+      expect(isProviderConfigured('ollama')).toBe(true)
+      expect(isProviderConfigured('hermes')).toBe(true)
+    })
+
+    it('returns local API keys correctly', () => {
+      expect(getProviderKey('ollama')).toBe('local')
+      expect(getProviderKey('hermes')).toBe('local')
+    })
+
+    it('identifies non-local cloud providers as reachable by default', async () => {
+      const reachable = await isProviderReachable('openai')
+      expect(reachable).toBe(true)
+    })
+  })
 })

packages/kbot/src/auth.ts

@@ -497,6 +497,51 @@ export function isKeylessProvider(provider: ByokProvider): boolean {
   return provider === 'ollama' || provider === 'lmstudio' || provider === 'jan' || provider === 'embedded' || provider === 'llada' || provider === 'hermes'
 }
 
+/** Check if a provider is configured (either keyless, or has an API key/token available) */
+export function isProviderConfigured(provider: ByokProvider): boolean {
+  if (isKeylessProvider(provider)) return true
+  const config = loadConfig()
+  if (config?.byok_provider === provider && config?.byok_key) return true
+  const envKey = ENV_KEYS.find(k => k.provider === provider)?.env
+  if (envKey && process.env[envKey]) return true
+  return false
+}
+
+/** Check if a provider is reachable (local servers only; cloud is assumed true) */
+export async function isProviderReachable(provider: ByokProvider): Promise<boolean> {
+  if (!isLocalProvider(provider)) return true
+  const p = PROVIDERS[provider]
+  try {
+    const url = new URL(p.apiUrl)
+    const res = await fetch(`${url.protocol}//${url.host}`, {
+      method: 'GET',
+      signal: AbortSignal.timeout(500),
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Get the API key/token for a specific provider */
+export function getProviderKey(provider: ByokProvider): string | null {
+  if (isKeylessProvider(provider)) return 'local'
+  const config = loadConfig()
+  if (config?.byok_provider === provider && config?.byok_key) {
+    return config.byok_key
+  }
+  const envKey = ENV_KEYS.find(k => k.provider === provider)?.env
+  if (envKey) {
+    const val = process.env[envKey]
+    if (val) return val
+  }
+  // Fallback: if the global key matches the requested provider style, reuse it
+  if (config?.byok_key && detectProvider(config.byok_key) === provider) {
+    return config.byok_key
+  }
+  return null
+}
+
 /** Check if BYOK mode is enabled (via env var or config) */
 export function isByokEnabled(): boolean {
   // Local providers always work without keys