The best way to control Claude Code, Codex and more from any computer or phone
fix(mcp): point a bare thread uuid at its mcp: thread in thread_not_found (#22452)
fixfon committed
Oct 21, 2026 at 16:17 UTC
b260a7cf69d061a3950220c320b85f8ac043a00c
5 files changed
+158
-7
apps/server/src/mcp/OrchestratorMcpService.test.ts
+76
@@ -2315,3 +2315,79 @@ describe("OrchestratorMcpService provider resolution", () => {
2315
);
2316
});
2317
});
2318
+
2319
+describe("OrchestratorMcpService thread lookup", () => {
2320
+ const bareId = ThreadId.make("5d0b4a3e-8c1f-4a52-9d37-2f6c7e1b9a04");
2321
+ const launched = liveThreadShell(ThreadId.make(`mcp:${bareId}`));
2322
+ const deletedLaunched = { ...launched, deletedAt: DateTime.makeUnsafe("2026-10-05T00:00:00Z") };
2323
+ const client: McpInvocationScope = {
2324
+ environmentId: EnvironmentId.make("environment:thread-lookup"),
2325
+ requestNamespace: "client:thread-lookup",
2326
+ thread: undefined,
2327
+ client: { sessionId: "thread-lookup", label: "Claude Code", access: "full-access" },
2328
+ capabilities: new Set(["orchestration"]),
2329
+ issuedAt: 1,
2330
+ };
2331
+ const service = (shells: ReadonlyArray<OrchestrationV2ThreadShell>, sent: Ref.Ref<number>) =>
2332
+ layerOrchestratorService.pipe(
2333
+ Layer.provide(
2334
+ Layer.mergeAll(
2335
+ NodeServices.layer,
2336
+ Layer.mock(ThreadManagementService.ThreadManagementService)({
2337
+ getThreadShell: (threadId) =>
2338
+ Effect.succeed(shells.find((shell) => shell.id === threadId) ?? null),
2339
+ sendToThread: () => Ref.update(sent, (count) => count + 1).pipe(Effect.as({} as never)),
2340
+ }),
2341
+ ServerSettings.layerTest(),
2342
+ Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
2343
+ Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
2344
+ list: () => Effect.succeed([]),
2345
+ }),
2346
+ Layer.mock(ProjectService.ProjectService)({}),
2347
+ Layer.mock(SecretRequests.SecretRequests)({}),
2348
+ Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
2349
+ ),
2350
+ ),
2351
+ );
2352
+ const failuresFor = (shells: ReadonlyArray<OrchestrationV2ThreadShell>) =>
2353
+ Effect.gen(function* () {
2354
+ const sent = yield* Ref.make(0);
2355
+ return yield* Effect.gen(function* () {
2356
+ const mcp = yield* OrchestratorMcpService.OrchestratorMcpService;
2357
+ const read = yield* mcp.readThread(client, { threadId: bareId }).pipe(Effect.flip);
2358
+ const send = yield* mcp
2359
+ .sendToThread(client, { threadId: bareId, message: "hello" })
2360
+ .pipe(Effect.flip);
2361
+ return { read, send, sends: yield* Ref.get(sent) };
2362
+ }).pipe(Effect.provide(service(shells, sent)));
2363
+ });
2364
+
2365
+ it.effect("points a bare uuid at the mcp: thread it belongs to", () =>
2366
+ Effect.gen(function* () {
2367
+ const { read, send, sends } = yield* failuresFor([launched]);
2368
+ for (const error of [read, send]) {
2369
+ assert.equal(error.code, "thread_not_found");
2370
+ assert.include(error.message, `mcp:${bareId}`);
2371
+ }
2372
+ assert.equal(sends, 0);
2373
+ }),
2374
+ );
2375
+
2376
+ it.effect("keeps the plain message for an id that matches nothing", () =>
2377
+ Effect.gen(function* () {
2378
+ const { read, send } = yield* failuresFor([]);
2379
+ assert.equal(read.code, "thread_not_found");
2380
+ assert.equal(read.message, `Thread ${bareId} is no longer available.`);
2381
+ assert.equal(send.code, "thread_not_found");
2382
+ assert.equal(send.message, `Thread ${bareId} was not found.`);
2383
+ }),
2384
+ );
2385
+
2386
+ it.effect("does not name an mcp: thread that was deleted", () =>
2387
+ Effect.gen(function* () {
2388
+ const { read, send } = yield* failuresFor([deletedLaunched]);
2389
+ assert.equal(read.message, `Thread ${bareId} is no longer available.`);
2390
+ assert.equal(send.message, `Thread ${bareId} was not found.`);
2391
+ }),
2392
+ );
2393
+});
apps/server/src/mcp/OrchestratorMcpService.ts
+26
-2
@@ -232,6 +232,26 @@ export const isLiveCallerShell = (
232
) ??
233
false));
234
235
+/**
236
+ * Threads an agent starts over MCP are `mcp:<uuid>`, and agents often paste the
237
+ * bare uuid. The id is never rewritten, so permission checks keyed on it still
238
+ * hold; the miss only names a live thread the caller could read by its full id.
239
+ */
240
+export const threadNotFound = Effect.fn("OrchestratorMcpService.threadNotFound")(function* (
241
+ threads: Pick<ThreadManagementService.ThreadManagementService["Service"], "getThreadShell">,
242
+ threadId: ThreadId,
243
+ message: string,
244
+) {
245
+ const prefixed = ThreadId.make(`mcp:${threadId}`);
246
+ const shell = yield* threads.getThreadShell(prefixed).pipe(Effect.orElseSucceed(() => null));
247
+ return yield* failure(
248
+ "thread_not_found",
249
+ shell === null || shell.deletedAt !== null
250
+ ? message
251
+ : `${message} Did you mean \`${prefixed}\`?`,
252
+ );
253
+});
254
+
255
function threadManagementFailure(error: unknown): OrchestratorMcpFailure {
256
if (!isThreadManagementError(error)) return failure("orchestration_error", errorMessage(error));
257
switch (error._tag) {
@@ -1124,7 +1144,7 @@ const make = Effect.gen(function* () {
1144
.getThreadShell(threadId)
1145
.pipe(Effect.mapError(threadManagementFailure));
1146
if (shell === null || shell.deletedAt !== null) {
1127
- return yield* failure("thread_not_found", `Thread ${threadId} was not found.`);
1147
+ return yield* threadNotFound(threadManagement, threadId, `Thread ${threadId} was not found.`);
1148
}
1149
return yield* loadProjectThread(shell.projectId, threadId);
1150
});
@@ -1199,7 +1219,11 @@ const make = Effect.gen(function* () {
1219
.getThreadShell(threadId)
1220
.pipe(Effect.mapError(threadManagementFailure));
1221
if (shell === null || shell.deletedAt !== null) {
1202
- return yield* failure("thread_not_found", `Thread ${threadId} is no longer available.`);
1222
+ return yield* threadNotFound(
1223
+ threadManagement,
1224
+ threadId,
1225
+ `Thread ${threadId} is no longer available.`,
1226
+ );
1227
}
1228
const target = yield* threadManagement
1229
.getProjectThreadRecords({ projectId: shell.projectId, threadId }, [
apps/server/src/mcp/ThreadMetadataMcpService.ts
+2
-1
@@ -16,6 +16,7 @@ import * as Layer from "effect/Layer";
16
17
import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
18
import type { McpInvocationScope } from "./McpInvocationContext.ts";
19
+import { threadNotFound } from "./OrchestratorMcpService.ts";
20
21
export class ThreadMetadataMcpService extends Context.Service<
22
ThreadMetadataMcpService,
@@ -167,7 +168,7 @@ const make = Effect.gen(function* () {
168
),
169
);
170
if (shell === null || shell.deletedAt !== null) {
170
- return yield* failure("thread_not_found", `Thread ${threadId} was not found.`);
171
+ return yield* threadNotFound(threadManagement, threadId, `Thread ${threadId} was not found.`);
172
}
173
const target = yield* threadManagement
174
.getProjectThreadRecords({ projectId: shell.projectId, threadId }, [])
apps/server/src/mcp/threadAccess.test.ts
new
+49
@@ -0,0 +1,49 @@
1
+import { expect, it } from "@effect/vitest";
2
+import { EnvironmentId, ThreadId } from "@t3tools/contracts";
3
+import * as Effect from "effect/Effect";
4
+import * as Layer from "effect/Layer";
5
+
6
+import * as ThreadManagement from "../orchestration-v2/ThreadManagementService.ts";
7
+import * as McpInvocationContext from "./McpInvocationContext.ts";
8
+import { liveThreadShell } from "./McpToolAccess.testkit.ts";
9
+import { readThread } from "./threadAccess.ts";
10
+
11
+const bareId = ThreadId.make("5d0b4a3e-8c1f-4a52-9d37-2f6c7e1b9a04");
12
+const client: McpInvocationContext.McpInvocationScope = {
13
+ environmentId: EnvironmentId.make("environment:thread-access"),
14
+ requestNamespace: "client:thread-access",
15
+ thread: undefined,
16
+ client: { sessionId: "thread-access", label: "Claude Code", access: "full-access" },
17
+ capabilities: new Set(["orchestration"]),
18
+ issuedAt: 1,
19
+};
20
+
21
+const readBare = (existing: ReadonlyArray<ThreadId>) =>
22
+ readThread(bareId).pipe(
23
+ Effect.flip,
24
+ Effect.provideService(McpInvocationContext.McpInvocationContext, client),
25
+ Effect.provide(
26
+ Layer.mock(ThreadManagement.ThreadManagementService)({
27
+ getThreadShell: (threadId) =>
28
+ Effect.succeed(existing.includes(threadId) ? liveThreadShell(threadId) : null),
29
+ }),
30
+ ),
31
+ );
32
+
33
+it.effect("points a bare uuid at the mcp: thread it belongs to", () =>
34
+ Effect.gen(function* () {
35
+ const error = yield* readBare([ThreadId.make(`mcp:${bareId}`)]);
36
+
37
+ expect(error.code).toBe("thread_not_found");
38
+ expect(error.message).toBe(`The thread was not found. Did you mean \`mcp:${bareId}\`?`);
39
+ }),
40
+);
41
+
42
+it.effect("keeps the plain message for an id that matches nothing", () =>
43
+ Effect.gen(function* () {
44
+ const error = yield* readBare([]);
45
+
46
+ expect(error.code).toBe("thread_not_found");
47
+ expect(error.message).toBe("The thread was not found.");
48
+ }),
49
+);
apps/server/src/mcp/threadAccess.ts
+5
-4
@@ -156,10 +156,11 @@ export const readThread = Effect.fn("mcp.readThread")(function* <
156
const targetId = yield* resolveThreadId(context, threadId);
157
const shell = yield* context.threads.getThreadShell(targetId).pipe(Effect.mapError(unavailable));
158
if (shell === null || shell.deletedAt !== null) {
159
- return yield* new OrchestratorMcpFailure({
160
- code: "thread_not_found",
161
- message: "The thread was not found.",
162
- });
159
+ return yield* OrchestrationMcp.threadNotFound(
160
+ context.threads,
161
+ targetId,
162
+ "The thread was not found.",
163
+ );
164
}
165
const projection = yield* context.threads
166
.getProjectThreadRecords({ projectId: shell.projectId, threadId: targetId }, fields, {