Unify provider runtime events and add Cursor adapter layer

- migrate Claude/Codex/registry adapters to canonical runtime event types and payload shapes - add Cursor layer adapter plus tests and wire it through server layers - update provider contracts/runtime schemas and related adapter tests

Julius Marminge committed 8 months ago

Commit fd65a351 parent e80564814 files · +3746 −535Browse files

Unified · Split

14 files

apps/server/src/provider/Layers/ClaudeCodeAdapter.test.ts +54 −40
apps/server/src/provider/Layers/ClaudeCodeAdapter.ts +600 −48
apps/server/src/provider/Layers/CodexAdapter.test.ts +5 −4
apps/server/src/provider/Layers/CodexAdapter.ts +623 −155
apps/server/src/provider/Layers/CursorAdapter.test.ts +350 −0
apps/server/src/provider/Layers/CursorAdapter.ts +1378 −0
apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts +20 −1
apps/server/src/provider/Layers/ProviderAdapterRegistry.ts +2 −1
apps/server/src/provider/Services/CursorAdapter.test.ts +97 −98
apps/server/src/provider/Services/CursorAdapter.ts +74 −178
apps/server/src/serverLayers.ts +5 −1
packages/contracts/src/provider.test.ts +6 −0
packages/contracts/src/provider.ts +6 −0
packages/contracts/src/providerRuntime.ts +526 −9

apps/server/src/provider/Layers/ClaudeCodeAdapter.test.ts+54−40

@@ -229,7 +229,7 @@ describe("ClaudeCodeAdapterLive", () => { · 228 unmodified lines
229	229	return Effect.gen(function* () {
230	230	const adapter = yield* ClaudeCodeAdapter;
231	231
232		− const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 8).pipe(
	232	+ const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 11).pipe(
233	233	Stream.runCollect,
234	234	Effect.forkChild,
235	235	);
@@ -315,40 +315,43 @@ describe("ClaudeCodeAdapterLive", () => { · 79 unmodified lines
315	315	runtimeEvents.map((event) => event.type),
316	316	[
317	317	"session.started",
	318	+ "session.configured",
	319	+ "session.state.changed",
318	320	"turn.started",
319	321	"thread.started",
320		− "message.delta",
321		− "tool.started",
322		− "tool.completed",
323		− "message.completed",
	322	+ "content.delta",
	323	+ "item.started",
	324	+ "item.completed",
	325	+ "item.updated",
	326	+ "item.completed",
324	327	"turn.completed",
325	328	],
326	329	);
327	330
328		− const turnStarted = runtimeEvents[1];
	331	+ const turnStarted = runtimeEvents[3];
329	332	assert.equal(turnStarted?.type, "turn.started");
330	333	if (turnStarted?.type === "turn.started") {
331	334	assert.equal(turnStarted.turnId, turn.turnId);
332	335	}
333	336
334		− const deltaEvent = runtimeEvents[3];
335		− assert.equal(deltaEvent?.type, "message.delta");
336		− if (deltaEvent?.type === "message.delta") {
337		− assert.equal(deltaEvent.delta, "Hi");
	337	+ const deltaEvent = runtimeEvents.find((event) => event.type === "content.delta");
	338	+ assert.equal(deltaEvent?.type, "content.delta");
	339	+ if (deltaEvent?.type === "content.delta") {
	340	+ assert.equal(deltaEvent.payload.delta, "Hi");
338	341	assert.equal(deltaEvent.turnId, turn.turnId);
339	342	}
340	343
341		− const toolStarted = runtimeEvents[4];
342		− assert.equal(toolStarted?.type, "tool.started");
343		− if (toolStarted?.type === "tool.started") {
344		− assert.equal(toolStarted.toolKind, "command");
	344	+ const toolStarted = runtimeEvents.find((event) => event.type === "item.started");
	345	+ assert.equal(toolStarted?.type, "item.started");
	346	+ if (toolStarted?.type === "item.started") {
	347	+ assert.equal(toolStarted.payload.itemType, "command_execution");
345	348	}
346	349
347		− const turnCompleted = runtimeEvents[7];
	350	+ const turnCompleted = runtimeEvents[runtimeEvents.length - 1];
348	351	assert.equal(turnCompleted?.type, "turn.completed");
349	352	if (turnCompleted?.type === "turn.completed") {
350	353	assert.equal(turnCompleted.turnId, turn.turnId);
351		− assert.equal(turnCompleted.status, "completed");
	354	+ assert.equal(turnCompleted.payload.state, "completed");
352	355	}
353	356	}).pipe(
354	357	Effect.provideService(Random.Random, makeDeterministicRandomService()),
@@ -361,7 +364,7 @@ describe("ClaudeCodeAdapterLive", () => { · 6 unmodified lines
361	364	return Effect.gen(function* () {
362	365	const adapter = yield* ClaudeCodeAdapter;
363	366
364		− const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 6).pipe(
	367	+ const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 9).pipe(
365	368	Stream.runCollect,
366	369	Effect.forkChild,
367	370	);
@@ -416,22 +419,25 @@ describe("ClaudeCodeAdapterLive", () => { · 48 unmodified lines
416	419	runtimeEvents.map((event) => event.type),
417	420	[
418	421	"session.started",
	422	+ "session.configured",
	423	+ "session.state.changed",
419	424	"turn.started",
420	425	"thread.started",
421		− "message.delta",
422		− "message.completed",
	426	+ "item.updated",
	427	+ "content.delta",
	428	+ "item.completed",
423	429	"turn.completed",
424	430	],
425	431	);
426	432
427		− const deltaIndex = runtimeEvents.findIndex((event) => event.type === "message.delta");
428		− const completedIndex = runtimeEvents.findIndex((event) => event.type === "message.completed");
	433	+ const deltaIndex = runtimeEvents.findIndex((event) => event.type === "content.delta");
	434	+ const completedIndex = runtimeEvents.findIndex((event) => event.type === "item.completed");
429	435	assert.equal(deltaIndex >= 0 && completedIndex >= 0 && deltaIndex < completedIndex, true);
430	436
431	437	const deltaEvent = runtimeEvents[deltaIndex];
432		− assert.equal(deltaEvent?.type, "message.delta");
433		− if (deltaEvent?.type === "message.delta") {
434		− assert.equal(deltaEvent.delta, "Late text");
	438	+ assert.equal(deltaEvent?.type, "content.delta");
	439	+ if (deltaEvent?.type === "content.delta") {
	440	+ assert.equal(deltaEvent.payload.delta, "Late text");
435	441	assert.equal(deltaEvent.turnId, turn.turnId);
436	442	}
437	443	}).pipe(
@@ -445,7 +451,7 @@ describe("ClaudeCodeAdapterLive", () => { · 7 unmodified lines
445	451	return Effect.gen(function* () {
446	452	const adapter = yield* ClaudeCodeAdapter;
447	453
448		− const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 6).pipe(
	454	+ const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 9).pipe(
449	455	Stream.runCollect,
450	456	Effect.forkChild,
451	457	);
@@ -485,18 +491,21 @@ describe("ClaudeCodeAdapterLive", () => { · 33 unmodified lines
485	491	runtimeEvents.map((event) => event.type),
486	492	[
487	493	"session.started",
	494	+ "session.configured",
	495	+ "session.state.changed",
488	496	"turn.started",
489	497	"thread.started",
490		− "message.delta",
491		− "message.completed",
	498	+ "item.updated",
	499	+ "content.delta",
	500	+ "item.completed",
492	501	"turn.completed",
493	502	],
494	503	);
495	504
496		− const deltaEvent = runtimeEvents.find((event) => event.type === "message.delta");
497		− assert.equal(deltaEvent?.type, "message.delta");
498		− if (deltaEvent?.type === "message.delta") {
499		− assert.equal(deltaEvent.delta, "Fallback hello");
	505	+ const deltaEvent = runtimeEvents.find((event) => event.type === "content.delta");
	506	+ assert.equal(deltaEvent?.type, "content.delta");
	507	+ if (deltaEvent?.type === "content.delta") {
	508	+ assert.equal(deltaEvent.payload.delta, "Fallback hello");
500	509	assert.equal(deltaEvent.turnId, turn.turnId);
501	510	}
502	511	}).pipe(
@@ -552,7 +561,13 @@ describe("ClaudeCodeAdapterLive", () => { · 49 unmodified lines
552	561	const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
553	562	assert.deepEqual(
554	563	runtimeEvents.map((event) => event.type),
555		− ["session.started", "turn.started", "thread.started", "message.completed", "turn.completed"],
	564	+ [
	565	+ "session.started",
	566	+ "session.configured",
	567	+ "session.state.changed",
	568	+ "turn.started",
	569	+ "thread.started",
	570	+ ],
556	571	);
557	572
558	573	const sessionStarted = runtimeEvents[0];
@@ -561,7 +576,7 @@ describe("ClaudeCodeAdapterLive", () => { · 2 unmodified lines
561	576	assert.equal("threadId" in sessionStarted, false);
562	577	}
563	578
564		− const threadStarted = runtimeEvents[2];
	579	+ const threadStarted = runtimeEvents[4];
565	580	assert.equal(threadStarted?.type, "thread.started");
566	581	if (threadStarted?.type === "thread.started") {
567	582	assert.equal(threadStarted.threadId, "sdk-thread-real");
@@ -582,8 +597,7 @@ describe("ClaudeCodeAdapterLive", () => { · 14 unmodified lines
582	597	approvalPolicy: "on-request",
583	598	});
584	599
585		− const consumeSessionStarted = yield* Stream.runHead(adapter.streamEvents);
586		− assert.equal(consumeSessionStarted._tag, "Some");
	600	+ yield* Stream.take(adapter.streamEvents, 3).pipe(Stream.runDrain);
587	601
588	602	const createInput = harness.getLastCreateQueryInput();
589	603	const canUseTool = createInput?.options.canUseTool;
@@ -613,8 +627,8 @@ describe("ClaudeCodeAdapterLive", () => { · 23 unmodified lines
613	627	if (requested._tag !== "Some") {
614	628	return;
615	629	}
616		− assert.equal(requested.value.type, "approval.requested");
617		− if (requested.value.type !== "approval.requested") {
	630	+ assert.equal(requested.value.type, "request.opened");
	631	+ if (requested.value.type !== "request.opened") {
618	632	return;
619	633	}
620	634
@@ -629,12 +643,12 @@ describe("ClaudeCodeAdapterLive", () => { · 8 unmodified lines
629	643	if (resolved._tag !== "Some") {
630	644	return;
631	645	}
632		− assert.equal(resolved.value.type, "approval.resolved");
633		− if (resolved.value.type !== "approval.resolved") {
	646	+ assert.equal(resolved.value.type, "request.resolved");
	647	+ if (resolved.value.type !== "request.resolved") {
634	648	return;
635	649	}
636	650	assert.equal(resolved.value.requestId, requested.value.requestId);
637		− assert.equal(resolved.value.decision, "accept");
	651	+ assert.equal(resolved.value.payload.decision, "accept");
638	652
639	653	const permissionResult = yield* Effect.promise(() => permissionPromise);
640	654	assert.equal((permissionResult as PermissionResult).behavior, "allow");

apps/server/src/provider/Layers/ClaudeCodeAdapter.ts+600−48

@@ -19,11 +19,12 @@ import { · 18 unmodified lines
19	19	} from "@anthropic-ai/claude-agent-sdk";
20	20	import {
21	21	ApprovalRequestId,
	22	+ type CanonicalItemType,
	23	+ type CanonicalRequestType,
22	24	EventId,
23	25	type ProviderApprovalDecision,
24	26	ProviderItemId,
25	27	type ProviderRuntimeEvent,
26		− type ProviderRuntimeToolKind,
27	28	type ProviderRuntimeTurnStatus,
28	29	type ProviderSendTurnInput,
29	30	ProviderSessionId,
@@ -73,7 +74,7 @@ interface ClaudeTurnState { · 43 unmodified lines
73	74	}
74	75
75	76	interface PendingApproval {
76		− readonly requestKind: "command" \| "file-change";
	77	+ readonly requestType: CanonicalRequestType;
77	78	readonly detail?: string;
78	79	readonly suggestions?: ReadonlyArray<PermissionUpdate>;
79	80	readonly decision: Deferred.Deferred<ProviderApprovalDecision>;
@@ -81,7 +82,8 @@ interface PendingApproval { · 1 unmodified line
81	82
82	83	interface ToolInFlight {
83	84	readonly itemId: string;
84		− readonly toolKind: ProviderRuntimeToolKind;
	85	+ readonly itemType: CanonicalItemType;
	86	+ readonly toolName: string;
85	87	readonly title: string;
86	88	readonly detail?: string;
87	89	}
@@ -188,7 +190,7 @@ function readClaudeResumeState(resumeCursor: unknown): ClaudeResumeState \| undef · 100 unmodified lines
188	190	};
189	191	}
190	192
191		−function classifyToolKind(toolName: string): ProviderRuntimeToolKind {
	193	+function classifyToolItemType(toolName: string): CanonicalItemType {
192	194	const normalized = toolName.toLowerCase();
193	195	if (
194	196	normalized.includes("bash") \|\|
@@ -196,7 +198,7 @@ function classifyToolKind(toolName: string): ProviderRuntimeToolKind { · 1 unmodified line
196	198	normalized.includes("shell") \|\|
197	199	normalized.includes("terminal")
198	200	) {
199		− return "command";
	201	+ return "command_execution";
200	202	}
201	203	if (
202	204	normalized.includes("edit") \|\|
@@ -207,13 +209,18 @@ function classifyToolKind(toolName: string): ProviderRuntimeToolKind { · 4 unmodified lines
207	209	normalized.includes("create") \|\|
208	210	normalized.includes("delete")
209	211	) {
210		− return "file-change";
	212	+ return "file_change";
211	213	}
212		− return "other";
	214	+ if (normalized.includes("mcp")) {
	215	+ return "mcp_tool_call";
	216	+ }
	217	+ return "dynamic_tool_call";
213	218	}
214	219
215		−function classifyRequestKind(toolName: string): "command" \| "file-change" {
216		− return classifyToolKind(toolName) === "command" ? "command" : "file-change";
	220	+function classifyRequestType(toolName: string): CanonicalRequestType {
	221	+ return classifyToolItemType(toolName) === "command_execution"
	222	+ ? "command_execution_approval"
	223	+ : "file_change_approval";
217	224	}
218	225
219	226	function summarizeToolRequest(toolName: string, input: Record<string, unknown>): string {
@@ -230,14 +237,18 @@ function summarizeToolRequest(toolName: string, input: Record<string, unknown>): · 10 unmodified lines
230	237	return `${toolName}: ${serialized.slice(0, 397)}...`;
231	238	}
232	239
233		−function titleForTool(kind: ProviderRuntimeToolKind): string {
234		− switch (kind) {
235		− case "command":
	240	+function titleForTool(itemType: CanonicalItemType): string {
	241	+ switch (itemType) {
	242	+ case "command_execution":
236	243	return "Command run";
237		− case "file-change":
	244	+ case "file_change":
238	245	return "File change";
239		− case "other":
	246	+ case "mcp_tool_call":
	247	+ return "MCP tool call";
	248	+ case "dynamic_tool_call":
240	249	return "Tool call";
	250	+ default:
	251	+ return "Item";
241	252	}
242	253	}
243	254
@@ -284,6 +295,10 @@ function turnStatusFromResult(result: SDKResultMessage): ProviderRuntimeTurnStat · 40 unmodified lines
284	295	return "failed";
285	296	}
286	297
	298	+function streamKindFromDeltaType(deltaType: string): "assistant_text" \| "reasoning_text" {
	299	+ return deltaType.includes("thinking") ? "reasoning_text" : "assistant_text";
	300	+}
	301	+
287	302	function extractAssistantText(message: SDKMessage): string {
288	303	if (message.type !== "assistant") {
289	304	return "";
@@ -540,6 +555,20 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 250 unmodified lines
540	555	sessionId: context.session.sessionId,
541	556	createdAt: stamp.createdAt,
542	557	threadId: nextThreadId,
	558	+ payload: {
	559	+ providerThreadId: nextThreadId,
	560	+ },
	561	+ providerRefs: {
	562	+ providerSessionId: context.session.sessionId,
	563	+ providerThreadId: nextThreadId,
	564	+ },
	565	+ raw: {
	566	+ source: "claude.sdk.message",
	567	+ method: "claude/thread/started",
	568	+ payload: {
	569	+ session_id: message.session_id,
	570	+ },
	571	+ },
543	572	});
544	573	}
545	574	});
@@ -563,7 +592,44 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 17 unmodified lines
563	592	createdAt: stamp.createdAt,
564	593	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
565	594	...(turnState ? { turnId: turnState.turnId } : {}),
566		− message,
	595	+ payload: {
	596	+ message,
	597	+ class: "provider_error",
	598	+ ...(cause !== undefined ? { detail: cause } : {}),
	599	+ },
	600	+ providerRefs: {
	601	+ providerSessionId: context.session.sessionId,
	602	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	603	+ ...(turnState ? { providerTurnId: turnState.turnId } : {}),
	604	+ },
	605	+ });
	606	+ });
	607	+
	608	+ const emitRuntimeWarning = (
	609	+ context: ClaudeSessionContext,
	610	+ message: string,
	611	+ detail?: unknown,
	612	+ ): Effect.Effect<void> =>
	613	+ Effect.gen(function* () {
	614	+ const turnState = context.turnState;
	615	+ const stamp = yield* makeEventStamp();
	616	+ yield* offerRuntimeEvent({
	617	+ type: "runtime.warning",
	618	+ eventId: stamp.eventId,
	619	+ provider: PROVIDER,
	620	+ sessionId: context.session.sessionId,
	621	+ createdAt: stamp.createdAt,
	622	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	623	+ ...(turnState ? { turnId: turnState.turnId } : {}),
	624	+ payload: {
	625	+ message,
	626	+ ...(detail !== undefined ? { detail } : {}),
	627	+ },
	628	+ providerRefs: {
	629	+ providerSessionId: context.session.sessionId,
	630	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	631	+ ...(turnState ? { providerTurnId: turnState.turnId } : {}),
	632	+ },
567	633	});
568	634	});
569	635
@@ -571,6 +637,7 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 1 unmodified line
571	637	context: ClaudeSessionContext,
572	638	status: ProviderRuntimeTurnStatus,
573	639	errorMessage?: string,
	640	+ result?: SDKResultMessage,
574	641	): Effect.Effect<void> =>
575	642	Effect.gen(function* () {
576	643	const turnState = context.turnState;
@@ -583,8 +650,20 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 6 unmodified lines
583	650	sessionId: context.session.sessionId,
584	651	createdAt: stamp.createdAt,
585	652	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
586		− status,
587		− ...(errorMessage ? { errorMessage } : {}),
	653	+ payload: {
	654	+ state: status,
	655	+ ...(result?.stop_reason !== undefined ? { stopReason: result.stop_reason } : {}),
	656	+ ...(result?.usage ? { usage: result.usage } : {}),
	657	+ ...(result?.modelUsage ? { modelUsage: result.modelUsage } : {}),
	658	+ ...(typeof result?.total_cost_usd === "number"
	659	+ ? { totalCostUsd: result.total_cost_usd }
	660	+ : {}),
	661	+ ...(errorMessage ? { errorMessage } : {}),
	662	+ },
	663	+ providerRefs: {
	664	+ providerSessionId: context.session.sessionId,
	665	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	666	+ },
588	667	});
589	668	return;
590	669	}
@@ -593,7 +672,7 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 2 unmodified lines
593	672	if (!turnState.emittedTextDelta && turnState.fallbackAssistantText.length > 0) {
594	673	const deltaStamp = yield* makeEventStamp();
595	674	yield* offerRuntimeEvent({
596		− type: "message.delta",
	675	+ type: "content.delta",
597	676	eventId: deltaStamp.eventId,
598	677	provider: PROVIDER,
599	678	sessionId: context.session.sessionId,
@@ -601,13 +680,22 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 1 unmodified line
601	680	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
602	681	turnId: turnState.turnId,
603	682	itemId: ProviderItemId.makeUnsafe(turnState.assistantItemId),
604		− delta: turnState.fallbackAssistantText,
	683	+ payload: {
	684	+ streamKind: "assistant_text",
	685	+ delta: turnState.fallbackAssistantText,
	686	+ },
	687	+ providerRefs: {
	688	+ providerSessionId: context.session.sessionId,
	689	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	690	+ providerTurnId: turnState.turnId,
	691	+ providerItemId: ProviderItemId.makeUnsafe(turnState.assistantItemId),
	692	+ },
605	693	});
606	694	}
607	695
608	696	const stamp = yield* makeEventStamp();
609	697	yield* offerRuntimeEvent({
610		− type: "message.completed",
	698	+ type: "item.completed",
611	699	eventId: stamp.eventId,
612	700	provider: PROVIDER,
613	701	sessionId: context.session.sessionId,
@@ -615,6 +703,17 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 1 unmodified line
615	703	itemId: ProviderItemId.makeUnsafe(turnState.assistantItemId),
616	704	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
617	705	turnId: turnState.turnId,
	706	+ payload: {
	707	+ itemType: "assistant_message",
	708	+ status: "completed",
	709	+ title: "Assistant message",
	710	+ },
	711	+ providerRefs: {
	712	+ providerSessionId: context.session.sessionId,
	713	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	714	+ providerTurnId: turnState.turnId,
	715	+ providerItemId: ProviderItemId.makeUnsafe(turnState.assistantItemId),
	716	+ },
618	717	});
619	718	}
620	719
@@ -632,8 +731,21 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 11 unmodified lines
632	731	createdAt: stamp.createdAt,
633	732	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
634	733	turnId: turnState.turnId,
635		− status,
636		− ...(errorMessage ? { errorMessage } : {}),
	734	+ payload: {
	735	+ state: status,
	736	+ ...(result?.stop_reason !== undefined ? { stopReason: result.stop_reason } : {}),
	737	+ ...(result?.usage ? { usage: result.usage } : {}),
	738	+ ...(result?.modelUsage ? { modelUsage: result.modelUsage } : {}),
	739	+ ...(typeof result?.total_cost_usd === "number"
	740	+ ? { totalCostUsd: result.total_cost_usd }
	741	+ : {}),
	742	+ ...(errorMessage ? { errorMessage } : {}),
	743	+ },
	744	+ providerRefs: {
	745	+ providerSessionId: context.session.sessionId,
	746	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	747	+ providerTurnId: turnState.turnId,
	748	+ },
637	749	});
638	750
639	751	const updatedAt = yield* nowIso;
@@ -673,7 +785,7 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 33 unmodified lines
673	785	}
674	786	const stamp = yield* makeEventStamp();
675	787	yield* offerRuntimeEvent({
676		− type: "message.delta",
	788	+ type: "content.delta",
677	789	eventId: stamp.eventId,
678	790	provider: PROVIDER,
679	791	sessionId: context.session.sessionId,
@@ -681,7 +793,21 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 1 unmodified line
681	793	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
682	794	turnId: context.turnState.turnId,
683	795	itemId: ProviderItemId.makeUnsafe(context.turnState.assistantItemId),
684		− delta: event.delta.text,
	796	+ payload: {
	797	+ streamKind: streamKindFromDeltaType(event.delta.type),
	798	+ delta: event.delta.text,
	799	+ },
	800	+ providerRefs: {
	801	+ providerSessionId: context.session.sessionId,
	802	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	803	+ providerTurnId: context.turnState.turnId,
	804	+ providerItemId: ProviderItemId.makeUnsafe(context.turnState.assistantItemId),
	805	+ },
	806	+ raw: {
	807	+ source: "claude.sdk.message",
	808	+ method: "claude/stream_event/content_block_delta",
	809	+ payload: message,
	810	+ },
685	811	});
686	812	}
687	813	return;
@@ -698,7 +824,7 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 10 unmodified lines
698	824	}
699	825
700	826	const toolName = block.name;
701		− const toolKind = classifyToolKind(toolName);
	827	+ const itemType = classifyToolItemType(toolName);
702	828	const toolInput =
703	829	typeof block.input === "object" && block.input !== null
704	830	? (block.input as Record<string, unknown>)
@@ -708,15 +834,16 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 3 unmodified lines
708	834
709	835	const tool: ToolInFlight = {
710	836	itemId,
711		− toolKind,
712		− title: titleForTool(toolKind),
	837	+ itemType,
	838	+ toolName,
	839	+ title: titleForTool(itemType),
713	840	detail,
714	841	};
715	842	context.inFlightTools.set(index, tool);
716	843
717	844	const stamp = yield* makeEventStamp();
718	845	yield* offerRuntimeEvent({
719		− type: "tool.started",
	846	+ type: "item.started",
720	847	eventId: stamp.eventId,
721	848	provider: PROVIDER,
722	849	sessionId: context.session.sessionId,
@@ -724,9 +851,27 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 1 unmodified line
724	851	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
725	852	...(context.turnState ? { turnId: context.turnState.turnId } : {}),
726	853	itemId: ProviderItemId.makeUnsafe(tool.itemId),
727		− toolKind: tool.toolKind,
728		− title: tool.title,
729		− ...(tool.detail ? { detail: tool.detail } : {}),
	854	+ payload: {
	855	+ itemType: tool.itemType,
	856	+ status: "inProgress",
	857	+ title: tool.title,
	858	+ ...(tool.detail ? { detail: tool.detail } : {}),
	859	+ data: {
	860	+ toolName: tool.toolName,
	861	+ input: toolInput,
	862	+ },
	863	+ },
	864	+ providerRefs: {
	865	+ providerSessionId: context.session.sessionId,
	866	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	867	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	868	+ providerItemId: ProviderItemId.makeUnsafe(tool.itemId),
	869	+ },
	870	+ raw: {
	871	+ source: "claude.sdk.message",
	872	+ method: "claude/stream_event/content_block_start",
	873	+ payload: message,
	874	+ },
730	875	});
731	876	return;
732	877	}
@@ -741,7 +886,7 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 8 unmodified lines
741	886
742	887	const stamp = yield* makeEventStamp();
743	888	yield* offerRuntimeEvent({
744		− type: "tool.completed",
	889	+ type: "item.completed",
745	890	eventId: stamp.eventId,
746	891	provider: PROVIDER,
747	892	sessionId: context.session.sessionId,
@@ -749,9 +894,23 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 1 unmodified line
749	894	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
750	895	...(context.turnState ? { turnId: context.turnState.turnId } : {}),
751	896	itemId: ProviderItemId.makeUnsafe(tool.itemId),
752		− toolKind: tool.toolKind,
753		− title: tool.title,
754		− ...(tool.detail ? { detail: tool.detail } : {}),
	897	+ payload: {
	898	+ itemType: tool.itemType,
	899	+ status: "completed",
	900	+ title: tool.title,
	901	+ ...(tool.detail ? { detail: tool.detail } : {}),
	902	+ },
	903	+ providerRefs: {
	904	+ providerSessionId: context.session.sessionId,
	905	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	906	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	907	+ providerItemId: ProviderItemId.makeUnsafe(tool.itemId),
	908	+ },
	909	+ raw: {
	910	+ source: "claude.sdk.message",
	911	+ method: "claude/stream_event/content_block_stop",
	912	+ payload: message,
	913	+ },
755	914	});
756	915	}
757	916	});
@@ -777,6 +936,35 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 19 unmodified lines
777	936	fallbackAssistantText,
778	937	};
779	938	}
	939	+
	940	+ const stamp = yield* makeEventStamp();
	941	+ yield* offerRuntimeEvent({
	942	+ type: "item.updated",
	943	+ eventId: stamp.eventId,
	944	+ provider: PROVIDER,
	945	+ sessionId: context.session.sessionId,
	946	+ createdAt: stamp.createdAt,
	947	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	948	+ turnId: context.turnState.turnId,
	949	+ itemId: ProviderItemId.makeUnsafe(context.turnState.assistantItemId),
	950	+ payload: {
	951	+ itemType: "assistant_message",
	952	+ status: "inProgress",
	953	+ title: "Assistant message",
	954	+ data: message.message,
	955	+ },
	956	+ providerRefs: {
	957	+ providerSessionId: context.session.sessionId,
	958	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	959	+ providerTurnId: context.turnState.turnId,
	960	+ providerItemId: ProviderItemId.makeUnsafe(context.turnState.assistantItemId),
	961	+ },
	962	+ raw: {
	963	+ source: "claude.sdk.message",
	964	+ method: "claude/assistant",
	965	+ payload: message,
	966	+ },
	967	+ });
780	968	}
781	969
782	970	context.lastAssistantUuid = message.uuid;
@@ -799,7 +987,251 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 16 unmodified lines
799	987	yield* emitRuntimeError(context, errorMessage ?? "Claude turn failed.");
800	988	}
801	989
802		− yield* completeTurn(context, status, errorMessage);
	990	+ yield* completeTurn(context, status, errorMessage, message);
	991	+ });
	992	+
	993	+ const handleSystemMessage = (
	994	+ context: ClaudeSessionContext,
	995	+ message: SDKMessage,
	996	+ ): Effect.Effect<void> =>
	997	+ Effect.gen(function* () {
	998	+ if (message.type !== "system") {
	999	+ return;
	1000	+ }
	1001	+
	1002	+ const stamp = yield* makeEventStamp();
	1003	+ const base = {
	1004	+ eventId: stamp.eventId,
	1005	+ provider: PROVIDER,
	1006	+ sessionId: context.session.sessionId,
	1007	+ createdAt: stamp.createdAt,
	1008	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	1009	+ ...(context.turnState ? { turnId: context.turnState.turnId } : {}),
	1010	+ providerRefs: {
	1011	+ providerSessionId: context.session.sessionId,
	1012	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	1013	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	1014	+ },
	1015	+ raw: {
	1016	+ source: "claude.sdk.message" as const,
	1017	+ method: sdkNativeMethod(message),
	1018	+ messageType: `${message.type}:${message.subtype}`,
	1019	+ payload: message,
	1020	+ },
	1021	+ };
	1022	+
	1023	+ switch (message.subtype) {
	1024	+ case "init":
	1025	+ yield* offerRuntimeEvent({
	1026	+ ...base,
	1027	+ type: "session.configured",
	1028	+ payload: {
	1029	+ config: message as Record<string, unknown>,
	1030	+ },
	1031	+ });
	1032	+ return;
	1033	+ case "status":
	1034	+ yield* offerRuntimeEvent({
	1035	+ ...base,
	1036	+ type: "session.state.changed",
	1037	+ payload: {
	1038	+ state: message.status === "compacting" ? "waiting" : "running",
	1039	+ reason: `status:${message.status ?? "active"}`,
	1040	+ detail: message,
	1041	+ },
	1042	+ });
	1043	+ return;
	1044	+ case "compact_boundary":
	1045	+ yield* offerRuntimeEvent({
	1046	+ ...base,
	1047	+ type: "thread.state.changed",
	1048	+ payload: {
	1049	+ state: "compacted",
	1050	+ detail: message,
	1051	+ },
	1052	+ });
	1053	+ return;
	1054	+ case "hook_started":
	1055	+ yield* offerRuntimeEvent({
	1056	+ ...base,
	1057	+ type: "hook.started",
	1058	+ payload: {
	1059	+ hookId: message.hook_id,
	1060	+ hookName: message.hook_name,
	1061	+ hookEvent: message.hook_event,
	1062	+ },
	1063	+ });
	1064	+ return;
	1065	+ case "hook_progress":
	1066	+ yield* offerRuntimeEvent({
	1067	+ ...base,
	1068	+ type: "hook.progress",
	1069	+ payload: {
	1070	+ hookId: message.hook_id,
	1071	+ output: message.output,
	1072	+ stdout: message.stdout,
	1073	+ stderr: message.stderr,
	1074	+ },
	1075	+ });
	1076	+ return;
	1077	+ case "hook_response":
	1078	+ yield* offerRuntimeEvent({
	1079	+ ...base,
	1080	+ type: "hook.completed",
	1081	+ payload: {
	1082	+ hookId: message.hook_id,
	1083	+ outcome: message.outcome,
	1084	+ output: message.output,
	1085	+ stdout: message.stdout,
	1086	+ stderr: message.stderr,
	1087	+ ...(typeof message.exit_code === "number" ? { exitCode: message.exit_code } : {}),
	1088	+ },
	1089	+ });
	1090	+ return;
	1091	+ case "task_started":
	1092	+ yield* offerRuntimeEvent({
	1093	+ ...base,
	1094	+ type: "task.started",
	1095	+ payload: {
	1096	+ taskId: message.task_id,
	1097	+ description: message.description,
	1098	+ ...(message.task_type ? { taskType: message.task_type } : {}),
	1099	+ },
	1100	+ });
	1101	+ return;
	1102	+ case "task_progress":
	1103	+ yield* offerRuntimeEvent({
	1104	+ ...base,
	1105	+ type: "task.progress",
	1106	+ payload: {
	1107	+ taskId: message.task_id,
	1108	+ description: message.description,
	1109	+ ...(message.usage ? { usage: message.usage } : {}),
	1110	+ ...(message.last_tool_name ? { lastToolName: message.last_tool_name } : {}),
	1111	+ },
	1112	+ });
	1113	+ return;
	1114	+ case "task_notification":
	1115	+ yield* offerRuntimeEvent({
	1116	+ ...base,
	1117	+ type: "task.completed",
	1118	+ payload: {
	1119	+ taskId: message.task_id,
	1120	+ status: message.status,
	1121	+ ...(message.summary ? { summary: message.summary } : {}),
	1122	+ ...(message.usage ? { usage: message.usage } : {}),
	1123	+ },
	1124	+ });
	1125	+ return;
	1126	+ case "files_persisted":
	1127	+ yield* offerRuntimeEvent({
	1128	+ ...base,
	1129	+ type: "files.persisted",
	1130	+ payload: {
	1131	+ files: Array.isArray(message.files)
	1132	+ ? message.files.map((file: { filename: string; file_id: string }) => ({
	1133	+ filename: file.filename,
	1134	+ fileId: file.file_id,
	1135	+ }))
	1136	+ : [],
	1137	+ ...(Array.isArray(message.failed)
	1138	+ ? {
	1139	+ failed: message.failed.map((entry: { filename: string; error: string }) => ({
	1140	+ filename: entry.filename,
	1141	+ error: entry.error,
	1142	+ })),
	1143	+ }
	1144	+ : {}),
	1145	+ },
	1146	+ });
	1147	+ return;
	1148	+ default:
	1149	+ yield* emitRuntimeWarning(
	1150	+ context,
	1151	+ `Unhandled Claude system message subtype '${message.subtype}'.`,
	1152	+ message,
	1153	+ );
	1154	+ return;
	1155	+ }
	1156	+ });
	1157	+
	1158	+ const handleSdkTelemetryMessage = (
	1159	+ context: ClaudeSessionContext,
	1160	+ message: SDKMessage,
	1161	+ ): Effect.Effect<void> =>
	1162	+ Effect.gen(function* () {
	1163	+ const stamp = yield* makeEventStamp();
	1164	+ const base = {
	1165	+ eventId: stamp.eventId,
	1166	+ provider: PROVIDER,
	1167	+ sessionId: context.session.sessionId,
	1168	+ createdAt: stamp.createdAt,
	1169	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	1170	+ ...(context.turnState ? { turnId: context.turnState.turnId } : {}),
	1171	+ providerRefs: {
	1172	+ providerSessionId: context.session.sessionId,
	1173	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	1174	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	1175	+ },
	1176	+ raw: {
	1177	+ source: "claude.sdk.message" as const,
	1178	+ method: sdkNativeMethod(message),
	1179	+ messageType: message.type,
	1180	+ payload: message,
	1181	+ },
	1182	+ };
	1183	+
	1184	+ if (message.type === "tool_progress") {
	1185	+ yield* offerRuntimeEvent({
	1186	+ ...base,
	1187	+ type: "tool.progress",
	1188	+ payload: {
	1189	+ toolUseId: message.tool_use_id,
	1190	+ toolName: message.tool_name,
	1191	+ elapsedSeconds: message.elapsed_time_seconds,
	1192	+ ...(message.task_id ? { summary: `task:${message.task_id}` } : {}),
	1193	+ },
	1194	+ });
	1195	+ return;
	1196	+ }
	1197	+
	1198	+ if (message.type === "tool_use_summary") {
	1199	+ yield* offerRuntimeEvent({
	1200	+ ...base,
	1201	+ type: "tool.summary",
	1202	+ payload: {
	1203	+ summary: message.summary,
	1204	+ ...(message.preceding_tool_use_ids.length > 0
	1205	+ ? { precedingToolUseIds: message.preceding_tool_use_ids }
	1206	+ : {}),
	1207	+ },
	1208	+ });
	1209	+ return;
	1210	+ }
	1211	+
	1212	+ if (message.type === "auth_status") {
	1213	+ yield* offerRuntimeEvent({
	1214	+ ...base,
	1215	+ type: "auth.status",
	1216	+ payload: {
	1217	+ isAuthenticating: message.isAuthenticating,
	1218	+ output: message.output,
	1219	+ ...(message.error ? { error: message.error } : {}),
	1220	+ },
	1221	+ });
	1222	+ return;
	1223	+ }
	1224	+
	1225	+ if (message.type === "rate_limit") {
	1226	+ yield* offerRuntimeEvent({
	1227	+ ...base,
	1228	+ type: "account.rate-limits.updated",
	1229	+ payload: {
	1230	+ rateLimits: message,
	1231	+ },
	1232	+ });
	1233	+ return;
	1234	+ }
803	1235	});
804	1236
805	1237	const handleSdkMessage = (
@@ -820,7 +1252,21 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 14 unmodified lines
820	1252	case "result":
821	1253	yield* handleResultMessage(context, message);
822	1254	return;
	1255	+ case "system":
	1256	+ yield* handleSystemMessage(context, message);
	1257	+ return;
	1258	+ case "tool_progress":
	1259	+ case "tool_use_summary":
	1260	+ case "auth_status":
	1261	+ case "rate_limit":
	1262	+ yield* handleSdkTelemetryMessage(context, message);
	1263	+ return;
823	1264	default:
	1265	+ yield* emitRuntimeWarning(
	1266	+ context,
	1267	+ `Unhandled Claude SDK message type '${message.type}'.`,
	1268	+ message,
	1269	+ );
824	1270	return;
825	1271	}
826	1272	});
@@ -854,7 +1300,7 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 27 unmodified lines
854	1300	yield* Deferred.succeed(pending.decision, "cancel");
855	1301	const stamp = yield* makeEventStamp();
856	1302	yield* offerRuntimeEvent({
857		− type: "approval.resolved",
	1303	+ type: "request.resolved",
858	1304	eventId: stamp.eventId,
859	1305	provider: PROVIDER,
860	1306	sessionId: context.session.sessionId,
@@ -862,8 +1308,16 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 1 unmodified line
862	1308	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
863	1309	...(context.turnState ? { turnId: context.turnState.turnId } : {}),
864	1310	requestId,
865		− requestKind: pending.requestKind,
866		− decision: "cancel",
	1311	+ payload: {
	1312	+ requestType: pending.requestType,
	1313	+ decision: "cancel",
	1314	+ },
	1315	+ providerRefs: {
	1316	+ providerSessionId: context.session.sessionId,
	1317	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	1318	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	1319	+ providerRequestId: requestId,
	1320	+ },
867	1321	});
868	1322	}
869	1323	context.pendingApprovals.clear();
@@ -893,7 +1347,14 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 23 unmodified lines
893	1347	sessionId: context.session.sessionId,
894	1348	createdAt: stamp.createdAt,
895	1349	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
896		− message: "Session stopped",
	1350	+ payload: {
	1351	+ reason: "Session stopped",
	1352	+ exitKind: "graceful",
	1353	+ },
	1354	+ providerRefs: {
	1355	+ providerSessionId: context.session.sessionId,
	1356	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	1357	+ },
897	1358	});
898	1359	}
899	1360
@@ -972,11 +1433,11 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 72 unmodified lines
972	1433	}
973	1434
974	1435	const requestId = ApprovalRequestId.makeUnsafe(yield* Random.nextUUIDv4);
975		− const requestKind = classifyRequestKind(toolName);
	1436	+ const requestType = classifyRequestType(toolName);
976	1437	const detail = summarizeToolRequest(toolName, toolInput);
977	1438	const decisionDeferred = yield* Deferred.make<ProviderApprovalDecision>();
978	1439	const pendingApproval: PendingApproval = {
979		− requestKind,
	1440	+ requestType,
980	1441	detail,
981	1442	decision: decisionDeferred,
982	1443	...(callbackOptions.suggestions
@@ -986,7 +1447,7 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 3 unmodified lines
986	1447
987	1448	const requestedStamp = yield* makeEventStamp();
988	1449	yield* offerRuntimeEvent({
989		− type: "approval.requested",
	1450	+ type: "request.opened",
990	1451	eventId: requestedStamp.eventId,
991	1452	provider: PROVIDER,
992	1453	sessionId: context.session.sessionId,
@@ -994,8 +1455,29 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 1 unmodified line
994	1455	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
995	1456	...(context.turnState ? { turnId: context.turnState.turnId } : {}),
996	1457	requestId,
997		− requestKind,
998		− detail,
	1458	+ payload: {
	1459	+ requestType,
	1460	+ detail,
	1461	+ args: {
	1462	+ toolName,
	1463	+ input: toolInput,
	1464	+ ...(callbackOptions.toolUseID ? { toolUseId: callbackOptions.toolUseID } : {}),
	1465	+ },
	1466	+ },
	1467	+ providerRefs: {
	1468	+ providerSessionId: context.session.sessionId,
	1469	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	1470	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	1471	+ providerRequestId: requestId,
	1472	+ },
	1473	+ raw: {
	1474	+ source: "claude.sdk.permission",
	1475	+ method: "canUseTool/request",
	1476	+ payload: {
	1477	+ toolName,
	1478	+ input: toolInput,
	1479	+ },
	1480	+ },
999	1481	});
1000	1482
1001	1483	pendingApprovals.set(requestId, pendingApproval);
@@ -1017,7 +1499,7 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 15 unmodified lines
1017	1499
1018	1500	const resolvedStamp = yield* makeEventStamp();
1019	1501	yield* offerRuntimeEvent({
1020		− type: "approval.resolved",
	1502	+ type: "request.resolved",
1021	1503	eventId: resolvedStamp.eventId,
1022	1504	provider: PROVIDER,
1023	1505	sessionId: context.session.sessionId,
@@ -1025,8 +1507,23 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 1 unmodified line
1025	1507	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
1026	1508	...(context.turnState ? { turnId: context.turnState.turnId } : {}),
1027	1509	requestId,
1028		− requestKind,
1029		− decision,
	1510	+ payload: {
	1511	+ requestType,
	1512	+ decision,
	1513	+ },
	1514	+ providerRefs: {
	1515	+ providerSessionId: context.session.sessionId,
	1516	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	1517	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	1518	+ providerRequestId: requestId,
	1519	+ },
	1520	+ raw: {
	1521	+ source: "claude.sdk.permission",
	1522	+ method: "canUseTool/decision",
	1523	+ payload: {
	1524	+ decision,
	1525	+ },
	1526	+ },
1030	1527	});
1031	1528
1032	1529	if (decision === "accept" \|\| decision === "acceptForSession") {
@@ -1134,6 +1631,52 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 101 unmodified lines
1134	1631	sessionId,
1135	1632	createdAt: sessionStartedStamp.createdAt,
1136	1633	...(threadId ? { threadId } : {}),
	1634	+ payload: input.resumeCursor !== undefined ? { resume: input.resumeCursor } : {},
	1635	+ providerRefs: {
	1636	+ providerSessionId: sessionId,
	1637	+ ...(threadId ? { providerThreadId: threadId } : {}),
	1638	+ },
	1639	+ });
	1640	+
	1641	+ const configuredStamp = yield* makeEventStamp();
	1642	+ yield* offerRuntimeEvent({
	1643	+ type: "session.configured",
	1644	+ eventId: configuredStamp.eventId,
	1645	+ provider: PROVIDER,
	1646	+ sessionId,
	1647	+ createdAt: configuredStamp.createdAt,
	1648	+ ...(threadId ? { threadId } : {}),
	1649	+ payload: {
	1650	+ config: {
	1651	+ ...(input.model ? { model: input.model } : {}),
	1652	+ ...(input.cwd ? { cwd: input.cwd } : {}),
	1653	+ ...(permissionMode ? { permissionMode } : {}),
	1654	+ ...(providerOptions?.maxThinkingTokens !== undefined
	1655	+ ? { maxThinkingTokens: providerOptions.maxThinkingTokens }
	1656	+ : {}),
	1657	+ },
	1658	+ },
	1659	+ providerRefs: {
	1660	+ providerSessionId: sessionId,
	1661	+ ...(threadId ? { providerThreadId: threadId } : {}),
	1662	+ },
	1663	+ });
	1664	+
	1665	+ const readyStamp = yield* makeEventStamp();
	1666	+ yield* offerRuntimeEvent({
	1667	+ type: "session.state.changed",
	1668	+ eventId: readyStamp.eventId,
	1669	+ provider: PROVIDER,
	1670	+ sessionId,
	1671	+ createdAt: readyStamp.createdAt,
	1672	+ ...(threadId ? { threadId } : {}),
	1673	+ payload: {
	1674	+ state: "ready",
	1675	+ },
	1676	+ providerRefs: {
	1677	+ providerSessionId: sessionId,
	1678	+ ...(threadId ? { providerThreadId: threadId } : {}),
	1679	+ },
1137	1680	});
1138	1681
1139	1682	Effect.runFork(runSdkStream(context));
@@ -1191,6 +1734,15 @@ function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { · 51 unmodified lines
1191	1734	createdAt: turnStartedStamp.createdAt,
1192	1735	...(context.session.threadId ? { threadId: context.session.threadId } : {}),
1193	1736	turnId,
	1737	+ payload: {
	1738	+ ...(input.model ? { model: input.model } : {}),
	1739	+ ...(input.effort ? { effort: input.effort } : {}),
	1740	+ },
	1741	+ providerRefs: {
	1742	+ providerSessionId: context.session.sessionId,
	1743	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	1744	+ providerTurnId: turnId,
	1745	+ },
1194	1746	});
1195	1747
1196	1748	const message = buildUserMessage(input);

apps/server/src/provider/Layers/CodexAdapter.test.ts+5−4

@@ -214,7 +214,7 @@ const lifecycleLayer = it.layer( · 213 unmodified lines
214	214	);
215	215
216	216	lifecycleLayer("CodexAdapterLive lifecycle", (it) => {
217		− it.effect("maps completed agent message items to canonical message.completed events", () =>
	217	+ it.effect("maps completed agent message items to canonical item.completed events", () =>
218	218	Effect.gen(function* () {
219	219	const adapter = yield* CodexAdapter;
220	220	const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
@@ -244,12 +244,13 @@ lifecycleLayer("CodexAdapterLive lifecycle", (it) => { · 23 unmodified lines
244	244	if (firstEvent._tag !== "Some") {
245	245	return;
246	246	}
247		− assert.equal(firstEvent.value.type, "message.completed");
248		− if (firstEvent.value.type !== "message.completed") {
	247	+ assert.equal(firstEvent.value.type, "item.completed");
	248	+ if (firstEvent.value.type !== "item.completed") {
249	249	return;
250	250	}
251	251	assert.equal(firstEvent.value.itemId, "msg_1");
252	252	assert.equal(firstEvent.value.turnId, "turn-1");
	253	+ assert.equal(firstEvent.value.payload.itemType, "assistant_message");
253	254	}),
254	255	);
255	256
@@ -280,7 +281,7 @@ lifecycleLayer("CodexAdapterLive lifecycle", (it) => { · 24 unmodified lines
280	281	return;
281	282	}
282	283	assert.equal(firstEvent.value.sessionId, "sess-1");
283		− assert.equal(firstEvent.value.message, "Session stopped");
	284	+ assert.equal(firstEvent.value.payload.reason, "Session stopped");
284	285	}),
285	286	);
286	287	});

apps/server/src/provider/Layers/CodexAdapter.ts+623−155

@@ -7,11 +7,10 @@ · 6 unmodified lines
7	7	* @module CodexAdapterLive
8	8	*/
9	9	import {
	10	+ type CanonicalItemType,
	11	+ type CanonicalRequestType,
10	12	type ProviderEvent,
11	13	type ProviderRuntimeEvent,
12		− type ProviderRuntimeTurnStatus,
13		− type ProviderRuntimeToolKind,
14		− ProviderItemId,
15	14	ProviderApprovalDecision,
16	15	ProviderSessionId,
17	16	ProviderThreadId,
@@ -100,7 +99,11 @@ function asString(value: unknown): string \| undefined { · 82 unmodified lines
100	99	return typeof value === "string" ? value : undefined;
101	100	}
102	101
103		−function toTurnStatus(value: unknown): ProviderRuntimeTurnStatus \| undefined {
	102	+function asNumber(value: unknown): number \| undefined {
	103	+ return typeof value === "number" && Number.isFinite(value) ? value : undefined;
	104	+}
	105	+
	106	+function toTurnStatus(value: unknown): "completed" \| "failed" \| "cancelled" \| "interrupted" {
104	107	switch (value) {
105	108	case "completed":
106	109	case "failed":
@@ -108,7 +111,7 @@ function toTurnStatus(value: unknown): ProviderRuntimeTurnStatus \| undefined { · 1 unmodified line
108	111	case "interrupted":
109	112	return value;
110	113	default:
111		− return undefined;
	114	+ return "completed";
112	115	}
113	116	}
114	117
@@ -123,29 +126,53 @@ function normalizeItemType(raw: unknown): string { · 8 unmodified lines
123	126	.toLowerCase();
124	127	}
125	128
126		−function shouldDropItemType(type: string): boolean {
127		− if (type.includes("preamble") \|\| type.includes("reasoning") \|\| type.includes("thought")) {
128		− return true;
129		− }
130		− return type === "work" \|\| type.startsWith("work ");
	129	+function toCanonicalItemType(raw: unknown): CanonicalItemType {
	130	+ const type = normalizeItemType(raw);
	131	+ if (type.includes("user")) return "user_message";
	132	+ if (type.includes("agent message") \|\| type.includes("assistant")) return "assistant_message";
	133	+ if (type.includes("reasoning") \|\| type.includes("thought")) return "reasoning";
	134	+ if (type.includes("plan") \|\| type.includes("todo")) return "plan";
	135	+ if (type.includes("command")) return "command_execution";
	136	+ if (type.includes("file change") \|\| type.includes("patch") \|\| type.includes("edit")) return "file_change";
	137	+ if (type.includes("mcp")) return "mcp_tool_call";
	138	+ if (type.includes("dynamic tool")) return "dynamic_tool_call";
	139	+ if (type.includes("collab")) return "collab_agent_tool_call";
	140	+ if (type.includes("web search")) return "web_search";
	141	+ if (type.includes("image")) return "image_view";
	142	+ if (type.includes("review entered")) return "review_entered";
	143	+ if (type.includes("review exited")) return "review_exited";
	144	+ if (type.includes("compact")) return "context_compaction";
	145	+ if (type.includes("error")) return "error";
	146	+ return "unknown";
131	147	}
132	148
133		−function toolMeta(type: string):
134		− \| {
135		− readonly toolKind: ProviderRuntimeToolKind;
136		− readonly title: string;
137		− }
138		− \| undefined {
139		− if (type.includes("command")) {
140		− return { toolKind: "command", title: "Command run" };
141		− }
142		− if (type.includes("file change")) {
143		− return { toolKind: "file-change", title: "File change" };
144		− }
145		− if (type.includes("tool")) {
146		− return { toolKind: "other", title: "Tool call" };
	149	+function itemTitle(itemType: CanonicalItemType): string \| undefined {
	150	+ switch (itemType) {
	151	+ case "assistant_message":
	152	+ return "Assistant message";
	153	+ case "user_message":
	154	+ return "User message";
	155	+ case "reasoning":
	156	+ return "Reasoning";
	157	+ case "plan":
	158	+ return "Plan";
	159	+ case "command_execution":
	160	+ return "Command run";
	161	+ case "file_change":
	162	+ return "File change";
	163	+ case "mcp_tool_call":
	164	+ return "MCP tool call";
	165	+ case "dynamic_tool_call":
	166	+ return "Tool call";
	167	+ case "web_search":
	168	+ return "Web search";
	169	+ case "image_view":
	170	+ return "Image view";
	171	+ case "error":
	172	+ return "Error";
	173	+ default:
	174	+ return undefined;
147	175	}
148		− return undefined;
149	176	}
150	177
151	178	function itemDetail(
@@ -174,80 +201,155 @@ function itemDetail( · 22 unmodified lines
174	201	return undefined;
175	202	}
176	203
177		−function mapMessageCompletedEvent(event: ProviderEvent): ProviderRuntimeEvent \| undefined {
178		− if (event.method !== "item/completed") {
179		− return undefined;
	204	+function toRequestTypeFromMethod(method: string): CanonicalRequestType {
	205	+ switch (method) {
	206	+ case "item/commandExecution/requestApproval":
	207	+ return "command_execution_approval";
	208	+ case "item/fileChange/requestApproval":
	209	+ return "file_change_approval";
	210	+ case "applyPatchApproval":
	211	+ return "apply_patch_approval";
	212	+ case "execCommandApproval":
	213	+ return "exec_command_approval";
	214	+ case "item/tool/requestUserInput":
	215	+ return "tool_user_input";
	216	+ case "item/tool/call":
	217	+ return "dynamic_tool_call";
	218	+ case "account/chatgptAuthTokens/refresh":
	219	+ return "auth_tokens_refresh";
	220	+ default:
	221	+ return "unknown";
180	222	}
	223	+}
181	224
182		− const payload = asObject(event.payload);
183		− const item = asObject(payload?.item);
184		− if (!item) {
185		− return undefined;
	225	+function toRequestTypeFromKind(kind: unknown): CanonicalRequestType {
	226	+ switch (kind) {
	227	+ case "command":
	228	+ return "command_execution_approval";
	229	+ case "file-change":
	230	+ return "file_change_approval";
	231	+ default:
	232	+ return "unknown";
186	233	}
	234	+}
187	235
188		− const normalizedType = normalizeItemType(item.type ?? item.kind);
189		− if (!normalizedType.includes("agent message")) {
190		− return undefined;
	236	+function toThreadState(value: unknown):
	237	+ \| "active"
	238	+ \| "idle"
	239	+ \| "archived"
	240	+ \| "closed"
	241	+ \| "compacted"
	242	+ \| "error" {
	243	+ switch (value) {
	244	+ case "idle":
	245	+ return "idle";
	246	+ case "archived":
	247	+ return "archived";
	248	+ case "closed":
	249	+ return "closed";
	250	+ case "compacted":
	251	+ return "compacted";
	252	+ case "error":
	253	+ case "failed":
	254	+ return "error";
	255	+ default:
	256	+ return "active";
191	257	}
	258	+}
192	259
193		− const itemId = event.itemId ?? asString(item.id);
194		− if (!itemId) {
195		− return undefined;
	260	+function contentStreamKindFromMethod(
	261	+ method: string,
	262	+): "assistant_text" \| "reasoning_text" \| "reasoning_summary_text" \| "plan_text" \| "command_output" \| "file_change_output" {
	263	+ switch (method) {
	264	+ case "item/agentMessage/delta":
	265	+ return "assistant_text";
	266	+ case "item/reasoning/textDelta":
	267	+ return "reasoning_text";
	268	+ case "item/reasoning/summaryTextDelta":
	269	+ return "reasoning_summary_text";
	270	+ case "item/plan/delta":
	271	+ return "plan_text";
	272	+ case "item/commandExecution/outputDelta":
	273	+ return "command_output";
	274	+ case "item/fileChange/outputDelta":
	275	+ return "file_change_output";
	276	+ default:
	277	+ return "assistant_text";
196	278	}
	279	+}
	280	+
	281	+function eventRawSource(event: ProviderEvent): ProviderRuntimeEvent["raw"]["source"] {
	282	+ return event.kind === "request" ? "codex.app-server.request" : "codex.app-server.notification";
	283	+}
	284	+
	285	+function providerRefsFromEvent(event: ProviderEvent): ProviderRuntimeEvent["providerRefs"] \| undefined {
	286	+ const refs: Record<string, string> = {
	287	+ providerSessionId: event.sessionId,
	288	+ };
	289	+ if (event.threadId) refs.providerThreadId = event.threadId;
	290	+ if (event.turnId) refs.providerTurnId = event.turnId;
	291	+ if (event.itemId) refs.providerItemId = event.itemId;
	292	+ if (event.requestId) refs.providerRequestId = event.requestId;
	293	+
	294	+ return Object.keys(refs).length > 0
	295	+ ? (refs as ProviderRuntimeEvent["providerRefs"])
	296	+ : undefined;
	297	+}
197	298
	299	+function runtimeEventBase(event: ProviderEvent): Omit<ProviderRuntimeEvent, "type" \| "payload"> {
	300	+ const refs = providerRefsFromEvent(event);
198	301	return {
199		− type: "message.completed",
200	302	eventId: event.id,
201	303	provider: event.provider,
202	304	sessionId: event.sessionId,
203	305	createdAt: event.createdAt,
204		− itemId: ProviderItemId.makeUnsafe(itemId),
205	306	...(event.threadId ? { threadId: event.threadId } : {}),
206	307	...(event.turnId ? { turnId: event.turnId } : {}),
	308	+ ...(event.itemId ? { itemId: event.itemId } : {}),
	309	+ ...(event.requestId ? { requestId: event.requestId } : {}),
	310	+ ...(refs ? { providerRefs: refs } : {}),
	311	+ raw: {
	312	+ source: eventRawSource(event),
	313	+ method: event.method,
	314	+ payload: event.payload ?? {},
	315	+ },
207	316	};
208	317	}
209	318
210		−function mapToolEvent(event: ProviderEvent): ProviderRuntimeEvent \| undefined {
211		− if (event.method !== "item/started" && event.method !== "item/completed") {
212		− return undefined;
213		− }
	319	+function mapItemLifecycle(
	320	+ event: ProviderEvent,
	321	+ lifecycle: "item.started" \| "item.updated" \| "item.completed",
	322	+): ProviderRuntimeEvent \| undefined {
214	323	const payload = asObject(event.payload);
215	324	const item = asObject(payload?.item);
216		− if (!item) {
	325	+ const source = item ?? payload;
	326	+ if (!source) {
217	327	return undefined;
218	328	}
219		− const normalizedType = normalizeItemType(item.type ?? item.kind);
220		− if (shouldDropItemType(normalizedType)) {
221		− return undefined;
222		− }
223		− const meta = toolMeta(normalizedType);
224		− if (!meta) {
	329	+
	330	+ const itemType = toCanonicalItemType(source.type ?? source.kind);
	331	+ if (itemType === "unknown" && lifecycle !== "item.updated") {
225	332	return undefined;
226	333	}
227	334
228		− const eventBase = {
229		− eventId: event.id,
230		− provider: event.provider,
231		− sessionId: event.sessionId,
232		− createdAt: event.createdAt,
233		− ...(event.threadId ? { threadId: event.threadId } : {}),
234		− ...(event.turnId ? { turnId: event.turnId } : {}),
235		− ...(event.itemId ? { itemId: event.itemId } : {}),
236		− toolKind: meta.toolKind,
237		− title: meta.title,
238		− ...(payload ? { detail: itemDetail(item, payload) } : {}),
239		− } as const;
240		−
241		− if (event.method === "item/started") {
242		− return {
243		− type: "tool.started",
244		− ...eventBase,
245		− };
246		− }
	335	+ const detail = itemDetail(source, payload ?? source);
	336	+ const status =
	337	+ lifecycle === "item.started"
	338	+ ? "inProgress"
	339	+ : lifecycle === "item.completed"
	340	+ ? "completed"
	341	+ : undefined;
247	342
248	343	return {
249		− type: "tool.completed",
250		− ...eventBase,
	344	+ ...runtimeEventBase(event),
	345	+ type: lifecycle,
	346	+ payload: {
	347	+ itemType,
	348	+ ...(status ? { status } : {}),
	349	+ ...(itemTitle(itemType) ? { title: itemTitle(itemType) } : {}),
	350	+ ...(detail ? { detail } : {}),
	351	+ ...(event.payload !== undefined ? { data: event.payload } : {}),
	352	+ },
251	353	};
252	354	}
253	355
@@ -261,78 +363,87 @@ function mapToRuntimeEvents(event: ProviderEvent): ReadonlyArray<ProviderRuntime · 7 unmodified lines
261	363	}
262	364	return [
263	365	{
	366	+ ...runtimeEventBase(event),
264	367	type: "runtime.error",
265		− eventId: event.id,
266		− provider: event.provider,
267		− sessionId: event.sessionId,
268		− createdAt: event.createdAt,
269		− ...(event.threadId ? { threadId: event.threadId } : {}),
270		− ...(event.turnId ? { turnId: event.turnId } : {}),
271		− ...(event.itemId ? { itemId: event.itemId } : {}),
272		− message: event.message,
	368	+ payload: {
	369	+ message: event.message,
	370	+ class: "provider_error",
	371	+ ...(event.payload !== undefined ? { detail: event.payload } : {}),
	372	+ },
273	373	},
274	374	];
275	375	}
276	376
277		− if (event.kind === "request" && event.requestId && event.requestKind) {
	377	+ if (event.kind === "request") {
278	378	const detail =
279	379	asString(payload?.command) ?? asString(payload?.reason) ?? asString(payload?.prompt);
280	380	return [
281	381	{
282		− type: "approval.requested",
283		− eventId: event.id,
284		− provider: event.provider,
285		− sessionId: event.sessionId,
286		− createdAt: event.createdAt,
287		− ...(event.threadId ? { threadId: event.threadId } : {}),
288		− ...(event.turnId ? { turnId: event.turnId } : {}),
289		− ...(event.itemId ? { itemId: event.itemId } : {}),
290		− requestId: event.requestId,
291		− requestKind: event.requestKind,
292		− ...(detail ? { detail } : {}),
	382	+ ...runtimeEventBase(event),
	383	+ type: "request.opened",
	384	+ payload: {
	385	+ requestType: toRequestTypeFromMethod(event.method),
	386	+ ...(detail ? { detail } : {}),
	387	+ ...(event.payload !== undefined ? { args: event.payload } : {}),
	388	+ },
293	389	},
294	390	];
295	391	}
296	392
297	393	if (event.method === "item/requestApproval/decision" && event.requestId) {
298	394	const decision = Schema.decodeUnknownSync(ProviderApprovalDecision)(payload?.decision);
	395	+ const requestType =
	396	+ event.requestKind !== undefined
	397	+ ? toRequestTypeFromKind(event.requestKind)
	398	+ : toRequestTypeFromMethod(event.method);
299	399	return [
300	400	{
301		− type: "approval.resolved",
302		− eventId: event.id,
303		− provider: event.provider,
304		− sessionId: event.sessionId,
305		− createdAt: event.createdAt,
306		− ...(event.threadId ? { threadId: event.threadId } : {}),
307		− ...(event.turnId ? { turnId: event.turnId } : {}),
308		− ...(event.itemId ? { itemId: event.itemId } : {}),
309		− requestId: event.requestId,
310		− ...(event.requestKind ? { requestKind: event.requestKind } : {}),
311		− ...(decision ? { decision } : {}),
	401	+ ...runtimeEventBase(event),
	402	+ type: "request.resolved",
	403	+ payload: {
	404	+ requestType,
	405	+ ...(decision ? { decision } : {}),
	406	+ ...(event.payload !== undefined ? { resolution: event.payload } : {}),
	407	+ },
312	408	},
313	409	];
314	410	}
315	411
316		− const messageCompleted = mapMessageCompletedEvent(event);
317		− if (messageCompleted) {
318		− return [messageCompleted];
	412	+ if (event.method === "session/connecting") {
	413	+ return [
	414	+ {
	415	+ ...runtimeEventBase(event),
	416	+ type: "session.state.changed",
	417	+ payload: {
	418	+ state: "starting",
	419	+ ...(event.message ? { reason: event.message } : {}),
	420	+ },
	421	+ },
	422	+ ];
319	423	}
320	424
321		− const tool = mapToolEvent(event);
322		− if (tool) {
323		− return [tool];
	425	+ if (event.method === "session/ready") {
	426	+ return [
	427	+ {
	428	+ ...runtimeEventBase(event),
	429	+ type: "session.state.changed",
	430	+ payload: {
	431	+ state: "ready",
	432	+ ...(event.message ? { reason: event.message } : {}),
	433	+ },
	434	+ },
	435	+ ];
324	436	}
325	437
326	438	if (event.method === "session/started") {
327	439	return [
328	440	{
	441	+ ...runtimeEventBase(event),
329	442	type: "session.started",
330		− eventId: event.id,
331		− provider: event.provider,
332		− sessionId: event.sessionId,
333		− createdAt: event.createdAt,
334		− ...(event.threadId ? { threadId: event.threadId } : {}),
335		− ...(event.message ? { message: event.message } : {}),
	443	+ payload: {
	444	+ ...(event.message ? { message: event.message } : {}),
	445	+ ...(event.payload !== undefined ? { resume: event.payload } : {}),
	446	+ },
336	447	},
337	448	];
338	449	}
@@ -340,33 +451,82 @@ function mapToRuntimeEvents(event: ProviderEvent): ReadonlyArray<ProviderRuntime · 1 unmodified line
340	451	if (event.method === "session/exited" \|\| event.method === "session/closed") {
341	452	return [
342	453	{
	454	+ ...runtimeEventBase(event),
343	455	type: "session.exited",
344		− eventId: event.id,
345		− provider: event.provider,
346		− sessionId: event.sessionId,
347		− createdAt: event.createdAt,
348		− ...(event.threadId ? { threadId: event.threadId } : {}),
349		− ...(event.message ? { message: event.message } : {}),
	456	+ payload: {
	457	+ ...(event.message ? { reason: event.message } : {}),
	458	+ ...(event.method === "session/closed" ? { exitKind: "graceful" } : {}),
	459	+ },
350	460	},
351	461	];
352	462	}
353	463
354	464	if (event.method === "thread/started") {
355	465	const payloadThreadId = asString(asObject(payload?.thread)?.id);
356		− const threadId =
	466	+ const providerThreadId =
357	467	event.threadId ??
358	468	(payloadThreadId ? ProviderThreadId.makeUnsafe(payloadThreadId) : undefined);
359		− if (!threadId) {
	469	+ if (!providerThreadId) {
360	470	return [];
361	471	}
362	472	return [
363	473	{
	474	+ ...runtimeEventBase(event),
364	475	type: "thread.started",
365		− eventId: event.id,
366		− provider: event.provider,
367		− sessionId: event.sessionId,
368		− createdAt: event.createdAt,
369		− threadId,
	476	+ payload: {
	477	+ providerThreadId,
	478	+ },
	479	+ },
	480	+ ];
	481	+ }
	482	+
	483	+ if (
	484	+ event.method === "thread/status/changed" \|\|
	485	+ event.method === "thread/archived" \|\|
	486	+ event.method === "thread/unarchived" \|\|
	487	+ event.method === "thread/closed" \|\|
	488	+ event.method === "thread/compacted"
	489	+ ) {
	490	+ return [
	491	+ {
	492	+ ...runtimeEventBase(event),
	493	+ type: "thread.state.changed",
	494	+ payload: {
	495	+ state:
	496	+ event.method === "thread/archived"
	497	+ ? "archived"
	498	+ : event.method === "thread/closed"
	499	+ ? "closed"
	500	+ : event.method === "thread/compacted"
	501	+ ? "compacted"
	502	+ : toThreadState(asObject(payload?.thread)?.state ?? payload?.state),
	503	+ ...(event.payload !== undefined ? { detail: event.payload } : {}),
	504	+ },
	505	+ },
	506	+ ];
	507	+ }
	508	+
	509	+ if (event.method === "thread/name/updated") {
	510	+ return [
	511	+ {
	512	+ ...runtimeEventBase(event),
	513	+ type: "thread.metadata.updated",
	514	+ payload: {
	515	+ ...(asString(payload?.threadName) ? { name: asString(payload?.threadName) } : {}),
	516	+ ...(event.payload !== undefined ? { metadata: asObject(event.payload) } : {}),
	517	+ },
	518	+ },
	519	+ ];
	520	+ }
	521	+
	522	+ if (event.method === "thread/tokenUsage/updated") {
	523	+ return [
	524	+ {
	525	+ ...runtimeEventBase(event),
	526	+ type: "thread.token-usage.updated",
	527	+ payload: {
	528	+ usage: event.payload ?? {},
	529	+ },
370	530	},
371	531	];
372	532	}
@@ -380,52 +540,360 @@ function mapToRuntimeEvents(event: ProviderEvent): ReadonlyArray<ProviderRuntime · 7 unmodified lines
380	540	}
381	541	return [
382	542	{
383		− type: "turn.started",
384		− eventId: event.id,
385		− provider: event.provider,
386		− sessionId: event.sessionId,
387		− createdAt: event.createdAt,
388		− ...(event.threadId ? { threadId: event.threadId } : {}),
	543	+ ...runtimeEventBase(event),
389	544	turnId,
	545	+ type: "turn.started",
	546	+ payload: {
	547	+ ...(asString(turn?.model) ? { model: asString(turn?.model) } : {}),
	548	+ ...(asString(turn?.effort) ? { effort: asString(turn?.effort) } : {}),
	549	+ },
390	550	},
391	551	];
392	552	}
393	553
394	554	if (event.method === "turn/completed") {
	555	+ const errorMessage = asString(asObject(turn?.error)?.message);
395	556	return [
396	557	{
	558	+ ...runtimeEventBase(event),
397	559	type: "turn.completed",
398		− eventId: event.id,
399		− provider: event.provider,
400		− sessionId: event.sessionId,
401		− createdAt: event.createdAt,
402		− ...(event.threadId ? { threadId: event.threadId } : {}),
403		− ...(event.turnId ? { turnId: event.turnId } : {}),
404		− ...(toTurnStatus(turn?.status) ? { status: toTurnStatus(turn?.status) } : {}),
405		− ...(asString(asObject(turn?.error)?.message)
406		− ? { errorMessage: asString(asObject(turn?.error)?.message) }
407		− : {}),
	560	+ payload: {
	561	+ state: toTurnStatus(turn?.status),
	562	+ ...(asString(turn?.stopReason) ? { stopReason: asString(turn?.stopReason) } : {}),
	563	+ ...(turn?.usage !== undefined ? { usage: turn.usage } : {}),
	564	+ ...(asObject(turn?.modelUsage) ? { modelUsage: asObject(turn?.modelUsage) } : {}),
	565	+ ...(asNumber(turn?.totalCostUsd) !== undefined
	566	+ ? { totalCostUsd: asNumber(turn?.totalCostUsd) }
	567	+ : {}),
	568	+ ...(errorMessage ? { errorMessage } : {}),
	569	+ },
	570	+ },
	571	+ ];
	572	+ }
	573	+
	574	+ if (event.method === "turn/aborted") {
	575	+ return [
	576	+ {
	577	+ ...runtimeEventBase(event),
	578	+ type: "turn.aborted",
	579	+ payload: {
	580	+ reason: event.message ?? "Turn aborted",
	581	+ },
	582	+ },
	583	+ ];
	584	+ }
	585	+
	586	+ if (event.method === "turn/plan/updated") {
	587	+ const steps = Array.isArray(payload?.plan) ? payload.plan : [];
	588	+ return [
	589	+ {
	590	+ ...runtimeEventBase(event),
	591	+ type: "turn.plan.updated",
	592	+ payload: {
	593	+ ...(asString(payload?.explanation) ? { explanation: asString(payload?.explanation) } : {}),
	594	+ plan: steps
	595	+ .map((entry) => asObject(entry))
	596	+ .filter((entry): entry is Record<string, unknown> => entry !== undefined)
	597	+ .map((entry) => ({
	598	+ step: asString(entry.step) ?? "step",
	599	+ status:
	600	+ entry.status === "completed" \|\| entry.status === "inProgress"
	601	+ ? entry.status
	602	+ : "pending",
	603	+ })),
	604	+ },
408	605	},
409	606	];
410	607	}
411	608
412		− if (event.method === "item/agentMessage/delta" && event.textDelta && event.textDelta.length > 0) {
	609	+ if (event.method === "turn/diff/updated") {
413	610	return [
414	611	{
415		− type: "message.delta",
416		− eventId: event.id,
417		− provider: event.provider,
418		− sessionId: event.sessionId,
419		− createdAt: event.createdAt,
420		− ...(event.threadId ? { threadId: event.threadId } : {}),
421		− ...(event.turnId ? { turnId: event.turnId } : {}),
422		− ...(event.itemId ? { itemId: event.itemId } : {}),
423		− delta: event.textDelta,
	612	+ ...runtimeEventBase(event),
	613	+ type: "turn.diff.updated",
	614	+ payload: {
	615	+ unifiedDiff:
	616	+ asString(payload?.unifiedDiff) ??
	617	+ asString(payload?.diff) ??
	618	+ asString(payload?.patch) ??
	619	+ "",
	620	+ },
424	621	},
425	622	];
426	623	}
427	624
428		− return [];
	625	+ if (event.method === "item/started") {
	626	+ const started = mapItemLifecycle(event, "item.started");
	627	+ return started ? [started] : [];
	628	+ }
	629	+
	630	+ if (event.method === "item/completed") {
	631	+ const completed = mapItemLifecycle(event, "item.completed");
	632	+ return completed ? [completed] : [];
	633	+ }
	634	+
	635	+ if (
	636	+ event.method === "item/reasoning/summaryPartAdded" \|\|
	637	+ event.method === "item/commandExecution/terminalInteraction"
	638	+ ) {
	639	+ const updated = mapItemLifecycle(event, "item.updated");
	640	+ return updated ? [updated] : [];
	641	+ }
	642	+
	643	+ if (
	644	+ event.method === "item/agentMessage/delta" \|\|
	645	+ event.method === "item/plan/delta" \|\|
	646	+ event.method === "item/commandExecution/outputDelta" \|\|
	647	+ event.method === "item/fileChange/outputDelta" \|\|
	648	+ event.method === "item/reasoning/summaryTextDelta" \|\|
	649	+ event.method === "item/reasoning/textDelta"
	650	+ ) {
	651	+ const delta =
	652	+ event.textDelta ??
	653	+ asString(payload?.delta) ??
	654	+ asString(payload?.text) ??
	655	+ asString(asObject(payload?.content)?.text);
	656	+ if (!delta \|\| delta.length === 0) {
	657	+ return [];
	658	+ }
	659	+ return [
	660	+ {
	661	+ ...runtimeEventBase(event),
	662	+ type: "content.delta",
	663	+ payload: {
	664	+ streamKind: contentStreamKindFromMethod(event.method),
	665	+ delta,
	666	+ ...(typeof payload?.contentIndex === "number" ? { contentIndex: payload.contentIndex } : {}),
	667	+ ...(typeof payload?.summaryIndex === "number" ? { summaryIndex: payload.summaryIndex } : {}),
	668	+ },
	669	+ },
	670	+ ];
	671	+ }
	672	+
	673	+ if (event.method === "item/mcpToolCall/progress") {
	674	+ return [
	675	+ {
	676	+ ...runtimeEventBase(event),
	677	+ type: "tool.progress",
	678	+ payload: {
	679	+ ...(asString(payload?.toolUseId) ? { toolUseId: asString(payload?.toolUseId) } : {}),
	680	+ ...(asString(payload?.toolName) ? { toolName: asString(payload?.toolName) } : {}),
	681	+ ...(asString(payload?.summary) ? { summary: asString(payload?.summary) } : {}),
	682	+ ...(asNumber(payload?.elapsedSeconds) !== undefined
	683	+ ? { elapsedSeconds: asNumber(payload?.elapsedSeconds) }
	684	+ : {}),
	685	+ },
	686	+ },
	687	+ ];
	688	+ }
	689	+
	690	+ if (event.method === "serverRequest/resolved") {
	691	+ return [
	692	+ {
	693	+ ...runtimeEventBase(event),
	694	+ type: "request.resolved",
	695	+ payload: {
	696	+ requestType: "unknown",
	697	+ ...(event.payload !== undefined ? { resolution: event.payload } : {}),
	698	+ },
	699	+ },
	700	+ ];
	701	+ }
	702	+
	703	+ if (event.method === "model/rerouted") {
	704	+ return [
	705	+ {
	706	+ ...runtimeEventBase(event),
	707	+ type: "model.rerouted",
	708	+ payload: {
	709	+ fromModel: asString(payload?.fromModel) ?? "unknown",
	710	+ toModel: asString(payload?.toModel) ?? "unknown",
	711	+ reason: asString(payload?.reason) ?? "unknown",
	712	+ },
	713	+ },
	714	+ ];
	715	+ }
	716	+
	717	+ if (event.method === "deprecationNotice") {
	718	+ return [
	719	+ {
	720	+ ...runtimeEventBase(event),
	721	+ type: "deprecation.notice",
	722	+ payload: {
	723	+ summary: asString(payload?.summary) ?? "Deprecation notice",
	724	+ ...(asString(payload?.details) ? { details: asString(payload?.details) } : {}),
	725	+ },
	726	+ },
	727	+ ];
	728	+ }
	729	+
	730	+ if (event.method === "configWarning") {
	731	+ return [
	732	+ {
	733	+ ...runtimeEventBase(event),
	734	+ type: "config.warning",
	735	+ payload: {
	736	+ summary: asString(payload?.summary) ?? "Configuration warning",
	737	+ ...(asString(payload?.details) ? { details: asString(payload?.details) } : {}),
	738	+ ...(asString(payload?.path) ? { path: asString(payload?.path) } : {}),
	739	+ ...(payload?.range !== undefined ? { range: payload.range } : {}),
	740	+ },
	741	+ },
	742	+ ];
	743	+ }
	744	+
	745	+ if (event.method === "account/updated") {
	746	+ return [
	747	+ {
	748	+ ...runtimeEventBase(event),
	749	+ type: "account.updated",
	750	+ payload: {
	751	+ account: event.payload ?? {},
	752	+ },
	753	+ },
	754	+ ];
	755	+ }
	756	+
	757	+ if (event.method === "account/rateLimits/updated") {
	758	+ return [
	759	+ {
	760	+ ...runtimeEventBase(event),
	761	+ type: "account.rate-limits.updated",
	762	+ payload: {
	763	+ rateLimits: event.payload ?? {},
	764	+ },
	765	+ },
	766	+ ];
	767	+ }
	768	+
	769	+ if (event.method === "mcpServer/oauthLogin/completed") {
	770	+ return [
	771	+ {
	772	+ ...runtimeEventBase(event),
	773	+ type: "mcp.oauth.completed",
	774	+ payload: {
	775	+ success: payload?.success === true,
	776	+ ...(asString(payload?.name) ? { name: asString(payload?.name) } : {}),
	777	+ ...(asString(payload?.error) ? { error: asString(payload?.error) } : {}),
	778	+ },
	779	+ },
	780	+ ];
	781	+ }
	782	+
	783	+ if (event.method === "thread/realtime/started") {
	784	+ const realtimeSessionId = asString(payload?.realtimeSessionId);
	785	+ return [
	786	+ {
	787	+ ...runtimeEventBase(event),
	788	+ type: "thread.realtime.started",
	789	+ payload: {
	790	+ realtimeSessionId,
	791	+ },
	792	+ },
	793	+ ];
	794	+ }
	795	+
	796	+ if (event.method === "thread/realtime/itemAdded") {
	797	+ return [
	798	+ {
	799	+ ...runtimeEventBase(event),
	800	+ type: "thread.realtime.item-added",
	801	+ payload: {
	802	+ item: event.payload ?? {},
	803	+ },
	804	+ },
	805	+ ];
	806	+ }
	807	+
	808	+ if (event.method === "thread/realtime/outputAudio/delta") {
	809	+ return [
	810	+ {
	811	+ ...runtimeEventBase(event),
	812	+ type: "thread.realtime.audio.delta",
	813	+ payload: {
	814	+ audio: event.payload ?? {},
	815	+ },
	816	+ },
	817	+ ];
	818	+ }
	819	+
	820	+ if (event.method === "thread/realtime/error") {
	821	+ const message = asString(payload?.message) ?? event.message ?? "Realtime error";
	822	+ return [
	823	+ {
	824	+ ...runtimeEventBase(event),
	825	+ type: "thread.realtime.error",
	826	+ payload: {
	827	+ message,
	828	+ },
	829	+ },
	830	+ ];
	831	+ }
	832	+
	833	+ if (event.method === "thread/realtime/closed") {
	834	+ return [
	835	+ {
	836	+ ...runtimeEventBase(event),
	837	+ type: "thread.realtime.closed",
	838	+ payload: {
	839	+ reason: event.message,
	840	+ },
	841	+ },
	842	+ ];
	843	+ }
	844	+
	845	+ if (event.method === "error") {
	846	+ const message =
	847	+ asString(asObject(payload?.error)?.message) ?? event.message ?? "Provider runtime error";
	848	+ return [
	849	+ {
	850	+ ...runtimeEventBase(event),
	851	+ type: "runtime.error",
	852	+ payload: {
	853	+ message,
	854	+ class: "provider_error",
	855	+ ...(event.payload !== undefined ? { detail: event.payload } : {}),
	856	+ },
	857	+ },
	858	+ ];
	859	+ }
	860	+
	861	+ if (event.method === "windows/worldWritableWarning") {
	862	+ return [
	863	+ {
	864	+ ...runtimeEventBase(event),
	865	+ type: "runtime.warning",
	866	+ payload: {
	867	+ message: event.message ?? "Windows world-writable warning",
	868	+ ...(event.payload !== undefined ? { detail: event.payload } : {}),
	869	+ },
	870	+ },
	871	+ ];
	872	+ }
	873	+
	874	+ if (event.method === "windowsSandbox/setupCompleted") {
	875	+ return [
	876	+ {
	877	+ ...runtimeEventBase(event),
	878	+ type: "runtime.warning",
	879	+ payload: {
	880	+ message: event.message ?? "Windows sandbox setup completed",
	881	+ ...(event.payload !== undefined ? { detail: event.payload } : {}),
	882	+ },
	883	+ },
	884	+ ];
	885	+ }
	886	+
	887	+ return [
	888	+ {
	889	+ ...runtimeEventBase(event),
	890	+ type: "runtime.warning",
	891	+ payload: {
	892	+ message: `Unhandled Codex provider event method: ${event.method}`,
	893	+ ...(event.payload !== undefined ? { detail: event.payload } : {}),
	894	+ },
	895	+ },
	896	+ ];
429	897	}
430	898
431	899	const makeCodexAdapter = (options?: CodexAdapterLiveOptions) =>

apps/server/src/provider/Layers/CursorAdapter.test.ts+350−0

@@ -0,0 +1,350 @@
	1	+import { EventEmitter } from "node:events";
	2	+import { PassThrough } from "node:stream";
	3	+import readline from "node:readline";
	4	+
	5	+import { ApprovalRequestId } from "@t3tools/contracts";
	6	+import { assert, describe, it } from "@effect/vitest";
	7	+import { Effect, Fiber, Stream } from "effect";
	8	+
	9	+import { ProviderAdapterValidationError } from "../Errors.ts";
	10	+import { CursorAdapter } from "../Services/CursorAdapter.ts";
	11	+import { makeCursorAdapterLive } from "./CursorAdapter.ts";
	12	+
	13	+class FakeCursorAcpProcess extends EventEmitter {
	14	+ readonly stdin = new PassThrough();
	15	+ readonly stdout = new PassThrough();
	16	+ readonly stderr = new PassThrough();
	17	+ killed = false;
	18	+
	19	+ private readonly input = readline.createInterface({ input: this.stdin });
	20	+ private permissionRequestId = 700;
	21	+ lastPermissionSelection: string \| undefined;
	22	+
	23	+ constructor() {
	24	+ super();
	25	+ this.input.on("line", (line) => {
	26	+ const message = JSON.parse(line) as Record<string, unknown>;
	27	+ if (typeof message.method === "string") {
	28	+ this.handleRequest(message);
	29	+ return;
	30	+ }
	31	+
	32	+ if (message.id === this.permissionRequestId) {
	33	+ const optionId =
	34	+ (message.result as { outcome?: { optionId?: unknown } } \| undefined)?.outcome?.optionId;
	35	+ if (typeof optionId === "string") {
	36	+ this.lastPermissionSelection = optionId;
	37	+ }
	38	+ }
	39	+ });
	40	+ }
	41	+
	42	+ kill(): boolean {
	43	+ if (this.killed) {
	44	+ return true;
	45	+ }
	46	+ this.killed = true;
	47	+ this.emit("exit", 0, null);
	48	+ return true;
	49	+ }
	50	+
	51	+ emitPermissionRequest(): void {
	52	+ this.emitServerMessage({
	53	+ jsonrpc: "2.0",
	54	+ id: this.permissionRequestId,
	55	+ method: "session/request_permission",
	56	+ params: {
	57	+ sessionId: "acp-session-1",
	58	+ toolCall: {
	59	+ toolCallId: "tool-perm-1",
	60	+ kind: "execute",
	61	+ title: "`pwd`",
	62	+ },
	63	+ options: [
	64	+ { optionId: "allow-once", kind: "allow_once" },
	65	+ { optionId: "allow-always", kind: "allow_always" },
	66	+ { optionId: "reject-once", kind: "reject_once" },
	67	+ ],
	68	+ },
	69	+ });
	70	+ }
	71	+
	72	+ private handleRequest(message: Record<string, unknown>): void {
	73	+ const method = message.method;
	74	+ const id = message.id;
	75	+ if (typeof method !== "string" \|\| (typeof id !== "string" && typeof id !== "number")) {
	76	+ return;
	77	+ }
	78	+
	79	+ switch (method) {
	80	+ case "initialize":
	81	+ this.emitServerMessage({
	82	+ jsonrpc: "2.0",
	83	+ id,
	84	+ result: {
	85	+ protocolVersion: 1,
	86	+ agentCapabilities: {
	87	+ loadSession: true,
	88	+ },
	89	+ authMethods: [{ id: "cursor_login" }],
	90	+ },
	91	+ });
	92	+ return;
	93	+ case "authenticate":
	94	+ this.emitServerMessage({
	95	+ jsonrpc: "2.0",
	96	+ id,
	97	+ result: {},
	98	+ });
	99	+ return;
	100	+ case "session/new":
	101	+ this.emitServerMessage({
	102	+ jsonrpc: "2.0",
	103	+ id,
	104	+ result: {
	105	+ sessionId: "acp-session-1",
	106	+ modes: {
	107	+ currentModeId: "agent",
	108	+ availableModes: [{ id: "agent" }],
	109	+ },
	110	+ },
	111	+ });
	112	+ return;
	113	+ case "session/load":
	114	+ this.emitServerMessage({
	115	+ jsonrpc: "2.0",
	116	+ id,
	117	+ result: {},
	118	+ });
	119	+ return;
	120	+ case "session/prompt": {
	121	+ this.emitServerMessage({
	122	+ jsonrpc: "2.0",
	123	+ method: "session/update",
	124	+ params: {
	125	+ sessionId: "acp-session-1",
	126	+ update: {
	127	+ sessionUpdate: "agent_thought_chunk",
	128	+ content: {
	129	+ type: "text",
	130	+ text: "thinking",
	131	+ },
	132	+ },
	133	+ },
	134	+ });
	135	+
	136	+ this.emitServerMessage({
	137	+ jsonrpc: "2.0",
	138	+ method: "session/update",
	139	+ params: {
	140	+ sessionId: "acp-session-1",
	141	+ update: {
	142	+ sessionUpdate: "agent_message_chunk",
	143	+ content: {
	144	+ type: "text",
	145	+ text: "hello",
	146	+ },
	147	+ },
	148	+ },
	149	+ });
	150	+
	151	+ this.emitServerMessage({
	152	+ jsonrpc: "2.0",
	153	+ method: "session/update",
	154	+ params: {
	155	+ sessionId: "acp-session-1",
	156	+ update: {
	157	+ sessionUpdate: "tool_call",
	158	+ toolCallId: "tool-1",
	159	+ kind: "execute",
	160	+ title: "`pwd`",
	161	+ rawInput: { command: "pwd" },
	162	+ },
	163	+ },
	164	+ });
	165	+
	166	+ this.emitServerMessage({
	167	+ jsonrpc: "2.0",
	168	+ method: "session/update",
	169	+ params: {
	170	+ sessionId: "acp-session-1",
	171	+ update: {
	172	+ sessionUpdate: "tool_call_update",
	173	+ toolCallId: "tool-1",
	174	+ status: "completed",
	175	+ rawOutput: {
	176	+ exitCode: 0,
	177	+ stdout: "/tmp/project",
	178	+ stderr: "",
	179	+ },
	180	+ },
	181	+ },
	182	+ });
	183	+
	184	+ this.emitServerMessage({
	185	+ jsonrpc: "2.0",
	186	+ id,
	187	+ result: {
	188	+ stopReason: "end_turn",
	189	+ },
	190	+ });
	191	+ return;
	192	+ }
	193	+ case "session/cancel":
	194	+ this.emitServerMessage({
	195	+ jsonrpc: "2.0",
	196	+ id,
	197	+ error: {
	198	+ code: -32601,
	199	+ message: "Method not found",
	200	+ },
	201	+ });
	202	+ return;
	203	+ default:
	204	+ this.emitServerMessage({
	205	+ jsonrpc: "2.0",
	206	+ id,
	207	+ error: {
	208	+ code: -32601,
	209	+ message: `Unhandled method: ${method}`,
	210	+ },
	211	+ });
	212	+ }
	213	+ }
	214	+
	215	+ private emitServerMessage(message: unknown): void {
	216	+ this.stdout.write(`${JSON.stringify(message)}\n`);
	217	+ }
	218	+}
	219	+
	220	+describe("CursorAdapterLive", () => {
	221	+ it.effect("returns validation error for non-cursor provider on startSession", () => {
	222	+ const fake = new FakeCursorAcpProcess();
	223	+ const layer = makeCursorAdapterLive({
	224	+ createProcess: () => fake as never,
	225	+ });
	226	+
	227	+ return Effect.gen(function* () {
	228	+ const adapter = yield* CursorAdapter;
	229	+ const result = yield* adapter.startSession({ provider: "codex" }).pipe(Effect.result);
	230	+
	231	+ assert.equal(result._tag, "Failure");
	232	+ if (result._tag !== "Failure") {
	233	+ return;
	234	+ }
	235	+ assert.deepEqual(
	236	+ result.failure,
	237	+ new ProviderAdapterValidationError({
	238	+ provider: "cursor",
	239	+ operation: "startSession",
	240	+ issue: "Expected provider 'cursor' but received 'codex'.",
	241	+ }),
	242	+ );
	243	+ }).pipe(Effect.provide(layer));
	244	+ });
	245	+
	246	+ it.effect("maps ACP prompt/update events into canonical runtime events", () => {
	247	+ const fake = new FakeCursorAcpProcess();
	248	+ const layer = makeCursorAdapterLive({
	249	+ createProcess: () => fake as never,
	250	+ });
	251	+
	252	+ return Effect.gen(function* () {
	253	+ const adapter = yield* CursorAdapter;
	254	+
	255	+ const eventsFiber = yield* Stream.take(adapter.streamEvents, 11).pipe(
	256	+ Stream.runCollect,
	257	+ Effect.forkChild,
	258	+ );
	259	+
	260	+ const session = yield* adapter.startSession({
	261	+ provider: "cursor",
	262	+ cwd: "/tmp/project",
	263	+ });
	264	+
	265	+ const turn = yield* adapter.sendTurn({
	266	+ sessionId: session.sessionId,
	267	+ input: "hello",
	268	+ attachments: [],
	269	+ });
	270	+
	271	+ const events = Array.from(yield* Fiber.join(eventsFiber));
	272	+ assert.deepEqual(
	273	+ events.map((event) => event.type),
	274	+ [
	275	+ "session.configured",
	276	+ "session.started",
	277	+ "thread.started",
	278	+ "session.state.changed",
	279	+ "turn.started",
	280	+ "content.delta",
	281	+ "content.delta",
	282	+ "item.started",
	283	+ "item.completed",
	284	+ "item.completed",
	285	+ "turn.completed",
	286	+ ],
	287	+ );
	288	+
	289	+ const turnStarted = events[4];
	290	+ assert.equal(turnStarted?.type, "turn.started");
	291	+ if (turnStarted?.type === "turn.started") {
	292	+ assert.equal(turnStarted.turnId, turn.turnId);
	293	+ }
	294	+
	295	+ const completion = events[10];
	296	+ assert.equal(completion?.type, "turn.completed");
	297	+ if (completion?.type === "turn.completed") {
	298	+ assert.equal(completion.payload.state, "completed");
	299	+ }
	300	+ }).pipe(Effect.provide(layer));
	301	+ });
	302	+
	303	+ it.effect("bridges permission requests to request.opened/request.resolved", () => {
	304	+ const fake = new FakeCursorAcpProcess();
	305	+ const layer = makeCursorAdapterLive({
	306	+ createProcess: () => fake as never,
	307	+ });
	308	+
	309	+ return Effect.gen(function* () {
	310	+ const adapter = yield* CursorAdapter;
	311	+
	312	+ const session = yield* adapter.startSession({
	313	+ provider: "cursor",
	314	+ });
	315	+
	316	+ // consume startup events
	317	+ yield* Stream.take(adapter.streamEvents, 4).pipe(Stream.runDrain);
	318	+
	319	+ fake.emitPermissionRequest();
	320	+
	321	+ const opened = yield* Stream.runHead(adapter.streamEvents);
	322	+ assert.equal(opened._tag, "Some");
	323	+ if (opened._tag !== "Some") {
	324	+ return;
	325	+ }
	326	+ assert.equal(opened.value.type, "request.opened");
	327	+ if (opened.value.type !== "request.opened") {
	328	+ return;
	329	+ }
	330	+
	331	+ yield* adapter.respondToRequest(
	332	+ session.sessionId,
	333	+ ApprovalRequestId.makeUnsafe(opened.value.requestId),
	334	+ "acceptForSession",
	335	+ );
	336	+
	337	+ const resolved = yield* Stream.runHead(adapter.streamEvents);
	338	+ assert.equal(resolved._tag, "Some");
	339	+ if (resolved._tag !== "Some") {
	340	+ return;
	341	+ }
	342	+ assert.equal(resolved.value.type, "request.resolved");
	343	+ if (resolved.value.type !== "request.resolved") {
	344	+ return;
	345	+ }
	346	+ assert.equal(resolved.value.payload.decision, "acceptForSession");
	347	+ assert.equal(fake.lastPermissionSelection, "allow-always");
	348	+ }).pipe(Effect.provide(layer));
	349	+ });
	350	+});

apps/server/src/provider/Layers/CursorAdapter.ts+1378−0

@@ -0,0 +1,1378 @@
	1	+/**
	2	+ * CursorAdapterLive - Scoped live implementation for the Cursor ACP provider adapter.
	3	+ *
	4	+ * Spawns `agent acp` over stdio, manages JSON-RPC session lifecycle, and maps
	5	+ * ACP notifications/requests into canonical provider runtime events.
	6	+ *
	7	+ * @module CursorAdapterLive
	8	+ */
	9	+import { randomUUID } from "node:crypto";
	10	+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
	11	+import readline from "node:readline";
	12	+
	13	+import {
	14	+ ApprovalRequestId,
	15	+ EventId,
	16	+ type CanonicalItemType,
	17	+ type CanonicalRequestType,
	18	+ ProviderSessionId,
	19	+ type ProviderRuntimeEvent,
	20	+ type ProviderSession,
	21	+ ProviderThreadId,
	22	+ ProviderTurnId,
	23	+ type ProviderTurnStartResult,
	24	+} from "@t3tools/contracts";
	25	+import { DateTime, Effect, Layer, Queue, Random, Schema, Stream } from "effect";
	26	+
	27	+import {
	28	+ ProviderAdapterProcessError,
	29	+ ProviderAdapterRequestError,
	30	+ ProviderAdapterSessionClosedError,
	31	+ ProviderAdapterSessionNotFoundError,
	32	+ ProviderAdapterValidationError,
	33	+ type ProviderAdapterError,
	34	+} from "../Errors.ts";
	35	+import {
	36	+ CursorAdapter,
	37	+ type CursorAdapterShape,
	38	+ CursorAcpInitializeResult,
	39	+ CursorAcpPermissionRequest,
	40	+ CursorAcpSessionNewResult,
	41	+ CursorAcpSessionPromptResult,
	42	+ CursorAcpSessionUpdateNotification,
	43	+} from "../Services/CursorAdapter.ts";
	44	+import { makeEventNdjsonLogger } from "./EventNdjsonLogger.ts";
	45	+
	46	+const PROVIDER = "cursor" as const;
	47	+const DEFAULT_REQUEST_TIMEOUT_MS = 120_000;
	48	+
	49	+interface CursorResumeState {
	50	+ readonly acpSessionId?: string;
	51	+}
	52	+
	53	+interface PendingRequest {
	54	+ readonly method: string;
	55	+ readonly timeout: ReturnType<typeof setTimeout>;
	56	+ readonly resolve: (value: unknown) => void;
	57	+ readonly reject: (error: Error) => void;
	58	+}
	59	+
	60	+interface PendingPermission {
	61	+ readonly jsonRpcId: string \| number;
	62	+ readonly requestType: CanonicalRequestType;
	63	+ readonly options: ReadonlyArray<{ optionId: string }>;
	64	+}
	65	+
	66	+interface CursorTurnState {
	67	+ readonly turnId: ReturnType<typeof ProviderTurnId.makeUnsafe>;
	68	+ readonly assistantItemId: string;
	69	+ readonly startedToolCalls: Set<string>;
	70	+ readonly items: Array<unknown>;
	71	+}
	72	+
	73	+interface CursorSessionContext {
	74	+ session: ProviderSession;
	75	+ readonly child: ChildProcessWithoutNullStreams;
	76	+ readonly output: readline.Interface;
	77	+ readonly pending: Map<string, PendingRequest>;
	78	+ readonly pendingPermissions: Map<ApprovalRequestId, PendingPermission>;
	79	+ readonly turns: Array<{
	80	+ id: ReturnType<typeof ProviderTurnId.makeUnsafe>;
	81	+ items: Array<unknown>;
	82	+ }>;
	83	+ turnState: CursorTurnState \| undefined;
	84	+ acpSessionId: string;
	85	+ nextRpcId: number;
	86	+ stopping: boolean;
	87	+}
	88	+
	89	+export interface CursorAdapterLiveOptions {
	90	+ readonly createProcess?: (input: {
	91	+ readonly binaryPath: string;
	92	+ readonly cwd: string;
	93	+ readonly env: NodeJS.ProcessEnv;
	94	+ }) => ChildProcessWithoutNullStreams;
	95	+ readonly nativeEventLogPath?: string;
	96	+}
	97	+
	98	+function toMessage(cause: unknown, fallback: string): string {
	99	+ if (cause instanceof Error && cause.message.length > 0) {
	100	+ return cause.message;
	101	+ }
	102	+ return fallback;
	103	+}
	104	+
	105	+function toSessionError(
	106	+ sessionId: ReturnType<typeof ProviderSessionId.makeUnsafe>,
	107	+ cause: unknown,
	108	+): ProviderAdapterSessionNotFoundError \| ProviderAdapterSessionClosedError \| undefined {
	109	+ const normalized = toMessage(cause, "").toLowerCase();
	110	+ if (normalized.includes("unknown session") \|\| normalized.includes("not found")) {
	111	+ return new ProviderAdapterSessionNotFoundError({
	112	+ provider: PROVIDER,
	113	+ sessionId,
	114	+ cause,
	115	+ });
	116	+ }
	117	+ if (normalized.includes("closed")) {
	118	+ return new ProviderAdapterSessionClosedError({
	119	+ provider: PROVIDER,
	120	+ sessionId,
	121	+ cause,
	122	+ });
	123	+ }
	124	+ return undefined;
	125	+}
	126	+
	127	+function toRequestError(
	128	+ sessionId: ReturnType<typeof ProviderSessionId.makeUnsafe>,
	129	+ method: string,
	130	+ cause: unknown,
	131	+): ProviderAdapterError {
	132	+ const sessionError = toSessionError(sessionId, cause);
	133	+ if (sessionError) {
	134	+ return sessionError;
	135	+ }
	136	+ return new ProviderAdapterRequestError({
	137	+ provider: PROVIDER,
	138	+ method,
	139	+ detail: toMessage(cause, `${method} failed`),
	140	+ cause,
	141	+ });
	142	+}
	143	+
	144	+function asObject(value: unknown): Record<string, unknown> \| undefined {
	145	+ if (!value \|\| typeof value !== "object") {
	146	+ return undefined;
	147	+ }
	148	+ return value as Record<string, unknown>;
	149	+}
	150	+
	151	+function asString(value: unknown): string \| undefined {
	152	+ return typeof value === "string" ? value : undefined;
	153	+}
	154	+
	155	+function normalizeToolItemType(kind: unknown, title: unknown): CanonicalItemType {
	156	+ const normalizedKind = asString(kind)?.toLowerCase();
	157	+ const normalizedTitle = asString(title)?.toLowerCase();
	158	+
	159	+ if (normalizedKind === "execute") {
	160	+ return "command_execution";
	161	+ }
	162	+ if (normalizedKind === "edit" \|\| normalizedKind === "write") {
	163	+ return "file_change";
	164	+ }
	165	+ if (normalizedKind === "mcp") {
	166	+ return "mcp_tool_call";
	167	+ }
	168	+ if (normalizedTitle?.includes("terminal")) {
	169	+ return "command_execution";
	170	+ }
	171	+ return "dynamic_tool_call";
	172	+}
	173	+
	174	+function normalizeRequestType(toolCall: unknown): CanonicalRequestType {
	175	+ const record = asObject(toolCall);
	176	+ const kind = asString(record?.kind)?.toLowerCase();
	177	+ if (kind === "execute") {
	178	+ return "command_execution_approval";
	179	+ }
	180	+ if (kind === "edit" \|\| kind === "write") {
	181	+ return "file_change_approval";
	182	+ }
	183	+ return "unknown";
	184	+}
	185	+
	186	+function titleForItemType(itemType: CanonicalItemType): string {
	187	+ switch (itemType) {
	188	+ case "command_execution":
	189	+ return "Command run";
	190	+ case "file_change":
	191	+ return "File change";
	192	+ case "mcp_tool_call":
	193	+ return "MCP tool call";
	194	+ case "dynamic_tool_call":
	195	+ return "Tool call";
	196	+ default:
	197	+ return "Item";
	198	+ }
	199	+}
	200	+
	201	+function summarizeToolOutput(rawOutput: unknown): string \| undefined {
	202	+ const output = asObject(rawOutput);
	203	+ if (!output) return undefined;
	204	+
	205	+ const stdout = asString(output.stdout);
	206	+ if (stdout && stdout.trim().length > 0) {
	207	+ return stdout.trim().slice(0, 400);
	208	+ }
	209	+
	210	+ const summary = JSON.stringify(output);
	211	+ return summary.length > 400 ? `${summary.slice(0, 397)}...` : summary;
	212	+}
	213	+
	214	+function mapStopReasonToTurnState(stopReason: string \| undefined):
	215	+ \| "completed"
	216	+ \| "failed"
	217	+ \| "interrupted"
	218	+ \| "cancelled" {
	219	+ if (stopReason === "cancelled") return "cancelled";
	220	+ if (stopReason === "interrupted") return "interrupted";
	221	+ return "completed";
	222	+}
	223	+
	224	+function readCursorResumeState(resumeCursor: unknown): CursorResumeState \| undefined {
	225	+ if (!resumeCursor \|\| typeof resumeCursor !== "object") {
	226	+ return undefined;
	227	+ }
	228	+
	229	+ const cursor = resumeCursor as {
	230	+ acpSessionId?: unknown;
	231	+ sessionId?: unknown;
	232	+ };
	233	+
	234	+ const acpSessionId =
	235	+ typeof cursor.acpSessionId === "string"
	236	+ ? cursor.acpSessionId
	237	+ : typeof cursor.sessionId === "string"
	238	+ ? cursor.sessionId
	239	+ : undefined;
	240	+
	241	+ if (!acpSessionId) {
	242	+ return {};
	243	+ }
	244	+ return { acpSessionId };
	245	+}
	246	+
	247	+function writeCursorMessage(context: CursorSessionContext, message: unknown): void {
	248	+ if (!context.child.stdin.writable) {
	249	+ throw new Error("Cannot write to Cursor ACP stdin.");
	250	+ }
	251	+ context.child.stdin.write(`${JSON.stringify(message)}\n`);
	252	+}
	253	+
	254	+function makeCursorAdapter(options?: CursorAdapterLiveOptions) {
	255	+ return Effect.gen(function* () {
	256	+ const nativeEventLogger =
	257	+ options?.nativeEventLogPath !== undefined
	258	+ ? makeEventNdjsonLogger(options.nativeEventLogPath)
	259	+ : undefined;
	260	+
	261	+ const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
	262	+ const nextEventId = Effect.map(Random.nextUUIDv4, (id) => EventId.makeUnsafe(id));
	263	+ const makeEventStamp = () => Effect.all({ eventId: nextEventId, createdAt: nowIso });
	264	+
	265	+ const sessions = new Map<ProviderSessionId, CursorSessionContext>();
	266	+ const runtimeEventQueue = yield* Queue.unbounded<ProviderRuntimeEvent>();
	267	+
	268	+ const offerRuntimeEvent = (event: ProviderRuntimeEvent): Effect.Effect<void> =>
	269	+ Queue.offer(runtimeEventQueue, event).pipe(Effect.asVoid);
	270	+
	271	+ const spawnCursorAcp = (input: {
	272	+ readonly binaryPath: string;
	273	+ readonly cwd: string;
	274	+ readonly env: NodeJS.ProcessEnv;
	275	+ }): ChildProcessWithoutNullStreams => {
	276	+ if (options?.createProcess) {
	277	+ return options.createProcess(input);
	278	+ }
	279	+ return spawn(input.binaryPath, ["acp"], {
	280	+ cwd: input.cwd,
	281	+ env: input.env,
	282	+ stdio: ["pipe", "pipe", "pipe"],
	283	+ });
	284	+ };
	285	+
	286	+ const sendRequest = (
	287	+ context: CursorSessionContext,
	288	+ method: string,
	289	+ params: unknown,
	290	+ timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
	291	+ ): Promise<unknown> => {
	292	+ const id = context.nextRpcId;
	293	+ context.nextRpcId += 1;
	294	+
	295	+ return new Promise((resolve, reject) => {
	296	+ const timeout = setTimeout(() => {
	297	+ context.pending.delete(String(id));
	298	+ reject(new Error(`Timed out waiting for ${method}.`));
	299	+ }, timeoutMs);
	300	+
	301	+ context.pending.set(String(id), {
	302	+ method,
	303	+ timeout,
	304	+ resolve,
	305	+ reject,
	306	+ });
	307	+
	308	+ writeCursorMessage(context, {
	309	+ jsonrpc: "2.0",
	310	+ id,
	311	+ method,
	312	+ params,
	313	+ });
	314	+ });
	315	+ };
	316	+
	317	+ const resolvePendingRequest = (context: CursorSessionContext, message: Record<string, unknown>) => {
	318	+ const id = message.id;
	319	+ if (typeof id !== "string" && typeof id !== "number") {
	320	+ return;
	321	+ }
	322	+ const pending = context.pending.get(String(id));
	323	+ if (!pending) {
	324	+ return;
	325	+ }
	326	+
	327	+ clearTimeout(pending.timeout);
	328	+ context.pending.delete(String(id));
	329	+
	330	+ const error = asObject(message.error);
	331	+ if (error) {
	332	+ pending.reject(new Error(`${pending.method} failed: ${JSON.stringify(error)}`));
	333	+ return;
	334	+ }
	335	+
	336	+ pending.resolve(message.result);
	337	+ };
	338	+
	339	+ const decodePermissionRequest = Schema.decodeUnknownSync(CursorAcpPermissionRequest);
	340	+ const decodeSessionUpdateNotification = Schema.decodeUnknownSync(CursorAcpSessionUpdateNotification);
	341	+
	342	+ const emitRuntimeWarning = (
	343	+ context: CursorSessionContext,
	344	+ message: string,
	345	+ detail?: unknown,
	346	+ ): Effect.Effect<void> =>
	347	+ Effect.gen(function* () {
	348	+ const stamp = yield* makeEventStamp();
	349	+ yield* offerRuntimeEvent({
	350	+ type: "runtime.warning",
	351	+ eventId: stamp.eventId,
	352	+ provider: PROVIDER,
	353	+ sessionId: context.session.sessionId,
	354	+ createdAt: stamp.createdAt,
	355	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	356	+ ...(context.turnState ? { turnId: context.turnState.turnId } : {}),
	357	+ payload: {
	358	+ message,
	359	+ ...(detail !== undefined ? { detail } : {}),
	360	+ },
	361	+ providerRefs: {
	362	+ providerSessionId: context.session.sessionId,
	363	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	364	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	365	+ },
	366	+ });
	367	+ });
	368	+
	369	+ const completeTurn = (
	370	+ context: CursorSessionContext,
	371	+ state: "completed" \| "failed" \| "interrupted" \| "cancelled",
	372	+ errorMessage?: string,
	373	+ stopReason?: string,
	374	+ ): Effect.Effect<void> =>
	375	+ Effect.gen(function* () {
	376	+ const turnState = context.turnState;
	377	+ if (!turnState) {
	378	+ return;
	379	+ }
	380	+
	381	+ const itemStamp = yield* makeEventStamp();
	382	+ yield* offerRuntimeEvent({
	383	+ type: "item.completed",
	384	+ eventId: itemStamp.eventId,
	385	+ provider: PROVIDER,
	386	+ sessionId: context.session.sessionId,
	387	+ createdAt: itemStamp.createdAt,
	388	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	389	+ turnId: turnState.turnId,
	390	+ itemId: turnState.assistantItemId,
	391	+ payload: {
	392	+ itemType: "assistant_message",
	393	+ status: "completed",
	394	+ title: "Assistant message",
	395	+ },
	396	+ providerRefs: {
	397	+ providerSessionId: context.session.sessionId,
	398	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	399	+ providerTurnId: turnState.turnId,
	400	+ providerItemId: turnState.assistantItemId,
	401	+ },
	402	+ });
	403	+
	404	+ context.turns.push({
	405	+ id: turnState.turnId,
	406	+ items: [...turnState.items],
	407	+ });
	408	+
	409	+ const stamp = yield* makeEventStamp();
	410	+ yield* offerRuntimeEvent({
	411	+ type: "turn.completed",
	412	+ eventId: stamp.eventId,
	413	+ provider: PROVIDER,
	414	+ sessionId: context.session.sessionId,
	415	+ createdAt: stamp.createdAt,
	416	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	417	+ turnId: turnState.turnId,
	418	+ payload: {
	419	+ state,
	420	+ ...(stopReason ? { stopReason } : {}),
	421	+ ...(errorMessage ? { errorMessage } : {}),
	422	+ },
	423	+ providerRefs: {
	424	+ providerSessionId: context.session.sessionId,
	425	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	426	+ providerTurnId: turnState.turnId,
	427	+ },
	428	+ });
	429	+
	430	+ context.turnState = undefined;
	431	+ context.session = {
	432	+ ...context.session,
	433	+ status: state === "failed" ? "error" : "ready",
	434	+ activeTurnId: undefined,
	435	+ ...(errorMessage ? { lastError: errorMessage } : {}),
	436	+ updatedAt: yield* nowIso,
	437	+ };
	438	+ });
	439	+
	440	+ const handlePermissionRequest = (
	441	+ context: CursorSessionContext,
	442	+ request: unknown,
	443	+ ): Effect.Effect<void> => {
	444	+ let decoded: ReturnType<typeof decodePermissionRequest>;
	445	+ try {
	446	+ decoded = decodePermissionRequest(request);
	447	+ } catch (error) {
	448	+ return emitRuntimeWarning(
	449	+ context,
	450	+ "Failed to decode Cursor ACP permission request.",
	451	+ error,
	452	+ );
	453	+ }
	454	+
	455	+ return Effect.gen(function* () {
	456	+ const requestId = ApprovalRequestId.makeUnsafe(randomUUID());
	457	+ const requestType = normalizeRequestType(decoded.params.toolCall);
	458	+
	459	+ context.pendingPermissions.set(requestId, {
	460	+ jsonRpcId: decoded.id,
	461	+ requestType,
	462	+ options: decoded.params.options.map((entry) => ({ optionId: entry.optionId })),
	463	+ });
	464	+
	465	+ const detail = asString(asObject(decoded.params.toolCall)?.title);
	466	+ const stamp = yield* makeEventStamp();
	467	+ yield* offerRuntimeEvent({
	468	+ type: "request.opened",
	469	+ eventId: stamp.eventId,
	470	+ provider: PROVIDER,
	471	+ sessionId: context.session.sessionId,
	472	+ createdAt: stamp.createdAt,
	473	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	474	+ ...(context.turnState ? { turnId: context.turnState.turnId } : {}),
	475	+ requestId,
	476	+ payload: {
	477	+ requestType,
	478	+ ...(detail ? { detail } : {}),
	479	+ args: decoded.params,
	480	+ },
	481	+ providerRefs: {
	482	+ providerSessionId: context.session.sessionId,
	483	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	484	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	485	+ providerRequestId: String(decoded.id),
	486	+ },
	487	+ raw: {
	488	+ source: "cursor.acp.request",
	489	+ method: decoded.method,
	490	+ payload: decoded,
	491	+ },
	492	+ });
	493	+ });
	494	+ };
	495	+
	496	+ const handleSessionUpdateNotification = (
	497	+ context: CursorSessionContext,
	498	+ notification: unknown,
	499	+ ): Effect.Effect<void> => {
	500	+ let decoded: ReturnType<typeof decodeSessionUpdateNotification>;
	501	+ try {
	502	+ decoded = decodeSessionUpdateNotification(notification);
	503	+ } catch (error) {
	504	+ return emitRuntimeWarning(
	505	+ context,
	506	+ "Failed to decode Cursor ACP session/update notification.",
	507	+ error,
	508	+ );
	509	+ }
	510	+
	511	+ return Effect.gen(function* () {
	512	+ const update = decoded.params.update;
	513	+
	514	+ const base = {
	515	+ provider: PROVIDER,
	516	+ sessionId: context.session.sessionId,
	517	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	518	+ ...(context.turnState ? { turnId: context.turnState.turnId } : {}),
	519	+ providerRefs: {
	520	+ providerSessionId: context.session.sessionId,
	521	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	522	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	523	+ },
	524	+ raw: {
	525	+ source: "cursor.acp.notification" as const,
	526	+ method: decoded.method,
	527	+ messageType: update.sessionUpdate,
	528	+ payload: decoded,
	529	+ },
	530	+ };
	531	+
	532	+ switch (update.sessionUpdate) {
	533	+ case "available_commands_update": {
	534	+ const stamp = yield* makeEventStamp();
	535	+ yield* offerRuntimeEvent({
	536	+ ...base,
	537	+ type: "session.configured",
	538	+ eventId: stamp.eventId,
	539	+ createdAt: stamp.createdAt,
	540	+ payload: {
	541	+ config: {
	542	+ availableCommands: update.availableCommands,
	543	+ },
	544	+ },
	545	+ });
	546	+ return;
	547	+ }
	548	+
	549	+ case "agent_thought_chunk": {
	550	+ if (!context.turnState) return;
	551	+ if (update.content.text.length === 0) return;
	552	+ const stamp = yield* makeEventStamp();
	553	+ yield* offerRuntimeEvent({
	554	+ ...base,
	555	+ type: "content.delta",
	556	+ eventId: stamp.eventId,
	557	+ createdAt: stamp.createdAt,
	558	+ turnId: context.turnState.turnId,
	559	+ itemId: context.turnState.assistantItemId,
	560	+ payload: {
	561	+ streamKind: "reasoning_text",
	562	+ delta: update.content.text,
	563	+ },
	564	+ });
	565	+ return;
	566	+ }
	567	+
	568	+ case "agent_message_chunk": {
	569	+ if (!context.turnState) return;
	570	+ if (update.content.text.length === 0) return;
	571	+ const stamp = yield* makeEventStamp();
	572	+ yield* offerRuntimeEvent({
	573	+ ...base,
	574	+ type: "content.delta",
	575	+ eventId: stamp.eventId,
	576	+ createdAt: stamp.createdAt,
	577	+ turnId: context.turnState.turnId,
	578	+ itemId: context.turnState.assistantItemId,
	579	+ payload: {
	580	+ streamKind: "assistant_text",
	581	+ delta: update.content.text,
	582	+ },
	583	+ });
	584	+ return;
	585	+ }
	586	+
	587	+ case "tool_call": {
	588	+ if (!context.turnState) return;
	589	+ const seen = context.turnState.startedToolCalls.has(update.toolCallId);
	590	+ const itemType = normalizeToolItemType(update.kind, update.title);
	591	+ const title = update.title ?? titleForItemType(itemType);
	592	+ const detail = asString(asObject(update.rawInput)?.command);
	593	+
	594	+ if (!seen) {
	595	+ context.turnState.startedToolCalls.add(update.toolCallId);
	596	+ const stamp = yield* makeEventStamp();
	597	+ yield* offerRuntimeEvent({
	598	+ ...base,
	599	+ type: "item.started",
	600	+ eventId: stamp.eventId,
	601	+ createdAt: stamp.createdAt,
	602	+ turnId: context.turnState.turnId,
	603	+ itemId: update.toolCallId,
	604	+ payload: {
	605	+ itemType,
	606	+ status: "inProgress",
	607	+ title,
	608	+ ...(detail ? { detail } : {}),
	609	+ ...(update.rawInput !== undefined ? { data: update.rawInput } : {}),
	610	+ },
	611	+ });
	612	+ return;
	613	+ }
	614	+
	615	+ const stamp = yield* makeEventStamp();
	616	+ yield* offerRuntimeEvent({
	617	+ ...base,
	618	+ type: "item.updated",
	619	+ eventId: stamp.eventId,
	620	+ createdAt: stamp.createdAt,
	621	+ turnId: context.turnState.turnId,
	622	+ itemId: update.toolCallId,
	623	+ payload: {
	624	+ itemType,
	625	+ status: "inProgress",
	626	+ title,
	627	+ ...(detail ? { detail } : {}),
	628	+ ...(update.rawInput !== undefined ? { data: update.rawInput } : {}),
	629	+ },
	630	+ });
	631	+ return;
	632	+ }
	633	+
	634	+ case "tool_call_update": {
	635	+ if (!context.turnState) return;
	636	+ const status = update.status === "completed" ? "completed" : "inProgress";
	637	+ const stamp = yield* makeEventStamp();
	638	+ const eventType = update.status === "completed" ? "item.completed" : "item.updated";
	639	+ yield* offerRuntimeEvent({
	640	+ ...base,
	641	+ type: eventType,
	642	+ eventId: stamp.eventId,
	643	+ createdAt: stamp.createdAt,
	644	+ turnId: context.turnState.turnId,
	645	+ itemId: update.toolCallId,
	646	+ payload: {
	647	+ itemType: "command_execution",
	648	+ status,
	649	+ title: "Tool call",
	650	+ ...(summarizeToolOutput(update.rawOutput)
	651	+ ? { detail: summarizeToolOutput(update.rawOutput) }
	652	+ : {}),
	653	+ ...(update.rawOutput !== undefined ? { data: update.rawOutput } : {}),
	654	+ },
	655	+ });
	656	+ return;
	657	+ }
	658	+ }
	659	+ });
	660	+ };
	661	+
	662	+ const handleStdoutLine = (context: CursorSessionContext, line: string): void => {
	663	+ let parsed: unknown;
	664	+ try {
	665	+ parsed = JSON.parse(line);
	666	+ } catch {
	667	+ Effect.runFork(
	668	+ emitRuntimeWarning(context, "Received invalid JSON from Cursor ACP.", {
	669	+ line,
	670	+ }),
	671	+ );
	672	+ return;
	673	+ }
	674	+
	675	+ const message = asObject(parsed);
	676	+ if (!message) {
	677	+ Effect.runFork(
	678	+ emitRuntimeWarning(context, "Received non-object protocol message from Cursor ACP."),
	679	+ );
	680	+ return;
	681	+ }
	682	+
	683	+ if (nativeEventLogger) {
	684	+ const nativeMethod =
	685	+ typeof message.method === "string"
	686	+ ? message.method
	687	+ : (typeof message.id === "string" \|\| typeof message.id === "number")
	688	+ ? "cursor/acp/response"
	689	+ : "cursor/acp/message";
	690	+ const nativeKind =
	691	+ typeof message.method === "string" &&
	692	+ (typeof message.id === "string" \|\| typeof message.id === "number")
	693	+ ? "request"
	694	+ : typeof message.method === "string"
	695	+ ? "notification"
	696	+ : "session";
	697	+ nativeEventLogger.write({
	698	+ observedAt: new Date().toISOString(),
	699	+ event: {
	700	+ id: EventId.makeUnsafe(randomUUID()),
	701	+ kind: nativeKind,
	702	+ provider: PROVIDER,
	703	+ sessionId: context.session.sessionId,
	704	+ createdAt: new Date().toISOString(),
	705	+ method: nativeMethod,
	706	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	707	+ ...(context.turnState ? { turnId: context.turnState.turnId } : {}),
	708	+ payload: message,
	709	+ },
	710	+ });
	711	+ }
	712	+
	713	+ if (
	714	+ (typeof message.id === "string" \|\| typeof message.id === "number") &&
	715	+ typeof message.method === "string"
	716	+ ) {
	717	+ if (message.method === "session/request_permission") {
	718	+ Effect.runFork(handlePermissionRequest(context, message));
	719	+ return;
	720	+ }
	721	+
	722	+ writeCursorMessage(context, {
	723	+ jsonrpc: "2.0",
	724	+ id: message.id,
	725	+ error: {
	726	+ code: -32601,
	727	+ message: `Unsupported server request: ${message.method}`,
	728	+ },
	729	+ });
	730	+ return;
	731	+ }
	732	+
	733	+ if (
	734	+ (typeof message.id === "string" \|\| typeof message.id === "number") &&
	735	+ ("result" in message \|\| "error" in message)
	736	+ ) {
	737	+ resolvePendingRequest(context, message);
	738	+ return;
	739	+ }
	740	+
	741	+ if (typeof message.method === "string") {
	742	+ if (message.method === "session/update") {
	743	+ Effect.runFork(handleSessionUpdateNotification(context, message));
	744	+ return;
	745	+ }
	746	+
	747	+ Effect.runFork(
	748	+ emitRuntimeWarning(
	749	+ context,
	750	+ `Unhandled Cursor ACP notification '${message.method}'.`,
	751	+ message,
	752	+ ),
	753	+ );
	754	+ return;
	755	+ }
	756	+
	757	+ Effect.runFork(
	758	+ emitRuntimeWarning(context, "Received unrecognized protocol message from Cursor ACP.", {
	759	+ message,
	760	+ }),
	761	+ );
	762	+ };
	763	+
	764	+ const stopSessionInternal = (
	765	+ context: CursorSessionContext,
	766	+ options?: { readonly emitExitEvent?: boolean },
	767	+ ): Effect.Effect<void> =>
	768	+ Effect.gen(function* () {
	769	+ if (context.stopping) return;
	770	+ context.stopping = true;
	771	+
	772	+ for (const pending of context.pending.values()) {
	773	+ clearTimeout(pending.timeout);
	774	+ pending.reject(new Error("Cursor session stopped before request completion."));
	775	+ }
	776	+ context.pending.clear();
	777	+
	778	+ if (context.turnState) {
	779	+ yield* completeTurn(context, "interrupted", "Session stopped.", "cancelled");
	780	+ }
	781	+
	782	+ context.output.close();
	783	+ if (!context.child.killed) {
	784	+ context.child.kill();
	785	+ }
	786	+
	787	+ context.session = {
	788	+ ...context.session,
	789	+ status: "closed",
	790	+ activeTurnId: undefined,
	791	+ updatedAt: yield* nowIso,
	792	+ };
	793	+
	794	+ if (options?.emitExitEvent !== false) {
	795	+ const stamp = yield* makeEventStamp();
	796	+ yield* offerRuntimeEvent({
	797	+ type: "session.exited",
	798	+ eventId: stamp.eventId,
	799	+ provider: PROVIDER,
	800	+ sessionId: context.session.sessionId,
	801	+ createdAt: stamp.createdAt,
	802	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	803	+ payload: {
	804	+ reason: "Session stopped",
	805	+ exitKind: "graceful",
	806	+ },
	807	+ providerRefs: {
	808	+ providerSessionId: context.session.sessionId,
	809	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	810	+ },
	811	+ });
	812	+ }
	813	+
	814	+ sessions.delete(context.session.sessionId);
	815	+ });
	816	+
	817	+ const requireSession = (
	818	+ sessionId: ReturnType<typeof ProviderSessionId.makeUnsafe>,
	819	+ ): Effect.Effect<CursorSessionContext, ProviderAdapterError> => {
	820	+ const context = sessions.get(sessionId);
	821	+ if (!context) {
	822	+ return Effect.fail(
	823	+ new ProviderAdapterSessionNotFoundError({
	824	+ provider: PROVIDER,
	825	+ sessionId,
	826	+ }),
	827	+ );
	828	+ }
	829	+ if (context.stopping \|\| context.session.status === "closed") {
	830	+ return Effect.fail(
	831	+ new ProviderAdapterSessionClosedError({
	832	+ provider: PROVIDER,
	833	+ sessionId,
	834	+ }),
	835	+ );
	836	+ }
	837	+ return Effect.succeed(context);
	838	+ };
	839	+
	840	+ const startSession: CursorAdapterShape["startSession"] = (input) =>
	841	+ Effect.gen(function* () {
	842	+ if (input.provider !== undefined && input.provider !== PROVIDER) {
	843	+ return yield* new ProviderAdapterValidationError({
	844	+ provider: PROVIDER,
	845	+ operation: "startSession",
	846	+ issue: `Expected provider '${PROVIDER}' but received '${input.provider}'.`,
	847	+ });
	848	+ }
	849	+
	850	+ const startedAt = yield* nowIso;
	851	+ const sessionId = ProviderSessionId.makeUnsafe(`cursor-session-${yield* Random.nextUUIDv4}`);
	852	+ const cwd = input.cwd ?? process.cwd();
	853	+ const cursorOptions = input.providerOptions?.cursor as
	854	+ \| { binaryPath?: string }
	855	+ \| undefined;
	856	+ const binaryPath = cursorOptions?.binaryPath ?? "agent";
	857	+ const resumeState = readCursorResumeState(input.resumeCursor);
	858	+
	859	+ const child = yield* Effect.try({
	860	+ try: () =>
	861	+ spawnCursorAcp({
	862	+ binaryPath,
	863	+ cwd,
	864	+ env: process.env,
	865	+ }),
	866	+ catch: (cause) =>
	867	+ new ProviderAdapterProcessError({
	868	+ provider: PROVIDER,
	869	+ sessionId,
	870	+ detail: toMessage(cause, "Failed to spawn Cursor ACP process."),
	871	+ cause,
	872	+ }),
	873	+ });
	874	+
	875	+ const output = readline.createInterface({ input: child.stdout });
	876	+
	877	+ const session: ProviderSession = {
	878	+ sessionId,
	879	+ provider: PROVIDER,
	880	+ status: "connecting",
	881	+ ...(input.cwd ? { cwd: input.cwd } : {}),
	882	+ ...(input.model ? { model: input.model } : {}),
	883	+ createdAt: startedAt,
	884	+ updatedAt: startedAt,
	885	+ };
	886	+
	887	+ const context: CursorSessionContext = {
	888	+ session,
	889	+ child,
	890	+ output,
	891	+ pending: new Map(),
	892	+ pendingPermissions: new Map(),
	893	+ turns: [],
	894	+ turnState: undefined,
	895	+ acpSessionId: resumeState?.acpSessionId ?? "",
	896	+ nextRpcId: 1,
	897	+ stopping: false,
	898	+ };
	899	+
	900	+ output.on("line", (line) => {
	901	+ handleStdoutLine(context, line);
	902	+ });
	903	+
	904	+ child.stderr.on("data", (chunk: Buffer) => {
	905	+ const message = chunk.toString().trim();
	906	+ if (message.length === 0) {
	907	+ return;
	908	+ }
	909	+ Effect.runFork(
	910	+ emitRuntimeWarning(context, "Cursor ACP stderr output", {
	911	+ message,
	912	+ }),
	913	+ );
	914	+ });
	915	+
	916	+ child.on("error", (error) => {
	917	+ Effect.runFork(
	918	+ Effect.gen(function* () {
	919	+ const stamp = yield* makeEventStamp();
	920	+ yield* offerRuntimeEvent({
	921	+ type: "runtime.error",
	922	+ eventId: stamp.eventId,
	923	+ provider: PROVIDER,
	924	+ sessionId: context.session.sessionId,
	925	+ createdAt: stamp.createdAt,
	926	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	927	+ ...(context.turnState ? { turnId: context.turnState.turnId } : {}),
	928	+ payload: {
	929	+ message: error.message \|\| "Cursor ACP process error.",
	930	+ class: "transport_error",
	931	+ detail: error,
	932	+ },
	933	+ });
	934	+ }),
	935	+ );
	936	+ });
	937	+
	938	+ child.on("exit", (code, signal) => {
	939	+ if (context.stopping) {
	940	+ return;
	941	+ }
	942	+ Effect.runFork(
	943	+ Effect.gen(function* () {
	944	+ if (context.turnState) {
	945	+ yield* completeTurn(
	946	+ context,
	947	+ "failed",
	948	+ `Cursor ACP exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`,
	949	+ );
	950	+ }
	951	+
	952	+ const stamp = yield* makeEventStamp();
	953	+ yield* offerRuntimeEvent({
	954	+ type: "session.exited",
	955	+ eventId: stamp.eventId,
	956	+ provider: PROVIDER,
	957	+ sessionId: context.session.sessionId,
	958	+ createdAt: stamp.createdAt,
	959	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	960	+ payload: {
	961	+ reason: `Cursor ACP exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`,
	962	+ exitKind: code === 0 ? "graceful" : "error",
	963	+ recoverable: code === 0,
	964	+ },
	965	+ });
	966	+
	967	+ sessions.delete(context.session.sessionId);
	968	+ }),
	969	+ );
	970	+ });
	971	+
	972	+ sessions.set(sessionId, context);
	973	+
	974	+ const initializeResult = yield* Effect.tryPromise({
	975	+ try: async () => sendRequest(context, "initialize", {}),
	976	+ catch: (cause) => toRequestError(sessionId, "initialize", cause),
	977	+ });
	978	+ const decodedInitialize = Schema.decodeUnknownSync(CursorAcpInitializeResult)(initializeResult);
	979	+
	980	+ const initStamp = yield* makeEventStamp();
	981	+ yield* offerRuntimeEvent({
	982	+ type: "session.configured",
	983	+ eventId: initStamp.eventId,
	984	+ provider: PROVIDER,
	985	+ sessionId,
	986	+ createdAt: initStamp.createdAt,
	987	+ payload: {
	988	+ config: decodedInitialize,
	989	+ },
	990	+ providerRefs: {
	991	+ providerSessionId: sessionId,
	992	+ },
	993	+ raw: {
	994	+ source: "cursor.acp.response",
	995	+ method: "initialize",
	996	+ payload: initializeResult,
	997	+ },
	998	+ });
	999	+
	1000	+ yield* Effect.tryPromise({
	1001	+ try: async () => sendRequest(context, "authenticate", { methodId: "cursor_login" }),
	1002	+ catch: () => undefined,
	1003	+ });
	1004	+
	1005	+ const acpSessionId = yield* Effect.tryPromise({
	1006	+ try: async () => {
	1007	+ if (resumeState?.acpSessionId) {
	1008	+ await sendRequest(context, "session/load", {
	1009	+ sessionId: resumeState.acpSessionId,
	1010	+ cwd,
	1011	+ mcpServers: [],
	1012	+ });
	1013	+ return resumeState.acpSessionId;
	1014	+ }
	1015	+
	1016	+ const sessionNewParams: {
	1017	+ cwd: string;
	1018	+ mcpServers: [];
	1019	+ model?: string;
	1020	+ } = {
	1021	+ cwd,
	1022	+ mcpServers: [],
	1023	+ };
	1024	+ if (input.model) {
	1025	+ sessionNewParams.model = input.model;
	1026	+ }
	1027	+ const result = await sendRequest(context, "session/new", sessionNewParams);
	1028	+ const decoded = Schema.decodeUnknownSync(CursorAcpSessionNewResult)(result);
	1029	+ return decoded.sessionId;
	1030	+ },
	1031	+ catch: (cause) => toRequestError(sessionId, "session/new\|session/load", cause),
	1032	+ });
	1033	+
	1034	+ const threadId = ProviderThreadId.makeUnsafe(acpSessionId);
	1035	+ context.acpSessionId = acpSessionId;
	1036	+ context.session = {
	1037	+ ...context.session,
	1038	+ status: "ready",
	1039	+ threadId,
	1040	+ resumeCursor: {
	1041	+ acpSessionId,
	1042	+ },
	1043	+ updatedAt: yield* nowIso,
	1044	+ };
	1045	+
	1046	+ const sessionStartedStamp = yield* makeEventStamp();
	1047	+ yield* offerRuntimeEvent({
	1048	+ type: "session.started",
	1049	+ eventId: sessionStartedStamp.eventId,
	1050	+ provider: PROVIDER,
	1051	+ sessionId,
	1052	+ createdAt: sessionStartedStamp.createdAt,
	1053	+ threadId,
	1054	+ payload: resumeState?.acpSessionId ? { resume: input.resumeCursor } : {},
	1055	+ providerRefs: {
	1056	+ providerSessionId: sessionId,
	1057	+ providerThreadId: threadId,
	1058	+ },
	1059	+ });
	1060	+
	1061	+ const threadStartedStamp = yield* makeEventStamp();
	1062	+ yield* offerRuntimeEvent({
	1063	+ type: "thread.started",
	1064	+ eventId: threadStartedStamp.eventId,
	1065	+ provider: PROVIDER,
	1066	+ sessionId,
	1067	+ createdAt: threadStartedStamp.createdAt,
	1068	+ threadId,
	1069	+ payload: {
	1070	+ providerThreadId: threadId,
	1071	+ },
	1072	+ providerRefs: {
	1073	+ providerSessionId: sessionId,
	1074	+ providerThreadId: threadId,
	1075	+ },
	1076	+ });
	1077	+
	1078	+ const readyStamp = yield* makeEventStamp();
	1079	+ yield* offerRuntimeEvent({
	1080	+ type: "session.state.changed",
	1081	+ eventId: readyStamp.eventId,
	1082	+ provider: PROVIDER,
	1083	+ sessionId,
	1084	+ createdAt: readyStamp.createdAt,
	1085	+ threadId,
	1086	+ payload: {
	1087	+ state: "ready",
	1088	+ },
	1089	+ providerRefs: {
	1090	+ providerSessionId: sessionId,
	1091	+ providerThreadId: threadId,
	1092	+ },
	1093	+ });
	1094	+
	1095	+ return {
	1096	+ ...context.session,
	1097	+ };
	1098	+ });
	1099	+
	1100	+ const sendTurn: CursorAdapterShape["sendTurn"] = (input) =>
	1101	+ Effect.gen(function* () {
	1102	+ const context = yield* requireSession(input.sessionId);
	1103	+
	1104	+ if (context.turnState) {
	1105	+ return yield* new ProviderAdapterValidationError({
	1106	+ provider: PROVIDER,
	1107	+ operation: "sendTurn",
	1108	+ issue: `Session '${input.sessionId}' already has an active turn '${context.turnState.turnId}'.`,
	1109	+ });
	1110	+ }
	1111	+
	1112	+ const turnId = ProviderTurnId.makeUnsafe(`cursor-turn-${yield* Random.nextUUIDv4}`);
	1113	+ const turnState: CursorTurnState = {
	1114	+ turnId,
	1115	+ assistantItemId: `cursor-assistant-${yield* Random.nextUUIDv4}`,
	1116	+ startedToolCalls: new Set(),
	1117	+ items: [],
	1118	+ };
	1119	+
	1120	+ context.turnState = turnState;
	1121	+ context.session = {
	1122	+ ...context.session,
	1123	+ status: "running",
	1124	+ activeTurnId: turnId,
	1125	+ updatedAt: yield* nowIso,
	1126	+ };
	1127	+
	1128	+ const startedStamp = yield* makeEventStamp();
	1129	+ yield* offerRuntimeEvent({
	1130	+ type: "turn.started",
	1131	+ eventId: startedStamp.eventId,
	1132	+ provider: PROVIDER,
	1133	+ sessionId: context.session.sessionId,
	1134	+ createdAt: startedStamp.createdAt,
	1135	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	1136	+ turnId,
	1137	+ payload: {
	1138	+ ...(input.model ? { model: input.model } : {}),
	1139	+ ...(input.effort ? { effort: input.effort } : {}),
	1140	+ },
	1141	+ providerRefs: {
	1142	+ providerSessionId: context.session.sessionId,
	1143	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	1144	+ providerTurnId: turnId,
	1145	+ },
	1146	+ });
	1147	+
	1148	+ const promptText = input.input?.trim();
	1149	+ if (!promptText \|\| promptText.length === 0) {
	1150	+ return yield* new ProviderAdapterValidationError({
	1151	+ provider: PROVIDER,
	1152	+ operation: "sendTurn",
	1153	+ issue: "Turn input must be non-empty.",
	1154	+ });
	1155	+ }
	1156	+
	1157	+ const promptResultRaw = yield* Effect.tryPromise({
	1158	+ try: async () =>
	1159	+ sendRequest(context, "session/prompt", {
	1160	+ sessionId: context.acpSessionId,
	1161	+ prompt: [{ type: "text", text: promptText }],
	1162	+ }),
	1163	+ catch: (cause) => toRequestError(input.sessionId, "session/prompt", cause),
	1164	+ });
	1165	+
	1166	+ const promptResult = Schema.decodeUnknownSync(CursorAcpSessionPromptResult)(promptResultRaw);
	1167	+ const turnStateValue = mapStopReasonToTurnState(promptResult.stopReason);
	1168	+ yield* completeTurn(
	1169	+ context,
	1170	+ turnStateValue,
	1171	+ turnStateValue === "failed" ? "Cursor prompt failed." : undefined,
	1172	+ promptResult.stopReason,
	1173	+ );
	1174	+
	1175	+ context.session = {
	1176	+ ...context.session,
	1177	+ status: "ready",
	1178	+ activeTurnId: undefined,
	1179	+ updatedAt: yield* nowIso,
	1180	+ resumeCursor: {
	1181	+ acpSessionId: context.acpSessionId,
	1182	+ },
	1183	+ };
	1184	+
	1185	+ return {
	1186	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	1187	+ turnId,
	1188	+ ...(context.session.resumeCursor !== undefined
	1189	+ ? { resumeCursor: context.session.resumeCursor }
	1190	+ : {}),
	1191	+ } satisfies ProviderTurnStartResult;
	1192	+ });
	1193	+
	1194	+ const interruptTurn: CursorAdapterShape["interruptTurn"] = (sessionId, _turnId) =>
	1195	+ Effect.gen(function* () {
	1196	+ const context = yield* requireSession(sessionId);
	1197	+ if (!context.turnState) {
	1198	+ return;
	1199	+ }
	1200	+
	1201	+ const cancelResult = yield* Effect.tryPromise({
	1202	+ try: async () => sendRequest(context, "session/cancel", { sessionId: context.acpSessionId }, 15_000),
	1203	+ catch: (cause) => cause,
	1204	+ });
	1205	+
	1206	+ if (cancelResult instanceof Error) {
	1207	+ yield* emitRuntimeWarning(
	1208	+ context,
	1209	+ "Cursor ACP session/cancel is unavailable; marking turn as interrupted.",
	1210	+ cancelResult,
	1211	+ );
	1212	+ }
	1213	+
	1214	+ yield* completeTurn(context, "interrupted", "Turn interrupted by user.", "cancelled");
	1215	+ });
	1216	+
	1217	+ const readThread: CursorAdapterShape["readThread"] = (sessionId) =>
	1218	+ Effect.gen(function* () {
	1219	+ const context = yield* requireSession(sessionId);
	1220	+ return {
	1221	+ threadId: ProviderThreadId.makeUnsafe(context.acpSessionId),
	1222	+ turns: context.turns.map((turn) => ({
	1223	+ id: turn.id,
	1224	+ items: [...turn.items],
	1225	+ })),
	1226	+ };
	1227	+ });
	1228	+
	1229	+ const rollbackThread: CursorAdapterShape["rollbackThread"] = (sessionId, _numTurns) =>
	1230	+ Effect.fail(
	1231	+ new ProviderAdapterRequestError({
	1232	+ provider: PROVIDER,
	1233	+ method: "thread/rollback",
	1234	+ detail: `Cursor ACP does not support thread rollback for session '${sessionId}'.`,
	1235	+ }),
	1236	+ );
	1237	+
	1238	+ const respondToRequest: CursorAdapterShape["respondToRequest"] = (
	1239	+ sessionId,
	1240	+ requestId,
	1241	+ decision,
	1242	+ ) =>
	1243	+ Effect.gen(function* () {
	1244	+ const context = yield* requireSession(sessionId);
	1245	+ const pending = context.pendingPermissions.get(requestId);
	1246	+ if (!pending) {
	1247	+ return yield* new ProviderAdapterRequestError({
	1248	+ provider: PROVIDER,
	1249	+ method: "session/request_permission",
	1250	+ detail: `Unknown pending permission request: ${requestId}`,
	1251	+ });
	1252	+ }
	1253	+
	1254	+ const allowAlways = pending.options.find((option) => option.optionId === "allow-always");
	1255	+ const allowOnce = pending.options.find((option) => option.optionId === "allow-once");
	1256	+ const rejectOnce = pending.options.find((option) => option.optionId === "reject-once");
	1257	+
	1258	+ const optionId =
	1259	+ decision === "acceptForSession"
	1260	+ ? allowAlways?.optionId ?? allowOnce?.optionId
	1261	+ : decision === "accept"
	1262	+ ? allowOnce?.optionId ?? allowAlways?.optionId
	1263	+ : rejectOnce?.optionId ?? pending.options[0]?.optionId;
	1264	+
	1265	+ if (!optionId) {
	1266	+ return yield* new ProviderAdapterRequestError({
	1267	+ provider: PROVIDER,
	1268	+ method: "session/request_permission",
	1269	+ detail: `No selectable permission options for request: ${requestId}`,
	1270	+ });
	1271	+ }
	1272	+
	1273	+ writeCursorMessage(context, {
	1274	+ jsonrpc: "2.0",
	1275	+ id: pending.jsonRpcId,
	1276	+ result: {
	1277	+ outcome: {
	1278	+ outcome: "selected",
	1279	+ optionId,
	1280	+ },
	1281	+ },
	1282	+ });
	1283	+
	1284	+ context.pendingPermissions.delete(requestId);
	1285	+
	1286	+ const stamp = yield* makeEventStamp();
	1287	+ yield* offerRuntimeEvent({
	1288	+ type: "request.resolved",
	1289	+ eventId: stamp.eventId,
	1290	+ provider: PROVIDER,
	1291	+ sessionId: context.session.sessionId,
	1292	+ createdAt: stamp.createdAt,
	1293	+ ...(context.session.threadId ? { threadId: context.session.threadId } : {}),
	1294	+ ...(context.turnState ? { turnId: context.turnState.turnId } : {}),
	1295	+ requestId,
	1296	+ payload: {
	1297	+ requestType: pending.requestType,
	1298	+ decision,
	1299	+ resolution: {
	1300	+ optionId,
	1301	+ },
	1302	+ },
	1303	+ providerRefs: {
	1304	+ providerSessionId: context.session.sessionId,
	1305	+ ...(context.session.threadId ? { providerThreadId: context.session.threadId } : {}),
	1306	+ ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}),
	1307	+ providerRequestId: requestId,
	1308	+ },
	1309	+ raw: {
	1310	+ source: "cursor.acp.response",
	1311	+ method: "session/request_permission",
	1312	+ payload: {
	1313	+ optionId,
	1314	+ },
	1315	+ },
	1316	+ });
	1317	+ });
	1318	+
	1319	+ const stopSession: CursorAdapterShape["stopSession"] = (sessionId) =>
	1320	+ Effect.gen(function* () {
	1321	+ const context = yield* requireSession(sessionId);
	1322	+ yield* stopSessionInternal(context, {
	1323	+ emitExitEvent: true,
	1324	+ });
	1325	+ });
	1326	+
	1327	+ const listSessions: CursorAdapterShape["listSessions"] = () =>
	1328	+ Effect.sync(() => Array.from(sessions.values(), ({ session }) => ({ ...session })));
	1329	+
	1330	+ const hasSession: CursorAdapterShape["hasSession"] = (sessionId) =>
	1331	+ Effect.sync(() => {
	1332	+ const context = sessions.get(sessionId);
	1333	+ return context !== undefined && !context.stopping;
	1334	+ });
	1335	+
	1336	+ const stopAll: CursorAdapterShape["stopAll"] = () =>
	1337	+ Effect.forEach(
	1338	+ sessions,
	1339	+ ([, context]) =>
	1340	+ stopSessionInternal(context, {
	1341	+ emitExitEvent: true,
	1342	+ }),
	1343	+ { discard: true },
	1344	+ );
	1345	+
	1346	+ yield* Effect.addFinalizer(() =>
	1347	+ Effect.forEach(
	1348	+ sessions,
	1349	+ ([, context]) =>
	1350	+ stopSessionInternal(context, {
	1351	+ emitExitEvent: false,
	1352	+ }),
	1353	+ { discard: true },
	1354	+ ).pipe(Effect.tap(() => Queue.shutdown(runtimeEventQueue))),
	1355	+ );
	1356	+
	1357	+ return {
	1358	+ provider: PROVIDER,
	1359	+ startSession,
	1360	+ sendTurn,
	1361	+ interruptTurn,
	1362	+ readThread,
	1363	+ rollbackThread,
	1364	+ respondToRequest,
	1365	+ stopSession,
	1366	+ listSessions,
	1367	+ hasSession,
	1368	+ stopAll,
	1369	+ streamEvents: Stream.fromQueue(runtimeEventQueue),
	1370	+ } satisfies CursorAdapterShape;
	1371	+ });
	1372	+}
	1373	+
	1374	+export const CursorAdapterLive = Layer.effect(CursorAdapter, makeCursorAdapter());
	1375	+
	1376	+export function makeCursorAdapterLive(options?: CursorAdapterLiveOptions) {
	1377	+ return Layer.effect(CursorAdapter, makeCursorAdapter(options));
	1378	+}

apps/server/src/provider/Layers/ProviderAdapterRegistry.test.ts+20−1

@@ -6,6 +6,7 @@ import { Effect, Layer, Stream } from "effect"; · 5 unmodified lines
6	6
7	7	import { ClaudeCodeAdapter, ClaudeCodeAdapterShape } from "../Services/ClaudeCodeAdapter.ts";
8	8	import { CodexAdapter, CodexAdapterShape } from "../Services/CodexAdapter.ts";
	9	+import { CursorAdapter, CursorAdapterShape } from "../Services/CursorAdapter.ts";
9	10	import { ProviderAdapterRegistry } from "../Services/ProviderAdapterRegistry.ts";
10	11	import { ProviderAdapterRegistryLive } from "./ProviderAdapterRegistry.ts";
11	12	import { ProviderUnsupportedError } from "../Errors.ts";
@@ -41,6 +42,21 @@ const fakeClaudeAdapter: ClaudeCodeAdapterShape = { · 29 unmodified lines
41	42	streamEvents: Stream.empty,
42	43	};
43	44
	45	+const fakeCursorAdapter: CursorAdapterShape = {
	46	+ provider: "cursor",
	47	+ startSession: vi.fn(),
	48	+ sendTurn: vi.fn(),
	49	+ interruptTurn: vi.fn(),
	50	+ respondToRequest: vi.fn(),
	51	+ stopSession: vi.fn(),
	52	+ listSessions: vi.fn(),
	53	+ hasSession: vi.fn(),
	54	+ readThread: vi.fn(),
	55	+ rollbackThread: vi.fn(),
	56	+ stopAll: vi.fn(),
	57	+ streamEvents: Stream.empty,
	58	+};
	59	+
44	60	const layer = it.layer(
45	61	Layer.mergeAll(
46	62	Layer.provide(
@@ -48,6 +64,7 @@ const layer = it.layer( · 1 unmodified line
48	64	Layer.mergeAll(
49	65	Layer.succeed(CodexAdapter, fakeCodexAdapter),
50	66	Layer.succeed(ClaudeCodeAdapter, fakeClaudeAdapter),
	67	+ Layer.succeed(CursorAdapter, fakeCursorAdapter),
51	68	),
52	69	),
53	70	NodeServices.layer,
@@ -60,11 +77,13 @@ layer("ProviderAdapterRegistryLive", (it) => { · 6 unmodified lines
60	77	const registry = yield* ProviderAdapterRegistry;
61	78	const codex = yield* registry.getByProvider("codex");
62	79	const claude = yield* registry.getByProvider("claudeCode");
	80	+ const cursor = yield* registry.getByProvider("cursor");
63	81	assert.equal(codex, fakeCodexAdapter);
64	82	assert.equal(claude, fakeClaudeAdapter);
	83	+ assert.equal(cursor, fakeCursorAdapter);
65	84
66	85	const providers = yield* registry.listProviders();
67		− assert.deepEqual(providers, ["codex", "claudeCode"]);
	86	+ assert.deepEqual(providers, ["codex", "claudeCode", "cursor"]);
68	87	}),
69	88	);
70	89

apps/server/src/provider/Layers/ProviderAdapterRegistry.ts+2−1

@@ -17,6 +17,7 @@ import { · 16 unmodified lines
17	17	} from "../Services/ProviderAdapterRegistry.ts";
18	18	import { ClaudeCodeAdapter } from "../Services/ClaudeCodeAdapter.ts";
19	19	import { CodexAdapter } from "../Services/CodexAdapter.ts";
	20	+import { CursorAdapter } from "../Services/CursorAdapter.ts";
20	21
21	22	export interface ProviderAdapterRegistryLiveOptions {
22	23	readonly adapters?: ReadonlyArray<ProviderAdapterShape<ProviderAdapterError>>;
@@ -27,7 +28,7 @@ const makeProviderAdapterRegistry = (options?: ProviderAdapterRegistryLiveOption · 4 unmodified lines
27	28	const adapters =
28	29	options?.adapters !== undefined
29	30	? options.adapters
30		− : [yield* CodexAdapter, yield* ClaudeCodeAdapter];
	31	+ : [yield* CodexAdapter, yield* ClaudeCodeAdapter, yield* CursorAdapter];
31	32	const byProvider = new Map(adapters.map((adapter) => [adapter.provider, adapter]));
32	33
33	34	const getByProvider: ProviderAdapterRegistryShape["getByProvider"] = (provider) => {

apps/server/src/provider/Services/CursorAdapter.test.ts+97−98

@@ -1,131 +1,130 @@
1	1	import { Schema } from "effect";
2	2	import { describe, expect, it } from "vitest";
3	3
4		−import { CursorCliStreamEvent } from "./CursorAdapter.ts";
	4	+import {
	5	+ CursorAcpPermissionRequest,
	6	+ CursorAcpSessionPromptResult,
	7	+ CursorAcpSessionUpdateNotification,
	8	+} from "./CursorAdapter.ts";
5	9
6		−describe("CursorCliStreamEvent", () => {
7		− it("decodes system/init events", () => {
8		− const decoded = Schema.decodeUnknownSync(CursorCliStreamEvent)({
9		− type: "system",
10		− subtype: "init",
11		− session_id: "sess-1",
12		− apiKeySource: "login",
13		− cwd: "/tmp/project",
14		− model: "Auto",
15		− permissionMode: "default",
	10	+describe("Cursor ACP schemas", () => {
	11	+ it("decodes session/update thought and message chunks", () => {
	12	+ const thought = Schema.decodeUnknownSync(CursorAcpSessionUpdateNotification)({
	13	+ jsonrpc: "2.0",
	14	+ method: "session/update",
	15	+ params: {
	16	+ sessionId: "sess-1",
	17	+ update: {
	18	+ sessionUpdate: "agent_thought_chunk",
	19	+ content: {
	20	+ type: "text",
	21	+ text: "thinking",
	22	+ },
	23	+ },
	24	+ },
16	25	});
17	26
18		− expect(decoded.type).toBe("system");
19		− if (decoded.type !== "system") {
20		− return;
21		− }
22		− expect(decoded.subtype).toBe("init");
23		− expect(decoded.session_id).toBe("sess-1");
24		− });
	27	+ expect(thought.params.update.sessionUpdate).toBe("agent_thought_chunk");
25	28
26		− it("decodes thinking delta/completed events", () => {
27		− const delta = Schema.decodeUnknownSync(CursorCliStreamEvent)({
28		− type: "thinking",
29		− subtype: "delta",
30		− text: "draft",
31		− session_id: "sess-1",
32		− timestamp_ms: 123,
	29	+ const message = Schema.decodeUnknownSync(CursorAcpSessionUpdateNotification)({
	30	+ jsonrpc: "2.0",
	31	+ method: "session/update",
	32	+ params: {
	33	+ sessionId: "sess-1",
	34	+ update: {
	35	+ sessionUpdate: "agent_message_chunk",
	36	+ content: {
	37	+ type: "text",
	38	+ text: "hello",
	39	+ },
	40	+ },
	41	+ },
33	42	});
34	43
35		− expect(delta.type).toBe("thinking");
36		− if (delta.type !== "thinking") {
37		− return;
38		− }
39		− expect(delta.subtype).toBe("delta");
	44	+ expect(message.params.update.sessionUpdate).toBe("agent_message_chunk");
	45	+ });
40	46
41		− const completed = Schema.decodeUnknownSync(CursorCliStreamEvent)({
42		− type: "thinking",
43		− subtype: "completed",
44		− session_id: "sess-1",
	47	+ it("decodes tool call lifecycle updates", () => {
	48	+ const started = Schema.decodeUnknownSync(CursorAcpSessionUpdateNotification)({
	49	+ jsonrpc: "2.0",
	50	+ method: "session/update",
	51	+ params: {
	52	+ sessionId: "sess-1",
	53	+ update: {
	54	+ sessionUpdate: "tool_call",
	55	+ toolCallId: "tool-1",
	56	+ title: "Terminal",
	57	+ kind: "execute",
	58	+ status: "pending",
	59	+ rawInput: { command: "pwd" },
	60	+ },
	61	+ },
45	62	});
46	63
47		− expect(completed.type).toBe("thinking");
48		− if (completed.type !== "thinking") {
49		− return;
50		− }
51		− expect(completed.subtype).toBe("completed");
52		− });
	64	+ expect(started.params.update.sessionUpdate).toBe("tool_call");
53	65
54		− it("decodes tool_call completed events with rejected results", () => {
55		− const decoded = Schema.decodeUnknownSync(CursorCliStreamEvent)({
56		− type: "tool_call",
57		− subtype: "completed",
58		− call_id: "tool-1\nline-2",
59		− session_id: "sess-1",
60		− tool_call: {
61		− shellToolCall: {
62		− args: {
63		− command: "rm -rf /tmp/nope",
64		− },
65		− result: {
66		− rejected: {
67		− reason: "approval denied",
68		− },
	66	+ const completed = Schema.decodeUnknownSync(CursorAcpSessionUpdateNotification)({
	67	+ jsonrpc: "2.0",
	68	+ method: "session/update",
	69	+ params: {
	70	+ sessionId: "sess-1",
	71	+ update: {
	72	+ sessionUpdate: "tool_call_update",
	73	+ toolCallId: "tool-1",
	74	+ status: "completed",
	75	+ rawOutput: {
	76	+ exitCode: 0,
	77	+ stdout: "ok",
	78	+ stderr: "",
69	79	},
70	80	},
71	81	},
72	82	});
73	83
74		− expect(decoded.type).toBe("tool_call");
75		− if (decoded.type !== "tool_call") {
76		− return;
77		− }
78		− expect(decoded.subtype).toBe("completed");
79		− expect(decoded.call_id).toContain("\n");
	84	+ expect(completed.params.update.sessionUpdate).toBe("tool_call_update");
80	85	});
81	86
82		− it("decodes result success events with usage payload", () => {
83		− const decoded = Schema.decodeUnknownSync(CursorCliStreamEvent)({
84		− type: "result",
85		− subtype: "success",
86		− duration_ms: 100,
87		− duration_api_ms: 90,
88		− is_error: false,
89		− result: "OK",
90		− session_id: "sess-1",
91		− request_id: "req-1",
92		− usage: {
93		− inputTokens: 10,
94		− outputTokens: 5,
95		− cacheReadTokens: 2,
96		− cacheWriteTokens: 1,
	87	+ it("decodes permission requests", () => {
	88	+ const decoded = Schema.decodeUnknownSync(CursorAcpPermissionRequest)({
	89	+ jsonrpc: "2.0",
	90	+ id: 9,
	91	+ method: "session/request_permission",
	92	+ params: {
	93	+ sessionId: "sess-1",
	94	+ toolCall: {
	95	+ toolCallId: "tool-1",
	96	+ kind: "execute",
	97	+ },
	98	+ options: [
	99	+ { optionId: "allow-once", name: "Allow once", kind: "allow_once" },
	100	+ { optionId: "reject-once", name: "Reject", kind: "reject_once" },
	101	+ ],
97	102	},
98	103	});
99	104
100		− expect(decoded.type).toBe("result");
101		− if (decoded.type !== "result") {
102		− return;
103		− }
104		− expect(decoded.subtype).toBe("success");
105		− expect(decoded.is_error).toBe(false);
	105	+ expect(decoded.method).toBe("session/request_permission");
	106	+ expect(decoded.params.options).toHaveLength(2);
106	107	});
107	108
108		− it("decodes connection/retry lifecycle events", () => {
109		− const reconnecting = Schema.decodeUnknownSync(CursorCliStreamEvent)({
110		− type: "connection",
111		− subtype: "reconnecting",
112		− session_id: "sess-1",
	109	+ it("decodes prompt completion result payload", () => {
	110	+ const decoded = Schema.decodeUnknownSync(CursorAcpSessionPromptResult)({
	111	+ stopReason: "end_turn",
113	112	});
114		− expect(reconnecting.type).toBe("connection");
115	113
116		− const retry = Schema.decodeUnknownSync(CursorCliStreamEvent)({
117		− type: "retry",
118		− subtype: "resuming",
119		− session_id: "sess-1",
120		− });
121		− expect(retry.type).toBe("retry");
	114	+ expect(decoded.stopReason).toBe("end_turn");
122	115	});
123	116
124		− it("rejects unsupported stream event types", () => {
	117	+ it("rejects unsupported update types", () => {
125	118	expect(() =>
126		− Schema.decodeUnknownSync(CursorCliStreamEvent)({
127		− type: "bogus",
128		− session_id: "sess-1",
	119	+ Schema.decodeUnknownSync(CursorAcpSessionUpdateNotification)({
	120	+ jsonrpc: "2.0",
	121	+ method: "session/update",
	122	+ params: {
	123	+ sessionId: "sess-1",
	124	+ update: {
	125	+ sessionUpdate: "unknown_update",
	126	+ },
	127	+ },
129	128	}),
130	129	).toThrow();
131	130	});

apps/server/src/provider/Services/CursorAdapter.ts+74−178

@@ -1,11 +1,7 @@
1	1	/**
2		− * CursorAdapter - Cursor CLI implementation of the generic provider adapter contract.
	2	+ * CursorAdapter - Cursor ACP implementation of the generic provider adapter contract.
3	3	*
4		− * This service will own Cursor CLI (`agent`) process / stream-json semantics and emit
5		− * canonical provider runtime events via the shared provider adapter contract.
6		− *
7		− * This file intentionally defines raw Cursor stream-json schemas up front so the future
8		− * layer implementation can decode/validate NDJSON lines in a single place.
	4	+ * Defines ACP JSON-RPC schemas used by the Cursor adapter layer.
9	5	*
10	6	* @module CursorAdapter
11	7	*/
@@ -14,201 +10,101 @@ import { Schema, ServiceMap } from "effect"; · 2 unmodified lines
14	10	import type { ProviderAdapterError } from "../Errors.ts";
15	11	import type { ProviderAdapterShape } from "./ProviderAdapter.ts";
16	12
17		−export const CursorCliSessionId = Schema.String.check(Schema.isNonEmpty());
18		−export type CursorCliSessionId = typeof CursorCliSessionId.Type;
	13	+export const CursorAcpJsonRpcId = Schema.Union([Schema.String, Schema.Int]);
	14	+export type CursorAcpJsonRpcId = typeof CursorAcpJsonRpcId.Type;
19	15
20		−export const CursorCliTextContentPart = Schema.Struct({
	16	+export const CursorAcpTextContent = Schema.Struct({
21	17	type: Schema.Literal("text"),
22	18	text: Schema.String,
23	19	});
24		−export type CursorCliTextContentPart = typeof CursorCliTextContentPart.Type;
	20	+export type CursorAcpTextContent = typeof CursorAcpTextContent.Type;
25	21
26		−export const CursorCliContentPart = Schema.Union([
27		− CursorCliTextContentPart,
	22	+export const CursorAcpSessionUpdate = Schema.Union([
	23	+ Schema.Struct({
	24	+ sessionUpdate: Schema.Literal("available_commands_update"),
	25	+ availableCommands: Schema.Array(
	26	+ Schema.Struct({
	27	+ name: Schema.String,
	28	+ description: Schema.optional(Schema.String),
	29	+ }),
	30	+ ),
	31	+ }),
28	32	Schema.Struct({
29		− type: Schema.String,
	33	+ sessionUpdate: Schema.Literal("agent_thought_chunk"),
	34	+ content: CursorAcpTextContent,
	35	+ }),
	36	+ Schema.Struct({
	37	+ sessionUpdate: Schema.Literal("agent_message_chunk"),
	38	+ content: CursorAcpTextContent,
	39	+ }),
	40	+ Schema.Struct({
	41	+ sessionUpdate: Schema.Literal("tool_call"),
	42	+ toolCallId: Schema.String,
	43	+ title: Schema.optional(Schema.String),
	44	+ kind: Schema.optional(Schema.String),
	45	+ status: Schema.optional(Schema.String),
	46	+ rawInput: Schema.optional(Schema.Unknown),
	47	+ }),
	48	+ Schema.Struct({
	49	+ sessionUpdate: Schema.Literal("tool_call_update"),
	50	+ toolCallId: Schema.String,
	51	+ status: Schema.String,
	52	+ rawOutput: Schema.optional(Schema.Unknown),
30	53	}),
31	54	]);
32		−export type CursorCliContentPart = typeof CursorCliContentPart.Type;
33		−
34		−export const CursorCliUserMessage = Schema.Struct({
35		− role: Schema.Literal("user"),
36		− content: Schema.Array(CursorCliContentPart),
37		−});
38		−export type CursorCliUserMessage = typeof CursorCliUserMessage.Type;
39		−
40		−export const CursorCliAssistantMessage = Schema.Struct({
41		− role: Schema.Literal("assistant"),
42		− content: Schema.Array(CursorCliContentPart),
43		−});
44		−export type CursorCliAssistantMessage = typeof CursorCliAssistantMessage.Type;
45		−
46		−export const CursorCliToolCallResult = Schema.Struct({
47		− success: Schema.optional(Schema.Unknown),
48		− failure: Schema.optional(Schema.Unknown),
49		− rejected: Schema.optional(Schema.Unknown),
50		−});
51		−export type CursorCliToolCallResult = typeof CursorCliToolCallResult.Type;
52		−
53		−export const CursorCliToolCallEntry = Schema.Struct({
54		− args: Schema.optional(Schema.Unknown),
55		− result: Schema.optional(CursorCliToolCallResult),
56		−});
57		−export type CursorCliToolCallEntry = typeof CursorCliToolCallEntry.Type;
58		−
59		−export const CursorCliFunctionToolCall = Schema.Struct({
60		− name: Schema.String,
61		− arguments: Schema.String,
62		− result: Schema.optional(CursorCliToolCallResult),
63		−});
64		−export type CursorCliFunctionToolCall = typeof CursorCliFunctionToolCall.Type;
65		−
66		−export const CursorCliToolCallPayload = Schema.Struct({
67		− readToolCall: Schema.optional(CursorCliToolCallEntry),
68		− writeToolCall: Schema.optional(CursorCliToolCallEntry),
69		− editToolCall: Schema.optional(CursorCliToolCallEntry),
70		− shellToolCall: Schema.optional(CursorCliToolCallEntry),
71		− grepToolCall: Schema.optional(CursorCliToolCallEntry),
72		− globToolCall: Schema.optional(CursorCliToolCallEntry),
73		− function: Schema.optional(CursorCliFunctionToolCall),
74		−});
75		−export type CursorCliToolCallPayload = typeof CursorCliToolCallPayload.Type;
76		−
77		−export const CursorCliTokenUsage = Schema.Struct({
78		− inputTokens: Schema.optional(Schema.Number),
79		− outputTokens: Schema.optional(Schema.Number),
80		− cacheReadTokens: Schema.optional(Schema.Number),
81		− cacheWriteTokens: Schema.optional(Schema.Number),
82		−});
83		−export type CursorCliTokenUsage = typeof CursorCliTokenUsage.Type;
84		−
85		−const CursorCliTimestampMs = {
86		− timestamp_ms: Schema.optional(Schema.Number),
87		−} as const;
88		−
89		−export const CursorCliSystemInitEvent = Schema.Struct({
90		− type: Schema.Literal("system"),
91		− subtype: Schema.Literal("init"),
92		− session_id: CursorCliSessionId,
93		− apiKeySource: Schema.optional(Schema.String),
94		− cwd: Schema.optional(Schema.String),
95		− model: Schema.optional(Schema.String),
96		− permissionMode: Schema.optional(Schema.String),
97		− ...CursorCliTimestampMs,
98		−});
99		−export type CursorCliSystemInitEvent = typeof CursorCliSystemInitEvent.Type;
100		−
101		−export const CursorCliUserEvent = Schema.Struct({
102		− type: Schema.Literal("user"),
103		− message: CursorCliUserMessage,
104		− session_id: CursorCliSessionId,
105		− ...CursorCliTimestampMs,
106		−});
107		−export type CursorCliUserEvent = typeof CursorCliUserEvent.Type;
108		−
109		−export const CursorCliAssistantEvent = Schema.Struct({
110		− type: Schema.Literal("assistant"),
111		− message: CursorCliAssistantMessage,
112		− session_id: CursorCliSessionId,
113		− ...CursorCliTimestampMs,
114		−});
115		−export type CursorCliAssistantEvent = typeof CursorCliAssistantEvent.Type;
116		−
117		−export const CursorCliThinkingDeltaEvent = Schema.Struct({
118		− type: Schema.Literal("thinking"),
119		− subtype: Schema.Literal("delta"),
120		− text: Schema.String,
121		− session_id: CursorCliSessionId,
122		− ...CursorCliTimestampMs,
123		−});
124		−export type CursorCliThinkingDeltaEvent = typeof CursorCliThinkingDeltaEvent.Type;
125		−
126		−export const CursorCliThinkingCompletedEvent = Schema.Struct({
127		− type: Schema.Literal("thinking"),
128		− subtype: Schema.Literal("completed"),
129		− session_id: CursorCliSessionId,
130		− ...CursorCliTimestampMs,
	55	+export type CursorAcpSessionUpdate = typeof CursorAcpSessionUpdate.Type;
	56	+
	57	+export const CursorAcpSessionUpdateNotification = Schema.Struct({
	58	+ jsonrpc: Schema.optional(Schema.Literal("2.0")),
	59	+ method: Schema.Literal("session/update"),
	60	+ params: Schema.Struct({
	61	+ sessionId: Schema.String,
	62	+ update: CursorAcpSessionUpdate,
	63	+ }),
131	64	});
132		−export type CursorCliThinkingCompletedEvent = typeof CursorCliThinkingCompletedEvent.Type;
	65	+export type CursorAcpSessionUpdateNotification = typeof CursorAcpSessionUpdateNotification.Type;
133	66
134		−export const CursorCliToolCallStartedEvent = Schema.Struct({
135		− type: Schema.Literal("tool_call"),
136		− subtype: Schema.Literal("started"),
137		− call_id: Schema.String,
138		− tool_call: CursorCliToolCallPayload,
139		− session_id: CursorCliSessionId,
140		− ...CursorCliTimestampMs,
	67	+export const CursorAcpPermissionOption = Schema.Struct({
	68	+ optionId: Schema.String,
	69	+ name: Schema.optional(Schema.String),
	70	+ kind: Schema.optional(Schema.String),
141	71	});
142		−export type CursorCliToolCallStartedEvent = typeof CursorCliToolCallStartedEvent.Type;
	72	+export type CursorAcpPermissionOption = typeof CursorAcpPermissionOption.Type;
143	73
144		−export const CursorCliToolCallCompletedEvent = Schema.Struct({
145		− type: Schema.Literal("tool_call"),
146		− subtype: Schema.Literal("completed"),
147		− call_id: Schema.String,
148		− tool_call: CursorCliToolCallPayload,
149		− session_id: CursorCliSessionId,
150		− ...CursorCliTimestampMs,
	74	+export const CursorAcpPermissionRequest = Schema.Struct({
	75	+ jsonrpc: Schema.optional(Schema.Literal("2.0")),
	76	+ id: CursorAcpJsonRpcId,
	77	+ method: Schema.Literal("session/request_permission"),
	78	+ params: Schema.Struct({
	79	+ sessionId: Schema.String,
	80	+ toolCall: Schema.optional(Schema.Unknown),
	81	+ options: Schema.Array(CursorAcpPermissionOption),
	82	+ }),
151	83	});
152		−export type CursorCliToolCallCompletedEvent = typeof CursorCliToolCallCompletedEvent.Type;
	84	+export type CursorAcpPermissionRequest = typeof CursorAcpPermissionRequest.Type;
153	85
154		−export const CursorCliResultSuccessEvent = Schema.Struct({
155		− type: Schema.Literal("result"),
156		− subtype: Schema.Literal("success"),
157		− duration_ms: Schema.Number,
158		− duration_api_ms: Schema.optional(Schema.Number),
159		− is_error: Schema.Boolean,
160		− result: Schema.String,
161		− session_id: CursorCliSessionId,
162		− request_id: Schema.optional(Schema.String),
163		− usage: Schema.optional(CursorCliTokenUsage),
164		− ...CursorCliTimestampMs,
	86	+export const CursorAcpInitializeResult = Schema.Struct({
	87	+ protocolVersion: Schema.optional(Schema.Int),
	88	+ agentCapabilities: Schema.optional(Schema.Unknown),
	89	+ authMethods: Schema.optional(Schema.Array(Schema.Unknown)),
165	90	});
166		−export type CursorCliResultSuccessEvent = typeof CursorCliResultSuccessEvent.Type;
	91	+export type CursorAcpInitializeResult = typeof CursorAcpInitializeResult.Type;
167	92
168		−export const CursorCliConnectionEvent = Schema.Struct({
169		− type: Schema.Literal("connection"),
170		− subtype: Schema.Literals(["reconnecting", "reconnected"]),
171		− session_id: Schema.optional(CursorCliSessionId),
172		− ...CursorCliTimestampMs,
	93	+export const CursorAcpSessionNewResult = Schema.Struct({
	94	+ sessionId: Schema.String,
	95	+ modes: Schema.optional(Schema.Unknown),
173	96	});
174		−export type CursorCliConnectionEvent = typeof CursorCliConnectionEvent.Type;
	97	+export type CursorAcpSessionNewResult = typeof CursorAcpSessionNewResult.Type;
175	98
176		−export const CursorCliRetryEvent = Schema.Struct({
177		− type: Schema.Literal("retry"),
178		− subtype: Schema.Literals(["starting", "resuming"]),
179		− session_id: Schema.optional(CursorCliSessionId),
180		− ...CursorCliTimestampMs,
	99	+export const CursorAcpSessionPromptResult = Schema.Struct({
	100	+ stopReason: Schema.optional(Schema.String),
181	101	});
182		−export type CursorCliRetryEvent = typeof CursorCliRetryEvent.Type;
183		−
184		−export const CursorCliStreamEvent = Schema.Union([
185		− CursorCliSystemInitEvent,
186		− CursorCliUserEvent,
187		− CursorCliAssistantEvent,
188		− CursorCliThinkingDeltaEvent,
189		− CursorCliThinkingCompletedEvent,
190		− CursorCliToolCallStartedEvent,
191		− CursorCliToolCallCompletedEvent,
192		− CursorCliResultSuccessEvent,
193		− CursorCliConnectionEvent,
194		− CursorCliRetryEvent,
195		−]);
196		−export type CursorCliStreamEvent = typeof CursorCliStreamEvent.Type;
	102	+export type CursorAcpSessionPromptResult = typeof CursorAcpSessionPromptResult.Type;
197	103
198		−/**
199		− * CursorAdapterShape - Service API for the Cursor provider adapter.
200		− *
201		− * `provider` is intentionally narrowed to `"cursor"` here. Until contracts add
202		− * Cursor to `ProviderKind`, this shape is defined via `Omit<...,"provider">`.
203		− */
204		−export interface CursorAdapterShape
205		− extends Omit<ProviderAdapterShape<ProviderAdapterError>, "provider"> {
	104	+export interface CursorAdapterShape extends ProviderAdapterShape<ProviderAdapterError> {
206	105	readonly provider: "cursor";
207	106	}
208	107
209		−/**
210		− * CursorAdapter - Service tag for Cursor provider adapter operations.
211		− */
212	108	export class CursorAdapter extends ServiceMap.Service<CursorAdapter, CursorAdapterShape>()(
213	109	"t3/provider/Services/CursorAdapter",
214	110	) {}

apps/server/src/serverLayers.ts+5−1

@@ -20,6 +20,7 @@ import { ProviderRuntimeIngestionLive } from "./orchestration/Layers/ProviderRun · 19 unmodified lines
20	20	import { ProviderUnsupportedError } from "./provider/Errors";
21	21	import { makeClaudeCodeAdapterLive } from "./provider/Layers/ClaudeCodeAdapter";
22	22	import { makeCodexAdapterLive } from "./provider/Layers/CodexAdapter";
	23	+import { makeCursorAdapterLive } from "./provider/Layers/CursorAdapter";
23	24	import { ProviderAdapterRegistryLive } from "./provider/Layers/ProviderAdapterRegistry";
24	25	import { makeProviderServiceLive } from "./provider/Layers/ProviderService";
25	26	import { ProviderSessionDirectoryLive } from "./provider/Layers/ProviderSessionDirectory";
@@ -60,8 +61,11 @@ export function makeServerProviderLayer(): Layer.Layer< · 34 unmodified lines
60	61	const claudeAdapterLayer = makeClaudeCodeAdapterLive({
61	62	nativeEventLogPath: path.join(providerLogsDir, "provider-native.ndjson"),
62	63	});
	64	+ const cursorAdapterLayer = makeCursorAdapterLive({
	65	+ nativeEventLogPath: path.join(providerLogsDir, "provider-native.ndjson"),
	66	+ });
63	67	const adapterRegistryLayer = ProviderAdapterRegistryLive.pipe(
64		− Layer.provide(Layer.mergeAll(codexAdapterLayer, claudeAdapterLayer)),
	68	+ Layer.provide(Layer.mergeAll(codexAdapterLayer, claudeAdapterLayer, cursorAdapterLayer)),
65	69	Layer.provideMerge(providerSessionDirectoryLayer),
66	70	);
67	71	return makeProviderServiceLive(

packages/contracts/src/provider.test.ts+6−0

@@ -52,11 +52,17 @@ describe("ProviderSessionStartInput", () => { · 51 unmodified lines
52	52	provider: "cursor",
53	53	cwd: "/tmp/workspace",
54	54	model: "composer-1.5",
	55	+ providerOptions: {
	56	+ cursor: {
	57	+ binaryPath: "/usr/local/bin/agent",
	58	+ },
	59	+ },
55	60	approvalPolicy: "on-request",
56	61	sandboxMode: "workspace-write",
57	62	});
58	63	expect(parsed.provider).toBe("cursor");
59	64	expect(parsed.model).toBe("composer-1.5");
	65	+ expect(parsed.providerOptions?.cursor?.binaryPath).toBe("/usr/local/bin/agent");
60	66	expect(parsed.approvalPolicy).toBe("on-request");
61	67	expect(parsed.sandboxMode).toBe("workspace-write");
62	68	});

packages/contracts/src/provider.ts+6−0

@@ -62,9 +62,15 @@ export const ClaudeCodeProviderStartOptions = Schema.Struct({ · 61 unmodified lines
62	62	});
63	63	export type ClaudeCodeProviderStartOptions = typeof ClaudeCodeProviderStartOptions.Type;
64	64
	65	+export const CursorProviderStartOptions = Schema.Struct({
	66	+ binaryPath: Schema.optional(TrimmedNonEmptyStringSchema),
	67	+});
	68	+export type CursorProviderStartOptions = typeof CursorProviderStartOptions.Type;
	69	+
65	70	export const ProviderStartOptions = Schema.Struct({
66	71	codex: Schema.optional(CodexProviderStartOptions),
67	72	claudeCode: Schema.optional(ClaudeCodeProviderStartOptions),
	73	+ cursor: Schema.optional(CursorProviderStartOptions),
68	74	});
69	75	export type ProviderStartOptions = typeof ProviderStartOptions.Type;
70	76

packages/contracts/src/providerRuntime.ts+526−9

@@ -9,6 +9,7 @@ import { · 8 unmodified lines
9	9	RuntimeItemId,
10	10	RuntimeRequestId,
11	11	RuntimeSessionId,
	12	+ RuntimeTaskId,
12	13	ThreadId,
13	14	TrimmedNonEmptyString,
14	15	TurnId,
@@ -25,6 +26,9 @@ export const RuntimeEventRawSource = Schema.Literals([ · 10 unmodified lines
25	26	"claude.sdk.message",
26	27	"claude.sdk.permission",
27	28	"codex.sdk.thread-event",
	29	+ "cursor.acp.notification",
	30	+ "cursor.acp.request",
	31	+ "cursor.acp.response",
28	32	]);
29	33	export type RuntimeEventRawSource = typeof RuntimeEventRawSource.Type;
30	34
@@ -48,6 +52,26 @@ export const ProviderRefs = Schema.Struct({ · 17 unmodified lines
48	52	});
49	53	export type ProviderRefs = typeof ProviderRefs.Type;
50	54
	55	+export const RuntimeSessionState = Schema.Literals([
	56	+ "starting",
	57	+ "ready",
	58	+ "running",
	59	+ "waiting",
	60	+ "stopped",
	61	+ "error",
	62	+]);
	63	+export type RuntimeSessionState = typeof RuntimeSessionState.Type;
	64	+
	65	+export const RuntimeThreadState = Schema.Literals([
	66	+ "active",
	67	+ "idle",
	68	+ "archived",
	69	+ "closed",
	70	+ "compacted",
	71	+ "error",
	72	+]);
	73	+export type RuntimeThreadState = typeof RuntimeThreadState.Type;
	74	+
51	75	export const RuntimeTurnState = Schema.Literals([
52	76	"completed",
53	77	"failed",
@@ -94,6 +118,12 @@ export const CanonicalItemType = Schema.Literals([ · 40 unmodified lines
94	118	"file_change",
95	119	"mcp_tool_call",
96	120	"dynamic_tool_call",
	121	+ "collab_agent_tool_call",
	122	+ "web_search",
	123	+ "image_view",
	124	+ "review_entered",
	125	+ "review_exited",
	126	+ "context_compaction",
97	127	"error",
98	128	"unknown",
99	129	]);
@@ -106,17 +136,30 @@ export const CanonicalRequestType = Schema.Literals([ · 6 unmodified lines
106	136	"exec_command_approval",
107	137	"tool_user_input",
108	138	"dynamic_tool_call",
	139	+ "auth_tokens_refresh",
109	140	"unknown",
110	141	]);
111	142	export type CanonicalRequestType = typeof CanonicalRequestType.Type;
112	143
113	144	export const ProviderRuntimeEventType = Schema.Literals([
114	145	"session.started",
	146	+ "session.configured",
	147	+ "session.state.changed",
115	148	"session.exited",
116	149	"thread.started",
	150	+ "thread.state.changed",
	151	+ "thread.metadata.updated",
	152	+ "thread.token-usage.updated",
	153	+ "thread.realtime.started",
	154	+ "thread.realtime.item-added",
	155	+ "thread.realtime.audio.delta",
	156	+ "thread.realtime.error",
	157	+ "thread.realtime.closed",
117	158	"turn.started",
118	159	"turn.completed",
	160	+ "turn.aborted",
119	161	"turn.plan.updated",
	162	+ "turn.diff.updated",
120	163	"item.started",
121	164	"item.updated",
122	165	"item.completed",
@@ -125,17 +168,46 @@ export const ProviderRuntimeEventType = Schema.Literals([ · 2 unmodified lines
125	168	"request.resolved",
126	169	"user-input.requested",
127	170	"user-input.resolved",
	171	+ "task.started",
	172	+ "task.progress",
	173	+ "task.completed",
	174	+ "hook.started",
	175	+ "hook.progress",
	176	+ "hook.completed",
	177	+ "tool.progress",
	178	+ "tool.summary",
	179	+ "auth.status",
	180	+ "account.updated",
	181	+ "account.rate-limits.updated",
	182	+ "mcp.status.updated",
	183	+ "mcp.oauth.completed",
	184	+ "model.rerouted",
	185	+ "config.warning",
	186	+ "deprecation.notice",
	187	+ "files.persisted",
128	188	"runtime.warning",
129	189	"runtime.error",
130	190	]);
131	191	export type ProviderRuntimeEventType = typeof ProviderRuntimeEventType.Type;
132	192
133	193	export const SessionStartedType = Schema.Literal("session.started");
	194	+export const SessionConfiguredType = Schema.Literal("session.configured");
	195	+export const SessionStateChangedType = Schema.Literal("session.state.changed");
134	196	export const SessionExitedType = Schema.Literal("session.exited");
135	197	export const ThreadStartedType = Schema.Literal("thread.started");
	198	+export const ThreadStateChangedType = Schema.Literal("thread.state.changed");
	199	+export const ThreadMetadataUpdatedType = Schema.Literal("thread.metadata.updated");
	200	+export const ThreadTokenUsageUpdatedType = Schema.Literal("thread.token-usage.updated");
	201	+export const ThreadRealtimeStartedType = Schema.Literal("thread.realtime.started");
	202	+export const ThreadRealtimeItemAddedType = Schema.Literal("thread.realtime.item-added");
	203	+export const ThreadRealtimeAudioDeltaType = Schema.Literal("thread.realtime.audio.delta");
	204	+export const ThreadRealtimeErrorType = Schema.Literal("thread.realtime.error");
	205	+export const ThreadRealtimeClosedType = Schema.Literal("thread.realtime.closed");
136	206	export const TurnStartedType = Schema.Literal("turn.started");
137	207	export const TurnCompletedType = Schema.Literal("turn.completed");
	208	+export const TurnAbortedType = Schema.Literal("turn.aborted");
138	209	export const TurnPlanUpdatedType = Schema.Literal("turn.plan.updated");
	210	+export const TurnDiffUpdatedType = Schema.Literal("turn.diff.updated");
139	211	export const ItemStartedType = Schema.Literal("item.started");
140	212	export const ItemUpdatedType = Schema.Literal("item.updated");
141	213	export const ItemCompletedType = Schema.Literal("item.completed");
@@ -144,6 +216,23 @@ export const RequestOpenedType = Schema.Literal("request.opened"); · 2 unmodified lines
144	216	export const RequestResolvedType = Schema.Literal("request.resolved");
145	217	export const UserInputRequestedType = Schema.Literal("user-input.requested");
146	218	export const UserInputResolvedType = Schema.Literal("user-input.resolved");
	219	+export const TaskStartedType = Schema.Literal("task.started");
	220	+export const TaskProgressType = Schema.Literal("task.progress");
	221	+export const TaskCompletedType = Schema.Literal("task.completed");
	222	+export const HookStartedType = Schema.Literal("hook.started");
	223	+export const HookProgressType = Schema.Literal("hook.progress");
	224	+export const HookCompletedType = Schema.Literal("hook.completed");
	225	+export const ToolProgressType = Schema.Literal("tool.progress");
	226	+export const ToolSummaryType = Schema.Literal("tool.summary");
	227	+export const AuthStatusType = Schema.Literal("auth.status");
	228	+export const AccountUpdatedType = Schema.Literal("account.updated");
	229	+export const AccountRateLimitsUpdatedType = Schema.Literal("account.rate-limits.updated");
	230	+export const McpStatusUpdatedType = Schema.Literal("mcp.status.updated");
	231	+export const McpOauthCompletedType = Schema.Literal("mcp.oauth.completed");
	232	+export const ModelReroutedType = Schema.Literal("model.rerouted");
	233	+export const ConfigWarningType = Schema.Literal("config.warning");
	234	+export const DeprecationNoticeType = Schema.Literal("deprecation.notice");
	235	+export const FilesPersistedType = Schema.Literal("files.persisted");
147	236	export const RuntimeWarningType = Schema.Literal("runtime.warning");
148	237	export const RuntimeErrorType = Schema.Literal("runtime.error");
149	238
@@ -167,6 +256,18 @@ export const SessionStartedPayload = Schema.Struct({ · 17 unmodified lines
167	256	});
168	257	export type SessionStartedPayload = typeof SessionStartedPayload.Type;
169	258
	259	+export const SessionConfiguredPayload = Schema.Struct({
	260	+ config: UnknownRecordSchema,
	261	+});
	262	+export type SessionConfiguredPayload = typeof SessionConfiguredPayload.Type;
	263	+
	264	+export const SessionStateChangedPayload = Schema.Struct({
	265	+ state: RuntimeSessionState,
	266	+ reason: Schema.optional(TrimmedNonEmptyStringSchema),
	267	+ detail: Schema.optional(Schema.Unknown),
	268	+});
	269	+export type SessionStateChangedPayload = typeof SessionStateChangedPayload.Type;
	270	+
170	271	export const SessionExitedPayload = Schema.Struct({
171	272	reason: Schema.optional(TrimmedNonEmptyStringSchema),
172	273	recoverable: Schema.optional(Schema.Boolean),
@@ -179,6 +280,48 @@ export const ThreadStartedPayload = Schema.Struct({ · 6 unmodified lines
179	280	});
180	281	export type ThreadStartedPayload = typeof ThreadStartedPayload.Type;
181	282
	283	+export const ThreadStateChangedPayload = Schema.Struct({
	284	+ state: RuntimeThreadState,
	285	+ detail: Schema.optional(Schema.Unknown),
	286	+});
	287	+export type ThreadStateChangedPayload = typeof ThreadStateChangedPayload.Type;
	288	+
	289	+export const ThreadMetadataUpdatedPayload = Schema.Struct({
	290	+ name: Schema.optional(TrimmedNonEmptyStringSchema),
	291	+ metadata: Schema.optional(UnknownRecordSchema),
	292	+});
	293	+export type ThreadMetadataUpdatedPayload = typeof ThreadMetadataUpdatedPayload.Type;
	294	+
	295	+export const ThreadTokenUsageUpdatedPayload = Schema.Struct({
	296	+ usage: Schema.Unknown,
	297	+});
	298	+export type ThreadTokenUsageUpdatedPayload = typeof ThreadTokenUsageUpdatedPayload.Type;
	299	+
	300	+export const ThreadRealtimeStartedPayload = Schema.Struct({
	301	+ realtimeSessionId: Schema.optional(TrimmedNonEmptyStringSchema),
	302	+});
	303	+export type ThreadRealtimeStartedPayload = typeof ThreadRealtimeStartedPayload.Type;
	304	+
	305	+export const ThreadRealtimeItemAddedPayload = Schema.Struct({
	306	+ item: Schema.Unknown,
	307	+});
	308	+export type ThreadRealtimeItemAddedPayload = typeof ThreadRealtimeItemAddedPayload.Type;
	309	+
	310	+export const ThreadRealtimeAudioDeltaPayload = Schema.Struct({
	311	+ audio: Schema.Unknown,
	312	+});
	313	+export type ThreadRealtimeAudioDeltaPayload = typeof ThreadRealtimeAudioDeltaPayload.Type;
	314	+
	315	+export const ThreadRealtimeErrorPayload = Schema.Struct({
	316	+ message: TrimmedNonEmptyStringSchema,
	317	+});
	318	+export type ThreadRealtimeErrorPayload = typeof ThreadRealtimeErrorPayload.Type;
	319	+
	320	+export const ThreadRealtimeClosedPayload = Schema.Struct({
	321	+ reason: Schema.optional(TrimmedNonEmptyStringSchema),
	322	+});
	323	+export type ThreadRealtimeClosedPayload = typeof ThreadRealtimeClosedPayload.Type;
	324	+
182	325	export const TurnStartedPayload = Schema.Struct({
183	326	model: Schema.optional(TrimmedNonEmptyStringSchema),
184	327	effort: Schema.optional(TrimmedNonEmptyStringSchema),
@@ -195,6 +338,11 @@ export const TurnCompletedPayload = Schema.Struct({ · 10 unmodified lines
195	338	});
196	339	export type TurnCompletedPayload = typeof TurnCompletedPayload.Type;
197	340
	341	+export const TurnAbortedPayload = Schema.Struct({
	342	+ reason: TrimmedNonEmptyStringSchema,
	343	+});
	344	+export type TurnAbortedPayload = typeof TurnAbortedPayload.Type;
	345	+
198	346	export const RuntimePlanStep = Schema.Struct({
199	347	step: TrimmedNonEmptyStringSchema,
200	348	status: RuntimePlanStepStatus,
@@ -207,6 +355,11 @@ export const TurnPlanUpdatedPayload = Schema.Struct({ · 6 unmodified lines
207	355	});
208	356	export type TurnPlanUpdatedPayload = typeof TurnPlanUpdatedPayload.Type;
209	357
	358	+export const TurnDiffUpdatedPayload = Schema.Struct({
	359	+ unifiedDiff: Schema.String,
	360	+});
	361	+export type TurnDiffUpdatedPayload = typeof TurnDiffUpdatedPayload.Type;
	362	+
210	363	export const ItemLifecyclePayload = Schema.Struct({
211	364	itemType: CanonicalItemType,
212	365	status: Schema.optional(RuntimeItemStatus),
@@ -262,6 +415,136 @@ export const UserInputResolvedPayload = Schema.Struct({ · 49 unmodified lines
262	415	});
263	416	export type UserInputResolvedPayload = typeof UserInputResolvedPayload.Type;
264	417
	418	+export const TaskStartedPayload = Schema.Struct({
	419	+ taskId: RuntimeTaskId,
	420	+ description: Schema.optional(TrimmedNonEmptyStringSchema),
	421	+ taskType: Schema.optional(TrimmedNonEmptyStringSchema),
	422	+});
	423	+export type TaskStartedPayload = typeof TaskStartedPayload.Type;
	424	+
	425	+export const TaskProgressPayload = Schema.Struct({
	426	+ taskId: RuntimeTaskId,
	427	+ description: TrimmedNonEmptyStringSchema,
	428	+ usage: Schema.optional(Schema.Unknown),
	429	+ lastToolName: Schema.optional(TrimmedNonEmptyStringSchema),
	430	+});
	431	+export type TaskProgressPayload = typeof TaskProgressPayload.Type;
	432	+
	433	+export const TaskCompletedPayload = Schema.Struct({
	434	+ taskId: RuntimeTaskId,
	435	+ status: Schema.Literals(["completed", "failed", "stopped"]),
	436	+ summary: Schema.optional(TrimmedNonEmptyStringSchema),
	437	+ usage: Schema.optional(Schema.Unknown),
	438	+});
	439	+export type TaskCompletedPayload = typeof TaskCompletedPayload.Type;
	440	+
	441	+export const HookStartedPayload = Schema.Struct({
	442	+ hookId: TrimmedNonEmptyStringSchema,
	443	+ hookName: TrimmedNonEmptyStringSchema,
	444	+ hookEvent: TrimmedNonEmptyStringSchema,
	445	+});
	446	+export type HookStartedPayload = typeof HookStartedPayload.Type;
	447	+
	448	+export const HookProgressPayload = Schema.Struct({
	449	+ hookId: TrimmedNonEmptyStringSchema,
	450	+ output: Schema.optional(Schema.String),
	451	+ stdout: Schema.optional(Schema.String),
	452	+ stderr: Schema.optional(Schema.String),
	453	+});
	454	+export type HookProgressPayload = typeof HookProgressPayload.Type;
	455	+
	456	+export const HookCompletedPayload = Schema.Struct({
	457	+ hookId: TrimmedNonEmptyStringSchema,
	458	+ outcome: Schema.Literals(["success", "error", "cancelled"]),
	459	+ output: Schema.optional(Schema.String),
	460	+ stdout: Schema.optional(Schema.String),
	461	+ stderr: Schema.optional(Schema.String),
	462	+ exitCode: Schema.optional(Schema.Int),
	463	+});
	464	+export type HookCompletedPayload = typeof HookCompletedPayload.Type;
	465	+
	466	+export const ToolProgressPayload = Schema.Struct({
	467	+ toolUseId: Schema.optional(TrimmedNonEmptyStringSchema),
	468	+ toolName: Schema.optional(TrimmedNonEmptyStringSchema),
	469	+ summary: Schema.optional(TrimmedNonEmptyStringSchema),
	470	+ elapsedSeconds: Schema.optional(Schema.Number),
	471	+});
	472	+export type ToolProgressPayload = typeof ToolProgressPayload.Type;
	473	+
	474	+export const ToolSummaryPayload = Schema.Struct({
	475	+ summary: TrimmedNonEmptyStringSchema,
	476	+ precedingToolUseIds: Schema.optional(Schema.Array(TrimmedNonEmptyStringSchema)),
	477	+});
	478	+export type ToolSummaryPayload = typeof ToolSummaryPayload.Type;
	479	+
	480	+export const AuthStatusPayload = Schema.Struct({
	481	+ isAuthenticating: Schema.optional(Schema.Boolean),
	482	+ output: Schema.optional(Schema.Array(Schema.String)),
	483	+ error: Schema.optional(TrimmedNonEmptyStringSchema),
	484	+});
	485	+export type AuthStatusPayload = typeof AuthStatusPayload.Type;
	486	+
	487	+export const AccountUpdatedPayload = Schema.Struct({
	488	+ account: Schema.Unknown,
	489	+});
	490	+export type AccountUpdatedPayload = typeof AccountUpdatedPayload.Type;
	491	+
	492	+export const AccountRateLimitsUpdatedPayload = Schema.Struct({
	493	+ rateLimits: Schema.Unknown,
	494	+});
	495	+export type AccountRateLimitsUpdatedPayload = typeof AccountRateLimitsUpdatedPayload.Type;
	496	+
	497	+export const McpStatusUpdatedPayload = Schema.Struct({
	498	+ status: Schema.Unknown,
	499	+});
	500	+export type McpStatusUpdatedPayload = typeof McpStatusUpdatedPayload.Type;
	501	+
	502	+export const McpOauthCompletedPayload = Schema.Struct({
	503	+ success: Schema.Boolean,
	504	+ name: Schema.optional(TrimmedNonEmptyStringSchema),
	505	+ error: Schema.optional(TrimmedNonEmptyStringSchema),
	506	+});
	507	+export type McpOauthCompletedPayload = typeof McpOauthCompletedPayload.Type;
	508	+
	509	+export const ModelReroutedPayload = Schema.Struct({
	510	+ fromModel: TrimmedNonEmptyStringSchema,
	511	+ toModel: TrimmedNonEmptyStringSchema,
	512	+ reason: TrimmedNonEmptyStringSchema,
	513	+});
	514	+export type ModelReroutedPayload = typeof ModelReroutedPayload.Type;
	515	+
	516	+export const ConfigWarningPayload = Schema.Struct({
	517	+ summary: TrimmedNonEmptyStringSchema,
	518	+ details: Schema.optional(TrimmedNonEmptyStringSchema),
	519	+ path: Schema.optional(TrimmedNonEmptyStringSchema),
	520	+ range: Schema.optional(Schema.Unknown),
	521	+});
	522	+export type ConfigWarningPayload = typeof ConfigWarningPayload.Type;
	523	+
	524	+export const DeprecationNoticePayload = Schema.Struct({
	525	+ summary: TrimmedNonEmptyStringSchema,
	526	+ details: Schema.optional(TrimmedNonEmptyStringSchema),
	527	+});
	528	+export type DeprecationNoticePayload = typeof DeprecationNoticePayload.Type;
	529	+
	530	+export const FilesPersistedPayload = Schema.Struct({
	531	+ files: Schema.Array(
	532	+ Schema.Struct({
	533	+ filename: TrimmedNonEmptyStringSchema,
	534	+ fileId: TrimmedNonEmptyStringSchema,
	535	+ }),
	536	+ ),
	537	+ failed: Schema.optional(
	538	+ Schema.Array(
	539	+ Schema.Struct({
	540	+ filename: TrimmedNonEmptyStringSchema,
	541	+ error: TrimmedNonEmptyStringSchema,
	542	+ }),
	543	+ ),
	544	+ ),
	545	+});
	546	+export type FilesPersistedPayload = typeof FilesPersistedPayload.Type;
	547	+
265	548	export const RuntimeWarningPayload = Schema.Struct({
266	549	message: TrimmedNonEmptyStringSchema,
267	550	detail: Schema.optional(Schema.Unknown),
@@ -282,6 +565,20 @@ export const ProviderRuntimeSessionStartedEvent = Schema.Struct({ · 14 unmodified lines
282	565	});
283	566	export type ProviderRuntimeSessionStartedEvent = typeof ProviderRuntimeSessionStartedEvent.Type;
284	567
	568	+export const ProviderRuntimeSessionConfiguredEvent = Schema.Struct({
	569	+ ...ProviderRuntimeEventBase.fields,
	570	+ type: SessionConfiguredType,
	571	+ payload: SessionConfiguredPayload,
	572	+});
	573	+export type ProviderRuntimeSessionConfiguredEvent = typeof ProviderRuntimeSessionConfiguredEvent.Type;
	574	+
	575	+export const ProviderRuntimeSessionStateChangedEvent = Schema.Struct({
	576	+ ...ProviderRuntimeEventBase.fields,
	577	+ type: SessionStateChangedType,
	578	+ payload: SessionStateChangedPayload,
	579	+});
	580	+export type ProviderRuntimeSessionStateChangedEvent = typeof ProviderRuntimeSessionStateChangedEvent.Type;
	581	+
285	582	export const ProviderRuntimeSessionExitedEvent = Schema.Struct({
286	583	...ProviderRuntimeEventBase.fields,
287	584	type: SessionExitedType,
@@ -296,6 +593,68 @@ export const ProviderRuntimeThreadStartedEvent = Schema.Struct({ · 8 unmodified lines
296	593	});
297	594	export type ProviderRuntimeThreadStartedEvent = typeof ProviderRuntimeThreadStartedEvent.Type;
298	595
	596	+export const ProviderRuntimeThreadStateChangedEvent = Schema.Struct({
	597	+ ...ProviderRuntimeEventBase.fields,
	598	+ type: ThreadStateChangedType,
	599	+ payload: ThreadStateChangedPayload,
	600	+});
	601	+export type ProviderRuntimeThreadStateChangedEvent = typeof ProviderRuntimeThreadStateChangedEvent.Type;
	602	+
	603	+export const ProviderRuntimeThreadMetadataUpdatedEvent = Schema.Struct({
	604	+ ...ProviderRuntimeEventBase.fields,
	605	+ type: ThreadMetadataUpdatedType,
	606	+ payload: ThreadMetadataUpdatedPayload,
	607	+});
	608	+export type ProviderRuntimeThreadMetadataUpdatedEvent = typeof ProviderRuntimeThreadMetadataUpdatedEvent.Type;
	609	+
	610	+export const ProviderRuntimeThreadTokenUsageUpdatedEvent = Schema.Struct({
	611	+ ...ProviderRuntimeEventBase.fields,
	612	+ type: ThreadTokenUsageUpdatedType,
	613	+ payload: ThreadTokenUsageUpdatedPayload,
	614	+});
	615	+export type ProviderRuntimeThreadTokenUsageUpdatedEvent =
	616	+ typeof ProviderRuntimeThreadTokenUsageUpdatedEvent.Type;
	617	+
	618	+export const ProviderRuntimeThreadRealtimeStartedEvent = Schema.Struct({
	619	+ ...ProviderRuntimeEventBase.fields,
	620	+ type: ThreadRealtimeStartedType,
	621	+ payload: ThreadRealtimeStartedPayload,
	622	+});
	623	+export type ProviderRuntimeThreadRealtimeStartedEvent =
	624	+ typeof ProviderRuntimeThreadRealtimeStartedEvent.Type;
	625	+
	626	+export const ProviderRuntimeThreadRealtimeItemAddedEvent = Schema.Struct({
	627	+ ...ProviderRuntimeEventBase.fields,
	628	+ type: ThreadRealtimeItemAddedType,
	629	+ payload: ThreadRealtimeItemAddedPayload,
	630	+});
	631	+export type ProviderRuntimeThreadRealtimeItemAddedEvent =
	632	+ typeof ProviderRuntimeThreadRealtimeItemAddedEvent.Type;
	633	+
	634	+export const ProviderRuntimeThreadRealtimeAudioDeltaEvent = Schema.Struct({
	635	+ ...ProviderRuntimeEventBase.fields,
	636	+ type: ThreadRealtimeAudioDeltaType,
	637	+ payload: ThreadRealtimeAudioDeltaPayload,
	638	+});
	639	+export type ProviderRuntimeThreadRealtimeAudioDeltaEvent =
	640	+ typeof ProviderRuntimeThreadRealtimeAudioDeltaEvent.Type;
	641	+
	642	+export const ProviderRuntimeThreadRealtimeErrorEvent = Schema.Struct({
	643	+ ...ProviderRuntimeEventBase.fields,
	644	+ type: ThreadRealtimeErrorType,
	645	+ payload: ThreadRealtimeErrorPayload,
	646	+});
	647	+export type ProviderRuntimeThreadRealtimeErrorEvent =
	648	+ typeof ProviderRuntimeThreadRealtimeErrorEvent.Type;
	649	+
	650	+export const ProviderRuntimeThreadRealtimeClosedEvent = Schema.Struct({
	651	+ ...ProviderRuntimeEventBase.fields,
	652	+ type: ThreadRealtimeClosedType,
	653	+ payload: ThreadRealtimeClosedPayload,
	654	+});
	655	+export type ProviderRuntimeThreadRealtimeClosedEvent =
	656	+ typeof ProviderRuntimeThreadRealtimeClosedEvent.Type;
	657	+
299	658	export const ProviderRuntimeTurnStartedEvent = Schema.Struct({
300	659	...ProviderRuntimeEventBase.fields,
301	660	type: TurnStartedType,
@@ -310,6 +669,13 @@ export const ProviderRuntimeTurnCompletedEvent = Schema.Struct({ · 8 unmodified lines
310	669	});
311	670	export type ProviderRuntimeTurnCompletedEvent = typeof ProviderRuntimeTurnCompletedEvent.Type;
312	671
	672	+export const ProviderRuntimeTurnAbortedEvent = Schema.Struct({
	673	+ ...ProviderRuntimeEventBase.fields,
	674	+ type: TurnAbortedType,
	675	+ payload: TurnAbortedPayload,
	676	+});
	677	+export type ProviderRuntimeTurnAbortedEvent = typeof ProviderRuntimeTurnAbortedEvent.Type;
	678	+
313	679	export const ProviderRuntimeTurnPlanUpdatedEvent = Schema.Struct({
314	680	...ProviderRuntimeEventBase.fields,
315	681	type: TurnPlanUpdatedType,
@@ -317,6 +683,13 @@ export const ProviderRuntimeTurnPlanUpdatedEvent = Schema.Struct({ · 1 unmodified line
317	683	});
318	684	export type ProviderRuntimeTurnPlanUpdatedEvent = typeof ProviderRuntimeTurnPlanUpdatedEvent.Type;
319	685
	686	+export const ProviderRuntimeTurnDiffUpdatedEvent = Schema.Struct({
	687	+ ...ProviderRuntimeEventBase.fields,
	688	+ type: TurnDiffUpdatedType,
	689	+ payload: TurnDiffUpdatedPayload,
	690	+});
	691	+export type ProviderRuntimeTurnDiffUpdatedEvent = typeof ProviderRuntimeTurnDiffUpdatedEvent.Type;
	692	+
320	693	export const ProviderRuntimeItemStartedEvent = Schema.Struct({
321	694	...ProviderRuntimeEventBase.fields,
322	695	type: ItemStartedType,
@@ -372,8 +745,127 @@ export const ProviderRuntimeUserInputResolvedEvent = Schema.Struct({ · 49 unmodified lines
372	745	type: UserInputResolvedType,
373	746	payload: UserInputResolvedPayload,
374	747	});
375		−export type ProviderRuntimeUserInputResolvedEvent =
376		− typeof ProviderRuntimeUserInputResolvedEvent.Type;
	748	+export type ProviderRuntimeUserInputResolvedEvent = typeof ProviderRuntimeUserInputResolvedEvent.Type;
	749	+
	750	+export const ProviderRuntimeTaskStartedEvent = Schema.Struct({
	751	+ ...ProviderRuntimeEventBase.fields,
	752	+ type: TaskStartedType,
	753	+ payload: TaskStartedPayload,
	754	+});
	755	+export type ProviderRuntimeTaskStartedEvent = typeof ProviderRuntimeTaskStartedEvent.Type;
	756	+
	757	+export const ProviderRuntimeTaskProgressEvent = Schema.Struct({
	758	+ ...ProviderRuntimeEventBase.fields,
	759	+ type: TaskProgressType,
	760	+ payload: TaskProgressPayload,
	761	+});
	762	+export type ProviderRuntimeTaskProgressEvent = typeof ProviderRuntimeTaskProgressEvent.Type;
	763	+
	764	+export const ProviderRuntimeTaskCompletedEvent = Schema.Struct({
	765	+ ...ProviderRuntimeEventBase.fields,
	766	+ type: TaskCompletedType,
	767	+ payload: TaskCompletedPayload,
	768	+});
	769	+export type ProviderRuntimeTaskCompletedEvent = typeof ProviderRuntimeTaskCompletedEvent.Type;
	770	+
	771	+export const ProviderRuntimeHookStartedEvent = Schema.Struct({
	772	+ ...ProviderRuntimeEventBase.fields,
	773	+ type: HookStartedType,
	774	+ payload: HookStartedPayload,
	775	+});
	776	+export type ProviderRuntimeHookStartedEvent = typeof ProviderRuntimeHookStartedEvent.Type;
	777	+
	778	+export const ProviderRuntimeHookProgressEvent = Schema.Struct({
	779	+ ...ProviderRuntimeEventBase.fields,
	780	+ type: HookProgressType,
	781	+ payload: HookProgressPayload,
	782	+});
	783	+export type ProviderRuntimeHookProgressEvent = typeof ProviderRuntimeHookProgressEvent.Type;
	784	+
	785	+export const ProviderRuntimeHookCompletedEvent = Schema.Struct({
	786	+ ...ProviderRuntimeEventBase.fields,
	787	+ type: HookCompletedType,
	788	+ payload: HookCompletedPayload,
	789	+});
	790	+export type ProviderRuntimeHookCompletedEvent = typeof ProviderRuntimeHookCompletedEvent.Type;
	791	+
	792	+export const ProviderRuntimeToolProgressEvent = Schema.Struct({
	793	+ ...ProviderRuntimeEventBase.fields,
	794	+ type: ToolProgressType,
	795	+ payload: ToolProgressPayload,
	796	+});
	797	+export type ProviderRuntimeToolProgressEvent = typeof ProviderRuntimeToolProgressEvent.Type;
	798	+
	799	+export const ProviderRuntimeToolSummaryEvent = Schema.Struct({
	800	+ ...ProviderRuntimeEventBase.fields,
	801	+ type: ToolSummaryType,
	802	+ payload: ToolSummaryPayload,
	803	+});
	804	+export type ProviderRuntimeToolSummaryEvent = typeof ProviderRuntimeToolSummaryEvent.Type;
	805	+
	806	+export const ProviderRuntimeAuthStatusEvent = Schema.Struct({
	807	+ ...ProviderRuntimeEventBase.fields,
	808	+ type: AuthStatusType,
	809	+ payload: AuthStatusPayload,
	810	+});
	811	+export type ProviderRuntimeAuthStatusEvent = typeof ProviderRuntimeAuthStatusEvent.Type;
	812	+
	813	+export const ProviderRuntimeAccountUpdatedEvent = Schema.Struct({
	814	+ ...ProviderRuntimeEventBase.fields,
	815	+ type: AccountUpdatedType,
	816	+ payload: AccountUpdatedPayload,
	817	+});
	818	+export type ProviderRuntimeAccountUpdatedEvent = typeof ProviderRuntimeAccountUpdatedEvent.Type;
	819	+
	820	+export const ProviderRuntimeAccountRateLimitsUpdatedEvent = Schema.Struct({
	821	+ ...ProviderRuntimeEventBase.fields,
	822	+ type: AccountRateLimitsUpdatedType,
	823	+ payload: AccountRateLimitsUpdatedPayload,
	824	+});
	825	+export type ProviderRuntimeAccountRateLimitsUpdatedEvent =
	826	+ typeof ProviderRuntimeAccountRateLimitsUpdatedEvent.Type;
	827	+
	828	+export const ProviderRuntimeMcpStatusUpdatedEvent = Schema.Struct({
	829	+ ...ProviderRuntimeEventBase.fields,
	830	+ type: McpStatusUpdatedType,
	831	+ payload: McpStatusUpdatedPayload,
	832	+});
	833	+export type ProviderRuntimeMcpStatusUpdatedEvent = typeof ProviderRuntimeMcpStatusUpdatedEvent.Type;
	834	+
	835	+export const ProviderRuntimeMcpOauthCompletedEvent = Schema.Struct({
	836	+ ...ProviderRuntimeEventBase.fields,
	837	+ type: McpOauthCompletedType,
	838	+ payload: McpOauthCompletedPayload,
	839	+});
	840	+export type ProviderRuntimeMcpOauthCompletedEvent = typeof ProviderRuntimeMcpOauthCompletedEvent.Type;
	841	+
	842	+export const ProviderRuntimeModelReroutedEvent = Schema.Struct({
	843	+ ...ProviderRuntimeEventBase.fields,
	844	+ type: ModelReroutedType,
	845	+ payload: ModelReroutedPayload,
	846	+});
	847	+export type ProviderRuntimeModelReroutedEvent = typeof ProviderRuntimeModelReroutedEvent.Type;
	848	+
	849	+export const ProviderRuntimeConfigWarningEvent = Schema.Struct({
	850	+ ...ProviderRuntimeEventBase.fields,
	851	+ type: ConfigWarningType,
	852	+ payload: ConfigWarningPayload,
	853	+});
	854	+export type ProviderRuntimeConfigWarningEvent = typeof ProviderRuntimeConfigWarningEvent.Type;
	855	+
	856	+export const ProviderRuntimeDeprecationNoticeEvent = Schema.Struct({
	857	+ ...ProviderRuntimeEventBase.fields,
	858	+ type: DeprecationNoticeType,
	859	+ payload: DeprecationNoticePayload,
	860	+});
	861	+export type ProviderRuntimeDeprecationNoticeEvent = typeof ProviderRuntimeDeprecationNoticeEvent.Type;
	862	+
	863	+export const ProviderRuntimeFilesPersistedEvent = Schema.Struct({
	864	+ ...ProviderRuntimeEventBase.fields,
	865	+ type: FilesPersistedType,
	866	+ payload: FilesPersistedPayload,
	867	+});
	868	+export type ProviderRuntimeFilesPersistedEvent = typeof ProviderRuntimeFilesPersistedEvent.Type;
377	869
378	870	export const ProviderRuntimeWarningEvent = Schema.Struct({
379	871	...ProviderRuntimeEventBase.fields,
@@ -391,11 +883,23 @@ export type ProviderRuntimeErrorEvent = typeof ProviderRuntimeErrorEvent.Type; · 11 unmodified lines
391	883
392	884	export const ProviderRuntimeEventV2 = Schema.Union([
393	885	ProviderRuntimeSessionStartedEvent,
	886	+ ProviderRuntimeSessionConfiguredEvent,
	887	+ ProviderRuntimeSessionStateChangedEvent,
394	888	ProviderRuntimeSessionExitedEvent,
395	889	ProviderRuntimeThreadStartedEvent,
	890	+ ProviderRuntimeThreadStateChangedEvent,
	891	+ ProviderRuntimeThreadMetadataUpdatedEvent,
	892	+ ProviderRuntimeThreadTokenUsageUpdatedEvent,
	893	+ ProviderRuntimeThreadRealtimeStartedEvent,
	894	+ ProviderRuntimeThreadRealtimeItemAddedEvent,
	895	+ ProviderRuntimeThreadRealtimeAudioDeltaEvent,
	896	+ ProviderRuntimeThreadRealtimeErrorEvent,
	897	+ ProviderRuntimeThreadRealtimeClosedEvent,
396	898	ProviderRuntimeTurnStartedEvent,
397	899	ProviderRuntimeTurnCompletedEvent,
	900	+ ProviderRuntimeTurnAbortedEvent,
398	901	ProviderRuntimeTurnPlanUpdatedEvent,
	902	+ ProviderRuntimeTurnDiffUpdatedEvent,
399	903	ProviderRuntimeItemStartedEvent,
400	904	ProviderRuntimeItemUpdatedEvent,
401	905	ProviderRuntimeItemCompletedEvent,
@@ -404,6 +908,23 @@ export const ProviderRuntimeEventV2 = Schema.Union([ · 2 unmodified lines
404	908	ProviderRuntimeRequestResolvedEvent,
405	909	ProviderRuntimeUserInputRequestedEvent,
406	910	ProviderRuntimeUserInputResolvedEvent,
	911	+ ProviderRuntimeTaskStartedEvent,
	912	+ ProviderRuntimeTaskProgressEvent,
	913	+ ProviderRuntimeTaskCompletedEvent,
	914	+ ProviderRuntimeHookStartedEvent,
	915	+ ProviderRuntimeHookProgressEvent,
	916	+ ProviderRuntimeHookCompletedEvent,
	917	+ ProviderRuntimeToolProgressEvent,
	918	+ ProviderRuntimeToolSummaryEvent,
	919	+ ProviderRuntimeAuthStatusEvent,
	920	+ ProviderRuntimeAccountUpdatedEvent,
	921	+ ProviderRuntimeAccountRateLimitsUpdatedEvent,
	922	+ ProviderRuntimeMcpStatusUpdatedEvent,
	923	+ ProviderRuntimeMcpOauthCompletedEvent,
	924	+ ProviderRuntimeModelReroutedEvent,
	925	+ ProviderRuntimeConfigWarningEvent,
	926	+ ProviderRuntimeDeprecationNoticeEvent,
	927	+ ProviderRuntimeFilesPersistedEvent,
407	928	ProviderRuntimeWarningEvent,
408	929	ProviderRuntimeErrorEvent,
409	930	]);
@@ -412,6 +933,7 @@ export type ProviderRuntimeEventV2 = typeof ProviderRuntimeEventV2.Type; · 2 unmodified lines
412	933	export const ProviderRuntimeEvent = ProviderRuntimeEventV2;
413	934	export type ProviderRuntimeEvent = ProviderRuntimeEventV2;
414	935
	936	+// Compatibility aliases for call sites still importing legacy names.
415	937	export const ProviderRuntimeMessageDeltaEvent = ProviderRuntimeContentDeltaEvent;
416	938	export type ProviderRuntimeMessageDeltaEvent = ProviderRuntimeContentDeltaEvent;
417	939	export const ProviderRuntimeMessageCompletedEvent = ProviderRuntimeItemCompletedEvent;
@@ -425,13 +947,8 @@ export type ProviderRuntimeApprovalRequestedEvent = ProviderRuntimeRequestOpened · 7 unmodified lines
425	947	export const ProviderRuntimeApprovalResolvedEvent = ProviderRuntimeRequestResolvedEvent;
426	948	export type ProviderRuntimeApprovalResolvedEvent = ProviderRuntimeRequestResolvedEvent;
427	949
428		−export const ProviderRuntimeToolKind = Schema.Literals([
429		− "command_execution",
430		− "file_change",
431		− "mcp_tool_call",
432		− "dynamic_tool_call",
433		− "other",
434		−]);
	950	+// Legacy helper aliases retained for adapters/tests.
	951	+export const ProviderRuntimeToolKind = Schema.Literals(["command", "file-change", "other"]);
435	952	export type ProviderRuntimeToolKind = typeof ProviderRuntimeToolKind.Type;
436	953
437	954	export const ProviderRuntimeTurnStatus = RuntimeTurnState;