typeclaw 0.37.1 → 0.37.3

package/README.md

@@ -1,10 +1,11 @@
 # TypeClaw
 
 <p align="center">
-  <img src="./docs/public/typeclaw.png" alt="TypeClaw logo" width="240" />
+  <img src="./docs/public/typeclaw-transparent.png" alt="TypeClaw logo" width="240" />
 </p>
 
-> The agent for perfectionists — crafted in every detail. It behaves in your team's chat and gets sharper the longer it runs. Sandboxed and self-managing.
+<h3 align="center">The agent for perfectionists</h3>
+<p align="center">Crafted in every detail – it behaves in your team's chat and<br />gets sharper the longer it runs. Sandboxed and self-managing.</p>
 
 ## Why?
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeclaw",
-  "version": "0.37.1",
+  "version": "0.37.3",
   "homepage": "https://github.com/typeclaw/typeclaw#readme",
   "bugs": {
     "url": "https://github.com/typeclaw/typeclaw/issues"
@@ -37,6 +37,7 @@
     "format:check": "oxfmt --check .",
     "check": "bun run typecheck && bun run lint && bun run format:check",
     "test": "bun test --parallel",
+    "dev:docs": "cd docs && bun run dev",
     "generate:schema": "bun run scripts/generate-schema.ts",
     "debug:prompt": "bun run scripts/dump-system-prompt.ts",
     "postinstall": "bun run scripts/generate-schema.ts"

package/src/agent/index.ts

@@ -15,7 +15,7 @@ import { loadMemory } from '@/bundled-plugins/memory/load-memory'
 import type { ChannelRouter } from '@/channels/router'
 import type { ReactionRef } from '@/channels/types'
 import { getConfig, resolveModel, resolveProfile } from '@/config'
-import { defaultThinkingLevelForRef, providerForModelRef, type ModelRef } from '@/config/providers'
+import { defaultThinkingLevelForRef, isOpenAiFamilyRef, providerForModelRef, type ModelRef } from '@/config/providers'
 import { renderMcpCatalog } from '@/mcp/catalog'
 import type { McpManager } from '@/mcp/manager'
 import { createMcpDispatcherTools, MCP_DISPATCHER_TOOL_NAMES } from '@/mcp/tools'
@@ -47,6 +47,7 @@ import {
   wrapSystemTool,
   zodToToolParameters,
 } from './plugin-tools'
+import { PROACTIVE_NEXT_STEP_NUDGE } from './proactive-next-step-nudge'
 import { createReloadTool } from './reload-tool'
 import type { RestartHandoffOrigin } from './restart-handoff'
 import type { SubagentBashPolicy } from './reviewer-bash-policy'
@@ -277,6 +278,7 @@ export async function createSessionWithDispose(options: CreateSessionOptions = {
           ...(options.mcpManager !== undefined ? { mcpManager: options.mcpManager } : {}),
           ...(options.subagentRegistry !== undefined ? { subagentRegistry: options.subagentRegistry } : {}),
           ...(options.suppressSystemMemory !== undefined ? { suppressSystemMemory: options.suppressSystemMemory } : {}),
+          ...(isOpenAiFamilyRef(activeRef) ? { proactiveNextStepNudge: true } : {}),
         })
 
   const getOrigin: () => SessionOrigin | undefined =
@@ -957,6 +959,7 @@ export type CreateResourceLoaderOptions = {
   // from `memory.vector.enabled` — vector is restart-required, so the boot
   // snapshot is coherent with the per-turn injection decision.
   suppressSystemMemory?: boolean
+  proactiveNextStepNudge?: boolean
 }
 
 // Origins where the operator-facing DEFAULT_SYSTEM_PROMPT, git-nudge, and the
@@ -1020,6 +1023,7 @@ export type SystemPromptComposition = {
   roleContext?: SessionRoleContext
   mcpCatalog?: string
   gitNudge: string
+  proactiveNextStepNudge?: string
   memorySection: string
 }
 
@@ -1065,6 +1069,9 @@ export function composeSystemPrompt(parts: SystemPromptComposition): string {
   if (parts.gitNudge !== '') {
     prompt = `${prompt}\n\n${parts.gitNudge}`
   }
+  if (parts.proactiveNextStepNudge !== undefined && parts.proactiveNextStepNudge !== '') {
+    prompt = `${prompt}\n\n${parts.proactiveNextStepNudge}`
+  }
   if (parts.memorySection !== '') {
     prompt = `${prompt}\n\n${parts.memorySection}`
   }
@@ -1164,6 +1171,7 @@ export async function createResourceLoader(options: CreateResourceLoaderOptions
       ? { mcpCatalog: renderMcpCatalog(options.mcpManager.listServers()) }
       : {}),
     gitNudge,
+    ...(options.proactiveNextStepNudge === true ? { proactiveNextStepNudge: PROACTIVE_NEXT_STEP_NUDGE } : {}),
     memorySection,
   })
 

package/src/agent/proactive-next-step-nudge.ts

@@ -0,0 +1,11 @@
+export const PROACTIVE_NEXT_STEP_NUDGE_TITLE = '## Proactive and requested next-step guidance'
+
+// GPT-only prompt text is intentionally absent from scripts/dump-system-prompt.ts
+// token accounting because the dump tooling renders with non-GPT placeholders.
+export const PROACTIVE_NEXT_STEP_NUDGE = [
+  PROACTIVE_NEXT_STEP_NUDGE_TITLE,
+  '',
+  'GPT/OpenAI-family behavior nudge: when the user asks for work and a reasonable or necessary next step is obvious, do not ask for permission or confirmation before doing it. Do the next step when it makes sense, especially when it is necessary to complete the task well. Avoid empty optional follow-up CTAs such as “if you want, I can also …”; either take the useful next action or end with the completed result.',
+  '',
+  'When the user explicitly asks for suggestions, options, alternatives, or what to do next, answer that request directly with concrete next-step suggestions instead of treating suggestions as an unwanted follow-up CTA.',
+].join('\n')

package/src/agent/session-origin.ts

@@ -384,6 +384,27 @@ function renderChannelOrigin(
     )
   }
 
+  // Discord renders no GFM tables — a raw `| a | b |` block shows as literal
+  // pipes. The discord-bot adapter rewrites BARE pipe tables into aligned
+  // inline-code rows for readability, but it skips any table inside a ``` /
+  // ~~~ fence (a fenced table is literal text by CommonMark). Models that have
+  // "learned" Discord mangles tables defensively wrap them in a fence, which is
+  // exactly what disables the auto-conversion — so the table renders ragged
+  // anyway. Tell the model to emit tables bare and let the adapter format them.
+  if (origin.adapter === 'discord-bot') {
+    lines.push(
+      '',
+      '**Emit Markdown tables as bare `| a | b |` blocks — never inside a code',
+      'fence.** Discord does not render Markdown tables, so this session',
+      'auto-reformats a bare pipe table (a `|`-row followed by a `|---|`',
+      'alignment row) into aligned, readable columns before it sends. That',
+      'reformatting only fires on raw Markdown: the moment you wrap the table in',
+      'a ``` or ~~~ fence it is treated as literal text and lands as ragged pipes.',
+      'So write the table directly in your reply with no surrounding fence. Use',
+      'fences only for actual code or output you want shown verbatim.',
+    )
+  }
+
   const conversationLine = renderConversationLine(origin)
   if (conversationLine !== null) lines.push('', conversationLine)
 

package/src/channels/continuation-willingness.ts

@@ -48,8 +48,20 @@ const EN_PHRASES: readonly string[] = [
   'looking into it now',
   'working on it now',
   'on it now',
+  "i'm on it",
   'give me a moment',
   'give me a sec',
+  // Parity additions for common first-person-future acks: "investigate / look up
+  // / pull up" are work-verb siblings of the "look into / dig in" entries above,
+  // and "lemme" is the contracted "let me" that chat models routinely emit.
+  "i'll investigate",
+  "i'll look it up",
+  "i'll pull that up",
+  "i'll pull it up",
+  'let me pull',
+  'lemme check',
+  'lemme look',
+  'lemme take a look',
 ]
 
 // Korean: -ㄹ게요 / -겠습니다 future-volitional endings on check/look/continue/
@@ -81,6 +93,27 @@ const KO_PHRASES: readonly string[] = [
   '잠시만요',
   '잠깐만요',
   '곧 알려',
+  // Bare first-person-volitional verb endings: the -ㄹ게요/-겠습니다 ending is
+  // self-directed regardless of the preceding adverb, so the "바로 …" prefix in
+  // the entries above is not load-bearing. "볼게요" alone (and "먼저/한번/지금 볼게요"
+  // by substring) is the exact production miss — the ack "…먼저 볼게요" did not
+  // match because only the "바로 볼게요" compound was listed. Common work verbs
+  // (검토/조회/찾아/알아/처리) in the same volitional form join here for parity with
+  // "확인/살펴" above; "볼게여" is the casual -여 variant seen in chat.
+  '볼게요',
+  '볼게여',
+  '확인할게여',
+  '검토할게요',
+  '검토해볼게요',
+  '검토하겠습니다',
+  '조회해볼게요',
+  '조회하겠습니다',
+  '찾아볼게요',
+  '찾아보겠습니다',
+  '알아볼게요',
+  '알아보겠습니다',
+  '처리할게요',
+  '처리하겠습니다',
 ]
 
 // The remaining languages mirror the precision-first selection above: every
@@ -106,6 +139,12 @@ const ES_PHRASES: readonly string[] = [
   'déjame comprobar',
   'déjame verificar',
   'déjame mirar',
+  'voy a echar un vistazo',
+  'déjame echar un vistazo',
+  'ahora lo reviso',
+  'ahora reviso',
+  'ahora lo verifico',
+  'ahora mismo lo reviso',
   'lo reviso enseguida',
   'lo verifico enseguida',
   'enseguida lo reviso',
@@ -123,10 +162,15 @@ const FR_PHRASES: readonly string[] = [
   'je vais poursuivre',
   'je vais voir',
   'je vais contrôler',
+  'je vais creuser',
+  'je vais jeter un œil',
   'laisse-moi vérifier',
   'laisse-moi regarder',
+  'laisse-moi jeter un œil',
   'je vérifie tout de suite',
   'je regarde tout de suite',
+  'je regarde ça tout de suite',
+  'je regarde ça',
   'un instant',
   'donne-moi un instant',
   'donne-moi une seconde',
@@ -137,12 +181,16 @@ const IT_PHRASES: readonly string[] = [
   'vado a controllare',
   'vado a verificare',
   'vado a guardare',
+  "vado a dare un'occhiata",
   'fammi controllare',
   'fammi verificare',
   'fammi guardare',
+  "fammi dare un'occhiata",
+  "do un'occhiata",
   'controllo subito',
   'verifico subito',
   'continuo subito',
+  'guardo subito',
   'un momento',
   'dammi un momento',
   'dammi un secondo',
@@ -156,9 +204,11 @@ const PT_PHRASES: readonly string[] = [
   'vou olhar',
   'vou continuar',
   'vou prosseguir',
+  'vou dar uma olhada',
   'deixa eu verificar',
   'deixa eu conferir',
   'deixa eu olhar',
+  'deixa eu dar uma olhada',
   'verifico já',
   'já verifico',
   'um momento',
@@ -175,8 +225,13 @@ const DE_PHRASES: readonly string[] = [
   'ich werde fortfahren',
   'lass mich prüfen',
   'lass mich nachsehen',
+  'lass mich schauen',
   'ich schaue gleich',
+  'ich schaue mir das an',
+  'ich schaue mir das mal an',
   'ich prüfe gleich',
+  'ich prüfe das gleich',
+  'ich sehe gleich nach',
   'gleich prüfen',
   'gleich überprüfen',
   'gleich nachsehen',
@@ -194,6 +249,8 @@ const RU_PHRASES: readonly string[] = [
   'я продолжу',
   'продолжу проверку',
   'сейчас посмотрю',
+  'дай мне проверить',
+  'дайте мне проверить',
   'дайте мне минуту',
   'одну секунду',
   'минутку',
@@ -214,6 +271,10 @@ const ZH_PHRASES: readonly string[] = [
   '我马上确认',
   '我马上检查',
   '我马上看',
+  '让我看看',
+  '让我查一下',
+  '让我确认一下',
+  '让我检查一下',
   '稍等一下',
   '我看一下',
 ]
@@ -265,6 +326,9 @@ const TR_PHRASES: readonly string[] = [
   'kontrol edeceğim',
   'kontrol ediyorum',
   'bakacağım',
+  'bir bakayım',
+  'bir kontrol edeyim',
+  'kontrol edeyim',
   'inceleyeceğim',
   'devam edeceğim',
   'hemen kontrol ediyorum',

package/src/channels/router.ts

@@ -279,6 +279,27 @@ export const WILLINGNESS_NUDGE = [
   '',
   '---',
 ].join('\n')
+// Injected when a `channel_send` ack tripped continuation-willingness, the model
+// did fresh work after it, then ended on an EMPTY `stop` leaf — the answer was
+// computed but never sent (the Kimi/Fireworks empty-completion flake). Distinct
+// from WILLINGNESS_NUDGE: that path is a `channel_reply` that ended the turn and
+// needs `continue: true`; this path is a `channel_send` (which never ends the
+// turn) whose follow-up degenerated, so the model just needs to emit the reply it
+// already worked out. Shares MAX_WILLINGNESS_NUDGES so a turn can't double-nudge.
+export const SEND_WILLINGNESS_NUDGE = [
+  '---',
+  '**[SYSTEM MESSAGE — not from a human]**',
+  '',
+  'You said you would keep working this turn and did the work, but the turn ended',
+  'without sending the result — nothing reached the channel after your last',
+  'message. This is an automated signal from the channel router, not a message',
+  'from anyone in the chat. **Do not acknowledge or reply to this notice itself.**',
+  '',
+  'Send the answer you just worked out now via your channel send tool. If you',
+  'genuinely have nothing to report, reply with `NO_REPLY`.',
+  '',
+  '---',
+].join('\n')
 // Rolling window for outbound send-rate telemetry. 5s matches Discord's
 // rate-limit shape (5 msg / 5 s / channel) and comfortably covers Slack's
 // 1 msg/s sustained. The window is observational; exceeding the burst
@@ -3358,23 +3379,6 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
       live.skippedTurn = null
       logger.info(`[channels] ${live.keyId} skip_contested_by_send recovering reply`)
     }
-    // A send landed this turn, but the model may have posted a `continue: true`
-    // progress reply, kept working, then ENDED with its final answer as plain
-    // prose — never calling a channel tool again. The terminal-reply abort fires
-    // only for a `channel_reply` WITHOUT `continue: true`, so that `stopReason:
-    // 'stop'` text leaf is left undelivered and unguarded (the false-receipt
-    // guard is github-only). The discriminator is leaf IDENTITY: only when the
-    // turn-end `stop` leaf is a DIFFERENT entry than the one in place at the last
-    // send did the model produce fresh post-reply prose. A leaf unchanged since
-    // the send is narration the model emitted with/before the reply that already
-    // landed — suppress it, as before.
-    if (live.successfulChannelSends > successfulSendsBeforePrompt) {
-      maybeNudgeContinuationWillingness(live)
-      const trailing = recoverableAssistantText(live.session)
-      if (trailing === null || trailing.source !== 'leaf') return
-      if (live.session.sessionManager.getLeafEntry()?.id === live.lastSendLeafId) return
-    }
-
     const postEmptyTurnFallback = async (cause: string): Promise<void> => {
       logger.warn(`[channels] ${live.keyId} empty_turn_fallback cause=${cause}`)
       const result = await send(
@@ -3392,6 +3396,86 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
       }
     }
 
+    // A send landed this turn, but the model may have posted a `continue: true`
+    // progress reply, kept working, then ENDED with its final answer as plain
+    // prose — never calling a channel tool again. The terminal-reply abort fires
+    // only for a `channel_reply` WITHOUT `continue: true`, so that `stopReason:
+    // 'stop'` text leaf is left undelivered and unguarded (the false-receipt
+    // guard is github-only). The discriminator is leaf IDENTITY: only when the
+    // turn-end `stop` leaf is a DIFFERENT entry than the one in place at the last
+    // send did the model produce fresh post-reply prose. A leaf unchanged since
+    // the send is narration the model emitted with/before the reply that already
+    // landed — suppress it, as before.
+    if (live.successfulChannelSends > successfulSendsBeforePrompt) {
+      maybeNudgeContinuationWillingness(live)
+
+      // A `channel_send` ack that promised to keep working, fresh post-ack work,
+      // then an EMPTY `stop` leaf: the model computed the answer in its reasoning
+      // / tool results but never sent it (the Kimi/Fireworks empty-completion
+      // flake). `maybeNudgeContinuationWillingness` above can't catch this — it
+      // reads `lastTerminalReplyAbort`, which only a `channel_reply` sets;
+      // `channel_send` keeps the turn alive and stamps nothing. And the
+      // stranded-toolUse retry below requires `source !== 'leaf'`, but an empty
+      // `stop` leaf recovers as `source: 'leaf'`, so this shape would otherwise
+      // fall straight through to the `endsWithNoReplySignal('')` → `no_reply`
+      // classification. Discriminator (all on existing state, zero false positives
+      // measured across the session corpus): a send landed AND the just-sent text
+      // trips the precision-tuned willingness detector AND the turn-end leaf is a
+      // FRESH empty `stop` (different entry than the ack's leaf — so the model did
+      // post-ack work, not an ack-then-await-user stop). Bounded by
+      // MAX_WILLINGNESS_NUDGES (shared with the reply path); on exhaustion post the
+      // fallback rather than going silent, mirroring the stranded-toolUse path.
+      // Gated on an empty `promptQueue` (like maybeNudgeContinuationWillingness): a
+      // real inbound that coalesced into the just-finished prompt will be answered
+      // by the next drain pass, and drain() splices pending reminders into that
+      // batch — so injecting a stale recovery nudge would prepend it to a live user
+      // message. Skip the nudge AND the fallback in that case and let the trailing
+      // recovery below run; the queued inbound supersedes this turn's silence.
+      if (live.promptQueue.length === 0 && live.currentTurnAuthorId !== null && isEmptyStopAfterWillingnessAck(live)) {
+        if (live.willingnessNudges < MAX_WILLINGNESS_NUDGES) {
+          live.willingnessNudges++
+          logger.warn(
+            `[channels] ${live.keyId} send_willingness_nudge attempt=${live.willingnessNudges}/${MAX_WILLINGNESS_NUDGES} ` +
+              `cause=empty_stop_after_send_ack`,
+          )
+          live.pendingSystemReminders.push(SEND_WILLINGNESS_NUDGE)
+        } else {
+          await postEmptyTurnFallback('empty_stop_after_send_ack_nudges_exhausted')
+        }
+        return
+      }
+
+      const trailing = recoverableAssistantText(live.session)
+      if (trailing === null || trailing.source !== 'leaf') {
+        // A `continue: true` status reply landed, then the turn stranded on an
+        // unanswered `toolUse` (the post-tool follow-up never produced an
+        // assistant message — aborted loop / cancelled stream). The promised
+        // work never finished, so the user is left with a bare "checking now…"
+        // and nothing after it. Re-prompt the same logical turn so the model
+        // completes its investigation and actually replies, instead of ending
+        // in silence. On retry-exhaustion post the fallback rather than
+        // returning silently — a retry turn that re-sends a status and re-strands
+        // on the same no-prose shape must not deadair the user. Any postable
+        // pre-tool/mid-turn prose is suppressed here as before (it was narration
+        // that accompanied the already-landed reply); only the no-prose strand
+        // gets a retry-or-fallback.
+        if (leafIsStrandedToolUse(live.session) && live.currentTurnAuthorId !== null) {
+          if (live.emptyTurnRetries < MAX_EMPTY_TURN_RETRIES) {
+            live.emptyTurnRetries++
+            logger.warn(
+              `[channels] ${live.keyId} empty_turn_retry attempt=${live.emptyTurnRetries}/${MAX_EMPTY_TURN_RETRIES} ` +
+                `cause=stranded_toolUse_after_send`,
+            )
+            live.pendingSystemReminders.push(EMPTY_TURN_RETRY_NUDGE)
+          } else {
+            await postEmptyTurnFallback('stranded_toolUse_retries_exhausted')
+          }
+        }
+        return
+      }
+      if (live.session.sessionManager.getLeafEntry()?.id === live.lastSendLeafId) return
+    }
+
     let candidate = recoverableAssistantText(live.session)
     // A `length` leaf is recovered ONLY when stripping leaked `<think>…</think>`
     // spans actually removed something AND leaves a postable reply. The removal
@@ -4961,6 +5045,58 @@ function assistantLeafStopReason(session: AgentSession): 'length' | 'error' | 'a
   return undefined
 }
 
+// True when the branch ends on an UNANSWERED `toolUse` that left NO postable
+// prose — the model called a tool and the upstream pi-agent-core post-tool
+// follow-up never produced an assistant message (the loop was aborted, or the
+// follow-up stream cancelled). Two leaf shapes carry this signature: the leaf
+// IS a `toolUse` assistant, or the leaf is a `toolResult` whose nearest
+// assistant ancestor (reached before any user message) is `toolUse`. The
+// no-prose requirement is the discriminator from a model that narrated a reply
+// alongside its tool call and DID land a real send this turn (that trailing
+// `toolUse` is delivered narration, not a stranded promise — leave it alone).
+// Keys on the model having INTENDED to keep working with nothing yet said; used
+// to re-prompt a turn that strands mid-work after a `continue: true` status
+// reply instead of ending in silence.
+function leafIsStrandedToolUse(session: AgentSession): boolean {
+  const leaf = session.sessionManager.getLeafEntry()
+  if (!leaf || leaf.type !== 'message') return false
+  if (leaf.message.role === 'assistant') {
+    return leaf.message.stopReason === 'toolUse' && visibleAssistantText(leaf.message).trim() === ''
+  }
+  if (leaf.message.role !== 'toolResult') return false
+  let cursor: { parentId: string | null } | undefined = leaf
+  for (let depth = 0; depth < 32 && cursor?.parentId; depth++) {
+    const parent = session.sessionManager.getEntry(cursor.parentId)
+    if (!parent) return false
+    if (parent.type === 'message') {
+      if (parent.message.role === 'assistant') {
+        return parent.message.stopReason === 'toolUse' && visibleAssistantText(parent.message).trim() === ''
+      }
+      if (parent.message.role === 'user') return false
+    }
+    cursor = parent
+  }
+  return false
+}
+
+// True when the turn-end leaf is a FRESH empty `stop` (no text, no tool call,
+// distinct from the leaf in place at the last successful send) AND the most
+// recent send to this target was a continuation-willingness ack. This is the
+// `channel_send` analogue of the `channel_reply` willingness path: the model
+// acked "I'll check…", did post-ack work, then the follow-up came back as a
+// clean empty completion that would otherwise be read as a deliberate `NO_REPLY`.
+// The fresh-leaf check (`!== lastSendLeafId`) is what separates this degeneration
+// from a legitimate ack-then-stop where the model meant to wait for the user.
+function isEmptyStopAfterWillingnessAck(live: LiveSession): boolean {
+  const leaf = live.session.sessionManager.getLeafEntry()
+  if (!leaf || leaf.type !== 'message' || leaf.message.role !== 'assistant') return false
+  if (leaf.message.stopReason !== 'stop') return false
+  if (hasToolCall(leaf.message) || visibleAssistantText(leaf.message).trim() !== '') return false
+  if (leaf.id === live.lastSendLeafId) return false
+  const ackText = live.lastSentText.get(consecutiveSendKey(live.key.chat, live.key.thread))
+  return ackText !== undefined && detectContinuationWillingness(ackText)
+}
+
 function visibleAssistantText(message: AssistantMessage): string {
   return message.content
     .filter((block) => block.type === 'text')

package/src/cli/fuzzy-filter.ts

@@ -0,0 +1,32 @@
+import type { Option } from '@clack/prompts'
+
+type FuzzyFilter<Value> = (search: string, option: Option<Value>) => boolean
+
+function optionHaystack<Value>(option: Option<Value>): string {
+  const label = option.label ?? String(option.value)
+  const hint = option.hint ?? ''
+  return `${label} ${String(option.value)} ${hint}`.toLowerCase()
+}
+
+function isSubsequence(query: string, haystack: string): boolean {
+  let i = 0
+  for (let j = 0; j < haystack.length && i < query.length; j++) {
+    if (haystack[j] === query[i]) i++
+  }
+  return i === query.length
+}
+
+// Splitting the query on whitespace lets "gpt 5.5" match "GPT-5.5 Turbo": each
+// token is matched independently as a subsequence, so the "-" inside "GPT-5.5"
+// no longer breaks the search the way a plain substring "gpt 5.5" would. Tokens
+// are order-independent so "turbo gpt" finds "GPT Turbo" too.
+export function fuzzyMatch<Value>(search: string, option: Option<Value>): boolean {
+  const tokens = search.toLowerCase().split(/\s+/).filter(Boolean)
+  if (tokens.length === 0) return true
+  const haystack = optionHaystack(option)
+  return tokens.every((token) => isSubsequence(token, haystack))
+}
+
+export const fuzzyFilter: FuzzyFilter<unknown> = fuzzyMatch
+
+export type { FuzzyFilter }

package/src/cli/init.ts

@@ -66,6 +66,7 @@ import {
   type KeyValidationResult,
 } from '@/init/validate-api-key'
 
+import { fuzzyMatch } from './fuzzy-filter'
 import { buildOAuthCallbacks } from './oauth-callbacks'
 import { CANCEL_SYMBOL, promptPrivateKeyPem } from './prompt-pem'
 import {
@@ -1098,6 +1099,7 @@ async function pickVendor(
   const choice = await autocomplete({
     message: 'Pick an LLM provider',
     placeholder: 'Type to search…',
+    filter: fuzzyMatch,
     options: vendors.map((id) => ({
       value: id,
       label: KNOWN_PROVIDER_VENDORS[id].name,
@@ -1120,6 +1122,7 @@ async function pickProviderVariant(
   const choice = await autocomplete<KnownProviderId>({
     message: `Pick a ${KNOWN_PROVIDER_VENDORS[vendorId].name} option`,
     placeholder: 'Type to search…',
+    filter: fuzzyMatch,
     options: variants.map((id) => {
       const hint = variantHint(vendorId, id)
       return hint !== undefined
@@ -1145,6 +1148,7 @@ async function pickModelForProvider(
   const choice = await autocomplete<string>({
     message: `Pick a ${KNOWN_PROVIDERS[providerId].name} model`,
     placeholder: 'Type to search…',
+    filter: fuzzyMatch,
     options: candidates.map((o) => ({
       value: o.ref,
       label: formatModelLabel(o),
@@ -1191,6 +1195,7 @@ async function pickVisionVendor(
   const choice = await autocomplete<KnownProviderVendorId | 'skip'>({
     message: 'Your model is text-only. Pick a provider for the `vision` profile (used for image input)',
     placeholder: 'Type to search…',
+    filter: fuzzyMatch,
     options: [
       ...vendors.map((id) => ({
         value: id as KnownProviderVendorId | 'skip',
@@ -1223,6 +1228,7 @@ async function pickVisionModel(
   const choice = await autocomplete<string>({
     message: `Pick a vision-capable ${KNOWN_PROVIDERS[providerId].name} model`,
     placeholder: 'Type to search…',
+    filter: fuzzyMatch,
     options: candidates.map((o) => ({
       value: o.ref,
       label: formatModelLabel(o),

package/src/cli/model.ts

@@ -19,6 +19,7 @@ import {
 import { findAgentDir, isInitialized } from '@/init'
 import { customModelMetaFromOption, fetchModelOptions, type ModelOption } from '@/init/models-dev'
 
+import { fuzzyMatch } from './fuzzy-filter'
 import { runProviderAddFlow } from './provider'
 import { c, done, errorLine } from './ui'
 
@@ -251,6 +252,7 @@ async function pickModelRef(cwd: string): Promise<PickedModelRef> {
     const choice = await autocomplete<string>({
       message: 'Pick a model',
       placeholder: 'Type to search…',
+      filter: fuzzyMatch,
       options: [
         ...modelOptions.map((option) => ({
           value: option.ref,

package/src/cli/provider.ts

@@ -23,6 +23,7 @@ import {
 import { findAgentDir, isInitialized } from '@/init'
 import { makeOAuthLoginRunner } from '@/init/oauth-login'
 
+import { fuzzyMatch } from './fuzzy-filter'
 import { buildOAuthCallbacks } from './oauth-callbacks'
 import { c, done, errorLine } from './ui'
 
@@ -285,6 +286,7 @@ async function pickVendorToAdd(): Promise<KnownProviderVendorId> {
   const choice = await autocomplete<KnownProviderVendorId>({
     message: 'Pick a provider to add',
     placeholder: 'Type to search…',
+    filter: fuzzyMatch,
     options: vendorIds.map((id) => ({
       value: id,
       label: KNOWN_PROVIDER_VENDORS[id].name,
@@ -305,6 +307,7 @@ async function pickVariantToAdd(vendorId: KnownProviderVendorId): Promise<KnownP
   const choice = await autocomplete<KnownProviderId>({
     message: `Pick a ${KNOWN_PROVIDER_VENDORS[vendorId].name} option`,
     placeholder: 'Type to search…',
+    filter: fuzzyMatch,
     options: variants.map((id) => {
       const hint = variantHint(vendorId, id)
       return hint !== undefined

package/src/config/providers.ts

@@ -991,9 +991,12 @@ function knownProviderForModelRef(ref: string): KnownProviderId | null {
 //
 // Anthropic, GLM, and Kimi don't share the padding behavior, so they keep the
 // SDK default.
+export function isOpenAiFamilyRef(ref: KnownModelRef | ModelRef | string): boolean {
+  return vendorForProviderId(providerForModelRef(ref)) === 'openai'
+}
+
 export function defaultThinkingLevelForRef(ref: KnownModelRef | ModelRef | string): 'low' | undefined {
-  const providerId = providerForModelRef(ref)
-  if (providerId === 'openai' || providerId === 'openai-codex') return 'low'
+  if (isOpenAiFamilyRef(ref)) return 'low'
   return undefined
 }