import { assert, describe, it } from "@effect/vitest";
import * as NodeServices from "@effect/platform-node/NodeServices";
import {
CheckpointId,
ChatAttachmentId,
EnvironmentId,
NodeId,
ProviderInstanceId,
ProviderSessionId,
ProviderThreadId,
ProviderTurnId,
RunAttemptId,
RunId,
ThreadId,
type ChatAttachment,
type ModelSelection,
type OrchestrationV2AppThread,
type OrchestrationV2ProviderThread,
OrchestrationV2UserInputQuestion,
type OrchestrationV2ProviderTurn,
} from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as Queue from "effect/Queue";
import * as Schema from "effect/Schema";
import * as Sink from "effect/Sink";
import * as Stream from "effect/Stream";
import * as ChildProcess from "effect/process/ChildProcess";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
import { handoffBudget } from "@t3tools/provider-core/server/handoffBudget";
import * as HostProcess from "@t3tools/shared/HostProcess";
import { AgentScope } from "@t3tools/shared/AgentScope";
import { toolOutputImages, compactDynamicToolOutput } from "@t3tools/shared/toolOutput";
import {
makePiAdapterV2,
PiAdapterV2Driver,
PI_PROVIDER,
type PiAdapterV2Options,
} from "./adapter.ts";
import { makePiRpcConnection, type PiRpcRecord } from "./rpc.ts";
import { loadMcpBridge } from "./mcpBridge.testkit.ts";
import { turnItemOutputText } from "../../../client-runtime/src/work-log/itemDetail.ts";
const layerTest = Layer.mergeAll(
NodeServices.layer,
IdAllocator.layer,
McpProviderSessions.layer,
TestProviderHost.layer().pipe(Layer.provide(NodeServices.layer)),
);
const decodeUserInputQuestions = Schema.decodeUnknownSync(
Schema.Array(OrchestrationV2UserInputQuestion),
);
const decodeJsonLine = Schema.decodeSync(Schema.fromJsonString(Schema.Unknown));
const encodeJsonLine = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
const PI_INSTANCE_ID = ProviderInstanceId.make("pi");
const THREAD_ID = ThreadId.make("thread-pi-test");
const SESSION_ID = ProviderSessionId.make("provider-session-pi-test");
const FAKE_SESSION_FILE = "/fake/.pi/agent/sessions/--workspace--/0001_abc.jsonl";
/** Deliberately outside the valid pid range so a group-kill can never land. */
const FAKE_PID = 999_999_999;
const at = (seconds: number) => DateTime.makeUnsafe(seconds * 1000);
const sessionMessage = (
id: string,
parentId: string | null,
role: "user" | "assistant",
seconds: number,
) => ({
type: "message",
id,
parentId,
timestamp: DateTime.formatIso(at(seconds)),
message: { role, content: [] },
});
const TURN_ONE_ENTRIES = [
sessionMessage("u1", null, "user", 10),
sessionMessage("a1", "u1", "assistant", 20),
sessionMessage("steer1", "a1", "user", 30),
sessionMessage("a1b", "steer1", "assistant", 40),
];
const UNCAPTURED_TURN_TREE = {
entries: [
...TURN_ONE_ENTRIES,
sessionMessage("u2", "a1b", "user", 110),
sessionMessage("a2", "u2", "assistant", 120),
sessionMessage("steer2", "a2", "user", 130),
sessionMessage("a2b", "steer2", "assistant", 140),
],
leafId: "a2b",
};
function uncapturedTurns(
providerThreadId: ProviderThreadId,
window = { startedAt: 150, completedAt: 200 },
): ReadonlyArray<OrchestrationV2ProviderTurn> {
const turn = (
ordinal: number,
nativeTurnRef: OrchestrationV2ProviderTurn["nativeTurnRef"],
status: OrchestrationV2ProviderTurn["status"],
startedAt: number,
completedAt: number,
): OrchestrationV2ProviderTurn => ({
id: ProviderTurnId.make(`turn-${ordinal}`),
providerThreadId,
nodeId: NodeId.make(`node-${ordinal}`),
runAttemptId: null,
nativeTurnRef,
ordinal,
status,
startedAt: at(startedAt),
completedAt: at(completedAt),
});
return [
turn(1, { driver: PI_PROVIDER, nativeId: "u1", strength: "strong" }, "completed", 0, 50),
turn(
2,
{ driver: PI_PROVIDER, nativeId: "synthetic-2", strength: "weak" },
"cancelled",
window.startedAt,
window.completedAt,
),
];
}
const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
runtimeMode: "full-access",
interactionMode: "default",
cwd: null,
});
const modelSelection = (model: string): ModelSelection => ({
instanceId: PI_INSTANCE_ID,
model,
});
interface FakePi {
readonly spawner: ChildProcessSpawner.ChildProcessSpawner["Service"];
readonly emit: (record: PiRpcRecord, chunkBytes?: number) => Effect.Effect<void>;
readonly takeRequest: (type: string) => Effect.Effect<PiRpcRecord>;
readonly queueEntries: (data: unknown) => void;
readonly queueMessages: (data: unknown) => void;
readonly vetoNextSwitch: () => void;
readonly queueState: (data: Record<string, unknown>) => void;
readonly setStreaming: (streaming: boolean) => void;
readonly setCompacting: (compacting: boolean) => void;
readonly deferNextState: () => void;
readonly resolveDeferredState: (data: unknown) => Effect.Effect<void>;
readonly failNextState: () => void;
readonly deferNextLifecycle: (type: "switch_session" | "new_session" | "fork" | "abort") => void;
readonly deferNextModelSelection: () => void;
readonly queueModels: (models: ReadonlyArray<unknown>) => void;
readonly vetoNextNewSession: () => void;
readonly allRequests: () => ReadonlyArray<PiRpcRecord>;
readonly queueStats: (data: unknown) => void;
/** Pi before 0.84.4 answers clear_queue as an unknown command. */
readonly setClearQueue: (
result:
| { readonly steering: ReadonlyArray<string>; readonly followUp: ReadonlyArray<string> }
| "unknown_command",
) => void;
readonly closeStdout: Effect.Effect<void>;
readonly lastSpawn: () => {
readonly args: ReadonlyArray<string>;
readonly env: NonNullable<ChildProcess.CommandOptions["env"]>;
};
}
/** Pi omits `model` when none is selected and `sessionName` until one is set. */
const recordedIdleState = (sessionFile: string) => ({
thinkingLevel: "high",
isStreaming: false,
isCompacting: false,
steeringMode: "one-at-a-time",
followUpMode: "one-at-a-time",
sessionFile,
sessionId: "00000000-0000-4000-8000-000000000002",
autoCompactionEnabled: true,
messageCount: 0,
pendingMessageCount: 0,
});
/** Pi 1.4.0 rejects every prompt while compaction runs, including steers. */
const PI_COMPACTING_PROMPT_ERROR =
"Cannot submit a prompt while compaction is in progress. Wait for compaction to finish and retry.";
const makeFakePi: Effect.Effect<FakePi> = Effect.gen(function* () {
const stdout = yield* Queue.unbounded<Uint8Array, Cause.Done>();
const requests = yield* Queue.unbounded<PiRpcRecord>();
const entriesQueue: Array<unknown> = [];
const messagesQueue: Array<unknown> = [];
const stateQueue: Array<Record<string, unknown>> = [];
const statsQueue: Array<unknown> = [];
const allRequests: Array<PiRpcRecord> = [];
let deferState = false;
let deferredStateRequest: PiRpcRecord | undefined;
let failState = false;
let vetoSwitch = false;
let vetoNewSession = false;
let deferredLifecycle: string | undefined;
let sessionFile = FAKE_SESSION_FILE;
let sessionGeneration = 0;
let models: ReadonlyArray<unknown> = [];
let isStreaming: boolean | null = null;
let isCompacting = false;
let clearQueue: Parameters<FakePi["setClearQueue"]>[0] = { steering: [], followUp: [] };
let stdinBuffer = "";
const emit = (record: PiRpcRecord, chunkBytes?: number) =>
Effect.gen(function* () {
const bytes = new TextEncoder().encode(`${encodeJsonLine(record)}\n`);
const size = chunkBytes ?? bytes.byteLength;
for (let offset = 0; offset < bytes.byteLength; offset += size) {
yield* Queue.offer(stdout, bytes.subarray(offset, offset + size));
}
});
const respondTo = (record: PiRpcRecord): PiRpcRecord | null => {
if (
typeof record["id"] !== "string" &&
!(record["type"] === "prompt" && (isStreaming !== null || isCompacting))
)
return null;
const base = {
type: "response",
id: record["id"],
command: String(record["type"]),
success: true,
};
switch (record["type"]) {
case "get_state":
if (failState) {
failState = false;
return { ...base, success: false, error: "state unavailable" };
}
return {
...base,
data: {
...recordedIdleState(sessionFile),
isStreaming: isStreaming ?? false,
...stateQueue.shift(),
},
};
case "prompt":
if (isCompacting) {
return { ...base, success: false, error: PI_COMPACTING_PROMPT_ERROR };
}
if (isStreaming && record["streamingBehavior"] === undefined) {
return {
...base,
success: false,
error:
"Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.",
};
}
return base;
case "get_available_models":
return { ...base, data: { models } };
case "new_session": {
const cancelled = vetoNewSession;
vetoNewSession = false;
if (!cancelled) sessionFile = `/fake/new-${++sessionGeneration}.jsonl`;
return { ...base, data: { cancelled } };
}
case "switch_session": {
const cancelled = vetoSwitch;
vetoSwitch = false;
return { ...base, data: { cancelled } };
}
case "get_entries":
return { ...base, data: entriesQueue.shift() ?? { entries: [], leafId: null } };
case "get_messages":
return { ...base, data: messagesQueue.shift() ?? { messages: [] } };
case "get_session_stats":
return { ...base, data: statsQueue.shift() ?? {} };
case "fork":
return { ...base, data: { text: "Hello pi", cancelled: false } };
case "clear_queue":
return clearQueue === "unknown_command"
? { ...base, success: false, error: "Unknown command: clear_queue" }
: { ...base, data: clearQueue };
default:
return base;
}
};
const handleStdinChunk = (chunk: Uint8Array) =>
Effect.gen(function* () {
stdinBuffer += new TextDecoder().decode(chunk);
while (true) {
const newline = stdinBuffer.indexOf("\n");
if (newline === -1) return;
const line = stdinBuffer.slice(0, newline);
stdinBuffer = stdinBuffer.slice(newline + 1);
if (line.length === 0) continue;
const record = decodeJsonLine(line) as PiRpcRecord;
allRequests.push(record);
yield* Queue.offer(requests, record);
if (record["type"] === "get_state" && deferState) {
deferState = false;
deferredStateRequest = record;
continue;
}
if (record["type"] === deferredLifecycle) {
deferredLifecycle = undefined;
continue;
}
const response = respondTo(record);
if (response !== null) yield* emit(response);
}
});
let lastSpawn: ReturnType<FakePi["lastSpawn"]> = {
args: [],
env: {},
};
const spawner = ChildProcessSpawner.make((command) =>
Effect.sync(() => {
if (ChildProcess.isStandardCommand(command)) {
lastSpawn = {
args: command.args.map(String),
env: command.options.env ?? {},
};
}
return ChildProcessSpawner.makeHandle({
pid: ChildProcessSpawner.ProcessId(FAKE_PID),
exitCode: Effect.never,
isRunning: Effect.succeed(true),
kill: () => Effect.void,
unref: Effect.succeed(Effect.void),
stdin: Sink.forEach(handleStdinChunk),
stdout: Stream.fromQueue(stdout),
stderr: Stream.empty,
all: Stream.empty,
getInputFd: () => Sink.drain,
getOutputFd: () => Stream.empty,
});
}),
);
const takeRequest = (type: string): Effect.Effect<PiRpcRecord> =>
Effect.gen(function* () {
while (true) {
const record = yield* Queue.take(requests);
if (record["type"] === type) return record;
}
});
return {
spawner,
emit,
takeRequest,
queueEntries: (data) => entriesQueue.push(data),
queueMessages: (data) => messagesQueue.push(data),
deferNextState: () => {
deferState = true;
},
resolveDeferredState: (data) =>
Effect.gen(function* () {
const record = deferredStateRequest;
assert.isDefined(record);
deferredStateRequest = undefined;
yield* emit({
type: "response",
id: record!["id"],
command: "get_state",
success: true,
data,
});
}),
failNextState: () => {
failState = true;
},
deferNextLifecycle: (type) => {
deferredLifecycle = type;
},
deferNextModelSelection: () => {
deferredLifecycle = "set_model";
},
queueModels: (value) => {
models = value;
},
vetoNextNewSession: () => {
vetoNewSession = true;
},
allRequests: () => allRequests,
vetoNextSwitch: () => {
vetoSwitch = true;
},
queueState: (data) => stateQueue.push(data),
setStreaming: (streaming) => {
isStreaming = streaming;
},
setCompacting: (compacting) => {
isCompacting = compacting;
},
queueStats: (data) => statsQueue.push(data),
setClearQueue: (result) => {
clearQueue = result;
},
closeStdout: Queue.end(stdout),
lastSpawn: () => lastSpawn,
} satisfies FakePi;
});
const makeAdapter = Effect.fnUntraced(function* (
fake: FakePi,
launchArgs = "",
forkFake?: FakePi,
continuationRequests?: PiAdapterV2Options["continuationRequests"],
) {
const spawner =
forkFake === undefined
? fake.spawner
: ChildProcessSpawner.make((command) =>
ChildProcess.isStandardCommand(command) && command.args.includes("--fork")
? forkFake.spawner.spawn(command)
: fake.spawner.spawn(command),
);
if (continuationRequests !== undefined) {
return yield* PiAdapterV2Driver.create({
instanceId: PI_INSTANCE_ID,
displayName: undefined,
enabled: true,
environment: [],
config: { enabled: true, binaryPath: "pi", launchArgs, customModels: [] },
}).pipe(
Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
Effect.provideService(HostProcess.Environment, {}),
Effect.provideService(ProviderContinuationRequests.ProviderContinuationRequests, {
...continuationRequests,
take: Effect.never,
}),
);
}
return yield* makePiAdapterV2({
instanceId: PI_INSTANCE_ID,
settings: { enabled: true, binaryPath: "pi", launchArgs, customModels: [] },
environment: {},
}).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
});
const openRuntime = Effect.fnUntraced(function* (
fake: FakePi,
model = "default",
threadId = THREAD_ID,
providerSessionId = SESSION_ID,
forkFake?: FakePi,
continuationRequests?: PiAdapterV2Options["continuationRequests"],
) {
const adapter = yield* makeAdapter(fake, "", forkFake, continuationRequests);
const runtime = yield* adapter.openSession({
threadId,
providerSessionId,
modelSelection: modelSelection(model),
runtimePolicy,
});
const emitted = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
yield* runtime.events.pipe(
Stream.runForEach((event) => Queue.offer(emitted, event)),
Effect.forkScoped,
);
const takeEvent = (predicate: (event: ProviderAdapter.ProviderAdapterV2Event) => boolean) =>
Effect.gen(function* () {
while (true) {
const event = yield* Queue.take(emitted);
if (predicate(event)) return event;
}
});
return { runtime, takeEvent };
});
const makeAppThread = Effect.fnUntraced(function* (model: string, threadId = THREAD_ID) {
const now = yield* DateTime.now;
return {
createdBy: "user",
creationSource: "web",
id: threadId,
projectId: "project:fixture:pi" as OrchestrationV2AppThread["projectId"],
title: "Pi test thread",
providerInstanceId: PI_INSTANCE_ID,
modelSelection: modelSelection(model),
runtimeMode: "full-access",
interactionMode: "default",
branch: null,
worktreePath: null,
activeProviderThreadId: null,
lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
forkedFrom: null,
createdAt: now,
updatedAt: now,
archivedAt: null,
settledOverride: null,
settledAt: null,
lastVisitedAt: null,
deletedAt: null,
} satisfies OrchestrationV2AppThread;
});
const startTurn = Effect.fnUntraced(function* (
runtime: ProviderAdapter.ProviderAdapterV2SessionRuntime,
providerThread: OrchestrationV2ProviderThread,
model = "default",
attachments: ReadonlyArray<ChatAttachment> = [],
text = "Hello pi",
selection?: ModelSelection,
runOrdinal = 1,
threadId = THREAD_ID,
continuation = false,
) {
const appThread = yield* makeAppThread(model, threadId);
const runId = RunId.make(`run:${threadId}:${runOrdinal}`);
yield* runtime.startTurn({
appThread,
threadId,
runId,
runOrdinal,
providerTurnOrdinal: runOrdinal,
attemptId: RunAttemptId.make(`run-attempt:${runId}:1`),
rootNodeId: NodeId.make(`node:${runId}:root`),
providerThread,
message: {
messageId: `message:${threadId}:${runOrdinal}` as never,
text,
attachments,
createdBy: continuation ? "agent" : "user",
creationSource: continuation ? "provider" : "web",
},
modelSelection: selection ?? modelSelection(model),
runtimePolicy,
});
});
describe("PiAdapterV2", () => {
it.effect(
"replaces keyed extension statuses while idle without producing conversation items",
() =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const { runtime, takeEvent } = yield* openRuntime(fake);
const updates = [
{ statusKey: "watch", statusText: "\u001b[32mWatching 3 files\u001b[0m\u0007" },
{ statusKey: "lint", statusText: "Lint clean" },
{ statusKey: "watch", statusText: "Watching 4 files" },
{ statusKey: "watch", statusText: "Watching 4 files" },
{ statusKey: "watch", statusText: "\u001b[32mWatching 4 files\u001b[0m" },
{ statusKey: "lint", statusText: "" },
{ statusKey: "missing" },
{ statusKey: "watch" },
{ statusKey: "watch", statusText: "Watching 4 files" },
];
for (const update of updates) {
yield* fake.emit({ type: "extension_ui_request", method: "setStatus", ...update });
}
// The following dialog is an observable milestone after the preceding native notifications.
yield* fake.emit({
type: "extension_ui_request",
id: "status-barrier",
method: "input",
title: "Continue?",
});
const observed: ProviderAdapter.ProviderAdapterV2Event[] = [];
yield* takeEvent((event) => {
observed.push(event);
return event.type === "runtime_request.updated";
});
assert.deepInclude(runtime.providerSession, {
extensionStatuses: [{ key: "watch", text: "Watching 4 files" }],
});
const snapshots = observed.filter((event) => event.type === "provider_session.updated");
assert.lengthOf(snapshots, 6);
assert.deepInclude(snapshots[0]?.providerSession, {
extensionStatuses: [{ key: "watch", text: "Watching 3 files" }],
});
assert.deepInclude(snapshots[2]?.providerSession, {
extensionStatuses: [
{ key: "watch", text: "Watching 4 files" },
{ key: "lint", text: "Lint clean" },
],
});
assert.isFalse(observed.some((event) => event.type === "message.updated"));
assert.isFalse(
observed.some(
(event) =>
event.type === "turn_item.updated" && event.turnItem.type !== "user_input_request",
),
);
assert.isFalse(
fake.allRequests().some((request) => request["type"] === "extension_ui_response"),
);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect("bounds native extension statuses and lets cleared keys free capacity", () =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const { runtime, takeEvent } = yield* openRuntime(fake);
for (let index = 0; index < 35; index++) {
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: `key-${index}`,
statusText: index === 1 ? "w".repeat(20000) : "Watching",
});
}
for (const update of [
{ statusKey: "" },
{ statusKey: "x".repeat(257) },
{ statusKey: "malformed", statusText: null },
]) {
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusText: "Invalid",
...update,
});
}
yield* fake.emit({ type: "extension_ui_request", method: "setStatus", statusKey: "key-0" });
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: "replacement",
statusText: "New status",
});
yield* fake.emit({
type: "extension_ui_request",
id: "status-barrier",
method: "input",
title: "Continue?",
});
yield* takeEvent((event) => event.type === "runtime_request.updated");
const statuses = runtime.providerSession.extensionStatuses ?? [];
assert.lengthOf(statuses, 32);
assert.equal(statuses[0]?.key, "key-1");
assert.equal(statuses[0]?.text.length, 4096);
assert.deepEqual(statuses.at(-1), { key: "replacement", text: "New status" });
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect("publishes extension status while native work awaits adoption", () =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{ offer: (offer) => Queue.offer(offers, offer).pipe(Effect.asVoid) },
);
yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({ type: "agent_start" });
yield* Queue.take(offers);
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: "watch",
statusText: "Native wake",
});
yield* fake.emit({
type: "extension_ui_request",
id: "status-barrier",
method: "input",
title: "Continue?",
});
yield* takeEvent((event) => event.type === "runtime_request.updated");
assert.deepEqual(runtime.providerSession.extensionStatuses, [
{ key: "watch", text: "Native wake" },
]);
assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect(
"keeps extension status through turn settlement and clears it on native session replacement",
() =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const { runtime, takeEvent } = yield* openRuntime(fake);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* startTurn(runtime, providerThread);
yield* fake.takeRequest("prompt");
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: "watch",
statusText: "Watching",
});
yield* fake.emit({ type: "agent_settled" });
yield* takeEvent((event) => event.type === "turn.terminal");
assert.deepInclude(runtime.providerSession, {
status: "ready",
extensionStatuses: [{ key: "watch", text: "Watching" }],
});
yield* startTurn(
runtime,
providerThread,
"anthropic/other-model",
[],
"Hello again",
undefined,
2,
);
assert.deepEqual(runtime.providerSession.extensionStatuses, [
{ key: "watch", text: "Watching" },
]);
yield* fake.emit({ type: "agent_settled" });
yield* takeEvent((event) => event.type === "turn.terminal");
yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
assert.deepInclude(runtime.providerSession, { extensionStatuses: [] });
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect.each(["model error", "rejected prompt", "failed compact"] as const)(
"keeps extension status through a reusable %s and the next turn",
(failure) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const { runtime, takeEvent } = yield* openRuntime(fake);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: "watch",
statusText: "Watching 3 files",
});
const command = failure === "failed compact" ? "compact" : "prompt";
yield* startTurn(
runtime,
providerThread,
"default",
[],
command === "compact" ? "/compact" : "Hello pi",
);
yield* fake.takeRequest(command);
if (failure === "model error") {
yield* fake.emit({
type: "message_end",
message: { role: "assistant", stopReason: "error", errorMessage: "Rate limited" },
});
yield* fake.emit({ type: "agent_settled" });
} else {
yield* fake.emit({
type: "response",
command,
success: false,
error: "Request rejected",
});
}
const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "failed");
assert.deepInclude(runtime.providerSession, {
status: "error",
extensionStatuses: [{ key: "watch", text: "Watching 3 files" }],
});
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: "watch",
statusText: "Watching 4 files",
});
yield* fake.emit({
type: "extension_ui_request",
id: "failed-turn-status-barrier",
method: "input",
title: "Continue?",
});
yield* takeEvent((event) => event.type === "runtime_request.updated");
assert.deepInclude(runtime.providerSession, {
status: "error",
extensionStatuses: [{ key: "watch", text: "Watching 4 files" }],
});
yield* startTurn(runtime, providerThread, "default", [], "Hello again", undefined, 2);
yield* fake.takeRequest("prompt");
yield* fake.emit({ type: "agent_settled" });
const nextTerminal = yield* takeEvent((event) => event.type === "turn.terminal");
assert.isTrue(nextTerminal.type === "turn.terminal" && nextTerminal.status === "completed");
assert.deepInclude(runtime.providerSession, {
id: SESSION_ID,
status: "ready",
extensionStatuses: [{ key: "watch", text: "Watching 4 files" }],
});
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect("preserves extension statuses when a native session switch is vetoed", () =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const { runtime, takeEvent } = yield* openRuntime(fake);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: "watch",
statusText: "Watching",
});
yield* fake.emit({
type: "extension_ui_request",
id: "status-barrier",
method: "input",
title: "Continue?",
});
yield* takeEvent((event) => event.type === "runtime_request.updated");
fake.vetoNextSwitch();
const exit = yield* runtime.resumeThread({ providerThread }).pipe(Effect.exit);
assert.isTrue(Exit.isFailure(exit));
assert.deepEqual(runtime.providerSession.extensionStatuses, [
{ key: "watch", text: "Watching" },
]);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect.each(["success", "cancelled", "error"] as const)(
"handles native status publications during session switch hooks, outcome=%s",
(outcome) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const { runtime, takeEvent } = yield* openRuntime(fake);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
for (const key of ["watch", "lint"])
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: key,
statusText: key === "lint" ? "Lint clean" : "Watching",
});
fake.deferNextLifecycle("switch_session");
const switching = yield* runtime
.resumeThread({ providerThread })
.pipe(Effect.exit, Effect.forkScoped);
const request = yield* fake.takeRequest("switch_session");
yield* fake.emit({ type: "extension_ui_request", method: "setStatus", statusKey: "watch" });
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: "startup",
statusText: "Fresh status",
});
yield* fake.emit({
type: "extension_ui_request",
id: "switch-hook",
method: "input",
title: "Continue?",
});
yield* takeEvent((event) => event.type === "runtime_request.updated");
yield* fake.emit({
type: "response",
id: request["id"],
command: "switch_session",
success: outcome !== "error",
data: { cancelled: outcome === "cancelled" },
...(outcome === "error" ? { error: "Session replacement failed" } : {}),
});
const exit = yield* Fiber.join(switching);
assert.equal(Exit.isFailure(exit), outcome !== "success");
if (outcome === "error") {
const reuse = yield* runtime.resumeThread({ providerThread }).pipe(Effect.exit);
assert.isTrue(Exit.isFailure(reuse));
yield* takeEvent(
(event) =>
event.type === "provider_session.updated" && event.providerSession.status === "error",
);
assert.deepEqual(runtime.providerSession.extensionStatuses, []);
return;
}
assert.deepEqual(runtime.providerSession.extensionStatuses, [
...(outcome === "cancelled" ? [{ key: "lint", text: "Lint clean" }] : []),
{ key: "startup", text: "Fresh status" },
]);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect.each(["stop", "transport death"] as const)(
"clears extension statuses on %s",
(retirement) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const { runtime, takeEvent } = yield* openRuntime(fake);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* startTurn(runtime, providerThread);
const turnStarted = yield* takeEvent((event) => event.type === "provider_turn.updated");
assert.equal(turnStarted.type, "provider_turn.updated");
if (turnStarted.type !== "provider_turn.updated") return;
yield* fake.emit({
type: "extension_ui_request",
method: "setStatus",
statusKey: "watch",
statusText: "Watching",
});
yield* fake.emit({
type: "extension_ui_request",
id: "status-barrier",
method: "input",
title: "Continue?",
});
yield* takeEvent((event) => event.type === "runtime_request.updated");
assert.deepInclude(runtime.providerSession, {
extensionStatuses: [{ key: "watch", text: "Watching" }],
});
if (retirement === "stop") {
yield* runtime.interruptTurn({
providerThread,
providerTurnId: turnStarted.providerTurn.id,
requestRuntimeRestart: true,
});
} else yield* fake.closeStdout;
yield* takeEvent(
(event) =>
event.type === "provider_session.updated" &&
event.providerSession.status === (retirement === "stop" ? "stopped" : "error"),
);
assert.deepInclude(runtime.providerSession, { extensionStatuses: [] });
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect("keeps native image bytes and the saved path in the prompt", () =>
Effect.gen(function* () {
const host = yield* ProviderHost.ProviderHost;
const fileSystem = yield* FileSystem.FileSystem;
const attachment: ChatAttachment = {
id: ChatAttachmentId.make("image"),
type: "image",
name: "image.png",
mimeType: "image/png",
sizeBytes: 3,
};
const path = host.resolveAttachmentPath(attachment)!;
yield* fileSystem.writeFile(path, new Uint8Array([1, 2, 3]));
const fake = yield* makeFakePi;
const { runtime } = yield* openRuntime(fake);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* startTurn(runtime, providerThread, "default", [attachment]);
const prompt = yield* fake.takeRequest("prompt");
assert.include(String(prompt["message"]), path);
assert.deepEqual(prompt["images"], [{ type: "image", data: "AQID", mimeType: "image/png" }]);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect("lists unavailable attachments alongside resolvable files in the native prompt", () =>
Effect.gen(function* () {
const host = yield* ProviderHost.ProviderHost;
const fake = yield* makeFakePi;
const { runtime } = yield* openRuntime(fake).pipe(
Effect.provideService(ProviderHost.ProviderHost, {
...host,
resolveAttachmentPath: (attachment) =>
attachment.id === "available" ? host.resolveAttachmentPath(attachment) : null,
}),
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
const attachments: ReadonlyArray<ChatAttachment> = [
{
id: ChatAttachmentId.make("available"),
type: "file",
name: "notes.txt",
mimeType: "text/plain",
sizeBytes: 1,
},
{
id: ChatAttachmentId.make("missing-file"),
type: "file",
name: "missing.txt",
mimeType: "text/plain",
sizeBytes: 1,
},
{
id: ChatAttachmentId.make("missing-image"),
type: "image",
name: "missing.png",
mimeType: "image/png",
sizeBytes: 1,
},
{
id: ChatAttachmentId.make("missing-future"),
type: "future",
name: "future.bin",
mimeType: "application/octet-stream",
sizeBytes: 1,
},
];
yield* startTurn(runtime, providerThread, "default", attachments);
const prompt = yield* fake.takeRequest("prompt");
assert.isString(prompt["message"]);
const message = String(prompt["message"]);
assert.include(message, host.resolveAttachmentPath(attachments[0]!)!);
for (const attachment of attachments.slice(1)) {
assert.include(message, attachment.name);
assert.include(message, attachment.id);
}
assert.equal((message.match(/unavailable/g) ?? []).length, 3);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect.each([false, true])(
"completes a resumed user turn before native wake events arrive, Pi streaming=%s",
(streaming) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const { runtime, takeEvent } = yield* openRuntime(fake);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
fake.setStreaming(streaming);
yield* runtime.resumeThread({ providerThread });
yield* startTurn(runtime, providerThread);
yield* fake.takeRequest("prompt");
yield* fake.emit({ type: "agent_start" });
yield* fake.emit({
type: "message_end",
message: {
role: "assistant",
content: [{ type: "text", text: "Resumed prompt completed" }],
stopReason: "stop",
},
});
fake.queueState({ isStreaming: false });
yield* fake.emit({ type: "agent_settled" });
const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect.each([false, true])(
"serializes rollback fork hooks with native wake ownership, wake=%s",
(nativeWake) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{
offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
},
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
fake.deferNextLifecycle("fork");
const rollingBack = yield* runtime
.rollbackThread({
providerThread,
target: {
type: "thread_start",
checkpointId: CheckpointId.make("checkpoint-start"),
appRunOrdinal: 0,
},
providerThreadTurns: [
{
id: ProviderTurnId.make("previous-turn"),
providerThreadId: providerThread.id,
nodeId: NodeId.make("previous-node"),
runAttemptId: null,
nativeTurnRef: {
driver: PI_PROVIDER,
nativeId: "user-before-wake",
strength: "strong",
},
ordinal: 1,
status: "completed",
startedAt: providerThread.createdAt,
completedAt: providerThread.createdAt,
},
],
})
.pipe(Effect.result, Effect.forkScoped);
const fork = yield* fake.takeRequest("fork");
const overlappingTurn = yield* startTurn(runtime, providerThread).pipe(Effect.result);
assert.equal(overlappingTurn._tag, "Failure");
const overlappingRegistration = yield* runtime
.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
})
.pipe(Effect.result);
assert.equal(overlappingRegistration._tag, "Failure");
yield* fake.emit({
type: "extension_ui_request",
id: "fork-hook-dialog",
method: "confirm",
title: "Restore this branch?",
});
const forkDialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
assert.isTrue(forkDialog.type === "runtime_request.updated");
if (forkDialog.type !== "runtime_request.updated") return;
assert.isNull(forkDialog.runtimeRequest.providerTurnId);
yield* runtime.respondToRuntimeRequest({
requestId: forkDialog.runtimeRequest.id,
decision: "accept",
});
yield* fake.takeRequest("extension_ui_response");
if (nativeWake) {
yield* fake.emit({ type: "agent_start" });
yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
yield* fake.emit({
type: "message_update",
assistantMessageEvent: {
type: "text_end",
contentIndex: 0,
content: "Discarded branch wake output",
},
});
yield* fake.emit({ type: "agent_settled" });
const retired = yield* takeEvent(
(event) =>
event.type === "provider_session.updated" &&
event.providerSession.status === "stopped",
).pipe(Effect.as(true), Effect.raceFirst(Queue.take(offers).pipe(Effect.as(false))));
assert.isTrue(retired, "Pi offered native work while rollback was changing its binding");
const result = yield* Fiber.join(rollingBack);
assert.equal(result._tag, "Failure");
assert.isFalse(yield* runtime.hasPendingBackgroundWork!);
const staleTurn = yield* startTurn(
runtime,
providerThread,
"default",
[],
"Synthetic wake",
undefined,
1,
THREAD_ID,
true,
).pipe(Effect.result);
assert.equal(staleTurn._tag, "Failure");
assert.isFalse(fake.allRequests().some((request) => request["type"] === "prompt"));
return;
}
fake.queueState({ sessionFile: "/fake/rolled-back-session.jsonl" });
yield* fake.emit({
type: "response",
id: fork["id"],
command: "fork",
success: true,
data: { cancelled: false },
});
const result = yield* Fiber.join(rollingBack);
assert.equal(result._tag, "Success");
if (result._tag !== "Success") return;
assert.equal(
result.success.providerThread.nativeThreadRef?.nativeId,
"/fake/rolled-back-session.jsonl",
);
yield* startTurn(runtime, result.success.providerThread);
const prompt = yield* fake.takeRequest("prompt");
assert.equal(prompt["message"], "Hello pi");
yield* fake.emit({ type: "response", command: "prompt", success: true });
yield* fake.emit({ type: "agent_start" });
yield* fake.emit({ type: "agent_settled" });
const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect.each([false, true])(
"retains native wake ownership and delivers a joining prompt held through compaction, aborted=%s",
(aborted) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{
offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
},
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.takeRequest("get_state");
yield* fake.emit({ type: "agent_start" });
yield* Queue.take(offers);
yield* fake.emit({ type: "agent_settled" });
yield* fake.emit({ type: "compaction_start", reason: "manual" });
yield* startTurn(runtime, providerThread);
yield* fake.emit({
type: "extension_ui_request",
id: "native-compaction-dialog",
method: "confirm",
title: "Continue native work?",
});
const dialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
assert.isTrue(dialog.type === "runtime_request.updated");
if (dialog.type !== "runtime_request.updated") return;
assert.isNotNull(dialog.runtimeRequest.providerTurnId);
yield* runtime.respondToRuntimeRequest({
requestId: dialog.runtimeRequest.id,
decision: "accept",
});
yield* fake.takeRequest("extension_ui_response");
assert.isFalse(fake.allRequests().some((request) => request["type"] === "prompt"));
yield* fake.emit(
aborted
? { type: "compaction_end", result: null, aborted: true }
: {
type: "compaction_end",
result: { summary: "Native compaction finished" },
willRetry: true,
},
);
const prompt = yield* fake.takeRequest("prompt");
assert.equal(prompt["message"], "Hello pi");
fake.queueState({ isStreaming: true });
yield* fake.emit({ type: "response", command: "prompt", success: true });
yield* fake.takeRequest("get_state");
yield* fake.emit({ type: "agent_start" });
yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
yield* fake.emit({
type: "message_update",
assistantMessageEvent: {
type: "text_end",
contentIndex: 0,
content: "Native work completed",
},
});
const message = yield* takeEvent((event) => event.type === "message.updated");
assert.isTrue(message.type === "message.updated" && message.message.runId !== null);
yield* fake.emit({ type: "agent_settled" });
const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
assert.equal(
fake.allRequests().filter((request) => request["type"] === "prompt").length,
1,
);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect("rejects rollback while native wake output is awaiting ownership", () =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{
offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
},
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({ type: "agent_start" });
yield* Queue.take(offers);
yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
yield* fake.emit({
type: "message_update",
assistantMessageEvent: {
type: "text_end",
contentIndex: 0,
content: "Current branch wake output",
},
});
yield* fake.emit({ type: "agent_settled" });
yield* takeEvent(
(event) =>
event.type === "provider_session.updated" && event.providerSession.status === "ready",
);
const rolledBack = yield* runtime
.rollbackThread({
providerThread,
target: {
type: "thread_start",
checkpointId: CheckpointId.make("checkpoint-start"),
appRunOrdinal: 0,
},
providerThreadTurns: [
{
id: ProviderTurnId.make("previous-turn"),
providerThreadId: providerThread.id,
nodeId: NodeId.make("previous-node"),
runAttemptId: null,
nativeTurnRef: {
driver: PI_PROVIDER,
nativeId: "user-before-wake",
strength: "strong",
},
ordinal: 1,
status: "completed",
startedAt: providerThread.createdAt,
completedAt: providerThread.createdAt,
},
],
})
.pipe(Effect.result);
assert.equal(
rolledBack._tag,
"Failure",
"Rollback changed the native session while its wake was still buffered",
);
assert.isFalse(fake.allRequests().some((request) => request["type"] === "fork"));
assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
yield* startTurn(
runtime,
providerThread,
"default",
[],
"Synthetic wake",
undefined,
1,
THREAD_ID,
true,
);
const message = yield* takeEvent((event) => event.type === "message.updated");
assert.equal(
message.type === "message.updated" && message.message.text,
"Current branch wake output",
);
yield* takeEvent((event) => event.type === "turn.terminal");
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect("answers model-selection dialogs before a user turn claims a native wake", () =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{ offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid) },
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({ type: "agent_start" });
yield* Queue.take(offers);
const requests: Array<
Extract<ProviderAdapter.ProviderAdapterV2Event, { type: "runtime_request.updated" }>
> = [];
fake.deferNextModelSelection();
const starting = yield* startTurn(
runtime,
providerThread,
"default",
[],
"Continue the review",
modelSelection("xai/grok-4.6"),
).pipe(Effect.forkScoped);
const modelRequest = yield* fake.takeRequest("set_model");
yield* fake.emit({
type: "extension_ui_request",
id: "model-selection-dialog",
method: "confirm",
title: "Use this model?",
});
yield* fake.emit({ type: "agent_settled" });
yield* takeEvent((event) => {
if (event.type === "runtime_request.updated") requests.push(event);
return (
event.type === "provider_session.updated" && event.providerSession.status === "ready"
);
});
const dialog = requests[0]?.runtimeRequest;
assert.isDefined(dialog, "Pi buffered the dialog needed to finish model selection");
assert.equal(requests[0]?.threadId, THREAD_ID);
assert.isNull(dialog!.providerTurnId);
yield* runtime.respondToRuntimeRequest({ requestId: dialog!.id, decision: "accept" });
const response = yield* fake.takeRequest("extension_ui_response");
assert.equal(response["id"], "model-selection-dialog");
assert.isTrue(response["confirmed"]);
yield* fake.emit({
type: "response",
id: modelRequest["id"],
command: "set_model",
success: true,
data: { provider: "xai", id: "grok-4.6" },
});
yield* Fiber.join(starting);
const prompt = yield* fake.takeRequest("prompt");
assert.equal(prompt["message"], "Continue the review");
assert.equal(prompt["streamingBehavior"], "steer");
const resolved = yield* takeEvent(
(event) =>
event.type === "runtime_request.updated" && event.runtimeRequest.id === dialog!.id,
);
assert.isTrue(
resolved.type === "runtime_request.updated" &&
resolved.runtimeRequest.status === "resolved",
);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect("adopts a completed native wake without sending a synthetic prompt", () =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{
offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
},
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({ type: "agent_start" });
const offer = yield* Queue.take(offers).pipe(
Effect.raceFirst(
takeEvent(
(event) =>
event.type === "provider_session.updated" && event.providerSession.status === "error",
).pipe(
Effect.andThen(Effect.sync(() => assert.fail("Pi killed a routable native wake"))),
),
),
);
assert.equal(offer.threadId, THREAD_ID);
assert.equal(offer.providerThreadId, providerThread.id);
assert.equal(offer.delivery, "adapter_buffered");
assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
let dispatchCommitted = false;
yield* offer.dispatchIfCurrent!(
Effect.sync(() => {
dispatchCommitted = true;
}),
);
assert.isTrue(dispatchCommitted);
assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
yield* fake.emit({
type: "message_update",
assistantMessageEvent: {
type: "text_delta",
contentIndex: 0,
delta: "Background review finished",
},
});
yield* fake.emit({ type: "message_end", message: { role: "assistant" } });
yield* fake.emit({ type: "agent_settled" });
yield* takeEvent(
(event) =>
event.type === "provider_session.updated" && event.providerSession.status === "ready",
);
assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
yield* startTurn(
runtime,
providerThread,
"default",
[],
"Synthetic wake",
undefined,
1,
THREAD_ID,
true,
);
const message = yield* takeEvent((event) => event.type === "message.updated");
assert.equal(
message.type === "message.updated" && message.message.text,
"Background review finished",
);
yield* takeEvent((event) => event.type === "turn.terminal");
assert.equal(fake.allRequests().filter((request) => request["type"] === "prompt").length, 0);
assert.isFalse(yield* runtime.hasPendingBackgroundWork!);
let dispatched = false;
yield* offer.dispatchIfCurrent!(
Effect.sync(() => {
dispatched = true;
}),
);
assert.isFalse(dispatched);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect.each([false, true])(
"a user prompt takes the wake without premature settlement, native wake settled=%s",
(settled) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{
offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
},
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({ type: "agent_start" });
const offer = yield* Queue.take(offers);
if (settled) {
yield* fake.emit({ type: "agent_settled" });
yield* takeEvent(
(event) =>
event.type === "provider_session.updated" && event.providerSession.status === "ready",
);
}
yield* startTurn(runtime, providerThread);
const prompt = yield* fake.takeRequest("prompt");
assert.equal(prompt["message"], "Hello pi");
assert.equal(prompt["streamingBehavior"], "steer");
yield* fake.emit({ type: "response", command: "prompt", success: true });
yield* fake.emit({ type: "agent_start" });
yield* fake.emit({
type: "extension_ui_request",
id: "owned-dialog",
method: "confirm",
title: "Continue?",
});
const dialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
assert.isTrue(dialog.type === "runtime_request.updated");
if (dialog.type !== "runtime_request.updated") return;
assert.isNotNull(dialog.runtimeRequest.providerTurnId);
yield* offer.clearIfCurrent!();
yield* runtime.respondToRuntimeRequest({
requestId: dialog.runtimeRequest.id,
decision: "accept",
});
const response = yield* fake.takeRequest("extension_ui_response");
assert.isTrue(response["confirmed"]);
yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
yield* fake.emit({
type: "message_update",
assistantMessageEvent: {
type: "text_end",
contentIndex: 0,
content: "User prompt completed",
},
});
yield* fake.emit({ type: "agent_settled" });
const message = yield* takeEvent(
(event) =>
event.type === "message.updated" && event.message.text === "User prompt completed",
);
assert.isTrue(message.type === "message.updated" && message.message.runId !== null);
yield* takeEvent((event) => event.type === "turn.terminal");
let dispatched = false;
yield* offer.dispatchIfCurrent!(
Effect.sync(() => {
dispatched = true;
}),
);
assert.isFalse(dispatched);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect.each([false, true])(
"defers a wake's late settlement until the joined user prompt is acknowledged, aborted=%s",
(aborted) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{
offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
},
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({ type: "agent_start" });
yield* Queue.take(offers);
yield* startTurn(runtime, providerThread);
yield* fake.takeRequest("prompt");
yield* fake.emit({ type: "agent_settled", aborted });
yield* fake.emit({
type: "extension_ui_request",
method: "notify",
message: "Ordering barrier",
});
yield* takeEvent(
(event) => event.type === "turn_item.updated" && event.turnItem.type === "system_notice",
);
assert.equal(runtime.providerSession.status, "running");
fake.queueState({ isStreaming: true });
yield* fake.emit({ type: "response", command: "prompt", success: true });
yield* fake.takeRequest("get_state");
yield* fake.emit({ type: "agent_start" });
yield* fake.emit({ type: "agent_settled" });
const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect.each([
{ aborted: false, resumes: false, expected: "completed" },
{ aborted: true, resumes: false, expected: "interrupted" },
{ aborted: true, resumes: true, expected: "completed" },
])(
"settles a completed wake, aborted=$aborted, resumes=$resumes",
({ aborted, resumes, expected }) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{
offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
},
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({ type: "agent_start" });
yield* Queue.take(offers);
yield* fake.emit({ type: "agent_settled", aborted });
yield* takeEvent(
(event) =>
event.type === "provider_session.updated" && event.providerSession.status === "ready",
);
yield* startTurn(runtime, providerThread, "default", [], "/hello");
yield* fake.takeRequest("prompt");
if (resumes) yield* fake.emit({ type: "agent_start" });
yield* fake.emit({ type: "response", command: "prompt", success: true });
if (resumes) yield* fake.emit({ type: "agent_settled", aborted: false });
const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
assert.isTrue(terminal.type === "turn.terminal" && terminal.status === expected);
yield* startTurn(
runtime,
providerThread,
"default",
[],
"Stale continuation",
undefined,
2,
THREAD_ID,
true,
);
yield* takeEvent((event) => event.type === "turn.terminal");
assert.equal(
fake.allRequests().filter((request) => request["type"] === "prompt").length,
1,
);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
it.effect("keeps a pending wake on its thread and lets Stop retire its process", () =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
const offers =
yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
const { runtime, takeEvent } = yield* openRuntime(
fake,
"default",
THREAD_ID,
SESSION_ID,
undefined,
{
offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
},
);
const providerThread = yield* runtime.ensureThread({
threadId: THREAD_ID,
modelSelection: modelSelection("default"),
runtimePolicy,
});
yield* fake.emit({ type: "agent_start" });