mini-coder 0.7.2 → 0.7.4

package/bun.lock

@@ -7,7 +7,7 @@
       "dependencies": {
         "@cel-tui/components": "^0.8.3",
         "@cel-tui/core": "^0.8.3",
-        "@earendil-works/pi-ai": "^0.79.3",
+        "@earendil-works/pi-ai": "^0.80.3",
         "diff": "^9.0.0",
         "simple-git": "^3.36.0",
         "yaml": "^2.9.0",
@@ -101,7 +101,7 @@
 
     "@cel-tui/types": ["@cel-tui/types@0.8.3", "", { "peerDependencies": { "typescript": ">=5.0.0" } }, "sha512-yEKXCY16U/W4A4JaVysv2/x/IBEHQAfb93CzL6HugN+N15ETB3Vn8tZrQwdyrOT/9WdlCQkeBH8Vj7BJHs4Hkw=="],
 
-    "@earendil-works/pi-ai": ["@earendil-works/pi-ai@0.79.3", "", { "dependencies": { "@anthropic-ai/sdk": "0.91.1", "@aws-sdk/client-bedrock-runtime": "3.1048.0", "@google/genai": "1.52.0", "@mistralai/mistralai": "2.2.1", "@smithy/node-http-handler": "4.7.3", "http-proxy-agent": "7.0.2", "https-proxy-agent": "7.0.6", "openai": "6.26.0", "partial-json": "0.1.7", "typebox": "1.1.38" }, "bin": { "pi-ai": "dist/cli.js" } }, "sha512-lMSput/haP5uZAGbXhS5rAYd3GB7GYdJkoAUxg3VFummBeqGqGqllaTWrbHFN12kVGyVfWHhdySNXkiqVh65Iw=="],
+    "@earendil-works/pi-ai": ["@earendil-works/pi-ai@0.80.3", "", { "dependencies": { "@anthropic-ai/sdk": "0.91.1", "@aws-sdk/client-bedrock-runtime": "3.1048.0", "@google/genai": "1.52.0", "@mistralai/mistralai": "2.2.6", "@opentelemetry/api": "1.9.0", "@smithy/node-http-handler": "4.7.3", "http-proxy-agent": "7.0.2", "https-proxy-agent": "7.0.6", "openai": "6.26.0", "partial-json": "0.1.7", "typebox": "1.1.38" }, "bin": { "pi-ai": "dist/cli.js" } }, "sha512-jPZLMeGL5kkMSEAwAklfXTMHqZvfhsJtCCpKGIr5Duk7mc0n4skjB1dugk7y0z3z8ZHIUCmPAWHdyDqgUz5vdA=="],
 
     "@google/genai": ["@google/genai@1.52.0", "", { "dependencies": { "google-auth-library": "^10.3.0", "p-retry": "^4.6.2", "protobufjs": "^7.5.4", "ws": "^8.18.0" }, "peerDependencies": { "@modelcontextprotocol/sdk": "^1.25.2" }, "optionalPeers": ["@modelcontextprotocol/sdk"] }, "sha512-gwSvbpiN/17O9TbsqSsE/OzZcpv5Fo4RQjdngGgogtuB9RsyJ8ZHhX5KjHj1bp5N9snN2eK8LDGXSaWW2hof8Q=="],
 
@@ -109,10 +109,14 @@
 
     "@kwsites/promise-deferred": ["@kwsites/promise-deferred@1.1.1", "", {}, "sha512-GaHYm+c0O9MjZRu0ongGBRbinu8gVAMd2UZjji6jVmqKtZluZnptXGWhz1E8j8D2HJ3f/yMxKAUC0b+57wncIw=="],
 
-    "@mistralai/mistralai": ["@mistralai/mistralai@2.2.1", "", { "dependencies": { "ws": "^8.18.0", "zod": "^3.25.0 || ^4.0.0", "zod-to-json-schema": "^3.25.0" } }, "sha512-uKU8CZmL2RzYKmplsU01hii4p3pe4HqJefpWNRWXm1Tcm0Sm4xXfwSLIy4k7ZCPlbETCGcp69E7hZs+WOJ5itQ=="],
+    "@mistralai/mistralai": ["@mistralai/mistralai@2.2.6", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.40.0", "ws": "^8.18.0", "zod": "^3.25.0 || ^4.0.0", "zod-to-json-schema": "^3.25.0" }, "peerDependencies": { "@opentelemetry/api": "^1.9.0" }, "optionalPeers": ["@opentelemetry/api"] }, "sha512-W8pX7zHxjJvMIpw8JMxeJEleapXX0Q9NPszdNzqkM3MIEoIGPObdodujj+WHteXEvGfaP/AMwlNyRfEzSY6dQQ=="],
 
     "@nodable/entities": ["@nodable/entities@2.1.0", "", {}, "sha512-nyT7T3nbMyBI/lvr6L5TyWbFJAI9FTgVRakNoBqCD+PmID8DzFrrNdLLtHMwMszOtqZa8PAOV24ZqDnQrhQINA=="],
 
+    "@opentelemetry/api": ["@opentelemetry/api@1.9.0", "", {}, "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg=="],
+
+    "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.41.1", "", {}, "sha512-/UhIkaZgPutTFmQ7RnIJGgDXZmtEJ7Dvi86xNTFWcnRxVRNk/aotsqDJYeEvDP+FSMB2SdW+pQzNMcWP0rwuNA=="],
+
     "@protobufjs/aspromise": ["@protobufjs/aspromise@1.1.2", "", {}, "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ=="],
 
     "@protobufjs/base64": ["@protobufjs/base64@1.1.2", "", {}, "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg=="],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-coder",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "type": "module",
   "packageManager": "bun@1.3.13",
   "bin": {
@@ -22,7 +22,7 @@
   "dependencies": {
     "@cel-tui/components": "^0.8.3",
     "@cel-tui/core": "^0.8.3",
-    "@earendil-works/pi-ai": "^0.79.3",
+    "@earendil-works/pi-ai": "^0.80.3",
     "diff": "^9.0.0",
     "simple-git": "^3.36.0",
     "yaml": "^2.9.0"

package/src/agent.ts

@@ -1,14 +1,13 @@
-import {
-  type AssistantMessage,
-  type Context,
-  type ImageContent,
-  type Message,
-  streamSimple,
-  type TextContent,
-  type ToolCall,
-  type ToolResultMessage,
+import type {
+  AssistantMessage,
+  Context,
+  ImageContent,
+  Message,
+  TextContent,
+  ToolCall,
+  ToolResultMessage,
 } from "@earendil-works/pi-ai";
-import { getApiKey } from "./oauth";
+import { createAppModels } from "./models.ts";
 import { estimateTokens } from "./shared";
 import type {
   AgentContex,
@@ -21,17 +20,31 @@ import type {
 // Published research found that **simply hiding old tool outputs** matched the quality of full LLM summarization with **zero extra compute**:
 // https://blog.jetbrains.com/research/2025/12/efficient-context-management/
 export function compactContext(messages: Message[]) {
-  // TODO: Preserve SKILL.md contents, and exclude them from compaction.
-  // Problem: How do we know? we need to check each message result againt it's arguments
-  // and then find if by chance it has a read skill command... This is a mess. We we.
-  // A better way would be to first add a read(path, lines, offset). And then we know
-  // which files are read using it, and can match by path if it's a SKILL.md ending.
   const KEEP_OBSERVATIONS = 10;
 
+  const skillReadToolCallIds = new Set<string>();
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+
+    for (const content of message.content) {
+      if (content.type !== "toolCall") continue;
+      if (content.name !== "read") continue;
+
+      const path = content.arguments.path;
+      if (typeof path === "string" && path.endsWith("SKILL.md")) {
+        skillReadToolCallIds.add(content.id);
+      }
+    }
+  }
+
   const toolResultIndices: number[] = [];
   for (let i = 0; i < messages.length; i++) {
     if (messages[i].role !== "toolResult") continue;
-    const content = (messages[i] as ToolResultMessage).content;
+
+    const message = messages[i] as ToolResultMessage;
+    if (skillReadToolCallIds.has(message.toolCallId)) continue;
+
+    const content = message.content;
     if (
       content.length === 1 &&
       content[0].type === "text" &&
@@ -73,15 +86,17 @@ export async function* streamAgent(
     messages: agentCtx.messages,
   };
 
-  // Important for refreshing tokens.
-  const apiKey = await getApiKey(agentCtx.options);
+  const models = createAppModels(agentCtx.options.customProviders);
 
   // Main agent loop, continues until llm sends a response other than toolCall or has no tool calls.
   while (true) {
-    const s = streamSimple(agentCtx.options.model, llmCtx, {
+    const estimate = estimateTokens(JSON.stringify(llmCtx));
+    // 80k is the agreed uppon threshold to the DUMB ZONE
+    if (estimate > 80000) compactContext(llmCtx.messages);
+
+    const s = models.streamSimple(agentCtx.options.model, llmCtx, {
       reasoning: agentCtx.options.effort,
       signal: agentCtx.signal,
-      apiKey,
     });
 
     let partial: AssistantMessage | null = null;
@@ -116,6 +131,8 @@ export async function* streamAgent(
 
         case "error": {
           const finalMessage = await s.result();
+          if (!finalMessage) throw new Error(e.error.errorMessage);
+
           if (added) {
             llmCtx.messages[llmCtx.messages.length - 1] = finalMessage;
           } else {
@@ -127,15 +144,11 @@ export async function* streamAgent(
           return;
         }
       }
-
-      // Experiment: use this inside the inner loop for "running" compaction
-      // after we are in the dumb zone.
-      const estimate = estimateTokens(JSON.stringify(llmCtx));
-      // 80k is the agreed uppon threshold to the DUMB ZONE
-      if (estimate > 80000) compactContext(llmCtx.messages);
     }
 
     const message = await s.result();
+    if (!message) throw new Error("Stream finished without a message");
+
     if (added) {
       llmCtx.messages[llmCtx.messages.length - 1] = message;
     } else {
@@ -144,7 +157,9 @@ export async function* streamAgent(
     }
     yield { type: "message_end", message };
 
-    const toolCalls = message.content.filter((c) => c.type === "toolCall");
+    const toolCalls = message.content.filter(
+      (c): c is ToolCall => c.type === "toolCall",
+    );
 
     // Stop on errors or no tools to call.
     if (message.stopReason !== "toolUse" || toolCalls.length === 0) {

package/src/args.ts

@@ -1,12 +1,11 @@
 import { mkdir } from "node:fs/promises";
-import {
-  type Api,
-  getModels,
-  getProviders,
-  type Model,
-  type ThinkingLevel,
-} from "@earendil-works/pi-ai";
+import type { ThinkingLevel } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
+import {
+  findModelConfig,
+  getFallbackModel,
+  getFirstModelConfig,
+} from "./models.ts";
 import { getAvailableProviders, isOAuthProvider, loginOAuth } from "./oauth";
 import { DATA_DIR, SETTINGS_PATH } from "./shared.ts";
 import { DEFAULT_TUI_THEME_ID } from "./themes.ts";
@@ -92,53 +91,6 @@ function requireValue(argv: string[], index: number, flag: string) {
   return value;
 }
 
-function findModelConfig(
-  modelId: string,
-  provider: string,
-  customProviders?: Model<Api>[],
-) {
-  const knownProviders = getProviders() as string[];
-  if (knownProviders.includes(provider)) {
-    const models = getModels(provider as any);
-    if (models.length === 0) throw new Error("Provider has no models");
-    return models.find((m) => m.id === modelId);
-  }
-  return customProviders?.find(
-    (m) => m.provider === provider && m.id === modelId,
-  );
-}
-
-function getFirstModelConfig(
-  provider: string,
-  customProviders?: Model<Api>[],
-): Model<Api> {
-  const knownProviders = getProviders() as string[];
-  if (knownProviders.includes(provider)) {
-    const models = getModels(provider as any);
-    if (models.length > 0) return models[0];
-  }
-  const custom = customProviders?.find((m) => m.provider === provider);
-  if (custom) return custom;
-  throw new Error("Provider has no models");
-}
-
-function getFallbackModel(
-  provider: string,
-  explicitModel: boolean,
-  providerChanged: boolean,
-  customProviders?: Model<Api>[],
-): Model<Api> {
-  if (explicitModel) {
-    throw new Error("Model not found");
-  }
-
-  if (!providerChanged) {
-    throw new Error("Model not found");
-  }
-
-  return getFirstModelConfig(provider, customProviders);
-}
-
 export async function handleArgv(argv: string[]): Promise<CliOptions> {
   const settings = await getSettings();
   const customProviders = settings?.customProviders ?? [];

package/src/index.ts

@@ -4,10 +4,18 @@ import { getBranchLabel } from "./git.ts";
 import { streamHeadless } from "./headless.ts";
 import { initTUI } from "./tui.ts";
 import type { TUIState } from "./types.ts";
+import { updateMiniCoder } from "./update.ts";
 
 export async function main(): Promise<void> {
+  const argv = process.argv.slice(2);
+
+  if (argv.includes("--update")) {
+    await updateMiniCoder();
+    return;
+  }
+
   const cwd = basename(process.cwd());
-  const options = await handleArgv(process.argv.slice(2));
+  const options = await handleArgv(argv);
 
   function leave(msg?: string) {
     if (msg) console.log(msg);

package/src/models.ts

@@ -0,0 +1,191 @@
+import type {
+  Api,
+  Credential,
+  CredentialStore,
+  KnownApi,
+  KnownProvider,
+  Model,
+  ProviderStreams,
+} from "@earendil-works/pi-ai";
+import { createProvider } from "@earendil-works/pi-ai";
+import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { azureOpenAIResponsesApi } from "@earendil-works/pi-ai/api/azure-openai-responses.lazy";
+import { bedrockConverseStreamApi } from "@earendil-works/pi-ai/api/bedrock-converse-stream.lazy";
+import { googleGenerativeAIApi } from "@earendil-works/pi-ai/api/google-generative-ai.lazy";
+import { googleVertexApi } from "@earendil-works/pi-ai/api/google-vertex.lazy";
+import { mistralConversationsApi } from "@earendil-works/pi-ai/api/mistral-conversations.lazy";
+import { openAICodexResponsesApi } from "@earendil-works/pi-ai/api/openai-codex-responses.lazy";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import {
+  builtinModels,
+  getBuiltinModels,
+  getBuiltinProviders,
+} from "@earendil-works/pi-ai/providers/all";
+import { AUTH_PATH } from "./shared.ts";
+
+const API_STREAMS: Record<KnownApi, () => ProviderStreams> = {
+  "anthropic-messages": anthropicMessagesApi,
+  "azure-openai-responses": azureOpenAIResponsesApi,
+  "bedrock-converse-stream": bedrockConverseStreamApi,
+  "google-generative-ai": googleGenerativeAIApi,
+  "google-vertex": googleVertexApi,
+  "mistral-conversations": mistralConversationsApi,
+  "openai-codex-responses": openAICodexResponsesApi,
+  "openai-completions": openAICompletionsApi,
+  "openai-responses": openAIResponsesApi,
+};
+
+type SavedCredentials = Record<string, Credential>;
+
+async function readCredentials(): Promise<SavedCredentials> {
+  const file = Bun.file(AUTH_PATH);
+  if (await file.exists()) {
+    return JSON.parse(await file.text()) as SavedCredentials;
+  }
+
+  return {};
+}
+
+async function writeCredentials(credentials: SavedCredentials) {
+  await Bun.write(AUTH_PATH, JSON.stringify(credentials));
+}
+
+export function createCredentialStore(): CredentialStore {
+  return {
+    async read(providerId) {
+      const credentials = await readCredentials();
+      return credentials[providerId];
+    },
+
+    async modify(providerId, fn) {
+      const credentials = await readCredentials();
+      const next = await fn(credentials[providerId]);
+
+      if (next) {
+        credentials[providerId] = next;
+        await writeCredentials(credentials);
+      }
+
+      return credentials[providerId];
+    },
+
+    async delete(providerId) {
+      const credentials = await readCredentials();
+      delete credentials[providerId];
+      await writeCredentials(credentials);
+    },
+  };
+}
+
+export function isBuiltinProvider(provider: string): provider is KnownProvider {
+  return getBuiltinProviders().includes(provider as KnownProvider);
+}
+
+export function findModelConfig(
+  modelId: string,
+  provider: string,
+  customProviders?: Model<Api>[],
+) {
+  if (isBuiltinProvider(provider)) {
+    const models = getBuiltinModels(provider);
+    if (models.length === 0) throw new Error("Provider has no models");
+    return models.find((m) => m.id === modelId);
+  }
+  return customProviders?.find(
+    (m) => m.provider === provider && m.id === modelId,
+  );
+}
+
+export function getFirstModelConfig(
+  provider: string,
+  customProviders?: Model<Api>[],
+): Model<Api> {
+  if (isBuiltinProvider(provider)) {
+    const models = getBuiltinModels(provider);
+    if (models.length > 0) return models[0];
+  }
+  const custom = customProviders?.find((m) => m.provider === provider);
+  if (custom) return custom;
+  throw new Error("Provider has no models");
+}
+
+export function getFallbackModel(
+  provider: string,
+  explicitModel: boolean,
+  providerChanged: boolean,
+  customProviders?: Model<Api>[],
+): Model<Api> {
+  if (explicitModel) {
+    throw new Error("Model not found");
+  }
+
+  if (!providerChanged) {
+    throw new Error("Model not found");
+  }
+
+  return getFirstModelConfig(provider, customProviders);
+}
+
+export function getProviderModels(
+  provider: string,
+  customProviders?: Model<Api>[],
+): Model<Api>[] {
+  const builtIn = isBuiltinProvider(provider) ? getBuiltinModels(provider) : [];
+  const custom = customProviders?.filter((m) => m.provider === provider) ?? [];
+
+  return [...builtIn, ...custom];
+}
+
+export function createAppModels(customProviders?: Model<Api>[]) {
+  const models = builtinModels({ credentials: createCredentialStore() });
+  const customProviderGroups = new Map<string, Model<Api>[]>();
+
+  for (const model of customProviders ?? []) {
+    const group = customProviderGroups.get(model.provider) ?? [];
+    group.push(model);
+    customProviderGroups.set(model.provider, group);
+  }
+
+  for (const [provider, providerModels] of customProviderGroups) {
+    models.setProvider(
+      createProvider({
+        id: provider,
+        name: provider,
+        models: providerModels,
+        auth: {
+          apiKey: {
+            name: provider,
+            resolve: async () => ({ auth: { apiKey: "dummy" } }),
+          },
+        },
+        api: Object.fromEntries(
+          Object.entries(API_STREAMS)
+            .filter(([api]) =>
+              providerModels.some((model) => model.api === api),
+            )
+            .map(([api, createStreams]) => [api, createStreams()]),
+        ),
+      }),
+    );
+  }
+
+  return models;
+}
+
+export async function getConfiguredBuiltinProviders(): Promise<string[]> {
+  const models = builtinModels({ credentials: createCredentialStore() });
+  const providers: string[] = [];
+
+  for (const provider of models.getProviders()) {
+    const model = provider.getModels()[0];
+    if (!model) continue;
+
+    try {
+      const auth = await models.getAuth(model);
+      if (auth) providers.push(provider.id);
+    } catch {}
+  }
+
+  return providers;
+}

package/src/oauth.ts

@@ -1,9 +1,7 @@
 import { mkdir } from "node:fs/promises";
 import readline from "node:readline";
 
-import { getEnvApiKey, getProviders } from "@earendil-works/pi-ai";
 import {
-  getOAuthApiKey,
   getOAuthProvider,
   getOAuthProviders,
   type OAuthLoginCallbacks,
@@ -11,6 +9,11 @@ import {
   type OAuthProviderId,
   type OAuthSelectPrompt,
 } from "@earendil-works/pi-ai/oauth";
+import {
+  createAppModels,
+  getConfiguredBuiltinProviders,
+  isBuiltinProvider,
+} from "./models.ts";
 import { AUTH_PATH as AUTH_FILE, DATA_DIR } from "./shared";
 import type { CliOptions, SavedOAuthCreds } from "./types";
 
@@ -66,9 +69,7 @@ export async function getAvailableProviders(): Promise<string[]> {
   const loggedInOAuthProviders = getOAuthProviders()
     .map((provider) => provider.id)
     .filter((provider) => auth[provider]);
-  const envKeyProviders = getProviders().filter(
-    (provider) => !!getEnvApiKey(provider),
-  );
+  const envKeyProviders = await getConfiguredBuiltinProviders();
   const providers: string[] = [];
   const providerIds = new Set<string>();
 
@@ -104,23 +105,12 @@ export async function loginOAuth(provider: OAuthProviderId) {
 
 export async function getApiKey(options: CliOptions) {
   const provider = options.model.provider;
-  const auth = await readCreds();
-
-  if (isOAuthProvider(provider)) {
-    const result = await getOAuthApiKey(provider, auth);
-    if (result) {
-      auth[provider] = { type: "oauth", ...result.newCredentials };
-      await writeCreds(auth);
-
-      return result.apiKey;
-    }
-  }
+  const models = createAppModels(options.customProviders);
+  const auth = await models.getAuth(options.model);
 
-  const envApiKey = getEnvApiKey(provider);
-  if (envApiKey) return envApiKey;
+  if (auth?.auth.apiKey) return auth.auth.apiKey;
 
-  const knownProviders = getProviders() as string[];
-  if (!knownProviders.includes(provider)) {
+  if (!isBuiltinProvider(provider)) {
     if (options.model.api === "openai-completions") {
       // pi-ai requires a truthy apiKey for OpenAI-compatible local providers like Ollama.
       return "dummy";

package/src/tui-conversation.ts

@@ -14,6 +14,17 @@ export function emptyState(state: TUIState): Node {
     state.options.theme === "ansi16"
       ? randColor
       : textColorForBackground(theme.bblack, state.options.theme);
+  const updateNotice = state.availableUpdate
+    ? [
+        HStack({ gap: 1 }, [
+          TextPill("update", shortcutFgColor, theme.bblack, 13),
+          Text(
+            `mini-coder ${state.availableUpdate.latestVersion} is available. Run mc --update.`,
+            { fgColor: theme.bblack },
+          ),
+        ]),
+      ]
+    : [];
   return HStack({ flex: 1, alignItems: "center" }, [
     VStack({ flex: 1, alignItems: "center", gap: 1 }, [
       HStack({ gap: 1 }, [
@@ -45,6 +56,7 @@ export function emptyState(state: TUIState): Node {
           TextPill("ctrl+c|d|q", shortcutFgColor, theme.bblack, 13),
           Text("Quit.", { fgColor: theme.bblack }),
         ]),
+        ...updateNotice,
       ]),
     ]),
   ]);

package/src/tui-overlay.ts

@@ -1,11 +1,8 @@
 import { cel, HStack, Text, TextInput, VStack } from "@cel-tui/core";
-import {
-  getModels,
-  type Message,
-  type ThinkingLevel,
-} from "@earendil-works/pi-ai";
+import type { Message, ThinkingLevel } from "@earendil-works/pi-ai";
 import { getOAuthProviders } from "@earendil-works/pi-ai/oauth";
 import { saveSettings } from "./args";
+import { findModelConfig, getProviderModels } from "./models.ts";
 import { getAvailableProviders } from "./oauth";
 import { listSessionsForCwd } from "./session";
 import { estimateTokens, formatTimestamp } from "./shared";
@@ -291,20 +288,11 @@ export function mainMenu(state: TUIState, initialPane = "main") {
     "xhigh",
   ];
   const efforts = reasoningEfforts.map((v) => ({ label: v, value: v }));
-  const getProviderModels = (provider: string) => {
-    const builtIn = getModels(provider as any).map((v) => ({
+  const getProviderModelOptions = (provider: string) =>
+    getProviderModels(provider, state.options.customProviders).map((v) => ({
       label: v.name,
       value: v.id,
     }));
-    const custom =
-      state.options.customProviders
-        ?.filter((m) => m.provider === provider)
-        .map((v) => ({
-          label: v.name,
-          value: v.id,
-        })) ?? [];
-    return [...builtIn, ...custom];
-  };
 
   let currentProviders: string[] = [];
   let currentSessions: Session[] = [];
@@ -560,7 +548,7 @@ export function mainMenu(state: TUIState, initialPane = "main") {
         openPane(s, {
           label: "models",
           filter: "",
-          list: getProviderModels(selectedProvider),
+          list: getProviderModelOptions(selectedProvider),
         });
         return;
       }
@@ -568,13 +556,11 @@ export function mainMenu(state: TUIState, initialPane = "main") {
       if (currentPane.label === "models") {
         if (!selectedProvider) return;
 
-        const builtIn = getModels(selectedProvider as any).find(
-          (v) => v.id === s.selected,
-        );
-        const custom = state.options.customProviders?.find(
-          (v) => v.provider === selectedProvider && v.id === s.selected,
+        const model = findModelConfig(
+          s.selected,
+          selectedProvider,
+          state.options.customProviders,
         );
-        const model = builtIn ?? custom;
         if (!model) return;
 
         state.options.provider = selectedProvider;

package/src/tui.ts

@@ -30,6 +30,11 @@ import { Conversation, emptyState } from "./tui-conversation";
 import { Editor } from "./tui-editor";
 import { mainMenu } from "./tui-overlay";
 import type { AgentContex, ToolAndRunner, TUIMessage, TUIState } from "./types";
+import { getAvailableUpdate } from "./update";
+
+async function refreshAvailableUpdate(state: TUIState): Promise<void> {
+  state.availableUpdate = await getAvailableUpdate();
+}
 
 function clearOrAbort(state: TUIState) {
   // Are we mid stream? Abort it.
@@ -46,6 +51,7 @@ function clearOrAbort(state: TUIState) {
 export function initTUI(state: TUIState, leave: (s: string) => void) {
   // TODO: Cleanup accumulated sessions for this cwd.
   const { spinnerEvery, currentSpinner } = Spinner();
+  void refreshAvailableUpdate(state);
 
   // Stable 60fps rendering.
   // This ensure Xfps, and excessive calls get coalesced in cel-tui.

package/src/types.ts

@@ -98,6 +98,11 @@ export type TUIMessage = {
   toolCalls?: TUIToolCall[];
 };
 
+export type AvailableUpdate = {
+  currentVersion: string;
+  latestVersion: string;
+};
+
 export type TUIState = {
   options: CliOptions;
   prompt: string;
@@ -110,6 +115,7 @@ export type TUIState = {
   abortController?: AbortController;
   cwd: string;
   gitBranch?: string;
+  availableUpdate?: AvailableUpdate | undefined;
   overlay?: boolean | undefined;
   forceThemeRefresh?: boolean | undefined;
   sessionId?: string | undefined;

package/src/update.ts

@@ -0,0 +1,171 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+import { type Static, Type } from "@earendil-works/pi-ai";
+import { Value } from "typebox/value";
+
+import { DATA_DIR } from "./shared";
+import type { AvailableUpdate } from "./types";
+
+const PACKAGE_NAME = "mini-coder";
+const PACKAGE_MANIFEST_URL = new URL("../package.json", import.meta.url);
+const UPDATE_CHECK_CACHE_PATH = join(DATA_DIR, "update-check.json");
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_CHECK_TIMEOUT_MS = 5_000;
+
+const UpdateCheckCacheSchema = Type.Object({
+  checkedAt: Type.Number(),
+  currentVersion: Type.String(),
+  latestVersion: Type.Optional(Type.String()),
+});
+type UpdateCheckCache = Static<typeof UpdateCheckCacheSchema>;
+
+function parseLatestVersion(output: string): string | undefined {
+  const version = output.trim().split(/\s+/)[0];
+
+  if (!version || !isValidVersion(version)) {
+    return;
+  }
+
+  return version;
+}
+
+function isValidVersion(version: string): boolean {
+  try {
+    Bun.semver.order(version, version);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isNewerVersion(
+  currentVersion: string,
+  latestVersion: string,
+): boolean {
+  try {
+    return Bun.semver.order(latestVersion, currentVersion) === 1;
+  } catch {
+    return false;
+  }
+}
+
+function isFreshUpdateCheck(cache: UpdateCheckCache, now: number): boolean {
+  return now - cache.checkedAt < UPDATE_CHECK_INTERVAL_MS;
+}
+
+function getAvailableUpdateFromLatest(
+  currentVersion: string,
+  latestVersion: string | undefined,
+): AvailableUpdate | undefined {
+  if (!latestVersion || !isNewerVersion(currentVersion, latestVersion)) {
+    return;
+  }
+
+  return { currentVersion, latestVersion };
+}
+
+async function getCurrentVersion(): Promise<string | undefined> {
+  const manifest = (await Bun.file(PACKAGE_MANIFEST_URL).json()) as {
+    version?: unknown;
+  };
+
+  if (typeof manifest.version !== "string") {
+    return;
+  }
+
+  return manifest.version;
+}
+
+async function getLatestVersion(): Promise<string | undefined> {
+  try {
+    const proc = Bun.spawn(["bun", "pm", "view", PACKAGE_NAME, "version"], {
+      stdout: "pipe",
+      stderr: "ignore",
+      timeout: UPDATE_CHECK_TIMEOUT_MS,
+    });
+    const [stdout, exitCode] = await Promise.all([
+      proc.stdout.text(),
+      proc.exited,
+    ]);
+
+    if (exitCode !== 0) {
+      return;
+    }
+
+    return parseLatestVersion(stdout);
+  } catch {
+    return;
+  }
+}
+
+async function readUpdateCheckCache(): Promise<UpdateCheckCache | undefined> {
+  try {
+    const file = Bun.file(UPDATE_CHECK_CACHE_PATH);
+
+    if (!(await file.exists())) {
+      return;
+    }
+
+    const value = (await file.json()) as unknown;
+
+    if (!Value.Check(UpdateCheckCacheSchema, value)) {
+      return;
+    }
+
+    return value;
+  } catch {
+    return;
+  }
+}
+
+async function writeUpdateCheckCache(cache: UpdateCheckCache): Promise<void> {
+  try {
+    await mkdir(DATA_DIR, { recursive: true });
+    await Bun.write(UPDATE_CHECK_CACHE_PATH, JSON.stringify(cache, null, 2));
+  } catch {
+    // Update checks are best-effort and must never interrupt startup.
+  }
+}
+
+export async function getAvailableUpdate(): Promise<
+  AvailableUpdate | undefined
+> {
+  const currentVersion = await getCurrentVersion().catch(() => undefined);
+
+  if (!currentVersion) {
+    return;
+  }
+
+  const now = Date.now();
+  const cache = await readUpdateCheckCache();
+
+  if (cache && isFreshUpdateCheck(cache, now)) {
+    return getAvailableUpdateFromLatest(currentVersion, cache.latestVersion);
+  }
+
+  const latestVersion = await getLatestVersion();
+  await writeUpdateCheckCache({
+    checkedAt: now,
+    currentVersion,
+    latestVersion,
+  });
+
+  return getAvailableUpdateFromLatest(currentVersion, latestVersion);
+}
+
+export async function updateMiniCoder(): Promise<void> {
+  console.log("Updating mini-coder...");
+
+  const proc = Bun.spawn(["bun", "add", "-g", "mini-coder@latest"], {
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    throw new Error(`Update failed with exit code ${exitCode}`);
+  }
+
+  console.log("mini-coder updated.");
+}