@freesyntax/notch-cli 0.5.22 → 0.5.23

package/dist/{chunk-EPSOOCNB.js → chunk-474TAHDN.js}

@@ -50,6 +50,7 @@ import {
 
 // src/tools/index.ts
 import { tool } from "ai";
+import { zodToJsonSchema } from "zod-to-json-schema";
 
 // src/tools/code-mode.ts
 import vm from "vm";
@@ -1696,6 +1697,7 @@ function mcpToolsToNotch(client, serverName) {
       name: `mcp_${serverName}_${toolDef.name}`,
       description: `[MCP/${serverName}] ${toolDef.description}`,
       parameters: params,
+      inputSchema: toolDef.inputSchema,
       async execute(args, _ctx) {
         try {
           const result = await client.callTool(toolDef.name, args);
@@ -2318,8 +2320,7 @@ async function spawnSubagent(config) {
 ## Working Directory
 ${toolContext.cwd}
 
-## Available Tools
-${Object.keys(tools).map((n) => `- ${n}`).join("\n")}`;
+${describeToolSchemas(subagentCtx, { includeNames: Object.keys(tools) })}`;
   const messages = [
     { role: "user", content: prompt }
   ];
@@ -2454,8 +2455,7 @@ async function spawnBuiltinAgent(config) {
 ## Working Directory
 ${toolContext.cwd}
 
-## Available Tools
-${Object.keys(tools).map((n) => `- ${n}`).join("\n")}`;
+${describeToolSchemas(subagentCtx, { includeNames: Object.keys(tools) })}`;
   const messages = [{ role: "user", content: prompt }];
   let iterations = 0;
   let totalToolCalls = 0;
@@ -3081,11 +3081,50 @@ ${paramSummary}`
 function listToolNames(ctx) {
   return getAllTools(ctx).map((t) => t.name);
 }
-function describeTools2(ctx) {
+function describeTools(ctx) {
   return getAllTools(ctx).map(
     (t) => `- **${t.name}**: ${t.description}`
   ).join("\n");
 }
+function describeToolSchemas(ctx, options = {}) {
+  const include = options.includeNames ? new Set(options.includeNames) : null;
+  const tools = getAllTools(ctx).filter((t) => !include || include.has(t.name));
+  if (tools.length === 0) return "## Tool Schemas\nNo tools are available in this mode.";
+  const lines = [
+    "## Tool Schemas",
+    "Native tool schemas are sent with every model request. They are repeated here so OpenAI-compatible routers and local models can reliably choose valid tools.",
+    "When using a tool, call the native tool with exactly one listed name and a JSON object matching its parameters schema. Do not print tool-call JSON as normal text.",
+    ""
+  ];
+  for (const t of tools) {
+    const schema = toolPromptSchema(t);
+    lines.push(`### ${t.name}`);
+    lines.push(t.description);
+    lines.push("Parameters JSON Schema:");
+    lines.push("```json");
+    lines.push(JSON.stringify(schema));
+    lines.push("```");
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function toolPromptSchema(t) {
+  const schema = t.inputSchema ?? zodToJsonSchema(t.parameters, {
+    target: "jsonSchema7",
+    $refStrategy: "none"
+  });
+  return stripSchemaNoise(schema);
+}
+function stripSchemaNoise(value) {
+  if (Array.isArray(value)) return value.map(stripSchemaNoise);
+  if (!value || typeof value !== "object") return value;
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (key === "$schema" || key === "definitions" || key === "$defs") continue;
+    out[key] = stripSchemaNoise(raw);
+  }
+  return out;
+}
 function mcpToolCount() {
   return mcpTools.length;
 }
@@ -3103,6 +3142,7 @@ export {
   disconnectMCPServers,
   buildToolMap,
   listToolNames,
-  describeTools2 as describeTools,
+  describeTools,
+  describeToolSchemas,
   mcpToolCount
 };

package/dist/{chunk-JXQ4HZ47.js → chunk-JVFOAPYV.js}

@@ -15,16 +15,17 @@ var BUILTIN_BYOK_PROVIDERS = [
     label: "OpenAI",
     baseUrl: "https://api.openai.com/v1",
     apiKeyEnv: "OPENAI_API_KEY",
-    defaultModel: "gpt-4o",
+    defaultModel: "gpt-5",
     models: [
-      "gpt-4o",
-      "gpt-4o-mini",
-      "gpt-4-turbo",
-      "gpt-4.1",
-      "gpt-4.1-mini",
       "gpt-5",
       "gpt-5-mini",
-      "o3-mini",
+      "gpt-5-nano",
+      "gpt-5-chat-latest",
+      "gpt-4.1",
+      "gpt-4.1-mini",
+      "gpt-4o",
+      "gpt-4o-mini",
+      "o3",
       "o4-mini"
     ],
     compatibility: "strict"
@@ -63,6 +64,33 @@ var BUILTIN_BYOK_PROVIDERS = [
       "X-Title": "Notch CLI"
     }
   },
+  {
+    id: "google",
+    label: "Google Gemini",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    apiKeyEnv: "GEMINI_API_KEY",
+    defaultModel: "gemini-3.5-flash",
+    models: [
+      "gemini-3.5-flash",
+      "gemini-2.5-pro",
+      "gemini-2.5-flash"
+    ],
+    compatibility: "compatible"
+  },
+  {
+    id: "deepseek",
+    label: "DeepSeek",
+    baseUrl: "https://api.deepseek.com",
+    apiKeyEnv: "DEEPSEEK_API_KEY",
+    defaultModel: "deepseek-v4-flash",
+    models: [
+      "deepseek-v4-flash",
+      "deepseek-v4-pro",
+      "deepseek-chat",
+      "deepseek-reasoner"
+    ],
+    compatibility: "strict"
+  },
   {
     id: "together",
     label: "Together AI",
@@ -194,23 +222,35 @@ function findByokProvider(id) {
 function listByokProviders() {
   return BUILTIN_BYOK_PROVIDERS.filter((p) => p.id !== "__custom__");
 }
-function isByokRef(model) {
-  return model.includes(":") && !isOllamaTagOnly(model);
+function normalizeProviderId(id) {
+  return id === "custom" ? "__custom__" : id;
 }
-function isOllamaTagOnly(model) {
-  const [head] = model.split(":");
-  if (!head) return false;
-  return !BYOK_BY_ID[head];
+function providerExists(id) {
+  return Boolean(BYOK_BY_ID[normalizeProviderId(id)]);
+}
+function isByokRef(model) {
+  const slash = model.indexOf("/");
+  if (slash > 0 && providerExists(model.slice(0, slash))) return true;
+  const colon = model.indexOf(":");
+  if (colon > 0 && providerExists(model.slice(0, colon))) return true;
+  return false;
 }
 function parseByokRef(ref) {
+  const slash = ref.indexOf("/");
   const colon = ref.indexOf(":");
-  if (colon < 0) {
-    throw new Error(`BYOK ref "${ref}" is missing a colon separator.`);
+  if (slash > 0 && (colon < 0 || slash < colon) && providerExists(ref.slice(0, slash))) {
+    const rawProvider = ref.slice(0, slash);
+    const model = ref.slice(slash + 1);
+    return { provider: normalizeProviderId(rawProvider), model };
   }
-  const rawProvider = ref.slice(0, colon);
-  const model = ref.slice(colon + 1);
-  const provider = rawProvider === "custom" ? "__custom__" : rawProvider;
-  return { provider, model };
+  if (colon > 0 && providerExists(ref.slice(0, colon))) {
+    const rawProvider = ref.slice(0, colon);
+    const model = ref.slice(colon + 1);
+    return { provider: normalizeProviderId(rawProvider), model };
+  }
+  throw new Error(
+    `Provider model ref "${ref}" must be "<provider>/<model>" or "<provider>:<model>".`
+  );
 }
 var ByokMissingApiKeyError = class extends Error {
   constructor(provider) {
@@ -225,7 +265,7 @@ var ByokMissingApiKeyError = class extends Error {
 var ByokMissingBaseUrlError = class extends Error {
   constructor() {
     super(
-      "Custom BYOK provider requires --base-url (and usually --api-key). Example: notch --provider custom --base-url https://my.endpoint/v1 --model my-model"
+      "Custom provider requires --base-url (and usually --api-key). Example: notch --provider custom --base-url https://my.endpoint/v1 --model my-model"
     );
     this.name = "ByokMissingBaseUrlError";
   }
@@ -234,7 +274,7 @@ function resolveByokModel(spec) {
   const providerInfo = findByokProvider(spec.provider);
   if (!providerInfo) {
     throw new Error(
-      `Unknown BYOK provider "${spec.provider}". Available: ${listByokProviders().map((p) => p.id).join(", ")}, custom`
+      `Unknown provider "${spec.provider}". Available: ${listByokProviders().map((p) => p.id).join(", ")}, custom`
     );
   }
   if (providerInfo.id === "__custom__" && !spec.baseUrl) {
@@ -244,7 +284,7 @@ function resolveByokModel(spec) {
   const modelId = spec.model && spec.model.length > 0 ? spec.model : providerInfo.defaultModel;
   if (!modelId) {
     throw new Error(
-      `BYOK provider "${providerInfo.id}" has no default model. Pass --model or set byok.model in .notch.json.`
+      `Provider "${providerInfo.id}" has no default model. Pass --model or set byok.model in .notch.json.`
     );
   }
   let apiKey = spec.apiKey;
@@ -303,7 +343,7 @@ function resolveByokModel(spec) {
 async function validateByokConfig(spec) {
   const providerInfo = findByokProvider(spec.provider);
   if (!providerInfo) {
-    return { ok: false, error: `Unknown BYOK provider "${spec.provider}"` };
+    return { ok: false, error: `Unknown provider "${spec.provider}"` };
   }
   if (providerInfo.id === "__custom__" && !spec.baseUrl) {
     return { ok: false, error: "Custom provider requires --base-url" };
@@ -324,6 +364,156 @@ async function validateByokConfig(spec) {
 
 // src/providers/registry.ts
 import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+
+// src/providers/pi-ai-adapter.ts
+var PI_AI_PROVIDER_MAP = {
+  openai: "openai",
+  anthropic: "anthropic",
+  google: "google",
+  "google-vertex": "google-vertex",
+  mistral: "mistral",
+  bedrock: "amazon-bedrock",
+  azure: "azure-openai"
+};
+var UNSUPPORTED_BY_PI_AI = /* @__PURE__ */ new Set(["openrouter", "groq", "together"]);
+function piAiMode() {
+  const enabled = process.env.NOTCH_USE_PI_AI;
+  if (!enabled || enabled === "0" || enabled.toLowerCase() === "false") return "off";
+  const mode = (process.env.NOTCH_PI_AI_MODE ?? "shadow").toLowerCase();
+  return mode === "swap" ? "swap" : "shadow";
+}
+function shouldRouteViaPiAi(config) {
+  if (piAiMode() === "off") return false;
+  const provider = extractProvider(config);
+  if (!provider) return false;
+  if (UNSUPPORTED_BY_PI_AI.has(provider)) return false;
+  return provider in PI_AI_PROVIDER_MAP;
+}
+var PiAiNotInstalledError = class extends Error {
+  constructor(originalError) {
+    super(
+      `NOTCH_USE_PI_AI is set but @mariozechner/pi-ai could not be loaded. Install with: pnpm --filter @freesyntax/notch-cli add @mariozechner/pi-ai@0.70.2. Original error: ${originalError instanceof Error ? originalError.message : String(originalError)}`
+    );
+    this.name = "PiAiNotInstalledError";
+  }
+};
+async function resolveModelViaPiAi(config) {
+  const { providerName, modelId } = extractProviderAndModel(config);
+  const piAiProvider = PI_AI_PROVIDER_MAP[providerName];
+  if (!piAiProvider) {
+    throw new Error(
+      `pi-ai does not support BYOK provider "${providerName}". Supported: ${Object.keys(PI_AI_PROVIDER_MAP).join(", ")}. Set NOTCH_USE_PI_AI=0 or use a different provider.`
+    );
+  }
+  if (!modelId) {
+    throw new Error(
+      `pi-ai resolution requires a non-empty model id. Config: ${JSON.stringify({ byokProvider: config.byokProvider, model: config.model })}`
+    );
+  }
+  const piAi = await loadPiAi();
+  const model = piAi.getModel(piAiProvider, modelId);
+  if (!model) {
+    throw new Error(
+      `pi-ai has no registered model "${piAiProvider}/${modelId}". pi-ai only lists tool-calling-capable models; if your model is text-only, keep it on the AI SDK path (UNSUPPORTED_BY_PI_AI) or clear NOTCH_USE_PI_AI.`
+    );
+  }
+  return { model, piAiProvider, modelId };
+}
+async function computePiAiCostUsd(config, usage) {
+  try {
+    const handle = await resolveModelViaPiAi(config);
+    const piAi = await loadPiAi();
+    const usageBucket = {
+      input: usage.input,
+      output: usage.output,
+      cacheRead: usage.cacheRead ?? 0,
+      cacheWrite: usage.cacheWrite ?? 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    };
+    piAi.calculateCost(handle.model, usageBucket);
+    return usageBucket.cost.total;
+  } catch {
+    return null;
+  }
+}
+var shadowContexts = /* @__PURE__ */ new WeakMap();
+function registerShadowContext(model, context) {
+  if (piAiMode() === "off") return;
+  shadowContexts.set(model, context);
+}
+async function recordShadowUsage(model, usage, opts) {
+  if (piAiMode() === "off") return;
+  const ctx = shadowContexts.get(model);
+  if (!ctx) return;
+  const inputTokens = usage.promptTokens ?? 0;
+  const outputTokens = usage.completionTokens ?? 0;
+  const piAiCostUsd = await computePiAiCostUsd(ctx.config, {
+    input: inputTokens,
+    output: outputTokens
+  });
+  await recordShadowCost({
+    requestId: opts?.requestId ?? `usage-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    provider: ctx.provider,
+    modelId: ctx.modelId,
+    inputTokens,
+    outputTokens,
+    piAiCostUsd,
+    stripeChargeUsd: opts?.stripeChargeUsd ?? null,
+    timestamp: Date.now()
+  });
+}
+async function recordShadowCost(event) {
+  if (piAiMode() === "off") return;
+  try {
+    const { homedir } = await import("os");
+    const { mkdir, appendFile } = await import("fs/promises");
+    const { join } = await import("path");
+    const dir = join(homedir(), ".notch");
+    await mkdir(dir, { recursive: true });
+    await appendFile(join(dir, "pi-ai-shadow.jsonl"), `${JSON.stringify(event)}
+`, "utf8");
+  } catch {
+  }
+}
+var piAiModulePromise = null;
+async function loadPiAi() {
+  if (!piAiModulePromise) {
+    piAiModulePromise = (async () => {
+      try {
+        const mod = await import("@mariozechner/pi-ai");
+        return mod;
+      } catch (err) {
+        piAiModulePromise = null;
+        throw new PiAiNotInstalledError(err);
+      }
+    })();
+  }
+  return piAiModulePromise;
+}
+function extractProvider(config) {
+  if (config.byokProvider) return config.byokProvider;
+  if (typeof config.model === "string" && isByokRef(config.model)) {
+    return parseByokRef(config.model).provider;
+  }
+  return void 0;
+}
+function extractProviderAndModel(config) {
+  if (config.byokProvider) {
+    return {
+      providerName: config.byokProvider,
+      modelId: typeof config.model === "string" ? config.model : ""
+    };
+  }
+  if (typeof config.model === "string" && isByokRef(config.model)) {
+    const { provider, model } = parseByokRef(config.model);
+    return { providerName: provider, modelId: model };
+  }
+  throw new Error(
+    "resolveModelViaPiAi called on a non-BYOK config. Notch-hosted Modal endpoints still use the AI SDK path."
+  );
+}
+
+// src/providers/registry.ts
 var MissingApiKeyError = class extends Error {
   /** Which flow caused this error (informs the onboarding message). */
   flow;
@@ -421,22 +611,40 @@ function isValidModel(id) {
 }
 function modelSupportsImages(modelId) {
   if (!modelId) return false;
+  const lowerModelId = modelId.toLowerCase();
   if (modelId in MODEL_CATALOG) return true;
-  if (modelId.startsWith("notch-")) return true;
-  const prefix = modelId.split(":", 1)[0]?.toLowerCase() ?? "";
+  if (lowerModelId.startsWith("notch-")) return true;
+  const ref = isByokRef(lowerModelId) ? parseByokRef(lowerModelId) : null;
+  const prefix = ref?.provider ?? "";
   switch (prefix) {
     case "openai":
     case "anthropic":
     case "google":
     case "together":
-    case "openrouter":
       return true;
+    case "openrouter":
+      return openRouterModelSupportsImages(ref?.model ?? "");
     case "groq":
       return false;
     default:
       return false;
   }
 }
+function openRouterModelSupportsImages(upstreamModelId) {
+  return [
+    "openai/gpt-5.3-codex",
+    "openai/gpt-5.2-codex",
+    "openai/gpt-5.1-codex",
+    "openai/gpt-5-codex",
+    "anthropic/claude-sonnet-4.6",
+    "anthropic/claude-sonnet-4.5",
+    "anthropic/claude-sonnet-4",
+    "moonshotai/kimi-k2.6",
+    "moonshotai/kimi-k2.5",
+    "~anthropic/claude-sonnet-latest",
+    "~moonshotai/kimi-latest"
+  ].some((id) => upstreamModelId === id || upstreamModelId.startsWith(`${id}:`));
+}
 function resolveModel(config) {
   if (config.byokProvider) {
     const resolved = resolveByokModel({
@@ -447,6 +655,7 @@ function resolveModel(config) {
       headers: { ...config.headers, ...config.byokHeaders },
       apiShape: config.byokApiShape
     });
+    firePiAiShadowProbe(config, resolved.model);
     return resolved.model;
   }
   if (typeof config.model === "string" && isByokRef(config.model)) {
@@ -459,12 +668,13 @@ function resolveModel(config) {
       headers: { ...config.headers, ...config.byokHeaders },
       apiShape: config.byokApiShape
     });
+    firePiAiShadowProbe(config, resolved.model);
     return resolved.model;
   }
   const info = MODEL_CATALOG[config.model];
   if (!info) {
     throw new Error(
-      `Unknown model "${config.model}". Notch models: ${MODEL_IDS.join(", ")}. For BYOK use "<provider>:<model>" (e.g. openrouter:anthropic/claude-sonnet-4-6).`
+      `Unknown model "${config.model}". Use provider/model, for example openrouter/anthropic/claude-sonnet-4-6.`
     );
   }
   const baseUrl = config.baseUrl ?? process.env.NOTCH_BASE_URL ?? info.baseUrl;
@@ -525,6 +735,47 @@ async function validateConfig(config) {
     return { ok: false, error: `Cannot reach Notch ${info.label} at ${baseUrl}` };
   }
 }
+function firePiAiShadowProbe(config, resolvedModel) {
+  if (piAiMode() === "off") return;
+  if (!shouldRouteViaPiAi(config)) return;
+  const provider = extractByokProvider(config);
+  const modelId = typeof config.model === "string" ? config.model : "unknown";
+  if (provider) {
+    registerShadowContext(resolvedModel, {
+      provider,
+      modelId,
+      config
+    });
+  }
+  void (async () => {
+    let handle = null;
+    let error = null;
+    try {
+      handle = await resolveModelViaPiAi(config);
+    } catch (err) {
+      error = err instanceof Error ? err.message : String(err);
+    }
+    await recordShadowCost({
+      requestId: `probe-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+      provider: handle?.piAiProvider ?? provider ?? "unknown",
+      modelId: handle?.modelId ?? modelId,
+      inputTokens: 0,
+      // real counts come from loop.ts via recordShadowUsage
+      outputTokens: 0,
+      piAiCostUsd: null,
+      stripeChargeUsd: null,
+      timestamp: Date.now(),
+      ...error ? { error } : {}
+    });
+  })();
+}
+function extractByokProvider(config) {
+  if (config.byokProvider) return config.byokProvider;
+  if (typeof config.model === "string" && isByokRef(config.model)) {
+    return parseByokRef(config.model).provider;
+  }
+  return void 0;
+}
 
 export {
   findByokProvider,
@@ -534,9 +785,9 @@ export {
   ByokMissingApiKeyError,
   ByokMissingBaseUrlError,
   resolveByokModel,
+  recordShadowUsage,
   MissingApiKeyError,
   MODEL_CATALOG,
-  MODEL_IDS,
   isValidModel,
   modelSupportsImages,
   resolveModel,

package/dist/{chunk-J66N6AFH.js → chunk-UHK6SI4H.js}

@@ -4,11 +4,18 @@ import {
 import {
   findByokProvider,
   isByokRef,
-  isValidModel
-} from "./chunk-JXQ4HZ47.js";
+  isValidModel,
+  listByokProviders,
+  parseByokRef
+} from "./chunk-JVFOAPYV.js";
+import {
+  OLLAMA_LOCAL_BASE_URL,
+  listModels
+} from "./chunk-GFVLHUSS.js";
 import {
   init_auth,
-  loadCredentials
+  loadCredentials,
+  loadSyncedByokKeys
 } from "./chunk-PPEBWOMJ.js";
 
 // src/config.ts
@@ -16,7 +23,7 @@ import fs from "fs/promises";
 import path from "path";
 init_auth();
 var DEFAULT_MODEL = {
-  model: "notch-pyre",
+  model: "openrouter/anthropic/claude-sonnet-4-6",
   temperature: 0.3
 };
 var DEFAULTS = {
@@ -33,17 +40,20 @@ var DEFAULTS = {
 };
 async function loadConfig(overrides = {}) {
   const config = { ...DEFAULTS, models: { chat: { ...DEFAULT_MODEL } } };
+  let explicitModelConfig = false;
   const configPath = path.resolve(config.projectRoot, ".notch.json");
   try {
     const raw = await fs.readFile(configPath, "utf-8");
     const fileConfig = JSON.parse(raw);
     if (fileConfig.model && (isValidModel(fileConfig.model) || isByokRef(fileConfig.model))) {
       config.models.chat.model = fileConfig.model;
+      explicitModelConfig = true;
     }
     if (fileConfig.baseUrl) config.models.chat.baseUrl = fileConfig.baseUrl;
     if (fileConfig.apiKey) config.models.chat.apiKey = fileConfig.apiKey;
-    if (fileConfig.byok && typeof fileConfig.byok === "object") {
-      const byok = fileConfig.byok;
+    const providerBlock = fileConfig.provider && typeof fileConfig.provider === "object" ? fileConfig.provider : fileConfig.byok;
+    if (providerBlock && typeof providerBlock === "object") {
+      const byok = providerBlock;
       config.byok = { ...byok };
       if (byok.provider && findByokProvider(byok.provider === "custom" ? "__custom__" : byok.provider)) {
         config.models.chat.byokProvider = byok.provider === "custom" ? "__custom__" : byok.provider;
@@ -55,6 +65,7 @@ async function loadConfig(overrides = {}) {
         if (byok.apiShape === "openai" || byok.apiShape === "anthropic") {
           config.models.chat.byokApiShape = byok.apiShape;
         }
+        explicitModelConfig = true;
       }
     }
     if (fileConfig.hybrid && typeof fileConfig.hybrid === "object") {
@@ -72,7 +83,34 @@ async function loadConfig(overrides = {}) {
     if (fileConfig.theme) config.theme = fileConfig.theme;
   } catch {
   }
-  const activeProviderId = config.models.chat.byokProvider ?? (typeof config.models.chat.model === "string" && isByokRef(config.models.chat.model) ? config.models.chat.model.split(":", 1)[0] : void 0);
+  if (process.env.NOTCH_PROVIDER) {
+    const providerId = process.env.NOTCH_PROVIDER === "custom" ? "__custom__" : process.env.NOTCH_PROVIDER;
+    const provider = findByokProvider(providerId);
+    if (provider) {
+      config.models.chat.byokProvider = providerId;
+      config.models.chat.model = process.env.NOTCH_MODEL || provider.defaultModel;
+      explicitModelConfig = true;
+    }
+  } else if (process.env.NOTCH_MODEL) {
+    const envModel = process.env.NOTCH_MODEL;
+    if (isValidModel(envModel)) {
+      config.models.chat.model = envModel;
+      config.models.chat.byokProvider = void 0;
+      explicitModelConfig = true;
+    } else if (isByokRef(envModel)) {
+      config.models.chat.model = envModel;
+      config.models.chat.byokProvider = void 0;
+      explicitModelConfig = true;
+    }
+  }
+  if (!explicitModelConfig) {
+    const inferred = await inferDefaultProviderConfig();
+    config.models.chat.model = inferred.modelRef;
+    config.models.chat.byokProvider = void 0;
+    if (inferred.baseUrl) config.models.chat.baseUrl = inferred.baseUrl;
+    if (inferred.apiShape) config.models.chat.byokApiShape = inferred.apiShape;
+  }
+  const activeProviderId = config.models.chat.byokProvider ?? (typeof config.models.chat.model === "string" && isByokRef(config.models.chat.model) ? parseByokRef(config.models.chat.model).provider : void 0);
   const isOllamaProvider = activeProviderId === "ollama" || activeProviderId === "ollama-cloud" || activeProviderId === "ollama-anthropic";
   if (isOllamaProvider) {
     if (!config.models.chat.apiKey && !process.env.OLLAMA_API_KEY) {
@@ -81,25 +119,16 @@ async function loadConfig(overrides = {}) {
         config.models.chat.apiKey = ollamaCreds.apiKey;
       }
     }
-  } else {
+  } else if (!activeProviderId) {
     const creds = await loadCredentials();
     if (creds?.token) {
       config.models.chat.apiKey = creds.token;
     }
   }
-  if (process.env.NOTCH_MODEL) {
-    const envModel = process.env.NOTCH_MODEL;
-    if (isValidModel(envModel)) {
-      config.models.chat.model = envModel;
-    } else if (isByokRef(envModel)) {
-      config.models.chat.model = envModel;
-      config.models.chat.byokProvider = void 0;
-    }
-  }
   if (process.env.NOTCH_BASE_URL) {
     config.models.chat.baseUrl = process.env.NOTCH_BASE_URL;
   }
-  if (process.env.NOTCH_API_KEY) {
+  if (process.env.NOTCH_API_KEY && !activeProviderId) {
     config.models.chat.apiKey = process.env.NOTCH_API_KEY;
   }
   if (config.models.chat.temperature !== void 0) {
@@ -108,6 +137,46 @@ async function loadConfig(overrides = {}) {
   config.maxIterations = Math.max(1, Math.min(100, config.maxIterations));
   return { ...config, ...overrides };
 }
+async function inferDefaultProviderConfig() {
+  const providers = listByokProviders();
+  const envMatch = providers.find((p) => p.apiKeyEnv && process.env[p.apiKeyEnv]);
+  if (envMatch) return { modelRef: `${envMatch.id}/${envMatch.defaultModel}` };
+  const synced = await loadSyncedByokKeys();
+  if (synced) {
+    const syncedMatch = providers.find((p) => {
+      const key = synced.keys[p.id];
+      return typeof key === "string" && key.length > 0;
+    });
+    if (syncedMatch) return { modelRef: `${syncedMatch.id}/${syncedMatch.defaultModel}` };
+    if (synced.localEndpoint) {
+      return {
+        modelRef: "custom/local-model",
+        baseUrl: synced.localEndpoint,
+        apiShape: "openai"
+      };
+    }
+  }
+  const localOllama = await inferLocalOllamaModel();
+  if (localOllama) return localOllama;
+  const openrouter = findByokProvider("openrouter");
+  if (openrouter) return { modelRef: `${openrouter.id}/${openrouter.defaultModel}` };
+  const first = providers[0];
+  return { modelRef: first ? `${first.id}/${first.defaultModel}` : DEFAULT_MODEL.model };
+}
+async function inferLocalOllamaModel() {
+  try {
+    const baseUrl = process.env.OLLAMA_HOST?.startsWith("http") ? process.env.OLLAMA_HOST : OLLAMA_LOCAL_BASE_URL;
+    const rows = await listModels(baseUrl, { timeoutMs: 300 });
+    const modelName = rows[0]?.name;
+    if (!modelName) return null;
+    return {
+      modelRef: `ollama/${modelName}`,
+      baseUrl: `${baseUrl.replace(/\/+$/, "")}/v1`
+    };
+  } catch {
+    return null;
+  }
+}
 async function persistConfigPatch(projectRoot, patch) {
   const configPath = path.resolve(projectRoot, ".notch.json");
   let current = {};