feat(dte): dynamic thinking effort (series PRs 1-5 + e2e addenda + F7)

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

@@ -627,3 +627,192 @@ export function addSubtaskFixtures(mock: InstanceType<typeof LLMock>) {
 		},
 	})
 }
+
+// ---------------------------------------------------------------------------
+// DTE series 5/5 — new_task thinking_effort pass-through (e2e).
+//
+// Three scenarios with unique, stable markers (no timestamps, no environment
+// details):
+// - INHERIT:  the parent's new_task call carries NO thinking_effort — the child
+//   starts with the parent's current effective effort (PR-2 resolution) and the
+//   child's real request must carry it.
+// - EXPLICIT: the parent's new_task call carries thinking_effort "high" on a
+//   model with a capability array — validation passes and the child subtask
+//   runs to completion on the real host.
+// - NEGATIVE: the parent's new_task call carries thinking_effort on a model
+//   without a capability array — the tool rejects before the approval ask, no
+//   child is created, and the error is visible to the model.
+export const DTE_NT_INHERIT_PARENT_MARKER = "DTE_E2E_NT_INHERIT_PARENT"
+export const DTE_NT_INHERIT_CHILD_MARKER = "DTE_E2E_NT_INHERIT_CHILD"
+const DTE_NT_INHERIT_CHILD_PROMPT = `${DTE_NT_INHERIT_CHILD_MARKER}: Complete immediately with the exact result "DTE inherit child completed".`
+export const DTE_NT_INHERIT_PARENT_PROMPT = `${DTE_NT_INHERIT_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${DTE_NT_INHERIT_CHILD_PROMPT}" Do not answer directly. When the subtask returns, complete with the exact result "DTE inherit parent resumed".`
+export const DTE_NT_INHERIT_CHILD_RESULT = "DTE inherit child completed"
+export const DTE_NT_INHERIT_PARENT_RESULT = "DTE inherit parent resumed"
+
+const DTE_NT_EXPLICIT_PARENT_MARKER = "DTE_E2E_NT_EXPLICIT_PARENT"
+const DTE_NT_EXPLICIT_CHILD_MARKER = "DTE_E2E_NT_EXPLICIT_CHILD"
+const DTE_NT_EXPLICIT_CHILD_PROMPT = `${DTE_NT_EXPLICIT_CHILD_MARKER}: Complete immediately with the exact result "DTE explicit child completed".`
+export const DTE_NT_EXPLICIT_PARENT_PROMPT = `${DTE_NT_EXPLICIT_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${DTE_NT_EXPLICIT_CHILD_PROMPT}" Do not answer directly. When the subtask returns, complete with the exact result "DTE explicit parent resumed".`
+export const DTE_NT_EXPLICIT_CHILD_RESULT = "DTE explicit child completed"
+export const DTE_NT_EXPLICIT_PARENT_RESULT = "DTE explicit parent resumed"
+
+export const DTE_NT_NEGATIVE_PARENT_MARKER = "DTE_E2E_NT_NEGATIVE_PARENT"
+const DTE_NT_NEGATIVE_CHILD_MARKER = "DTE_E2E_NT_NEGATIVE_CHILD"
+const DTE_NT_NEGATIVE_CHILD_PROMPT = `${DTE_NT_NEGATIVE_CHILD_MARKER}: Complete immediately with the exact result "DTE negative child completed".`
+export const DTE_NT_NEGATIVE_PARENT_PROMPT = `${DTE_NT_NEGATIVE_PARENT_MARKER}: Use the new_task tool exactly once, with thinking_effort set to "high". Create an ask-mode subtask with this exact message: "${DTE_NT_NEGATIVE_CHILD_PROMPT}" Do not answer directly. If the tool call is rejected, complete with the exact result "DTE negative parent completed".`
+export const DTE_NT_NEGATIVE_PARENT_RESULT = "DTE negative parent completed"
+
+export function addDteNewTaskEffortFixtures(mock: InstanceType<typeof LLMock>) {
+	// INHERIT: parent turn -> new_task without an explicit effort.
+	mock.addFixture({
+		match: {
+			userMessage: new RegExp(DTE_NT_INHERIT_PARENT_MARKER),
+			sequenceIndex: 0,
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "new_task",
+					arguments: JSON.stringify({
+						mode: "ask",
+						message: DTE_NT_INHERIT_CHILD_PROMPT,
+					}),
+					id: "call_dte_nt_inherit_new_task_001",
+				},
+			],
+		},
+	})
+
+	// Child turn: the child prompt is embedded verbatim in the parent prompt, so the
+	// parent-marker exclusion keeps parent turns out of this fixture (same collision
+	// class as the fast-child fixture above).
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				lastUserMessageContains(req, DTE_NT_INHERIT_CHILD_MARKER) &&
+				!requestContains(req, [DTE_NT_INHERIT_PARENT_MARKER]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: DTE_NT_INHERIT_CHILD_RESULT }),
+					id: "call_dte_nt_inherit_child_completion_002",
+				},
+			],
+		},
+	})
+
+	// Parent resume turn: guarded on the child-result injection (not the child result
+	// text, which the parent prompt embeds verbatim).
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				requestContains(req, [DTE_NT_INHERIT_PARENT_MARKER, SUBTASK_RESULT_INJECTION]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: DTE_NT_INHERIT_PARENT_RESULT }),
+					id: "call_dte_nt_inherit_parent_completion_003",
+				},
+			],
+		},
+	})
+
+	// EXPLICIT: parent turn -> new_task with thinking_effort "high" (valid on models
+	// whose capability array accepts it, e.g. deepseek-v4-pro).
+	mock.addFixture({
+		match: {
+			userMessage: new RegExp(DTE_NT_EXPLICIT_PARENT_MARKER),
+			sequenceIndex: 0,
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "new_task",
+					arguments: JSON.stringify({
+						mode: "ask",
+						message: DTE_NT_EXPLICIT_CHILD_PROMPT,
+						thinking_effort: "high",
+					}),
+					id: "call_dte_nt_explicit_new_task_001",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				lastUserMessageContains(req, DTE_NT_EXPLICIT_CHILD_MARKER) &&
+				!requestContains(req, [DTE_NT_EXPLICIT_PARENT_MARKER]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: DTE_NT_EXPLICIT_CHILD_RESULT }),
+					id: "call_dte_nt_explicit_child_completion_002",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				requestContains(req, [DTE_NT_EXPLICIT_PARENT_MARKER, SUBTASK_RESULT_INJECTION]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: DTE_NT_EXPLICIT_PARENT_RESULT }),
+					id: "call_dte_nt_explicit_parent_completion_003",
+				},
+			],
+		},
+	})
+
+	// NEGATIVE: parent turn -> new_task with thinking_effort "high" on a model without a
+	// capability array. The tool rejects before the approval ask, so the next parent
+	// turn is the error-recovery completion (matched on the tool-error text, which only
+	// appears in a request after the rejected call).
+	mock.addFixture({
+		match: {
+			userMessage: new RegExp(DTE_NT_NEGATIVE_PARENT_MARKER),
+			sequenceIndex: 0,
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "new_task",
+					arguments: JSON.stringify({
+						mode: "ask",
+						message: DTE_NT_NEGATIVE_CHILD_PROMPT,
+						thinking_effort: "high",
+					}),
+					id: "call_dte_nt_negative_new_task_001",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				requestContains(req, [DTE_NT_NEGATIVE_PARENT_MARKER, "Invalid thinking_effort"]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: DTE_NT_NEGATIVE_PARENT_RESULT }),
+					id: "call_dte_nt_negative_parent_completion_002",
+				},
+			],
+		},
+	})
+}

apps/vscode-e2e/src/fixtures/thinking-effort.ts

@@ -0,0 +1,159 @@
+import { LLMock } from "@copilotkit/aimock"
+import type { ChatCompletionRequest } from "@copilotkit/aimock"
+
+// DTE e2e fixtures for the thinking-effort-tool and thinking-effort-switching
+// suites. Replaces the former JSON fixtures (fixtures/thinking-effort-*.json):
+// post-tool requests end with a role:user message (fresh <environment_details>
+// is appended after the tool result), so aimock's toolCallId matcher — which
+// requires the LAST message to be role:tool — can never bind those continuation
+// turns, and JSON fixtures cannot carry predicates. Each turn is instead scoped
+// by a predicate that searches the whole request for its own flow identifiers:
+// the unique prompt marker for the baseline turn and the previous turn's unique
+// tool call id for the continuations (same pattern as deepseek-v4.ts). No other
+// suite can serve these responses and these suites cannot match unrelated turns.
+
+const SWITCH_MODEL = "openai/gpt-5.1"
+const APPLY_MODEL = "openai/gpt-5"
+const SWITCH_MARKER = "DTE_E2E_SWITCH"
+const APPLY_MARKER = "DTE_E2E_EFFORT_APPLY"
+const SWITCH_DONE = "DTE_E2E_SWITCH_DONE"
+
+// Post-tool requests carry the tool result of the PREVIOUS turn and nothing
+// appends another tool result before the next API call, so the LAST role:tool
+// message is exactly the call whose result this request follows.
+const lastToolCallId = (req: ChatCompletionRequest): string | undefined => {
+	const messages = Array.isArray(req?.messages) ? req.messages : []
+	return messages.filter((message) => message?.role === "tool").at(-1)?.tool_call_id
+}
+
+// aimock's userMessage matcher only inspects the LAST user message and joins
+// only the type:"text" content parts (getTextContent in aimock's router) — the
+// predicate replicates that semantics for the baseline turns.
+const lastUserMessageContains = (req: ChatCompletionRequest, text: string): boolean => {
+	const userMessages = req.messages?.filter((message) => message.role === "user") ?? []
+	const last = userMessages.at(-1)
+	if (!last) return false
+	const content =
+		typeof last.content === "string"
+			? last.content
+			: (last.content ?? [])
+					.filter((part): part is { type: "text"; text: string } => part?.type === "text")
+					.map((part) => part.text)
+					.join("")
+	return content.includes(text)
+}
+
+export function addThinkingEffortFixtures(mock: InstanceType<typeof LLMock>) {
+	// --- thinking-effort-switching suite (openai/gpt-5.1) ---
+	// Baseline turn: bound to this suite's unique prompt marker.
+	mock.addFixture({
+		match: {
+			model: SWITCH_MODEL,
+			predicate: (req: ChatCompletionRequest) => lastUserMessageContains(req, SWITCH_MARKER),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "set_thinking_effort",
+					arguments: JSON.stringify({ effort: "medium", reason: "start at medium" }),
+					id: "call_dte_sw_001",
+				},
+			],
+		},
+	})
+
+	// Continuations: each turn binds to the previous turn's unique tool call id,
+	// so a future flow on the same model cannot serve these responses.
+	const switchingContinuations: Array<{
+		afterCallId: string
+		effort: string
+		reason: string
+		responseCallId: string
+	}> = [
+		{
+			afterCallId: "call_dte_sw_001",
+			effort: "medium",
+			reason: "confirm current level",
+			responseCallId: "call_dte_sw_002",
+		},
+		{ afterCallId: "call_dte_sw_002", effort: "high", reason: "raise to high", responseCallId: "call_dte_sw_003" },
+		{
+			afterCallId: "call_dte_sw_003",
+			effort: "medium",
+			reason: "try returning to medium",
+			responseCallId: "call_dte_sw_004",
+		},
+	]
+	for (const continuation of switchingContinuations) {
+		mock.addFixture({
+			match: {
+				model: SWITCH_MODEL,
+				predicate: (req: ChatCompletionRequest) => lastToolCallId(req) === continuation.afterCallId,
+			},
+			response: {
+				toolCalls: [
+					{
+						name: "set_thinking_effort",
+						arguments: JSON.stringify({
+							effort: continuation.effort,
+							reason: continuation.reason,
+						}),
+						id: continuation.responseCallId,
+					},
+				],
+			},
+		})
+	}
+
+	// Final turn: after the refused oscillation call, the task completes.
+	mock.addFixture({
+		match: {
+			model: SWITCH_MODEL,
+			predicate: (req: ChatCompletionRequest) => lastToolCallId(req) === "call_dte_sw_004",
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: SWITCH_DONE }),
+					id: "call_dte_sw_005",
+				},
+			],
+		},
+	})
+
+	// --- thinking-effort-tool suite (openai/gpt-5) ---
+	// Baseline turn: bound to this suite's unique prompt marker.
+	mock.addFixture({
+		match: {
+			model: APPLY_MODEL,
+			predicate: (req: ChatCompletionRequest) => lastUserMessageContains(req, APPLY_MARKER),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "set_thinking_effort",
+					arguments: JSON.stringify({ effort: "high", reason: "multi-step math" }),
+					id: "call_dte_e2e_001",
+				},
+			],
+		},
+	})
+
+	// Continuation: binds to the set_thinking_effort call's unique tool call id.
+	mock.addFixture({
+		match: {
+			model: APPLY_MODEL,
+			predicate: (req: ChatCompletionRequest) => lastToolCallId(req) === "call_dte_e2e_001",
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: "42" }),
+					id: "call_dte_e2e_002",
+				},
+			],
+		},
+	})
+}

apps/vscode-e2e/src/runTest.ts

@@ -18,7 +18,8 @@ import { addTerminalProfileResultFixtures } from "./fixtures/terminal-profile"
 import { addListFilesResultFixtures } from "./fixtures/list-files"
 import { addReadFileResultFixtures } from "./fixtures/read-file"
 import { addSearchFilesResultFixtures } from "./fixtures/search-files"
-import { addSubtaskFixtures } from "./fixtures/subtasks"
+import { addDteNewTaskEffortFixtures, addSubtaskFixtures } from "./fixtures/subtasks"
+import { addThinkingEffortFixtures } from "./fixtures/thinking-effort"
 import { addUseMcpToolResultFixtures } from "./fixtures/use-mcp-tool"
 import { addWriteToFileResultFixtures } from "./fixtures/write-to-file"
 import { createScenarioWorkspace, removeScenarioWorkspace } from "./restart/scenarioWorkspace"
@@ -140,6 +141,8 @@ async function main() {
 				addReadFileResultFixtures(mock)
 				addSearchFilesResultFixtures(mock)
 				addSubtaskFixtures(mock)
+				addDteNewTaskEffortFixtures(mock)
+				addThinkingEffortFixtures(mock)
 				addUseMcpToolResultFixtures(mock)
 				addWriteToFileResultFixtures(mock)
 				addDeepSeekV4Fixtures(mock)