Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
fix(grok): Harden ACP resume with replay-idle load readiness (#3156)
Mike Olson52b04b947e36
diff --git a/apps/server/scripts/acp-mock-agent.ts b/apps/server/scripts/acp-mock-agent.tsindex 0d8977584..bc7828dd8 100644--- a/apps/server/scripts/acp-mock-agent.ts+++ b/apps/server/scripts/acp-mock-agent.ts@@ -19,6 +19,23 @@ const emitInterleavedAssistantToolCalls =const emitGenericToolPlaceholders = process.env.T3_ACP_EMIT_GENERIC_TOOL_PLACEHOLDERS === "1";const emitAskQuestion = process.env.T3_ACP_EMIT_ASK_QUESTION === "1";const emitXAiAskUserQuestion = process.env.T3_ACP_EMIT_XAI_ASK_USER_QUESTION === "1";+const emitXAiPromptCompleteThenHang = process.env.T3_ACP_EMIT_XAI_PROMPT_COMPLETE_THEN_HANG === "1";+const emitForeignSessionUpdates = process.env.T3_ACP_EMIT_FOREIGN_SESSION_UPDATES === "1";+const hangPromptForever = process.env.T3_ACP_HANG_PROMPT_FOREVER === "1";+const hangFirstPromptForever = process.env.T3_ACP_HANG_FIRST_PROMPT_FOREVER === "1";+const emitLateUpdateAfterCancel = process.env.T3_ACP_EMIT_LATE_UPDATE_AFTER_CANCEL === "1";+const omitXAiPromptCompleteStopReason =+ process.env.T3_ACP_OMIT_XAI_PROMPT_COMPLETE_STOP_REASON === "1";+const failLoadSession = process.env.T3_ACP_FAIL_LOAD_SESSION === "1";+const emitLoadReplay = process.env.T3_ACP_EMIT_LOAD_REPLAY === "1";+const hangLoadSessionAfterReplay = process.env.T3_ACP_HANG_LOAD_SESSION_AFTER_REPLAY === "1";+const delayLoadSessionAfterReplay = process.env.T3_ACP_DELAY_LOAD_SESSION_AFTER_REPLAY === "1";+const loadSessionDelayMs = Number(process.env.T3_ACP_LOAD_SESSION_DELAY_MS ?? "5000");+const emitStaleXAiPromptCompleteBeforeSecondHang =+ process.env.T3_ACP_EMIT_STALE_XAI_PROMPT_COMPLETE_BEFORE_SECOND_HANG === "1";+const emitOverlappingXAiPromptCompleteOutOfOrder =+ process.env.T3_ACP_EMIT_OVERLAPPING_XAI_PROMPT_COMPLETE_OUT_OF_ORDER === "1";+const failPrompt = process.env.T3_ACP_FAIL_PROMPT === "1";const failSetConfigOption = process.env.T3_ACP_FAIL_SET_CONFIG_OPTION === "1";const exitOnSetConfigOption = process.env.T3_ACP_EXIT_ON_SET_CONFIG_OPTION === "1";const promptResponseText = process.env.T3_ACP_PROMPT_RESPONSE_TEXT;@@ -36,8 +53,21 @@ let parameterizedModelPicker = false;let currentReasoning = "medium";let currentContext = "272k";let currentFast = false;+let promptCount = 0;+let overlappingFirstPromptId: string | undefined;const cancelledSessions = new Set<string>();+function promptIdFromRequestMeta(+ request: Pick<AcpSchema.PromptRequest, "_meta">,+): string | undefined {+ const meta = request._meta;+ if (meta === null || typeof meta !== "object") {+ return undefined;+ }+ const promptId = meta.promptId ?? meta.requestId;+ return typeof promptId === "string" && promptId.length > 0 ? promptId : undefined;+}+function logExit(reason: string): void {if (!exitLogPath) {return;@@ -45,6 +75,10 @@ function logExit(reason: string): void {NodeFS.appendFileSync(exitLogPath, `${reason}\n`, "utf8");}+function writeJsonRpcNotification(method: string, params: unknown): void {+ process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);+}+process.once("SIGTERM", () => {logExit("SIGTERM");process.exit(0);@@ -284,22 +318,66 @@ const program = Effect.gen(function* () {}),);+ const emitLoadReplayNotifications = (requestedSessionId: string) => {+ writeJsonRpcNotification("session/update", {+ _meta: { isReplay: true },+ sessionId: requestedSessionId,+ update: {+ sessionUpdate: "tool_call",+ toolCallId: "replay-tool-1",+ title: "Replay tool",+ kind: "search",+ status: "completed",+ },+ });+ writeJsonRpcNotification("session/update", {+ _meta: { isReplay: true },+ sessionId: requestedSessionId,+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "replayed assistant text" },+ },+ });+ };+yield* agent.handleLoadSession((request) =>- agent.client- .sessionUpdate({- sessionId: String(request.sessionId ?? sessionId),+ Effect.gen(function* () {+ const requestedSessionId = String(request.sessionId ?? sessionId);+ if (failLoadSession) {+ return yield* AcpError.AcpRequestError.internalError("Mock load session failure");+ }+ if (hangLoadSessionAfterReplay || delayLoadSessionAfterReplay) {+ emitLoadReplayNotifications(requestedSessionId);+ yield* agent.client.sessionUpdate({+ sessionId: requestedSessionId,+ update: {+ sessionUpdate: "user_message_chunk",+ content: { type: "text", text: "replay-tail" },+ },+ });+ yield* Effect.sleep(loadSessionDelayMs);+ return {+ modes: modeState(),+ models: modelState(),+ configOptions: configOptions(),+ };+ }+ if (emitLoadReplay) {+ emitLoadReplayNotifications(requestedSessionId);+ }+ yield* agent.client.sessionUpdate({+ sessionId: requestedSessionId,update: {sessionUpdate: "user_message_chunk",content: { type: "text", text: "replay" },},- })- .pipe(- Effect.as({- modes: modeState(),- models: modelState(),- configOptions: configOptions(),- }),- ),+ });+ return {+ modes: modeState(),+ models: modelState(),+ configOptions: configOptions(),+ };+ }),);yield* agent.handleSetSessionModel((request) =>@@ -356,19 +434,152 @@ const program = Effect.gen(function* () {);yield* agent.handleCancel(({ sessionId }) =>- Effect.sync(() => {- cancelledSessions.add(String(sessionId ?? "mock-session-1"));+ Effect.gen(function* () {+ const cancelledSessionId = String(sessionId ?? "mock-session-1");+ cancelledSessions.add(cancelledSessionId);+ if (emitLateUpdateAfterCancel) {+ yield* Effect.sleep("50 millis");+ yield* Effect.sync(() => {+ writeJsonRpcNotification("session/update", {+ sessionId: cancelledSessionId,+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "late after cancel" },+ },+ });+ });+ }}),);yield* agent.handlePrompt((request) =>Effect.gen(function* () {const requestedSessionId = String(request.sessionId ?? sessionId);+ promptCount += 1;if (Number.isFinite(promptDelayMs) && promptDelayMs > 0) {yield* Effect.sleep(`${promptDelayMs} millis`);}+ if (failPrompt) {+ return yield* AcpError.AcpRequestError.internalError("Mock prompt failure");+ }++ if (emitStaleXAiPromptCompleteBeforeSecondHang && promptCount === 1) {+ return {+ stopReason: "end_turn",+ _meta: {+ promptId: "mock-stale-xai-prompt-1",+ requestId: "mock-stale-xai-prompt-1",+ },+ };+ }++ if (emitStaleXAiPromptCompleteBeforeSecondHang && promptCount === 2) {+ const currentPromptId = promptIdFromRequestMeta(request) ?? "mock-current-xai-prompt-2";+ writeJsonRpcNotification("_x.ai/session/prompt_complete", {+ sessionId: requestedSessionId,+ promptId: "mock-stale-xai-prompt-1",+ stopReason: "end_turn",+ agentResult: null,+ });++ writeJsonRpcNotification("_x.ai/session/prompt_complete", {+ sessionId: requestedSessionId,+ promptId: currentPromptId,+ stopReason: "end_turn",+ agentResult: null,+ });++ return yield* Effect.never;+ }++ if (emitOverlappingXAiPromptCompleteOutOfOrder && promptCount === 1) {+ overlappingFirstPromptId = promptIdFromRequestMeta(request);+ return yield* Effect.never;+ }++ if (emitOverlappingXAiPromptCompleteOutOfOrder && promptCount === 2) {+ const secondPromptId = promptIdFromRequestMeta(request);+ if (overlappingFirstPromptId !== undefined && secondPromptId !== undefined) {+ writeJsonRpcNotification("_x.ai/session/prompt_complete", {+ sessionId: requestedSessionId,+ promptId: secondPromptId,+ stopReason: "end_turn",+ agentResult: null,+ });+ writeJsonRpcNotification("_x.ai/session/prompt_complete", {+ sessionId: requestedSessionId,+ promptId: overlappingFirstPromptId,+ stopReason: "end_turn",+ agentResult: null,+ });+ }+ return yield* Effect.never;+ }++ if (hangPromptForever || (hangFirstPromptForever && promptCount === 1)) {+ return yield* Effect.never;+ }++ if (emitXAiPromptCompleteThenHang) {+ writeJsonRpcNotification("session/update", {+ sessionId: requestedSessionId,+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "hello from " },+ },+ });++ if (emitForeignSessionUpdates) {+ writeJsonRpcNotification("session/update", {+ sessionId: "mock-child-session-1",+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "child before completion" },+ },+ });+ }++ writeJsonRpcNotification("_x.ai/session/prompt_complete", {+ sessionId: requestedSessionId,+ promptId: promptIdFromRequestMeta(request) ?? "mock-xai-prompt-1",+ ...(omitXAiPromptCompleteStopReason ? {} : { stopReason: "end_turn" }),+ agentResult: null,+ });++ if (emitForeignSessionUpdates) {+ writeJsonRpcNotification("session/update", {+ sessionId: "mock-child-session-1",+ update: {+ sessionUpdate: "tool_call",+ toolCallId: "child-tool-call-1",+ title: "Child-only tool",+ kind: "other",+ status: "pending",+ rawInput: {},+ },+ });+ writeJsonRpcNotification("session/update", {+ sessionId: "mock-child-session-1",+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "child after completion" },+ },+ });+ }++ writeJsonRpcNotification("session/update", {+ sessionId: requestedSessionId,+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "mock" },+ },+ });++ return yield* Effect.never;+ }+if (emitInterleavedAssistantToolCalls) {const toolCallId = "tool-call-1";@@ -599,6 +810,42 @@ const program = Effect.gen(function* () {return { stopReason: "end_turn" };}+ if (emitForeignSessionUpdates) {+ yield* agent.client.sessionUpdate({+ sessionId: requestedSessionId,+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "root before child" },+ },+ });+ yield* agent.client.sessionUpdate({+ sessionId: "mock-child-session-1",+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "child content" },+ },+ });+ yield* agent.client.sessionUpdate({+ sessionId: "mock-child-session-1",+ update: {+ sessionUpdate: "tool_call",+ toolCallId: "child-tool-call-1",+ title: "Child-only tool",+ kind: "other",+ status: "pending",+ rawInput: {},+ },+ });+ yield* agent.client.sessionUpdate({+ sessionId: requestedSessionId,+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: " root after child" },+ },+ });+ return { stopReason: "end_turn" };+ }+yield* agent.client.sessionUpdate({sessionId: requestedSessionId,update: {diff --git a/apps/server/src/provider/Layers/CursorAdapter.test.ts b/apps/server/src/provider/Layers/CursorAdapter.test.tsindex 9795e5a06..73dc09676 100644--- a/apps/server/src/provider/Layers/CursorAdapter.test.ts+++ b/apps/server/src/provider/Layers/CursorAdapter.test.ts@@ -113,6 +113,23 @@ async function waitForFileContent(filePath: string, attempts = 40) {throw new Error(`Timed out waiting for file content at ${filePath}`);}+function waitForJsonLogMatch(+ filePath: string,+ predicate: (entry: Record<string, unknown>) => boolean,+ attempts = 40,+) {+ return Effect.gen(function* () {+ for (let attempt = 0; attempt < attempts; attempt += 1) {+ const requests = yield* Effect.promise(() => readJsonLines(filePath));+ if (requests.some(predicate)) {+ return requests;+ }+ yield* Effect.yieldNow;+ }+ return yield* Effect.promise(() => readJsonLines(filePath));+ });+}+// Tests mutate `ServerSettingsService` mid-flight (e.g. setting// `providers.cursor.binaryPath` to a mock ACP wrapper). The adapter// captures `cursorSettings` once at construction, so without a resolver@@ -1004,7 +1021,10 @@ cursorAdapterTestLayer("CursorAdapterLive", (it) => {assert.equal(turnCompleted.payload.stopReason, "cancelled");}- const requests = yield* Effect.promise(() => readJsonLines(requestLogPath));+ const requests = yield* waitForJsonLogMatch(+ requestLogPath,+ (entry) => entry.method === "session/cancel",+ );assert.isTrue(requests.some((entry) => entry.method === "session/cancel"));assert.isTrue(requests.some(diff --git a/apps/server/src/provider/Layers/CursorAdapter.ts b/apps/server/src/provider/Layers/CursorAdapter.tsindex 9760b2f81..59788a2d2 100644--- a/apps/server/src/provider/Layers/CursorAdapter.ts+++ b/apps/server/src/provider/Layers/CursorAdapter.ts@@ -785,6 +785,9 @@ export function makeCursorAdapter(Stream.mapEffect(acp.getEvents(), (event) =>Effect.gen(function* () {switch (event._tag) {+ case "EventStreamBarrier":+ yield* Deferred.succeed(event.acknowledge, undefined);+ return;case "ModeChanged":return;case "AssistantItemStarted":diff --git a/apps/server/src/provider/Layers/GrokAdapter.test.ts b/apps/server/src/provider/Layers/GrokAdapter.test.tsindex c871e3c2f..7b6f0972a 100644--- a/apps/server/src/provider/Layers/GrokAdapter.test.ts+++ b/apps/server/src/provider/Layers/GrokAdapter.test.ts@@ -10,20 +10,23 @@ import * as Deferred from "effect/Deferred";import * as Effect from "effect/Effect";import * as Fiber from "effect/Fiber";import * as Layer from "effect/Layer";+import * as Ref from "effect/Ref";import * as Schema from "effect/Schema";import * as Stream from "effect/Stream";+import * as TestClock from "effect/testing/TestClock";import {ApprovalRequestId,GrokSettings,ProviderDriverKind,- ThreadId,ProviderInstanceId,+ ThreadId,+ TurnId,type ProviderRuntimeEvent,} from "@t3tools/contracts";import { ServerConfig } from "../../config.ts";-import { makeGrokAdapter } from "./GrokAdapter.ts";+import { grokPromptSettlementBelongsToContext, makeGrokAdapter } from "./GrokAdapter.ts";const decodeGrokSettings = Schema.decodeSync(GrokSettings);const __dirname = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url));@@ -45,7 +48,11 @@ exec ${JSON.stringify(mockAgentCommand)} ${JSON.stringify(mockAgentPath)} "$@"return wrapperPath;}-function waitForFileContent(filePath: string, attempts = 40): Effect.Effect<string> {+function waitForFileContent(+ filePath: string,+ attempts = 40,+ expectedContent?: string,+): Effect.Effect<string> {const readAttempt = (remainingAttempts: number): Effect.Effect<string> =>Effect.gen(function* () {if (remainingAttempts <= 0) {@@ -54,7 +61,10 @@ function waitForFileContent(filePath: string, attempts = 40): Effect.Effect<striconst raw = yield* Effect.tryPromise(() => NodeFSP.readFile(filePath, "utf8")).pipe(Effect.orElseSucceed(() => ""),);- if (raw.trim().length > 0) {+ if (+ raw.trim().length > 0 &&+ (expectedContent === undefined || raw.includes(expectedContent))+ ) {return raw;}yield* Effect.sleep("25 millis");@@ -79,6 +89,39 @@ const grokAdapterTestLayer = ServerConfig.layerTest(process.cwd(), {const makeTestAdapter = (binaryPath: string, options?: Parameters<typeof makeGrokAdapter>[1]) =>makeGrokAdapter(decodeGrokSettings({ binaryPath }), options).pipe(Effect.orDie);+it("requires a settlement to match the live Grok turn", () => {+ const staleTurnId = TurnId.make("stale-turn");+ const replacementTurnId = TurnId.make("replacement-turn");++ assert.isFalse(+ grokPromptSettlementBelongsToContext({+ liveAcpSessionId: "session-1",+ expectedAcpSessionId: "session-1",+ liveActiveTurnId: replacementTurnId,+ liveSessionActiveTurnId: replacementTurnId,+ turnId: staleTurnId,+ }),+ );+ assert.isFalse(+ grokPromptSettlementBelongsToContext({+ liveAcpSessionId: "replacement-session",+ expectedAcpSessionId: "stale-session",+ liveActiveTurnId: staleTurnId,+ liveSessionActiveTurnId: staleTurnId,+ turnId: staleTurnId,+ }),+ );+ assert.isTrue(+ grokPromptSettlementBelongsToContext({+ liveAcpSessionId: "session-1",+ expectedAcpSessionId: "session-1",+ liveActiveTurnId: staleTurnId,+ liveSessionActiveTurnId: staleTurnId,+ turnId: staleTurnId,+ }),+ );+});+it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {it.effect("starts a session and maps mock ACP prompt flow to runtime events", () =>Effect.gen(function* () {@@ -175,6 +218,783 @@ it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {}),);+ it.effect("reports a Grok session running only while the prompt is in flight", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-session-ready-after-prompt");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_EMIT_TOOL_CALLS: "1",+ }),+ );+ const adapter = yield* makeTestAdapter(wrapperPath);+ const requestOpened =+ yield* Deferred.make<Extract<ProviderRuntimeEvent, { type: "request.opened" }>>();+ const eventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ event.type === "request.opened"+ ? Deferred.succeed(requestOpened, event).pipe(Effect.ignore)+ : Effect.void,+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "approval-required",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ });++ const sendTurnFiber = yield* adapter+ .sendTurn({ threadId, input: "check lifecycle", attachments: [] })+ .pipe(Effect.forkChild);+ const requestOpenedEvent = yield* Deferred.await(requestOpened);++ const runningSessions = yield* adapter.listSessions();+ const runningSession = runningSessions.find((session) => session.threadId === threadId);+ assert.equal(runningSession?.status, "running");+ assert.isDefined(runningSession?.activeTurnId);++ yield* adapter.respondToRequest(+ threadId,+ ApprovalRequestId.make(String(requestOpenedEvent.requestId)),+ "accept",+ );+ yield* Fiber.join(sendTurnFiber);++ const readySessions = yield* adapter.listSessions();+ const readySession = readySessions.find((session) => session.threadId === threadId);+ assert.equal(readySession?.status, "ready");+ assert.isUndefined(readySession?.activeTurnId);++ yield* Fiber.interrupt(eventsFiber);+ yield* adapter.stopSession(threadId);+ }),+ );++ it.effect("restores ready without completing an unstarted turn when preparation fails", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-preparation-failure-while-connecting");+ const wrapperPath = yield* Effect.promise(() => makeMockGrokWrapper());+ const adapter = yield* makeTestAdapter(wrapperPath);++ const runtimeEvents: ProviderRuntimeEvent[] = [];+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ Effect.sync(() => {+ runtimeEvents.push(event);+ }),+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ });++ const error = yield* Effect.flip(+ adapter.sendTurn({+ threadId,+ input: "prepare invalid attachment",+ attachments: [+ {+ type: "image",+ id: "missing-image",+ name: "missing.png",+ mimeType: "image/png",+ sizeBytes: 1,+ },+ ],+ }),+ );+ for (let yieldAttempt = 0; yieldAttempt < 4; yieldAttempt += 1) {+ yield* Effect.yieldNow;+ }++ const turnCompletedEvent = runtimeEvents.find(+ (event): event is Extract<ProviderRuntimeEvent, { type: "turn.completed" }> =>+ event.type === "turn.completed",+ );+ const readySessions = yield* adapter.listSessions();+ const readySession = readySessions.find((session) => session.threadId === threadId);++ assert.equal(error._tag, "ProviderAdapterRequestError");+ assert.isUndefined(turnCompletedEvent);+ assert.equal(readySession?.status, "ready");+ assert.isUndefined(readySession?.activeTurnId);++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }),+ );++ it.effect("completes a Grok turn from xAI prompt completion when the prompt RPC hangs", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-xai-prompt-complete-fallback");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_EMIT_XAI_PROMPT_COMPLETE_THEN_HANG: "1",+ T3_ACP_EMIT_FOREIGN_SESSION_UPDATES: "1",+ }),+ );+ const adapter = yield* makeTestAdapter(wrapperPath);++ const runtimeEvents: ProviderRuntimeEvent[] = [];+ const turnCompleted = yield* Deferred.make<void>();+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ Effect.sync(() => {+ runtimeEvents.push(event);+ }).pipe(+ Effect.andThen(+ event.type === "turn.completed"+ ? Deferred.succeed(turnCompleted, undefined)+ : Effect.void,+ ),+ ),+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ });++ const sendTurnResult = yield* adapter.sendTurn({+ threadId,+ input: "exercise fallback",+ attachments: [],+ });++ yield* Deferred.await(turnCompleted);+ for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) {+ yield* Effect.yieldNow;+ }+ const readySessions = yield* adapter.listSessions();+ const readySession = readySessions.find((session) => session.threadId === threadId);+ const turnCompletedEvent = runtimeEvents.find(+ (event): event is Extract<ProviderRuntimeEvent, { type: "turn.completed" }> =>+ event.type === "turn.completed",+ );+ const eventTypes = runtimeEvents.map((event) => event.type);+ const content = runtimeEvents+ .filter(+ (event): event is Extract<ProviderRuntimeEvent, { type: "content.delta" }> =>+ event.type === "content.delta" && String(event.threadId) === String(threadId),+ )+ .map((event) => event.payload.delta)+ .join("");+ const terminalIndex = runtimeEvents.findIndex(+ (event) => event.type === "turn.completed" && String(event.threadId) === String(threadId),+ );+ const turnOutputTypes = new Set([+ "content.delta",+ "item.started",+ "item.updated",+ "item.completed",+ "turn.plan.updated",+ ]);+ const outputAfterTerminal = runtimeEvents+ .slice(terminalIndex + 1)+ .filter(+ (event) => String(event.threadId) === String(threadId) && turnOutputTypes.has(event.type),+ );+ const toolTitles = runtimeEvents.flatMap((event) =>+ event.type === "item.updated" && event.payload.title ? [event.payload.title] : [],+ );++ assert.equal(sendTurnResult.threadId, threadId);+ assert.include(eventTypes, "turn.completed");+ assert.equal(content, "hello from mock");+ assert.isAtLeast(terminalIndex, 0);+ assert.deepEqual(outputAfterTerminal, []);+ assert.notInclude(toolTitles, "Child-only tool");+ assert.equal(turnCompletedEvent?.payload.stopReason, "end_turn");+ assert.equal(readySession?.status, "ready");+ assert.isUndefined(readySession?.activeTurnId);++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }),+ );++ it.effect("retains turn transcript when sendTurn is interrupted after prompt success", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-send-turn-interrupt-after-prompt");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_EMIT_XAI_PROMPT_COMPLETE_THEN_HANG: "1",+ }),+ );+ const adapter = yield* makeTestAdapter(wrapperPath);+ const contentDelta = yield* Deferred.make<void>();+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ event.type === "content.delta" ? Deferred.succeed(contentDelta, undefined) : Effect.void,+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ });++ const sendTurnFiber = yield* adapter+ .sendTurn({+ threadId,+ input: "interrupt after prompt",+ attachments: [],+ })+ .pipe(Effect.forkChild);++ yield* Deferred.await(contentDelta);+ for (let yieldAttempt = 0; yieldAttempt < 6; yieldAttempt += 1) {+ yield* Effect.yieldNow;+ }+ yield* Fiber.interrupt(sendTurnFiber);+ for (let yieldAttempt = 0; yieldAttempt < 4; yieldAttempt += 1) {+ yield* Effect.yieldNow;+ }++ const snapshot = yield* adapter.readThread(threadId);+ assert.equal(snapshot.turns.length, 1);+ assert.equal(snapshot.turns[0]?.items.length, 1);++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }),+ );++ it.effect("does not report a synthetic stop reason when xAI omits one", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-xai-prompt-complete-missing-stop-reason");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_EMIT_XAI_PROMPT_COMPLETE_THEN_HANG: "1",+ T3_ACP_OMIT_XAI_PROMPT_COMPLETE_STOP_REASON: "1",+ }),+ );+ const adapter = yield* makeTestAdapter(wrapperPath);++ const runtimeEvents: ProviderRuntimeEvent[] = [];+ const turnCompleted = yield* Deferred.make<void>();+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ Effect.sync(() => {+ runtimeEvents.push(event);+ }).pipe(+ Effect.andThen(+ event.type === "turn.completed"+ ? Deferred.succeed(turnCompleted, undefined)+ : Effect.void,+ ),+ ),+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ });++ yield* adapter.sendTurn({+ threadId,+ input: "exercise missing stop reason",+ attachments: [],+ });++ yield* Deferred.await(turnCompleted);+ const turnCompletedEvent = runtimeEvents.find(+ (event): event is Extract<ProviderRuntimeEvent, { type: "turn.completed" }> =>+ event.type === "turn.completed",+ );++ assert.equal(turnCompletedEvent?.payload.state, "completed");+ assert.isNull(turnCompletedEvent?.payload.stopReason);++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }),+ );++ it.effect("lets Stop unblock a fully silent Grok prompt and accept a follow-up turn", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-stop-after-full-silence");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_HANG_FIRST_PROMPT_FOREVER: "1",+ }),+ );+ const adapter = yield* makeTestAdapter(wrapperPath);++ const runtimeEvents: ProviderRuntimeEvent[] = [];+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ Effect.sync(() => {+ runtimeEvents.push(event);+ }),+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ });++ yield* Effect.gen(function* () {+ yield* Effect.sleep("500 millis");+ yield* adapter.interruptTurn(threadId);+ }).pipe(Effect.forkChild({ startImmediately: true }));++ yield* adapter.sendTurn({+ threadId,+ input: "hang forever",+ attachments: [],+ });+ for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) {+ yield* Effect.yieldNow;+ }++ const cancelledEvents = runtimeEvents.filter(+ (event): event is Extract<ProviderRuntimeEvent, { type: "turn.completed" }> =>+ event.type === "turn.completed" && String(event.threadId) === String(threadId),+ );+ const readySessions = yield* adapter.listSessions();+ const readySession = readySessions.find((session) => session.threadId === threadId);++ assert.lengthOf(cancelledEvents, 1);+ assert.equal(cancelledEvents[0]?.payload.state, "cancelled");+ assert.equal(readySession?.status, "ready");+ assert.isUndefined(readySession?.activeTurnId);++ const followUpEventsBefore = runtimeEvents.length;+ yield* adapter.sendTurn({+ threadId,+ input: "continue after stop",+ attachments: [],+ });+ for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) {+ yield* Effect.yieldNow;+ }++ const followUpCompletedEvents = runtimeEvents+ .slice(followUpEventsBefore)+ .filter(+ (event): event is Extract<ProviderRuntimeEvent, { type: "turn.completed" }> =>+ event.type === "turn.completed" && String(event.threadId) === String(threadId),+ );+ assert.lengthOf(followUpCompletedEvents, 1);+ assert.equal(followUpCompletedEvents[0]?.payload.state, "completed");++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }).pipe(TestClock.withLive),+ );++ it.effect("does not let a cancelled prompt settlement consume the follow-up prompt slot", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-cancelled-settlement-before-follow-up");+ const tempDir = yield* Effect.promise(() =>+ NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "grok-acp-cancel-race-")),+ );+ const requestLogPath = NodePath.join(tempDir, "requests.ndjson");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_HANG_FIRST_PROMPT_FOREVER: "1",+ T3_ACP_REQUEST_LOG_PATH: requestLogPath,+ }),+ );+ const adapter = yield* makeTestAdapter(wrapperPath);++ const runtimeEvents: ProviderRuntimeEvent[] = [];+ const firstTurnStarted = yield* Deferred.make<TurnId>();+ const twoTurnsCompleted = yield* Deferred.make<void>();+ const completedCountRef = yield* Ref.make(0);+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ Effect.gen(function* () {+ runtimeEvents.push(event);+ if (String(event.threadId) !== String(threadId)) {+ return;+ }+ if (event.type === "turn.started" && event.turnId !== undefined) {+ yield* Deferred.succeed(firstTurnStarted, event.turnId).pipe(Effect.ignore);+ return;+ }+ if (event.type !== "turn.completed") {+ return;+ }+ const completedCount = yield* Ref.updateAndGet(completedCountRef, (count) => count + 1);+ if (completedCount === 2) {+ yield* Deferred.succeed(twoTurnsCompleted, undefined);+ }+ }),+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ });++ const firstSendTurnFiber = yield* adapter+ .sendTurn({ threadId, input: "cancel this prompt", attachments: [] })+ .pipe(Effect.forkChild);+ const firstTurnId = yield* Deferred.await(firstTurnStarted).pipe(Effect.timeout("2 seconds"));+ yield* waitForFileContent(requestLogPath, 80, '"method":"session/prompt"');++ yield* adapter.interruptTurn(threadId, firstTurnId).pipe(Effect.timeout("2 seconds"));+ const followUp = yield* adapter+ .sendTurn({ threadId, input: "complete the follow-up", attachments: [] })+ .pipe(Effect.timeout("2 seconds"));+ yield* Fiber.join(firstSendTurnFiber).pipe(Effect.timeout("2 seconds"));+ yield* Deferred.await(twoTurnsCompleted).pipe(Effect.timeout("2 seconds"));++ const turnCompletedEvents = runtimeEvents.filter(+ (event): event is Extract<ProviderRuntimeEvent, { type: "turn.completed" }> =>+ event.type === "turn.completed" && String(event.threadId) === String(threadId),+ );+ const readySessions = yield* adapter.listSessions();+ const readySession = readySessions.find((session) => session.threadId === threadId);++ assert.notEqual(String(followUp.turnId), String(firstTurnId));+ assert.deepEqual(+ turnCompletedEvents.map((event) => [String(event.turnId), event.payload.state]),+ [+ [String(firstTurnId), "cancelled"],+ [String(followUp.turnId), "completed"],+ ],+ );+ assert.equal(readySession?.status, "ready");+ assert.isUndefined(readySession?.activeTurnId);++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }).pipe(TestClock.withLive),+ );++ it.effect("drops late ACP notifications after a turn is cancelled", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-drop-late-cancelled-notifications");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_HANG_PROMPT_FOREVER: "1",+ T3_ACP_EMIT_LATE_UPDATE_AFTER_CANCEL: "1",+ }),+ );+ const lateNativeUpdate = yield* Deferred.make<void>();+ const adapter = yield* makeTestAdapter(wrapperPath, {+ nativeEventLogger: {+ filePath: "memory://grok-cancelled-native-events",+ write: (record: unknown) =>+ JSON.stringify(record).includes("late after cancel")+ ? Deferred.succeed(lateNativeUpdate, undefined).pipe(Effect.asVoid)+ : Effect.void,+ close: () => Effect.void,+ },+ });++ const runtimeEvents: ProviderRuntimeEvent[] = [];+ const turnStarted = yield* Deferred.make<TurnId>();+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ Effect.sync(() => {+ runtimeEvents.push(event);+ }).pipe(+ Effect.andThen(+ event.type === "turn.started" &&+ event.turnId !== undefined &&+ String(event.threadId) === String(threadId)+ ? Deferred.succeed(turnStarted, event.turnId).pipe(Effect.asVoid)+ : Effect.void,+ ),+ ),+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ });++ const sendTurnFiber = yield* adapter+ .sendTurn({ threadId, input: "cancel before the late update", attachments: [] })+ .pipe(Effect.forkChild);+ const turnId = yield* Deferred.await(turnStarted).pipe(Effect.timeout("2 seconds"));+ yield* adapter.interruptTurn(threadId, turnId).pipe(Effect.timeout("2 seconds"));+ yield* Fiber.join(sendTurnFiber).pipe(Effect.timeout("2 seconds"));+ yield* Deferred.await(lateNativeUpdate).pipe(Effect.timeout("2 seconds"));+ for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) {+ yield* Effect.yieldNow;+ }++ const cancelledIndex = runtimeEvents.findIndex(+ (event) =>+ event.type === "turn.completed" &&+ String(event.threadId) === String(threadId) &&+ String(event.turnId) === String(turnId) &&+ event.payload.state === "cancelled",+ );+ const turnOutputTypes = new Set([+ "content.delta",+ "item.started",+ "item.updated",+ "item.completed",+ "turn.plan.updated",+ ]);+ const outputAfterCancellation = runtimeEvents+ .slice(cancelledIndex + 1)+ .filter(+ (event) => String(event.threadId) === String(threadId) && turnOutputTypes.has(event.type),+ );++ assert.isAtLeast(cancelledIndex, 0);+ assert.deepEqual(outputAfterCancellation, []);++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }).pipe(TestClock.withLive),+ );++ it.effect("lets Stop cancel during the xAI completion drain window", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-stop-during-completion-drain");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_EMIT_XAI_PROMPT_COMPLETE_THEN_HANG: "1",+ }),+ );+ const adapter = yield* makeTestAdapter(wrapperPath);++ const runtimeEvents: ProviderRuntimeEvent[] = [];+ const activeTurnIdRef = yield* Ref.make<TurnId | undefined>(undefined);+ const trailingChunkTurnId = yield* Deferred.make<TurnId>();+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ Effect.gen(function* () {+ runtimeEvents.push(event);+ if (String(event.threadId) !== String(threadId)) {+ return;+ }+ if (event.type === "turn.started") {+ yield* Ref.set(activeTurnIdRef, event.turnId);+ }+ if (event.type !== "content.delta" || event.payload.delta !== "mock") {+ return;+ }+ const turnId = event.turnId ?? (yield* Ref.get(activeTurnIdRef));+ if (turnId === undefined) {+ return;+ }+ yield* Deferred.succeed(trailingChunkTurnId, turnId).pipe(Effect.ignore);+ }),+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ });++ const sendTurnFiber = yield* adapter+ .sendTurn({+ threadId,+ input: "cancel during completion drain",+ attachments: [],+ })+ .pipe(Effect.forkChild);++ const turnId = yield* Deferred.await(trailingChunkTurnId).pipe(Effect.timeout("2 seconds"));+ yield* adapter.interruptTurn(threadId, turnId).pipe(Effect.timeout("2 seconds"));+ yield* Fiber.join(sendTurnFiber).pipe(Effect.timeout("2 seconds"));++ const turnCompletedEvents = runtimeEvents.filter(+ (event): event is Extract<ProviderRuntimeEvent, { type: "turn.completed" }> =>+ event.type === "turn.completed" && String(event.threadId) === String(threadId),+ );+ const readySessions = yield* adapter.listSessions();+ const readySession = readySessions.find((session) => session.threadId === threadId);++ assert.lengthOf(turnCompletedEvents, 1);+ assert.equal(turnCompletedEvents[0]?.payload.state, "cancelled");+ assert.equal(readySession?.status, "ready");+ assert.isUndefined(readySession?.activeTurnId);++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }),+ );++ it.effect("settles the in-flight prompt before emitting completion", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-completion-before-next-turn");+ const wrapperPath = yield* Effect.promise(() => makeMockGrokWrapper());+ const adapter = yield* makeTestAdapter(wrapperPath);+ const completedCountRef = yield* Ref.make(0);+ const secondTurnCompleted = yield* Deferred.make<void>();++ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) => {+ if (event.type !== "turn.completed" || String(event.threadId) !== String(threadId)) {+ return Effect.void;+ }++ return Ref.modify(completedCountRef, (count) => {+ const nextCount = count + 1;+ return [nextCount, nextCount] as const;+ }).pipe(+ Effect.flatMap((count) => {+ if (count === 1) {+ return adapter+ .sendTurn({+ threadId,+ input: "second turn after completion",+ attachments: [],+ })+ .pipe(Effect.forkChild, Effect.asVoid);+ }+ if (count === 2) {+ return Deferred.succeed(secondTurnCompleted, undefined).pipe(Effect.asVoid);+ }+ return Effect.void;+ }),+ );+ }).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ });++ yield* adapter.sendTurn({+ threadId,+ input: "first turn",+ attachments: [],+ });+ yield* Deferred.await(secondTurnCompleted);++ const completedCount = yield* Ref.get(completedCountRef);+ const readySessions = yield* adapter.listSessions();+ const readySession = readySessions.find((session) => session.threadId === threadId);++ assert.equal(completedCount, 2);+ assert.equal(readySession?.status, "ready");+ assert.isUndefined(readySession?.activeTurnId);++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }),+ );++ it.effect("restores a Grok session to ready when the prompt RPC fails", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-prompt-failure-ready");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_FAIL_PROMPT: "1",+ }),+ );+ const adapter = yield* makeTestAdapter(wrapperPath);+ const runtimeEvents: ProviderRuntimeEvent[] = [];+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ Effect.sync(() => {+ runtimeEvents.push(event);+ }),+ ).pipe(Effect.forkChild);++ yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ });++ const error = yield* Effect.flip(+ adapter.sendTurn({+ threadId,+ input: "fail prompt",+ attachments: [],+ }),+ );+ const readySessions = yield* adapter.listSessions();+ const readySession = readySessions.find((session) => session.threadId === threadId);+ const failedTurnCompleted = runtimeEvents.find(+ (event) => event.type === "turn.completed" && event.threadId === threadId,+ );++ assert.equal(error._tag, "ProviderAdapterRequestError");+ assert.equal(readySession?.status, "ready");+ assert.isUndefined(readySession?.activeTurnId);+ assert.equal(failedTurnCompleted?.type, "turn.completed");+ if (failedTurnCompleted?.type === "turn.completed") {+ assert.equal(failedTurnCompleted.payload.state, "failed");+ assert.isString(failedTurnCompleted.payload.errorMessage);+ }++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }),+ );++ it.effect("ignores replayed session/load updates when resuming a Grok session", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("grok-load-replay-filter");+ const wrapperPath = yield* Effect.promise(() =>+ makeMockGrokWrapper({+ T3_ACP_EMIT_LOAD_REPLAY: "1",+ }),+ );+ const adapter = yield* makeTestAdapter(wrapperPath);+ const runtimeEvents: ProviderRuntimeEvent[] = [];+ const runtimeEventsFiber = yield* Stream.runForEach(adapter.streamEvents, (event) =>+ Effect.sync(() => {+ runtimeEvents.push(event);+ }),+ ).pipe(Effect.forkChild);++ const session = yield* adapter.startSession({+ threadId,+ provider: ProviderDriverKind.make("grok"),+ cwd: process.cwd(),+ runtimeMode: "full-access",+ modelSelection: { instanceId: ProviderInstanceId.make("grok"), model: "grok-build" },+ resumeCursor: { schemaVersion: 1, sessionId: "mock-session-1" },+ });++ yield* adapter.sendTurn({+ threadId,+ input: "after resume",+ attachments: [],+ });++ assert.deepStrictEqual(session.resumeCursor, {+ schemaVersion: 1,+ sessionId: "mock-session-1",+ });+ assert.isFalse(+ runtimeEvents.some(+ (event) => event.type === "item.completed" && event.payload.title === "Replay tool",+ ),+ );+ assert.isFalse(+ runtimeEvents.some(+ (event) =>+ event.type === "content.delta" && event.payload.delta === "replayed assistant text",+ ),+ );++ yield* Fiber.interrupt(runtimeEventsFiber);+ yield* adapter.stopSession(threadId);+ }),+ );+it.effect("rejects startSession when provider mismatches", () =>Effect.gen(function* () {const wrapperPath = yield* Effect.promise(() => makeMockGrokWrapper());@@ -331,6 +1151,7 @@ it.layer(grokAdapterTestLayer)("GrokAdapterLive", (it) => {assert.deepEqual(resolvedEvent.payload.answers, {"Which scope should Grok use?": "Workspace",});+ assert.equal(String(resolvedEvent.turnId), String(requestedEvent.turnId));yield* Fiber.join(sendTurnFiber);yield* Fiber.interrupt(eventsFiber);diff --git a/apps/server/src/provider/Layers/GrokAdapter.ts b/apps/server/src/provider/Layers/GrokAdapter.tsindex 40f425cba..c22b21801 100644--- a/apps/server/src/provider/Layers/GrokAdapter.ts+++ b/apps/server/src/provider/Layers/GrokAdapter.ts@@ -22,6 +22,7 @@ import * as FileSystem from "effect/FileSystem";import * as Option from "effect/Option";import * as Path from "effect/Path";import * as PubSub from "effect/PubSub";+import * as Ref from "effect/Ref";import * as Schema from "effect/Schema";import * as Scope from "effect/Scope";import * as Semaphore from "effect/Semaphore";@@ -62,6 +63,7 @@ import {extractXAiAskUserQuestions,makeXAiAskUserQuestionCancelledResponse,makeXAiAskUserQuestionResponse,+ promptResponseHasMissingXAiStopReason,XAiAskUserQuestionRequest,} from "../acp/XAiAcpExtension.ts";import { type GrokAdapterShape } from "../Services/GrokAdapter.ts";@@ -108,6 +110,8 @@ interface GrokSessionContext {turns: Array<{ id: TurnId; items: Array<unknown> }>;lastPlanFingerprint: string | undefined;activeTurnId: TurnId | undefined;+ /** Turns already interrupted; late prompt RPCs must not resurrect them. */+ interruptedTurnIds: Set<TurnId>;/** Number of sendTurn prompts currently in flight or being prepared.* >0 means a turn is actively running, so a new sendTurn is a steer that* continues it, and only the last remaining prompt settles the turn. */@@ -136,10 +140,38 @@ function settlePendingUserInputsAsCancelled();}+function appendPromptResultToTurn(+ ctx: GrokSessionContext,+ turnId: TurnId,+ promptParts: ReadonlyArray<EffectAcpSchema.ContentBlock>,+ result: EffectAcpSchema.PromptResponse,+): void {+ const existingTurnRecord = ctx.turns.find((turn) => turn.id === turnId);+ ctx.turns = existingTurnRecord+ ? ctx.turns.map((turn) =>+ turn.id === turnId+ ? { ...turn, items: [...turn.items, { prompt: promptParts, result }] }+ : turn,+ )+ : [...ctx.turns, { id: turnId, items: [{ prompt: promptParts, result }] }];+}+function isRecord(value: unknown): value is Record<string, unknown> {return typeof value === "object" && value !== null && !Array.isArray(value);}+const resolveNotificationTurnId = (ctx: GrokSessionContext): TurnId | undefined => ctx.activeTurnId;++const resolveCallbackTurnId = (ctx: GrokSessionContext): TurnId | undefined => ctx.activeTurnId;++const resolveSessionCallbackTurnId = (+ sessions: ReadonlyMap<ThreadId, GrokSessionContext>,+ threadId: ThreadId,+): TurnId | undefined => {+ const ctx = sessions.get(threadId);+ return ctx ? resolveCallbackTurnId(ctx) : undefined;+};+function parseGrokResume(raw: unknown): { sessionId: string } | undefined {if (!isRecord(raw)) return undefined;if (raw.schemaVersion !== GROK_RESUME_VERSION) return undefined;@@ -170,6 +202,28 @@ function selectAutoApprovedPermissionOption();}+function completedStopReasonFromPromptResponse(+ response: EffectAcpSchema.PromptResponse | undefined,+): EffectAcpSchema.StopReason | null {+ if (response === undefined || promptResponseHasMissingXAiStopReason(response)) {+ return null;+ }+ return response.stopReason;+}++export function grokPromptSettlementBelongsToContext(input: {+ readonly liveAcpSessionId: string;+ readonly expectedAcpSessionId: string;+ readonly liveActiveTurnId: TurnId | undefined;+ readonly liveSessionActiveTurnId: TurnId | undefined;+ readonly turnId: TurnId;+}): boolean {+ return (+ input.liveAcpSessionId === input.expectedAcpSessionId &&+ (input.liveActiveTurnId === input.turnId || input.liveSessionActiveTurnId === input.turnId)+ );+}+export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapterLiveOptions) {return Effect.gen(function* () {const boundInstanceId = options?.instanceId ?? ProviderInstanceId.make("grok");@@ -240,6 +294,144 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteconst withThreadLock = <A, E, R>(threadId: string, effect: Effect.Effect<A, E, R>) =>Effect.flatMap(getThreadSemaphore(threadId), (semaphore) => semaphore.withPermit(effect));+ const settlePromptInFlight = (+ threadId: ThreadId,+ turnId: TurnId,+ expectedAcpSessionId: string,+ options?: {+ readonly errorMessage?: string;+ readonly completedStopReason?: EffectAcpSchema.StopReason | null;+ readonly emitTurnCompletion?: boolean;+ /** Interrupt/cancel: drop every outstanding prompt slot and settle once. */+ readonly settleAllPrompts?: boolean;+ },+ ) =>+ Effect.gen(function* () {+ const liveCtx = sessions.get(threadId);+ if (!liveCtx) {+ return;+ }+ const settlementBelongsToLiveContext = grokPromptSettlementBelongsToContext({+ liveAcpSessionId: liveCtx.acpSessionId,+ expectedAcpSessionId,+ liveActiveTurnId: liveCtx.activeTurnId,+ liveSessionActiveTurnId: liveCtx.session.activeTurnId,+ turnId,+ });+ if (!settlementBelongsToLiveContext) {+ // interruptTurn already consumed every prompt slot for this turn. A+ // late prompt result must neither emit a second terminal event nor+ // consume a slot belonging to a newer turn on the same ACP session.+ if (+ liveCtx.acpSessionId !== expectedAcpSessionId ||+ liveCtx.interruptedTurnIds.has(turnId)+ ) {+ return;+ }+ if (options?.emitTurnCompletion !== false) {+ if (options?.errorMessage !== undefined) {+ yield* offerRuntimeEvent({+ type: "turn.completed",+ ...(yield* makeEventStamp()),+ provider: PROVIDER,+ threadId,+ turnId,+ payload: {+ state: "failed",+ errorMessage: options.errorMessage,+ },+ });+ } else if (options?.completedStopReason !== undefined) {+ yield* offerRuntimeEvent({+ type: "turn.completed",+ ...(yield* makeEventStamp()),+ provider: PROVIDER,+ threadId,+ turnId,+ payload: {+ state: options.completedStopReason === "cancelled" ? "cancelled" : "completed",+ stopReason: options.completedStopReason ?? null,+ },+ });+ }+ }+ return;+ }+ let settleTurnId = turnId;+ if (options?.settleAllPrompts) {+ liveCtx.promptsInFlight = 0;+ if (liveCtx.activeTurnId !== turnId && liveCtx.session.activeTurnId !== turnId) {+ const fallbackTurnId = liveCtx.activeTurnId ?? liveCtx.session.activeTurnId;+ if (!fallbackTurnId) {+ if (liveCtx.session.status === "running" || liveCtx.session.status === "connecting") {+ const updatedAt = yield* nowIso;+ const { activeTurnId: _activeTurnId, ...readySession } = liveCtx.session;+ liveCtx.activeTurnId = undefined;+ liveCtx.session = {+ ...readySession,+ status: "ready",+ updatedAt,+ };+ }+ return;+ }+ settleTurnId = fallbackTurnId;+ }+ } else {+ const remainingPrompts = Math.max(0, liveCtx.promptsInFlight - 1);+ if (+ remainingPrompts > 0 ||+ liveCtx.activeTurnId !== settleTurnId ||+ liveCtx.session.activeTurnId !== settleTurnId+ ) {+ liveCtx.promptsInFlight = remainingPrompts;+ return;+ }+ liveCtx.promptsInFlight = remainingPrompts;+ }+ const updatedAt = yield* nowIso;+ const canEmitTurnCompletion =+ liveCtx.session.status === "running" || liveCtx.session.status === "connecting";+ const shouldEmitFailedTurn = options?.errorMessage !== undefined && canEmitTurnCompletion;+ const shouldEmitCompletedTurn =+ options?.completedStopReason !== undefined && canEmitTurnCompletion;+ const { activeTurnId: _activeTurnId, ...readySession } = liveCtx.session;+ liveCtx.activeTurnId = undefined;+ liveCtx.session = {+ ...readySession,+ status: "ready",+ updatedAt,+ };+ if (options?.emitTurnCompletion === false) {+ return;+ }+ if (shouldEmitFailedTurn) {+ yield* offerRuntimeEvent({+ type: "turn.completed",+ ...(yield* makeEventStamp()),+ provider: PROVIDER,+ threadId,+ turnId: settleTurnId,+ payload: {+ state: "failed",+ errorMessage: options.errorMessage,+ },+ });+ } else if (shouldEmitCompletedTurn) {+ yield* offerRuntimeEvent({+ type: "turn.completed",+ ...(yield* makeEventStamp()),+ provider: PROVIDER,+ threadId,+ turnId: settleTurnId,+ payload: {+ state: options.completedStopReason === "cancelled" ? "cancelled" : "completed",+ stopReason: options.completedStopReason ?? null,+ },+ });+ }+ });+const logNative = (threadId: ThreadId, method: string, payload: unknown) =>Effect.gen(function* () {if (!nativeEventLogger) return;@@ -271,6 +463,8 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteconst emitPlanUpdate = (ctx: GrokSessionContext,+ turnId: TurnId | undefined,+ stamp: { readonly eventId: EventId; readonly createdAt: string },payload: {readonly explanation?: string | null;readonly plan: ReadonlyArray<{@@ -282,17 +476,17 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdaptemethod: string,) =>Effect.gen(function* () {- const fingerprint = `${ctx.activeTurnId ?? "no-turn"}:${encodeJsonStringForDiagnostics(payload) ?? "[unserializable payload]"}`;+ const fingerprint = `${turnId ?? "no-turn"}:${encodeJsonStringForDiagnostics(payload) ?? "[unserializable payload]"}`;if (ctx.lastPlanFingerprint === fingerprint) {return;}ctx.lastPlanFingerprint = fingerprint;yield* offerRuntimeEvent(makeAcpPlanUpdatedEvent({- stamp: yield* makeEventStamp(),+ stamp,provider: PROVIDER,threadId: ctx.threadId,- turnId: ctx.activeTurnId,+ turnId,payload,source: "acp.jsonrpc",method,@@ -424,13 +618,14 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteconst requestId = ApprovalRequestId.make(yield* randomUUIDv4);const runtimeRequestId = RuntimeRequestId.make(requestId);const resolution = yield* Deferred.make<PendingUserInputResolution>();+ const turnId = resolveSessionCallbackTurnId(sessions, input.threadId);pendingUserInputs.set(requestId, { resolution });yield* offerRuntimeEvent({type: "user-input.requested",...(yield* makeEventStamp()),provider: PROVIDER,threadId: input.threadId,- turnId: sessions.get(input.threadId)?.activeTurnId,+ turnId,requestId: runtimeRequestId,payload: { questions: extractXAiAskUserQuestions(params) },raw: {@@ -447,7 +642,7 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte...(yield* makeEventStamp()),provider: PROVIDER,threadId: input.threadId,- turnId: sessions.get(input.threadId)?.activeTurnId,+ turnId,requestId: runtimeRequestId,payload: { answers: resolvedAnswers },raw: {@@ -486,13 +681,14 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteconst requestId = ApprovalRequestId.make(yield* randomUUIDv4);const runtimeRequestId = RuntimeRequestId.make(requestId);const decision = yield* Deferred.make<ProviderApprovalDecision>();+ const turnId = resolveSessionCallbackTurnId(sessions, input.threadId);pendingApprovals.set(requestId, { decision });yield* offerRuntimeEvent(makeAcpRequestOpenedEvent({stamp: yield* makeEventStamp(),provider: PROVIDER,threadId: input.threadId,- turnId: sessions.get(input.threadId)?.activeTurnId,+ turnId,requestId: runtimeRequestId,permissionRequest,detail:@@ -512,7 +708,7 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdaptestamp: yield* makeEventStamp(),provider: PROVIDER,threadId: input.threadId,- turnId: sessions.get(input.threadId)?.activeTurnId,+ turnId,requestId: runtimeRequestId,permissionRequest,decision: resolved,@@ -578,6 +774,7 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteturns: [],lastPlanFingerprint: undefined,activeTurnId: undefined,+ interruptedTurnIds: new Set(),promptsInFlight: 0,currentModelId: boundModelId,stopped: false,@@ -586,14 +783,39 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteconst nf = yield* Stream.runDrain(Stream.mapEffect(acp.getEvents(), (event) =>Effect.gen(function* () {+ if (event._tag === "EventStreamBarrier") {+ yield* Deferred.succeed(event.acknowledge, undefined);+ return;+ }+ if (+ event._tag === "PlanUpdated" ||+ event._tag === "ToolCallUpdated" ||+ event._tag === "ContentDelta"+ ) {+ yield* logNative(ctx.threadId, "session/update", event.rawPayload);+ }++ if (event._tag === "ModeChanged") {+ return;+ }++ const notificationTurnId = resolveNotificationTurnId(ctx);+ if (+ notificationTurnId === undefined ||+ ctx.interruptedTurnIds.has(notificationTurnId)+ ) {+ return;+ }+ const stamp = yield* makeEventStamp();+switch (event._tag) {case "AssistantItemStarted":yield* offerRuntimeEvent(makeAcpAssistantItemEvent({- stamp: yield* makeEventStamp(),+ stamp,provider: PROVIDER,threadId: ctx.threadId,- turnId: ctx.activeTurnId,+ turnId: notificationTurnId,itemId: event.itemId,lifecycle: "item.started",}),@@ -602,40 +824,44 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdaptecase "AssistantItemCompleted":yield* offerRuntimeEvent(makeAcpAssistantItemEvent({- stamp: yield* makeEventStamp(),+ stamp,provider: PROVIDER,threadId: ctx.threadId,- turnId: ctx.activeTurnId,+ turnId: notificationTurnId,itemId: event.itemId,lifecycle: "item.completed",}),);return;case "PlanUpdated":- yield* logNative(ctx.threadId, "session/update", event.rawPayload);- yield* emitPlanUpdate(ctx, event.payload, event.rawPayload, "session/update");+ yield* emitPlanUpdate(+ ctx,+ notificationTurnId,+ stamp,+ event.payload,+ event.rawPayload,+ "session/update",+ );return;case "ToolCallUpdated":- yield* logNative(ctx.threadId, "session/update", event.rawPayload);yield* offerRuntimeEvent(makeAcpToolCallEvent({- stamp: yield* makeEventStamp(),+ stamp,provider: PROVIDER,threadId: ctx.threadId,- turnId: ctx.activeTurnId,+ turnId: notificationTurnId,toolCall: event.toolCall,rawPayload: event.rawPayload,}),);return;case "ContentDelta":- yield* logNative(ctx.threadId, "session/update", event.rawPayload);yield* offerRuntimeEvent(makeAcpContentDeltaEvent({- stamp: yield* makeEventStamp(),+ stamp,provider: PROVIDER,threadId: ctx.threadId,- turnId: ctx.activeTurnId,+ turnId: notificationTurnId,...(event.itemId ? { itemId: event.itemId } : {}),text: event.text,rawPayload: event.rawPayload,@@ -697,6 +923,15 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte// resolving from here on does not settle the turn; decremented on// preparation failure here, and after the prompt below otherwise.ctx.promptsInFlight += 1;+ // Bind the turn id before cooperative yields so interruptTurn can+ // settle this prompt even if stop arrives during preparation.+ ctx.activeTurnId = turnId;+ ctx.session = {+ ...ctx.session,+ status: steeringTurnId === undefined ? "connecting" : "running",+ activeTurnId: turnId,+ updatedAt: yield* nowIso,+ };return yield* Effect.gen(function* () {const turnModelSelection =@@ -765,12 +1000,27 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteconst displayModel = currentModelId? resolveGrokAcpBaseModelId(currentModelId): undefined;- ctx.activeTurnId = turnId;+ for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) {+ yield* Effect.yieldNow;+ }+ if (ctx.interruptedTurnIds.has(turnId)) {+ yield* settlePromptInFlight(input.threadId, turnId, ctx.acpSessionId, {+ completedStopReason: "cancelled",+ emitTurnCompletion: false,+ settleAllPrompts: true,+ });+ return yield* new ProviderAdapterRequestError({+ provider: PROVIDER,+ method: "session/prompt",+ detail: "Grok prompt was interrupted during preparation.",+ });+ }if (steeringTurnId === undefined) {ctx.lastPlanFingerprint = undefined;}ctx.session = {...ctx.session,+ status: "running",activeTurnId: turnId,updatedAt: yield* nowIso,...(displayModel ? { model: displayModel } : {}),@@ -796,13 +1046,27 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte};}).pipe(Effect.tapCause(() =>- Effect.sync(() => {- ctx.promptsInFlight = Math.max(0, ctx.promptsInFlight - 1);+ Effect.gen(function* () {+ const liveCtx = sessions.get(input.threadId);+ if (!liveCtx) {+ return;+ }+ yield* settlePromptInFlight(input.threadId, turnId, liveCtx.acpSessionId, {+ errorMessage: "Grok prompt preparation failed.",+ emitTurnCompletion: false,+ });}),),);}),);+ const promptSettled = yield* Ref.make(false);+ const promptRpcSucceeded = yield* Ref.make(false);+ const promptResultRef = yield* Ref.make<EffectAcpSchema.PromptResponse | undefined>(+ undefined,+ );++ const promptFailureMessageRef = yield* Ref.make<string | undefined>(undefined);return yield* Effect.gen(function* () {const result = yield* prepared.acp@@ -810,6 +1074,18 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteprompt: prepared.promptParts,}).pipe(+ Effect.tap((promptResult) =>+ Effect.all([+ Ref.set(promptRpcSucceeded, true),+ Ref.set(promptResultRef, promptResult),+ ]),+ ),+ Effect.tapError((error) =>+ Ref.set(+ promptFailureMessageRef,+ mapAcpToAdapterError(PROVIDER, input.threadId, "session/prompt", error).message,+ ).pipe(Effect.andThen(prepared.acp.drainEvents)),+ ),Effect.mapError((error) =>mapAcpToAdapterError(PROVIDER, input.threadId, "session/prompt", error),),@@ -820,38 +1096,88 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteEffect.gen(function* () {const ctx = yield* requireSession(input.threadId);if (ctx.acpSessionId !== prepared.acpSessionId) {+ yield* settlePromptInFlight(+ input.threadId,+ prepared.turnId,+ prepared.acpSessionId,+ {+ errorMessage: "Grok session changed before the turn completed.",+ settleAllPrompts: true,+ },+ );+ yield* Ref.set(promptSettled, true);return yield* new ProviderAdapterRequestError({provider: PROVIDER,method: "session/prompt",detail: "Grok session changed before the turn completed.",});}+ // Keep prompt settlement atomic with respect to Stop and steering.+ // interruptTurn marks its target before waiting for this lock, so+ // cancellation can still win while queued ACP events are drained.+ for (let yieldAttempt = 0; yieldAttempt < 8; yieldAttempt += 1) {+ yield* Effect.yieldNow;+ }+ yield* prepared.acp.drainEvents;+ if (ctx.interruptedTurnIds.has(prepared.turnId)) {+ yield* Ref.set(promptSettled, true);+ return {+ threadId: input.threadId,+ turnId: prepared.turnId,+ resumeCursor: ctx.session.resumeCursor,+ };+ }- const existingTurnRecord = ctx.turns.find((turn) => turn.id === prepared.turnId);- ctx.turns = existingTurnRecord- ? ctx.turns.map((turn) =>- turn.id === prepared.turnId- ? {- ...turn,- items: [...turn.items, { prompt: prepared.promptParts, result }],- }- : turn,- )- : [- ...ctx.turns,- { id: prepared.turnId, items: [{ prompt: prepared.promptParts, result }] },- ];+ if (+ ctx.promptsInFlight <= 0 ||+ ctx.activeTurnId !== prepared.turnId ||+ ctx.session.activeTurnId !== prepared.turnId+ ) {+ yield* Ref.set(promptSettled, true);+ return {+ threadId: input.threadId,+ turnId: prepared.turnId,+ resumeCursor: ctx.session.resumeCursor,+ };+ }++ appendPromptResultToTurn(ctx, prepared.turnId, prepared.promptParts, result);ctx.session = {...ctx.session,+ status: "running",activeTurnId: prepared.turnId,updatedAt: yield* nowIso,...(prepared.displayModel ? { model: prepared.displayModel } : {}),};+ const remainingPrompts = Math.max(0, ctx.promptsInFlight - 1);+ ctx.promptsInFlight = remainingPrompts;- // Only the last remaining prompt settles the turn — a steer-- // superseded prompt resolving (usually cancelled) while another- // is in flight or pending must leave the merged turn running.- if (ctx.promptsInFlight === 1) {+ // Only the last remaining prompt settles the turn. A steer-+ // superseded prompt resolving while another is in flight or+ // pending must leave the merged turn running.+ if (+ remainingPrompts === 0 &&+ ctx.activeTurnId === prepared.turnId &&+ ctx.session.activeTurnId === prepared.turnId+ ) {+ if (ctx.interruptedTurnIds.has(prepared.turnId)) {+ yield* Ref.set(promptSettled, true);+ return {+ threadId: input.threadId,+ turnId: prepared.turnId,+ resumeCursor: ctx.session.resumeCursor,+ };+ }+ const completedAt = yield* nowIso;+ const { activeTurnId: _completedTurnId, ...readySession } = ctx.session;+ ctx.activeTurnId = undefined;+ ctx.session = {+ ...readySession,+ status: "ready",+ updatedAt: completedAt,+ ...(prepared.displayModel ? { model: prepared.displayModel } : {}),+ };+ const completedStopReason = completedStopReasonFromPromptResponse(result);yield* offerRuntimeEvent({type: "turn.completed",...(yield* makeEventStamp()),@@ -860,9 +1186,13 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapteturnId: prepared.turnId,payload: {state: result.stopReason === "cancelled" ? "cancelled" : "completed",- stopReason: result.stopReason ?? null,+ stopReason: completedStopReason,},});+ ctx.interruptedTurnIds.delete(prepared.turnId);+ yield* Ref.set(promptSettled, true);+ } else if (remainingPrompts > 0) {+ yield* Ref.set(promptSettled, true);}return {@@ -874,27 +1204,153 @@ export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapte);}).pipe(Effect.ensuring(- Effect.sync(() => {- const liveCtx = sessions.get(input.threadId);- if (liveCtx) {- liveCtx.promptsInFlight = Math.max(0, liveCtx.promptsInFlight - 1);+ Effect.gen(function* () {+ if (yield* Ref.get(promptSettled)) {+ return;}- }),++ if (yield* Ref.get(promptRpcSucceeded)) {+ const promptResult = yield* Ref.get(promptResultRef);+ if (promptResult === undefined) {+ return;+ }+ yield* withThreadLock(+ input.threadId,+ Effect.gen(function* () {+ const ctx = yield* requireSession(input.threadId);+ if (ctx.acpSessionId !== prepared.acpSessionId) {+ yield* settlePromptInFlight(+ input.threadId,+ prepared.turnId,+ prepared.acpSessionId,+ {+ errorMessage: "Grok session changed before the turn completed.",+ settleAllPrompts: true,+ },+ );+ return;+ }+ if (ctx.interruptedTurnIds.has(prepared.turnId)) {+ return;+ }+ if (+ ctx.promptsInFlight <= 0 ||+ ctx.activeTurnId !== prepared.turnId ||+ ctx.session.activeTurnId !== prepared.turnId+ ) {+ return;+ }+ appendPromptResultToTurn(+ ctx,+ prepared.turnId,+ prepared.promptParts,+ promptResult,+ );+ yield* settlePromptInFlight(+ input.threadId,+ prepared.turnId,+ prepared.acpSessionId,+ {+ completedStopReason: completedStopReasonFromPromptResponse(promptResult),+ },+ );+ }),+ );+ return;+ }++ const errorMessage = yield* Ref.get(promptFailureMessageRef);+ yield* withThreadLock(+ input.threadId,+ settlePromptInFlight(input.threadId, prepared.turnId, prepared.acpSessionId, {+ errorMessage: errorMessage ?? "Grok prompt request failed.",+ }),+ );+ }).pipe(Effect.catch(() => Effect.void)),),);});- const interruptTurn: GrokAdapterShape["interruptTurn"] = (threadId) =>+ const interruptTurn: GrokAdapterShape["interruptTurn"] = (threadId, turnId) =>Effect.gen(function* () {- const ctx = yield* requireSession(threadId);- yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals);- yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs);- yield* Effect.ignore(- ctx.acp.cancel.pipe(- Effect.mapError((error) =>- mapAcpToAdapterError(PROVIDER, threadId, "session/cancel", error),- ),- ),+ const observed = yield* Effect.sync(() => {+ const ctx = sessions.get(threadId);+ if (!ctx || ctx.stopped) {+ return {+ _tag: "Proceed" as const,+ acpSessionId: undefined,+ interruptedTurnId: turnId,+ };+ }+ const activeTurnId = ctx.activeTurnId ?? ctx.session.activeTurnId;+ if (turnId !== undefined && activeTurnId !== undefined && activeTurnId !== turnId) {+ return { _tag: "Ignore" as const };+ }+ const interruptedTurnId = turnId ?? activeTurnId;+ if (interruptedTurnId !== undefined) {+ ctx.interruptedTurnIds.add(interruptedTurnId);+ }+ return {+ _tag: "Proceed" as const,+ acpSessionId: ctx.acpSessionId,+ interruptedTurnId,+ };+ });+ if (observed._tag === "Ignore") {+ return;+ }++ yield* withThreadLock(+ threadId,+ Effect.gen(function* () {+ const ctx = yield* requireSession(threadId);+ if (observed.acpSessionId !== undefined && ctx.acpSessionId !== observed.acpSessionId) {+ return;+ }+ const activeTurnId = ctx.activeTurnId ?? ctx.session.activeTurnId;+ if (turnId !== undefined && activeTurnId !== undefined && activeTurnId !== turnId) {+ return;+ }+ if (+ observed.interruptedTurnId !== undefined &&+ activeTurnId !== undefined &&+ activeTurnId !== observed.interruptedTurnId+ ) {+ return;+ }+ const interruptedTurnId =+ observed.interruptedTurnId ?? turnId ?? activeTurnId ?? ctx.session.activeTurnId;+ yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals);+ yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs);+ yield* Effect.ignore(+ ctx.acp.cancel.pipe(+ Effect.mapError((error) =>+ mapAcpToAdapterError(PROVIDER, threadId, "session/cancel", error),+ ),+ ),+ );+ if (interruptedTurnId) {+ ctx.interruptedTurnIds.add(interruptedTurnId);+ yield* settlePromptInFlight(threadId, interruptedTurnId, ctx.acpSessionId, {+ completedStopReason: "cancelled",+ settleAllPrompts: true,+ });+ } else if (+ ctx.promptsInFlight > 0 ||+ ctx.session.status === "running" ||+ ctx.session.status === "connecting"+ ) {+ const updatedAt = yield* nowIso;+ ctx.promptsInFlight = 0;+ ctx.activeTurnId = undefined;+ const { activeTurnId: _activeTurnId, ...readySession } = ctx.session;+ ctx.session = {+ ...readySession,+ status: "ready",+ updatedAt,+ };+ }+ }),);});diff --git a/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts b/apps/server/src/provider/acp/AcpJsonRpcConnection.test.tsindex 5533a04bc..4e9700dab 100644--- a/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts+++ b/apps/server/src/provider/acp/AcpJsonRpcConnection.test.ts@@ -7,6 +7,9 @@ import * as NodeFS from "node:fs";import * as NodeServices from "@effect/platform-node/NodeServices";import { it } from "@effect/vitest";import * as Effect from "effect/Effect";+import * as Fiber from "effect/Fiber";+import * as Option from "effect/Option";+import * as TestClock from "effect/testing/TestClock";import * as Stream from "effect/Stream";import { describe, expect } from "vite-plus/test";@@ -113,6 +116,122 @@ describe("AcpSessionRuntime", () => {),);+ it.effect("drops session updates emitted for a child ACP session", () =>+ Effect.gen(function* () {+ const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;+ yield* runtime.start();++ const promptResult = yield* runtime.prompt({+ prompt: [{ type: "text", text: "hi" }],+ });+ expect(promptResult).toMatchObject({ stopReason: "end_turn" });++ const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 4)));+ expect(notes.map((note) => note._tag)).toEqual([+ "AssistantItemStarted",+ "ContentDelta",+ "ContentDelta",+ "AssistantItemCompleted",+ ]);+ expect(+ notes+ .filter((note) => note._tag === "ContentDelta")+ .map((note) => note.text)+ .join(""),+ ).toBe("root before child root after child");+ expect(notes.some((note) => note._tag === "ToolCallUpdated")).toBe(false);+ }).pipe(+ Effect.provide(+ AcpSessionRuntime.layer({+ spawn: {+ command: mockAgentCommand,+ args: mockAgentArgs,+ env: {+ T3_ACP_EMIT_FOREIGN_SESSION_UPDATES: "1",+ },+ },+ cwd: process.cwd(),+ clientInfo: { name: "t3-test", version: "0.0.0" },+ authMethodId: "test",+ }),+ ),+ Effect.scoped,+ Effect.provide(NodeServices.layer),+ ),+ );++ it.effect("supports successive standard ACP prompts", () =>+ Effect.gen(function* () {+ const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;+ yield* runtime.start();++ const firstPromptResult = yield* runtime.prompt({+ prompt: [{ type: "text", text: "first" }],+ });+ const secondPromptResult = yield* runtime.prompt({+ prompt: [{ type: "text", text: "second" }],+ });++ expect(firstPromptResult).toMatchObject({ stopReason: "end_turn" });+ expect(secondPromptResult).toMatchObject({ stopReason: "end_turn" });+ }).pipe(+ Effect.provide(+ AcpSessionRuntime.layer({+ spawn: {+ command: mockAgentCommand,+ args: mockAgentArgs,+ },+ cwd: process.cwd(),+ clientInfo: { name: "t3-test", version: "0.0.0" },+ authMethodId: "test",+ }),+ ),+ Effect.scoped,+ Effect.provide(NodeServices.layer),+ ),+ );++ it.effect("releases a fully silent prompt when session/cancel is requested", () =>+ Effect.gen(function* () {+ const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;+ yield* runtime.start();++ const promptFiber = yield* runtime+ .prompt({+ prompt: [{ type: "text", text: "hang forever" }],+ })+ .pipe(Effect.forkChild({ startImmediately: true }));++ yield* TestClock.adjust("500 millis");+ yield* runtime.cancel;++ const firstPromptResult = yield* Fiber.join(promptFiber);+ expect(firstPromptResult).toMatchObject({ stopReason: "cancelled" });++ const secondPromptResult = yield* runtime.prompt({+ prompt: [{ type: "text", text: "second" }],+ });+ expect(secondPromptResult).toMatchObject({ stopReason: "end_turn" });+ }).pipe(+ Effect.provide(+ AcpSessionRuntime.layer({+ spawn: {+ command: mockAgentCommand,+ args: mockAgentArgs,+ env: {+ T3_ACP_HANG_FIRST_PROMPT_FOREVER: "1",+ },+ },+ cwd: process.cwd(),+ clientInfo: { name: "t3-test", version: "0.0.0" },+ authMethodId: "test",+ }),+ ),+ Effect.scoped,+ Effect.provide(NodeServices.layer),+ ),+ );+it.effect("segments assistant text around ACP tool calls", () =>Effect.gen(function* () {const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;@@ -346,6 +465,109 @@ describe("AcpSessionRuntime", () => {);});+ it.effect("fails session startup when session/load returns an error", () =>+ Effect.gen(function* () {+ const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;+ const error = yield* runtime.start().pipe(Effect.flip);++ expect(error._tag).toBe("AcpRequestError");+ }).pipe(+ Effect.provide(+ AcpSessionRuntime.layer({+ authMethodId: "test",+ spawn: {+ command: mockAgentCommand,+ args: mockAgentArgs,+ env: {+ T3_ACP_FAIL_LOAD_SESSION: "1",+ },+ },+ cwd: process.cwd(),+ resumeSessionId: "stale-session-id",+ clientInfo: { name: "t3-test", version: "0.0.0" },+ }),+ ),+ Effect.scoped,+ Effect.provide(NodeServices.layer),+ ),+ );++ it.effect("ignores session/update replay notifications during session/load", () =>+ Effect.gen(function* () {+ const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;+ yield* runtime.start();++ yield* runtime.prompt({+ prompt: [{ type: "text", text: "hi" }],+ });+ const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 4)));+ expect(notes.map((note) => note._tag)).toEqual([+ "PlanUpdated",+ "AssistantItemStarted",+ "ContentDelta",+ "AssistantItemCompleted",+ ]);+ expect(notes.some((note) => note._tag === "ToolCallUpdated")).toBe(false);+ }).pipe(+ Effect.provide(+ AcpSessionRuntime.layer({+ authMethodId: "test",+ spawn: {+ command: mockAgentCommand,+ args: mockAgentArgs,+ env: {+ T3_ACP_EMIT_LOAD_REPLAY: "1",+ },+ },+ cwd: process.cwd(),+ resumeSessionId: "mock-session-1",+ clientInfo: { name: "t3-test", version: "0.0.0" },+ }),+ ),+ Effect.scoped,+ Effect.provide(NodeServices.layer),+ ),+ );++ it.effect("completes session/load after replay becomes idle while its RPC stays pending", () =>+ Effect.gen(function* () {+ const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;+ const started = yield* runtime.start().pipe(Effect.timeout("2 seconds"));++ expect(started.sessionId).toBe("mock-session-1");+ expect(started.sessionSetupResult._meta).toMatchObject({+ t3SessionLoadReady: "replay_idle",+ });++ const unexpectedReplayEvent = yield* Stream.runHead(runtime.getEvents()).pipe(+ Effect.timeoutOption("100 millis"),+ );+ expect(Option.isNone(unexpectedReplayEvent)).toBe(true);+ }).pipe(+ Effect.provide(+ AcpSessionRuntime.layer({+ authMethodId: "test",+ spawn: {+ command: mockAgentCommand,+ args: mockAgentArgs,+ env: {+ T3_ACP_HANG_LOAD_SESSION_AFTER_REPLAY: "1",+ T3_ACP_LOAD_SESSION_DELAY_MS: "10000",+ },+ },+ cwd: process.cwd(),+ resumeSessionId: "mock-session-1",+ sessionLoadReplayIdleGap: "50 millis",+ sessionLoadTimeout: "1 second",+ clientInfo: { name: "t3-test", version: "0.0.0" },+ }),+ ),+ Effect.scoped,+ Effect.provide(NodeServices.layer),+ TestClock.withLive,+ ),+ );+it.effect("rejects invalid config option values before sending session/set_config_option", () => {const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "acp-runtime-"));const requestLogPath = NodePath.join(tempDir, "requests.ndjson");diff --git a/apps/server/src/provider/acp/AcpRuntimeModel.test.ts b/apps/server/src/provider/acp/AcpRuntimeModel.test.tsindex 54b9e5390..7682c5f5f 100644--- a/apps/server/src/provider/acp/AcpRuntimeModel.test.ts+++ b/apps/server/src/provider/acp/AcpRuntimeModel.test.ts@@ -8,6 +8,8 @@ import {parsePermissionRequest,parseSessionModeState,parseSessionUpdateEvent,+ sessionUpdateIsReplay,+ syntheticLoadSessionResponseFromInitialize,} from "./AcpRuntimeModel.ts";describe("AcpRuntimeModel", () => {@@ -59,6 +61,95 @@ describe("AcpRuntimeModel", () => {expect(modelConfigId).toBe("model");});+ it("detects Grok session replay updates from _meta.isReplay", () => {+ expect(+ sessionUpdateIsReplay({+ _meta: { isReplay: true },+ sessionId: "session-1",+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "replayed" },+ },+ } satisfies EffectAcpSchema.SessionNotification),+ ).toBe(true);+ expect(+ sessionUpdateIsReplay({+ sessionId: "session-1",+ update: {+ sessionUpdate: "agent_message_chunk",+ content: { type: "text", text: "live" },+ },+ } satisfies EffectAcpSchema.SessionNotification),+ ).toBe(false);+ });++ it("builds a synthetic load response from initialize model state", () => {+ const response = syntheticLoadSessionResponseFromInitialize({+ protocolVersion: 1,+ _meta: {+ modelState: {+ currentModelId: "grok-build",+ availableModels: [{ modelId: "grok-build", name: "Grok Build" }],+ },+ },+ } satisfies EffectAcpSchema.InitializeResponse);++ expect(response.models?.currentModelId).toBe("grok-build");+ expect(response._meta).toMatchObject({ t3SessionLoadReady: "replay_idle" });+ });++ it("accepts initialize model descriptions with null", () => {+ const response = syntheticLoadSessionResponseFromInitialize({+ protocolVersion: 1,+ _meta: {+ modelState: {+ currentModelId: "grok-build",+ availableModels: [{ modelId: "grok-build", name: "Grok Build", description: null }],+ },+ },+ } satisfies EffectAcpSchema.InitializeResponse);++ expect(response.models?.availableModels[0]?.description).toBeNull();+ });++ it("ignores malformed initialize model state in synthetic load responses", () => {+ const response = syntheticLoadSessionResponseFromInitialize({+ protocolVersion: 1,+ _meta: {+ modelState: {+ currentModelId: "grok-build",+ availableModels: [null],+ },+ modeState: {+ currentModeId: "code",+ availableModes: [{ id: "code", name: 12 }],+ },+ },+ } as EffectAcpSchema.InitializeResponse);++ expect(response.models).toBeUndefined();+ expect(response.modes).toBeUndefined();+ expect(response._meta).toMatchObject({ t3SessionLoadReady: "replay_idle" });+ });++ it("builds a synthetic load response with initialize mode state", () => {+ const response = syntheticLoadSessionResponseFromInitialize({+ protocolVersion: 1,+ _meta: {+ modeState: {+ currentModeId: "code",+ availableModes: [+ { id: "ask", name: "Ask" },+ { id: "code", name: "Code" },+ ],+ },+ },+ } satisfies EffectAcpSchema.InitializeResponse);++ expect(response.modes?.currentModeId).toBe("code");+ expect(response.modes?.availableModes).toHaveLength(2);+ });+it("projects typed ACP tool call updates into runtime events", () => {const created = parseSessionUpdateEvent({sessionId: "session-1",diff --git a/apps/server/src/provider/acp/AcpRuntimeModel.ts b/apps/server/src/provider/acp/AcpRuntimeModel.tsindex 3587d703d..e6bfc127e 100644--- a/apps/server/src/provider/acp/AcpRuntimeModel.ts+++ b/apps/server/src/provider/acp/AcpRuntimeModel.ts@@ -1,3 +1,8 @@+import * as Clock from "effect/Clock";+import * as Duration from "effect/Duration";+import * as Effect from "effect/Effect";+import * as Option from "effect/Option";+import * as Ref from "effect/Ref";import type * as EffectAcpSchema from "effect-acp/schema";import { deriveToolActivityPresentation } from "@t3tools/shared/toolActivity";import type { ToolLifecycleItemType } from "@t3tools/contracts";@@ -6,6 +11,40 @@ function isRecord(value: unknown): value is Record<string, unknown> {return typeof value === "object" && value !== null && !Array.isArray(value);}+function isSessionModelState(value: unknown): value is EffectAcpSchema.SessionModelState {+ if (!isRecord(value) || typeof value.currentModelId !== "string") {+ return false;+ }+ if (!Array.isArray(value.availableModels)) {+ return false;+ }+ return value.availableModels.every(+ (model) =>+ isRecord(model) &&+ typeof model.modelId === "string" &&+ typeof model.name === "string" &&+ (model.description === undefined ||+ model.description === null ||+ typeof model.description === "string"),+ );+}++function isSessionModeState(value: unknown): value is EffectAcpSchema.SessionModeState {+ if (!isRecord(value) || typeof value.currentModeId !== "string") {+ return false;+ }+ if (!Array.isArray(value.availableModes)) {+ return false;+ }+ return value.availableModes.every(+ (mode) =>+ isRecord(mode) &&+ typeof mode.id === "string" &&+ typeof mode.name === "string" &&+ (mode.description === undefined || typeof mode.description === "string"),+ );+}+export interface AcpSessionMode {readonly id: string;readonly name: string;@@ -414,6 +453,58 @@ export function parsePermissionRequest(};}+export function sessionUpdateIsReplay(params: EffectAcpSchema.SessionNotification): boolean {+ const meta = params._meta;+ return isRecord(meta) && meta.isReplay === true;+}++export interface SessionLoadGate {+ readonly active: boolean;+ readonly lastActivityAtMillis: number | undefined;+ readonly idleGap: Duration.Duration;+ readonly initializeResult: EffectAcpSchema.InitializeResponse;+}++export const waitForSessionLoadReplayIdle = (input: {+ readonly gateRef: Ref.Ref<Option.Option<SessionLoadGate>>;+}): Effect.Effect<EffectAcpSchema.LoadSessionResponse, never> =>+ Effect.gen(function* () {+ const pollInterval = Duration.millis(25);+ while (true) {+ const gate = yield* Ref.get(input.gateRef);+ if (+ Option.isSome(gate) &&+ gate.value.active &&+ gate.value.lastActivityAtMillis !== undefined+ ) {+ const idleGapMillis = Duration.toMillis(gate.value.idleGap);+ const nowMillis = yield* Clock.currentTimeMillis;+ if (nowMillis - gate.value.lastActivityAtMillis >= idleGapMillis) {+ return syntheticLoadSessionResponseFromInitialize(gate.value.initializeResult);+ }+ }+ yield* Effect.sleep(pollInterval);+ }+ });++export function syntheticLoadSessionResponseFromInitialize(+ initializeResult: EffectAcpSchema.InitializeResponse,+): EffectAcpSchema.LoadSessionResponse {+ const meta = initializeResult._meta;+ const modelState = isRecord(meta) ? meta.modelState : undefined;+ const modeState = isRecord(meta) ? meta.modeState : undefined;+ const models = isSessionModelState(modelState) ? modelState : undefined;+ const modes = isSessionModeState(modeState) ? modeState : undefined;++ return {+ ...(models ? { models } : {}),+ ...(modes ? { modes } : {}),+ _meta: {+ t3SessionLoadReady: "replay_idle",+ },+ };+}+export function parseSessionUpdateEvent(params: EffectAcpSchema.SessionNotification): {readonly modeId?: string;readonly events: ReadonlyArray<AcpParsedSessionEvent>;diff --git a/apps/server/src/provider/acp/AcpSessionRuntime.ts b/apps/server/src/provider/acp/AcpSessionRuntime.tsindex 4fc2c443e..bc2df3aa8 100644--- a/apps/server/src/provider/acp/AcpSessionRuntime.ts+++ b/apps/server/src/provider/acp/AcpSessionRuntime.ts@@ -1,12 +1,16 @@import * as Cause from "effect/Cause";+import * as Clock from "effect/Clock";import * as Context from "effect/Context";import * as Deferred from "effect/Deferred";+import * as Duration from "effect/Duration";import * as Effect from "effect/Effect";-import * as Exit from "effect/Exit";+import * as Fiber from "effect/Fiber";import * as Layer from "effect/Layer";+import * as Option from "effect/Option";import * as Queue from "effect/Queue";import * as Ref from "effect/Ref";import * as Scope from "effect/Scope";+import * as Semaphore from "effect/Semaphore";import * as Stream from "effect/Stream";import * as ChildProcess from "effect/unstable/process/ChildProcess";import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";@@ -23,6 +27,9 @@ import {mergeToolCallState,parseSessionModeState,parseSessionUpdateEvent,+ sessionUpdateIsReplay,+ waitForSessionLoadReplayIdle,+ type SessionLoadGate,type AcpParsedSessionEvent,type AcpSessionModeState,type AcpToolCallState,@@ -32,6 +39,16 @@ function formatConfigOptionValue(value: string | boolean): string {return JSON.stringify(value);}+export interface AcpSessionEventStreamBarrier {+ readonly _tag: "EventStreamBarrier";+ readonly acknowledge: Deferred.Deferred<void>;+}++export type AcpSessionRuntimeEvent = AcpParsedSessionEvent | AcpSessionEventStreamBarrier;++const defaultSessionLoadTimeout = Duration.seconds(90);+const defaultSessionLoadReplayIdleGap = Duration.seconds(2);+export interface AcpSpawnInput {readonly command: string;readonly args: ReadonlyArray<string>;@@ -43,6 +60,8 @@ export interface AcpSessionRuntimeOptions {readonly spawn: AcpSpawnInput;readonly cwd: string;readonly resumeSessionId?: string;+ readonly sessionLoadTimeout?: Duration.Input;+ readonly sessionLoadReplayIdleGap?: Duration.Input;readonly clientCapabilities?: EffectAcpSchema.InitializeRequest["clientCapabilities"];readonly clientInfo: {readonly name: string;@@ -160,7 +179,9 @@ export class AcpSessionRuntime extends Context.Service<*/readonly start: () => Effect.Effect<AcpSessionRuntimeStartResult, EffectAcpErrors.AcpError>;/** Stream of parsed ACP session events emitted after startup. */- readonly getEvents: () => Stream.Stream<AcpParsedSessionEvent, never>;+ readonly getEvents: () => Stream.Stream<AcpSessionRuntimeEvent, never>;+ /** Waits until the current event consumer has processed every queued event. */+ readonly drainEvents: Effect.Effect<void>;/** Latest mode state observed from session setup and `session/update` notifications. */readonly getModeState: Effect.Effect<AcpSessionModeState | undefined>;/** Latest configuration options observed from session setup and configuration writes. */@@ -254,12 +275,17 @@ export const make = (Effect.gen(function* () {const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;const runtimeScope = yield* Scope.Scope;- const eventQueue = yield* Queue.unbounded<AcpParsedSessionEvent>();+ const eventQueue = yield* Queue.unbounded<AcpSessionRuntimeEvent>();const modeStateRef = yield* Ref.make<AcpSessionModeState | undefined>(undefined);const toolCallsRef = yield* Ref.make(new Map<string, AcpToolCallState>());const assistantSegmentRef = yield* Ref.make<AcpAssistantSegmentState>({ nextSegmentIndex: 0 });const configOptionsRef = yield* Ref.make(sessionConfigOptionsFromSetup(undefined));const startStateRef = yield* Ref.make<AcpStartState>({ _tag: "NotStarted" });+ const promptSerializationSemaphore = yield* Semaphore.make(1);+ const activePromptFiberRef = yield* Ref.make<+ Option.Option<Fiber.Fiber<EffectAcpSchema.PromptResponse, EffectAcpErrors.AcpError>>+ >(Option.none());+ const sessionLoadGateRef = yield* Ref.make<Option.Option<SessionLoadGate>>(Option.none());const logRequest = (event: AcpSessionRequestLogEvent) =>options.requestLogger ? options.requestLogger(event) : Effect.void;@@ -331,15 +357,40 @@ export const make = (const acp = yield* Effect.service(EffectAcpClient.AcpClient).pipe(Effect.provide(acpContext));yield* acp.handleSessionUpdate((notification) =>- handleSessionUpdate({- queue: eventQueue,- modeStateRef,- toolCallsRef,- assistantSegmentRef,- params: notification,+ Effect.gen(function* () {+ const gate = yield* Ref.get(sessionLoadGateRef);+ if (Option.isSome(gate) && gate.value.active) {+ const lastActivityAtMillis = yield* Clock.currentTimeMillis;+ yield* Ref.set(+ sessionLoadGateRef,+ Option.some({+ ...gate.value,+ lastActivityAtMillis,+ }),+ );+ return;+ }+ if (sessionUpdateIsReplay(notification)) {+ return;+ }+ const startState = yield* Ref.get(startStateRef);+ // One runtime projects one root ACP session. Child-session updates need+ // explicit lineage routing and must never be flattened into this stream.+ if (+ startState._tag !== "Started" ||+ notification.sessionId !== startState.result.sessionId+ ) {+ return;+ }+ yield* handleSessionUpdate({+ queue: eventQueue,+ modeStateRef,+ toolCallsRef,+ assistantSegmentRef,+ params: notification,+ });}),);-const initializeClientCapabilities = {fs: {readTextFile: false,@@ -499,27 +550,74 @@ export const make = (cwd: options.cwd,mcpServers: options.mcpServers ?? [],} satisfies EffectAcpSchema.LoadSessionRequest;- const resumed = yield* runLoggedRequest(- "session/load",- loadPayload,- acp.agent.loadSession(loadPayload),- ).pipe(Effect.exit);- if (Exit.isSuccess(resumed)) {- sessionId = options.resumeSessionId;- sessionSetupResult = resumed.value;- } else {- const createPayload = {- cwd: options.cwd,- mcpServers: options.mcpServers ?? [],- } satisfies EffectAcpSchema.NewSessionRequest;- const created = yield* runLoggedRequest(- "session/new",- createPayload,- acp.agent.createSession(createPayload),+ const sessionLoadTimeout = Duration.fromInputUnsafe(+ options.sessionLoadTimeout ?? defaultSessionLoadTimeout,+ );+ const sessionLoadReplayIdleGap = Duration.fromInputUnsafe(+ options.sessionLoadReplayIdleGap ?? defaultSessionLoadReplayIdleGap,+ );++ yield* Ref.set(+ sessionLoadGateRef,+ Option.some({+ active: true,+ lastActivityAtMillis: undefined,+ idleGap: sessionLoadReplayIdleGap,+ initializeResult,+ }),+ );++ sessionId = options.resumeSessionId;+ sessionSetupResult = yield* Effect.gen(function* () {+ yield* logRequest({+ method: "session/load",+ payload: loadPayload,+ status: "started",+ });++ const idleFiber = yield* waitForSessionLoadReplayIdle({+ gateRef: sessionLoadGateRef,+ }).pipe(Effect.forkIn(runtimeScope));+ const loaded = yield* Effect.raceFirst(+ acp.agent.loadSession(loadPayload),+ Fiber.join(idleFiber),+ ).pipe(+ Effect.ensuring(Fiber.interrupt(idleFiber).pipe(Effect.ignore)),+ Effect.timeoutOption(sessionLoadTimeout),+ Effect.flatMap((result) =>+ Option.match(result, {+ onNone: () =>+ Effect.fail(+ new EffectAcpErrors.AcpTransportError({+ operation: "call-rpc",+ method: "session/load",+ detail: "session/load timed out waiting for RPC response or replay idle gap",+ cause: undefined,+ }),+ ),+ onSome: Effect.succeed,+ }),+ ),+ Effect.tap((result) =>+ logRequest({+ method: "session/load",+ payload: loadPayload,+ status: "succeeded",+ result,+ }),+ ),+ Effect.onError((cause) =>+ logRequest({+ method: "session/load",+ payload: loadPayload,+ status: "failed",+ cause,+ }),+ ),);- sessionId = created.sessionId;- sessionSetupResult = created;- }++ return loaded;+ }).pipe(Effect.ensuring(Ref.set(sessionLoadGateRef, Option.none())));} else {const createPayload = {cwd: options.cwd,@@ -596,25 +694,48 @@ export const make = (handleExtNotification: acp.handleExtNotification,start: () => start,getEvents: () => Stream.fromQueue(eventQueue),+ drainEvents: Effect.gen(function* () {+ const acknowledge = yield* Deferred.make<void>();+ yield* Queue.offer(eventQueue, {+ _tag: "EventStreamBarrier",+ acknowledge,+ });+ yield* Deferred.await(acknowledge);+ }),getModeState: Ref.get(modeStateRef),getConfigOptions: Ref.get(configOptionsRef),prompt: (payload) =>- getStartedState.pipe(- Effect.flatMap((started) => {+ promptSerializationSemaphore.withPermit(+ Effect.gen(function* () {+ const started = yield* getStartedState;+ yield* closeActiveAssistantSegment({+ queue: eventQueue,+ assistantSegmentRef,+ });const requestPayload = {sessionId: started.sessionId,...payload,} satisfies EffectAcpSchema.PromptRequest;- return closeActiveAssistantSegment({- queue: eventQueue,- assistantSegmentRef,- }).pipe(- Effect.andThen(- runLoggedRequest(- "session/prompt",- requestPayload,- acp.agent.prompt(requestPayload),- ),+ const cancelledResponse = {+ stopReason: "cancelled",+ } satisfies EffectAcpSchema.PromptResponse;+ const promptRpcFiber = yield* runLoggedRequest(+ "session/prompt",+ requestPayload,+ acp.agent.prompt(requestPayload),+ ).pipe(Effect.forkIn(runtimeScope));+ yield* Ref.set(activePromptFiberRef, Option.some(promptRpcFiber));+ return yield* Fiber.join(promptRpcFiber).pipe(+ Effect.catchCause((cause) =>+ Cause.hasInterruptsOnly(cause)+ ? Effect.succeed(cancelledResponse)+ : Effect.failCause(cause),+ ),+ Effect.ensuring(+ Effect.gen(function* () {+ yield* Fiber.interrupt(promptRpcFiber).pipe(Effect.ignore);+ yield* Ref.set(activePromptFiberRef, Option.none());+ }),),Effect.tap(() =>closeActiveAssistantSegment({@@ -626,7 +747,17 @@ export const make = (}),),cancel: getStartedState.pipe(- Effect.flatMap((started) => acp.agent.cancel({ sessionId: started.sessionId })),+ Effect.flatMap((started) =>+ Effect.gen(function* () {+ const activePromptFiber = yield* Ref.get(activePromptFiberRef);+ if (Option.isSome(activePromptFiber)) {+ yield* Fiber.interrupt(activePromptFiber.value).pipe(Effect.ignore);+ }+ yield* acp.agent+ .cancel({ sessionId: started.sessionId })+ .pipe(Effect.ignore, Effect.forkIn(runtimeScope));+ }),+ ),),setMode: (modeId) =>Ref.get(modeStateRef).pipe(@@ -705,7 +836,7 @@ const handleSessionUpdate = ({assistantSegmentRef,params,}: {- readonly queue: Queue.Queue<AcpParsedSessionEvent>;+ readonly queue: Queue.Queue<AcpSessionRuntimeEvent>;readonly modeStateRef: Ref.Ref<AcpSessionModeState | undefined>;readonly toolCallsRef: Ref.Ref<Map<string, AcpToolCallState>>;readonly assistantSegmentRef: Ref.Ref<AcpAssistantSegmentState>;@@ -801,7 +932,7 @@ const ensureActiveAssistantSegment = ({assistantSegmentRef,sessionId,}: {- readonly queue: Queue.Queue<AcpParsedSessionEvent>;+ readonly queue: Queue.Queue<AcpSessionRuntimeEvent>;readonly assistantSegmentRef: Ref.Ref<AcpAssistantSegmentState>;readonly sessionId: string;}) =>@@ -838,7 +969,7 @@ const closeActiveAssistantSegment = ({queue,assistantSegmentRef,}: {- readonly queue: Queue.Queue<AcpParsedSessionEvent>;+ readonly queue: Queue.Queue<AcpSessionRuntimeEvent>;readonly assistantSegmentRef: Ref.Ref<AcpAssistantSegmentState>;}) =>Ref.modify(assistantSegmentRef, (current) => {diff --git a/apps/server/src/provider/acp/GrokAcpSupport.ts b/apps/server/src/provider/acp/GrokAcpSupport.tsindex ee8af1e52..3e6d63a53 100644--- a/apps/server/src/provider/acp/GrokAcpSupport.ts+++ b/apps/server/src/provider/acp/GrokAcpSupport.ts@@ -8,6 +8,7 @@ import type * as EffectAcpSchema from "effect-acp/schema";import { normalizeModelSlug } from "@t3tools/shared/model";import * as AcpSessionRuntime from "./AcpSessionRuntime.ts";+import { makeXAiPromptCompletionRuntime } from "./XAiAcpExtension.ts";const GROK_API_KEY_ENV = "XAI_API_KEY";const GROK_OAUTH2_REFERRER_ENV = "GROK_OAUTH2_REFERRER";@@ -68,9 +69,10 @@ export const makeGrokAcpRuntime = (),),);- return yield* Effect.service(AcpSessionRuntime.AcpSessionRuntime).pipe(+ const runtime = yield* Effect.service(AcpSessionRuntime.AcpSessionRuntime).pipe(Effect.provide(acpContext),);+ return yield* makeXAiPromptCompletionRuntime(runtime);});export function resolveGrokAcpBaseModelId(model: string | null | undefined): string {diff --git a/apps/server/src/provider/acp/XAiAcpExtension.test.ts b/apps/server/src/provider/acp/XAiAcpExtension.test.tsindex a42561d9a..c435269fd 100644--- a/apps/server/src/provider/acp/XAiAcpExtension.test.ts+++ b/apps/server/src/provider/acp/XAiAcpExtension.test.ts@@ -1,12 +1,39 @@-import { describe, expect, it } from "vite-plus/test";+// @effect-diagnostics nodeBuiltinImport:off+import * as NodePath from "node:path";+import * as NodeURL from "node:url";++import * as NodeServices from "@effect/platform-node/NodeServices";+import { it } from "@effect/vitest";+import * as Effect from "effect/Effect";import * as Schema from "effect/Schema";+import { describe, expect } from "vite-plus/test";import {extractXAiAskUserQuestions,makeXAiAskUserQuestionCancelledResponse,makeXAiAskUserQuestionResponse,+ makeXAiPromptCompletionRuntime,XAiAskUserQuestionRequest,} from "./XAiAcpExtension.ts";+import * as AcpSessionRuntime from "./AcpSessionRuntime.ts";++const __dirname = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url));+const mockAgentPath = NodePath.join(__dirname, "../../../scripts/acp-mock-agent.ts");++const makePromptCompletionRuntime = (env: NodeJS.ProcessEnv) =>+ Effect.gen(function* () {+ const runtime = yield* AcpSessionRuntime.make({+ spawn: {+ command: process.execPath,+ args: [mockAgentPath],+ env,+ },+ cwd: process.cwd(),+ clientInfo: { name: "t3-test", version: "0.0.0" },+ authMethodId: "test",+ });+ return yield* makeXAiPromptCompletionRuntime(runtime);+ });const decodeXAiAskUserQuestionRequest = Schema.decodeUnknownSync(XAiAskUserQuestionRequest);@@ -247,4 +274,59 @@ describe("XAiAcpExtension", () => {},});});++ it.effect("resolves a hung standard prompt from xAI prompt completion", () =>+ Effect.gen(function* () {+ const runtime = yield* makePromptCompletionRuntime({+ T3_ACP_EMIT_XAI_PROMPT_COMPLETE_THEN_HANG: "1",+ });+ yield* runtime.start();++ const promptResult = yield* runtime.prompt({+ prompt: [{ type: "text", text: "hi" }],+ });+ const promptId = promptResult._meta?.promptId;++ expect(typeof promptId).toBe("string");+ expect(promptResult).toMatchObject({+ stopReason: "end_turn",+ _meta: {+ sessionId: "mock-session-1",+ promptId,+ requestId: promptId,+ },+ });+ }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),+ );++ it.effect("ignores stale xAI completion from an already settled prompt", () =>+ Effect.gen(function* () {+ const runtime = yield* makePromptCompletionRuntime({+ T3_ACP_EMIT_STALE_XAI_PROMPT_COMPLETE_BEFORE_SECOND_HANG: "1",+ });+ yield* runtime.start();++ const firstPromptResult = yield* runtime.prompt({+ prompt: [{ type: "text", text: "first" }],+ });+ expect(firstPromptResult).toMatchObject({+ stopReason: "end_turn",+ _meta: { promptId: "mock-stale-xai-prompt-1" },+ });++ const secondPromptResult = yield* runtime.prompt({+ prompt: [{ type: "text", text: "second" }],+ });+ const secondPromptId = secondPromptResult._meta?.promptId;+ expect(typeof secondPromptId).toBe("string");+ expect(secondPromptId).not.toBe("mock-stale-xai-prompt-1");+ expect(secondPromptResult).toMatchObject({+ stopReason: "end_turn",+ _meta: {+ promptId: secondPromptId,+ requestId: secondPromptId,+ },+ });+ }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),+ );});diff --git a/apps/server/src/provider/acp/XAiAcpExtension.ts b/apps/server/src/provider/acp/XAiAcpExtension.tsindex 6c774c7f8..d36a5fcfc 100644--- a/apps/server/src/provider/acp/XAiAcpExtension.ts+++ b/apps/server/src/provider/acp/XAiAcpExtension.ts@@ -1,5 +1,29 @@import type { ProviderUserInputAnswers, UserInputQuestion } from "@t3tools/contracts";+import * as Deferred from "effect/Deferred";+import * as Effect from "effect/Effect";+import * as Ref from "effect/Ref";import * as Schema from "effect/Schema";+import type * as EffectAcpSchema from "effect-acp/schema";++import type * as AcpSessionRuntime from "./AcpSessionRuntime.ts";++const XAiPromptCompleteNotification = Schema.Struct({+ sessionId: Schema.String,+ promptId: Schema.optional(Schema.String),+ stopReason: Schema.optional(Schema.String),+ agentResult: Schema.optional(Schema.NullOr(Schema.Unknown)),+});++type XAiPromptCompleteNotification = typeof XAiPromptCompleteNotification.Type;++interface PendingXAiPromptCompletion {+ readonly sessionId: string;+ readonly promptId: string;+ readonly deferred: Deferred.Deferred<EffectAcpSchema.PromptResponse>;+}++const completedXAiPromptIdLimit = 128;+const xAiStopReasonMissingMetaKey = "xAiStopReasonMissing";const XAiAskUserQuestionOption = Schema.Struct({label: Schema.String,@@ -171,3 +195,238 @@ export function makeXAiAskUserQuestionResponse(export function makeXAiAskUserQuestionCancelledResponse(): XAiAskUserQuestionCancelledResponse {return { outcome: "cancelled" };}++/**+ * Adds Grok's private prompt-completion fallback around a standards-only ACP runtime.+ * The underlying runtime remains unaware of xAI methods and metadata.+ */+export const makeXAiPromptCompletionRuntime = Effect.fn("makeXAiPromptCompletionRuntime")(+ function* (runtime: AcpSessionRuntime.AcpSessionRuntime["Service"]) {+ const activeSessionIdRef = yield* Ref.make<string | undefined>(undefined);+ const pendingRef = yield* Ref.make<ReadonlyArray<PendingXAiPromptCompletion>>([]);+ const completedPromptIdsRef = yield* Ref.make<ReadonlyArray<string>>([]);+ let nextPromptFallbackId = 0;+ const allocatePromptFallbackId = Effect.sync(() => {+ nextPromptFallbackId += 1;+ return `t3-xai-prompt-${nextPromptFallbackId}`;+ });++ yield* runtime.handleExtNotification(+ "_x.ai/session/prompt_complete",+ XAiPromptCompleteNotification,+ (notification) =>+ resolveXAiPromptCompletionFallback({+ pendingRef,+ completedPromptIdsRef,+ notification,+ }),+ );++ return {+ ...runtime,+ start: () =>+ runtime+ .start()+ .pipe(Effect.tap((started) => Ref.set(activeSessionIdRef, started.sessionId))),+ prompt: (payload) =>+ Effect.gen(function* () {+ const sessionId = yield* Ref.get(activeSessionIdRef);+ if (sessionId === undefined) {+ return yield* runtime.prompt(payload);+ }++ const promptId = yield* allocatePromptFallbackId;+ const fallback = yield* registerXAiPromptCompletionFallback(+ pendingRef,+ sessionId,+ promptId,+ );+ const requestPayload = {+ ...payload,+ _meta: {+ ...payload._meta,+ promptId: fallback.promptId,+ requestId: fallback.promptId,+ },+ } satisfies Omit<EffectAcpSchema.PromptRequest, "sessionId">;++ return yield* Effect.raceFirst(+ runtime.prompt(requestPayload),+ Deferred.await(fallback.deferred),+ ).pipe(+ Effect.tap((response) =>+ rememberCompletedXAiPromptId(completedPromptIdsRef, response, fallback.promptId),+ ),+ Effect.ensuring(unregisterXAiPromptCompletionFallback(pendingRef, fallback.deferred)),+ );+ }),+ cancel: Ref.get(activeSessionIdRef).pipe(+ Effect.flatMap((sessionId) =>+ sessionId === undefined+ ? runtime.cancel+ : abortPendingPromptCompletions(pendingRef, sessionId).pipe(+ Effect.andThen(runtime.cancel),+ ),+ ),+ ),+ } satisfies AcpSessionRuntime.AcpSessionRuntime["Service"];+ },+);++const registerXAiPromptCompletionFallback = (+ pendingRef: Ref.Ref<ReadonlyArray<PendingXAiPromptCompletion>>,+ sessionId: string,+ promptId: string,+) =>+ Deferred.make<EffectAcpSchema.PromptResponse>().pipe(+ Effect.tap((deferred) =>+ Ref.update(pendingRef, (pending) => [...pending, { sessionId, promptId, deferred }]),+ ),+ Effect.map((deferred) => ({ deferred, promptId })),+ );++const unregisterXAiPromptCompletionFallback = (+ pendingRef: Ref.Ref<ReadonlyArray<PendingXAiPromptCompletion>>,+ deferred: Deferred.Deferred<EffectAcpSchema.PromptResponse>,+) => Ref.update(pendingRef, (pending) => pending.filter((entry) => entry.deferred !== deferred));++const abortPendingPromptCompletions = (+ pendingRef: Ref.Ref<ReadonlyArray<PendingXAiPromptCompletion>>,+ sessionId: string,+) =>+ Ref.modify(pendingRef, (pending) => {+ const [toAbort, remaining] = pending.reduce<+ [ReadonlyArray<PendingXAiPromptCompletion>, ReadonlyArray<PendingXAiPromptCompletion>]+ >(+ ([aborting, kept], entry) =>+ entry.sessionId === sessionId ? [[...aborting, entry], kept] : [aborting, [...kept, entry]],+ [[], []],+ );+ if (toAbort.length === 0) {+ return [Effect.void, pending] as const;+ }+ return [+ Effect.forEach(+ toAbort,+ (entry) =>+ Deferred.succeed(+ entry.deferred,+ promptResponseFromXAi({+ sessionId: entry.sessionId,+ promptId: entry.promptId,+ stopReason: "cancelled",+ agentResult: null,+ }),+ ),+ { concurrency: "unbounded" },+ ).pipe(Effect.asVoid),+ remaining,+ ] as const;+ }).pipe(Effect.flatten);++const resolveXAiPromptCompletionFallback = ({+ pendingRef,+ completedPromptIdsRef,+ notification,+}: {+ readonly pendingRef: Ref.Ref<ReadonlyArray<PendingXAiPromptCompletion>>;+ readonly completedPromptIdsRef: Ref.Ref<ReadonlyArray<string>>;+ readonly notification: XAiPromptCompleteNotification;+}) =>+ Ref.get(completedPromptIdsRef).pipe(+ Effect.flatMap((completedPromptIds) => {+ if (+ notification.promptId !== undefined &&+ completedPromptIds.includes(notification.promptId)+ ) {+ return Effect.void;+ }+ return Ref.modify(pendingRef, (pending) => {+ const index =+ notification.promptId !== undefined+ ? pending.findIndex(+ (entry) =>+ entry.sessionId === notification.sessionId &&+ entry.promptId === notification.promptId,+ )+ : pending.findIndex((entry) => entry.sessionId === notification.sessionId);+ if (index < 0) {+ return [Effect.void, pending] as const;+ }+ const entry = pending[index];+ if (!entry) {+ return [Effect.void, pending] as const;+ }+ return [+ Deferred.succeed(entry.deferred, promptResponseFromXAi(notification)).pipe(Effect.asVoid),+ [...pending.slice(0, index), ...pending.slice(index + 1)],+ ] as const;+ }).pipe(Effect.flatten);+ }),+ );++const rememberCompletedXAiPromptId = (+ completedPromptIdsRef: Ref.Ref<ReadonlyArray<string>>,+ response: EffectAcpSchema.PromptResponse,+ fallbackPromptId: string,+) => {+ const promptId = promptIdFromResponse(response) ?? fallbackPromptId;+ return Ref.update(completedPromptIdsRef, (completedPromptIds) => {+ if (completedPromptIds.includes(promptId)) {+ return completedPromptIds;+ }+ return [...completedPromptIds, promptId].slice(-completedXAiPromptIdLimit);+ });+};++function promptIdFromResponse(response: EffectAcpSchema.PromptResponse): string | undefined {+ const meta = response._meta;+ if (meta === null || typeof meta !== "object") {+ return undefined;+ }+ const promptId = meta.promptId ?? meta.requestId;+ return typeof promptId === "string" && promptId.length > 0 ? promptId : undefined;+}++export function promptResponseHasMissingXAiStopReason(+ response: EffectAcpSchema.PromptResponse,+): boolean {+ const meta = response._meta;+ return meta !== null && typeof meta === "object" && meta[xAiStopReasonMissingMetaKey] === true;+}++function promptResponseFromXAi(+ notification: XAiPromptCompleteNotification,+): EffectAcpSchema.PromptResponse {+ const stopReason = normalizeXAiStopReason(notification.stopReason);+ const meta: Record<string, unknown> = {+ sessionId: notification.sessionId,+ };+ if (notification.stopReason === undefined) {+ meta[xAiStopReasonMissingMetaKey] = true;+ }+ if (notification.promptId !== undefined) {+ meta.promptId = notification.promptId;+ meta.requestId = notification.promptId;+ }+ if (notification.agentResult !== undefined) {+ meta.agentResult = notification.agentResult;+ }+ return {+ stopReason,+ _meta: meta,+ };+}++function normalizeXAiStopReason(value: string | undefined): EffectAcpSchema.StopReason {+ switch (value) {+ case "cancelled":+ case "end_turn":+ case "max_tokens":+ case "max_turn_requests":+ case "refusal":+ return value;+ default:+ return "end_turn";+ }+}diff --git a/apps/web/src/components/ChatView.logic.test.ts b/apps/web/src/components/ChatView.logic.test.tsindex 43ed895c0..0a0103df1 100644--- a/apps/web/src/components/ChatView.logic.test.ts+++ b/apps/web/src/components/ChatView.logic.test.ts@@ -6,6 +6,7 @@ import {MAX_HIDDEN_MOUNTED_PREVIEW_THREADS,MAX_HIDDEN_MOUNTED_TERMINAL_THREADS,buildExpiredTerminalContextToastCopy,+ buildThreadTurnInterruptInput,createLocalDispatchSnapshot,deriveComposerSendState,getStartedThreadModelChangeBlockReason,@@ -69,6 +70,30 @@ const readySession = {updatedAt: "2026-03-29T00:00:10.000Z",};+describe("buildThreadTurnInterruptInput", () => {+ it("targets the session's active running turn", () => {+ const activeTurnId = TurnId.make("turn-running");++ expect(+ buildThreadTurnInterruptInput(+ makeThread({+ session: {+ ...readySession,+ status: "running",+ activeTurnId,+ },+ }),+ ),+ ).toEqual({ threadId, turnId: activeTurnId });+ });++ it("omits a turn id when the session is not running", () => {+ expect(buildThreadTurnInterruptInput(makeThread({ session: readySession }))).toEqual({+ threadId,+ });+ });+});+describe("deriveComposerSendState", () => {it("treats expired terminal pills as non-sendable content", () => {const state = deriveComposerSendState({diff --git a/apps/web/src/components/ChatView.logic.ts b/apps/web/src/components/ChatView.logic.tsindex 36947caae..705793ec7 100644--- a/apps/web/src/components/ChatView.logic.ts+++ b/apps/web/src/components/ChatView.logic.ts@@ -74,6 +74,17 @@ export function shouldWriteThreadErrorToCurrentServerThread(input: {);}+export function buildThreadTurnInterruptInput(thread: Pick<Thread, "id" | "session">): {+ threadId: ThreadId;+ turnId?: TurnId;+} {+ const runningTurnId = thread.session?.status === "running" ? thread.session.activeTurnId : null;+ return {+ threadId: thread.id,+ ...(runningTurnId !== null ? { turnId: runningTurnId } : {}),+ };+}+export function reconcileMountedTerminalThreadIds(input: {currentThreadIds: ReadonlyArray<string>;openThreadIds: ReadonlyArray<string>;diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsxindex 5249ee021..d9ae6e481 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -214,6 +214,7 @@ import {MAX_HIDDEN_MOUNTED_TERMINAL_THREADS,buildExpiredTerminalContextToastCopy,buildLocalDraftThread,+ buildThreadTurnInterruptInput,collectUserMessageBlobPreviewUrls,createLocalDispatchSnapshot,deriveComposerSendState,@@ -3941,9 +3942,7 @@ function ChatViewContent(props: ChatViewProps) {if (!activeThread) return;const result = await interruptThreadTurn({environmentId,- input: {- threadId: activeThread.id,- },+ input: buildThreadTurnInterruptInput(activeThread),});if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {const error = squashAtomCommandFailure(result);@@ -4771,6 +4770,11 @@ function ChatViewContent(props: ChatViewProps) {listRef={legendListRef}timelineEntries={timelineEntries}latestTurn={activeLatestTurn}+ runningTurnId={+ activeThread.session?.status === "running"+ ? activeThread.session.activeTurnId+ : null+ }turnDiffSummaryByAssistantMessageId={turnDiffSummaryByAssistantMessageId}activeThreadEnvironmentId={activeThread.environmentId}routeThreadKey={routeThreadKey}diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.tsindex 50ee10b41..1676d2d7c 100644--- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts+++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts@@ -794,6 +794,67 @@ describe("deriveMessagesTimelineRows", () => {]);});+ it("does not fold the session's running turn when latestTurn regresses", () => {+ const rows = deriveMessagesTimelineRows({+ timelineEntries: [+ {+ id: "previous-work-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:05Z",+ entry: {+ id: "previous-work",+ createdAt: "2026-01-01T00:00:05Z",+ turnId: "turn-1" as never,+ label: "Read files",+ tone: "tool" as const,+ },+ },+ {+ id: "user-followup-entry",+ kind: "message",+ createdAt: "2026-01-01T00:01:00Z",+ message: {+ id: "user-followup" as never,+ role: "user",+ text: "continue",+ turnId: null,+ createdAt: "2026-01-01T00:01:00Z",+ updatedAt: "2026-01-01T00:01:00Z",+ streaming: false,+ },+ },+ {+ id: "running-work-entry",+ kind: "work",+ createdAt: "2026-01-01T00:01:05Z",+ entry: {+ id: "running-work",+ createdAt: "2026-01-01T00:01:05Z",+ turnId: "turn-2" as never,+ label: "Searched files",+ tone: "tool" as const,+ },+ },+ ],+ latestTurn: {+ turnId: "turn-1" as never,+ state: "completed",+ startedAt: "2026-01-01T00:00:00Z",+ completedAt: "2026-01-01T00:00:25Z",+ },+ runningTurnId: "turn-2" as never,+ isWorking: true,+ activeTurnStartedAt: "2026-01-01T00:01:00Z",+ turnDiffSummaryByAssistantMessageId: new Map(),+ revertTurnCountByUserMessageId: new Map(),+ });++ expect(rows.filter((row) => row.kind === "turn-fold").map((row) => row.turnId)).toEqual([+ "turn-1",+ ]);+ expect(rows.map((row) => row.id)).toContain("running-work-entry");+ });+it("only shows assistant metadata on the terminal assistant message", () => {const rows = deriveMessagesTimelineRows({timelineEntries: [diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.tsindex 1426f1dee..86212576f 100644--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts@@ -149,13 +149,20 @@ interface TurnFold {}/**- * The latest turn counts as unsettled while it is still running (or has not- * recorded a completion). This is deliberately keyed on the turn's own- * lifecycle rather than transient working state: right after the user sends- * a message, the previous turn is still the "active" one until the server- * creates the new turn, and folding must not flicker through that window.+ * The session's running turn is authoritative when latestTurn briefly lags or+ * regresses behind it. Otherwise, the latest turn counts as unsettled while it+ * is still running (or has not recorded a completion). This is deliberately+ * keyed on turn lifecycle rather than transient working state: right after the+ * user sends a message, the previous turn is still the "active" one until the+ * server creates the new turn, and folding must not flicker through that window.*/-function deriveUnsettledTurnId(latestTurn: TimelineLatestTurn | null): TurnId | null {+function deriveUnsettledTurnId(+ latestTurn: TimelineLatestTurn | null,+ runningTurnId: TurnId | null,+): TurnId | null {+ if (runningTurnId !== null) {+ return runningTurnId;+ }if (!latestTurn) {return null;}@@ -291,6 +298,7 @@ function deriveTurnFolds(input: {export function deriveMessagesTimelineRows(input: {timelineEntries: ReadonlyArray<TimelineEntry>;latestTurn?: TimelineLatestTurn | null;+ runningTurnId?: TurnId | null;expandedTurnIds?: ReadonlySet<TurnId>;isWorking: boolean;activeTurnStartedAt: string | null;@@ -302,7 +310,10 @@ export function deriveMessagesTimelineRows(input: {input.timelineEntries.flatMap((entry) => (entry.kind === "message" ? [entry.message] : [])),);const terminalAssistantMessageIds = deriveTerminalAssistantMessageIds(input.timelineEntries);- const unsettledTurnId = deriveUnsettledTurnId(input.latestTurn ?? null);+ const unsettledTurnId = deriveUnsettledTurnId(+ input.latestTurn ?? null,+ input.runningTurnId ?? null,+ );const foldsByAnchorEntryId = deriveTurnFolds({timelineEntries: input.timelineEntries,terminalAssistantMessageIds,diff --git a/apps/web/src/components/chat/MessagesTimeline.test.tsx b/apps/web/src/components/chat/MessagesTimeline.test.tsxindex 3008bd2ba..a69ce17c7 100644--- a/apps/web/src/components/chat/MessagesTimeline.test.tsx+++ b/apps/web/src/components/chat/MessagesTimeline.test.tsx@@ -109,6 +109,7 @@ function buildProps() {activeTurnStartedAt: null,listRef: createRef<LegendListRef | null>(),latestTurn: null,+ runningTurnId: null,turnDiffSummaryByAssistantMessageId: new Map(),routeThreadKey: "environment-local:thread-1",onOpenTurnDiff: () => {},diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsxindex 55c982c64..cf8224d51 100644--- a/apps/web/src/components/chat/MessagesTimeline.tsx+++ b/apps/web/src/components/chat/MessagesTimeline.tsx@@ -153,6 +153,7 @@ interface MessagesTimelineProps {listRef: React.RefObject<LegendListRef | null>;timelineEntries: ReturnType<typeof deriveTimelineEntries>;latestTurn: TimelineLatestTurn | null;+ runningTurnId: TurnId | null;turnDiffSummaryByAssistantMessageId: Map<MessageId, TurnDiffSummary>;routeThreadKey: string;onOpenTurnDiff: (turnId: TurnId, filePath?: string) => void;@@ -182,6 +183,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({listRef,timelineEntries,latestTurn,+ runningTurnId,turnDiffSummaryByAssistantMessageId,routeThreadKey,onOpenTurnDiff,@@ -272,6 +274,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({deriveMessagesTimelineRows({timelineEntries,latestTurn,+ runningTurnId,expandedTurnIds,isWorking,activeTurnStartedAt,@@ -281,6 +284,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({[timelineEntries,latestTurn,+ runningTurnId,expandedTurnIds,isWorking,activeTurnStartedAt,diff --git a/packages/effect-acp/src/client.test.ts b/packages/effect-acp/src/client.test.tsindex c732f80ef..779a6499e 100644--- a/packages/effect-acp/src/client.test.ts+++ b/packages/effect-acp/src/client.test.ts@@ -17,18 +17,59 @@ import { it, assert } from "@effect/vitest";import * as AcpClient from "./client.ts";import * as AcpSchema from "./_generated/schema.gen.ts";import * as AcpError from "./errors.ts";-import { encodeJsonl, jsonRpcRequest, jsonRpcResponse } from "./_internal/shared.ts";+import {+ encodeJsonl,+ jsonRpcNotification,+ jsonRpcRequest,+ jsonRpcResponse,+} from "./_internal/shared.ts";import { makeInMemoryStdio } from "./_internal/stdio.ts";const InitializeRequest = jsonRpcRequest("initialize", AcpSchema.InitializeRequest);const InitializeResponse = jsonRpcResponse(AcpSchema.InitializeResponse);const ExtRequest = jsonRpcRequest("x/test", Schema.Struct({ hello: Schema.String }));const ExtResponse = jsonRpcResponse(Schema.Struct({ ok: Schema.Boolean }));+const PromptRequest = jsonRpcRequest("session/prompt", AcpSchema.PromptRequest);+const PromptResponse = jsonRpcResponse(AcpSchema.PromptResponse);+const decodePromptRequestLine = Schema.decodeEffect(Schema.fromJsonString(PromptRequest));+const XAiPromptCompleteNotification = jsonRpcNotification(+ "_x.ai/session/prompt_complete",+ Schema.Struct({+ sessionId: Schema.String,+ promptId: Schema.String,+ stopReason: Schema.String,+ agentResult: Schema.NullOr(Schema.Unknown),+ }),+);+const XAiQueueChangedNotification = jsonRpcNotification(+ "_x.ai/queue/changed",+ Schema.Struct({+ sessionId: Schema.String,+ entries: Schema.Array(Schema.Unknown),+ }),+);+const XAiSessionsChangedNotification = jsonRpcNotification(+ "_x.ai/sessions/changed",+ Schema.Struct({+ upserted: Schema.Array(Schema.Unknown),+ removed: Schema.Array(Schema.Unknown),+ }),+);const mockPeerPath = Effect.map(Effect.service(Path.Path), (path) =>path.join(import.meta.dirname, "../test/fixtures/acp-mock-peer.ts"),);const mockPeerArgs = (path: string) => [path];+function concatBytes(chunks: ReadonlyArray<Uint8Array>): Uint8Array {+ const batch = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));+ let offset = 0;+ for (const chunk of chunks) {+ batch.set(chunk, offset);+ offset += chunk.length;+ }+ return batch;+}+it.layer(NodeServices.layer)("effect-acp client", (it) => {const makeHandle = (env?: Record<string, string>) =>Effect.gen(function* () {@@ -446,4 +487,90 @@ it.layer(NodeServices.layer)("effect-acp client", (it) => {yield* Scope.close(scope, Exit.void);}),);++ it.effect(+ "routes a standard prompt response after Grok extension notifications in the same batch",+ () =>+ Effect.gen(function* () {+ const { stdio, input, output } = yield* makeInMemoryStdio();+ const scope = yield* Scope.make();+ const acp = yield* AcpClient.make(stdio).pipe(Effect.provideService(Scope.Scope, scope));++ const promptFiber = yield* acp.agent+ .prompt({+ sessionId: "grok-session-1",+ prompt: [{ type: "text", text: "run the ls command" }],+ })+ .pipe(Effect.forkScoped);++ const outbound = yield* Queue.take(output);+ const decodedPrompt = yield* decodePromptRequestLine(outbound);++ const responseBatch = concatBytes(+ yield* Effect.all([+ encodeJsonl(XAiQueueChangedNotification, {+ jsonrpc: "2.0",+ method: "_x.ai/queue/changed",+ params: { sessionId: "grok-session-1", entries: [] },+ }),+ encodeJsonl(XAiPromptCompleteNotification, {+ jsonrpc: "2.0",+ method: "_x.ai/session/prompt_complete",+ params: {+ sessionId: "grok-session-1",+ promptId: "prompt-1",+ stopReason: "end_turn",+ agentResult: null,+ },+ }),+ encodeJsonl(XAiSessionsChangedNotification, {+ jsonrpc: "2.0",+ method: "_x.ai/sessions/changed",+ params: {+ upserted: [+ {+ sessionId: "grok-session-1",+ title: null,+ cwd: process.cwd(),+ isWorktree: false,+ modelId: "grok-composer-2.5-fast",+ yolo: false,+ activity: "idle",+ resident: true,+ lastChangeUnixMs: 1_710_000_000_000,+ origin: { kind: "local" },+ },+ ],+ removed: [],+ },+ }),+ encodeJsonl(PromptResponse, {+ jsonrpc: "2.0",+ id: decodedPrompt.id,+ result: {+ stopReason: "end_turn",+ _meta: {+ sessionId: "grok-session-1",+ requestId: "prompt-1",+ promptId: "prompt-1",+ modelId: "grok-composer-2.5-fast",+ },+ },+ }),+ ]),+ );+ yield* Queue.offer(input, responseBatch);++ assert.deepEqual(yield* Fiber.join(promptFiber), {+ stopReason: "end_turn",+ _meta: {+ sessionId: "grok-session-1",+ requestId: "prompt-1",+ promptId: "prompt-1",+ modelId: "grok-composer-2.5-fast",+ },+ });+ yield* Scope.close(scope, Exit.void);+ }),+ );});