@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/chat/locale-strings.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Server-side locale strings for deterministic planner responses.
+ * Covers summary_for_user messages that bypass the LLM.
+ */
+export type ServerLocale = "en" | "de";
+declare const en: {
+    readonly "rename.needsPath": "Please provide the target page path, for example: rename page from /old to /new.";
+    readonly "rename.done": "Renamed page path from {{from}} to {{to}}.";
+    readonly "delete.homeBlocked": "The home page cannot be deleted. Navigate to a different page first, or specify which page to delete (e.g. \"delete /about\").";
+    readonly "delete.done": "Deleted page {{slug}}.";
+    readonly "move.notFound": "I could not find page {{slug}}.";
+    readonly "move.homeFixed": "Home page (/) is fixed at the first position in navigation.";
+    readonly "move.specifyWhere": "Specify where to place the page (first/last/before/after).";
+    readonly "move.anchorNotFound": "I could not find anchor page {{slug}}.";
+    readonly "move.done": "Moved **{{slug}}** {{direction}}.";
+    readonly "audience.done": "Tailored this page for {{audience}}.";
+    readonly "reorder.specify": "I can reorder sections if needed, but please specify what should move (for example: move FAQ below Testimonials).";
+    readonly "hero.secondaryCta": "Added a secondary CTA button to the selected Hero.";
+    readonly "update.done": "Updated {{type}}.";
+    readonly "update.specify": "Please specify the section and exact change you want.";
+    readonly "update.needsBlock": "I need to know which block to update.";
+    readonly "update.invalidFields": "Please specify at least one valid field for {{type}}.";
+    readonly "remove.allAlready": "All blocks are already {{type}} — nothing to remove.";
+    readonly "remove.keptOnly": "Removed all blocks except {{type}}.";
+    readonly "remove.needsBlock": "I need to know which block to remove.";
+    readonly "remove.specifyItem": "Please specify which item to remove (e.g., \"the first question\", \"the last item\").";
+    readonly "remove.outOfRange": "There are only {{count}} items in {{type}} — cannot remove item {{index}}.";
+    readonly "remove.itemDone": "Removed an item from {{type}}.";
+    readonly "remove.done": "Removed {{type}}.";
+    readonly "move.needsBlock": "I need to know which block to move.";
+    readonly "move.anchorBlockNotFound": "I could not find the anchor block to move after.";
+    readonly "move.anchorBlockBeforeNotFound": "I could not find the anchor block to move before.";
+    readonly "move.specifyDirection": "Please specify where to move the block (top, bottom, before, after).";
+    readonly "move.blockDone": "Moved {{type}}.";
+    readonly "add.multiple": "Added {{types}}.";
+    readonly "add.heroImage": "Updated the hero image.";
+    readonly "add.specifyType": "Please specify which block type to add ({{types}}).";
+    readonly "add.itemDone": "Added an item to {{type}}.";
+    readonly "add.anchorAfterNotFound": "I could not find the anchor block to place this after.";
+    readonly "add.anchorBeforeNotFound": "I could not find the anchor block to place this before.";
+    readonly "add.done": "Added {{type}}.";
+    readonly "duplicate.done": "Duplicated {{type}}.";
+    readonly "duplicate.pageDone": "Duplicated page {{from}} as {{to}}.";
+};
+type ServerStringKey = keyof typeof en;
+export declare function st(locale: string | undefined, key: ServerStringKey, vars?: Record<string, string | number>): string;
+export {};

package/dist/chat/locale-strings.js

@@ -0,0 +1,100 @@
+/**
+ * Server-side locale strings for deterministic planner responses.
+ * Covers summary_for_user messages that bypass the LLM.
+ */
+function resolveLocale(locale) {
+    if (locale === "de")
+        return "de";
+    return "en";
+}
+const en = {
+    "rename.needsPath": "Please provide the target page path, for example: rename page from /old to /new.",
+    "rename.done": "Renamed page path from {{from}} to {{to}}.",
+    "delete.homeBlocked": "The home page cannot be deleted. Navigate to a different page first, or specify which page to delete (e.g. \"delete /about\").",
+    "delete.done": "Deleted page {{slug}}.",
+    "move.notFound": "I could not find page {{slug}}.",
+    "move.homeFixed": "Home page (/) is fixed at the first position in navigation.",
+    "move.specifyWhere": "Specify where to place the page (first/last/before/after).",
+    "move.anchorNotFound": "I could not find anchor page {{slug}}.",
+    "move.done": "Moved **{{slug}}** {{direction}}.",
+    "audience.done": "Tailored this page for {{audience}}.",
+    "reorder.specify": "I can reorder sections if needed, but please specify what should move (for example: move FAQ below Testimonials).",
+    "hero.secondaryCta": "Added a secondary CTA button to the selected Hero.",
+    "update.done": "Updated {{type}}.",
+    "update.specify": "Please specify the section and exact change you want.",
+    "update.needsBlock": "I need to know which block to update.",
+    "update.invalidFields": "Please specify at least one valid field for {{type}}.",
+    "remove.allAlready": "All blocks are already {{type}} — nothing to remove.",
+    "remove.keptOnly": "Removed all blocks except {{type}}.",
+    "remove.needsBlock": "I need to know which block to remove.",
+    "remove.specifyItem": "Please specify which item to remove (e.g., \"the first question\", \"the last item\").",
+    "remove.outOfRange": "There are only {{count}} items in {{type}} — cannot remove item {{index}}.",
+    "remove.itemDone": "Removed an item from {{type}}.",
+    "remove.done": "Removed {{type}}.",
+    "move.needsBlock": "I need to know which block to move.",
+    "move.anchorBlockNotFound": "I could not find the anchor block to move after.",
+    "move.anchorBlockBeforeNotFound": "I could not find the anchor block to move before.",
+    "move.specifyDirection": "Please specify where to move the block (top, bottom, before, after).",
+    "move.blockDone": "Moved {{type}}.",
+    "add.multiple": "Added {{types}}.",
+    "add.heroImage": "Updated the hero image.",
+    "add.specifyType": "Please specify which block type to add ({{types}}).",
+    "add.itemDone": "Added an item to {{type}}.",
+    "add.anchorAfterNotFound": "I could not find the anchor block to place this after.",
+    "add.anchorBeforeNotFound": "I could not find the anchor block to place this before.",
+    "add.done": "Added {{type}}.",
+    "duplicate.done": "Duplicated {{type}}.",
+    "duplicate.pageDone": "Duplicated page {{from}} as {{to}}.",
+};
+const strings = {
+    en,
+    de: {
+        "rename.needsPath": "Bitte gib den Zielpfad an, zum Beispiel: Seite umbenennen von /alt nach /neu.",
+        "rename.done": "Seitenpfad von {{from}} nach {{to}} umbenannt.",
+        "delete.homeBlocked": "Die Startseite kann nicht gel\u00F6scht werden. Navigiere zuerst zu einer anderen Seite oder gib an, welche Seite gel\u00F6scht werden soll (z.\u00A0B. \"/about l\u00F6schen\").",
+        "delete.done": "Seite {{slug}} gelöscht.",
+        "move.notFound": "Seite {{slug}} nicht gefunden.",
+        "move.homeFixed": "Die Startseite (/) ist fest an erster Stelle in der Navigation.",
+        "move.specifyWhere": "Gib an, wohin die Seite verschoben werden soll (erste/letzte/vor/nach).",
+        "move.anchorNotFound": "Ankerseite {{slug}} nicht gefunden.",
+        "move.done": "**{{slug}}** {{direction}} verschoben.",
+        "audience.done": "Diese Seite wurde für {{audience}} angepasst.",
+        "reorder.specify": "Ich kann Bereiche umordnen, aber bitte gib an, was verschoben werden soll (z.\u00A0B.: FAQ unter Testimonials verschieben).",
+        "hero.secondaryCta": "Sekundären CTA-Button zum ausgewählten Hero hinzugefügt.",
+        "update.done": "{{type}} aktualisiert.",
+        "update.specify": "Bitte gib den Bereich und die gewünschte Änderung an.",
+        "update.needsBlock": "Ich muss wissen, welcher Block aktualisiert werden soll.",
+        "update.invalidFields": "Bitte gib mindestens ein gültiges Feld für {{type}} an.",
+        "remove.allAlready": "Alle Blöcke sind bereits {{type}} — nichts zu entfernen.",
+        "remove.keptOnly": "Alle Blöcke außer {{type}} entfernt.",
+        "remove.needsBlock": "Ich muss wissen, welcher Block entfernt werden soll.",
+        "remove.specifyItem": "Bitte gib an, welches Element entfernt werden soll (z.\u00A0B. 'die erste Frage', 'das letzte Element').",
+        "remove.outOfRange": "Es gibt nur {{count}} Elemente in {{type}} — Element {{index}} kann nicht entfernt werden.",
+        "remove.itemDone": "Element aus {{type}} entfernt.",
+        "remove.done": "{{type}} entfernt.",
+        "move.needsBlock": "Ich muss wissen, welcher Block verschoben werden soll.",
+        "move.anchorBlockNotFound": "Ankerblock zum Verschieben nicht gefunden.",
+        "move.anchorBlockBeforeNotFound": "Ankerblock zum Davor-Platzieren nicht gefunden.",
+        "move.specifyDirection": "Bitte gib an, wohin der Block verschoben werden soll (oben, unten, vor, nach).",
+        "move.blockDone": "{{type}} verschoben.",
+        "add.multiple": "{{types}} hinzugefügt.",
+        "add.heroImage": "Hero-Bild aktualisiert.",
+        "add.specifyType": "Bitte gib den Blocktyp an, der hinzugefügt werden soll ({{types}}).",
+        "add.itemDone": "Element zu {{type}} hinzugefügt.",
+        "add.anchorAfterNotFound": "Ankerblock zum Danach-Platzieren nicht gefunden.",
+        "add.anchorBeforeNotFound": "Ankerblock zum Davor-Platzieren nicht gefunden.",
+        "add.done": "{{type}} hinzugefügt.",
+        "duplicate.done": "{{type}} dupliziert.",
+        "duplicate.pageDone": "Seite {{from}} als {{to}} dupliziert.",
+    },
+};
+export function st(locale, key, vars) {
+    const l = resolveLocale(locale);
+    let str = strings[l][key] ?? strings.en[key] ?? key;
+    if (vars) {
+        for (const [k, v] of Object.entries(vars)) {
+            str = str.replaceAll(`{{${k}}}`, String(v));
+        }
+    }
+    return str;
+}

package/dist/chat/plan-json-schema.d.ts

@@ -0,0 +1,133 @@
+export declare const editPlanJsonSchema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly intent: {
+            readonly type: "string";
+            readonly enum: readonly ["edit_plan", "needs_clarification", "content_answer"];
+            readonly description: "Whether this is a concrete edit plan, a clarification request, or a read-only answer about page content.";
+        };
+        readonly summary_for_user: {
+            readonly type: "string";
+            readonly description: "Human-readable summary of what was done. Use past tense. Use **bold** and bullet lists (- item) for readability when listing multiple points.";
+        };
+        readonly change_log: {
+            readonly type: "string";
+            readonly description: "Markdown summary of changes, one line per operation.";
+        };
+        readonly ops: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly op: {
+                        readonly type: "string";
+                        readonly description: "Operation name";
+                    };
+                    readonly pageSlug: {
+                        readonly type: "string";
+                    };
+                    readonly blockId: {
+                        readonly type: "string";
+                    };
+                    readonly afterBlockId: {
+                        readonly type: "string";
+                    };
+                    readonly newBlockId: {
+                        readonly type: "string";
+                    };
+                    readonly toPageSlug: {
+                        readonly type: "string";
+                    };
+                    readonly newPageSlug: {
+                        readonly type: "string";
+                    };
+                    readonly newTitle: {
+                        readonly type: "string";
+                    };
+                    readonly afterPageSlug: {
+                        readonly type: "string";
+                    };
+                    readonly listKey: {
+                        readonly type: "string";
+                    };
+                    readonly index: {
+                        readonly type: "integer";
+                    };
+                    readonly afterIndex: {
+                        readonly type: "integer";
+                    };
+                    readonly patch: {
+                        readonly type: "object";
+                    };
+                    readonly block: {
+                        readonly type: "object";
+                    };
+                    readonly page: {
+                        readonly type: "object";
+                    };
+                    readonly item: {
+                        readonly type: "object";
+                    };
+                };
+                readonly required: readonly ["op"];
+            };
+            readonly description: "Array of operations. Each has 'op' plus operation-specific fields.";
+        };
+        readonly suggested_next_actions: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "2-4 short imperative phrases the user could type next.";
+        };
+    };
+    readonly required: string[];
+};
+/**
+ * Returns the EditPlan schema for a request. In plan-first review mode the
+ * `intent` enum is narrowed to `["edit_plan"]` so the model CANNOT emit
+ * needs_clarification / content_answer — it must produce a concrete, reviewable
+ * plan (the Apply/Discard preview gate makes a wrong guess one-click-discardable,
+ * so bailing to a question is never the right move). Prompt directives alone
+ * proved unreliable here; constraining the output schema is the hard guarantee.
+ */
+export declare function buildEditPlanJsonSchema(opts?: {
+    planFirstMode?: boolean;
+}): typeof editPlanJsonSchema;
+export declare const intentJsonSchema: {
+    type: "object";
+    additionalProperties: boolean;
+    properties: {
+        action: {
+            type: "string";
+            enum: string[];
+        };
+        target_block_ref: {
+            anyOf: Record<string, unknown>[];
+        };
+        target_block_type: {
+            anyOf: Record<string, unknown>[];
+        };
+        new_block_type: {
+            anyOf: Record<string, unknown>[];
+        };
+        position: {
+            anyOf: Record<string, unknown>[];
+        };
+        anchor_block_ref: {
+            anyOf: Record<string, unknown>[];
+        };
+        summary: {
+            anyOf: Record<string, unknown>[];
+        };
+        assumption: {
+            anyOf: Record<string, unknown>[];
+        };
+        complexity: {
+            anyOf: Record<string, unknown>[];
+        };
+    };
+    required: string[];
+};

package/dist/chat/plan-json-schema.js

@@ -0,0 +1,112 @@
+import { allowedBlockTypes } from "@avocadostudio-ai/shared";
+// ---------------------------------------------------------------------------
+// JSON Schema for EditPlan — used as Anthropic tool_use input_schema and
+// OpenAI json_schema response_format.
+// ---------------------------------------------------------------------------
+// Intentionally loose on the ops array: the downstream normalizePlanCandidate +
+// Zod editPlanSchema validation handles strict validation and repair. Keeping
+// the schema simple avoids the model fighting overly-rigid constraints while
+// still guaranteeing we get structured JSON instead of prose.
+// ---------------------------------------------------------------------------
+export const editPlanJsonSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        intent: {
+            type: "string",
+            enum: ["edit_plan", "needs_clarification", "content_answer"],
+            description: "Whether this is a concrete edit plan, a clarification request, or a read-only answer about page content."
+        },
+        summary_for_user: {
+            type: "string",
+            description: "Human-readable summary of what was done. Use past tense. Use **bold** and bullet lists (- item) for readability when listing multiple points."
+        },
+        change_log: {
+            type: "string",
+            description: "Markdown summary of changes, one line per operation."
+        },
+        ops: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    op: { type: "string", description: "Operation name" },
+                    pageSlug: { type: "string" },
+                    blockId: { type: "string" },
+                    afterBlockId: { type: "string" },
+                    newBlockId: { type: "string" },
+                    toPageSlug: { type: "string" },
+                    newPageSlug: { type: "string" },
+                    newTitle: { type: "string" },
+                    afterPageSlug: { type: "string" },
+                    listKey: { type: "string" },
+                    index: { type: "integer" },
+                    afterIndex: { type: "integer" },
+                    patch: { type: "object" },
+                    block: { type: "object" },
+                    page: { type: "object" },
+                    item: { type: "object" }
+                },
+                required: ["op"]
+            },
+            description: "Array of operations. Each has 'op' plus operation-specific fields."
+        },
+        suggested_next_actions: {
+            type: "array",
+            items: { type: "string" },
+            description: "2-4 short imperative phrases the user could type next."
+        }
+    },
+    required: ["intent", "summary_for_user", "change_log", "ops"]
+};
+/**
+ * Returns the EditPlan schema for a request. In plan-first review mode the
+ * `intent` enum is narrowed to `["edit_plan"]` so the model CANNOT emit
+ * needs_clarification / content_answer — it must produce a concrete, reviewable
+ * plan (the Apply/Discard preview gate makes a wrong guess one-click-discardable,
+ * so bailing to a question is never the right move). Prompt directives alone
+ * proved unreliable here; constraining the output schema is the hard guarantee.
+ */
+export function buildEditPlanJsonSchema(opts) {
+    if (!opts?.planFirstMode)
+        return editPlanJsonSchema;
+    return {
+        ...editPlanJsonSchema,
+        properties: {
+            ...editPlanJsonSchema.properties,
+            intent: {
+                ...editPlanJsonSchema.properties.intent,
+                enum: ["edit_plan"],
+                description: "Plan-first review mode: this MUST be \"edit_plan\". Clarification and read-only answers are not permitted — generate any missing copy and choose sensible defaults to produce a concrete, reviewable plan."
+            }
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// JSON Schema for intent parsing — used with output_config.format for
+// constrained decoding (guaranteed valid JSON matching this schema).
+// Hand-crafted to stay within the intersection of OpenAI strict mode and
+// Anthropic json_schema constraints (no propertyNames, $ref, oneOf, etc.).
+// ---------------------------------------------------------------------------
+function nullable(schema) {
+    return { anyOf: [schema, { type: "null" }] };
+}
+const blockTypeEnumSchema = { type: "string", enum: [...allowedBlockTypes] };
+export const intentJsonSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        action: { type: "string", enum: ["add", "move", "update", "remove", "info", "clarify"] },
+        target_block_ref: nullable({ type: "string" }),
+        target_block_type: nullable(blockTypeEnumSchema),
+        new_block_type: nullable(blockTypeEnumSchema),
+        position: nullable({ type: "string", enum: ["top", "bottom", "before", "after"] }),
+        anchor_block_ref: nullable({ type: "string" }),
+        summary: nullable({ type: "string" }),
+        assumption: nullable({ type: "string" }),
+        complexity: nullable({ type: "string", enum: ["simple", "standard", "complex"] })
+    },
+    required: ["action", "target_block_ref", "target_block_type", "new_block_type",
+        "position", "anchor_block_ref", "summary", "assumption", "complexity"]
+};

package/dist/chat/planner-types.d.ts

@@ -0,0 +1,120 @@
+import type { PlannerSource } from "./provider-routing.ts";
+import type { ParsedIntent } from "../nlp/deterministic-planner.ts";
+import type { EditPlan, PageDoc, BlockManifest, Operation } from "@avocadostudio-ai/shared";
+import type { TokenUsage } from "../telemetry/usage.ts";
+import type { PlannerSchemaContextMeta } from "./planner.ts";
+import type { DeferredNativeImageCall } from "./chat-pipeline-shared.ts";
+import type { ToolRuntime } from "../tools/runtime.ts";
+import type { ToolExecutionEvent } from "../tools/types.ts";
+export type CommonParseIntentArgs = {
+    message: string;
+    slug: string;
+    currentPage: PageDoc;
+    activeBlockId?: string;
+    activeBlockType?: string;
+    activeEditablePath?: string;
+    model: string;
+    log?: {
+        warn: (obj: Record<string, unknown>, msg: string) => void;
+    };
+};
+export type ThinkingEvent = {
+    type: "start";
+} | {
+    type: "token";
+    text: string;
+} | {
+    type: "end";
+    durationMs: number;
+};
+export type CommonGeneratePlanArgs = {
+    message: string;
+    slug: string;
+    currentPage: PageDoc;
+    contextPack: ReturnType<typeof import("../nlp/deterministic-planner.ts").plannerContextPack>;
+    model: string;
+    history?: Array<{
+        role: "user" | "assistant";
+        content: string;
+    }>;
+    feedback?: string;
+    onToken?: (token: string) => void;
+    onThinking?: (event: ThinkingEvent) => void;
+    onFieldDraft?: (draft: {
+        blockId: string;
+        editablePath: string;
+        value: string;
+    }) => void;
+    onPlannedOp?: (op: Operation, index: number) => void;
+    onSummaryChunk?: (text: string) => void;
+    onChangeLogEntry?: (entry: string) => void;
+    onToolExecution?: (event: ToolExecutionEvent) => void;
+    onStatusUpdate?: (message: string) => void;
+    onImageProgress?: (event: {
+        percent: number;
+        stage: string;
+    }) => void;
+    toolRuntime?: ToolRuntime;
+    toolCallContext?: {
+        siteId: string;
+        sessionId: string;
+        userId?: string;
+        traceId: string;
+        gdriveFolderId?: string;
+    };
+    siteContextBlock?: string | null;
+    log?: {
+        warn: (obj: Record<string, unknown>, msg: string) => void;
+    };
+    forceFullSchemaContracts?: boolean;
+    componentsManifest?: BlockManifest;
+    lightweight?: boolean;
+    signal?: AbortSignal;
+    locale?: string;
+    /**
+     * True iff the planner is allowed to return needs_clarification asking the
+     * user whether a new image should come from Unsplash or AI generation. Set
+     * only when both sources are configured server-side AND no session-level
+     * preference is in effect. See chat-pipeline.ts for the computation and
+     * sectionImageSourceChoice in prompts.ts for how the rule is phrased.
+     */
+    imageSourceChoiceOpen?: boolean;
+    /**
+     * Enable adaptive thinking at the given effort (Anthropic). Ignored by
+     * providers that don't support it. Effort controls thinking depth and overall
+     * token spend — keep it modest for cost efficiency.
+     */
+    thinking?: {
+        effort: PlannerEffort;
+    };
+};
+/**
+ * Effort levels accepted by the Messages API `output_config.effort` field on the
+ * stable SDK. `xhigh` is beta-only and intentionally excluded.
+ */
+export type PlannerEffort = "low" | "medium" | "high" | "max";
+/**
+ * Map a legacy thinking token budget onto an effort level, preserving the
+ * "bigger budget → more thinking" intent of the CHAT_AUTO_REASONING_BUDGET knob
+ * while moving to the adaptive-thinking API. Deliberately cost-conscious: the
+ * default budget (2048) lands on "medium", not "high".
+ */
+export declare function budgetTokensToEffort(budgetTokens: number): PlannerEffort;
+export type GeneratePlanResult = {
+    plan: EditPlan;
+    usage: TokenUsage;
+    schemaContext: PlannerSchemaContextMeta;
+    deferredNativeImageCalls?: DeferredNativeImageCall[];
+};
+export interface Planner {
+    readonly source: PlannerSource;
+    /** True when the provider supports native tool use for structured output. */
+    readonly supportsNativeTools: boolean;
+    parseIntent(args: CommonParseIntentArgs): Promise<ParsedIntent>;
+    generatePlan(args: CommonGeneratePlanArgs): Promise<GeneratePlanResult>;
+}
+export type PlannerRegistry = {
+    get(source: PlannerSource): Planner | null;
+    has(source: PlannerSource): boolean;
+};
+export declare function createPlannerRegistry(overrides?: Partial<Record<PlannerSource, Planner>>): PlannerRegistry;

package/dist/chat/planner-types.js

@@ -0,0 +1,66 @@
+import { generatePlanWithOpenAI, parseIntentWithOpenAI, } from "./planner.js";
+import { generatePlanWithAnthropic, parseIntentWithAnthropic, } from "./anthropic-planner.js";
+import { generatePlanWithGemini, parseIntentWithGemini, } from "./gemini-planner.js";
+/**
+ * Map a legacy thinking token budget onto an effort level, preserving the
+ * "bigger budget → more thinking" intent of the CHAT_AUTO_REASONING_BUDGET knob
+ * while moving to the adaptive-thinking API. Deliberately cost-conscious: the
+ * default budget (2048) lands on "medium", not "high".
+ */
+export function budgetTokensToEffort(budgetTokens) {
+    if (budgetTokens <= 1500)
+        return "low";
+    if (budgetTokens <= 8000)
+        return "medium";
+    if (budgetTokens <= 24000)
+        return "high";
+    return "max";
+}
+// ---------------------------------------------------------------------------
+// Default implementations — thin adapters over existing functions.
+// Each adapter strips fields the underlying provider function doesn't accept.
+// ---------------------------------------------------------------------------
+const openAIPlanner = {
+    source: "openai",
+    supportsNativeTools: false,
+    async parseIntent(args) {
+        const { log: _log, ...rest } = args;
+        return parseIntentWithOpenAI(rest);
+    },
+    async generatePlan(args) {
+        // OpenAI doesn't yet support Anthropic-style thinking events — drop them.
+        const { onStatusUpdate: _s, onImageProgress: _i, log: _l, onThinking: _t, thinking: _th, ...rest } = args;
+        return generatePlanWithOpenAI(rest);
+    },
+};
+const anthropicPlanner = {
+    source: "anthropic",
+    supportsNativeTools: true,
+    parseIntent: parseIntentWithAnthropic,
+    generatePlan: generatePlanWithAnthropic,
+};
+const geminiPlanner = {
+    source: "gemini",
+    supportsNativeTools: true,
+    parseIntent: parseIntentWithGemini,
+    async generatePlan(args) {
+        const { onThinking: _t, thinking: _th, ...rest } = args;
+        return generatePlanWithGemini(rest);
+    },
+};
+export function createPlannerRegistry(overrides) {
+    const defaults = {
+        openai: openAIPlanner,
+        anthropic: anthropicPlanner,
+        gemini: geminiPlanner,
+    };
+    const merged = { ...defaults, ...(overrides ?? {}) };
+    return {
+        get(source) {
+            return merged[source] ?? null;
+        },
+        has(source) {
+            return merged[source] !== undefined;
+        },
+    };
+}