diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index 76b7a5948741b..47cedeefc1c9e 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -1462,6 +1462,126 @@ describe("OpenCodeAdapterV2", () => { }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer))), ); + // After a restart the adapter no longer holds the child, so its earlier turns come from OpenCode. + it.effect.each([ + { case: "in memory", restarted: false }, + { case: "after a restart", restarted: true }, + ])("appends a resumed task child's turn after its earlier turns ($case)", ({ restarted }) => + Effect.gen(function* () { + const nativeEvents = asyncEventStream(); + const push = (event: unknown) => Effect.promise(() => nativeEvents.push(event)); + const root = "ses_root"; + const child = "ses_child"; + let promptId = ""; + const harness = yield* makeOpenCodeRuntimeHarness("resumed-child", root, { + event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, + session: { + create: async () => ({ data: { id: root, time: { created: 1, updated: 1 } } }), + get: async () => ({ + data: { id: child, parentID: root, permission: [], time: { created: 2, updated: 2 } }, + }), + update: async () => ({ data: { id: child, parentID: root } }), + promptAsync: async (input: { messageID: string }) => { + promptId = input.messageID; + return { data: true }; + }, + abort: async () => ({ data: true }), + children: async () => ({ data: [] }), + // OpenCode may have stored the resume prompt before its event reaches the adapter. + messages: async () => ({ + data: [ + { info: { id: "msg_child_first", role: "user" }, parts: [] }, + { info: { id: "msg_child_resume", role: "user" }, parts: [] }, + ], + }), + }, + }); + yield* harness.startTurn(); + const childTurns = yield* harness.runtime.events.pipe( + Stream.filter( + (event) => + event.type === "provider_turn.updated" && + event.providerTurn.status === "running" && + event.providerTurn.providerThreadId.includes(child), + ), + Stream.take(restarted ? 1 : 2), + Stream.runCollect, + Effect.forkScoped, + ); + const taskPart = (partId: string, status: "running" | "completed", taskId?: string) => ({ + type: "message.part.updated", + properties: { + sessionID: root, + part: { + id: partId, + sessionID: root, + messageID: "msg_root_assistant", + type: "tool", + tool: "task", + callID: `call_${partId}`, + state: { + status, + input: { + description: "Explore", + prompt: "look around", + subagent_type: "general", + ...(taskId === undefined ? {} : { task_id: taskId }), + }, + title: "Explore", + metadata: { parentSessionId: root, sessionId: child }, + time: { start: 3, ...(status === "completed" ? { end: 4 } : {}) }, + ...(status === "completed" ? { output: "done" } : {}), + }, + }, + }, + }); + const childPrompt = (id: string, created: number) => ({ + type: "message.updated", + properties: { + sessionID: child, + info: { id, sessionID: child, role: "user", time: { created } }, + }, + }); + const status = (sessionID: string, type: "busy" | "idle") => ({ + type: "session.status", + properties: { sessionID, status: { type } }, + }); + + yield* push({ + type: "message.updated", + properties: { + sessionID: root, + info: { id: promptId, sessionID: root, role: "user", time: { created: 1 } }, + }, + }); + yield* push(status(root, "busy")); + if (!restarted) { + yield* push(taskPart("prt_task_first", "running")); + yield* push(childPrompt("msg_child_first", 3)); + yield* push(status(child, "busy")); + yield* push(status(child, "idle")); + yield* push({ type: "session.idle", properties: { sessionID: child } }); + yield* push(taskPart("prt_task_first", "completed")); + } + // The lead resumes the same child session by passing its task_id. + yield* push(taskPart("prt_task_resume", "running", child)); + yield* push(childPrompt("msg_child_resume", 5)); + yield* push(status(child, "busy")); + + const turns = Array.from(yield* Fiber.join(childTurns)).flatMap((event) => + event.type === "provider_turn.updated" ? [event.providerTurn] : [], + ); + assert.equal(new Set(turns.map((turn) => turn.providerThreadId)).size, 1); + assert.deepEqual( + turns.map((turn) => turn.ordinal), + restarted ? [2] : [1, 2], + ); + }).pipe( + Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)), + Effect.scoped, + ), + ); + it.effect("projects OpenCode read output and search titles from native tool calls", () => Effect.gen(function* () { const directoryOutput = diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index 4459a219aa7d3..b017a8861f408 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -378,7 +378,8 @@ interface OpenCodeThreadState { readonly messageRoles: Map; readonly userMessageIds: Array; parentSubagent: OpenCodeSubagentContext | null; - nextChildTurnOrdinal: number; + // null: a child resumed after a restart, whose next ordinal is recovered from OpenCode. + nextChildTurnOrdinal: number | null; nextAdmissionGeneration: number; permission: PermissionRuleset; /** Parent rules last written into this child's `permission`; empty for root sessions. */ @@ -1308,6 +1309,22 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function }); }); + // A child turn's ordinal never exceeds its user message's position in the session, and that + // position survives restarts, so it stays above every ordinal allocated before. + const storedUserMessagePosition = Effect.fnUntraced(function* ( + childSessionId: string, + messageId: string, + ) { + const response = yield* sdkCall("session.messages", { sessionID: childSessionId }, () => + client.session.messages({ sessionID: childSessionId }), + ); + const userMessageIds = unwrapData("session.messages", response).flatMap((entry) => + entry.info.role === "user" ? [entry.info.id] : [], + ); + const index = userMessageIds.indexOf(messageId); + return (index === -1 ? userMessageIds.length : index) + 1; + }); + const emitSubagent = Effect.fnUntraced(function* ( state: OpenCodeThreadState, turn: ActiveOpenCodeTurn, @@ -1416,6 +1433,15 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function permission: childPermission, }), ); + // A Task call with task_id resumes the child, whose earlier turns already hold ordinals. + const knownChild = threads.get(childSessionId); + const resumedChild = knownChild?.parentSubagent == null ? undefined : knownChild; + const nextChildTurnOrdinal = + resumedChild === undefined + ? recordString(input, "task_id") === childSessionId + ? null + : 1 + : resumedChild.nextChildTurnOrdinal; threads.set(childSessionId, { nativeSessionId: childSessionId, providerThread: childProviderThread, @@ -1423,10 +1449,10 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function activeTurn: null, providerTurns: new Map(), runtimeRequests: new Map(), - messageRoles: new Map(), - userMessageIds: [], + messageRoles: resumedChild?.messageRoles ?? new Map(), + userMessageIds: resumedChild?.userMessageIds ?? [], parentSubagent: context, - nextChildTurnOrdinal: 1, + nextChildTurnOrdinal, nextAdmissionGeneration: 1, permission: childPermission, inheritedPermission: openCodePermissionRules(turn.runtimePolicy), @@ -2222,6 +2248,10 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function message: Extract, ) { if (state.appThread === null || state.parentSubagent === null) return null; + const ordinal = + state.nextChildTurnOrdinal ?? + (yield* storedUserMessagePosition(state.nativeSessionId, message.id)); + state.nextChildTurnOrdinal = ordinal + 1; const now = yield* DateTime.now; const startedAt = dateTimeFromEpoch(message.time.created, now); const rootNodeId = idAllocator.derive.nodeFromProviderItem({ @@ -2238,7 +2268,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function nodeId: rootNodeId, runAttemptId: null, nativeTurnRef: providerRef(message.id, "weak"), - ordinal: state.nextChildTurnOrdinal++, + ordinal, status: "running", startedAt, completedAt: null,