@llm4ts/core 3.3.0 → 3.4.0

package/src/providers/ClaudeCliConnector.ts

@@ -11,7 +11,8 @@ import {
   ConnectorIds,
   LlmChunk,
   TokenUsage,
-  type JsonSchema
+  type JsonSchema,
+  cliExecutable
 } from "../Models.ts"
 import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
 import { collect } from "../Streaming.ts"
@@ -37,6 +38,8 @@ import {
   jsonObjectEntries
 } from "./CliSupport.ts"
 
+const executable = cliExecutable("ClaudeCli")
+
 /**
  * `claude auth status --json` reads the credential store and answers
  * `{"loggedIn": true|false, ...}` without a request to Anthropic. A claude
@@ -243,7 +246,7 @@ export const makeClaudeCliConnector = (
     prompt: string
   ) {
     const result = yield* executor.runWithStdin(
-      ["claude", "--print", ...extraArgs],
+      [executable, "--print", ...extraArgs],
       cwd,
       config.envVars,
       prompt
@@ -269,7 +272,7 @@ export const makeClaudeCliConnector = (
         ([model, said]) =>
           executor
             .runStreamingWithStdin(
-              ["claude", "--print", "--output-format", "stream-json", "--verbose", ...extraArgs],
+              [executable, "--print", "--output-format", "stream-json", "--verbose", ...extraArgs],
               cwd,
               config.envVars,
               prompt
@@ -341,11 +344,11 @@ export const makeClaudeCliConnector = (
       // another way are not), so the grade is partial.
       pathDeny: "partial"
     }),
-    buildArgv: (prompt, _context) => ["claude", "--print", ...extraArgs, prompt],
-    buildInteractiveArgv: (_context) => ["claude", ...extraArgs],
+    buildArgv: (prompt, _context) => [executable, "--print", ...extraArgs, prompt],
+    buildInteractiveArgv: (_context) => [executable, ...extraArgs],
     complete,
     completeStream,
-    versionProbe: { executor, binary: "claude", cwd, authProbe: claudeAuthProbe }
+    versionProbe: { executor, binary: executable, cwd, authProbe: claudeAuthProbe }
   })
 
   const executeStructuredWithUsage = <A, E, RD, RE>(

package/src/providers/CodexConnector.ts

@@ -10,7 +10,8 @@ import {
   ConnectorIds,
   LlmChunk,
   TokenUsage,
-  type JsonSchema
+  type JsonSchema,
+  cliExecutable
 } from "../Models.ts"
 import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
 import { collect } from "../Streaming.ts"
@@ -33,6 +34,8 @@ import {
   type JsonValue
 } from "./CliSupport.ts"
 
+const executable = cliExecutable("Codex")
+
 export const codexExtraArgs = (config: CliConnectorConfig): ReadonlyArray<string> => {
   const effectiveFlags = config.readOnly
     ? {
@@ -251,7 +254,7 @@ export const makeCodexConnector = (
     prompt: string
   ) {
     const result = yield* executor.runWithStdin(
-      ["codex", "exec", ...extraArgs],
+      [executable, "exec", ...extraArgs],
       cwd,
       config.envVars,
       prompt
@@ -265,7 +268,7 @@ export const makeCodexConnector = (
   })
 
   const completeStream = (prompt: string) =>
-    rawStream(["codex", "exec", "--json", ...extraArgs], prompt).pipe(
+    rawStream([executable, "exec", "--json", ...extraArgs], prompt).pipe(
       Stream.mapEffect(failCodexChunk)
     )
 
@@ -279,11 +282,11 @@ export const makeCodexConnector = (
       effort: "mapped",
       isolatedHeadless: "partial"
     }),
-    buildArgv: (prompt, _context) => ["codex", "exec", ...extraArgs, prompt],
-    buildInteractiveArgv: (_context) => ["codex", ...extraArgs],
+    buildArgv: (prompt, _context) => [executable, "exec", ...extraArgs, prompt],
+    buildInteractiveArgv: (_context) => [executable, ...extraArgs],
     complete,
     completeStream,
-    versionProbe: { executor, binary: "codex", cwd, authProbe: codexAuthProbe }
+    versionProbe: { executor, binary: executable, cwd, authProbe: codexAuthProbe }
   })
 
   const executeStructuredWithUsage = <A, E, RD, RE>(
@@ -308,7 +311,7 @@ export const makeCodexConnector = (
           jsonText(codexStrictSchema(jsonSchema))
         )
         const reply = yield* collect(
-          rawStream(["codex", "exec", "--json", "--output-schema", path, ...extraArgs], prompt)
+          rawStream([executable, "exec", "--json", "--output-schema", path, ...extraArgs], prompt)
         )
         if (reply.metadata.codexError !== undefined) {
           return yield* failClassifiedCliError("codex", "codex error", reply.metadata.codexError)

package/src/providers/ConnectorFactories.ts

@@ -1,10 +1,12 @@
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as Record from "effect/Record"
 import {
   ApiConnectorConfig,
   CliConnectorConfig,
   toLlmConfig,
-  type ConnectorConfig
+  type ConnectorConfig,
+  type ConnectorConfigOf
 } from "../ConnectorConfig.ts"
 import {
   ConnectorRegistry,
@@ -15,7 +17,14 @@ import {
 import type { ConnectorShape } from "../Connector.ts"
 import { ConfigError, type LlmError } from "../Errors.ts"
 import { HttpClient, type HttpClientShape } from "../HttpClient.ts"
-import { ConnectorIds, LlmConfig, type ConnectorId, type ConnectorKind } from "../Models.ts"
+import {
+  ConnectorIds,
+  LlmConfig,
+  isCliConnectorName,
+  type ConnectorId,
+  type ConnectorKind,
+  type ConnectorName
+} from "../Models.ts"
 import { ProcessExecutor, type ProcessExecutorShape } from "../ProcessExecutor.ts"
 import { TemporaryFiles, type TemporaryFilesShape } from "../TemporaryFiles.ts"
 import { makeAnthropicProvider } from "./AnthropicProvider.ts"
@@ -76,58 +85,51 @@ const cliFactory = (
       : Effect.fail(expectedConfig("Cli", id))
 })
 
+// A connector without an entry here does not compile. The registry lists
+// them in this order.
+const builders: {
+  readonly [K in ConnectorName]: (
+    config: ConnectorConfigOf<K>,
+    dependencies: ConnectorFactoryDependencies
+  ) => ConnectorShape
+} = {
+  OpenAI: (config, { http }) => makeOpenAIProvider(toLlmConfig(config), http),
+  Anthropic: (config, { http }) => makeAnthropicProvider(toLlmConfig(config), http),
+  GeminiApi: (config, { http }) => makeGeminiApiProvider(toLlmConfig(config), http),
+  LmStudio: (config, { http }) => makeLmStudioProvider(toLlmConfig(config), http),
+  Ollama: (config, { http }) => makeOllamaProvider(toLlmConfig(config), http),
+  MlxLm: (config, { http }) => makeMlxLmProvider(toLlmConfig(config), http),
+  ClaudeCli: (config, { process }) => makeClaudeCliConnector(config, process),
+  OpenCode: (config, { process }) => makeOpenCodeCliConnector(config, process),
+  GeminiCli: (config, { geminiCli }) =>
+    makeGeminiCliProvider(
+      LlmConfig.make({
+        provider: "GeminiCli",
+        model: config.model ?? "gemini-2.5-flash"
+      }),
+      geminiCli,
+      geminiCliExecutionContextFrom(config)
+    ),
+  Codex: (config, { process, temporaryFiles }) =>
+    makeCodexConnector(config, process, temporaryFiles),
+  Copilot: (config, { process }) => makeCopilotConnector(config, process),
+  Pi: (config, { process }) => makePiConnector(config, process),
+  AntigravityCli: (config, { process }) => makeAntigravityConnector(config, process),
+  Grok: (config, { process }) => makeGrokCliConnector(config, process),
+  Cursor: (config, { process }) => makeCursorConnector(config, process),
+  Mock: (config) => makeMockProvider(toLlmConfig(config))
+}
+
 export const createConnectorRegistry = (
   dependencies: ConnectorFactoryDependencies
 ): ConnectorRegistryShape =>
-  makeConnectorRegistry([
-    apiFactory(ConnectorIds.OpenAI, (config) =>
-      makeOpenAIProvider(toLlmConfig(config), dependencies.http)
-    ),
-    apiFactory(ConnectorIds.Anthropic, (config) =>
-      makeAnthropicProvider(toLlmConfig(config), dependencies.http)
-    ),
-    apiFactory(ConnectorIds.GeminiApi, (config) =>
-      makeGeminiApiProvider(toLlmConfig(config), dependencies.http)
-    ),
-    apiFactory(ConnectorIds.LmStudio, (config) =>
-      makeLmStudioProvider(toLlmConfig(config), dependencies.http)
-    ),
-    apiFactory(ConnectorIds.Ollama, (config) =>
-      makeOllamaProvider(toLlmConfig(config), dependencies.http)
-    ),
-    apiFactory(ConnectorIds.MlxLm, (config) =>
-      makeMlxLmProvider(toLlmConfig(config), dependencies.http)
-    ),
-    cliFactory(ConnectorIds.ClaudeCli, (config) =>
-      makeClaudeCliConnector(config, dependencies.process)
-    ),
-    cliFactory(ConnectorIds.OpenCode, (config) =>
-      makeOpenCodeCliConnector(config, dependencies.process)
-    ),
-    cliFactory(ConnectorIds.GeminiCli, (config) =>
-      makeGeminiCliProvider(
-        LlmConfig.make({
-          provider: "GeminiCli",
-          model: config.model ?? "gemini-2.5-flash"
-        }),
-        dependencies.geminiCli,
-        geminiCliExecutionContextFrom(config)
-      )
-    ),
-    cliFactory(ConnectorIds.Codex, (config) =>
-      makeCodexConnector(config, dependencies.process, dependencies.temporaryFiles)
-    ),
-    cliFactory(ConnectorIds.Copilot, (config) =>
-      makeCopilotConnector(config, dependencies.process)
-    ),
-    cliFactory(ConnectorIds.Pi, (config) => makePiConnector(config, dependencies.process)),
-    cliFactory(ConnectorIds.AntigravityCli, (config) =>
-      makeAntigravityConnector(config, dependencies.process)
-    ),
-    cliFactory(ConnectorIds.Grok, (config) => makeGrokCliConnector(config, dependencies.process)),
-    cliFactory(ConnectorIds.Cursor, (config) => makeCursorConnector(config, dependencies.process)),
-    apiFactory(ConnectorIds.Mock, (config) => makeMockProvider(toLlmConfig(config)))
-  ])
+  makeConnectorRegistry(
+    Record.keys(builders).map((name) =>
+      isCliConnectorName(name)
+        ? cliFactory(ConnectorIds[name], (config) => builders[name](config, dependencies))
+        : apiFactory(ConnectorIds[name], (config) => builders[name](config, dependencies))
+    )
+  )
 
 export const ConnectorRegistryLive = Layer.effect(
   ConnectorRegistry,

package/src/providers/CopilotConnector.ts

@@ -2,12 +2,14 @@ import * as Effect from "effect/Effect"
 import * as Stream from "effect/Stream"
 import { makeCliConnector, type CliConnectorShape } from "../Connector.ts"
 import type { CliConnectorConfig } from "../ConnectorConfig.ts"
-import { ConnectorCapabilities, ConnectorIds, LlmChunk } from "../Models.ts"
+import { ConnectorCapabilities, ConnectorIds, LlmChunk, cliExecutable } from "../Models.ts"
 import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
 import { failClassifiedCliError } from "./CliSupport.ts"
 
+const executable = cliExecutable("Copilot")
+
 export const buildCopilotArgv = (prompt: string): ReadonlyArray<string> => [
-  "gh",
+  executable,
   "copilot",
   "suggest",
   "-t",
@@ -46,7 +48,7 @@ export const makeCopilotConnector = (
       readOnlyEnforcement: "ignored"
     }),
     buildArgv: (prompt, _context) => buildCopilotArgv(prompt),
-    buildInteractiveArgv: (_context) => ["gh", "copilot"],
+    buildInteractiveArgv: (_context) => [executable, "copilot"],
     complete,
     completeStream: (prompt) =>
       Stream.fromEffect(complete(prompt)).pipe(
@@ -55,6 +57,6 @@ export const makeCopilotConnector = (
     // No auth probe: `gh auth status` validates every stored token against
     // the GitHub API (and `gh auth token` would print the secret), so there
     // is no offline login check to run; the login stays Unknown.
-    versionProbe: { executor, binary: "gh", versionArgs: ["copilot", "--version"], cwd: "." }
+    versionProbe: { executor, binary: executable, versionArgs: ["copilot", "--version"], cwd: "." }
   })
 }

package/src/providers/CursorConnector.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect"
 import * as Stream from "effect/Stream"
 import { makeCliConnector, type CliAuthProbe, type CliConnectorShape } from "../Connector.ts"
 import type { CliConnectorConfig } from "../ConnectorConfig.ts"
-import { ConnectorCapabilities, ConnectorIds, LlmChunk } from "../Models.ts"
+import { ConnectorCapabilities, ConnectorIds, LlmChunk, cliExecutable } from "../Models.ts"
 import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
 import {
   failClassifiedCliError,
@@ -19,6 +19,8 @@ import {
   type JsonValue
 } from "./CliSupport.ts"
 
+const executable = cliExecutable("Cursor")
+
 /**
  * `cursor-agent status --format json` (alias `whoami`) answers
  * `{"isAuthenticated": true|false, ...}` from the stored tokens.
@@ -84,7 +86,7 @@ export const makeCursorConnector = (
   const cwd = config.workingDir ?? "."
   const extraArgs = cursorExtraArgs(config)
   const buildArgv = (prompt: string): ReadonlyArray<string> => [
-    "cursor-agent",
+    executable,
     ...extraArgs,
     "-p",
     prompt
@@ -107,7 +109,7 @@ export const makeCursorConnector = (
   const completeStream = (prompt: string) =>
     executor
       .runStreaming(
-        ["cursor-agent", "--output-format", "stream-json", ...extraArgs, "-p", prompt],
+        [executable, "--output-format", "stream-json", ...extraArgs, "-p", prompt],
         cwd,
         config.envVars
       )
@@ -133,9 +135,9 @@ export const makeCursorConnector = (
       readOnlyEnforcement: "ignored"
     }),
     buildArgv: (prompt, _context) => buildArgv(prompt),
-    buildInteractiveArgv: (_context) => ["cursor-agent", ...extraArgs],
+    buildInteractiveArgv: (_context) => [executable, ...extraArgs],
     complete,
     completeStream,
-    versionProbe: { executor, binary: "cursor-agent", cwd, authProbe: cursorAuthProbe }
+    versionProbe: { executor, binary: executable, cwd, authProbe: cursorAuthProbe }
   })
 }

package/src/providers/GeminiAcpSession.ts

@@ -16,6 +16,9 @@ import {
   type JsonRecord,
   type JsonValue
 } from "./CliSupport.ts"
+import { cliExecutable } from "../Models.ts"
+
+const executable = cliExecutable("GeminiCli")
 
 /**
  * ACP (Agent Client Protocol, `gemini --experimental-acp`) message shapes
@@ -28,7 +31,7 @@ import {
  * integration smoke test, not a substitute for that determinism.
  */
 export const geminiAcpArgv = (model: string | undefined): ReadonlyArray<string> => [
-  "gemini",
+  executable,
   "--experimental-acp",
   ...(model === undefined ? [] : ["-m", model])
 ]

package/src/providers/GeminiCliProvider.ts

@@ -22,7 +22,8 @@ import {
   TokenUsage,
   type JsonSchema,
   type LlmConfig,
-  type Message
+  type Message,
+  cliExecutable
 } from "../Models.ts"
 import { collect } from "../Streaming.ts"
 import { jsonCandidates, parseFromText, withSchemaHint } from "../StructuredOutput.ts"
@@ -41,6 +42,8 @@ import {
   type JsonValue
 } from "./CliSupport.ts"
 
+const executable = cliExecutable("GeminiCli")
+
 export class GeminiCliLogLine extends Schema.TaggedClass<GeminiCliLogLine>()("LogLine", {
   line: Schema.String
 }) {}
@@ -1005,14 +1008,14 @@ export const makeGeminiCliProvider = (
     id: ConnectorIds.GeminiCli,
     interactionSupport: "InteractiveStdin",
     buildArgv: (prompt, context) => [
-      "gemini",
+      executable,
       "--yolo",
       ...(context.repoPath.length === 0 ? [] : ["--include-directories", context.repoPath]),
       "-p",
       prompt
     ],
     buildInteractiveArgv: (context) => [
-      "gemini",
+      executable,
       "--yolo",
       ...(context.repoPath.length === 0 ? [] : ["--include-directories", context.repoPath])
     ],

package/src/providers/GrokCliConnector.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect"
 import * as Stream from "effect/Stream"
 import { makeCliConnector, type CliConnectorShape } from "../Connector.ts"
 import type { CliConnectorConfig } from "../ConnectorConfig.ts"
-import { ConnectorIds, LlmChunk, TokenUsage } from "../Models.ts"
+import { ConnectorIds, LlmChunk, TokenUsage, cliExecutable } from "../Models.ts"
 import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
 import {
   failClassifiedCliError,
@@ -16,6 +16,8 @@ import {
   usageEventChunk
 } from "./CliSupport.ts"
 
+const executable = cliExecutable("Grok")
+
 export const grokCliExtraArgs = (config: CliConnectorConfig): ReadonlyArray<string> => [
   ...optionalModelArgs(config.model),
   ...(config.readOnly ? ["--permission-mode", "plan"] : ["--always-approve"]),
@@ -75,7 +77,12 @@ export const makeGrokCliConnector = (
 ): CliConnectorShape => {
   const cwd = config.workingDir ?? "."
   const extraArgs = grokCliExtraArgs(config)
-  const buildArgv = (prompt: string): ReadonlyArray<string> => ["grok", ...extraArgs, "-p", prompt]
+  const buildArgv = (prompt: string): ReadonlyArray<string> => [
+    executable,
+    ...extraArgs,
+    "-p",
+    prompt
+  ]
 
   const complete = Effect.fn("@llm4ts/core/providers/GrokCliConnector.complete")(function* (
     prompt: string
@@ -91,7 +98,7 @@ export const makeGrokCliConnector = (
   const completeStream = (prompt: string) =>
     executor
       .runStreaming(
-        ["grok", "--output-format", "streaming-json", ...extraArgs, "-p", prompt],
+        [executable, "--output-format", "streaming-json", ...extraArgs, "-p", prompt],
         cwd,
         config.envVars
       )
@@ -109,10 +116,10 @@ export const makeGrokCliConnector = (
     id: ConnectorIds.Grok,
     interactionSupport: "ContinuationOnly",
     buildArgv: (prompt, _context) => buildArgv(prompt),
-    buildInteractiveArgv: (_context) => ["grok", ...extraArgs],
+    buildInteractiveArgv: (_context) => [executable, ...extraArgs],
     complete,
     completeStream,
     // No auth probe: grok offers `login` but no status subcommand; Unknown.
-    versionProbe: { executor, binary: "grok", cwd }
+    versionProbe: { executor, binary: executable, cwd }
   })
 }

package/src/providers/OpenCodeCliConnector.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect"
 import * as Stream from "effect/Stream"
 import { makeCliConnector, type CliConnectorShape } from "../Connector.ts"
 import type { CliConnectorConfig } from "../ConnectorConfig.ts"
-import { ConnectorIds, LlmChunk, TokenUsage } from "../Models.ts"
+import { ConnectorIds, LlmChunk, TokenUsage, cliExecutable } from "../Models.ts"
 import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
 import {
   failClassifiedCliError,
@@ -17,6 +17,8 @@ import {
   usageEventChunk
 } from "./CliSupport.ts"
 
+const executable = cliExecutable("OpenCode")
+
 export const openCodeCliExtraArgs = (config: CliConnectorConfig): ReadonlyArray<string> => [
   ...optionalModelArgs(config.model),
   ...(config.readOnly ? ["--agent", "plan"] : ["--auto"]),
@@ -98,7 +100,7 @@ export const makeOpenCodeCliConnector = (
   const cwd = config.workingDir ?? "."
   const extraArgs = openCodeCliExtraArgs(config)
   const buildArgv = (prompt: string): ReadonlyArray<string> => [
-    "opencode",
+    executable,
     "run",
     ...extraArgs,
     prompt
@@ -122,7 +124,7 @@ export const makeOpenCodeCliConnector = (
   const completeStream = (prompt: string) =>
     executor
       .runStreaming(
-        ["opencode", "run", "--format", "json", ...extraArgs, prompt],
+        [executable, "run", "--format", "json", ...extraArgs, prompt],
         cwd,
         config.envVars
       )
@@ -142,11 +144,11 @@ export const makeOpenCodeCliConnector = (
     id: ConnectorIds.OpenCode,
     interactionSupport: "ContinuationOnly",
     buildArgv: (prompt, _context) => buildArgv(prompt),
-    buildInteractiveArgv: (_context) => ["opencode"],
+    buildInteractiveArgv: (_context) => [executable],
     complete,
     completeStream,
     // No auth probe: `opencode auth list` lists stored credentials by
     // provider, not whether the provider this seat runs has any; Unknown.
-    versionProbe: { executor, binary: "opencode", cwd }
+    versionProbe: { executor, binary: executable, cwd }
   })
 }

package/src/providers/PiConnector.ts

@@ -3,7 +3,13 @@ import * as Stream from "effect/Stream"
 import { makeCliConnector, type CliAuthProbe, type CliConnectorShape } from "../Connector.ts"
 import type { CliConnectorConfig } from "../ConnectorConfig.ts"
 import { InvalidRequestError, ProviderError, type LlmError } from "../Errors.ts"
-import { ConnectorCapabilities, ConnectorIds, LlmChunk, TokenUsage } from "../Models.ts"
+import {
+  ConnectorCapabilities,
+  ConnectorIds,
+  LlmChunk,
+  TokenUsage,
+  cliExecutable
+} from "../Models.ts"
 import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
 import {
   atLeastVersion,
@@ -26,6 +32,8 @@ import {
   statusChunk
 } from "./CliSupport.ts"
 
+const executable = cliExecutable("Pi")
+
 /**
  * `pi auth check --model <model> --no-refresh --json` says whether pi holds
  * credentials for the provider that model resolves to:
@@ -235,7 +243,7 @@ export const makePiConnector = (
   const checkFloorOnce: Effect.Effect<void, LlmError> = Effect.suspend(() =>
     floorChecked
       ? Effect.void
-      : Effect.flatMap(executor.run(["pi", "--version"], cwd, config.envVars), (result) => {
+      : Effect.flatMap(executor.run([executable, "--version"], cwd, config.envVars), (result) => {
           const problem = piReadOnlyProblem([...result.stdout, ...result.stderr].join("\n"))
           return problem === undefined
             ? Effect.sync(() => {
@@ -250,7 +258,7 @@ export const makePiConnector = (
   ) {
     yield* checkFloorOnce
     const result = yield* executor.runWithStdin(
-      ["pi", "-p", ...extraArgs],
+      [executable, "-p", ...extraArgs],
       cwd,
       config.envVars,
       prompt
@@ -273,7 +281,7 @@ export const makePiConnector = (
       Stream.drain,
       Stream.concat(
         executor.runStreamingWithStdin(
-          ["pi", "-p", "--mode", "json", ...extraArgs],
+          [executable, "-p", "--mode", "json", ...extraArgs],
           cwd,
           config.envVars,
           prompt
@@ -306,13 +314,13 @@ export const makePiConnector = (
     }),
     // `--` ends the options (pi >= 0.84.3): a prompt starting with a dash
     // is a prompt, not a flag. Stdin paths need no separator.
-    buildArgv: (prompt, _context) => ["pi", "-p", ...extraArgs, "--", prompt],
-    buildInteractiveArgv: (_context) => ["pi", ...extraArgs],
+    buildArgv: (prompt, _context) => [executable, "-p", ...extraArgs, "--", prompt],
+    buildInteractiveArgv: (_context) => [executable, ...extraArgs],
     complete,
     completeStream,
     versionProbe: {
       executor,
-      binary: "pi",
+      binary: executable,
       cwd,
       ...(config.model === undefined ? {} : { authProbe: piAuthProbe(config.model) })
     }