The best way to control Claude Code, Codex and more from any computer or phone
fix(claude): ENABLE_TOOL_SEARCH=auto no longer costs 10x cache writes per session (#24654)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Theo Browne committed
Oct 24, 2026 at 19:38 UTC
24c80f34a1013f0c67ddcf05b8980b812d26f1e1
2 files changed
+241
-1
apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+124
@@ -272,6 +272,40 @@ describe("ClaudeAdapterV2 runtime query policy", () => {
272
);
273
});
274
275
+ it("pins Claude's auto tool search on through flag settings", () => {
276
+ const override = ClaudeAdapterV2.claudeToolSearchOverride;
277
+ for (const value of ["auto", "auto:10", "auto:99.5", "auto:x", "auto:Infinity"]) {
278
+ assert.equal(override(value), "true", value);
279
+ }
280
+ for (const value of [
281
+ undefined,
282
+ "true",
283
+ "false",
284
+ "auto:0",
285
+ "auto:-5",
286
+ "auto:100",
287
+ "auto:1e2",
288
+ "auto:1_000",
289
+ "auto:1,000",
290
+ "AUTO",
291
+ ]) {
292
+ assert.isUndefined(override(value), String(value));
293
+ }
294
+
295
+ const options = ClaudeAdapterV2.makeClaudeQueryOptions({
296
+ modelSelection: CLAUDE_TEST_MODEL_SELECTION,
297
+ nativeThreadId: "native-tool-search",
298
+ resume: false,
299
+ cwd: "/workspace",
300
+ sdkSettings: { env: { OTHER: "kept" } },
301
+ toolSearchOverride: "true",
302
+ });
303
+ assert.deepEqual((options.settings as { env?: Record<string, string> }).env, {
304
+ OTHER: "kept",
305
+ ENABLE_TOOL_SEARCH: "true",
306
+ });
307
+ });
308
+
309
it("projects AskUserQuestion input with question text as the answer key", () => {
310
const preview = "\n **Proposed change**\n\n```ts\n\tconst enabled = true;\n```\n ";
311
assert.deepEqual(
@@ -2846,6 +2880,96 @@ describe("ClaudeAdapterV2 background wake turns", () => {
2880
),
2881
),
2882
);
2883
+
2884
+ it.effect("pins tool search on when the user's Claude settings choose auto", () =>
2885
+ Effect.gen(function* () {
2886
+ const fileSystem = yield* FileSystem.FileSystem;
2887
+ const path = yield* Path.Path;
2888
+ const home = yield* fileSystem.makeTempDirectoryScoped({
2889
+ prefix: "t3-claude-tool-search-",
2890
+ });
2891
+ const openedToolSearch = (
2892
+ settingsJson: string,
2893
+ cwd = CLAUDE_TEST_RUNTIME_POLICY.cwd,
2894
+ environment?: NodeJS.ProcessEnv,
2895
+ ) =>
2896
+ Effect.scoped(
2897
+ Effect.gen(function* () {
2898
+ yield* fileSystem.writeFileString(path.join(home, "settings.json"), settingsJson);
2899
+ const harness = yield* makeWakeHarnessWithOptions({
2900
+ settings: { ...DEFAULT_CLAUDE_SETTINGS, homePath: home },
2901
+ ...(environment === undefined ? {} : { environment }),
2902
+ });
2903
+ yield* harness.runtime.startTurn(
2904
+ makeClaudeTestTurnInput({
2905
+ threadId: harness.threadId,
2906
+ providerThread: harness.providerThread,
2907
+ now: yield* DateTime.now,
2908
+ attemptId: RunAttemptId.make("attempt-tool-search"),
2909
+ text: "Run git status.",
2910
+ attachments: [],
2911
+ runtimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
2912
+ ...CLAUDE_TEST_RUNTIME_POLICY,
2913
+ cwd,
2914
+ }),
2915
+ }),
2916
+ );
2917
+ const settings = harness.getOpenedOptions()?.settings;
2918
+ return typeof settings === "object" ? settings.env?.ENABLE_TOOL_SEARCH : undefined;
2919
+ }),
2920
+ );
2921
+ assert.equal(yield* openedToolSearch('{"env":{"ENABLE_TOOL_SEARCH":"auto"}}'), "true");
2922
+ assert.isUndefined(yield* openedToolSearch('{"env":{"ENABLE_TOOL_SEARCH":"false"}}'));
2923
+ assert.isUndefined(yield* openedToolSearch("{}"));
2924
+
2925
+ // Claude Code keeps the local file at the repository root, the main checkout's root in a
2926
+ // worktree, and that file beats the user's settings.
2927
+ const repo = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-claude-repo-" });
2928
+ const worktree = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-claude-wt-" });
2929
+ const worktreeGitDir = path.join(repo, ".git", "worktrees", "wt");
2930
+ yield* fileSystem.makeDirectory(worktreeGitDir, { recursive: true });
2931
+ yield* fileSystem.writeFileString(path.join(worktreeGitDir, "commondir"), "../..\n");
2932
+ yield* fileSystem.writeFileString(
2933
+ path.join(worktree, ".git"),
2934
+ `gitdir: ${worktreeGitDir}\n`,
2935
+ );
2936
+ yield* fileSystem.makeDirectory(path.join(repo, ".claude"));
2937
+ yield* fileSystem.makeDirectory(path.join(repo, "packages", "app"), { recursive: true });
2938
+ const rootLocal = (value: string) =>
2939
+ fileSystem.writeFileString(
2940
+ path.join(repo, ".claude", "settings.local.json"),
2941
+ `{"env":{"ENABLE_TOOL_SEARCH":"${value}"}}`,
2942
+ );
2943
+ const userAuto = '{"env":{"ENABLE_TOOL_SEARCH":"auto"}}';
2944
+ yield* rootLocal("auto");
2945
+ assert.equal(yield* openedToolSearch("{}", worktree), "true");
2946
+ yield* rootLocal("false");
2947
+ assert.isUndefined(yield* openedToolSearch(userAuto, worktree));
2948
+ assert.isUndefined(yield* openedToolSearch(userAuto, path.join(repo, "packages", "app")));
2949
+
2950
+ // Project settings beat user settings, and the process env applies only when no file sets it.
2951
+ const project = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-claude-project-" });
2952
+ yield* fileSystem.makeDirectory(path.join(project, ".claude"));
2953
+ yield* fileSystem.writeFileString(
2954
+ path.join(project, ".claude", "settings.json"),
2955
+ '{"env":{"ENABLE_TOOL_SEARCH":"auto"}}',
2956
+ );
2957
+ assert.equal(
2958
+ yield* openedToolSearch('{"env":{"ENABLE_TOOL_SEARCH":"false"}}', project),
2959
+ "true",
2960
+ );
2961
+ assert.equal(
2962
+ yield* openedToolSearch("{}", CLAUDE_TEST_RUNTIME_POLICY.cwd, {
2963
+ ENABLE_TOOL_SEARCH: "auto",
2964
+ }),
2965
+ "true",
2966
+ );
2967
+ }).pipe(
2968
+ Effect.provide(
2969
+ Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
2970
+ ),
2971
+ ),
2972
+ );
2973
});
2974
2975
describe("Plan-mode tool approval", () => {
apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
+117
-1
@@ -1273,6 +1273,35 @@ export function claudeQueryEnvironment(
1273
return { ...environment, CLAUDE_CODE_PROMPT_CACHE_TTL: subagentPromptCacheTtl };
1274
}
1275
1276
+// Claude Code's auto tool search sends every MCP schema in full while they fit under a share of the
1277
+// context window, which T3's tools do on 1M models. auto:0 already means on and auto:100 off.
1278
+export function claudeToolSearchOverride(value: string | undefined): "true" | undefined {
1279
+ if (value === undefined) return undefined;
1280
+ if (value === "auto") return "true";
1281
+ if (!value.startsWith("auto:")) return undefined;
1282
+ const percent = parseClaudeInteger(value.slice("auto:".length));
1283
+ // Claude Code treats an unparsable auto:N as auto, and clamps N to 0..100.
1284
+ if (Number.isNaN(percent)) return "true";
1285
+ const clamped = Math.min(100, Math.max(0, percent));
1286
+ return clamped > 0 && clamped < 100 ? "true" : undefined;
1287
+}
1288
+
1289
+// Claude Code 2.1.310's integer parsing for auto:N. Scientific notation counts only when it is an
1290
+// integer, grouped digits (1_000, 1,000, or 1 000) are joined, and anything else uses parseInt.
1291
+const CLAUDE_SCIENTIFIC_INTEGER = /^[+-]?(\d+(\.\d*)?|\.\d+)[eE][+-]?\d+$/;
1292
+const CLAUDE_GROUPED_INTEGER = /^[+-]?\d{1,3}([_,\u00A0\u202F ])\d{3}(?:\1\d{3})*$/;
1293
+function parseClaudeInteger(text: string): number {
1294
+ const value = text.trim();
1295
+ if (value.length <= 32 && CLAUDE_SCIENTIFIC_INTEGER.test(value)) {
1296
+ const number = Number(value);
1297
+ return Number.isInteger(number) ? number : Number.NaN;
1298
+ }
1299
+ if (value.length <= 32 && CLAUDE_GROUPED_INTEGER.test(value)) {
1300
+ return Number.parseInt(value.replace(/[_,\u00A0\u202F ]/g, ""), 10);
1301
+ }
1302
+ return Number.parseInt(value, 10);
1303
+}
1304
+
1305
// Claude Code defers MCP tools behind ToolSearch, so the agent only finds
1306
// t3_background_wait when the system prompt says when to reach for it.
1307
const CLAUDE_BACKGROUND_WAIT_INSTRUCTIONS = `
@@ -1302,6 +1331,8 @@ export function makeClaudeQueryOptions(input: {
1331
readonly supportedDialogKinds?: ClaudeQueryOptions["supportedDialogKinds"];
1332
readonly allowDangerouslySkipPermissions?: boolean;
1333
readonly appendSystemPromptFileText?: string;
1334
+ // Flag settings, because a user's settings.json env beats the process env in Claude Code.
1335
+ readonly toolSearchOverride?: "true";
1336
}): ClaudeAgentSdkQueryOptions {
1337
const compiledSelection = compileClaudeModelSelection(input.modelSelection);
1338
const {
@@ -1338,13 +1369,21 @@ export function makeClaudeQueryOptions(input: {
1369
: typeof input.sdkSettings === "object" && input.sdkSettings !== null
1370
? ({ ...input.sdkSettings, ...selectionSettings } as ClaudeSdkSettings)
1371
: selectionSettings;
1341
- const effectiveQuerySettings =
1372
+ const compactQuerySettings =
1373
input.settings?.autoCompactWindow === undefined || input.settings.autoCompactWindow.length === 0
1374
? querySettings
1375
: ({
1376
...(typeof querySettings === "object" && querySettings !== null ? querySettings : {}),
1377
autoCompactWindow: Number(input.settings.autoCompactWindow),
1378
} as ClaudeSdkSettings);
1379
+ // A settings file path cannot take extra keys, so it goes through unchanged.
1380
+ const effectiveQuerySettings =
1381
+ input.toolSearchOverride === undefined || typeof compactQuerySettings === "string"
1382
+ ? compactQuerySettings
1383
+ : ({
1384
+ ...compactQuerySettings,
1385
+ env: { ...compactQuerySettings?.env, ENABLE_TOOL_SEARCH: input.toolSearchOverride },
1386
+ } as ClaudeSdkSettings);
1387
const options: ClaudeAgentSdkQueryOptions = {
1388
model: compiledSelection.apiModelId,
1389
tools: claudeAgentSdkQueryToolsForSdk(selectedTools),
@@ -2160,6 +2199,14 @@ const decodeClaudeSubagentCacheSettings = Schema.decodeUnknownEffect(
2199
),
2200
),
2201
);
2202
+const decodeClaudeEnvSettings = Schema.decodeUnknownEffect(
2203
+ fromLenientJson(
2204
+ Schema.StructWithRest(
2205
+ Schema.Struct({ env: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)) }),
2206
+ [Schema.Record(Schema.String, Schema.Unknown)],
2207
+ ),
2208
+ ),
2209
+);
2210
2211
function claudeBypassAvailability(
2212
settings: typeof ClaudeBypassSettings.Type,
@@ -3946,6 +3993,73 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
3993
},
3994
);
3995
3996
+ const readToolSearchSetting = (filePath: string) =>
3997
+ fileSystem.readFileString(filePath).pipe(
3998
+ Effect.flatMap(decodeClaudeEnvSettings),
3999
+ Effect.map((settings) => {
4000
+ const value = settings.env?.ENABLE_TOOL_SEARCH;
4001
+ return typeof value === "string" ? value : undefined;
4002
+ }),
4003
+ Effect.orElseSucceed(() => undefined),
4004
+ );
4005
+ // A worktree's .git file points at <main>/.git/worktrees/<name>, whose commondir leads back to
4006
+ // <main>/.git. A bare repository has no main checkout, so its worktree keeps its own file.
4007
+ const mainCheckoutRoot = (checkout: string) =>
4008
+ fileSystem.readFileString(path.join(checkout, ".git")).pipe(
4009
+ Effect.flatMap((pointer) => {
4010
+ const gitDir = /^gitdir:\s*(.+)$/m.exec(pointer)?.[1]?.trim();
4011
+ if (gitDir === undefined) return Effect.succeed(checkout);
4012
+ const worktreeGitDir = path.resolve(checkout, gitDir);
4013
+ return fileSystem.readFileString(path.join(worktreeGitDir, "commondir")).pipe(
4014
+ Effect.map((commonDir) => {
4015
+ const common = path.resolve(worktreeGitDir, commonDir.trim());
4016
+ return path.basename(common) === ".git" ? path.dirname(common) : checkout;
4017
+ }),
4018
+ );
4019
+ }),
4020
+ Effect.orElseSucceed(() => checkout),
4021
+ );
4022
+ // Claude Code keeps .claude/settings.local.json at the repository root, or in cwd outside a
4023
+ // repository, on Windows, or when the root is home. Its owner check is skipped: missing it only
4024
+ // leaves tool search on, Claude Code's default.
4025
+ const localSettingsDirectory = Effect.fn("ClaudeAdapterV2.localSettingsDirectory")(function* (
4026
+ cwd: string,
4027
+ ) {
4028
+ if ((yield* HostProcess.Platform) === "win32") return cwd;
4029
+ for (let directory = cwd; ; directory = path.dirname(directory)) {
4030
+ const isCheckout = yield* fileSystem
4031
+ .exists(path.join(directory, ".git"))
4032
+ .pipe(Effect.orElseSucceed(() => false));
4033
+ if (isCheckout) {
4034
+ const root = yield* mainCheckoutRoot(directory);
4035
+ return root === (yield* HostProcess.HomeDirectory) ? cwd : root;
4036
+ }
4037
+ if (path.dirname(directory) === directory) return cwd;
4038
+ }
4039
+ });
4040
+ // Settings env beats the process env, local over project over user, and a local file an older
4041
+ // Claude Code left in cwd applies under the root one. resolveSettings reads local from cwd only.
4042
+ const resolveToolSearchOverride = Effect.fn("ClaudeAdapterV2.resolveToolSearchOverride")(
4043
+ function* (cwd: string | null) {
4044
+ const localDirectory = cwd === null ? null : yield* localSettingsDirectory(cwd);
4045
+ const settingsFiles = [
4046
+ ...(cwd === null || localDirectory === null
4047
+ ? []
4048
+ : [
4049
+ path.join(localDirectory, ".claude", "settings.local.json"),
4050
+ ...(localDirectory === cwd ? [] : [path.join(cwd, ".claude", "settings.local.json")]),
4051
+ path.join(cwd, ".claude", "settings.json"),
4052
+ ]),
4053
+ path.join(homePath, "settings.json"),
4054
+ ];
4055
+ for (const settingsFile of settingsFiles) {
4056
+ const value = yield* readToolSearchSetting(settingsFile);
4057
+ if (value !== undefined) return claudeToolSearchOverride(value);
4058
+ }
4059
+ return claudeToolSearchOverride(adapterOptions.environment.ENABLE_TOOL_SEARCH);
4060
+ },
4061
+ );
4062
+
4063
const userInvocableSkills = (cwd: string | null) =>
4064
discoverClaudeSkills(
4065
adapterOptions.settings,
@@ -9220,6 +9334,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
9334
turnInput.nativeThreadHasTurns ?? turnInput.providerTurnOrdinal > 1;
9335
const shouldResume =
9336
resumeSessionAt !== undefined || openedWithResume || hasPersistedProviderTurn;
9337
+ const toolSearchOverride = yield* resolveToolSearchOverride(turnInput.runtimePolicy.cwd);
9338
const queryOptions = makeClaudeQueryOptions({
9339
modelSelection: turnInput.modelSelection,
9340
nativeThreadId,
@@ -9252,6 +9367,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
9367
onUserDialog,
9368
supportedDialogKinds: ["resume_return"],
9369
...(appendSystemPromptFileText === undefined ? {} : { appendSystemPromptFileText }),
9370
+ ...(toolSearchOverride === undefined ? {} : { toolSearchOverride }),
9371
});
9372
const querySession = yield* queryRunner
9373
.open({