Merge branch 'main' into feat/view-local-state-base

Author: easonLiangWorldedtech

.github/workflows/code-qa.yml

@@ -170,3 +170,17 @@ jobs:
                   disable_search: true
                   flags: ${{ matrix.codecov-flag }},core-integration
                   token: ${{ secrets.CODECOV_TOKEN }}
+            - name: Upload coverage reports to GitHub
+              if: matrix.upload-coverage
+              uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+              with:
+                  name: coverage-reports-${{ matrix.name }}
+                  path: |
+                      src/coverage/lcov.info
+                      webview-ui/coverage/lcov.info
+                      packages/cloud/coverage/lcov.info
+                      packages/telemetry/coverage/lcov.info
+                      apps/cli/coverage/lcov.info
+                      packages/core/coverage/unit/lcov.info
+                      packages/core/coverage/integration/lcov.info
+                  retention-days: 7

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Zoo Code Changelog
 
+## [3.70.0]
+
+### Minor Changes
+
+- Add Kenari as a first-class provider, an Indonesian OpenAI-compatible AI gateway billed in Rupiah covering Claude, GPT, DeepSeek, GLM, Kimi and more (#792 by @doedja, PR #793 by @doedja)
+- Add OpenAI GPT-5.6 family support (sol, terra, luna) across both OpenAI Codex and OpenAI Native provider paths (#871 by @xRaTcHeT302, PR #876 by @navedmerchant)
+- Add Grok 4.5 support and fix a latent xAI reasoning-effort format bug affecting Grok 4 Mini (#866 by @navedmerchant, PR #867 by @navedmerchant)
+- Surface the context-compaction button and context window progress bar in the collapsed task header so context pressure can be monitored and acted on without expanding it (#606 by @awschmeder, PR #680 by @awschmeder)
+- Fix(terminal): fix output loss and premature task completion on cold terminals by reading command output only after shell execution actually starts (#800 by @juneleung, PR #834 by @edelauna)
+- Fix(zoo-gateway): enable image attach for Zoo Gateway and Vercel AI Gateway models based on live vision-capability tags instead of a static allowlist (PR #897 by @JamesRobert20)
+- Chore(deps): routine dependency updates (PRs #807-#828 by @app/renovate)
+
 ## [3.68.0]
 
 ### Minor Changes

README.md

@@ -16,35 +16,17 @@
 
 ## We are Zoo Code
 
-> You may have seen the
-> [recent announcement](https://x.com/mattrubens/status/2046636598859559114)
-> from the Roo team 🦘🦘🦘. The TLDR is the team is winding down active Roo
-> Code development as they focus on [Roomote](https://roomote.dev/). That news
-> was difficult for many Roo users, this plugin means a lot to this community.
+> Zoo Code continues development of this project after the Roo team wound down
+> active Roo Code work to focus on [Roomote](https://roomote.dev/). Thank you
+> to the Roo team for everything they built.
 >
-> We want to thank the entire Roo team for the work they put into this plugin.
-> We won't call out each person by name here, but we can all agree they are
-> exceptional developers and, just as importantly, incredible people. Thank you
-> to the Roo team.
->
-> As Roo coders, we come in all kinds of shapes and sizes. Some of us are using
-> it professionally in our day-to-day work, some are using it to tinker and
-> scheme unimaginably complicated workflows. Some are using it to improve Roo
-> itself while others are using it to improve the very models that Roo is using
-> (super meta). The point we are making is that the community is
-> diverse, and although a kangaroo 🦘🦘🦘 is a distinguished and noble animal,
-> we felt a "Zoo" 🐘🦡🦒🦓🦛🦧🦭🦦 of different species better reflected this
-> diversity of the plugin's users.
->
-> So we would like to announce that **Zoo Code** will continue development on
-> this important project. The core team is a group of developers who contributed
-> to Roo previously and care deeply about this plugin. We will continue to make
-> model updates, fix bugs, and release features. But more than anything, we plan
-> to listen to the community that made this plugin so special. Feel free to join
-> us on [Discord](https://discord.gg/VxfP4Vx3gX),
+> The core team is a group of developers who contributed to Roo previously and
+> care deeply about this plugin. We will continue to make model updates, fix
+> bugs, and release features, and we plan to listen closely to the community
+> that made this plugin so special. Join us on
+> [Discord](https://discord.gg/VxfP4Vx3gX),
 > [Reddit](https://www.reddit.com/r/ZooCode), or
-> [open a PR or issue](https://github.com/Zoo-Code-Org/Zoo-Code), and above all,
-> please stay involved, connected, and active as a community.
+> [open a PR or issue](https://github.com/Zoo-Code-Org/Zoo-Code).
 >
 > _-Zoo Code Team_
 
@@ -53,15 +35,15 @@
 You can find a quick guide for migrating from Roo Code to Zoo Code in the [Roo→Zoo migration guide](https://docs.zoocode.dev/roo-to-zoo-migration). We plan to try and help users as they transition over, we have our [Reddit](https://www.reddit.com/r/ZooCode) and [Discord](https://discord.gg/VxfP4Vx3gX)
 for this exact support, so if you are having problems or if you have question, jump on and ask.
 
-## What's New in v3.68.0
+## What's New in v3.70.0
 
-- **Friendli provider with GLM-5.2 support** — use the latest GLM model through Friendli.
-- **Native Ollama thinking/reasoning support** — preserve reasoning output end-to-end when you use Ollama models.
-- **Anthropic custom `apiModelId` fix** — custom Anthropic model IDs now stay selected instead of silently falling back to `claude-sonnet-4-5`.
-- Fix: Ollama provider tool result handling and premature context condensing.
-- Fix: preserve the parent-child task link when a delegated subtask is interrupted.
-- Improve Anthropic Vertex Claude content block handling for more reliable responses.
-- CI, nightly publishing, and dependency/tooling updates.
+- **OpenAI GPT-5.6 family** — `Sol`, `Terra`, and `Luna` are now available across both the OpenAI Codex and OpenAI Native provider paths.
+- **Grok 4.5 support** — xAI's new flagship model, plus a reasoning-effort format fix that also benefits Grok 4 Mini.
+- **Kenari provider support** — a first-class, OpenAI-compatible AI gateway billed in Rupiah covering Claude, GPT, DeepSeek, GLM, Kimi and more.
+- Surface the context-compaction button and context window progress bar in the collapsed task header.
+- Fix: terminal output loss and premature task completion on cold terminals.
+- Fix: image attach for Zoo Gateway and Vercel AI Gateway models now follows live vision-capability tags instead of a static allowlist.
+- Dependency and tooling updates.
 
 <details>
   <summary>🌐 Available languages</summary>

apps/vscode-e2e/src/fixtures/subtasks.ts

@@ -7,6 +7,8 @@ const SUBTASK_PARENT_MARKER = "SUBTASK_PARENT_CANCELLATION_SMOKE"
 const SUBTASK_CHILD_MARKER = "SUBTASK_CHILD_CALCULATOR_SMOKE"
 const SUBTASK_INTERRUPT_PARENT_MARKER = "SUBTASK_PARENT_INTERRUPT_RESUME"
 const SUBTASK_INTERRUPT_CHILD_MARKER = "SUBTASK_CHILD_INTERRUPT_RESUME"
+export const SUBTASK_API_HANG_PARENT_MARKER = "SUBTASK_PARENT_API_HANG_INTERRUPT_RESUME"
+export const SUBTASK_API_HANG_CHILD_MARKER = "SUBTASK_CHILD_API_HANG_INTERRUPT_RESUME"
 const SUBTASK_FAST_PARENT_MARKER = "SUBTASK_PARENT_IMMEDIATE_COMPLETION"
 const SUBTASK_FAST_CHILD_MARKER = "SUBTASK_CHILD_IMMEDIATE_COMPLETION"
 const SUBTASK_XPROFILE_PARENT_MARKER = "SUBTASK_PARENT_CROSS_PROFILE"
@@ -24,13 +26,21 @@ export const SUBTASK_INTERRUPT_PARENT_PROMPT = `${SUBTASK_INTERRUPT_PARENT_MARKE
 export const SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER = "9"
 export const SUBTASK_INTERRUPT_PARENT_RESULT = "Interrupted parent resumed"
 
+const SUBTASK_API_HANG_CHILD_PROMPT = `${SUBTASK_API_HANG_CHILD_MARKER}: Complete with the exact result "Hung child completed".`
+export const SUBTASK_API_HANG_PARENT_PROMPT = `${SUBTASK_API_HANG_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${SUBTASK_API_HANG_CHILD_PROMPT}" Do not answer directly. When the subtask returns, complete with the exact result "API hang parent resumed".`
+export const SUBTASK_API_HANG_RESUME_MESSAGE = "Continue after provider hang."
+export const SUBTASK_API_HANG_CHILD_RESULT = "Hung child completed"
+export const SUBTASK_API_HANG_PARENT_RESULT = "API hang parent resumed"
+
 const SUBTASK_XPROFILE_SAME_CHILD_PROMPT = `${SUBTASK_XPROFILE_SAME_CHILD_MARKER}: Complete immediately with the exact result "Same-profile child completed".`
 const SUBTASK_XPROFILE_DIFFERENT_CHILD_PROMPT = `${SUBTASK_XPROFILE_DIFFERENT_CHILD_MARKER}: Complete immediately with the exact result "Different-profile child completed".`
 export const SUBTASK_XPROFILE_PARENT_PROMPT = `${SUBTASK_XPROFILE_PARENT_MARKER}: First use new_task to create a code-mode subtask with this exact message: "${SUBTASK_XPROFILE_SAME_CHILD_PROMPT}" After it returns, create an ask-mode subtask with the next instructions you receive.`
 export const SUBTASK_XPROFILE_SAME_CHILD_RESULT = "Same-profile child completed"
 export const SUBTASK_XPROFILE_DIFFERENT_CHILD_RESULT = "Different-profile child completed"
 export const SUBTASK_XPROFILE_PARENT_RESULT = "Sequential cross-profile parent resumed"
 
+const apiHangChildMatch = new RegExp(SUBTASK_API_HANG_CHILD_MARKER)
+
 const requestContains = (req: ChatCompletionRequest, expected: string[]) => {
 	const rawRequest = JSON.stringify(req)
 	return expected.every((text) => rawRequest.includes(text))
@@ -167,6 +177,79 @@ export function addSubtaskFixtures(mock: InstanceType<typeof LLMock>) {
 		},
 	})
 
+	mock.addFixture({
+		match: {
+			userMessage: new RegExp(SUBTASK_API_HANG_PARENT_MARKER),
+			sequenceIndex: 0,
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "new_task",
+					arguments: JSON.stringify({
+						mode: "ask",
+						message: SUBTASK_API_HANG_CHILD_PROMPT,
+					}),
+					id: "call_api_hang_parent_new_task_001",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			userMessage: apiHangChildMatch,
+			sequenceIndex: 0,
+		},
+		// Keep the first child response pending long enough for the e2e test to cancel an in-flight API request.
+		latency: 15_000,
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: SUBTASK_API_HANG_CHILD_RESULT }),
+					id: "call_api_hang_child_completion_002",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			userMessage: apiHangChildMatch,
+			sequenceIndex: 1,
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: SUBTASK_API_HANG_CHILD_RESULT }),
+					id: "call_api_hang_child_completion_003",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				requestContains(req, [
+					SUBTASK_API_HANG_PARENT_MARKER,
+					"call_api_hang_parent_new_task_001",
+					SUBTASK_API_HANG_CHILD_RESULT,
+				]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: SUBTASK_API_HANG_PARENT_RESULT }),
+					id: "call_api_hang_parent_completion_004",
+				},
+			],
+		},
+	})
+
 	// Issue #457 sequence: a same-profile child returns first, then the resumed
 	// parent delegates to a child whose mode uses a different API profile.
 	mock.addFixture({

apps/vscode-e2e/src/suite/subtasks.test.ts

@@ -5,6 +5,12 @@ import { RooCodeEventName, type ClineMessage } from "@roo-code/types"
 import { setDefaultSuiteTimeout } from "./test-utils"
 import { sleep, waitFor, waitUntilCompleted } from "./utils"
 import {
+	SUBTASK_API_HANG_CHILD_RESULT,
+	SUBTASK_API_HANG_CHILD_MARKER,
+	SUBTASK_API_HANG_PARENT_MARKER,
+	SUBTASK_API_HANG_PARENT_PROMPT,
+	SUBTASK_API_HANG_PARENT_RESULT,
+	SUBTASK_API_HANG_RESUME_MESSAGE,
 	SUBTASK_CHILD_FOLLOWUP_ANSWER,
 	SUBTASK_FAST_PARENT_PROMPT,
 	SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER,
@@ -17,6 +23,45 @@ import {
 	SUBTASK_XPROFILE_SAME_CHILD_RESULT,
 } from "../fixtures/subtasks"
 
+type AimockMessageContent = string | Array<{ type?: string; text?: string }>
+
+type AimockJournalEntry = {
+	body?: {
+		messages?: Array<{
+			role?: string
+			content?: AimockMessageContent
+		}>
+	}
+}
+
+const messageContentText = (content?: AimockMessageContent) => {
+	if (typeof content === "string") {
+		return content
+	}
+
+	return content?.map((part) => part.text ?? "").join("") ?? ""
+}
+
+const waitForAimockRequestContaining = async (expectedText: string, excludeText?: string) => {
+	const aimockUrl = process.env.AIMOCK_URL
+	assert.ok(aimockUrl, "AIMOCK_URL must be set for aimock journal assertions")
+
+	await waitFor(async () => {
+		const response = await fetch(`${aimockUrl}/__aimock/journal`)
+		const entries = (await response.json()) as AimockJournalEntry[]
+
+		return entries.some((entry) => {
+			const messages = entry.body?.messages
+			if (!messages) return false
+			const entryText = messages.map((m) => messageContentText(m.content)).join("")
+			if (excludeText && entryText.includes(excludeText)) return false
+			return messages.some(
+				(message) => message.role === "user" && messageContentText(message.content).includes(expectedText),
+			)
+		})
+	})
+}
+
 suite("Roo Code Subtasks", function () {
 	setDefaultSuiteTimeout(this)
 
@@ -412,6 +457,113 @@ suite("Roo Code Subtasks", function () {
 		}
 	})
 
+	// Issue #566: a child interrupted while its provider request is still pending
+	// must keep its parent link when manually resumed and completed.
+	test("API-hung interrupted child resumes and returns to parent", async () => {
+		const api = globalThis.api
+		const asks: Record<string, ClineMessage[]> = {}
+		const says: Record<string, ClineMessage[]> = {}
+
+		const messageHandler = ({ taskId, message }: { taskId: string; message: ClineMessage }) => {
+			if (message.type === "ask") {
+				asks[taskId] = asks[taskId] || []
+				asks[taskId].push(message)
+			}
+			if (message.type === "say" && message.partial === false) {
+				says[taskId] = says[taskId] || []
+				says[taskId].push(message)
+			}
+		}
+
+		api.on(RooCodeEventName.Message, messageHandler)
+
+		try {
+			const parentTaskId = await api.startNewTask({
+				configuration: {
+					mode: "ask",
+					alwaysAllowModeSwitch: true,
+					alwaysAllowSubtasks: true,
+					autoApprovalEnabled: true,
+					enableCheckpoints: false,
+				},
+				text: SUBTASK_API_HANG_PARENT_PROMPT,
+			})
+
+			let childTaskId: string | undefined
+			await waitFor(() => {
+				const stack = api.getCurrentTaskStack()
+				const current = stack[stack.length - 1]
+				if (current && current !== parentTaskId) {
+					childTaskId = current
+					return true
+				}
+				return false
+			})
+
+			await waitForAimockRequestContaining(SUBTASK_API_HANG_CHILD_MARKER, SUBTASK_API_HANG_PARENT_MARKER)
+
+			await api.cancelCurrentTask()
+
+			await waitFor(() => api.getCurrentTaskStack().at(-1) === childTaskId)
+			await waitFor(
+				() => asks[childTaskId!]?.some(({ type, ask }) => type === "ask" && ask === "resume_task") ?? false,
+			)
+
+			const interruptedChild = await api.getTaskHistoryItem(childTaskId!)
+			assert.strictEqual(interruptedChild?.status, "interrupted", "Child should be interrupted after manual stop")
+			assert.strictEqual(
+				interruptedChild?.parentTaskId,
+				parentTaskId,
+				"Interrupted child should retain its parent link before resume",
+			)
+
+			const completedParentTaskId = await waitUntilCompleted({
+				api,
+				start: async () => {
+					await api.sendMessage(SUBTASK_API_HANG_RESUME_MESSAGE)
+					return parentTaskId
+				},
+			})
+
+			assert.strictEqual(
+				completedParentTaskId,
+				parentTaskId,
+				"Parent task should complete after API-hung child resumes and reports back",
+			)
+			assert.strictEqual(
+				says[childTaskId!]
+					?.filter(({ say }) => say === "completion_result")
+					.map(({ text }) => text?.trim())
+					.find((text) => text === SUBTASK_API_HANG_CHILD_RESULT),
+				SUBTASK_API_HANG_CHILD_RESULT,
+				"Child should complete with its expected result after resume",
+			)
+			assert.strictEqual(
+				says[parentTaskId]
+					?.filter(({ say }) => say === "completion_result")
+					.map(({ text }) => text?.trim())
+					.find((text) => text === SUBTASK_API_HANG_PARENT_RESULT),
+				SUBTASK_API_HANG_PARENT_RESULT,
+				"Parent should resume and complete with its expected result",
+			)
+
+			const parent = await api.getTaskHistoryItem(parentTaskId)
+			assert.notStrictEqual(parent?.status, "delegated", "Parent history should not remain delegated")
+			assert.strictEqual(parent?.awaitingChildId, undefined, "Parent awaitingChildId should be cleared")
+			assert.strictEqual(parent?.completedByChildId, childTaskId, "Parent should record completed child")
+
+			const child = await api.getTaskHistoryItem(childTaskId!)
+			assert.strictEqual(child?.status, "completed", "Child history should be completed")
+			assert.strictEqual(child?.parentTaskId, parentTaskId, "Completed child should still point to parent")
+		} finally {
+			api.off(RooCodeEventName.Message, messageHandler)
+			while (api.getCurrentTaskStack().length > 0) {
+				await api.clearCurrentTask()
+			}
+			await waitFor(() => api.getCurrentTaskStack().length === 0).catch(() => {})
+		}
+	})
+
 	test("same-profile child returns before a different-profile child", async () => {
 		const api = globalThis.api
 		const says: Record<string, ClineMessage[]> = {}