@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.b1abb545

package/dist/cli-web-branch.d.ts

@@ -20,6 +20,8 @@ export interface CliFlags {
     webPort?: number;
     /** Additional allowed origins for CORS: `--allowed-origins http://192.168.1.10:8080` */
     webAllowedOrigins?: string[];
+    /** Disable the web launcher's bearer token gate: `--no-auth` */
+    webNoAuth?: boolean;
     /** Set by `gsd sessions` when the user picks a specific session to resume */
     _selectedSessionPath?: string;
 }

package/dist/cli-web-branch.js

@@ -52,6 +52,9 @@ export function parseCliArgs(argv) {
             const origins = args[++i].split(',').map(o => o.trim()).filter(Boolean);
             flags.webAllowedOrigins = (flags.webAllowedOrigins ?? []).concat(origins);
         }
+        else if (arg === '--no-auth') {
+            flags.webNoAuth = true;
+        }
         else if (arg === '--model' && i + 1 < args.length) {
             flags.model = args[++i];
         }
@@ -232,14 +235,18 @@ export async function runWebCliBranch(flags, deps = {}) {
     const agentDir = deps.agentDir ?? defaultAgentDir;
     const projectSessionsDir = getProjectSessionsDir(currentCwd, baseSessionsDir);
     migrateLegacyFlatSessions(baseSessionsDir, projectSessionsDir);
-    const status = await (deps.runWebMode ?? launchWebMode)({
+    const launchOptions = {
         cwd: currentCwd,
         projectSessionsDir,
         agentDir,
         host: flags.webHost,
         port: flags.webPort,
         allowedOrigins: flags.webAllowedOrigins,
-    });
+    };
+    if (flags.webNoAuth !== undefined) {
+        launchOptions.noAuth = flags.webNoAuth;
+    }
+    const status = await (deps.runWebMode ?? launchWebMode)(launchOptions);
     if (!status.ok) {
         emitWebModeFailure(stderr, status);
     }

package/dist/help-text.js

@@ -189,6 +189,11 @@ export function printHelp(version) {
     process.stdout.write('  --worktree, -w [name]    Start in an isolated worktree (auto-named if omitted)\n');
     process.stdout.write('  --model <id>             Override model (e.g. provider/model-id)\n');
     process.stdout.write('  --no-session             Disable session persistence\n');
+    process.stdout.write('  --web [path]             Start browser-only web mode\n');
+    process.stdout.write('  --host <host>            Web mode bind address\n');
+    process.stdout.write('  --port <port>            Web mode port\n');
+    process.stdout.write('  --allowed-origins <csv>  Additional allowed web origins\n');
+    process.stdout.write('  --no-auth                Disable web token auth; requires external access control\n');
     process.stdout.write('  --extension <path>       Load additional extension\n');
     process.stdout.write('  --tools <a,b,c>          Restrict available tools\n');
     process.stdout.write('  --list-models [search]   List available models and exit\n');

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-83d1de3e3261d473
+9a23824a70bd2722

package/dist/resources/extensions/ask-user-questions.js

@@ -114,6 +114,61 @@ function errorResult(message, questions = [], options) {
         details: { questions, response: null, cancelled: true, interrupted: options?.interrupted === true },
     };
 }
+/** Parse the LLM-facing JSON payload back into a RoundResult for TUI rendering. */
+function parseLlmAnswersContent(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (!parsed?.answers || typeof parsed.answers !== "object")
+            return null;
+        const answers = {};
+        for (const [id, entry] of Object.entries(parsed.answers)) {
+            const list = Array.isArray(entry?.answers) ? [...entry.answers] : [];
+            let notes = "";
+            const noteIdx = list.findIndex((item) => typeof item === "string" && item.startsWith("user_note:"));
+            if (noteIdx >= 0) {
+                notes = list.splice(noteIdx, 1)[0].replace(/^user_note:\s*/, "");
+            }
+            if (list.length === 0)
+                continue;
+            answers[id] = {
+                selected: list.length === 1 ? list[0] : list,
+                notes,
+            };
+        }
+        if (Object.keys(answers).length === 0)
+            return null;
+        return { endInterview: false, answers };
+    }
+    catch {
+        return null;
+    }
+}
+function isCancelledResultContent(text) {
+    return /\bwas cancelled before receiving a response\b/i.test(text)
+        || /\bwas interrupted before receiving a response\b/i.test(text);
+}
+function renderAnswerLines(questions, response, theme) {
+    const lines = [];
+    for (const q of questions) {
+        const answer = response.answers[q.id];
+        if (!answer) {
+            lines.push(`${theme.fg("accent", q.header)}: ${theme.fg("dim", "(no answer)")}`);
+            continue;
+        }
+        const selected = answer.selected;
+        const notes = answer.notes;
+        const multiSel = !!q.allowMultiple;
+        const answerText = multiSel && Array.isArray(selected)
+            ? selected.join(", ")
+            : (Array.isArray(selected) ? selected[0] : selected) ?? "(no answer)";
+        let line = `${theme.fg("success", "✓ ")}${theme.fg("accent", q.header)}: ${answerText}`;
+        if (notes) {
+            line += ` ${theme.fg("muted", `[note: ${notes}]`)}`;
+        }
+        lines.push(line);
+    }
+    return new Text(lines.join("\n"), 0, 0);
+}
 /** Convert the shared RoundResult into the JSON the LLM expects. */
 function formatForLLM(result) {
     const answers = {};
@@ -318,11 +373,17 @@ export default function AskUserQuestions(pi) {
             }
             return new Text(text, 0, 0);
         },
-        renderResult(result, _options, theme) {
+        renderResult(result, _options, theme, context) {
             const details = result.details;
+            const contentText = result.content[0]?.type === "text" ? result.content[0].text : "";
+            const questionsFromArgs = context?.args?.questions;
+            const parsedResponse = contentText ? parseLlmAnswersContent(contentText) : null;
             if (!details) {
-                const text = result.content[0];
-                return new Text(text?.type === "text" ? text.text : "", 0, 0);
+                const questions = questionsFromArgs;
+                if (questions?.length && parsedResponse) {
+                    return renderAnswerLines(questions, parsedResponse, theme);
+                }
+                return new Text(contentText, 0, 0);
             }
             // Remote channel result (discriminated on details.remote === true)
             if (details.remote) {
@@ -352,30 +413,24 @@ export default function AskUserQuestions(pi) {
                 }
                 return new Text(lines.join("\n"), 0, 0);
             }
-            if (details.cancelled || !details.response) {
+            const questions = details.questions ?? questionsFromArgs;
+            const response = details.response ?? parsedResponse;
+            const explicitCancel = details.cancelled === true || isCancelledResultContent(contentText);
+            if (explicitCancel && !response) {
                 const interrupted = "interrupted" in details && details.interrupted === true;
                 return new Text(theme.fg("warning", interrupted ? "Interrupted" : "Cancelled"), 0, 0);
             }
-            const lines = [];
-            for (const q of details.questions) {
-                const answer = details.response.answers[q.id];
-                if (!answer) {
-                    lines.push(`${theme.fg("accent", q.header)}: ${theme.fg("dim", "(no answer)")}`);
-                    continue;
-                }
-                const selected = answer.selected;
-                const notes = answer.notes;
-                const multiSel = !!q.allowMultiple;
-                const answerText = multiSel && Array.isArray(selected)
-                    ? selected.join(", ")
-                    : (Array.isArray(selected) ? selected[0] : selected) ?? "(no answer)";
-                let line = `${theme.fg("success", "✓ ")}${theme.fg("accent", q.header)}: ${answerText}`;
-                if (notes) {
-                    line += ` ${theme.fg("muted", `[note: ${notes}]`)}`;
-                }
-                lines.push(line);
+            if (questions?.length && response) {
+                return renderAnswerLines(questions, response, theme);
+            }
+            if (contentText) {
+                return new Text(contentText, 0, 0);
+            }
+            if (details.cancelled || !details.response) {
+                const interrupted = "interrupted" in details && details.interrupted === true;
+                return new Text(theme.fg("warning", interrupted ? "Interrupted" : "Cancelled"), 0, 0);
             }
-            return new Text(lines.join("\n"), 0, 0);
+            return new Text("", 0, 0);
         },
     });
 }

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -14,13 +14,18 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
-import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
+import { ZERO_USAGE, mapUsage } from "./partial-builder.js";
+import { attachExternalResultsToToolBlocks, buildFinalAssistantContent, extractToolResultsFromSdkUserMessage, handleClaudeCodePartialStreamEvent, } from "./turn-assembler.js";
 import { buildWorkflowMcpServers, getRequiredWorkflowToolsForAutoUnit, resolveWorkflowMcpProjectRoot, } from "../gsd/workflow-mcp.js";
+import { resolveWorkflowQuestionToolSurface } from "../gsd/question-transport.js";
 import { buildProjectGsdMcpServers, ensureProjectWorkflowMcpConfig } from "../gsd/mcp-project-config.js";
 import { loadProjectGSDPreferences } from "../gsd/preferences.js";
+import { markToolStart, markToolEnd } from "../gsd/auto.js";
+import { markInteractiveElicitationStart, markInteractiveElicitationEnd, } from "../gsd/auto-tool-tracking.js";
 import { discoverBrowserMcpServerName, discoverMcpServers, discoverMcpServerNames, discoverUserMcpServerNames, discoverWorkflowMcpServerName, computeMcpDisallowedTools, } from "../gsd/mcp-filter.js";
 import { RUN_UAT_CLAUDE_NATIVE_TOOL_NAMES, RUN_UAT_FORBIDDEN_TOOL_NAMES, RUN_UAT_WORKFLOW_TOOL_NAMES, resolveToolPresentationPlan } from "../gsd/tool-presentation-plan.js";
 import { showInterviewRound } from "../shared/tui.js";
+export { buildFinalAssistantContent, extractToolResultsFromSdkUserMessage, handleClaudeCodePartialStreamEvent, mergePendingToolCalls, } from "./turn-assembler.js";
 export function serverToolUseToToolCallLike(block) {
     const argumentsValue = block.input && typeof block.input === "object" && !Array.isArray(block.input)
         ? block.input
@@ -1078,7 +1083,26 @@ export function createClaudeCodeCanUseToolHandler(ui) {
 // ---------------------------------------------------------------------------
 // Elicitation handler
 // ---------------------------------------------------------------------------
-/** Create an SDK elicitation handler that routes requests through the extension UI dialogs, or undefined if no UI is available. */
+/**
+ * Create an SDK elicitation handler that routes requests through the extension UI dialogs, or undefined if no UI is available.
+ *
+ * For structured (AskUserQuestion) elicitations, the interview round's result
+ * disambiguates two cases that must not be conflated: an `undefined` result
+ * means the custom UI is unavailable, so we fall back to the simpler `select`
+ * dialogs; an empty-answers result means the user dismissed the question, which
+ * is treated as a clean cancel. Falling back to dialogs on dismissal would
+ * re-ask the same questions (the duplicate-question bug).
+ */
+/**
+ * Monotonic counter so concurrent/sequential elicitations resolved within the
+ * same millisecond get distinct synthetic in-flight-tool ids (the `cc-elicit-*`
+ * namespace never collides with real MCP toolCallIds).
+ */
+let _elicitationSeq = 0;
+function nextElicitationSeq() {
+    _elicitationSeq = (_elicitationSeq + 1) % Number.MAX_SAFE_INTEGER;
+    return _elicitationSeq;
+}
 export function createClaudeCodeElicitationHandler(ui) {
     if (!ui)
         return undefined;
@@ -1091,18 +1115,64 @@ export function createClaudeCodeElicitationHandler(ui) {
             const headlessAnswer = answerElicitationFromHeadlessAnswers(questions, loadHeadlessAnswers());
             if (headlessAnswer)
                 return headlessAnswer;
-            const interviewResult = await showInterviewRound(questions, { signal }, { ui }).catch(() => undefined);
-            if (interviewResult && Object.keys(interviewResult.answers).length > 0) {
+            // The SDK elicitation blocks waiting for human input, but it is not an
+            // MCP tool dispatch, so markToolStart/markToolEnd are never called for
+            // it. Without this the soft/context/idle/hard watchdogs see zero
+            // in-flight tools and re-dispatch (and ultimately abort) the agent
+            // turn hosting this elicitation, tearing the question down (#2676 /
+            // claude-code-cli self-cancel loop). Bracketing the human wait with
+            // the s.active-gated interactive-tool guard makes it visible to
+            // hasInteractiveToolInFlight()/getInFlightToolCount() so those
+            // watchdogs exempt it. No-op outside auto-mode (wrapper self-gates).
+            //
+            // markInteractiveElicitationStart/End is a SEPARATE, ungated signal that
+            // is observable in FOREGROUND (where the s.active-gated markToolStart is a
+            // no-op). The foreground approval-gate pause path (register-hooks
+            // message_update) consults isInteractiveElicitationInFlight() and bails so
+            // it does not tear down the very elicitation that IS the human boundary
+            // (#cc-elicitation-self-cancel). It clears in the finally on every exit.
+            const elicId = "cc-elicit-" + (request.id ?? `${Date.now()}-${nextElicitationSeq()}`);
+            markInteractiveElicitationStart();
+            markToolStart(elicId, "ask_user_questions");
+            try {
+                const interviewResult = await showInterviewRound(questions, { signal, overlay: true }, { ui }).catch(() => undefined);
+                if (interviewResult === undefined) {
+                    // `await` so the dialog human-wait stays inside try/finally and the
+                    // in-flight guard is held until the dialog resolves. Without it,
+                    // `finally` runs the moment the promise is created and the fallback
+                    // wait runs with zero in-flight tools — reintroducing the
+                    // self-cancel on this path (Bugbot #1c00624d).
+                    return await promptElicitationWithDialogs(request, questions, ui, signal);
+                }
+                if (Object.keys(interviewResult.answers).length === 0) {
+                    // A system/host teardown (compaction, session_switch, true
+                    // interrupt) that aborted the signal mid-wait sets `interrupted`.
+                    // Surface that as a non-affirmative `decline` so it is not
+                    // laundered into a clean user-declined `cancel` the model re-asks
+                    // against. A genuine user dismissal leaves `interrupted` falsy and
+                    // keeps the prior `cancel` semantics.
+                    return interviewResult.interrupted ? { action: "decline" } : { action: "cancel" };
+                }
                 return {
                     action: "accept",
                     content: roundResultToElicitationContent(questions, interviewResult),
                 };
             }
-            return promptElicitationWithDialogs(request, questions, ui, signal);
+            finally {
+                markToolEnd(elicId);
+                markInteractiveElicitationEnd();
+            }
         }
         const textFields = parseTextInputElicitation(request);
         if (textFields) {
-            return promptTextInputElicitation(request, textFields, ui, signal);
+            const elicId = "cc-elicit-" + (request.id ?? `${Date.now()}-${nextElicitationSeq()}`);
+            markToolStart(elicId, "secure_env_collect");
+            try {
+                return await promptTextInputElicitation(request, textFields, ui, signal);
+            }
+            finally {
+                markToolEnd(elicId);
+            }
         }
         return { action: "decline" };
     };
@@ -1417,6 +1487,13 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     // leave allowed mcp__... tools with no registered backing tool.
     const settingSources = strictMcpConfig ? [] : ["user", "project", "local"];
     const exactWorkflowMcpTools = resolveExactWorkflowMcpToolsForPhase(gsdPhase, workflowServerName, workflowExplicitlyBlocked);
+    const questionToolSurface = resolveWorkflowQuestionToolSurface({
+        workflowServerName,
+        workflowExplicitlyBlocked,
+        workflowMcpTools,
+        exactWorkflowMcpTools,
+        env: process.env,
+    });
     const runUatDisallowedTools = gsdPhase === "run-uat" && workflowServerName
         ? [
             ...RUN_UAT_FORBIDDEN_TOOL_NAMES.filter((toolName) => !toolName.startsWith("mcp__")),
@@ -1430,6 +1507,7 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const disallowedTools = [...new Set([
             "ToolSearch",
             ...(workflowMcpTools.length > 0 || exactWorkflowMcpTools.length > 0 ? ["AskUserQuestion"] : []),
+            ...questionToolSurface.disallowedTools,
             ...runUatDisallowedTools,
             ...extraDisallowedTools,
         ])];
@@ -1492,228 +1570,6 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         ...sdkExtraOptions,
     };
 }
-/** Normalise heterogeneous SDK tool-result content (string, array, or object) into a uniform `ExternalToolResultContentBlock[]`. */
-function normalizeToolResultContent(content) {
-    if (typeof content === "string") {
-        return [{ type: "text", text: content }];
-    }
-    if (!Array.isArray(content)) {
-        if (content == null)
-            return [{ type: "text", text: "" }];
-        return [{ type: "text", text: JSON.stringify(content) }];
-    }
-    const blocks = [];
-    for (const item of content) {
-        if (typeof item === "string") {
-            blocks.push({ type: "text", text: item });
-            continue;
-        }
-        if (!item || typeof item !== "object") {
-            blocks.push({ type: "text", text: String(item) });
-            continue;
-        }
-        const block = item;
-        if (block.type === "text") {
-            blocks.push({ type: "text", text: typeof block.text === "string" ? block.text : "" });
-            continue;
-        }
-        if (block.type === "image"
-            && typeof block.data === "string"
-            && typeof block.mimeType === "string") {
-            blocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
-            continue;
-        }
-        blocks.push({ type: "text", text: JSON.stringify(block) });
-    }
-    return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
-}
-/**
- * Extract a `details` payload from an MCP tool-result block.
- *
- * MCP's `CallToolResult` carries structured data in `structuredContent` — the
- * protocol's supported channel for non-text payloads. Claude Code's synthetic
- * user message may surface that field in one of two shapes depending on SDK
- * version: as a sibling on the `mcp_tool_result` block itself, or as a
- * dedicated content sub-block with `type: "structuredContent"`. Snake-case
- * (`structured_content`) is accepted defensively in case a transport hop
- * rewrites casing. All other shapes fall back to an empty object so callers
- * can rely on `details` being present.
- */
-function extractStructuredDetailsFromBlock(block) {
-    const sibling = block.structuredContent ?? block.structured_content;
-    if (sibling && typeof sibling === "object" && !Array.isArray(sibling)) {
-        return sibling;
-    }
-    if (Array.isArray(block.content)) {
-        for (const item of block.content) {
-            if (!item || typeof item !== "object")
-                continue;
-            const sub = item;
-            if (sub.type !== "structuredContent" && sub.type !== "structured_content")
-                continue;
-            const payload = sub.structuredContent ?? sub.structured_content ?? sub.data ?? sub.value;
-            if (payload && typeof payload === "object" && !Array.isArray(payload)) {
-                return payload;
-            }
-        }
-    }
-    // Return undefined (not {}) when no structured payload is present, matching
-    // the pre-#4477 contract where `details` was nullable. An empty-object
-    // sentinel is truthy and breaks downstream consumers that gate on
-    // `if (details)`. `undefined` matches the type of the field these results
-    // flow into (`Record<string, unknown> | undefined`).
-    return undefined;
-}
-/**
- * True for items that are MCP `structuredContent` pseudo-blocks living inside
- * a tool-result `content[]` array. These blocks carry the structured payload
- * (extracted separately by `extractStructuredDetailsFromBlock`) and must NOT
- * leak into the visible content rendered to the user — otherwise the renderer
- * stringifies the JSON pseudo-block and shows it next to the actual tool
- * output. See PR #4477 review (post-fix-round).
- */
-function isStructuredContentPseudoBlock(item) {
-    if (!item || typeof item !== "object")
-        return false;
-    const type = item.type;
-    return type === "structuredContent" || type === "structured_content";
-}
-/**
- * Strip `structuredContent` pseudo-blocks from a tool-result content array
- * before normalization. The structured payload is extracted via the sibling
- * `structuredContent` field (or a dedicated extractor pass on the raw block);
- * the visible content path must not include the pseudo-block itself.
- */
-function stripStructuredContentPseudoBlocks(content) {
-    if (!Array.isArray(content))
-        return content;
-    return content.filter((item) => !isStructuredContentPseudoBlock(item));
-}
-/** Extract tool result payloads from an SDK synthetic user message, keyed by tool-use ID. */
-export function extractToolResultsFromSdkUserMessage(message) {
-    const extracted = [];
-    const seen = new Set();
-    const rawMessage = message.message;
-    const content = Array.isArray(rawMessage?.content) ? rawMessage.content : [];
-    for (const item of content) {
-        if (!item || typeof item !== "object")
-            continue;
-        const block = item;
-        const type = typeof block.type === "string" ? block.type : "";
-        if (type !== "tool_result" && type !== "mcp_tool_result")
-            continue;
-        const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
-        if (!toolUseId || seen.has(toolUseId))
-            continue;
-        seen.add(toolUseId);
-        extracted.push({
-            toolUseId,
-            result: {
-                content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(block.content)),
-                details: extractStructuredDetailsFromBlock(block),
-                isError: block.is_error === true,
-            },
-        });
-    }
-    if (extracted.length === 0) {
-        const fallback = message.tool_use_result;
-        if (fallback && typeof fallback === "object") {
-            const toolResult = fallback;
-            const toolUseId = typeof toolResult.tool_use_id === "string" ? toolResult.tool_use_id : "";
-            if (toolUseId) {
-                extracted.push({
-                    toolUseId,
-                    result: {
-                        content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(toolResult.content)),
-                        details: extractStructuredDetailsFromBlock(toolResult),
-                        isError: toolResult.is_error === true,
-                    },
-                });
-            }
-        }
-    }
-    return extracted;
-}
-/** Attach external tool results from the SDK synthetic user message to their corresponding tool-call blocks by ID. */
-function attachExternalResultsToToolBlocks(toolBlocks, toolResultsById) {
-    for (const block of toolBlocks) {
-        if (block.type !== "toolCall" && block.type !== "serverToolUse")
-            continue;
-        const externalResult = toolResultsById.get(block.id);
-        if (!externalResult)
-            continue;
-        block.externalResult = externalResult;
-    }
-}
-/**
- * Build the final assistant content that Agent Core consumes in
- * `externalToolExecution` mode. This preserves tool-call blocks, attaches any
- * SDK-produced external results by tool-call id, and then appends the final
- * text/thinking blocks for the completed turn.
- */
-export function buildFinalAssistantContent(params) {
-    const mergedToolBlocks = [...params.intermediateToolBlocks];
-    if (params.pendingContent) {
-        mergePendingToolCalls(mergedToolBlocks, params.pendingContent);
-    }
-    attachExternalResultsToToolBlocks(mergedToolBlocks, params.toolResultsById);
-    const finalContent = [...mergedToolBlocks];
-    if (params.pendingContent && params.pendingContent.length > 0) {
-        for (const block of params.pendingContent) {
-            if (block.type === "text" || block.type === "thinking") {
-                finalContent.push(block);
-            }
-        }
-    }
-    else {
-        if (params.lastThinkingContent) {
-            finalContent.push({ type: "thinking", thinking: params.lastThinkingContent });
-        }
-        if (params.lastTextContent) {
-            finalContent.push({ type: "text", text: params.lastTextContent });
-        }
-    }
-    if (finalContent.length === 0 && params.fallbackResultText) {
-        finalContent.push({ type: "text", text: params.fallbackResultText });
-    }
-    return finalContent;
-}
-/**
- * Merge tool-call blocks from the active partial-message builder into the
- * running list of intermediate tool calls, preserving order and de-duping
- * by tool-call id. Exposed for testing the F3 fix (final-turn tool calls
- * dropped when `result` arrives without a preceding synthetic `user`).
- */
-export function mergePendingToolCalls(intermediate, pending) {
-    const alreadyIncluded = new Set();
-    for (const block of intermediate) {
-        if (block.type === "toolCall")
-            alreadyIncluded.add(block.id);
-    }
-    for (const block of pending) {
-        if (block.type !== "toolCall")
-            continue;
-        if (alreadyIncluded.has(block.id))
-            continue;
-        alreadyIncluded.add(block.id);
-        intermediate.push(block);
-    }
-    return intermediate;
-}
-export function handleClaudeCodePartialStreamEvent(builder, event, modelId) {
-    if (event.type === "message_start") {
-        // Claude Code can emit repeated SDK message_start events inside one
-        // logical assistant response. Keep appending until a synthetic user
-        // tool-result boundary explicitly clears the builder.
-        return {
-            builder: builder ?? new PartialMessageBuilder(event.message?.model ?? modelId),
-            assistantEvent: null,
-        };
-    }
-    if (!builder)
-        return { builder, assistantEvent: null };
-    return { builder, assistantEvent: builder.handleEvent(event) };
-}
 // ---------------------------------------------------------------------------
 // streamSimple implementation
 // ---------------------------------------------------------------------------