import {
EnvironmentId,
NodeId,
type OrchestrationV2ThreadProjection,
type OrchestrationV2ThreadShell,
ProjectId,
ProviderDriverKind,
ProviderInstanceId,
RunId,
ScheduledTaskId,
SECRET_REQUEST_UNSAVED_NOTE,
ThreadId,
TurnItemId,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Metric from "effect/Metric";
import * as TestClock from "effect/testing/TestClock";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import { expect, it } from "vite-plus/test";
import * as ProviderAdapterRegistry from "../orchestration-v2/ProviderAdapterRegistry.ts";
import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
import * as ProjectService from "../project/ProjectService.ts";
import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as SecretRequests from "../secrets/SecretRequests.ts";
import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts";
import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
import * as RemoteDelegation from "../peer/RemoteDelegation.ts";
import * as Orchestrator from "../orchestration-v2/Orchestrator.ts";
import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
import type * as McpInvocationContext from "./McpInvocationContext.ts";
import * as OrchestratorMcpService from "./OrchestratorMcpService.ts";
import { liveThreadShell } from "./McpToolAccess.testkit.ts";
const layerOrchestratorService = OrchestratorMcpService.layer.pipe(
Layer.provide(Layer.mock(ThreadLaunchService.ThreadLaunchService)({})),
Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)({})),
);
const environmentId = EnvironmentId.make("environment-mcp-orchestrator-detail");
const projectId = ProjectId.make("project-mcp-orchestrator-detail");
const parentThreadId = ThreadId.make("thread-mcp-orchestrator-parent");
const childThreadId = ThreadId.make("thread-mcp-orchestrator-child");
const activeRunId = RunId.make("run-mcp-active");
const cancelledRunId = RunId.make("run-mcp-cancelled");
const childRunId = RunId.make("run-mcp-child");
const taskId = NodeId.make("node-mcp-task-1");
const now = DateTime.makeUnsafe("2026-08-04T12:00:00.000Z");
const codexDriver = ProviderDriverKind.make("codex");
const customCodexInstanceId = ProviderInstanceId.make("codex-custom-workspace");
const parentInstanceId = ProviderInstanceId.make("codex");
const makeScope = (): McpInvocationContext.McpInvocationScope => ({
environmentId,
requestNamespace: "provider-session-mcp-orchestrator-detail",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session-mcp-orchestrator-detail",
providerInstanceId: parentInstanceId,
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
});
function baseThread(input: {
readonly threadId: ThreadId;
readonly title: string;
readonly instanceId: ProviderInstanceId;
readonly model: string;
}) {
return {
id: input.threadId,
projectId,
title: input.title,
createdBy: "user" as const,
creationSource: "mcp" as const,
modelSelection: {
instanceId: input.instanceId,
model: input.model,
},
runtimeMode: "full-access" as const,
interactionMode: "default" as const,
branch: null,
worktreePath: null,
lineage: {
parentThreadId: null,
relationshipToParent: null,
rootThreadId: input.threadId,
},
archivedAt: null,
deletedAt: null,
providerInstanceId: input.instanceId,
createdAt: now,
updatedAt: now,
};
}
function makeRun(input: {
readonly id: RunId;
readonly ordinal: number;
readonly status: "running" | "waiting" | "cancelled" | "queued" | "completed";
readonly instanceId?: ProviderInstanceId;
}) {
return {
id: input.id,
ordinal: input.ordinal,
status: input.status,
modelSelection: {
instanceId: input.instanceId ?? parentInstanceId,
model: "gpt-5.4",
},
providerInstanceId: input.instanceId ?? parentInstanceId,
requestedAt: now,
startedAt: input.status === "cancelled" || input.status === "queued" ? null : now,
completedAt: input.status === "cancelled" || input.status === "completed" ? now : null,
};
}
it("readThread preserves caller access errors and prefers activity-run status over a newer cancelled queued run", async () => {
let callerUnavailable = false;
const projection = {
thread: baseThread({
threadId: parentThreadId,
title: "Parent",
instanceId: parentInstanceId,
model: "gpt-5.4",
}),
runs: [
makeRun({ id: activeRunId, ordinal: 1, status: "running" }),
makeRun({ id: cancelledRunId, ordinal: 2, status: "cancelled" }),
],
visibleTurnItems: [],
runtimeRequests: [],
messages: [],
contextTransfers: [],
subagents: [],
updatedAt: now,
} as unknown as OrchestrationV2ThreadProjection;
const layer = layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
Layer.mock(ThreadManagementService.ThreadManagementService)({
getTimelinePage: () => Effect.succeed({ items: [], totalItems: 0, hasMore: false }),
getThreadRecords: (threadId) =>
callerUnavailable
? Effect.fail(
new Orchestrator.OrchestratorProjectionError({
threadId,
cause: "Caller unavailable",
}),
)
: threadId === parentThreadId
? Effect.succeed(projection)
: Effect.die(`unexpected thread ${threadId}`),
getThreadShell: (threadId) =>
callerUnavailable
? Effect.die("A failed caller read must not reach the target")
: Effect.succeed(
threadId === parentThreadId
? (projection.thread as unknown as OrchestrationV2ThreadShell)
: null,
),
getProjectThreadRecords: (input) =>
input.threadId === parentThreadId
? Effect.succeed(projection)
: Effect.die(`unexpected thread ${input.threadId}`),
} satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
} satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () => Effect.succeed({ tasks: [] }),
} satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
} satisfies Partial<ProviderAdapterRegistry.ProviderAdapterRegistryV2["Service"]>),
NodeCrypto.layer,
),
),
);
await Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const result = yield* service.readThread(makeScope(), { threadId: parentThreadId });
expect(result.thread.status).toBe("running");
expect(result.thread.latestRunId).toBe(cancelledRunId);
expect(result.thread.activeRunId).toBe(activeRunId);
callerUnavailable = true;
const denied = yield* service
.readThread({ ...makeScope(), capabilities: new Set() }, { threadId: parentThreadId })
.pipe(Effect.flip);
expect(denied.code).toBe("capability_denied");
const missingCaller = yield* service
.readThread(makeScope(), { threadId: parentThreadId })
.pipe(Effect.flip);
expect(missingCaller.code).toBe("orchestration_error");
expect(missingCaller.message).toContain(`Unable to read thread ${parentThreadId}:`);
}).pipe(Effect.provide(layer), Effect.runPromise);
});
it("readThread pages cut-off text without splitting an emoji across pages", async () => {
const text = "a😀bc";
const itemId = TurnItemId.make("turn-item-mcp-reasoning");
const projection = {
thread: baseThread({
threadId: parentThreadId,
title: "Parent",
instanceId: parentInstanceId,
model: "gpt-5.4",
}),
runs: [makeRun({ id: activeRunId, ordinal: 1, status: "running" })],
visibleTurnItems: [],
runtimeRequests: [],
messages: [],
contextTransfers: [],
subagents: [],
updatedAt: now,
} as unknown as OrchestrationV2ThreadProjection;
const row = {
position: 0,
visibility: "visible",
sourceThreadId: parentThreadId,
sourceItemId: itemId,
item: {
type: "reasoning",
runId: activeRunId,
status: "completed",
title: null,
text,
updatedAt: now,
},
};
const layer = layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
Layer.mock(ThreadManagementService.ThreadManagementService)({
getTimelinePage: () =>
Effect.succeed({
items: [row] as unknown as OrchestrationV2ThreadProjection["visibleTurnItems"],
totalItems: 1,
hasMore: false,
}),
getThreadRecords: () => Effect.succeed(projection),
getProjectThreadRecords: () => Effect.succeed(projection),
getThreadShell: () =>
Effect.succeed(projection.thread as unknown as OrchestrationV2ThreadShell),
} satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
} satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () => Effect.succeed({ tasks: [] }),
} satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
} satisfies Partial<ProviderAdapterRegistry.ProviderAdapterRegistryV2["Service"]>),
NodeCrypto.layer,
),
),
);
await Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
for (const [maxCharsPerItem, expected] of [
[2, ["a", "😀", "bc"]],
[1, ["a", "😀", "b", "c"]],
] as const) {
let textOffset = 0;
for (const [index, text] of expected.entries()) {
const result = yield* service.readThread(makeScope(), {
threadId: parentThreadId,
view: "activity",
itemId,
textOffset,
maxCharsPerItem,
});
textOffset += text.length;
expect(result.items[0]).toMatchObject({
text,
textTruncated: index < expected.length - 1,
nextTextOffset: index < expected.length - 1 ? textOffset : null,
});
}
}
}).pipe(Effect.provide(layer), Effect.runPromise);
});
it("taskStatus returns task.providerInstanceId rather than the driver kind", async () => {
const parentProjection = {
thread: baseThread({
threadId: parentThreadId,
title: "Parent",
instanceId: parentInstanceId,
model: "gpt-5.4",
}),
runs: [makeRun({ id: activeRunId, ordinal: 1, status: "running" })],
visibleTurnItems: [],
runtimeRequests: [],
messages: [],
contextTransfers: [],
subagents: [
{
id: taskId,
threadId: parentThreadId,
runId: activeRunId,
parentNodeId: NodeId.make("node-parent"),
origin: "app_owned",
createdBy: "agent",
driver: codexDriver,
providerInstanceId: customCodexInstanceId,
providerThreadId: null,
childThreadId,
nativeTaskRef: null,
prompt: "Inspect the custom instance.",
title: null,
model: "gpt-5.4",
status: "running",
result: null,
startedAt: now,
completedAt: null,
updatedAt: now,
},
],
updatedAt: now,
} as unknown as OrchestrationV2ThreadProjection;
const childProjection = {
thread: {
...baseThread({
threadId: childThreadId,
title: "Child",
instanceId: customCodexInstanceId,
model: "gpt-5.4",
}),
lineage: {
parentThreadId,
relationshipToParent: "subagent",
rootThreadId: parentThreadId,
},
createdBy: "agent",
},
runs: [
makeRun({
id: childRunId,
ordinal: 1,
status: "running",
instanceId: customCodexInstanceId,
}),
],
visibleTurnItems: [],
runtimeRequests: [],
messages: [],
contextTransfers: [
{
type: "subagent_spawn",
sourceThreadId: parentThreadId,
targetThreadId: childThreadId,
targetRunId: childRunId,
},
],
subagents: [],
providerThreads: [],
updatedAt: now,
} as unknown as OrchestrationV2ThreadProjection;
const layer = layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
Layer.mock(ThreadManagementService.ThreadManagementService)({
getTimelinePage: () => Effect.succeed({ items: [], totalItems: 0, hasMore: false }),
getThreadRecords: (threadId) => {
if (threadId === parentThreadId) return Effect.succeed(parentProjection);
if (threadId === childThreadId) return Effect.succeed(childProjection);
return Effect.die(`unexpected thread ${threadId}`);
},
} satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
} satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () => Effect.succeed({ tasks: [] }),
} satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
} satisfies Partial<ProviderAdapterRegistry.ProviderAdapterRegistryV2["Service"]>),
NodeCrypto.layer,
),
),
);
await Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const result = yield* service.taskStatus(makeScope(), taskId);
expect(result.providerInstanceId).toBe(customCodexInstanceId);
expect(result.providerInstanceId).not.toBe(ProviderInstanceId.make(String(codexDriver)));
expect(result.status).toBe("running");
expect(result.taskId).toBe(taskId);
expect(result.childThreadId).toBe(childThreadId);
}).pipe(Effect.provide(layer), Effect.runPromise);
});
it("readThread and sendToThread reach threads in other projects", async () => {
let parentShell: OrchestrationV2ThreadShell | null = null;
let parentRuns: ReadonlyArray<unknown> = [
makeRun({ id: RunId.make("run-parent-live"), ordinal: 1, status: "running" }),
];
const foreignProjectId = ProjectId.make("project-mcp-orchestrator-foreign");
const foreignThreadId = ThreadId.make("thread-mcp-orchestrator-foreign");
const parentProjection = {
thread: baseThread({
threadId: parentThreadId,
title: "Parent",
instanceId: parentInstanceId,
model: "gpt-5.4",
}),
get runs() {
return parentRuns;
},
visibleTurnItems: [],
runtimeRequests: [],
messages: [],
contextTransfers: [],
subagents: [],
updatedAt: now,
} as unknown as OrchestrationV2ThreadProjection;
const foreignProjection = (threadId: ThreadId) =>
({
thread: {
...baseThread({
threadId,
title: "Foreign",
instanceId: parentInstanceId,
model: "gpt-5.4",
}),
projectId: foreignProjectId,
},
runs: [],
visibleTurnItems: [
{
position: 0,
visibility: "inherited",
sourceThreadId: threadId,
sourceItemId: "item-1",
item: {
id: "item-1",
type: "assistant_message",
messageId: "assistant-1",
status: "completed",
title: null,
text: "Foreign thread said hello",
createdAt: now,
updatedAt: now,
},
},
],
runtimeRequests: [],
messages: [],
contextTransfers: [],
subagents: [],
updatedAt: now,
}) as unknown as OrchestrationV2ThreadProjection;
const layer = layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) => {
if (threadId === parentThreadId) return Effect.succeed(parentProjection);
if (threadId === foreignThreadId) return Effect.succeed(foreignProjection(threadId));
return Effect.die(`unexpected thread ${threadId}`);
},
getThreadShell: (threadId) =>
Effect.succeed(
threadId === foreignThreadId
? (foreignProjection(threadId).thread as unknown as OrchestrationV2ThreadShell)
: threadId === parentThreadId
? parentShell
: null,
),
getTimelinePage: (threadId) =>
Effect.succeed({
items: foreignProjection(threadId).visibleTurnItems,
totalItems: 1,
hasMore: false,
}),
getProjectThreadRecords: (input) =>
input.threadId === foreignThreadId && input.projectId === foreignProjectId
? Effect.succeed(foreignProjection(input.threadId))
: Effect.fail(
new ThreadManagementService.ThreadManagementThreadNotFoundError({
projectId: input.projectId,
threadId: input.threadId,
}),
),
sendToThread: () =>
Effect.succeed({
run: { id: "run-foreign", status: "queued" },
delivery: "started",
} as unknown as ThreadManagementService.ThreadManagementSendResult),
} satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
} satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () =>
Effect.succeed({
tasks: [
{
id: "task-foreign",
projectId: foreignProjectId,
runtimeMode: "approval-required",
interactionMode: "default",
} as never,
],
}),
} satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
} satisfies Partial<ProviderAdapterRegistry.ProviderAdapterRegistryV2["Service"]>),
NodeCrypto.layer,
),
),
);
await Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const foreign = yield* service.readThread(makeScope(), { threadId: foreignThreadId });
expect(foreign.thread.threadId).toBe(foreignThreadId);
expect(foreign.thread.projectId).toBe(foreignProjectId);
expect(foreign.items.map((item) => item.text)).toEqual(["Foreign thread said hello"]);
const sent = yield* service.sendToThread(makeScope(), {
threadId: foreignThreadId,
message: "hi",
});
expect(sent.threadId).toBe(foreignThreadId);
parentRuns = [];
yield* service.readThread(makeScope(), { threadId: foreignThreadId });
const stale = yield* service
.sendToThread(makeScope(), { threadId: foreignThreadId, message: "hi again" })
.pipe(Effect.flip);
expect(stale.code).toBe("parent_not_active");
const staleInterrupt = yield* service
.interruptThread(makeScope(), { threadId: foreignThreadId })
.pipe(Effect.flip);
expect(staleInterrupt.code).toBe("parent_not_active");
const staleSchedule = yield* service
.scheduleTask(makeScope(), {
projectId: foreignProjectId,
prompt: "check in later",
schedule: { type: "interval", everyMs: 3_600_000 },
})
.pipe(Effect.flip);
expect(staleSchedule.code).toBe("parent_not_active");
const staleUpdate = yield* service
.updateScheduledTask(makeScope(), {
scheduledTaskId: ScheduledTaskId.make("task-foreign"),
enabled: false,
})
.pipe(Effect.flip);
expect(staleUpdate.code).toBe("parent_not_active");
const staleDelete = yield* service
.deleteScheduledTask(makeScope(), { scheduledTaskId: ScheduledTaskId.make("task-foreign") })
.pipe(Effect.flip);
expect(staleDelete.code).toBe("parent_not_active");
const backgroundTasks = [
{
taskId: "background-subagent",
kind: "subagent" as const,
providerInstanceId: parentInstanceId,
},
];
parentShell = {
...liveThreadShell(parentThreadId, { activeRunId: null }),
pendingBackgroundTasks: backgroundTasks,
};
const backgroundSent = yield* service.sendToThread(makeScope(), {
threadId: foreignThreadId,
message: "background",
});
expect(backgroundSent.threadId).toBe(foreignThreadId);
const delegate = yield* service
.delegateTask(makeScope(), { task: "requires a run" })
.pipe(Effect.flip);
expect(delegate.code).toBe("parent_not_active");
const create = yield* service
.createThreads(makeScope(), { threads: [{ prompt: "requires a run" }] })
.pipe(Effect.flip);
expect(create.code).toBe("parent_not_active");
const secret = yield* service
.requestSecret(makeScope(), { label: "Secret", reason: "requires a run" })
.pipe(Effect.flip);
expect(secret.code).toBe("parent_not_active");
parentShell = { ...parentShell, providerInstanceId: customCodexInstanceId };
const switchedScope = {
...makeScope(),
thread: { ...makeScope().thread!, providerInstanceId: customCodexInstanceId },
};
const switched = yield* service
.sendToThread(switchedScope, { threadId: foreignThreadId, message: "wrong owner" })
.pipe(Effect.flip);
expect(switched.code).toBe("parent_not_active");
const mismatched = yield* service
.sendToThread(makeScope(), { threadId: foreignThreadId, message: "stale provider" })
.pipe(Effect.flip);
expect(mismatched.code).toBe("parent_not_active");
parentShell = liveThreadShell(parentThreadId);
const restarted = yield* service.sendToThread(makeScope(), {
threadId: foreignThreadId,
message: "new run",
});
expect(restarted.threadId).toBe(foreignThreadId);
parentShell = {
...parentShell,
activeRunId: null,
pendingBackgroundTasks: backgroundTasks,
archivedAt: now,
};
const archived = yield* service
.sendToThread(makeScope(), { threadId: foreignThreadId, message: "archived" })
.pipe(Effect.flip);
expect(archived.code).toBe("parent_not_active");
parentShell = { ...parentShell, archivedAt: null, pendingBackgroundTasks: [] };
const stopped = yield* service
.sendToThread(makeScope(), { threadId: foreignThreadId, message: "after stop" })
.pipe(Effect.flip);
expect(stopped.code).toBe("parent_not_active");
}).pipe(Effect.provide(layer), Effect.runPromise);
});
it("requestSecret saves a pasted value to a file without opening a card", async () => {
const projection = {
thread: baseThread({
threadId: parentThreadId,
title: "Parent",
instanceId: parentInstanceId,
model: "gpt-5.4",
}),
runs: [{ ...makeRun({ id: activeRunId, ordinal: 1, status: "running" }), rootNodeId: taskId }],
visibleTurnItems: [],
runtimeRequests: [],
messages: [],
contextTransfers: [],
subagents: [],
updatedAt: now,
} as unknown as OrchestrationV2ThreadProjection;
const dispatched: Array<unknown> = [];
const saved: Array<{
readonly requestNamespace: string;
readonly requestKey: string;
readonly value: string;
}> = [];
const file = "/home/user/.t3/userdata/secrets/files/0123456789abcdef0123456789abcdef";
const layer = layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
threadId === parentThreadId
? Effect.succeed(projection)
: Effect.die(`unexpected thread ${threadId}`),
getThreadShell: (threadId) =>
Effect.succeed(
threadId === parentThreadId
? (projection.thread as unknown as OrchestrationV2ThreadShell)
: null,
),
dispatch: (command) => Effect.sync(() => void dispatched.push(command) as never),
} satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
} satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({
savePasted: (input) =>
Effect.sync(() => {
saved.push({
requestNamespace: input.requestNamespace,
requestKey: input.requestKey,
value: input.value,
});
return file;
}),
}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({}),
NodeCrypto.layer,
),
),
);
const counted = Metric.snapshot.pipe(
Effect.map((snapshots) => {
const found = snapshots.find(
(snapshot) =>
snapshot.id === "t3_secret_requests_total" &&
snapshot.attributes?.status === "saved_pasted",
);
return found?.type === "Counter" ? Number(found.state.count) : 0;
}),
);
await Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const before = yield* counted;
const result = yield* service.requestSecret(makeScope(), {
label: "Pixel PIN",
reason: "Unlocks the test phone.",
value: "482916",
clientRequestId: "pin-1",
});
expect(result).toEqual({ status: "saved", file });
expect(JSON.stringify(result)).not.toContain("482916");
expect(saved).toEqual([
{
requestNamespace: "provider-session-mcp-orchestrator-detail",
requestKey: "pin-1",
value: "482916",
},
]);
expect(dispatched).toEqual([]);
expect((yield* counted) - before).toBe(1);
const asRef = yield* service
.requestSecret(makeScope(), {
label: "Pixel PIN",
reason: "Unlocks the test phone.",
value: "482916",
delivery: "secretRef",
})
.pipe(Effect.flip);
expect(asRef.code).toBe("invalid_request");
expect(asRef.message).not.toContain("482916");
expect(saved).toHaveLength(1);
expect(dispatched).toEqual([]);
}).pipe(Effect.provide(layer), Effect.runPromise);
});
it("requestSecret returns the unsaved note for a declined, cancelled or timed-out card", async () => {
const outcomes = ["declined", "cancelled", "pending"] as const;
const results = await Effect.forEach(outcomes, (outcome) => {
const dispatched: Array<{ readonly type: string; readonly turnItemId?: string }> = [];
const projection = () => {
const card = dispatched.find((command) => command.type === "secret_request.record");
return {
thread: baseThread({
threadId: parentThreadId,
title: "Parent",
instanceId: parentInstanceId,
model: "gpt-5.4",
}),
runs: [
{ ...makeRun({ id: activeRunId, ordinal: 1, status: "running" }), rootNodeId: taskId },
],
visibleTurnItems: [],
turnItems:
card === undefined
? []
: [{ type: "secret_request", id: card.turnItemId, secretStatus: outcome }],
runtimeRequests: [],
messages: [],
contextTransfers: [],
subagents: [],
updatedAt: now,
} as unknown as OrchestrationV2ThreadProjection;
};
const layer = layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: () => Effect.sync(projection),
getThreadShell: () =>
Effect.sync(() => projection().thread as unknown as OrchestrationV2ThreadShell),
dispatch: (command) => Effect.sync(() => void dispatched.push(command) as never),
} satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
} satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({}),
NodeCrypto.layer,
),
),
);
return Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const request = yield* service
.requestSecret(makeScope(), {
label: "Staging password",
reason: "Signs in the QA account.",
delivery: "file",
timeoutMs: 1_000,
})
.pipe(Effect.forkChild({ startImmediately: true }));
yield* TestClock.adjust("2 seconds");
return yield* Fiber.join(request);
}).pipe(Effect.provide(Layer.merge(layer, TestClock.layer())));
}).pipe(Effect.runPromise);
expect(results).toEqual([
{ status: "declined", note: SECRET_REQUEST_UNSAVED_NOTE.declined },
{ status: "cancelled", note: SECRET_REQUEST_UNSAVED_NOTE.cancelled },
{ status: "timed_out", note: SECRET_REQUEST_UNSAVED_NOTE.timed_out },
]);
});