@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/chat/anthropic-planner.js

@@ -0,0 +1,1012 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { allowedBlockTypes, editPlanSchema } from "@avocadostudio-ai/shared";
+import { buildIntentParserSystemPrompt, buildPlannerSystemPromptSegments } from "./prompts.js";
+import { GENERATING_IMAGE_PLACEHOLDER, SEARCHING_IMAGE_PLACEHOLDER } from "./chat-pipeline.js";
+import { extractAudienceTarget, fetchImageAsBase64, resolveAttachmentsForLlm, intentSchema } from "../nlp/deterministic-planner.js";
+import { isBatchAddRequest, isBatchRemoveRequest, isBatchReorderRequest, isPageWideRewriteRequest, isDuplicateAndModifyRequest, requestsPlanFirst } from "../nlp/intent-detection.js";
+import { extractJsonObject, normalizePlanCandidate, repairAndParseJsonWithMeta } from "../nlp/plan-normalizer.js";
+import { buildPlannerSchemaContext, extractUpdatePropsFieldDraftsFromPlanBuffer, extractOpsFromPlanBuffer, extractSummaryFromPlanBuffer, isChatStrictPrimaryOpMode, isPageWideTranslationRequest } from "./planner.js";
+import { buildEditPlanJsonSchema, intentJsonSchema } from "./plan-json-schema.js";
+import { extractUsage, ZERO_USAGE } from "../telemetry/usage.js";
+import { anthropicSystemPromptWithCache, anthropicSegmentedSystemPromptWithCache, anthropicToolWithCache, ANTHROPIC_FINE_GRAINED_STREAM_HEADERS } from "./anthropic-cache.js";
+import { executeToolCall } from "../tools/runtime.js";
+import { DEFERRABLE_IMAGE_TOOLS } from "./chat-pipeline-shared.js";
+// Minimum text length to treat a text-only model response as meaningful
+// content (rather than discarding it in favor of the hardcoded fallback).
+const MIN_MEANINGFUL_RESPONSE_LENGTH = 20;
+const LLM_TIMEOUT_MS = 120_000;
+/** Detect API-level errors (rate limits, auth failures, quota exhaustion) that
+ *  should NOT be treated as recoverable stream parse errors. */
+function isApiLevelError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const msg = err.message.toLowerCase();
+    return (msg.includes("usage limit") ||
+        msg.includes("rate limit") ||
+        msg.includes("quota") ||
+        msg.includes("authentication") ||
+        msg.includes("unauthorized") ||
+        msg.includes("invalid.*api.*key") ||
+        msg.includes("billing") ||
+        /\b40[0-13]\b/.test(err.message));
+}
+/**
+ * Try JSON.parse, then repairAndParseJson. Returns parsed object or null.
+ */
+function tryParseOrRepair(buf, log, model) {
+    try {
+        return JSON.parse(buf);
+    }
+    catch {
+        try {
+            const meta = repairAndParseJsonWithMeta(buf);
+            log?.warn({ event: "anthropic_planner_json_repaired", model: model ?? "unknown", strategy: meta.strategy, mutationCount: meta.mutationCount, discardedBytes: meta.discardedBytes }, "Anthropic planner: repaired malformed tool JSON from stream buffer");
+            return meta.parsed;
+        }
+        catch (repairErr) {
+            log?.warn({
+                event: "anthropic_planner_repair_failed",
+                model: model ?? "unknown",
+                repairError: repairErr instanceof Error ? repairErr.message : String(repairErr),
+            }, "Anthropic planner: repairAndParseJson failed");
+            return null;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Singleton Anthropic client — reuses HTTP/2 connection pool across requests.
+// Lazily initialized on first use so module-level import doesn't throw if
+// ANTHROPIC_API_KEY isn't set yet.
+// ---------------------------------------------------------------------------
+let _anthropicSingleton = null;
+function getAnthropicClient() {
+    if (!_anthropicSingleton) {
+        _anthropicSingleton = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+    }
+    return _anthropicSingleton;
+}
+/** Reset the singleton (useful for tests that swap API keys). */
+export function resetAnthropicClient() {
+    _anthropicSingleton = null;
+}
+export async function parseIntentWithAnthropic(args) {
+    const client = getAnthropicClient();
+    const system = buildIntentParserSystemPrompt();
+    const user = {
+        request: args.message,
+        slug: args.slug,
+        activeBlockId: args.activeBlockId ?? null,
+        activeBlockType: args.activeBlockType ?? null,
+        activeEditablePath: args.activeEditablePath ?? null,
+        availableBlockTypes: allowedBlockTypes,
+        blocks: args.currentPage.blocks.map((b) => ({ id: b.id, type: b.type, props: Object.keys(b.props) }))
+    };
+    const response = await client.messages.create({
+        model: args.model,
+        max_tokens: 2048,
+        system: anthropicSystemPromptWithCache(system),
+        output_config: {
+            format: { type: "json_schema", schema: intentJsonSchema }
+        },
+        messages: [
+            { role: "user", content: JSON.stringify(user) }
+        ],
+    }, { signal: AbortSignal.timeout(LLM_TIMEOUT_MS) });
+    if (response.stop_reason === "max_tokens") {
+        const textBlock = response.content.find((b) => b.type === "text");
+        const raw = textBlock && "text" in textBlock ? textBlock.text : "";
+        args.log?.warn({
+            event: "anthropic_intent_truncated",
+            model: args.model,
+            stopReason: response.stop_reason,
+            rawPreview: raw.slice(0, 500)
+        }, "Anthropic intent parser: response truncated (max_tokens)");
+        throw new Error("Intent parser response was truncated (max_tokens reached)");
+    }
+    const textBlock = response.content.find((b) => b.type === "text");
+    const raw = textBlock && "text" in textBlock ? textBlock.text : "";
+    if (!raw.trim()) {
+        args.log?.warn({
+            event: "anthropic_intent_no_json",
+            model: args.model,
+            stopReason: response.stop_reason ?? "unknown",
+            rawPreview: raw.slice(0, 500),
+            contentBlockTypes: response.content.map((b) => b.type)
+        }, "Anthropic intent parser: model returned empty response");
+        throw new Error("Intent parser did not return JSON");
+    }
+    // output_config guarantees valid JSON matching our schema — parse directly
+    const normalized = JSON.parse(raw);
+    // Nulls from the schema become undefined for Zod optional fields
+    for (const key of Object.keys(normalized)) {
+        if (normalized[key] === null)
+            delete normalized[key];
+    }
+    const parsed = intentSchema.safeParse(normalized);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        const detail = issue?.message ?? "Invalid intent parser output";
+        const at = issue?.path?.length ? ` at ${issue.path.join(".")}` : "";
+        throw new Error(`${detail}${at}`);
+    }
+    return parsed.data;
+}
+function sumTokenUsage(a, b) {
+    return {
+        inputTokens: a.inputTokens + b.inputTokens,
+        outputTokens: a.outputTokens + b.outputTokens,
+        totalTokens: a.totalTokens + b.totalTokens,
+        ...(a.cacheCreationInputTokens !== undefined || b.cacheCreationInputTokens !== undefined
+            ? { cacheCreationInputTokens: (a.cacheCreationInputTokens ?? 0) + (b.cacheCreationInputTokens ?? 0) }
+            : {}),
+        ...(a.cacheReadInputTokens !== undefined || b.cacheReadInputTokens !== undefined
+            ? { cacheReadInputTokens: (a.cacheReadInputTokens ?? 0) + (b.cacheReadInputTokens ?? 0) }
+            : {})
+    };
+}
+function asToolUseBlock(block) {
+    if (block.type !== "tool_use")
+        return null;
+    return block;
+}
+function toAnthropicToolAlias(name, used) {
+    let alias = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    if (!alias)
+        alias = "tool";
+    if (/^[0-9]/.test(alias))
+        alias = `tool_${alias}`;
+    alias = alias.slice(0, 120);
+    let unique = alias;
+    let counter = 1;
+    while (used.has(unique)) {
+        unique = `${alias}_${counter}`;
+        counter += 1;
+    }
+    used.add(unique);
+    return unique;
+}
+export async function generatePlanWithAnthropic(args) {
+    const client = args.client ?? getAnthropicClient();
+    const effectiveSignal = args.signal
+        ? AbortSignal.any([args.signal, AbortSignal.timeout(LLM_TIMEOUT_MS)])
+        : AbortSignal.timeout(LLM_TIMEOUT_MS);
+    const effectiveBlockTypes = args.componentsManifest ? args.componentsManifest.blocks.map(c => c.type) : allowedBlockTypes;
+    const batchOverride = isBatchAddRequest(args.message) || isBatchRemoveRequest(args.message) || isBatchReorderRequest(args.message) || isPageWideRewriteRequest(args.message) || isDuplicateAndModifyRequest(args.message);
+    const pageWideRewrite = isPageWideRewriteRequest(args.message);
+    const planFirstMode = requestsPlanFirst(args.message);
+    const pageWideTranslation = isPageWideTranslationRequest(args.message);
+    const chatStrictPrimaryOpMode = isChatStrictPrimaryOpMode() && !batchOverride && !pageWideTranslation;
+    const selectedBlockId = String(args.contextPack.selected.blockId ?? "");
+    const audienceHint = extractAudienceTarget(args.message);
+    const explicitOtherReference = selectedBlockId.length > 0 &&
+        Array.isArray(args.contextPack.resolvedReferences.mentionedBlocks) &&
+        args.contextPack.resolvedReferences.mentionedBlocks.some((entry) => entry && typeof entry === "object" && "id" in entry && entry.id !== selectedBlockId);
+    const systemSegments = buildPlannerSystemPromptSegments({
+        provider: "anthropic",
+        lightweight: !!args.lightweight,
+        selectedBlockId,
+        explicitOtherReference: !!explicitOtherReference,
+        chatStrictPrimaryOpMode,
+        pageWideTranslation,
+        pageWideRewrite,
+        planFirstMode,
+        effectiveBlockTypes,
+        siteContextBlock: args.siteContextBlock,
+        imageUrlForVision: args.contextPack.selected?.imageUrlForVision,
+        editablePath: args.contextPack.selected?.editablePath,
+        blockId: args.contextPack.selected?.blockId,
+        locale: args.locale,
+        imageSourceChoiceOpen: args.imageSourceChoiceOpen,
+        attachmentCount: args.contextPack.attachments?.length,
+    });
+    // Stable prefix carries cache_control; dynamic tail is sent as a second
+    // text block without it, so per-request flags don't bust the cached prefix.
+    const cachedSystem = anthropicSegmentedSystemPromptWithCache(systemSegments);
+    const lowerMsg = args.message.toLowerCase();
+    const includeContracts = !args.lightweight && (batchOverride ||
+        pageWideTranslation ||
+        /\b(create|add|insert|build|generate)\b/.test(lowerMsg) ||
+        /\b(seo|meta|metadata|og\s*image|open\s*graph|description|structured\s*data|schema\.org)\b/.test(lowerMsg) ||
+        /\d{2,3}\s*char/i.test(args.message) ||
+        // Multi-field updates need block contracts to know valid prop names
+        (lowerMsg.match(/['''"""\u201C\u201D\u2018\u2019]/g)?.length ?? 0) >= 4);
+    const schemaContext = args.lightweight
+        ? {
+            payload: {},
+            meta: {
+                contractMode: "minimal",
+                contractBytes: 0,
+                contractBlockCount: 0,
+                targetBlockTypes: [],
+                strictJsonEnabled: false
+            }
+        }
+        : buildPlannerSchemaContext({
+            message: args.message,
+            contextPack: args.contextPack,
+            batchOverride,
+            pageWideTranslation,
+            legacyIncludeContracts: includeContracts,
+            forceFullContracts: args.forceFullSchemaContracts,
+            componentsManifest: args.componentsManifest
+        });
+    const user = {
+        request: args.message,
+        audienceHint: audienceHint ?? null,
+        slug: args.slug,
+        contextPack: args.contextPack,
+        ...schemaContext.payload,
+        feedback: args.feedback ?? null
+    };
+    const imageUrlForVision = typeof args.contextPack.selected?.imageUrlForVision === "string"
+        ? args.contextPack.selected.imageUrlForVision
+        : null;
+    const imageBase64 = imageUrlForVision ? await fetchImageAsBase64(imageUrlForVision) : null;
+    // User-attached files (images + PDFs) become native content blocks: images as
+    // `image` blocks, PDFs as `document` blocks (Claude reads text + per-page visuals).
+    const resolvedAttachments = await resolveAttachmentsForLlm(args.contextPack.attachments);
+    const attachmentBlocks = resolvedAttachments.map((attachment) => attachment.kind === "pdf"
+        ? { type: "document", source: { type: "base64", media_type: "application/pdf", data: attachment.base64 } }
+        : { type: "image", source: { type: "base64", media_type: attachment.mediaType, data: attachment.base64 } });
+    const visionBlocks = imageUrlForVision
+        ? [
+            imageBase64
+                ? { type: "image", source: { type: "base64", media_type: imageBase64.mediaType, data: imageBase64.base64 } }
+                : { type: "image", source: { type: "url", url: imageUrlForVision } }
+        ]
+        : [];
+    const userContent = visionBlocks.length > 0 || attachmentBlocks.length > 0
+        ? [...visionBlocks, ...attachmentBlocks, { type: "text", text: JSON.stringify(user) }]
+        : JSON.stringify(user);
+    // Anthropic rejects the WHOLE request ("text content blocks must contain non-whitespace
+    // text") if any message carries an empty/whitespace text block — e.g. a blank chat turn
+    // that slipped into history. Drop those so one stray turn can't fail the entire plan.
+    const historyMessages = (args.history ?? [])
+        .filter((h) => typeof h.content === "string" && h.content.trim().length > 0)
+        .map((h) => ({
+        role: h.role,
+        content: h.content
+    }));
+    const submitPlanToolDef = {
+        name: "submit_edit_plan",
+        description: "Submit the structured EditPlan JSON.",
+        input_schema: buildEditPlanJsonSchema({ planFirstMode }),
+        eager_input_streaming: true
+    };
+    const runtimeToolNameByAlias = new Map();
+    const usedAliases = new Set(["submit_edit_plan"]);
+    const runtimeTools = args.toolRuntime
+        ? args.toolRuntime.registry.listEnabled().map((entry) => {
+            const alias = toAnthropicToolAlias(entry.manifest.name, usedAliases);
+            runtimeToolNameByAlias.set(alias, entry.manifest.name);
+            return {
+                name: alias,
+                description: entry.manifest.description,
+                input_schema: entry.manifest.inputSchema
+            };
+        })
+        : [];
+    // Anthropic allows max 4 cache_control breakpoints. Cache the *first* tool
+    // (submitPlanToolDef) — it carries the large editPlanJsonSchema and is
+    // present on every request. Caching the first tool means the cached prefix
+    // stays a hit even when runtime tools (gdrive, unsplash, image.generate)
+    // come and go between requests.
+    const toolDefs = [
+        anthropicToolWithCache(submitPlanToolDef),
+        ...runtimeTools,
+    ];
+    let parsed;
+    let usage = { ...ZERO_USAGE };
+    const deferredNativeImageCalls = [];
+    let streamedOpsCount = 0;
+    let lastSummaryLen = 0;
+    let emittedChangeLogCount = 0;
+    const emittedFieldDraftByKey = new Map();
+    const maxToolTurns = 6;
+    // Anthropic adaptive thinking — added to every messages.create/stream call when
+    // args.thinking is set. Adaptive thinking + `output_config.effort` is the current
+    // API; the legacy `budget_tokens` shape is rejected (400) on Opus 4.8 / Sonnet 5.
+    // `display: "summarized"` keeps streamed thinking tokens visible (the default is
+    // "omitted", which streams empty thinking blocks and would blank the reasoning UI).
+    // Plan-first review mode disables thinking: thinking forces the tool_choice="auto"
+    // path, where the model can emit free-form prose instead of calling
+    // submit_edit_plan — and a text-only response is wrapped as needs_clarification
+    // (see fallback below). With thinking OFF we route to constrained decoding
+    // (output_config.format) / forced tool_choice, both of which honor the narrowed
+    // intent enum and guarantee a reviewable edit_plan.
+    const thinkingParam = !planFirstMode && args.thinking
+        ? { type: "adaptive", display: "summarized" }
+        : undefined;
+    const effortParam = thinkingParam ? args.thinking.effort : undefined;
+    // Adaptive thinking counts thinking tokens against max_tokens; give headroom so
+    // the actual response isn't truncated. Effort (not max_tokens) governs spend.
+    const plannerMaxTokens = thinkingParam ? 16000 : 8192;
+    // Collapsed request params spread into every tool-loop create/stream call.
+    // effort rides inside output_config alongside thinking; only the constrained-
+    // decoding fallback (thinking OFF) sets output_config.format instead.
+    const thinkingRequestParams = thinkingParam
+        ? { thinking: thinkingParam, output_config: { effort: effortParam } }
+        : {};
+    // Plan-first review mode forces the submit_edit_plan tool so the model cannot
+    // emit free-form prose (which the text-only fallback wraps as
+    // needs_clarification). Combined with the narrowed intent enum, this
+    // guarantees a reviewable edit_plan. Safe here because planFirstMode also
+    // disables thinking above, and forced tool_choice is incompatible with thinking.
+    const submitToolChoice = planFirstMode
+        ? { type: "tool", name: "submit_edit_plan" }
+        : { type: "auto" };
+    // Track thinking lifecycle for callbacks (Path 1 tool-loop and Path 2 stream)
+    let thinkingStartedAt = null;
+    const emitThinkingStart = () => {
+        if (!args.onThinking || thinkingStartedAt !== null)
+            return;
+        thinkingStartedAt = Date.now();
+        args.onThinking({ type: "start" });
+    };
+    const emitThinkingToken = (text) => {
+        if (!args.onThinking || !text)
+            return;
+        emitThinkingStart();
+        args.onThinking({ type: "token", text });
+    };
+    const emitThinkingEnd = () => {
+        if (!args.onThinking || thinkingStartedAt === null)
+            return;
+        const durationMs = Date.now() - thinkingStartedAt;
+        thinkingStartedAt = null;
+        args.onThinking({ type: "end", durationMs });
+    };
+    const emitProgressFromToolJson = (toolJsonBuf) => {
+        if (args.onFieldDraft) {
+            const fieldDrafts = extractUpdatePropsFieldDraftsFromPlanBuffer(toolJsonBuf);
+            for (const draft of fieldDrafts) {
+                const key = `${draft.opIndex}:${draft.blockId}:${draft.editablePath}`;
+                const prev = emittedFieldDraftByKey.get(key);
+                if (prev === draft.value)
+                    continue;
+                emittedFieldDraftByKey.set(key, draft.value);
+                args.onFieldDraft({ blockId: draft.blockId, editablePath: draft.editablePath, value: draft.value, ...(draft.pageSlug ? { pageSlug: draft.pageSlug } : {}) });
+            }
+        }
+        if (args.onSummaryChunk || args.onChangeLogEntry) {
+            const extracted = extractSummaryFromPlanBuffer(toolJsonBuf);
+            if (extracted.summary && extracted.summary.length > lastSummaryLen) {
+                args.onSummaryChunk?.(extracted.summary.slice(lastSummaryLen));
+                lastSummaryLen = extracted.summary.length;
+            }
+            for (let i = emittedChangeLogCount; i < extracted.changeLog.length; i++) {
+                args.onChangeLogEntry?.(extracted.changeLog[i]);
+            }
+            emittedChangeLogCount = extracted.changeLog.length;
+        }
+        if (args.onPlannedOp) {
+            const next = extractOpsFromPlanBuffer(toolJsonBuf, streamedOpsCount);
+            streamedOpsCount = next.nextEmittedCount;
+            for (let idx = 0; idx < next.newOps.length; idx += 1) {
+                args.onPlannedOp(next.newOps[idx], streamedOpsCount - next.newOps.length + idx + 1);
+            }
+        }
+    };
+    if (runtimeTools.length > 0) {
+        const loopMessages = [
+            ...historyMessages,
+            { role: "user", content: userContent }
+        ];
+        for (let turn = 0; turn < maxToolTurns; turn += 1) {
+            let response;
+            let emittedTextDeltas = false;
+            if (client.messages.stream) {
+                const stream = client.messages.stream({
+                    model: args.model,
+                    max_tokens: plannerMaxTokens,
+                    system: cachedSystem,
+                    tools: toolDefs,
+                    tool_choice: submitToolChoice,
+                    messages: loopMessages,
+                    ...thinkingRequestParams
+                }, {
+                    headers: ANTHROPIC_FINE_GRAINED_STREAM_HEADERS,
+                    signal: effectiveSignal,
+                });
+                const toolNameByIndex = new Map();
+                const submitToolJsonByIndex = new Map();
+                const thinkingBlockIndexes = new Set();
+                let path1TextBuf = "";
+                // Wrap stream iteration — SDK may throw on message_stop if tool JSON is malformed
+                let path1StreamError;
+                try {
+                    for await (const event of stream) {
+                        if (event.type === "content_block_start") {
+                            const idx = typeof event.index === "number" ? event.index : -1;
+                            if (idx >= 0 && event.content_block?.type === "tool_use" && typeof event.content_block.name === "string") {
+                                toolNameByIndex.set(idx, event.content_block.name);
+                            }
+                            if (idx >= 0 && event.content_block?.type === "thinking") {
+                                thinkingBlockIndexes.add(idx);
+                                emitThinkingStart();
+                            }
+                            continue;
+                        }
+                        if (event.type === "content_block_stop") {
+                            const idx = typeof event.index === "number" ? event.index : -1;
+                            if (idx >= 0 && thinkingBlockIndexes.has(idx)) {
+                                thinkingBlockIndexes.delete(idx);
+                                if (thinkingBlockIndexes.size === 0)
+                                    emitThinkingEnd();
+                            }
+                            continue;
+                        }
+                        if (event.type !== "content_block_delta")
+                            continue;
+                        if (event.delta?.type === "thinking_delta") {
+                            const thinkingText = event.delta.thinking ?? "";
+                            if (thinkingText.length > 0)
+                                emitThinkingToken(thinkingText);
+                            continue;
+                        }
+                        if (event.delta?.type === "text_delta") {
+                            const text = event.delta.text ?? "";
+                            if (text.length > 0) {
+                                emittedTextDeltas = true;
+                                path1TextBuf += text;
+                                args.onToken?.(text);
+                            }
+                            continue;
+                        }
+                        if (event.delta?.type !== "input_json_delta")
+                            continue;
+                        const idx = typeof event.index === "number" ? event.index : -1;
+                        if (idx < 0 || toolNameByIndex.get(idx) !== "submit_edit_plan")
+                            continue;
+                        const nextBuf = (submitToolJsonByIndex.get(idx) ?? "") + (event.delta.partial_json ?? "");
+                        submitToolJsonByIndex.set(idx, nextBuf);
+                        emitProgressFromToolJson(nextBuf);
+                    }
+                }
+                catch (err) {
+                    // Re-throw API-level errors (rate limits, auth failures, quota exhaustion)
+                    // instead of treating them as recoverable stream parse errors.
+                    if (isApiLevelError(err))
+                        throw err;
+                    path1StreamError = err;
+                }
+                // If stream threw, try to parse from accumulated buffers instead of finalMessage
+                if (path1StreamError) {
+                    args.log?.warn({
+                        event: "anthropic_path1_stream_loop_error",
+                        model: args.model,
+                        error: path1StreamError instanceof Error ? path1StreamError.message : String(path1StreamError),
+                        submitToolJsonEntries: submitToolJsonByIndex.size,
+                        textBufLength: path1TextBuf.length,
+                    }, "Anthropic Path 1: stream loop threw (SDK JSON parse) — will attempt buffer repair");
+                    // Find the submit_edit_plan buffer and attempt repair
+                    for (const [idx, buf] of submitToolJsonByIndex) {
+                        if (toolNameByIndex.get(idx) === "submit_edit_plan" && buf.length > 0) {
+                            parsed = tryParseOrRepair(buf, args.log, args.model) ?? undefined;
+                            if (parsed)
+                                break;
+                        }
+                    }
+                    if (parsed)
+                        break;
+                    // Buffer repair failed. If we accumulated meaningful text, use it as
+                    // an info response rather than falling through to the hardcoded fallback.
+                    if (path1TextBuf.trim().length > MIN_MEANINGFUL_RESPONSE_LENGTH) {
+                        emitThinkingEnd();
+                        return {
+                            plan: {
+                                intent: "needs_clarification",
+                                summary_for_user: path1TextBuf.trim(),
+                                change_log: [],
+                                ops: []
+                            },
+                            usage,
+                            schemaContext: schemaContext.meta
+                        };
+                    }
+                    // If we couldn't parse, build a synthetic response to let the outer logic handle it
+                    response = { content: [], stop_reason: "end_turn", usage: { input_tokens: 0, output_tokens: 0 } };
+                }
+                else {
+                    const finalMessage = await stream.finalMessage();
+                    response = finalMessage;
+                }
+            }
+            else {
+                response = await client.messages.create({
+                    model: args.model,
+                    max_tokens: plannerMaxTokens,
+                    system: cachedSystem,
+                    tools: toolDefs,
+                    tool_choice: submitToolChoice,
+                    messages: loopMessages,
+                    ...thinkingRequestParams
+                }, { signal: effectiveSignal });
+            }
+            usage = sumTokenUsage(usage, extractUsage(response));
+            if (response.stop_reason === "max_tokens") {
+                args.log?.warn({
+                    event: "anthropic_planner_truncated",
+                    model: args.model,
+                    stopReason: "max_tokens",
+                    turn,
+                    contentBlockTypes: response.content.map((b) => b.type)
+                }, "Anthropic planner: response truncated (max_tokens) during tool loop");
+                throw new Error("Model response was truncated (max_tokens reached)");
+            }
+            if (args.onToken && !emittedTextDeltas) {
+                for (const block of response.content) {
+                    if (block.type === "text" && "text" in block && typeof block.text === "string") {
+                        args.onToken(block.text);
+                    }
+                }
+            }
+            const submitToolUse = response.content
+                .map((block) => asToolUseBlock(block))
+                .find((block) => block?.name === "submit_edit_plan");
+            if (submitToolUse && submitToolUse.input && typeof submitToolUse.input === "object") {
+                parsed = submitToolUse.input;
+                break;
+            }
+            const runtimeToolCalls = response.content
+                .map((block) => asToolUseBlock(block))
+                .filter((block) => Boolean(block && block.name !== "submit_edit_plan"));
+            if (runtimeToolCalls.length === 0) {
+                const textBlock = response.content.find((block) => block.type === "text");
+                const raw = textBlock && "text" in textBlock ? textBlock.text : "";
+                const jsonText = extractJsonObject(raw);
+                if (jsonText) {
+                    try {
+                        parsed = JSON.parse(jsonText);
+                    }
+                    catch {
+                        try {
+                            const meta = repairAndParseJsonWithMeta(jsonText);
+                            parsed = meta.parsed;
+                            args.log?.warn({ event: "anthropic_planner_json_repaired", model: args.model, strategy: meta.strategy, mutationCount: meta.mutationCount, discardedBytes: meta.discardedBytes }, "Anthropic planner: repaired malformed text-block JSON (non-streaming tool loop)");
+                        }
+                        catch { /* fall through */ }
+                    }
+                    if (parsed)
+                        break;
+                }
+                // Model responded with text only (no tool call). If we have meaningful
+                // text content, treat it as an "info" response rather than discarding it.
+                const trimmed = raw.trim();
+                if (trimmed.length > MIN_MEANINGFUL_RESPONSE_LENGTH) {
+                    emitThinkingEnd();
+                    return {
+                        plan: {
+                            intent: "needs_clarification",
+                            summary_for_user: trimmed,
+                            change_log: [],
+                            ops: []
+                        },
+                        usage,
+                        schemaContext: schemaContext.meta
+                    };
+                }
+                emitThinkingEnd();
+                return {
+                    plan: {
+                        intent: "needs_clarification",
+                        summary_for_user: "I'm not sure what to do with that. You can try:",
+                        change_log: [],
+                        ops: [],
+                        suggested_next_actions: [
+                            "Create a new page",
+                            "Add a section to the page",
+                            "Rewrite the copy",
+                            "Change the images"
+                        ]
+                    },
+                    usage,
+                    schemaContext: schemaContext.meta
+                };
+            }
+            loopMessages.push({ role: "assistant", content: response.content });
+            const toolResults = [];
+            for (const toolCall of runtimeToolCalls) {
+                const input = "input" in toolCall ? toolCall.input : {};
+                const runtimeToolName = runtimeToolNameByAlias.get(toolCall.name) ?? toolCall.name;
+                // Defer slow image tools — return a placeholder so text ops stream immediately
+                if (DEFERRABLE_IMAGE_TOOLS.has(runtimeToolName)) {
+                    const placeholderUrl = runtimeToolName === "image.generate"
+                        ? GENERATING_IMAGE_PLACEHOLDER
+                        : SEARCHING_IMAGE_PLACEHOLDER;
+                    const placeholderData = runtimeToolName === "image.generate"
+                        ? { imageUrl: placeholderUrl, alt: String(input.prompt ?? "Generating image…"), width: 768, height: 512 }
+                        : { items: [{ id: "placeholder", imageUrl: placeholderUrl, thumbUrl: placeholderUrl, alt: String(input.query ?? "Searching…"), author: "Placeholder", sourceUrl: "" }] };
+                    deferredNativeImageCalls.push({
+                        toolName: runtimeToolName,
+                        input: input,
+                        placeholderUrl
+                    });
+                    args.onToolExecution?.({
+                        toolName: runtimeToolName,
+                        ok: true,
+                        latencyMs: 0,
+                        attempts: 0,
+                        traceId: args.toolCallContext?.traceId ?? "tool-call",
+                        sessionId: args.toolCallContext?.sessionId ?? "dev",
+                        siteId: args.toolCallContext?.siteId ?? "default",
+                        plannerProvider: "anthropic",
+                        deferred: true
+                    });
+                    toolResults.push({
+                        type: "tool_result",
+                        tool_use_id: toolCall.id,
+                        content: JSON.stringify(placeholderData)
+                    });
+                    continue;
+                }
+                const result = await executeToolCall({
+                    runtime: args.toolRuntime,
+                    toolName: runtimeToolName,
+                    input,
+                    context: {
+                        siteId: args.toolCallContext?.siteId ?? "default",
+                        sessionId: args.toolCallContext?.sessionId ?? "dev",
+                        userId: args.toolCallContext?.userId,
+                        traceId: args.toolCallContext?.traceId ?? "tool-call",
+                        plannerProvider: "anthropic",
+                        gdriveFolderId: args.toolCallContext?.gdriveFolderId,
+                        onStatusUpdate: args.onStatusUpdate,
+                        onImageProgress: args.onImageProgress
+                    },
+                    policy: args.toolRuntime?.defaultPolicy
+                });
+                args.onToolExecution?.({
+                    toolName: runtimeToolName,
+                    ok: result.ok,
+                    latencyMs: result.latencyMs,
+                    attempts: result.attempts,
+                    errorCode: result.error?.code,
+                    traceId: args.toolCallContext?.traceId ?? "tool-call",
+                    sessionId: args.toolCallContext?.sessionId ?? "dev",
+                    siteId: args.toolCallContext?.siteId ?? "default",
+                    plannerProvider: "anthropic"
+                });
+                toolResults.push({
+                    type: "tool_result",
+                    tool_use_id: toolCall.id,
+                    content: JSON.stringify(result.ok ? result.data : { error: result.error }),
+                    ...(result.ok ? {} : { is_error: true })
+                });
+            }
+            loopMessages.push({
+                role: "user",
+                content: toolResults
+            });
+        }
+    }
+    else if (args.onToken) {
+        let toolJsonBuf = "";
+        let textBuf = "";
+        if (client.messages.stream) {
+            // NOTE: forced tool_choice is incompatible with extended thinking on Anthropic;
+            // when thinking is enabled we relax to `auto` so the model can think freely
+            // before emitting the tool call.
+            const stream = client.messages.stream({
+                model: args.model,
+                max_tokens: plannerMaxTokens,
+                system: cachedSystem,
+                tools: [anthropicToolWithCache(submitPlanToolDef)],
+                tool_choice: thinkingParam
+                    ? { type: "auto" }
+                    : { type: "tool", name: "submit_edit_plan" },
+                messages: [
+                    ...historyMessages,
+                    { role: "user", content: userContent }
+                ],
+                ...thinkingRequestParams
+            }, {
+                headers: ANTHROPIC_FINE_GRAINED_STREAM_HEADERS,
+                signal: effectiveSignal,
+            });
+            // Wrap stream iteration — SDK may throw on message_stop if tool JSON is malformed
+            let streamLoopError;
+            const path2ThinkingBlockIndexes = new Set();
+            try {
+                for await (const event of stream) {
+                    if (event.type === "content_block_start") {
+                        const idx = typeof event.index === "number" ? event.index : -1;
+                        if (idx >= 0 && event.content_block?.type === "thinking") {
+                            path2ThinkingBlockIndexes.add(idx);
+                            emitThinkingStart();
+                        }
+                        continue;
+                    }
+                    if (event.type === "content_block_stop") {
+                        const idx = typeof event.index === "number" ? event.index : -1;
+                        if (idx >= 0 && path2ThinkingBlockIndexes.has(idx)) {
+                            path2ThinkingBlockIndexes.delete(idx);
+                            if (path2ThinkingBlockIndexes.size === 0)
+                                emitThinkingEnd();
+                        }
+                        continue;
+                    }
+                    if (event.type === "content_block_delta") {
+                        if (event.delta?.type === "thinking_delta") {
+                            const thinkingText = event.delta.thinking ?? "";
+                            if (thinkingText.length > 0)
+                                emitThinkingToken(thinkingText);
+                        }
+                        else if (event.delta?.type === "input_json_delta") {
+                            toolJsonBuf += event.delta.partial_json ?? "";
+                            emitProgressFromToolJson(toolJsonBuf);
+                        }
+                        else if (event.delta?.type === "text_delta") {
+                            textBuf += event.delta.text ?? "";
+                            args.onToken(event.delta.text ?? "");
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (isApiLevelError(err))
+                    throw err;
+                streamLoopError = err;
+                args.log?.warn({
+                    event: "anthropic_path2_stream_loop_error",
+                    model: args.model,
+                    error: err instanceof Error ? err.message : String(err),
+                    toolJsonBufLength: toolJsonBuf.length,
+                    toolJsonBufPreview: toolJsonBuf.slice(0, 500),
+                }, "Anthropic Path 2: stream loop threw (SDK JSON parse) — will attempt toolJsonBuf repair");
+            }
+            // If stream completed normally, try finalMessage() for validated tool input.
+            // Skip if stream threw — finalMessage() would also fail.
+            if (!streamLoopError) {
+                let finalMessage;
+                try {
+                    finalMessage = await stream.finalMessage();
+                    usage = extractUsage(finalMessage);
+                    const streamStopReason = finalMessage?.stop_reason;
+                    if (streamStopReason === "max_tokens") {
+                        args.log?.warn({
+                            event: "anthropic_planner_truncated",
+                            model: args.model,
+                            stopReason: streamStopReason,
+                            toolJsonBufLength: toolJsonBuf.length,
+                            textBufLength: textBuf.length
+                        }, "Anthropic planner: response truncated (max_tokens)");
+                        throw new Error("Model response was truncated (max_tokens reached)");
+                    }
+                    const finalToolBlock = finalMessage.content
+                        ?.map((block) => asToolUseBlock(block))
+                        .find((block) => block?.name === "submit_edit_plan");
+                    if (finalToolBlock?.input && typeof finalToolBlock.input === "object") {
+                        parsed = finalToolBlock.input;
+                    }
+                }
+                catch (finalMsgErr) {
+                    if (finalMsgErr instanceof Error && finalMsgErr.message.includes("max_tokens"))
+                        throw finalMsgErr;
+                    args.log?.warn({
+                        event: "anthropic_planner_final_message_failed",
+                        model: args.model,
+                        error: finalMsgErr instanceof Error ? finalMsgErr.message : String(finalMsgErr),
+                        toolJsonBufLength: toolJsonBuf.length,
+                    }, "Anthropic planner: finalMessage() threw — falling back to streamed buffer repair");
+                }
+            }
+            // Fallback: streamed buffer + repair (if finalMessage didn't yield tool input)
+            if (!parsed && toolJsonBuf.length > 0) {
+                parsed = tryParseOrRepair(toolJsonBuf, args.log, args.model) ?? undefined;
+            }
+            if (!parsed && textBuf.length > 0) {
+                const jsonText = extractJsonObject(textBuf);
+                if (jsonText) {
+                    try {
+                        parsed = JSON.parse(jsonText);
+                    }
+                    catch {
+                        try {
+                            const meta = repairAndParseJsonWithMeta(jsonText);
+                            parsed = meta.parsed;
+                            args.log?.warn({ event: "anthropic_planner_json_repaired", model: args.model, strategy: meta.strategy, mutationCount: meta.mutationCount, discardedBytes: meta.discardedBytes }, "Anthropic planner: repaired malformed text-block JSON (streaming)");
+                        }
+                        catch { /* fall through to non-parsed state */ }
+                    }
+                }
+            }
+        }
+        else {
+            const response = await client.messages.create({
+                model: args.model,
+                max_tokens: plannerMaxTokens,
+                system: cachedSystem,
+                tools: [anthropicToolWithCache(submitPlanToolDef)],
+                tool_choice: thinkingParam
+                    ? { type: "auto" }
+                    : { type: "tool", name: "submit_edit_plan" },
+                messages: [
+                    ...historyMessages,
+                    { role: "user", content: userContent }
+                ],
+                ...thinkingRequestParams
+            }, { signal: effectiveSignal });
+            usage = extractUsage(response);
+            if (response.stop_reason === "max_tokens") {
+                args.log?.warn({
+                    event: "anthropic_planner_truncated",
+                    model: args.model,
+                    stopReason: response.stop_reason,
+                    contentBlockTypes: response.content.map((b) => b.type)
+                }, "Anthropic planner: response truncated (max_tokens)");
+                throw new Error("Model response was truncated (max_tokens reached)");
+            }
+            const toolBlock = response.content.find((b) => b.type === "tool_use");
+            if (toolBlock && "input" in toolBlock && toolBlock.input && typeof toolBlock.input === "object") {
+                parsed = toolBlock.input;
+            }
+            else {
+                const textBlock = response.content.find((b) => b.type === "text");
+                const raw = textBlock && "text" in textBlock ? textBlock.text : "";
+                const jsonText = extractJsonObject(raw);
+                if (jsonText) {
+                    try {
+                        parsed = JSON.parse(jsonText);
+                    }
+                    catch {
+                        try {
+                            const meta = repairAndParseJsonWithMeta(jsonText);
+                            parsed = meta.parsed;
+                            args.log?.warn({ event: "anthropic_planner_json_repaired", model: args.model, strategy: meta.strategy, mutationCount: meta.mutationCount, discardedBytes: meta.discardedBytes }, "Anthropic planner: repaired malformed text-block JSON (non-streaming)");
+                        }
+                        catch { /* fall through */ }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // No runtime tools — try output_config.format for constrained decoding first,
+        // then fall back to tool_choice if the model doesn't return parseable JSON
+        // (some models like Haiku 4.5 may not reliably support output_config).
+        // NOTE: output_config is incompatible with extended thinking. When thinking
+        // is requested, skip straight to the tool_choice fallback below.
+        if (!thinkingParam)
+            try {
+                const response = await client.messages.create({
+                    model: args.model,
+                    max_tokens: plannerMaxTokens,
+                    system: cachedSystem,
+                    output_config: {
+                        format: { type: "json_schema", schema: buildEditPlanJsonSchema({ planFirstMode }) }
+                    },
+                    messages: [
+                        ...historyMessages,
+                        { role: "user", content: userContent }
+                    ],
+                }, { signal: effectiveSignal });
+                usage = extractUsage(response);
+                if (response.stop_reason === "max_tokens") {
+                    args.log?.warn({
+                        event: "anthropic_planner_truncated",
+                        model: args.model,
+                        stopReason: response.stop_reason,
+                        contentBlockTypes: response.content.map((b) => b.type)
+                    }, "Anthropic planner: response truncated (max_tokens)");
+                    throw new Error("Model response was truncated (max_tokens reached)");
+                }
+                const textBlock = response.content.find((b) => b.type === "text");
+                const raw = textBlock && "text" in textBlock ? textBlock.text : "";
+                if (raw.trim()) {
+                    try {
+                        parsed = JSON.parse(raw);
+                    }
+                    catch {
+                        try {
+                            const meta = repairAndParseJsonWithMeta(raw);
+                            parsed = meta.parsed;
+                            args.log?.warn({ event: "anthropic_planner_json_repaired", model: args.model, strategy: meta.strategy, mutationCount: meta.mutationCount, discardedBytes: meta.discardedBytes }, "Anthropic planner: repaired malformed output_config JSON");
+                        }
+                        catch { /* fall through to tool_choice fallback below */ }
+                    }
+                }
+            }
+            catch (outputConfigErr) {
+                // output_config may not be supported by this model — log and fall through
+                // to the tool_choice fallback below (don't re-throw truncation errors).
+                if (outputConfigErr instanceof Error && outputConfigErr.message.includes("truncated"))
+                    throw outputConfigErr;
+                args.log?.warn({
+                    event: "anthropic_planner_output_config_failed",
+                    model: args.model,
+                    error: outputConfigErr instanceof Error ? outputConfigErr.message : String(outputConfigErr)
+                }, "Anthropic planner: output_config call failed, falling back to tool_choice");
+            }
+        // Fallback: if output_config didn't produce JSON, retry with tool_choice
+        if (!parsed) {
+            args.log?.warn({
+                event: "anthropic_planner_output_config_fallback",
+                model: args.model
+            }, "Anthropic planner: output_config returned no JSON, retrying with tool_choice");
+            const fallbackResponse = await client.messages.create({
+                model: args.model,
+                max_tokens: plannerMaxTokens,
+                system: cachedSystem,
+                tools: [anthropicToolWithCache(submitPlanToolDef)],
+                tool_choice: thinkingParam
+                    ? { type: "auto" }
+                    : { type: "tool", name: "submit_edit_plan" },
+                messages: [
+                    ...historyMessages,
+                    { role: "user", content: userContent }
+                ],
+                ...thinkingRequestParams
+            }, { signal: effectiveSignal });
+            const fallbackUsage = extractUsage(fallbackResponse);
+            usage = {
+                inputTokens: usage.inputTokens + fallbackUsage.inputTokens,
+                outputTokens: usage.outputTokens + fallbackUsage.outputTokens,
+                totalTokens: usage.totalTokens + fallbackUsage.totalTokens,
+                cacheCreationInputTokens: (usage.cacheCreationInputTokens ?? 0) + (fallbackUsage.cacheCreationInputTokens ?? 0),
+                cacheReadInputTokens: (usage.cacheReadInputTokens ?? 0) + (fallbackUsage.cacheReadInputTokens ?? 0)
+            };
+            if (fallbackResponse.stop_reason === "max_tokens") {
+                throw new Error("Model response was truncated (max_tokens reached)");
+            }
+            const toolBlock = fallbackResponse.content.find((b) => b.type === "tool_use");
+            if (toolBlock && "input" in toolBlock && toolBlock.input && typeof toolBlock.input === "object") {
+                parsed = toolBlock.input;
+            }
+            else {
+                const textBlock = fallbackResponse.content.find((b) => b.type === "text");
+                const raw = textBlock && "text" in textBlock ? textBlock.text : "";
+                const jsonText = extractJsonObject(raw);
+                if (jsonText) {
+                    try {
+                        parsed = JSON.parse(jsonText);
+                    }
+                    catch {
+                        try {
+                            const meta = repairAndParseJsonWithMeta(jsonText);
+                            parsed = meta.parsed;
+                        }
+                        catch { /* fall through */ }
+                    }
+                }
+            }
+        }
+    }
+    // Safety: close any dangling thinking event before exit paths
+    emitThinkingEnd();
+    if (!parsed) {
+        args.log?.warn({
+            event: "anthropic_planner_no_json",
+            model: args.model,
+            hasHistory: (args.history?.length ?? 0) > 0,
+            hasFeedback: !!args.feedback
+        }, "Anthropic planner: model did not return parseable JSON");
+        throw new Error(`Model did not return JSON (model=${args.model})`);
+    }
+    const normalized = normalizePlanCandidate(parsed, {
+        defaultSlug: args.slug,
+        currentPage: args.currentPage,
+        userMessage: args.message
+    });
+    const planResult = editPlanSchema.safeParse(normalized);
+    if (!planResult.success) {
+        const first = planResult.error.issues[0];
+        const message = first?.message ?? "Invalid model output";
+        const path = first?.path?.length ? ` at ${first.path.join(".")}` : "";
+        const sample = JSON.stringify(normalized).slice(0, 700);
+        throw new Error(`${message}${path}. Parsed sample: ${sample}`);
+    }
+    const deferredImageMeta = deferredNativeImageCalls.length > 0 ? { deferredNativeImageCalls } : {};
+    if (chatStrictPrimaryOpMode && planResult.data.intent === "edit_plan" && planResult.data.ops.length > 1) {
+        return {
+            plan: {
+                ...planResult.data,
+                ops: [planResult.data.ops[0]]
+            },
+            usage,
+            schemaContext: schemaContext.meta,
+            ...deferredImageMeta
+        };
+    }
+    return { plan: planResult.data, usage, schemaContext: schemaContext.meta, ...deferredImageMeta };
+}