npm - kanna-code - Versions diffs - 0.32.0 → 0.32.2 - Mend

kanna-code 0.32.0 → 0.32.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/dist/client/assets/index-B3EUEMfY.css +32 -0
package/dist/client/assets/index-CdBLcsbf.js +2598 -0
package/dist/client/index.html +2 -2
package/package.json +1 -1
package/src/server/codex-app-server.test.ts +155 -0
package/src/server/codex-app-server.ts +49 -1
package/src/server/diff-store.test.ts +57 -0
package/src/server/diff-store.ts +29 -8
package/src/server/event-store.test.ts +1 -1
package/src/server/llm-provider.ts +58 -0
package/src/server/provider-catalog.test.ts +5 -5
package/src/server/quick-response.ts +1 -1
package/src/server/read-models.test.ts +1 -1
package/src/server/server.ts +2 -1
package/src/server/ws-router.test.ts +4 -0
package/src/server/ws-router.ts +19 -0
package/src/shared/protocol.ts +7 -0
package/src/shared/types.ts +37 -4
package/dist/client/assets/index-BxEBJJ_f.css +0 -32
package/dist/client/assets/index-CoeDwJZ0.js +0 -2593

package/dist/client/index.html CHANGED Viewed

@@ -30,8 +30,8 @@
       })()
     </script>
     <title>Kanna</title>
-    <script type="module" crossorigin src="/assets/index-CoeDwJZ0.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BxEBJJ_f.css">
+    <script type="module" crossorigin src="/assets/index-CdBLcsbf.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B3EUEMfY.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "kanna-code",
   "type": "module",
-  "version": "0.32.0",
+  "version": "0.32.2",
   "description": "A beautiful web UI for Claude Code",
   "license": "MIT",
   "keywords": [

package/src/server/codex-app-server.test.ts CHANGED Viewed

@@ -672,6 +672,161 @@ describe("CodexAppServerManager", () => {
     })
   })
+  test("maps plain-text fileChange adds into write_file tool calls", async () => {
+    const process = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-1" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      } else if (message.method === "turn/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { turn: { id: "turn-1", status: "inProgress", error: null } },
+        })
+        child.writeServerMessage({
+          method: "item/completed",
+          params: {
+            threadId: "thread-1",
+            turnId: "turn-1",
+            item: {
+              type: "fileChange",
+              id: "call-1",
+              changes: [
+                {
+                  path: "/tmp/project/test.md",
+                  kind: {
+                    type: "add",
+                    move_path: null,
+                  },
+                  diff: "hello\nworld\n",
+                },
+              ],
+              status: "completed",
+            },
+          },
+        })
+        child.writeServerMessage({
+          method: "turn/completed",
+          params: {
+            threadId: "thread-1",
+            turn: { id: "turn-1", status: "completed", error: null },
+          },
+        })
+      }
+    })
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+    await manager.startSession({
+      chatId: "chat-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+    })
+    const turn = await manager.startTurn({
+      chatId: "chat-1",
+      model: "gpt-5.4",
+      content: "write a file",
+      planMode: false,
+      onToolRequest: async () => ({}),
+    })
+    const events = await collectStream(turn.stream)
+    const toolCall = events.find((event) => event.type === "transcript" && event.entry.kind === "tool_call")
+    expect(toolCall?.entry.kind).toBe("tool_call")
+    if (!toolCall || toolCall.entry.kind !== "tool_call") throw new Error("missing tool call")
+    expect(toolCall.entry.tool.toolKind).toBe("write_file")
+    expect(toolCall.entry.tool.input).toEqual({
+      filePath: "/tmp/project/test.md",
+      content: "hello\nworld\n",
+    })
+  })
+  test("maps plain-text fileChange deletes into delete_file tool calls", async () => {
+    const process = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-1" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      } else if (message.method === "turn/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { turn: { id: "turn-1", status: "inProgress", error: null } },
+        })
+        child.writeServerMessage({
+          method: "item/completed",
+          params: {
+            threadId: "thread-1",
+            turnId: "turn-1",
+            item: {
+              type: "fileChange",
+              id: "call-1",
+              changes: [
+                {
+                  path: "/tmp/project/test.md",
+                  kind: {
+                    type: "delete",
+                    move_path: null,
+                  },
+                  diff: "hello\nworld\n",
+                },
+              ],
+              status: "completed",
+            },
+          },
+        })
+        child.writeServerMessage({
+          method: "turn/completed",
+          params: {
+            threadId: "thread-1",
+            turn: { id: "turn-1", status: "completed", error: null },
+          },
+        })
+      }
+    })
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+    await manager.startSession({
+      chatId: "chat-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+    })
+    const turn = await manager.startTurn({
+      chatId: "chat-1",
+      model: "gpt-5.4",
+      content: "delete a file",
+      planMode: false,
+      onToolRequest: async () => ({}),
+    })
+    const events = await collectStream(turn.stream)
+    const toolCall = events.find((event) => event.type === "transcript" && event.entry.kind === "tool_call")
+    expect(toolCall?.entry.kind).toBe("tool_call")
+    if (!toolCall || toolCall.entry.kind !== "tool_call") throw new Error("missing tool call")
+    expect(toolCall.entry.tool.toolKind).toBe("delete_file")
+    expect(toolCall.entry.tool.toolName).toBe("Delete")
+    expect(toolCall.entry.tool.input).toEqual({
+      filePath: "/tmp/project/test.md",
+      content: "hello\nworld\n",
+    })
+  })
   test("splits multi-change fileChange items into multiple tool calls and results", async () => {
     const process = new FakeCodexProcess((message, child) => {
       if (message.method === "initialize") {

package/src/server/codex-app-server.ts CHANGED Viewed

@@ -430,6 +430,18 @@ function parseUnifiedDiff(diff: string): { oldString: string; newString: string
   }
 }
+function isUnifiedDiff(diff: string) {
+  return diff.includes("@@")
+    || diff.startsWith("---")
+    || diff.startsWith("+++")
+    || diff.split(/\r?\n/).some((line) => (
+      line.startsWith("+")
+      || line.startsWith("-")
+      || line.startsWith(" ")
+      || line === "\"
+    ))
+}
 function fileChangeToToolCalls(item: Extract<ThreadItem, { type: "fileChange" }>): TranscriptEntry[] {
   return item.changes.map((change, index) => {
     const payload = fileChangePayload(item, change)
@@ -453,7 +465,10 @@ function fileChangeToToolCalls(item: Extract<ThreadItem, { type: "fileChange" }>
     }
     if (typeof change.diff === "string") {
-      const { oldString, newString } = parseUnifiedDiff(change.diff)
+      const diffIsUnified = isUnifiedDiff(change.diff)
+      const { oldString, newString } = diffIsUnified
+        ? parseUnifiedDiff(change.diff)
+        : { oldString: change.diff, newString: change.diff }
       if (normalizedKind.type === "add") {
         return timestamped({
@@ -473,6 +488,22 @@ function fileChangeToToolCalls(item: Extract<ThreadItem, { type: "fileChange" }>
       }
       if (normalizedKind.type === "update") {
+        if (!diffIsUnified) {
+          return timestamped({
+            kind: "tool_call",
+            tool: {
+              kind: "tool",
+              toolKind: "unknown_tool",
+              toolName: "FileChange",
+              toolId,
+              input: {
+                payload,
+              },
+              rawInput: payload,
+            },
+          })
+        }
         return timestamped({
           kind: "tool_call",
           tool: {
@@ -489,6 +520,23 @@ function fileChangeToToolCalls(item: Extract<ThreadItem, { type: "fileChange" }>
           },
         })
       }
+      if (normalizedKind.type === "delete") {
+        return timestamped({
+          kind: "tool_call",
+          tool: {
+            kind: "tool",
+            toolKind: "delete_file",
+            toolName: "Delete",
+            toolId,
+            input: {
+              filePath: change.path,
+              content: oldString,
+            },
+            rawInput: payload,
+          },
+        })
+      }
     }
     return timestamped({

package/src/server/diff-store.test.ts CHANGED Viewed

@@ -176,6 +176,41 @@ describe("DiffStore", () => {
     expect((await run(["git", "log", "-1", "--pretty=%s"], repoRoot)).trim()).toBe("Local only")
   })
+  test("commits tracked files inside newly ignored directories", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await mkdir(path.join(repoRoot, "build", ".wrangler"), { recursive: true })
+    await writeFile(path.join(repoRoot, "build", ".wrangler", "state.sqlite"), "base\n", "utf8")
+    await run(["git", "add", "."], repoRoot)
+    await run(["git", "commit", "-m", "init"], repoRoot)
+    await writeFile(path.join(repoRoot, "build", ".gitignore"), ".wrangler/\n", "utf8")
+    await writeFile(path.join(repoRoot, "build", ".wrangler", "state.sqlite"), "changed\n", "utf8")
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await store.refreshSnapshot("project-1", repoRoot)
+    const result = await store.commitFiles({
+      projectId: "project-1",
+      projectPath: repoRoot,
+      paths: ["build/.wrangler/state.sqlite"],
+      summary: "Commit tracked ignored file",
+      mode: "commit_only",
+    })
+    expect(result).toMatchObject({
+      ok: true,
+      mode: "commit_only",
+      pushed: false,
+    })
+    expect((await run(["git", "log", "-1", "--pretty=%s"], repoRoot)).trim()).toBe("Commit tracked ignored file")
+    const snapshot = store.getProjectSnapshot("project-1")
+    expect(snapshot.files).toHaveLength(1)
+    expect(snapshot.files[0]?.path).toBe("build/.gitignore")
+  })
   test("refreshSnapshot reports origin presence before the first commit", async () => {
     const repoRoot = await createRepo()
     tempDirs.push(repoRoot)
@@ -235,6 +270,28 @@ describe("DiffStore", () => {
     })
   })
+  test("refreshSnapshot tolerates tracked files replaced by directories", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await writeFile(path.join(repoRoot, "thing"), "base\n", "utf8")
+    await run(["git", "add", "."], repoRoot)
+    await run(["git", "commit", "-m", "init"], repoRoot)
+    await rm(path.join(repoRoot, "thing"), { force: true })
+    await mkdir(path.join(repoRoot, "thing"), { recursive: true })
+    await writeFile(path.join(repoRoot, "thing", "file.txt"), "nested\n", "utf8")
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await expect(store.refreshSnapshot("project-1", repoRoot)).resolves.toBe(true)
+    const snapshot = store.getProjectSnapshot("project-1")
+    expect(snapshot.status).toBe("ready")
+    expect(snapshot.files).toHaveLength(2)
+    expect(snapshot.files.map((file) => file.path)).toEqual(["thing", "thing/file.txt"])
+    expect(snapshot.files.map((file) => file.changeType)).toEqual(["deleted", "added"])
+  })
   test("discardFile reverts a tracked modified file", async () => {
     const repoRoot = await createRepo()
     tempDirs.push(repoRoot)

package/src/server/diff-store.ts CHANGED Viewed

@@ -179,12 +179,20 @@ function summarizeGitFailure(detail: string, fallback: string) {
 }
 function createCommitFailure(mode: DiffCommitMode, detail: string): DiffCommitResult {
-  const message = summarizeGitFailure(detail, "Git could not create the commit.")
+  const normalized = detail.toLowerCase()
+  let title = "Commit failed"
+  let message = summarizeGitFailure(detail, "Git could not create the commit.")
+  if (normalized.includes("ignored by one of your .gitignore files")) {
+    title = "Ignored files cannot be staged"
+    message = "One or more selected paths are ignored by .gitignore. Unignore them or remove them from the commit selection."
+  }
   return {
     ok: false,
     mode,
     phase: "commit",
-    title: "Commit failed",
+    title,
     message,
     detail,
   }
@@ -848,7 +856,8 @@ async function listDirtyPaths(repoRoot: string) {
 async function readWorktreeFile(repoRoot: string, relativePath: string): Promise<string | null> {
   const absolutePath = path.join(repoRoot, relativePath)
-  if (!(await fileExists(absolutePath))) {
+  const fileInfo = await stat(absolutePath).catch(() => null)
+  if (!fileInfo?.isFile()) {
     return null
   }
@@ -2017,15 +2026,27 @@ export class DiffStore {
     ])
     const hasOriginRemote = originRemoteUrl !== null
-    const currentDirtyPaths = new Set((await listDirtyPaths(repo.repoRoot)).map((entry) => entry.path))
-    const missingPaths = normalizedPaths.filter((relativePath) => !currentDirtyPaths.has(relativePath))
+    const currentDirtyEntries = await listDirtyPaths(repo.repoRoot)
+    const currentDirtyPathsByPath = new Map(currentDirtyEntries.map((entry) => [entry.path, entry]))
+    const missingPaths = normalizedPaths.filter((relativePath) => !currentDirtyPathsByPath.has(relativePath))
     if (missingPaths.length > 0) {
       throw new Error(`File is no longer changed: ${missingPaths[0]}`)
     }
-    const addResult = await runGit(["add", "--", ...normalizedPaths], repo.repoRoot)
-    if (addResult.exitCode !== 0) {
-      throw new Error(addResult.stderr.trim() || "Failed to stage selected files")
+    const trackedPaths = normalizedPaths.filter((relativePath) => !currentDirtyPathsByPath.get(relativePath)?.isUntracked)
+    if (trackedPaths.length > 0) {
+      const addTrackedResult = await runGit(["add", "-u", "--", ...trackedPaths], repo.repoRoot)
+      if (addTrackedResult.exitCode !== 0) {
+        return createCommitFailure(args.mode, formatGitFailure(addTrackedResult))
+      }
+    }
+    const untrackedPaths = normalizedPaths.filter((relativePath) => currentDirtyPathsByPath.get(relativePath)?.isUntracked)
+    if (untrackedPaths.length > 0) {
+      const addUntrackedResult = await runGit(["add", "--", ...untrackedPaths], repo.repoRoot)
+      if (addUntrackedResult.exitCode !== 0) {
+        return createCommitFailure(args.mode, formatGitFailure(addUntrackedResult))
+      }
     }
     const commitArgs = ["commit", "--only", "-m", summary]

package/src/server/event-store.test.ts CHANGED Viewed

@@ -181,7 +181,7 @@ describe("EventStore", () => {
       content: "second queued",
       attachments: [],
       provider: "claude",
-      model: "sonnet",
+      model: "claude-sonnet-4-6",
       planMode: true,
     })

package/src/server/llm-provider.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import path from "node:path"
+import OpenAI from "openai"
 import { getLlmProviderFilePath } from "../shared/branding"
 import {
   DEFAULT_OPENAI_SDK_MODEL,
@@ -8,6 +9,7 @@ import {
   type LlmProviderFile,
   type LlmProviderKind,
   type LlmProviderSnapshot,
+  type LlmProviderValidationResult,
 } from "../shared/types"
 export const OPENAI_BASE_URL = "https://api.openai.com/v1"
@@ -147,3 +149,59 @@ export async function writeLlmProviderSnapshot(
   await writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8")
   return snapshot
 }
+function toSerializableValue(value: unknown): unknown {
+  if (value === null || value === undefined) return value ?? null
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value
+  if (Array.isArray(value)) {
+    return value.map((entry) => toSerializableValue(entry))
+  }
+  if (value instanceof Error) {
+    return toSerializableValue(Object.fromEntries(
+      Object.getOwnPropertyNames(value).map((key) => [key, (value as unknown as Record<string, unknown>)[key]])
+    ))
+  }
+  if (typeof value === "object") {
+    const record = value as Record<string, unknown>
+    return Object.fromEntries(
+      Object.keys(record).map((key) => [key, toSerializableValue(record[key])])
+    )
+  }
+  return String(value)
+}
+export async function validateLlmProviderCredentials(
+  value: Pick<LlmProviderSnapshot, "provider" | "apiKey" | "model" | "baseUrl">
+): Promise<LlmProviderValidationResult> {
+  const snapshot = normalizeLlmProviderSnapshot(value)
+  if (!snapshot.enabled) {
+    return {
+      ok: false,
+      error: {
+        type: "config_error",
+        message: snapshot.warning ?? "LLM provider configuration is incomplete.",
+      },
+    }
+  }
+  try {
+    const client = new OpenAI({
+      apiKey: snapshot.apiKey,
+      baseURL: snapshot.resolvedBaseUrl,
+    })
+    await client.responses.create({
+      model: snapshot.model,
+      input: "Reply with ok.",
+      max_output_tokens: 5,
+    })
+    return {
+      ok: true,
+      error: null,
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      error: toSerializableValue(error),
+    }
+  }
+}

package/src/server/provider-catalog.test.ts CHANGED Viewed

@@ -8,14 +8,14 @@ import { resolveClaudeApiModelId } from "../shared/types"
 describe("provider catalog normalization", () => {
   test("maps legacy Claude effort into shared model options", () => {
-    expect(normalizeClaudeModelOptions("opus", undefined, "max")).toEqual({
+    expect(normalizeClaudeModelOptions("claude-opus-4-7", undefined, "max")).toEqual({
       reasoningEffort: "max",
       contextWindow: "200k",
     })
   })
   test("normalizes Claude context window only for supported models", () => {
-    expect(normalizeClaudeModelOptions("sonnet", {
+    expect(normalizeClaudeModelOptions("claude-sonnet-4-6", {
       claude: {
         reasoningEffort: "medium",
         contextWindow: "1m",
@@ -25,7 +25,7 @@ describe("provider catalog normalization", () => {
       contextWindow: "1m",
     })
-    expect(normalizeClaudeModelOptions("haiku", {
+    expect(normalizeClaudeModelOptions("claude-haiku-4-5-20251001", {
       claude: {
         reasoningEffort: "medium",
         contextWindow: "1m",
@@ -56,7 +56,7 @@ describe("provider catalog normalization", () => {
   })
   test("resolves Claude API model ids for 1m context window", () => {
-    expect(resolveClaudeApiModelId("opus", "1m")).toBe("opus[1m]")
-    expect(resolveClaudeApiModelId("sonnet", "200k")).toBe("sonnet")
+    expect(resolveClaudeApiModelId("claude-opus-4-7", "1m")).toBe("claude-opus-4-7[1m]")
+    expect(resolveClaudeApiModelId("claude-sonnet-4-6", "200k")).toBe("claude-sonnet-4-6")
   })
 })

package/src/server/quick-response.ts CHANGED Viewed

@@ -98,7 +98,7 @@ export async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs
     prompt: args.prompt,
     options: {
       cwd: args.cwd,
-      model: "haiku",
+      model: "claude-haiku-4-5-20251001",
       tools: [],
       systemPrompt: "",
       effort: "low",

package/src/server/read-models.test.ts CHANGED Viewed

@@ -62,7 +62,7 @@ describe("read models", () => {
       attachments: [],
       createdAt: 2,
       provider: "claude",
-      model: "sonnet",
+      model: "claude-sonnet-4-6",
       planMode: true,
     }])

package/src/server/server.ts CHANGED Viewed

@@ -8,7 +8,7 @@ import { AgentCoordinator } from "./agent"
 import { DiffStore } from "./diff-store"
 import { discoverProjects, type DiscoveredProject } from "./discovery"
 import { KeybindingsManager } from "./keybindings"
-import { readLlmProviderSnapshot, writeLlmProviderSnapshot } from "./llm-provider"
+import { readLlmProviderSnapshot, validateLlmProviderCredentials, writeLlmProviderSnapshot } from "./llm-provider"
 import { getMachineDisplayName } from "./machine-name"
 import { TerminalManager } from "./terminal-manager"
 import { UpdateManager } from "./update-manager"
@@ -124,6 +124,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     llmProvider: {
       read: readLlmProviderSnapshot,
       write: writeLlmProviderSnapshot,
+      validate: validateLlmProviderCredentials,
     },
     refreshDiscovery,
     getDiscoveredProjects: () => discoveredProjects,

package/src/server/ws-router.test.ts CHANGED Viewed

@@ -142,6 +142,10 @@ describe("ws-router", () => {
             enabled: Boolean(value.apiKey && value.model),
           }
         },
+        validate: async () => ({
+          ok: true,
+          error: null,
+        }),
       },
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],

package/src/server/ws-router.ts CHANGED Viewed

@@ -13,6 +13,7 @@ import { TerminalManager } from "./terminal-manager"
 import type { UpdateManager } from "./update-manager"
 import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
 import type { LlmProviderSnapshot } from "../shared/types"
+import type { LlmProviderValidationResult } from "../shared/types"
 const DEFAULT_CHAT_RECENT_LIMIT = 200
@@ -100,6 +101,7 @@ interface CreateWsRouterArgs {
   llmProvider?: {
     read: () => Promise<LlmProviderSnapshot>
     write: (value: Pick<LlmProviderSnapshot, "provider" | "apiKey" | "model" | "baseUrl">) => Promise<LlmProviderSnapshot>
+    validate: (value: Pick<LlmProviderSnapshot, "provider" | "apiKey" | "model" | "baseUrl">) => Promise<LlmProviderValidationResult>
   }
   refreshDiscovery: () => Promise<DiscoveredProject[]>
   getDiscoveredProjects: () => DiscoveredProject[]
@@ -203,6 +205,13 @@ export function createWsRouter({
       warning: null,
       filePathDisplay: "~/.kanna/llm-provider.json",
     }),
+    validate: async () => ({
+      ok: false,
+      error: {
+        type: "config_error",
+        message: "LLM provider validation unavailable.",
+      },
+    }),
   }
   function getProtectedChatIds() {
@@ -730,6 +739,16 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
           return
         }
+        case "settings.validateLlmProvider": {
+          const result = await resolvedLlmProvider.validate({
+            provider: command.provider,
+            apiKey: command.apiKey,
+            model: command.model,
+            baseUrl: command.baseUrl,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          return
+        }
         case "project.open": {
           await ensureProjectDirectory(command.localPath)
           const project = await store.openProject(command.localPath)

package/src/shared/protocol.ts CHANGED Viewed

@@ -66,6 +66,13 @@ export type ClientCommand =
       model: string
       baseUrl: string
     }
+  | {
+      type: "settings.validateLlmProvider"
+      provider: LlmProviderSnapshot["provider"]
+      apiKey: string
+      model: string
+      baseUrl: string
+    }
   | {
       type: "system.openExternal"
       localPath: string