@avocadostudio-ai/orchestrator-core 0.22.0 → 0.24.0

package/dist/agents/templates.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { CheckRule } from "../checks/types.ts";
+import type { AgentSpec } from "./spec.ts";
+export type TemplateContext = {
+    agentId: string;
+    stepIndex: number;
+    severity: AgentSpec["severity"];
+};
+export type RuleTemplate = {
+    id: string;
+    /** One line for API callers and, later, the authoring UI. */
+    description: string;
+    /** An example `params` object, shown by GET /agents/templates. */
+    example: Record<string, unknown>;
+    /** False for a template the check runner does not execute (Edit safety's diff). */
+    runnable: boolean;
+    params: z.ZodType<Record<string, unknown>>;
+    build(params: Record<string, unknown>, ctx: TemplateContext): CheckRule[];
+};
+/**
+ * A date a person typed into a field: ISO (`2026-09-06`), European
+ * (`06.09.2026`, `6/9/2026` read day-first) or anything `Date.parse` reads
+ * (`Sat 6 Sep 2026`). Null when it is not a date — that field is skipped,
+ * never reported, because a template must not guess.
+ */
+export declare function parseFieldDate(value: unknown): number | null;
+export declare const RULE_TEMPLATES: RuleTemplate[];
+export declare function templateById(id: string): RuleTemplate | undefined;
+/**
+ * A spec's detect steps as check rules. Throws, naming the step, on an
+ * unknown template or bad params — a spec that cannot compile is refused
+ * when it is saved, not discovered when it runs at 03:00.
+ */
+export declare function compileSpec(spec: AgentSpec): CheckRule[];

package/dist/agents/templates.js

@@ -0,0 +1,268 @@
+import { z } from "zod";
+import { fieldText } from "../checks/field-walk.js";
+import { DRAFT_RULES } from "../checks/rules-draft.js";
+const MAX_TEXT = 10_000;
+const MAX_FINDINGS_PER_PAGE = 50;
+function ruleId(ctx, template) {
+    return `${ctx.agentId}/${ctx.stepIndex}:${template}`;
+}
+/** A field whose own key (the last path segment) is `field`: `date` matches `date` and `items[2].date`. */
+function fieldMatches(entry, field) {
+    if (entry.path === field)
+        return true;
+    const last = entry.path.split(".").pop() ?? entry.path;
+    return last === field;
+}
+function blockMatches(entry, blockType) {
+    return !blockType || entry.blockType === blockType;
+}
+function where(entry) {
+    return {
+        source: "draft",
+        blockId: entry.blockId,
+        blockType: entry.blockType,
+        ...(entry.blockLabel ? { blockLabel: entry.blockLabel } : {}),
+        path: entry.path
+    };
+}
+function capped(findings) {
+    return findings.slice(0, MAX_FINDINGS_PER_PAGE);
+}
+/**
+ * The start of today, UTC. A date field "before today" is one whose day has
+ * fully passed — an event today is not yet in the past.
+ */
+function startOfToday(now) {
+    const d = new Date(now);
+    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+}
+/**
+ * A date a person typed into a field: ISO (`2026-09-06`), European
+ * (`06.09.2026`, `6/9/2026` read day-first) or anything `Date.parse` reads
+ * (`Sat 6 Sep 2026`). Null when it is not a date — that field is skipped,
+ * never reported, because a template must not guess.
+ */
+export function parseFieldDate(value) {
+    if (typeof value !== "string")
+        return null;
+    const text = value.trim();
+    if (!text)
+        return null;
+    const iso = /^(\d{4})-(\d{2})-(\d{2})/.exec(text);
+    if (iso)
+        return Date.UTC(Number(iso[1]), Number(iso[2]) - 1, Number(iso[3]));
+    const dayFirst = /^(\d{1,2})[./](\d{1,2})[./](\d{4})$/.exec(text);
+    if (dayFirst)
+        return Date.UTC(Number(dayFirst[3]), Number(dayFirst[2]) - 1, Number(dayFirst[1]));
+    const parsed = Date.parse(text);
+    if (Number.isNaN(parsed))
+        return null;
+    const d = new Date(parsed);
+    return Date.UTC(d.getFullYear(), d.getMonth(), d.getDate());
+}
+// ---------------------------------------------------------------------------
+const draftRule = {
+    id: "draft-rule",
+    description: "The draft checker's own rules, by id — how the built-in agents are expressed.",
+    example: { ruleIds: ["seo.title-missing", "a11y.alt-missing"] },
+    runnable: true,
+    params: z.object({ ruleIds: z.array(z.string().min(1)).min(1) }).strict(),
+    build(params) {
+        const wanted = new Set(params.ruleIds);
+        const unknown = [...wanted].filter((id) => !DRAFT_RULES.some((rule) => rule.id === id));
+        if (unknown.length > 0)
+            throw new Error(`unknown draft rule: ${unknown.join(", ")}`);
+        return DRAFT_RULES.filter((rule) => wanted.has(rule.id));
+    }
+};
+const fieldEmpty = {
+    id: "field-empty",
+    description: "A field that should have content has none.",
+    example: { blockType: "Hero", field: "subheading" },
+    runnable: true,
+    params: z.object({ field: z.string().min(1).max(80), blockType: z.string().min(1).max(80).optional() }).strict(),
+    build(params, ctx) {
+        const { field, blockType } = params;
+        return [
+            {
+                id: ruleId(ctx, "field-empty"),
+                agent: ctx.agentId,
+                severity: ctx.severity,
+                run: (check) => capped(check.fields
+                    .filter((entry) => fieldMatches(entry, field) && blockMatches(entry, blockType))
+                    .filter((entry) => entry.kind !== "boolean" && fieldText(entry.value).trim() === "")
+                    .map((entry) => ({
+                    key: `${entry.blockId}:${entry.path}`,
+                    title: `${entry.label ?? field} is empty`,
+                    evidence: where(entry)
+                })))
+            }
+        ];
+    }
+};
+const textMatches = {
+    id: "text-matches",
+    description: "Text that matches a pattern: a word to avoid, last year's date, an old price.",
+    example: { pattern: "\\b2025\\b", fields: ["heading", "description"] },
+    runnable: true,
+    params: z
+        .object({
+        pattern: z.string().min(1).max(200),
+        caseSensitive: z.boolean().optional(),
+        blockType: z.string().min(1).max(80).optional(),
+        fields: z.array(z.string().min(1).max(80)).max(20).optional(),
+        /** The finding's title; `{{match}}` is replaced by what matched. */
+        title: z.string().min(1).max(120).optional()
+    })
+        .strict(),
+    build(params, ctx) {
+        const p = params;
+        let pattern;
+        try {
+            pattern = new RegExp(p.pattern, p.caseSensitive ? "" : "i");
+        }
+        catch (error) {
+            throw new Error(`text-matches: invalid pattern — ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return [
+            {
+                id: ruleId(ctx, "text-matches"),
+                agent: ctx.agentId,
+                severity: ctx.severity,
+                run: (check) => {
+                    const out = [];
+                    for (const entry of check.fields) {
+                        if (!blockMatches(entry, p.blockType))
+                            continue;
+                        if (p.fields && !p.fields.some((field) => fieldMatches(entry, field)))
+                            continue;
+                        const text = fieldText(entry.value).slice(0, MAX_TEXT);
+                        const match = text ? pattern.exec(text) : null;
+                        if (!match)
+                            continue;
+                        out.push({
+                            key: `${entry.blockId}:${entry.path}`,
+                            title: (p.title ?? "“{{match}}” in {{field}}").replace("{{match}}", match[0]).replace("{{field}}", entry.label ?? entry.path),
+                            evidence: { ...where(entry), excerpt: text.slice(Math.max(0, match.index - 40), match.index + match[0].length + 40) }
+                        });
+                    }
+                    return capped(out);
+                }
+            }
+        ];
+    }
+};
+const fieldBeforeToday = {
+    id: "field-before-today",
+    description: "A date field whose day has passed: an event that is over, an offer that expired.",
+    example: { blockType: "Card", field: "date" },
+    runnable: true,
+    params: z.object({ field: z.string().min(1).max(80), blockType: z.string().min(1).max(80).optional() }).strict(),
+    build(params, ctx) {
+        const { field, blockType } = params;
+        return [
+            {
+                id: ruleId(ctx, "field-before-today"),
+                agent: ctx.agentId,
+                severity: ctx.severity,
+                run: (check) => {
+                    const today = startOfToday(Date.now());
+                    return capped(check.fields
+                        .filter((entry) => fieldMatches(entry, field) && blockMatches(entry, blockType))
+                        .flatMap((entry) => {
+                        const at = parseFieldDate(entry.value);
+                        if (at === null || at >= today)
+                            return [];
+                        return [
+                            {
+                                key: `${entry.blockId}:${entry.path}`,
+                                title: `${entry.label ?? field} has passed (${String(entry.value).trim()})`,
+                                evidence: where(entry)
+                            }
+                        ];
+                    }));
+                }
+            }
+        ];
+    }
+};
+const notUpdatedFor = {
+    id: "not-updated-for",
+    description: "A page nobody has changed in a while.",
+    example: { days: 180 },
+    runnable: true,
+    params: z.object({ days: z.number().int().min(1).max(3650) }).strict(),
+    build(params, ctx) {
+        const { days } = params;
+        return [
+            {
+                id: ruleId(ctx, "not-updated-for"),
+                agent: ctx.agentId,
+                severity: ctx.severity,
+                run: (check) => {
+                    const updated = Date.parse(check.page.updatedAt);
+                    if (Number.isNaN(updated))
+                        return [];
+                    const age = Math.floor((Date.now() - updated) / 86_400_000);
+                    if (age < days)
+                        return [];
+                    return [{ title: `Not updated for ${age} days`, evidence: { source: "draft" } }];
+                }
+            }
+        ];
+    }
+};
+/** Edit safety's before/after diff. Named so its built-in spec is honest; the check runner skips it. */
+const editDamage = {
+    id: "edit-damage",
+    description: "Damage an edit did that nobody asked for. Runs on each AI or MCP edit, not on a check run.",
+    example: {},
+    runnable: false,
+    params: z.object({}).strict(),
+    build: () => []
+};
+export const RULE_TEMPLATES = [draftRule, fieldEmpty, textMatches, fieldBeforeToday, notUpdatedFor, editDamage];
+export function templateById(id) {
+    return RULE_TEMPLATES.find((template) => template.id === id);
+}
+/**
+ * A spec's detect steps as check rules. Throws, naming the step, on an
+ * unknown template or bad params — a spec that cannot compile is refused
+ * when it is saved, not discovered when it runs at 03:00.
+ */
+export function compileSpec(spec) {
+    const rules = [];
+    spec.detect.forEach((step, stepIndex) => {
+        const template = templateById(step.template);
+        if (!template)
+            throw new Error(`detect[${stepIndex}]: unknown template "${step.template}"`);
+        const parsed = template.params.safeParse(step.params ?? {});
+        if (!parsed.success) {
+            const issue = parsed.error.issues[0];
+            throw new Error(`detect[${stepIndex}] (${step.template}): ${issue?.path.join(".") || "params"} — ${issue?.message ?? "invalid"}`);
+        }
+        if (!template.runnable)
+            return;
+        try {
+            rules.push(...template.build(parsed.data, { agentId: spec.id, stepIndex, severity: spec.severity }));
+        }
+        catch (error) {
+            throw new Error(`detect[${stepIndex}] (${step.template}): ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+    return withScope(rules, spec.scope);
+}
+/** `scope.blockTypes` narrows the fields and links every rule sees. Page scope is the runner's. */
+function withScope(rules, scope) {
+    const types = scope.blockTypes?.length ? new Set(scope.blockTypes) : null;
+    if (!types)
+        return rules;
+    return rules.map((rule) => ({
+        ...rule,
+        run: (ctx) => rule.run({
+            ...ctx,
+            fields: ctx.fields.filter((entry) => types.has(entry.blockType)),
+            links: ctx.links.filter((link) => types.has(link.blockType))
+        })
+    }));
+}

package/dist/agents/tick.d.ts

@@ -0,0 +1,59 @@
+import type { DurableStore, InboxItemRecord } from "../durable/types.ts";
+import type { Logger } from "../logger.ts";
+import { type ScheduleTrigger } from "./schedule.ts";
+/** The digest's slot: Monday 06:00 UTC, covering the seven days before it. */
+export declare const DIGEST_SCHEDULE: ScheduleTrigger;
+export type TickOutcome = {
+    at: number;
+    sites: number;
+    ran: Array<{
+        scopeKey: string;
+        agentId: string;
+        opened: number;
+        closed: number;
+    }>;
+    failed: Array<{
+        scopeKey: string;
+        agentId: string;
+        error: string;
+    }>;
+    digests: string[];
+};
+export type TickArgs = {
+    now?: number;
+    /**
+     * Load a site's pages before its agents read them. Library mode passes the
+     * draft bootstrap here: a cold serverless process has no pages, and an
+     * agent run against none would close every finding it ever raised.
+     */
+    prepare?: (scopeKey: string) => Promise<void>;
+    log?: Logger;
+    store?: DurableStore;
+};
+export declare function tickAgents(args?: TickArgs): Promise<TickOutcome>;
+export type DigestAgentLine = {
+    agentId: string;
+    found: number;
+    fixed: number;
+    open: number;
+};
+export type DigestPayload = {
+    weekStart: number;
+    weekEnd: number;
+    found: number;
+    fixed: number;
+    open: number;
+    caught: number;
+    reverted: number;
+    agents: DigestAgentLine[];
+};
+export declare function digestItemId(scopeKey: string, slot: number): string;
+/** "9 fixed, 2 need you" — the digest's headline is its result (SO-06). */
+export declare function digestHeadline(d: Pick<DigestPayload, "fixed" | "open" | "found" | "caught">): string;
+/**
+ * Post the digest for the week that ended at the latest Monday slot, once.
+ * A week in which no agent found, fixed or caught anything posts nothing
+ * (SO-07: a run that finds nothing never creates a card). A new digest closes
+ * last week's if nobody opened it: two weeks of the same news is noise.
+ */
+export declare function postWeeklyDigest(scopeKey: string, now: number, store: DurableStore): Promise<InboxItemRecord | null>;

package/dist/agents/tick.js

@@ -0,0 +1,164 @@
+import { getDurableStore } from "../durable/durable-store-singleton.js";
+import { agentOfFinding } from "./inbox.js";
+import { runAgentSpec } from "./run-spec.js";
+import { isDue, latestSlot } from "./schedule.js";
+import { resolveSiteAgents } from "./settings.js";
+import { siteOpsAgentsEnabled } from "./enabled.js";
+/*
+ * POST /agents/tick (site-ops-agents.md §8 item 6): run every scheduled agent
+ * whose slot has passed, on every site, and post each site's weekly digest.
+ *
+ * Idempotent by construction. What is due is read from what was recorded —
+ * the check-run ledger for agents, the Inbox for digests — so a tick that
+ * fires twice, or two processes ticking at once, repeat nothing but the
+ * reading. The one window left is two ticks inside the same run; a run
+ * records its start before it scans, so that window is milliseconds.
+ */
+/** The digest's slot: Monday 06:00 UTC, covering the seven days before it. */
+export const DIGEST_SCHEDULE = { kind: "schedule", every: "week", weekday: 1, hour: 6 };
+const WEEK = 7 * 24 * 3_600_000;
+/** How far back the ledger is read to find an agent's last scheduled run. */
+const LEDGER_WINDOW = 500;
+export async function tickAgents(args = {}) {
+    const now = args.now ?? Date.now();
+    const store = args.store ?? getDurableStore();
+    const outcome = { at: now, sites: 0, ran: [], failed: [], digests: [] };
+    if (!siteOpsAgentsEnabled())
+        return outcome;
+    for (const scopeKey of await store.listAgentScopes()) {
+        outcome.sites += 1;
+        try {
+            await tickSite(scopeKey, now, store, args, outcome);
+        }
+        catch (error) {
+            // One site failing must not starve the rest of the tick.
+            args.log?.error({ err: String(error), scopeKey }, "[agents] tick failed for a site");
+        }
+    }
+    return outcome;
+}
+async function tickSite(scopeKey, now, store, args, outcome) {
+    const site = await resolveSiteAgents(scopeKey, store);
+    const rows = new Map((await store.listAgentSettings(scopeKey)).map((row) => [row.agentId, row]));
+    const scheduled = site.agents.filter((agent) => agent.enabled && agent.spec.trigger.kind === "schedule");
+    let ledger = null;
+    const due = [];
+    for (const agent of scheduled) {
+        ledger ??= await store.listCheckRuns(scopeKey, LEDGER_WINDOW);
+        const last = ledger.find((run) => run.agent === agent.agentId && run.trigger === "scheduled")?.startedAt ?? 0;
+        // A change to the agent counts as a fresh start: switched on at 09:00, it
+        // waits for tomorrow's 06:00 rather than catching up on today's.
+        const since = Math.max(last, rows.get(agent.agentId)?.updatedAt ?? 0);
+        if (isDue(agent.spec.trigger, since, now))
+            due.push(agent);
+    }
+    if (due.length > 0)
+        await args.prepare?.(scopeKey);
+    for (const agent of due) {
+        try {
+            const run = await runAgentSpec({ scopeKey, spec: agent.spec, trigger: "scheduled", store, now: () => now });
+            outcome.ran.push({ scopeKey, agentId: agent.agentId, opened: run.findingsOpened, closed: run.findingsClosed });
+            args.log?.info({ scopeKey, agentId: agent.agentId, opened: run.findingsOpened }, "[agents] scheduled run complete");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            outcome.failed.push({ scopeKey, agentId: agent.agentId, error: message });
+            args.log?.error({ err: message, scopeKey, agentId: agent.agentId }, "[agents] scheduled run failed");
+        }
+    }
+    if (site.agents.some((agent) => agent.enabled)) {
+        const digest = await postWeeklyDigest(scopeKey, now, store);
+        if (digest)
+            outcome.digests.push(digest.id);
+    }
+}
+export function digestItemId(scopeKey, slot) {
+    return `digest:${scopeKey}:${new Date(slot).toISOString().slice(0, 10)}`;
+}
+/** "9 fixed, 2 need you" — the digest's headline is its result (SO-06). */
+export function digestHeadline(d) {
+    const parts = [];
+    if (d.fixed > 0)
+        parts.push(`${d.fixed} fixed`);
+    if (d.open > 0)
+        parts.push(`${d.open} need${d.open === 1 ? "s" : ""} you`);
+    if (parts.length === 0 && d.found > 0)
+        parts.push(`${d.found} found`);
+    if (d.caught > 0)
+        parts.push(`${d.caught} edit${d.caught === 1 ? "" : "s"} caught`);
+    return parts.join(", ");
+}
+/**
+ * Post the digest for the week that ended at the latest Monday slot, once.
+ * A week in which no agent found, fixed or caught anything posts nothing
+ * (SO-07: a run that finds nothing never creates a card). A new digest closes
+ * last week's if nobody opened it: two weeks of the same news is noise.
+ */
+export async function postWeeklyDigest(scopeKey, now, store) {
+    const weekEnd = latestSlot(DIGEST_SCHEDULE, now);
+    const weekStart = weekEnd - WEEK;
+    const id = digestItemId(scopeKey, weekEnd);
+    if (await store.getInboxItem(id))
+        return null;
+    const site = await resolveSiteAgents(scopeKey, store);
+    const enabled = new Set(site.agents.filter((agent) => agent.enabled).map((agent) => agent.agentId));
+    const inWeek = (at) => at != null && at >= weekStart && at < weekEnd;
+    const lines = new Map();
+    const line = (agentId) => {
+        let entry = lines.get(agentId);
+        if (!entry)
+            lines.set(agentId, (entry = { agentId, found: 0, fixed: 0, open: 0 }));
+        return entry;
+    };
+    for (const finding of await store.listFindings({ scopeKey })) {
+        const agentId = agentOfFinding(finding);
+        if (!enabled.has(agentId))
+            continue;
+        if (inWeek(finding.firstSeenAt))
+            line(agentId).found += 1;
+        if (finding.status === "fixed" && inWeek(finding.resolvedAt))
+            line(agentId).fixed += 1;
+        if (finding.status === "open")
+            line(agentId).open += 1;
+    }
+    let caught = 0;
+    let reverted = 0;
+    if (enabled.has("edit-safety")) {
+        for (const alert of await store.listInboxItems({ scopeKey, kind: "alert", agent: "edit-safety" })) {
+            if (!inWeek(alert.createdAt))
+                continue;
+            caught += 1;
+            if (alert.resolution === "reverted")
+                reverted += 1;
+        }
+    }
+    const agents = [...lines.values()].filter((l) => l.found + l.fixed + l.open > 0);
+    const sum = (key) => agents.reduce((total, l) => total + l[key], 0);
+    const payload = {
+        weekStart,
+        weekEnd,
+        found: sum("found"),
+        fixed: sum("fixed"),
+        open: sum("open"),
+        caught,
+        reverted,
+        agents
+    };
+    if (payload.found + payload.fixed + payload.caught === 0)
+        return null;
+    for (const previous of await store.listInboxItems({ scopeKey, kind: "report", agent: "digest", status: "open" })) {
+        await store.resolveInboxItem(previous.id, { resolution: "superseded", at: now });
+    }
+    return store.putInboxItem({
+        id,
+        scopeKey,
+        kind: "report",
+        agent: "digest",
+        object: "This week",
+        verb: `${payload.found} found, ${payload.fixed} fixed`,
+        title: digestHeadline(payload),
+        slugs: [],
+        payload: payload,
+        createdAt: now
+    });
+}

package/dist/chat/anthropic-model-caps.d.ts

@@ -0,0 +1,19 @@
+/** Whether `tool_choice: {type: "tool", name}` is accepted by this model. */
+export declare function supportsForcedToolChoice(model: string): boolean;
+/**
+ * Request fields for a call that wants as little thinking as the model allows.
+ *
+ * - Sonnet 5.5: `between_tools` is its "off" (valid at effort high or below,
+ *   which is the default, and accepts no other field inside `thinking`).
+ * - Opus 5.5 / Fable 5.1: thinking cannot be turned off; `low` effort keeps it
+ *   short. Opus 5.5 would otherwise run at its `medium` default.
+ * - Everything older: send nothing, as before.
+ */
+export declare function minimalThinkingParams(model: string): {
+    thinking?: {
+        type: "between_tools";
+    };
+    output_config?: {
+        effort: "low";
+    };
+};

package/dist/chat/anthropic-model-caps.js

@@ -0,0 +1,56 @@
+// What a given Claude model accepts, for the two request shapes the planner
+// used to send to every model alike.
+//
+// Sonnet 5.5, Opus 5.5 and Fable 5.1 changed both. Forced `tool_choice`
+// (`{type: "tool"}` / `{type: "any"}`) is a 400 on them, and so is
+// `thinking: {type: "disabled"}`; each turns thinking off, or down, its own way.
+// Older models — Haiku 4.5 on the fast tier, and anything a deployment pins
+// through ANTHROPIC_MODEL_* — keep the old behaviour, so this is decided per
+// model rather than by flipping the planner over wholesale.
+/**
+ * Version of a Claude model id, e.g. `claude-sonnet-5-5` → sonnet 5.5,
+ * `claude-haiku-4-5-20251001` → haiku 4.5, `claude-opus-5` → opus 5.0. A
+ * trailing 8-digit date is a snapshot suffix, not a minor version. Returns null
+ * for anything that is not a `claude-<family>-<major>` id.
+ */
+function parseClaudeModel(model) {
+    const match = /^(?:anthropic\.)?claude-([a-z]+)-(\d+)(?:-(\d{1,2}))?(?:-\d{8})?(?:@.*)?$/.exec(model.trim().toLowerCase());
+    if (!match)
+        return null;
+    return { family: match[1], version: Number(match[2]) + Number(match[3] ?? 0) / 10 };
+}
+/**
+ * Sonnet/Opus 5.5 and later, Fable/Mythos 5.1 and later. Unrecognised ids are
+ * treated as old: a forced tool_choice that a new model rejects fails loudly on
+ * the first request, while the reverse would silently drop the guarantee.
+ */
+function isPreservedThinkingGeneration(model) {
+    const parsed = parseClaudeModel(model);
+    if (!parsed)
+        return false;
+    if (parsed.family === "sonnet" || parsed.family === "opus")
+        return parsed.version >= 5.5;
+    if (parsed.family === "fable" || parsed.family === "mythos")
+        return parsed.version >= 5.1;
+    return false;
+}
+/** Whether `tool_choice: {type: "tool", name}` is accepted by this model. */
+export function supportsForcedToolChoice(model) {
+    return !isPreservedThinkingGeneration(model);
+}
+/**
+ * Request fields for a call that wants as little thinking as the model allows.
+ *
+ * - Sonnet 5.5: `between_tools` is its "off" (valid at effort high or below,
+ *   which is the default, and accepts no other field inside `thinking`).
+ * - Opus 5.5 / Fable 5.1: thinking cannot be turned off; `low` effort keeps it
+ *   short. Opus 5.5 would otherwise run at its `medium` default.
+ * - Everything older: send nothing, as before.
+ */
+export function minimalThinkingParams(model) {
+    if (!isPreservedThinkingGeneration(model))
+        return {};
+    if (parseClaudeModel(model)?.family === "sonnet")
+        return { thinking: { type: "between_tools" } };
+    return { output_config: { effort: "low" } };
+}

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

@@ -8,6 +8,7 @@ import { type ToolRuntime } from "../tools/runtime.ts";
 import type { ToolExecutionEvent } from "../tools/types.ts";
 import { type DeferredNativeImageCall } from "./chat-pipeline-shared.ts";
 export type { DeferredNativeImageCall };
+export declare function getAnthropicClient(): Anthropic;
 /** Reset the singleton (useful for tests that swap API keys). */
 export declare function resetAnthropicClient(): void;
 export declare function parseIntentWithAnthropic(args: {