@semanticist14/clco 0.2.1 → 0.2.2

package/README.md

@@ -246,7 +246,9 @@ curl -fsSL https://raw.githubusercontent.com/semanticist21/clco/main/uninstall.s
      Responses API where a model requires it (the GPT-5.x family). SSE
      streaming, tool calling, images and parallel tool calls work on both.
 
-   A rejected native attempt falls back to the translated path. Only an
+   A rejected native attempt falls back to the translated path, except a
+   context overflow, which comes back as Anthropic's own error so Claude Code
+   can compact. Only an
    unsupported model/endpoint rejection (including HTTP 404) is remembered;
    other request errors leave native routing available on the next turn.
    Route changes are recorded in the adapter log (`CLCO_DEBUG=1` in run mode).
@@ -278,8 +280,9 @@ CLCO_UPSTREAM=http://127.0.0.1:9099 bun run scripts/mock-upstream.ts
   personal use.
 - Extended thinking works on the native route only; it stays disabled on
   translated routes. `stop_sequences` are not enforced on Responses-API models.
-- `/effort` is forwarded when the selected model declares that level, and
-  dropped otherwise — rows in `/model` say which do not support it.
+- `/effort` maps to the nearest level the selected model declares (ties go
+  up; kimi's low/high/max turns `medium` into `high`) and is dropped for models
+  with none — rows in `/model` say which.
 - Catalog-known Claude rows recalculate their context handling when `/model`
   switches. Non-catalog rows use a conservative session ceiling because
   Claude Code cannot inspect their upstream context limit; this can compact

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semanticist14/clco",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "private": false,
   "type": "module",
   "description": "Run Claude Code on a GitHub Copilot subscription",

package/src/auth.ts

@@ -110,6 +110,7 @@ export async function runDeviceFlow(): Promise<{ token: string; login?: string }
       try {
         const user = await copilotFetch(`${GITHUB_API_BASE_URL}/user`, {
           headers: githubRequestHeaders(token),
+          signal: AbortSignal.timeout(15_000),
         })
         if (user.ok) login = ((await user.json()) as { login?: string }).login
       } catch {

package/src/claudehome.ts

@@ -26,6 +26,7 @@ import {
   writeFile,
 } from "node:fs/promises"
 import { homedir } from "node:os"
+import { isDeepStrictEqual } from "node:util"
 import { join } from "node:path"
 
 /** Written by claude during a session — must stay private to clco. */
@@ -46,6 +47,7 @@ const PRIVATE_ENTRIES = new Set([
  * user's file every launch discarded whatever claude had persisted in the
  * private one.
  */
+
 /**
  * clco owns routing and auth: ANTHROPIC_BASE_URL and the bearer travel in
  * the --settings tier. A provider env block in the user's own settings.json
@@ -75,20 +77,43 @@ function denyServerWebSearch(parsed: Record<string, unknown>): void {
   parsed.permissions = permissions
 }
 
-async function writeSettings(real: string, home: string): Promise<void> {
-  const target = join(home, "settings.json")
-  const source = await readFile(join(real, "settings.json"), "utf8").catch(
-    () => null,
-  )
-  const existing = await readFile(target, "utf8").catch(() => null)
-  const raw = source ?? existing
-  if (raw === null) return
+// What clco last derived from the user's settings.json. A three-way merge
+// against it tells the keys claude persisted during a clco session (kept)
+// from the ones the user changed in their own file since (taken).
+const SETTINGS_BASE = ".clco-settings-base.json"
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v)
+}
+
+/** Objects merge key by key, lists element by element; on a scalar clash clco's side wins. */
+export function merge3(base: unknown, mine: unknown, theirs: unknown): unknown {
+  if (isPlainObject(mine) && isPlainObject(theirs)) {
+    const b = isPlainObject(base) ? base : {}
+    const out: Record<string, unknown> = {}
+    for (const key of new Set([...Object.keys(mine), ...Object.keys(theirs)])) {
+      const v = merge3(b[key], mine[key], theirs[key])
+      if (v !== undefined) out[key] = v
+    }
+    return out
+  }
+  if (isDeepStrictEqual(mine, base)) return theirs
+  if (isDeepStrictEqual(theirs, base)) return mine
+  if (Array.isArray(mine) && Array.isArray(theirs) && Array.isArray(base)) {
+    // Both edited a list (permissions.allow, hooks): keep each side's
+    // additions and removals rather than one side's whole list.
+    const has = (list: unknown[], x: unknown) => list.some((y) => isDeepStrictEqual(x, y))
+    return [
+      ...theirs.filter((x) => !has(base, x) || has(mine, x)),
+      ...mine.filter((x) => !has(base, x) && !has(theirs, x)),
+    ]
+  }
+  return mine
+}
+
+function parseSettings(raw: string): Record<string, unknown> {
   try {
-    const parsed = JSON.parse(raw) as Record<string, unknown>
-    delete parsed.model
-    stripRoutingEnv(parsed)
-    denyServerWebSearch(parsed)
-    await atomicWrite(target, JSON.stringify(parsed, null, 2) + "\n")
+    return JSON.parse(raw) as Record<string, unknown>
   } catch {
     // claude tolerates comments where JSON.parse does not. A line-based regex
     // was worse than useless here: deleting the last key's line left a
@@ -96,25 +121,57 @@ async function writeSettings(real: string, home: string): Promise<void> {
     // nested in other objects, and it missed the key when it shared a line.
     // Strip comments, parse, and re-emit — losing the comments is a smaller
     // loss than losing the settings.
+    return JSON.parse(stripJsonComments(raw)) as Record<string, unknown>
+  }
+}
+
+function sanitizeSettings(parsed: Record<string, unknown>): Record<string, unknown> {
+  delete parsed.model
+  stripRoutingEnv(parsed)
+  denyServerWebSearch(parsed)
+  return parsed
+}
+
+async function writeSettings(real: string, home: string): Promise<void> {
+  const target = join(home, "settings.json")
+  const basePath = join(home, SETTINGS_BASE)
+  const source = await readFile(join(real, "settings.json"), "utf8").catch(
+    () => null,
+  )
+  const existing = await readFile(target, "utf8").catch(() => null)
+  if (source === null && existing === null) return
+  let theirs: Record<string, unknown>
+  try {
+    theirs = sanitizeSettings(parseSettings(source ?? existing!))
+  } catch (err) {
+    // Neither form parses: keep the previous private file rather than
+    // replace it with something broken, and say so - a stale `model` here
+    // is exactly what this function exists to prevent.
+    const first = existing === null
+    console.error(
+      `[clco] could not parse ${join(real, "settings.json")} (${(err as Error).message}) - ` +
+        (first
+          ? "this session starts with NO settings: no env, no hooks, no permissions."
+          : "clco's copy was left as it was."),
+    )
+    return
+  }
+  let merged = theirs
+  if (source !== null && existing !== null) {
     try {
-      const parsed = JSON.parse(stripJsonComments(raw)) as Record<string, unknown>
-      delete parsed.model
-    stripRoutingEnv(parsed)
-    denyServerWebSearch(parsed)
-      await atomicWrite(target, JSON.stringify(parsed, null, 2) + "\n")
-    } catch (err) {
-      // Neither form parses: keep the previous private file rather than
-      // replace it with something broken, and say so - a stale `model` here
-      // is exactly what this function exists to prevent.
-      const first = existing === null
-      console.error(
-        `[clco] could not parse ${join(real, "settings.json")} (${(err as Error).message}) - ` +
-          (first
-            ? "this session starts with NO settings: no env, no hooks, no permissions."
-            : "clco's copy was left as it was."),
-      )
+      const mine = parseSettings(existing)
+      const baseRaw = await readFile(basePath, "utf8").catch(() => null)
+      // No snapshot (first launch on this version): earlier versions rebuilt
+      // the private copy from the user's file every launch, so let it win.
+      const base = baseRaw === null ? mine : JSON.parse(baseRaw)
+      merged = sanitizeSettings(merge3(base, mine, theirs) as Record<string, unknown>)
+    } catch {
+      // An unreadable private copy has nothing worth keeping.
     }
   }
+  await atomicWrite(target, JSON.stringify(merged, null, 2) + "\n")
+  // A briefly missing user file keeps the old snapshot for when it returns.
+  if (source !== null) await atomicWrite(basePath, JSON.stringify(theirs, null, 2) + "\n")
 }
 
 /** Comments only — string contents are left alone. */
@@ -181,6 +238,27 @@ async function atomicWrite(path: string, data: string): Promise<void> {
   }
 }
 
+const PROJECT_MCP_KEYS = [
+  "mcpServers",
+  "enabledMcpjsonServers",
+  "disabledMcpjsonServers",
+  "enableAllProjectMcpServers",
+]
+// The real file's per-project MCP keys as last synced. Plain claude writes
+// empty defaults for every project, so "absent/empty there" cannot mean
+// "removed": only a change since this snapshot propagates.
+const CLAUDE_JSON_BASE = ".clco-claude-json-base.json"
+
+function projectMcp(json: Record<string, unknown>): Record<string, Record<string, unknown>> {
+  const out: Record<string, Record<string, unknown>> = {}
+  for (const [path, entry] of Object.entries((json.projects ?? {}) as Record<string, Record<string, unknown>>)) {
+    const keys: Record<string, unknown> = {}
+    for (const key of PROJECT_MCP_KEYS) if (entry?.[key] !== undefined) keys[key] = entry[key]
+    out[path] = keys
+  }
+  return out
+}
+
 /**
  * `.claude.json` carries trust decisions, MCP server definitions (with their
  * env secrets) and project history. Seeded once so the first session inherits
@@ -191,30 +269,46 @@ async function atomicWrite(path: string, data: string): Promise<void> {
  */
 async function syncClaudeState(userHome: string, home: string): Promise<void> {
   const target = join(home, ".claude.json")
+  const basePath = join(home, CLAUDE_JSON_BASE)
   const source = await readFile(join(userHome, ".claude.json"), "utf8").catch(
     () => null,
   )
   if (source === null) return
   const existing = await readFile(target, "utf8").catch(() => null)
-  if (existing === null) {
-    await copyFile(join(userHome, ".claude.json"), target).catch(() => {})
-    return
-  }
   try {
     const real = JSON.parse(source) as Record<string, unknown>
-    const mine = JSON.parse(existing) as Record<string, unknown>
-    mine.mcpServers = real.mcpServers
-    const realProjects = (real.projects ?? {}) as Record<string, { hasTrustDialogAccepted?: boolean }>
-    const myProjects = (mine.projects ?? {}) as Record<string, { hasTrustDialogAccepted?: boolean }>
-    for (const [path, entry] of Object.entries(myProjects)) {
-      // Absent means "no opinion", not "withdrawn". clco sessions run against
-      // the private config dir, so a project only ever used through clco is
-      // never recorded in the real file at all — forcing false there re-asked
-      // the trust question on every single launch.
-      const trusted = realProjects[path]?.hasTrustDialogAccepted
-      if (trusted !== undefined) entry.hasTrustDialogAccepted = trusted
+    if (existing === null) {
+      await copyFile(join(userHome, ".claude.json"), target)
+    } else {
+      const mine = JSON.parse(existing) as Record<string, unknown>
+      mine.mcpServers = real.mcpServers
+      const realProjects = (real.projects ?? {}) as Record<string, Record<string, unknown>>
+      const myProjects = (mine.projects ?? {}) as Record<string, Record<string, unknown>>
+      const baseRaw = await readFile(basePath, "utf8").catch(() => null)
+      // No snapshot (first launch on this version): earlier versions never
+      // synced these keys, so keep what clco has until the real file changes.
+      const base = baseRaw === null ? projectMcp(real) : JSON.parse(baseRaw)
+      if (Object.keys(realProjects).length > 0) mine.projects = myProjects
+      for (const [path, theirs] of Object.entries(realProjects)) {
+        const entry = (myProjects[path] ??= {})
+        // Local-scope MCP servers (the `claude mcp add` default) and the
+        // .mcp.json approvals live per project; a removal must reach clco.
+        for (const key of PROJECT_MCP_KEYS) {
+          const v = merge3(base[path]?.[key], entry[key], theirs[key])
+          if (v === undefined) delete entry[key]
+          else entry[key] = v
+        }
+        // Absent means "no opinion", not "withdrawn". clco sessions run against
+        // the private config dir, so a project only ever used through clco is
+        // never recorded in the real file at all — forcing false there re-asked
+        // the trust question on every single launch.
+        if (theirs.hasTrustDialogAccepted !== undefined) {
+          entry.hasTrustDialogAccepted = theirs.hasTrustDialogAccepted
+        }
+      }
+      await atomicWrite(target, JSON.stringify(mine, null, 2) + "\n")
     }
-    await atomicWrite(target, JSON.stringify(mine, null, 2) + "\n")
+    await atomicWrite(basePath, JSON.stringify(projectMcp(real)) + "\n")
   } catch {
     // Unparseable on either side: leave what is there rather than lose it.
   }
@@ -274,8 +368,20 @@ export async function prepareClaudeHome(
         // Trusting an existing link without checking left ones pointing at a
         // previous $HOME pointing there forever.
         if ((await readlink(link).catch(() => null)) === target) continue
+        await rm(link, { force: true })
+        await symlink(target, link)
+        continue
+      }
+      if (existing) {
+        // A real entry means claude created it here before ~/.claude had one
+        // (clco used before plain claude). Folding it in automatically races
+        // running sessions and concurrent launches, so leave it and say so.
+        console.error(
+          `[clco] ${link} is clco's own copy, so ~/.claude/${name} is not shared yet.` +
+            ` Merge it into ${target} and delete it to share.`,
+        )
+        continue
       }
-      if (existing) await rm(link, { recursive: true, force: true })
       await symlink(target, link)
     } catch {
       // One unlinkable entry should not sink the session.

package/src/cli.ts

@@ -851,7 +851,7 @@ async function main(): Promise<void> {
   // user passes their own --mcp-config, and claiming success there would be
   // the same trap as registering a server with no extension.
   const injected = setupClaudeArgs(setup, args.overrides, args.claudeArgs, browserExtension, searchAgent)
-  const registered = injected.includes("--mcp-config")
+  const registered = injected.some((a) => a.startsWith("--mcp-config="))
   const browserLine = startupLine(
     browserEnabled,
     browserExtension,
@@ -869,7 +869,7 @@ async function main(): Promise<void> {
   console.error(
     webEnabled && !searchAgent
       ? "+ web: unavailable (Copilot exposed no search-agent model)"
-      : webEnabled && injected.includes("--mcp-config")
+      : webEnabled && registered
       ? `+ web: search via ${searchAgent} planner + live local execution`
       : webEnabled
         ? "+ web: enabled in setup, but not registered because --mcp-config was supplied"

package/src/config.ts

@@ -8,7 +8,6 @@ import {
   readFile,
   rename,
   rm,
-  unlink,
   writeFile,
 } from "node:fs/promises"
 import { homedir } from "node:os"
@@ -72,18 +71,7 @@ export async function loadAuth(): Promise<AuthStore | null> {
 export async function saveAuth(auth: AuthStore): Promise<void> {
   await mkdir(authDir(), { recursive: true })
   await chmod(authDir(), 0o700).catch(() => {})
-  const tmp = join(authDir(), `.auth.${process.pid}.tmp`)
-  const handle = await openExclusive(tmp)
-  try {
-    await handle.writeFile(JSON.stringify(auth, null, 2) + "\n")
-    await handle.close()
-    await rename(tmp, authPath())
-    await chmod(authPath(), 0o600).catch(() => {})
-  } catch (err) {
-    await handle.close().catch(() => {})
-    await unlink(tmp).catch(() => {})
-    throw err
-  }
+  await writeSecret(authPath(), JSON.stringify(auth, null, 2) + "\n")
 }
 
 // "wx": fail if the temp file already exists (never truncate through a
@@ -121,10 +109,17 @@ function prefsPath(): string {
 
 export async function loadPrefs(): Promise<Prefs> {
   await migrateFromClcopilot()
+  const raw = await readFile(prefsPath(), "utf8").catch((err) => {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return null
+    throw err
+  })
+  if (raw === null) return {}
   try {
-    return JSON.parse(await readFile(prefsPath(), "utf8")) as Prefs
-  } catch {
-    return {}
+    return JSON.parse(raw) as Prefs
+  } catch (err) {
+    // Treating it as empty let the next save overwrite the setup answers and
+    // the stored extension token with defaults.
+    throw new Error(`${prefsPath()} is not valid JSON (${(err as Error).message}) - fix or delete it`)
   }
 }
 
@@ -137,15 +132,19 @@ export async function loadPrefs(): Promise<Prefs> {
  */
 async function writeSecret(path: string, data: string): Promise<void> {
   const tmp = `${path}.tmp.${process.pid}`
+  // A crash can leave one behind, and "wx" would then refuse it forever.
   await rm(tmp, { force: true }).catch(() => {})
   const handle = await openExclusive(tmp)
   try {
     await handle.writeFile(data)
-  } finally {
     await handle.close()
+    await chmod(tmp, 0o600).catch(() => {})
+    await rename(tmp, path)
+  } catch (err) {
+    await handle.close().catch(() => {})
+    await rm(tmp, { force: true }).catch(() => {})
+    throw err
   }
-  await chmod(tmp, 0o600).catch(() => {})
-  await rename(tmp, path)
 }
 
 export async function savePrefs(prefs: Prefs): Promise<void> {

package/src/responses.ts

@@ -166,7 +166,9 @@ export function toResponsesRequest(
       description: t.description,
       parameters: t.input_schema,
     })),
-    tool_choice: pinnedMissing
+    tool_choice: servable.length === 0
+      ? undefined
+      : pinnedMissing
       ? ("auto" as const)
       : choice?.type === "auto"
         ? ("auto" as const)

package/src/server.ts

@@ -146,6 +146,9 @@ function detectVision(payload: OpenAIRequest): boolean {
 }
 
 const routes = new DialectRouter()
+// Anthropic's wording, OpenAI's, and Copilot's own pre-check.
+const CONTEXT_OVERFLOW =
+  /prompt is too long|context[ _](?:length|window)|maximum context|prompt token count of \d+ exceeds the limit|max_prompt_tokens_exceeded/i
 
 type ChatResult =
   | { ok: true; res: Response; dialect: Dialect }
@@ -225,9 +228,13 @@ async function copilotChat(
     // evidence changes future routing. Quota, auth and rate-limit failures
     // are not shape problems, so they surface
     // as-is rather than burning a second upstream call.
+    // A context overflow is the request's own fault, not the route's: the
+    // translated retry would only swap Anthropic's "prompt is too long" (the
+    // text Claude Code's reactive compaction keys on) for another error.
     if (
       dialect === "native" &&
-      [400, 404, 415, 422].includes(res.status)
+      [400, 404, 415, 422].includes(res.status) &&
+      !CONTEXT_OVERFLOW.test(text)
     ) {
       debug("native /v1/messages rejected:", res.status, text.slice(0, 300))
       const remembered = routes.rejectNative(payload.model, res.status, text)
@@ -246,7 +253,16 @@ async function copilotChat(
       dialect = "responses"
       continue
     }
-    return { ok: false, status: res.status, message: friendlyUpstreamError(text) }
+    const message = friendlyUpstreamError(text)
+    return {
+      ok: false,
+      status: res.status,
+      // Claude Code starts reactive compaction on Anthropic's phrase; give
+      // every dialect's overflow that phrase.
+      message: CONTEXT_OVERFLOW.test(text) && !/prompt is too long/i.test(message)
+        ? `prompt is too long: ${message}`
+        : message,
+    }
   }
   return { ok: false, status: 502, message: "upstream retry exhausted" }
 }
@@ -414,7 +430,7 @@ async function handleMessages(
   }
   const stream = payload.stream === true
   logLine(
-    `[${timestamp()}] POST /v1/messages model=${payload.model} stream=${stream}`,
+    `[${timestamp()}] POST /v1/messages model=${payload.model} stream=${stream} effort=${payload.output_config?.effort ?? "-"}`,
   )
 
   const info = modelInfo(normalizeModel(payload.model))

package/src/setup.ts

@@ -166,7 +166,9 @@ export function setupClaudeArgs(
   const webRequested = setup.web === true && overrides.web !== false
   if ((browserRequested || webRequested) && !has("--mcp-config")) {
     const config = combinedMcpConfig(browserExtension, webRequested, searchAgent)
-    if (config) out.push("--mcp-config", config)
+    // One argv element: claude's --mcp-config is variadic, so a separate value
+    // would also swallow a positional prompt that follows (`clco -- "ask"`).
+    if (config) out.push(`--mcp-config=${config}`)
   }
   return out
 }

package/src/token.ts

@@ -59,7 +59,15 @@ async function fetchCopilotToken(): Promise<string> {
     // Short metadata call — never let a hung connection stall startup.
     signal: AbortSignal.timeout(10_000),
   })
-  if (res.status === 401 || res.status === 403) {
+  if (res.status === 403) {
+    // A valid token refused Copilot (no seat, org policy, SSO): re-auth would
+    // only fetch another token that hits the same wall.
+    const detail = await res.text().catch(() => "")
+    throw new Error(
+      `Copilot access denied: HTTP 403 (check your Copilot seat or org policy)${detail ? ` - ${detail.slice(0, 300)}` : ""}`,
+    )
+  }
+  if (res.status === 401) {
     // The stored GitHub token is revoked/expired — drop it so the next
     // ensureGithubToken can pick up a fresh one after re-auth.
     githubToken = null

package/src/translate.ts

@@ -39,15 +39,34 @@ function marked(blocks: unknown): boolean {
 const COPILOT_CACHE = { type: "ephemeral" } as const
 
 // Copilot declares the reasoning_effort values each model accepts in its
-// /models capabilities. Send the effort only when the model claims it —
-// anything else is dropped rather than risking a 400.
+// /models capabilities, and they rarely match Claude Code's tiers one to one
+// (kimi offers low/high/max, gpt-5-mini tops out at high). A tier the model
+// lacks maps to its nearest declared one, ties going up, so /effort still
+// moves the dial instead of silently falling back to the upstream default.
+const EFFORT_ORDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max"]
+
 export function effortFor(
   payload: AnthropicRequest,
   allowed: string[] | null | undefined,
 ): string | undefined {
   const effort = payload.output_config?.effort
-  if (!effort || !allowed || !allowed.includes(effort)) return undefined
-  return effort
+  if (!effort || !allowed || allowed.length === 0) return undefined
+  if (allowed.includes(effort)) return effort
+  const want = EFFORT_ORDER.indexOf(effort)
+  if (want < 0) return undefined
+  let best: string | undefined
+  let bestDistance = Infinity
+  for (const value of allowed) {
+    // "none" turns reasoning off; never pick it for a tier that asked for some.
+    const rank = value === "none" ? -1 : EFFORT_ORDER.indexOf(value)
+    if (rank < 0) continue
+    const distance = Math.abs(rank - want)
+    if (distance < bestDistance || (distance === bestDistance && rank > want)) {
+      best = value
+      bestDistance = distance
+    }
+  }
+  return best
 }
 
 // ---------------------------------------------------------------------------
@@ -236,8 +255,11 @@ function translateSystem(
 function translateTools(
   tools: AnthropicRequest["tools"],
 ): OpenAIRequest["tools"] {
-  if (!tools || tools.length === 0) return undefined
-  return tools.map((tool) => ({
+  // Claude's server-side tools (web_search, ...) carry no input_schema and
+  // cannot run as client functions; drop them like the Responses path does.
+  const servable = tools?.filter((tool) => tool.input_schema)
+  if (!servable || servable.length === 0) return undefined
+  return servable.map((tool) => ({
     type: "function" as const,
     function: {
       name: tool.name,
@@ -276,6 +298,7 @@ export function translateRequest(
   allowedEfforts?: string[] | null,
 ): OpenAIRequest {
   const effort = effortFor(payload, allowedEfforts)
+  const tools = translateTools(payload.tools)
   return {
     model: normalizeModel(payload.model),
     ...(effort && { reasoning_effort: effort }),
@@ -301,15 +324,11 @@ export function translateRequest(
     temperature: payload.temperature,
     top_p: payload.top_p,
     user: payload.metadata?.user_id ?? null,
-    tools: translateTools(payload.tools),
-    tool_choice: translateToolChoice(
-      payload.tool_choice,
-      new Set(
-        (payload.tools ?? [])
-          .filter((tool) => tool.input_schema)
-          .map((tool) => tool.name),
-      ),
-    ),
+    tools,
+    // A tool_choice with no tools left is a 400 on OpenAI-style endpoints.
+    tool_choice: tools
+      ? translateToolChoice(payload.tool_choice, new Set(tools.map((t) => t.function.name)))
+      : undefined,
   }
 }