import * as AssetSigner from "../../assets/AssetSigner.ts";
import * as DocumentText from "../../provider/DocumentText.ts";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { expect, it } from "@effect/vitest";
import {
DEFAULT_SERVER_SETTINGS,
ChatImageAttachment,
CommandId,
EnvironmentId,
NodeId,
OrchestratorMcpThreadReadResult,
ProviderDriverKind,
ProviderInstanceId,
RunId,
ScheduledTaskError,
ScheduledTask,
RuntimeRequestId,
ThreadId,
TurnItemId,
type OrchestrationV2ProjectedTurnItem,
type OrchestrationV2ThreadShell,
} from "@t3tools/contracts";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as TestClock from "effect/testing/TestClock";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import { McpAttachmentInput } from "./attachment/input.ts";
import { McpSchema, McpServer } from "effect/ai";
import { FetchHttpClient } from "effect/http";
import {
OrchestratorCommandRejectedError,
OrchestratorDispatchError,
OrchestratorProjectionError,
} from "../../orchestration-v2/Orchestrator.ts";
import * as ServerSecretStore from "../../auth/ServerSecretStore.ts";
import * as ServerConfig from "../../config.ts";
import * as ProviderAdapterRegistry from "../../orchestration-v2/ProviderAdapterRegistry.ts";
import * as ThreadLaunchService from "../../orchestration-v2/ThreadLaunchService.ts";
import * as GitVcsDriver from "../../vcs/GitVcsDriver.ts";
import * as ThreadManagement from "../../orchestration-v2/ThreadManagementService.ts";
import * as ThreadSearch from "../../orchestration-v2/ThreadSearch.ts";
import * as PreviewBrowser from "../../preview/PreviewBrowser.ts";
import * as ProjectService from "../../project/ProjectService.ts";
import * as ProviderRegistry from "../../provider/ProviderRegistry.ts";
import * as SecretRequests from "../../secrets/SecretRequests.ts";
import * as RemoteDelegation from "../../peer/RemoteDelegation.ts";
import * as ScheduledTaskService from "../../scheduledTasks/ScheduledTaskService.ts";
import * as ServerSettings from "../../serverSettings.ts";
import * as McpHttpServer from "../McpHttpServer.ts";
import * as McpInvocationContext from "../McpInvocationContext.ts";
import * as McpToolAccessTestkit from "../McpToolAccess.testkit.ts";
import * as AnalyticsService from "../../telemetry/AnalyticsService.ts";
import { dispatchFailure } from "../threadAccess.ts";
import * as EnvironmentHandlers from "./environment/handlers.ts";
import * as AttachmentHandlers from "./attachment/handlers.ts";
import * as PeerForwarding from "../../peer/PeerForwarding.ts";
import * as PeerLinkRequests from "../../peer/PeerLinkRequests.ts";
import * as PeerLinks from "../../peer/PeerLinks.ts";
const layerOrchestratorToolkit = McpHttpServer.layerOrchestratorToolkit.pipe(
Layer.provide(Layer.mock(ThreadLaunchService.ThreadLaunchService)({})),
Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)({})),
);
const declaredFailure = (result: McpSchema.CallToolResult) => {
const text = result.content[0];
return result.isError === true && text?.type === "text" ? JSON.parse(text.text) : undefined;
};
import { htmlRenderFromToolItem } from "@t3tools/shared/toolOutput";
const decodeMcpAttachmentInput = Schema.decodeUnknownEffect(McpAttachmentInput);
const decodeThreadReadResult = Schema.decodeUnknownEffect(OrchestratorMcpThreadReadResult);
const layerThreadToolkit = McpHttpServer.layerThreadToolkit.pipe(
Layer.provide(Layer.mock(ThreadSearch.ThreadSearch)({})),
Layer.provide(Layer.mock(ScheduledTaskService.ScheduledTaskService)({})),
Layer.provide(Layer.mock(PeerForwarding.PeerForwarding)({})),
Layer.provide(Layer.mock(PeerLinkRequests.PeerLinkRequests)({})),
Layer.provide(Layer.mock(PeerLinks.PeerLinks)({})),
);
const threadId = ThreadId.make("mcp-core-thread");
const scope: McpInvocationContext.McpInvocationScope = {
environmentId: EnvironmentId.make("mcp-core-environment"),
requestNamespace: "mcp-core-session",
thread: {
threadId,
providerSessionId: "mcp-core-session",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
issuedAt: 0,
capabilities: new Set(["orchestration"]),
};
const client = McpSchema.McpServerClient.of({
clientId: 1,
protocolVersion: "2025-06-18",
clientCapabilities: {},
clientInfo: { name: "mcp-core", version: "1" },
initializePayload: {
protocolVersion: "2025-06-18",
capabilities: {},
clientInfo: { name: "mcp-core", version: "1" },
},
getClient: Effect.die("unused"),
});
it.effect("checks capability through the production registration", () =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
expect(server.tools.some(({ tool }) => tool.name === "t3_thread_organize")).toBe(true);
const result = yield* server
.callTool({ name: "t3_thread_organize", arguments: { action: "pin" } })
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, {
...scope,
capabilities: new Set<never>(),
}),
Effect.provideService(McpSchema.McpServerClient, client),
);
expect(declaredFailure(result)).toMatchObject({ code: "capability_denied" });
expect(result.isError).toBe(true);
expect(result.structuredContent).toBeUndefined();
}).pipe(
Effect.provide(
layerThreadToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(McpToolAccessTestkit.liveThreadsLayer),
),
),
),
);
it.effect("an answered question reports already answered instead of not found", () => {
const shell = McpToolAccessTestkit.liveThreadShell(threadId);
const requestId = RuntimeRequestId.make("answered-question");
const projection = McpToolAccessTestkit.idleThreadProjection(shell);
return Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const respond = (id: string) =>
server
.callTool({
name: "t3_pending_request",
arguments: { action: "respond", requestId: id, answers: { size: "large" } },
})
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, scope),
Effect.provideService(McpSchema.McpServerClient, client),
);
expect(declaredFailure(yield* respond(requestId))).toMatchObject({
code: "invalid_request",
message: "The user-input request was already answered.",
});
expect(declaredFailure(yield* respond("missing-question"))).toMatchObject({
code: "invalid_request",
message: "The pending user-input request was not found.",
});
}).pipe(
Effect.provide(
layerThreadToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
getThreadShell: () => Effect.succeed(shell),
getProjectThreadRecords: () =>
Effect.succeed({
...projection,
runtimeRequests: [
{
id: requestId,
nodeId: NodeId.make("root"),
providerTurnId: null,
nativeRequestRef: null,
kind: "user_input",
status: "resolved",
responseCapability: { type: "message" },
createdAt: shell.createdAt,
resolvedAt: shell.updatedAt,
answers: { size: "large" },
},
],
turnItems: [
{
id: TurnItemId.make("answered-question-item"),
threadId,
runId: null,
nodeId: null,
providerThreadId: null,
providerTurnId: null,
nativeItemRef: null,
parentItemId: null,
ordinal: 0,
status: "completed",
title: null,
startedAt: shell.createdAt,
completedAt: shell.updatedAt,
updatedAt: shell.updatedAt,
type: "user_input_request",
requestId,
questions: [],
},
],
}),
dispatch: () => Effect.die("an answered question must not dispatch again"),
}),
),
),
),
);
});
it("bounds public command rejections and redacts internal dispatch causes", () => {
const command = { commandId: CommandId.make("mcp-core-command"), commandType: "thread.settle" };
expect(
dispatchFailure(new OrchestratorDispatchError({ ...command, cause: "🙂".repeat(1001) }))
.message,
).toBe("🙂".repeat(1000));
expect(
dispatchFailure(
new OrchestratorCommandRejectedError({ ...command, cause: "Run is not queued." }),
).message,
).toBe("Run is not queued.");
for (const cause of [
undefined,
"",
new Error("private-storage-path"),
{ message: "private-storage-path" },
]) {
expect(dispatchFailure(new OrchestratorDispatchError({ ...command, cause }))).toMatchObject({
code: "orchestration_error",
message: "The operation could not be completed.",
});
expect(
dispatchFailure(new OrchestratorCommandRejectedError({ ...command, cause })),
).toMatchObject({
code: "orchestration_error",
message: "The operation could not be completed.",
});
}
expect(
dispatchFailure(new OrchestratorProjectionError({ threadId, cause: "private-storage-path" })),
).toMatchObject({
code: "orchestration_error",
message: "The operation could not be completed.",
});
});
it.effect("returns an HTML render reference that Codex and Claude tool rows both carry", () =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const result = yield* server
.callTool({
name: "html_render",
arguments: { html: "<p>Revenue</p>", title: "Revenue", height: 240 },
})
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, scope),
Effect.provideService(McpSchema.McpServerClient, client),
);
const reference = htmlRenderFromToolItem({
toolName: "t3-code.html_render",
output: result.structuredContent,
});
expect(reference).toMatchObject({ title: "Revenue", height: 240 });
expect(
htmlRenderFromToolItem({ toolName: "mcp__t3-code__html_render", output: result.content }),
).toEqual(reference);
}).pipe(
Effect.provide(
McpHttpServer.layerHtmlToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(McpProviderSessions.layer),
Layer.provide(PreviewBrowser.layer),
Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-mcp-html-render-" })),
Layer.provide(
DocumentText.layer.pipe(
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
),
),
Layer.provide(FetchHttpClient.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
getThreadShell: () =>
Effect.succeed({
id: threadId,
deletedAt: null,
archivedAt: null,
activeRunId: RunId.make("mcp-core-run"),
providerInstanceId: ProviderInstanceId.make("codex"),
} as OrchestrationV2ThreadShell),
}),
),
),
),
),
);
it.effect("records only failed calls of tools that hand off no work", () => {
// Recording runs detached from the tool response, so the first event is awaited.
const recorded = Deferred.makeUnsafe<{ event: string; properties: object }>();
return Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const organize = (capabilities: McpInvocationContext.McpInvocationScope["capabilities"]) =>
server.callTool({ name: "t3_thread_organize", arguments: { action: "pin" } }).pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, {
...scope,
capabilities,
}),
Effect.provideService(McpSchema.McpServerClient, client),
);
expect((yield* organize(scope.capabilities)).isError).not.toBe(true);
expect(declaredFailure(yield* organize(new Set<never>()))).toMatchObject({
code: "capability_denied",
});
// The successful call ran first, so it would be the first event if it were recorded.
expect(yield* Deferred.await(recorded)).toMatchObject({
event: "mcp.tool.invoked",
properties: { tool: "t3_thread_organize", outcome: "error" },
});
}).pipe(
Effect.provide(
layerThreadToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
getThreadShell: (id) => Effect.succeed(McpToolAccessTestkit.liveThreadShell(id)),
getProjectThreadRecords: ({ threadId: id }) =>
Effect.succeed(
McpToolAccessTestkit.idleThreadProjection(McpToolAccessTestkit.liveThreadShell(id)),
),
dispatch: () => Effect.succeed({ sequence: 1 } as never),
}),
),
Layer.provide(
Layer.succeed(
AnalyticsService.AnalyticsService,
AnalyticsService.AnalyticsService.of({
record: (event, properties) =>
Deferred.succeed(recorded, { event, properties: properties ?? {} }).pipe(
Effect.asVoid,
),
flush: Effect.void,
recordOwners: () => Effect.void,
}),
),
),
),
),
);
});
it.effect("rejects an unknown organize target instead of archiving the calling thread", () => {
const dispatched: Array<unknown> = [];
return Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const outcome = yield* server
.callTool({
name: "t3_thread_organize",
arguments: { action: "archive", threadIds: ["other-thread"] },
})
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, scope),
Effect.provideService(McpSchema.McpServerClient, client),
Effect.result,
);
expect(dispatched).toEqual([]);
expect(outcome).toMatchObject({
_tag: "Failure",
failure: { message: expect.stringContaining("Expected no excess property") },
});
}).pipe(
Effect.provide(
layerThreadToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
getThreadShell: (id) => Effect.succeed(McpToolAccessTestkit.liveThreadShell(id)),
getProjectThreadRecords: ({ threadId: id }) =>
Effect.succeed(
McpToolAccessTestkit.idleThreadProjection(McpToolAccessTestkit.liveThreadShell(id)),
),
dispatch: (command) => {
dispatched.push(command);
return Effect.succeed({ sequence: 1 } as never);
},
}),
),
),
),
);
});
it.effect("keeps unexpected handler defects private through the production registration", () =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const result = yield* server
.callTool({ name: "t3_thread_organize", arguments: { action: "pin" } })
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, scope),
Effect.provideService(McpSchema.McpServerClient, client),
);
expect(result.isError).toBe(true);
expect(result.structuredContent).toBeUndefined();
expect(result.content).toEqual([
{ type: "text", text: "Tool execution failed due to an internal server error." },
]);
}).pipe(
Effect.provide(
layerThreadToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
getThreadShell: () => Effect.die(new Error("private-storage-path")),
}),
),
),
),
),
);
it("keeps MCP preference output allowlisted and Unicode-bounded", () => {
const settings = {
...DEFAULT_SERVER_SETTINGS,
privateCredential: "must-not-escape",
sourceControlWritingStyle: {
...DEFAULT_SERVER_SETTINGS.sourceControlWritingStyle,
customInstructions: "🙂".repeat(4001),
},
};
const result = EnvironmentHandlers.preferences(settings);
expect(result).not.toHaveProperty("privateCredential");
expect(result).not.toHaveProperty("providers");
expect(result.sourceControlWritingStyle).toMatchObject({
customInstructions: "🙂".repeat(4000),
truncated: true,
});
});
it.effect("resolves reused attachment references from stored metadata", () =>
Effect.gen(function* () {
const stored = ChatImageAttachment.make({
type: "image",
id: "owned-image",
name: "original.png",
mimeType: "image/png",
sizeBytes: 12,
source: {
kind: "snap-shot",
capturedAt: "2026-09-10T00:00:00.000Z",
appName: "Terminal",
windowTitle: "Test",
accessibility: { format: "flat-text", text: "Stored context", truncated: false },
},
});
const forged = yield* decodeMcpAttachmentInput({
type: "image",
id: stored.id,
name: "changed.jpg",
mimeType: "image/jpeg",
sizeBytes: 99,
});
const result = yield* AttachmentHandlers.resolveAttachmentReferences([forged], [stored]);
expect(result).toEqual([stored]);
const failure = yield* AttachmentHandlers.resolveAttachmentReferences(
[{ ...forged, id: "other-image" }],
[stored],
).pipe(Effect.flip);
expect(failure.code).toBe("invalid_request");
}),
);
const clientScope = (
access: McpInvocationContext.McpClientCaller["access"],
): McpInvocationContext.McpInvocationScope => ({
environmentId: EnvironmentId.make("mcp-core-environment"),
requestNamespace: "client:session-1",
thread: undefined,
client: { sessionId: "session-1", label: "Claude Code", access },
issuedAt: 0,
capabilities: new Set(["orchestration", "worktree", "pull-requests"]),
});
it.effect("a client caller targets any thread within its ceiling and cannot act as a thread", () =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const call = (
name: string,
args: Record<string, unknown>,
invocation: McpInvocationContext.McpInvocationScope,
) =>
server
.callTool({ name, arguments: args })
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
Effect.provideService(McpSchema.McpServerClient, client),
);
const untargeted = yield* call("t3_thread_organize", { action: "pin" }, clientScope("auto"));
expect(declaredFailure(untargeted)).toMatchObject({ code: "target_required" });
const pinned = yield* call(
"t3_thread_organize",
{ action: "pin", threadId: "other-project-thread" },
clientScope("auto"),
);
expect(pinned.isError).toBe(false);
expect(pinned.structuredContent).toMatchObject({ sequence: 7 });
const aboveCeiling = yield* call(
"t3_thread_organize",
{ action: "pin", threadId: "other-project-thread" },
clientScope("approval-required"),
);
expect(declaredFailure(aboveCeiling)).toMatchObject({
code: "runtime_mode_escalation_denied",
});
const forked = yield* call(
"t3_thread_transfer",
{ action: "fork", sourcePoint: { type: "latest_stable" } },
clientScope("auto"),
);
expect(declaredFailure(forked)).toMatchObject({ code: "target_required" });
}).pipe(
Effect.provide(
layerThreadToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
getThreadShell: (id) =>
Effect.succeed(McpToolAccessTestkit.liveThreadShell(id, { runtimeMode: "auto" })),
getProjectThreadRecords: () =>
Effect.succeed({
thread: {
id: ThreadId.make("other-project-thread"),
projectId: "other-project",
runtimeMode: "auto",
interactionMode: "default",
deletedAt: null,
},
} as never),
dispatch: () => Effect.succeed({ sequence: 7, storedEvents: [] }),
}),
),
),
),
),
);
it.effect("a read-only client reads threads and is refused every write before it runs", () =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const call = (name: string, args: Record<string, unknown>) =>
server
.callTool({ name, arguments: args })
.pipe(
Effect.provideService(
McpInvocationContext.McpInvocationContext,
clientScope("read-only"),
),
Effect.provideService(McpSchema.McpServerClient, client),
);
const configuration = yield* call("t3_thread_configure", {
threadId: "other-project-thread",
});
expect(configuration.isError).toBe(false);
expect(configuration.structuredContent).toMatchObject({ runtimeMode: "auto" });
const pinned = yield* call("t3_thread_organize", {
action: "pin",
threadId: "other-project-thread",
});
expect(declaredFailure(pinned)).toMatchObject({ code: "capability_denied" });
expect(dispatched).toEqual([]);
const configure = yield* call("t3_thread_configure", {
threadId: "other-project-thread",
modelSelection: { instanceId: "codex", model: "gpt-5" },
});
expect(declaredFailure(configure)).toMatchObject({ code: "capability_denied" });
expect(dispatched).toEqual([]);
}).pipe(
Effect.provide(
layerThreadToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
getThreadShell: () =>
Effect.succeed({
id: ThreadId.make("other-project-thread"),
projectId: "other-project",
deletedAt: null,
} as never),
getProjectThreadRecords: () =>
Effect.succeed({
thread: {
id: ThreadId.make("other-project-thread"),
projectId: "other-project",
modelSelection: { instanceId: "codex", model: "gpt-5" },
runtimeMode: "auto",
interactionMode: "default",
deletedAt: null,
},
} as never),
dispatch: () =>
Effect.sync(() => {
dispatched.push("dispatch");
return { sequence: 7 } as never;
}),
}),
),
),
),
),
);
const dispatched: Array<string> = [];
it.effect("refuses act-as-caller tools to a client caller", () =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const result = yield* server
.callTool({
name: "delegate_task",
arguments: { task: "Review", mode: "async" },
})
.pipe(
Effect.provideService(
McpInvocationContext.McpInvocationContext,
clientScope("full-access"),
),
Effect.provideService(McpSchema.McpServerClient, client),
);
expect(declaredFailure(result)).toMatchObject({ code: "thread_credential_required" });
}).pipe(
Effect.provide(
layerOrchestratorToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(Layer.mock(ThreadManagement.ThreadManagementService)({})),
Layer.provide(ServerSettings.layerTest()),
Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
Layer.provide(Layer.mock(ScheduledTaskService.ScheduledTaskService)({})),
Layer.provide(Layer.mock(PeerForwarding.PeerForwarding)({})),
Layer.provide(Layer.mock(PeerLinkRequests.PeerLinkRequests)({})),
Layer.provide(Layer.mock(PeerLinks.PeerLinks)({})),
Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
Layer.provide(Layer.mock(SecretRequests.SecretRequests)({})),
Layer.provide(Layer.mock(RemoteDelegation.RemoteDelegation)({})),
),
),
),
);
it.effect("a caller cannot rewrite a scheduled task that runs above its own modes", () =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const call = (name: string, args: Record<string, unknown>) =>
server
.callTool({ name, arguments: args })
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, clientScope("auto")),
Effect.provideService(McpSchema.McpServerClient, client),
);
const update = yield* call("schedule_task", {
scheduledTaskId: "task-full-access",
prompt: "Run something else",
});
expect(declaredFailure(update)).toMatchObject({ code: "runtime_mode_escalation_denied" });
const remove = yield* call("delete_scheduled_task", { scheduledTaskId: "task-full-access" });
expect(declaredFailure(remove)).toMatchObject({ code: "runtime_mode_escalation_denied" });
const allowed = yield* call("schedule_task", {
scheduledTaskId: "task-auto",
enabled: false,
});
expect(allowed.isError).toBe(false);
const incomplete = yield* call("schedule_task", { prompt: "Run nightly" });
expect(declaredFailure(incomplete)).toMatchObject({ code: "invalid_request" });
}).pipe(
Effect.provide(
layerOrchestratorToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(Layer.mock(ThreadManagement.ThreadManagementService)({})),
Layer.provide(ServerSettings.layerTest()),
Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
Layer.provide(
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () =>
Effect.succeed({
tasks: [
scheduledTask("task-full-access", "full-access"),
scheduledTask("task-auto", "auto"),
],
}),
upsert: (input) =>
Effect.succeed({
task: { ...(scheduledTask(input.id ?? "task-auto", "auto") as object), ...input },
} as never),
}),
),
Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
Layer.provide(Layer.mock(SecretRequests.SecretRequests)({})),
Layer.provide(Layer.mock(PeerForwarding.PeerForwarding)({})),
Layer.provide(Layer.mock(PeerLinkRequests.PeerLinkRequests)({})),
Layer.provide(Layer.mock(PeerLinks.PeerLinks)({})),
Layer.provide(Layer.mock(RemoteDelegation.RemoteDelegation)({})),
),
),
),
);
it.effect.each([
{
scenario: "explains why a webhook task cannot run manually",
tasks: [
{
...Schema.decodeSync(ScheduledTask)(scheduledTask("task-webhook", "full-access")),
schedule: { type: "webhook" as const, signature: null },
},
],
error: new ScheduledTaskError({
message: "Webhook tasks run when their URL receives a request.",
cause: new Error("private-webhook-cause"),
}),
code: "orchestration_error",
message: "Webhook tasks run when their URL receives a request.",
},
{
scenario: "reports a missing task before trying to run it",
tasks: [],
error: new ScheduledTaskError({ message: "must not run a missing task" }),
code: "invalid_request",
message: "The scheduled task was not found.",
},
])("run_scheduled_task_now $scenario", ({ tasks, error, code, message }) =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const result = yield* server
.callTool({ name: "run_scheduled_task_now", arguments: { taskId: "task-webhook" } })
.pipe(
Effect.provideService(
McpInvocationContext.McpInvocationContext,
clientScope("full-access"),
),
Effect.provideService(McpSchema.McpServerClient, client),
);
expect(result.isError).toBe(true);
expect(result.structuredContent).toBeUndefined();
expect(declaredFailure(result)).toEqual({ _tag: "OrchestratorMcpFailure", code, message });
expect(JSON.stringify(result)).not.toContain("private-");
}).pipe(
Effect.provide(
McpHttpServer.layerThreadToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(Layer.mock(ThreadManagement.ThreadManagementService)({})),
Layer.provide(Layer.mock(ThreadSearch.ThreadSearch)({})),
Layer.provide(Layer.mock(PeerForwarding.PeerForwarding)({})),
Layer.provide(Layer.mock(PeerLinkRequests.PeerLinkRequests)({})),
Layer.provide(Layer.mock(PeerLinks.PeerLinks)({})),
Layer.provide(
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () => Effect.succeed({ tasks }),
runNow: () => Effect.fail(error),
}),
),
),
),
),
);
function scheduledTask(id: string, runtimeMode: "auto" | "full-access"): never {
return {
id,
title: id,
prompt: "Check the build",
enabled: true,
projectId: "project-a",
threadId: null,
schedule: { type: "interval", everyMs: 3_600_000 },
workspaceStrategy: { type: "worktree", baseRef: "main", startFromOrigin: true },
modelSelection: { instanceId: "codex", model: "gpt-5" },
runtimeMode,
interactionMode: "default",
createdBy: "user",
creationSource: "web",
nextRunAt: null,
lastRunStatus: "never",
lastRunAt: null,
lastRunThreadId: null,
lastRunError: null,
runCount: 0,
createdAt: "2026-10-01T00:00:00.000Z",
updatedAt: "2026-10-01T00:00:00.000Z",
} as never;
}
it.effect.each(["t3_thread_interrupt", "t3_workflow_stop"])(
"a caller cannot use %s on a thread that runs above its own modes",
(toolName) =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const result = yield* server
.callTool({
name: toolName,
arguments: {
threadId: "full-access-thread",
...(toolName === "t3_workflow_stop" ? { subagentId: "workflow-coordinator" } : {}),
},
})
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, clientScope("auto")),
Effect.provideService(McpSchema.McpServerClient, client),
);
expect(declaredFailure(result)).toMatchObject({ code: "runtime_mode_escalation_denied" });
}).pipe(
Effect.provide(
layerOrchestratorToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
getThreadShell: () =>
Effect.succeed({
projectId: "project-a",
deletedAt: null,
runtimeMode: "full-access",
interactionMode: "default",
} as never),
getProjectThreadRecords: () =>
Effect.succeed({
thread: {
id: ThreadId.make("full-access-thread"),
projectId: "project-a",
runtimeMode: "full-access",
interactionMode: "default",
deletedAt: null,
},
runs: [],
} as never),
stopWorkflow: () => Effect.die("workflow stop must not dispatch above the ceiling"),
interruptThread: () => Effect.die("interrupt must not dispatch above the ceiling"),
}),
),
Layer.provide(ServerSettings.layerTest()),
Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
Layer.provide(Layer.mock(ScheduledTaskService.ScheduledTaskService)({})),
Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
Layer.provide(Layer.mock(SecretRequests.SecretRequests)({})),
Layer.provide(Layer.mock(RemoteDelegation.RemoteDelegation)({})),
Layer.provide(Layer.mock(PeerForwarding.PeerForwarding)({})),
Layer.provide(Layer.mock(PeerLinkRequests.PeerLinkRequests)({})),
Layer.provide(Layer.mock(PeerLinks.PeerLinks)({})),
),
),
),
);
it.effect("discovers workflow stop targets and requires orchestration capability", () => {
const threadId = ThreadId.make("workflow-parent");
const shell = McpToolAccessTestkit.liveThreadShell(threadId);
const subagentId = NodeId.make("workflow-coordinator");
const itemId = TurnItemId.make("workflow-coordinator-activity");
const row: OrchestrationV2ProjectedTurnItem = {
position: 0,
visibility: "local",
sourceThreadId: threadId,
sourceItemId: itemId,
item: {
id: itemId,
threadId,
runId: shell.activeRunId,
nodeId: subagentId,
providerThreadId: null,
providerTurnId: null,
nativeItemRef: null,
parentItemId: null,
ordinal: 0,
status: "running",
title: "Workflow: checkout review",
startedAt: shell.createdAt,
completedAt: null,
updatedAt: shell.updatedAt,
type: "subagent",
subagentId,
origin: "provider_native",
driver: ProviderDriverKind.make("claudeAgent"),
providerInstanceId: ProviderInstanceId.make("claudeAgent"),
childThreadId: ThreadId.make("workflow-child"),
prompt: "Review checkout",
result: null,
},
};
const stopped: Array<{ readonly threadId: ThreadId; readonly subagentId: string }> = [];
return Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const scope = clientScope("full-access");
const read = yield* server
.callTool({ name: "t3_thread_read", arguments: { threadId, view: "activity" } })
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, scope),
Effect.provideService(McpSchema.McpServerClient, client),
);
expect(read.isError).toBe(false);
const result = yield* decodeThreadReadResult(read.structuredContent);
expect(result.items[0]?.subagentId).toBe(subagentId);
const call = (invocation: McpInvocationContext.McpInvocationScope) =>
server
.callTool({
name: "t3_workflow_stop",
arguments: { threadId, subagentId: result.items[0]?.subagentId },
})
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
Effect.provideService(McpSchema.McpServerClient, client),
);
const denied = yield* call({ ...scope, capabilities: new Set(["worktree"]) });
expect(declaredFailure(denied)).toMatchObject({ code: "capability_denied" });
expect(stopped).toEqual([]);
const allowed = yield* call(scope);
expect(allowed.isError).toBe(false);
expect(stopped).toEqual([{ threadId: "workflow-parent", subagentId: "workflow-coordinator" }]);
}).pipe(
Effect.provide(
layerOrchestratorToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
getThreadShell: (id) => Effect.succeed(McpToolAccessTestkit.liveThreadShell(id)),
getProjectThreadRecords: () =>
Effect.succeed(McpToolAccessTestkit.idleThreadProjection(shell)),
getTimelinePage: () => Effect.succeed({ items: [row], totalItems: 1, hasMore: false }),
stopWorkflow: (input) =>
Effect.sync(() => {
stopped.push(input);
}),
}),
),
Layer.provide(ServerSettings.layerTest()),
Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
Layer.provide(Layer.mock(ScheduledTaskService.ScheduledTaskService)({})),
Layer.provide(Layer.mock(PeerForwarding.PeerForwarding)({})),
Layer.provide(Layer.mock(PeerLinkRequests.PeerLinkRequests)({})),
Layer.provide(Layer.mock(PeerLinks.PeerLinks)({})),
Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
Layer.provide(Layer.mock(SecretRequests.SecretRequests)({})),
Layer.provide(Layer.mock(RemoteDelegation.RemoteDelegation)({})),
),
),
);
});
it.effect("only the caller that prepared a pending upload can discard it", () =>
Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const call = (
name: string,
args: Record<string, unknown>,
invocation: McpInvocationContext.McpInvocationScope,
) =>
server
.callTool({ name, arguments: args })
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
Effect.provideService(McpSchema.McpServerClient, client),
);
const prepared = yield* call(
"t3_attachment_prepare_upload",
{ upload: { name: "shot.png", mimeType: "image/png", sizeBytes: 4 } },
scope,
);
const { attachmentId } = prepared.structuredContent as { readonly attachmentId: string };
const otherThread = {
...scope,
requestNamespace: "other-session",
thread: { ...scope.thread!, threadId: ThreadId.make("other-thread") },
};
const refused = yield* call("t3_attachment_discard", { attachmentId }, otherThread);
expect(declaredFailure(refused)).toMatchObject({ code: "invalid_request" });
yield* TestClock.adjust(24 * 60 * 60 * 1000 + 5 * 60_000);
yield* call(
"t3_attachment_prepare_upload",
{ upload: { name: "later.png", mimeType: "image/png", sizeBytes: 4 } },
scope,
);
const discarded = yield* call(
"t3_attachment_discard",
{ attachmentId },
{ ...scope, requestNamespace: "mcp-core-session-2" },
);
expect(discarded.isError).toBe(false);
}).pipe(
Effect.provide(
McpHttpServer.layerAttachmentToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(McpToolAccessTestkit.liveThreadsLayer),
Layer.provide(AssetSigner.layer.pipe(Layer.provideMerge(ServerSecretStore.layer))),
Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-mcp-attachment-" })),
Layer.provide(
DocumentText.layer.pipe(
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
),
),
Layer.provide(NodeCrypto.layer),
),
),
),
);
it.effect(
"t3_thread_list settled:false with an empty statuses list lists the unsettled threads",
() => {
const unsettled = McpToolAccessTestkit.liveThreadShell(ThreadId.make("unsettled-thread"));
const settled = {
...McpToolAccessTestkit.liveThreadShell(ThreadId.make("settled-thread")),
settledOverride: "settled",
} as const;
return Effect.gen(function* () {
const server = yield* McpServer.McpServer;
const result = yield* server
.callTool({
name: "t3_thread_list",
arguments: { projectId: unsettled.projectId, settled: false, statuses: [] },
})
.pipe(
Effect.provideService(
McpInvocationContext.McpInvocationContext,
clientScope("full-access"),
),
Effect.provideService(McpSchema.McpServerClient, client),
);
expect(result.isError).toBe(false);
expect(result.structuredContent).toMatchObject({
threads: [{ threadId: unsettled.id, settled: false }],
total: 1,
});
}).pipe(
Effect.provide(
layerOrchestratorToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provide(NodeCrypto.layer),
Layer.provide(
Layer.mock(ThreadManagement.ThreadManagementService)({
listProjectThreads: () => Effect.succeed([unsettled, settled]),
}),
),
Layer.provide(ServerSettings.layerTest()),
Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
Layer.provide(Layer.mock(ScheduledTaskService.ScheduledTaskService)({})),
Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
Layer.provide(Layer.mock(SecretRequests.SecretRequests)({})),
Layer.provide(Layer.mock(PeerForwarding.PeerForwarding)({})),
Layer.provide(Layer.mock(PeerLinkRequests.PeerLinkRequests)({})),
Layer.provide(Layer.mock(PeerLinks.PeerLinks)({})),
Layer.provide(Layer.mock(RemoteDelegation.RemoteDelegation)({})),
),
),
);
},
);