@miphamai/cli 0.36.1 → 0.36.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.36.1",
+  "version": "0.36.2",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/core/engine.ts

@@ -446,13 +446,12 @@ export class QueryEngine {
 
     // Stream model response
     try {
-      for await (const chunk of this.registry.chat({
-        model: this.registry.getActiveModel(),
+      for await (const chunk of this.chatWithFallback(
         messages,
         systemPrompt,
-        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        toolDefs.length > 0 ? toolDefs : undefined,
         signal,
-      })) {
+      )) {
         yield chunk
 
         if (chunk.type === 'error') {
@@ -1144,6 +1143,80 @@ export class QueryEngine {
     return this.registry
   }
 
+  /**
+   * Stream a chat response with graceful provider fallback (v2.1.229 alignment).
+   *
+   * On a connection/availability failure from the active provider (thrown
+   * network error or an error chunk), switches to the configured default
+   * provider and retries once, yielding a `warning` chunk so the UI can tell
+   * the user the provider degraded. Abort errors propagate untouched.
+   */
+  private async *chatWithFallback(
+    messages: import('../shared/types').Message[],
+    systemPrompt: string,
+    toolDefs: Record<string, unknown>[] | undefined,
+    signal?: AbortSignal,
+  ): AsyncGenerator<StreamChunk> {
+    const activeId = this.registry.getActive().config.id
+    const defaultId = this.registry.getDefaultProviderId()
+
+    // ── Attempt 1: active provider ──
+    let failure: string | null = null
+    try {
+      for await (const chunk of this.registry.chat({
+        model: this.registry.getActiveModel(),
+        messages,
+        systemPrompt,
+        tools: toolDefs,
+        signal,
+      })) {
+        if (chunk.type === 'error') {
+          failure = chunk.error ?? 'Unknown error'
+          break
+        }
+        yield chunk
+      }
+      if (failure === null) return
+    } catch (err) {
+      if (isAbortError(err)) throw err
+      failure = String(err)
+    }
+
+    // ── Fallback: configured default provider, once ──
+    if (!defaultId || defaultId === activeId || !this.registry.get(defaultId)) {
+      yield { type: 'error', error: failure }
+      return
+    }
+    const fallbackModel = this.registry
+      .get(defaultId)!
+      .config.models.find((m) => m.status === 'active')?.id
+    if (!fallbackModel) {
+      yield { type: 'error', error: failure }
+      return
+    }
+
+    this.registry.switchProvider(defaultId, fallbackModel)
+    yield {
+      type: 'warning',
+      content: `${activeId} unreachable — degraded to ${defaultId} (${fallbackModel})`,
+    }
+
+    try {
+      for await (const chunk of this.registry.chat({
+        model: fallbackModel,
+        messages,
+        systemPrompt,
+        tools: toolDefs,
+        signal,
+      })) {
+        yield chunk
+      }
+    } catch (err) {
+      if (isAbortError(err)) throw err
+      yield { type: 'error', error: String(err) }
+    }
+  }
+
   getTools(): Map<string, ToolDefinition> {
     return this.tools
   }

package/src/providers/openai-compat.ts

@@ -8,9 +8,13 @@ export class OpenAICompatProvider implements ProviderInstance {
   constructor(public config: ProviderConfig) {}
 
   async *chat(req: ChatRequest): AsyncGenerator<StreamChunk> {
-    // Accept both baseUrl and baseURL (common YAML typo)
+    // Accept both baseUrl and baseURL (common YAML typo); resolve env templates
     const rawBase = (this.config as any).baseUrl || (this.config as any).baseURL
-    const baseUrl = rawBase?.replace(/\/+$/, '') || 'https://api.openai.com/v1'
+    const baseUrl =
+      this.resolveEnvTemplate(
+        rawBase?.replace(/\/+$/, '') || '',
+        'OpenAI-compatible provider: baseUrl',
+      ) || 'https://api.openai.com/v1'
     const apiKey = this.resolveApiKey(this.config.apiKey)
 
     const body = {
@@ -224,11 +228,18 @@ export class OpenAICompatProvider implements ProviderInstance {
   async healthCheck(): Promise<boolean> {
     try {
       const rawBase = (this.config as any).baseUrl || (this.config as any).baseURL
-      const baseUrl = rawBase?.replace(/\/+$/, '') || 'https://api.openai.com/v1'
+      const baseUrl =
+        this.resolveEnvTemplate(
+          rawBase?.replace(/\/+$/, '') || '',
+          'OpenAI-compatible provider: baseUrl',
+        ) || 'https://api.openai.com/v1'
       const apiKey = this.resolveApiKey(this.config.apiKey)
-      const res = await fetch(`${baseUrl}/models`, {
-        headers: { Authorization: `Bearer ${apiKey}` },
-      })
+      // 5s timeout so a down endpoint doesn't hang health checks (v2.1.229 alignment)
+      const res = await fetchWithRetry(
+        `${baseUrl}/models`,
+        { headers: { Authorization: `Bearer ${apiKey}` } },
+        { timeout: 5000, maxRetries: 0 },
+      )
       return res.ok
     } catch {
       return false
@@ -366,21 +377,25 @@ export class OpenAICompatProvider implements ProviderInstance {
     }
   }
 
-  private resolveApiKey(keyTemplate: string): string {
-    // Accept both ${VAR} and $VAR syntax
-    let match = keyTemplate.match(/^\$\{(.+)\}$/)
-    if (!match) match = keyTemplate.match(/^\$([A-Z_][A-Z0-9_]*)$/)
+  /** Resolve a `${VAR}` / `$VAR` template against the environment. */
+  private resolveEnvTemplate(value: string, warnPrefix: string): string {
+    let match = value.match(/^\$\{(.+)\}$/)
+    if (!match) match = value.match(/^\$([A-Z_][A-Z0-9_]*)$/)
     if (match?.[1]) {
       const varName = match[1]
-      const value = process.env[varName]
-      if (!value) {
+      const envValue = process.env[varName]
+      if (!envValue) {
         process.stderr.write(
-          `⚠ OpenAI-compatible provider: apiKey references $${varName} but that environment variable is not set\n`,
+          `⚠ ${warnPrefix} references $${varName} but that environment variable is not set\n`,
         )
         return ''
       }
-      return value
+      return envValue
     }
-    return keyTemplate
+    return value
+  }
+
+  private resolveApiKey(keyTemplate: string): string {
+    return this.resolveEnvTemplate(keyTemplate, 'OpenAI-compatible provider: apiKey')
   }
 }

package/src/providers/registry.ts

@@ -21,10 +21,24 @@ export class ProviderRegistry {
   private providers = new Map<string, ProviderInstance>()
   private activeProviderId: string
   private activeModelId: string
+  private defaultProviderId: string
+  private defaultModelId: string
 
   constructor(providers: ProviderConfig[], defaultProvider: string, defaultModel: string) {
     this.activeProviderId = defaultProvider
     this.activeModelId = defaultModel
+    this.defaultProviderId = defaultProvider
+    this.defaultModelId = defaultModel
+  }
+
+  /** The configured default provider id (used for fallback routing). */
+  getDefaultProviderId(): string {
+    return this.defaultProviderId
+  }
+
+  /** The configured default model id. */
+  getDefaultModelId(): string {
+    return this.defaultModelId
   }
 
   register(id: string, instance: ProviderInstance): void {
@@ -72,6 +86,32 @@ export class ProviderRegistry {
     return undefined
   }
 
+  /**
+   * Check a single provider's health. Returns undefined if not registered,
+   * otherwise the provider's healthCheck() result. Never throws.
+   */
+  async healthStatus(id: string): Promise<boolean | undefined> {
+    const provider = this.providers.get(id)
+    if (!provider) return undefined
+    try {
+      return await provider.healthCheck()
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Health of all registered providers, checked concurrently.
+   * Returns a Map of provider id → reachable boolean.
+   */
+  async healthMap(): Promise<Map<string, boolean>> {
+    const ids = this.listIds()
+    const results = await Promise.all(
+      ids.map(async (id) => [id, (await this.healthStatus(id)) ?? false] as const),
+    )
+    return new Map(results)
+  }
+
   async *chat(req: ChatRequest): AsyncGenerator<StreamChunk> {
     const provider = this.getActive()
     yield* provider.chat({ ...req, model: req.model || this.activeModelId })

package/src/shared/types.ts

@@ -129,6 +129,7 @@ export interface StreamChunk {
     | 'thinking'
     | 'stop'
     | 'error'
+    | 'warning'
     | 'task_notification'
     | 'usage'
   content?: string

package/src/ui/app.tsx

@@ -658,6 +658,17 @@ export function App({
             ])
           }
 
+          if (chunk.type === 'warning' && chunk.content) {
+            setMessages((prev) => [...prev, { role: 'system', content: `⚠ ${chunk.content}` }])
+            // Keep the footer's provider/model in sync after an automatic fallback
+            // switch. RemoteEngine's registry is a stub without getActive.
+            const registry = engine.getRegistry()
+            if ('getActive' in registry) {
+              setProviderId(registry.getActive().config.id)
+              setModelId(registry.getActiveModel())
+            }
+          }
+
           if (chunk.type === 'task_notification' && chunk.taskNotification) {
             const tn = chunk.taskNotification
             const isDone = tn.status === 'completed'

package/src/ui/commands.ts

@@ -317,12 +317,20 @@ const contextCmd: CommandHandler = (ctx) => {
   }
 }
 
-const statusCmd: CommandHandler = (ctx) => {
+const statusCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   const c = ctx.engine.getContext()
   const tools = ctx.engine.getTools()
   const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js'
   const runtimeVer = typeof Bun !== 'undefined' ? Bun.version : process.version
+  const health = ctx.engine.getRegistry()
+    ? await ctx.engine.getRegistry().healthMap()
+    : new Map<string, boolean>()
+  const providerHealth = ctx.config.providers
+    .filter((p) => p.status !== 'upcoming')
+    .map((p) => `${p.id} ${health.get(p.id) ? '🟢' : '🔴'}`)
+    .join('  ')
+
   return {
     content: stripIndent`
       ${t('commands.status.session_title')}
@@ -337,6 +345,9 @@ const statusCmd: CommandHandler = (ctx) => {
       ${t('commands.status.platform')}   ${process.platform} ${process.arch}
       ${t('commands.status.runtime')}    ${runtime} ${runtimeVer}
       ${t('commands.status.cwd')}        ${process.cwd()}
+
+      Providers
+      ${providerHealth}
     `,
   }
 }
@@ -449,12 +460,19 @@ const providerCmd: CommandHandler = (ctx) => {
   }
 }
 
-const providersCmd: CommandHandler = (ctx) => {
+const providersCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
-  const lines = ctx.config.providers.map(
-    (p) =>
-      `  ${p.id.padEnd(14)} ${p.name.padEnd(20)} ${p.protocol.padEnd(18)} ${p.models.length} models  ${p.status === 'upcoming' ? '[upcoming]' : '✓'}`,
-  )
+  const health = ctx.engine.getRegistry()
+    ? await ctx.engine.getRegistry().healthMap()
+    : new Map<string, boolean>()
+
+  const lines = ctx.config.providers.map((p) => {
+    if (p.status === 'upcoming') {
+      return `  ${p.id.padEnd(14)} ${p.name.padEnd(20)} ${p.protocol.padEnd(18)} ${p.models.length} models  ⏳ [upcoming]`
+    }
+    const ok = health.get(p.id) ?? false
+    return `  ${p.id.padEnd(14)} ${p.name.padEnd(20)} ${p.protocol.padEnd(18)} ${p.models.length} models  ${ok ? '🟢 reachable' : '🔴 unreachable'}`
+  })
   return {
     content: `${t('commands.providers.title')}\n\n${lines.join('\n')}\n\n${t('commands.providers.current', { provider: ctx.providerId, model: ctx.modelId })}`,
   }