fix: implement robust session exit condition for reasoning models and tool execution

- Add comprehensive exit logic handling reasoning blocks, text content, and tool calls
- Prevent premature exit on reasoning-only messages (thinking/thoughts)
- Properly handle combinations: reasoning+text, text+tools, reasoning+tools
- Support both separated thinking (reasoning blocks) and interleaved thinking models
- Check for pending or running tools before exiting session processing loop
- Add hasRunningOrPendingTools() function with defensive error handling
- Fix TypeScript type inference issues with MessageV2.User and MessageV2.WithParts
- Add explicit type casting for proper property access and message comparison

This makes session processing more reliable across different AI model types
and response patterns, especially for reasoning-capable models. The fix
ensures tools complete execution before considering the session done,
regardless of execution pattern (sequential or parallel).

Author: no1wudi

packages/opencode/src/session/prompt.ts

@@ -250,15 +250,20 @@ export namespace SessionPrompt {
       let msgs = await MessageV2.filterCompacted(MessageV2.stream(sessionID))
 
       let lastUser: MessageV2.User | undefined
-      let lastAssistant: MessageV2.Assistant | undefined
+      let lastAssistant: MessageV2.WithParts | undefined
       let lastFinished: MessageV2.Assistant | undefined
       let tasks: (MessageV2.CompactionPart | MessageV2.SubtaskPart)[] = []
       for (let i = msgs.length - 1; i >= 0; i--) {
         const msg = msgs[i]
-        if (!lastUser && msg.info.role === "user") lastUser = msg.info as MessageV2.User
-        if (!lastAssistant && msg.info.role === "assistant") lastAssistant = msg.info as MessageV2.Assistant
-        if (!lastFinished && msg.info.role === "assistant" && msg.info.finish)
+        if (!lastUser && msg.info.role === "user") {
+          lastUser = msg.info as MessageV2.User
+        }
+        if (!lastAssistant && msg.info.role === "assistant") {
+          lastAssistant = msg
+        }
+        if (!lastFinished && msg.info.role === "assistant" && msg.info.finish) {
           lastFinished = msg.info as MessageV2.Assistant
+        }
         if (lastUser && lastFinished) break
         const task = msg.parts.filter((part) => part.type === "compaction" || part.type === "subtask")
         if (task && !lastFinished) {
@@ -267,13 +272,38 @@ export namespace SessionPrompt {
       }
 
       if (!lastUser) throw new Error("No user message found in stream. This should never happen.")
-      if (
-        lastAssistant?.finish &&
-        !["tool-calls", "unknown"].includes(lastAssistant.finish) &&
-        lastUser.id < lastAssistant.id
-      ) {
-        log.info("exiting loop", { sessionID })
-        break
+
+      // Exit Loop When:
+      // • Text + Reasoning → Complete response ready
+      // • Text Only → Normal response ready
+      //
+      // Continue Loop When:
+      // • Reasoning Only → Wait for text content
+      // • Any tool calls pending → Tools must execute first
+      // • Text + Tools → Tools executing needed
+      // • Invalid/error state → Unexpected condition
+
+      const hasReasoningBlocks = lastAssistant?.parts.some((part) => part.type === "reasoning")
+      const hasTextContent = lastAssistant?.parts.some((part) => part.type === "text")
+      const hasOnlyReasoning = hasReasoningBlocks && !hasTextContent
+
+      // Check if there are pending or running tools for the last assistant message
+      const hasPendingTools = lastAssistant
+        ? await hasRunningOrPendingTools((lastAssistant.info as MessageV2.Assistant).id)
+        : false
+
+      if (lastAssistant?.info.role === "assistant" && lastAssistant.info.finish) {
+        const hasToolCalls = lastAssistant.info.finish === "tool-calls"
+        const hasTextAndToolCalls = hasTextContent && hasToolCalls
+        const hasValidFinish = !["tool-calls", "unknown"].includes(lastAssistant.info.finish)
+        const hasValidIds = (lastUser as MessageV2.User).id < (lastAssistant.info as MessageV2.Assistant).id
+        const shouldExit =
+          hasValidFinish && hasValidIds && !hasOnlyReasoning && !hasTextAndToolCalls && !hasPendingTools
+
+        if (shouldExit) {
+          log.info("exiting loop", { sessionID })
+          break
+        }
       }
 
       step++
@@ -360,7 +390,7 @@ export namespace SessionPrompt {
               },
             },
           )
-          .catch(() => {})
+          .catch(() => { })
         assistantMessage.finish = "tool-calls"
         assistantMessage.time.completed = Date.now()
         await Session.updateMessage(assistantMessage)
@@ -539,10 +569,10 @@ export namespace SessionPrompt {
         headers: {
           ...(model.providerID.startsWith("opencode")
             ? {
-                "x-opencode-project": Instance.project.id,
-                "x-opencode-session": sessionID,
-                "x-opencode-request": lastUser.id,
-              }
+              "x-opencode-project": Instance.project.id,
+              "x-opencode-session": sessionID,
+              "x-opencode-request": lastUser.id,
+            }
             : undefined),
           ...model.headers,
         },
@@ -914,7 +944,7 @@ export namespace SessionPrompt {
                       agent: input.agent!,
                       messageID: info.id,
                       extra: { bypassCwdCheck: true, model },
-                      metadata: async () => {},
+                      metadata: async () => { },
                     })
                     pieces.push({
                       id: Identifier.ascending("part"),
@@ -974,7 +1004,7 @@ export namespace SessionPrompt {
                     agent: input.agent!,
                     messageID: info.id,
                     extra: { bypassCwdCheck: true },
-                    metadata: async () => {},
+                    metadata: async () => { },
                   }),
                 )
                 return [
@@ -1377,14 +1407,14 @@ export namespace SessionPrompt {
     const parts =
       (agent.mode === "subagent" && command.subtask !== false) || command.subtask === true
         ? [
-            {
-              type: "subtask" as const,
-              agent: agent.name,
-              description: command.description ?? "",
-              // TODO: how can we make task tool accept a more complex input?
-              prompt: await resolvePromptParts(template).then((x) => x.find((y) => y.type === "text")?.text ?? ""),
-            },
-          ]
+          {
+            type: "subtask" as const,
+            agent: agent.name,
+            description: command.description ?? "",
+            // TODO: how can we make task tool accept a more complex input?
+            prompt: await resolvePromptParts(template).then((x) => x.find((y) => y.type === "text")?.text ?? ""),
+          },
+        ]
         : await resolvePromptParts(template)
 
     const result = (await prompt({
@@ -1405,6 +1435,18 @@ export namespace SessionPrompt {
     return result
   }
 
+  async function hasRunningOrPendingTools(messageID: string): Promise<boolean> {
+    try {
+      const parts = await MessageV2.parts(messageID)
+      return parts.some(
+        (part) => part.type === "tool" && (part.state.status === "running" || part.state.status === "pending"),
+      )
+    } catch {
+      // If we can't read the parts, assume no pending tools
+      return false
+    }
+  }
+
   async function ensureTitle(input: {
     session: Session.Info
     message: MessageV2.WithParts