@avocadostudio-ai/orchestrator-core 0.1.0

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

@@ -0,0 +1,20 @@
+import Anthropic from "@anthropic-ai/sdk";
+export declare function anthropicPromptCacheControl(): Anthropic.CacheControlEphemeral | undefined;
+export declare function anthropicSystemPromptWithCache(system: string): string | Anthropic.TextBlockParam[];
+/**
+ * Wraps a {stable, dynamic} prompt split into Anthropic system content blocks
+ * with `cache_control` on the stable prefix only. The dynamic suffix (per-
+ * request flags like selected block, locale, conditional modes) is sent as a
+ * separate text block without `cache_control`, so changing it does not bust
+ * the cache on the stable prefix.
+ *
+ * When caching is disabled, returns a single joined string for backward compat.
+ */
+export declare function anthropicSegmentedSystemPromptWithCache(segments: {
+    stable: string;
+    dynamic: string;
+}): string | Anthropic.TextBlockParam[];
+export declare function anthropicToolWithCache(tool: Anthropic.Messages.Tool): Anthropic.Messages.Tool;
+export declare const ANTHROPIC_FINE_GRAINED_STREAM_HEADERS: {
+    "anthropic-beta": string;
+};

package/dist/chat/anthropic-cache.js

@@ -0,0 +1,54 @@
+const ENABLED_RE = /^(1|true|yes|on)$/i;
+function promptCacheEnabled() {
+    return ENABLED_RE.test((process.env.ANTHROPIC_PROMPT_CACHE ?? "").trim());
+}
+function promptCacheTtl() {
+    const raw = (process.env.ANTHROPIC_PROMPT_CACHE_TTL ?? "").trim();
+    if (raw === "5m" || raw === "1h")
+        return raw;
+    return undefined;
+}
+export function anthropicPromptCacheControl() {
+    if (!promptCacheEnabled())
+        return undefined;
+    const ttl = promptCacheTtl();
+    return ttl ? { type: "ephemeral", ttl } : { type: "ephemeral" };
+}
+export function anthropicSystemPromptWithCache(system) {
+    const cacheControl = anthropicPromptCacheControl();
+    if (!cacheControl)
+        return system;
+    return [{ type: "text", text: system, cache_control: cacheControl }];
+}
+/**
+ * Wraps a {stable, dynamic} prompt split into Anthropic system content blocks
+ * with `cache_control` on the stable prefix only. The dynamic suffix (per-
+ * request flags like selected block, locale, conditional modes) is sent as a
+ * separate text block without `cache_control`, so changing it does not bust
+ * the cache on the stable prefix.
+ *
+ * When caching is disabled, returns a single joined string for backward compat.
+ */
+export function anthropicSegmentedSystemPromptWithCache(segments) {
+    const dynamic = segments.dynamic.trim();
+    const cacheControl = anthropicPromptCacheControl();
+    if (!cacheControl) {
+        return dynamic ? `${segments.stable}\n\n${dynamic}` : segments.stable;
+    }
+    const blocks = [
+        { type: "text", text: segments.stable, cache_control: cacheControl }
+    ];
+    if (dynamic) {
+        blocks.push({ type: "text", text: dynamic });
+    }
+    return blocks;
+}
+export function anthropicToolWithCache(tool) {
+    const cacheControl = anthropicPromptCacheControl();
+    if (!cacheControl)
+        return tool;
+    return { ...tool, cache_control: cacheControl };
+}
+export const ANTHROPIC_FINE_GRAINED_STREAM_HEADERS = {
+    "anthropic-beta": "fine-grained-tool-streaming-2025-05-14"
+};

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

@@ -0,0 +1,98 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { type BlockManifest, type EditPlan, type Operation, type PageDoc } from "@avocadostudio-ai/shared";
+import { type ParsedIntent, plannerContextPack } from "../nlp/deterministic-planner.ts";
+import type { ThinkingEvent, PlannerEffort } from "./planner-types.ts";
+import { type PlannerSchemaContextMeta } from "./planner.ts";
+import { type TokenUsage } from "../telemetry/usage.ts";
+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 };
+/** Reset the singleton (useful for tests that swap API keys). */
+export declare function resetAnthropicClient(): void;
+export declare function parseIntentWithAnthropic(args: {
+    message: string;
+    slug: string;
+    currentPage: PageDoc;
+    activeBlockId?: string;
+    activeBlockType?: string;
+    activeEditablePath?: string;
+    model: string;
+    log?: {
+        warn: (obj: Record<string, unknown>, msg: string) => void;
+    };
+}): Promise<ParsedIntent>;
+export type PlannerAnthropicClient = {
+    messages: {
+        create: (args: unknown, options?: {
+            signal?: AbortSignal;
+        }) => Promise<Anthropic.Messages.Message>;
+        stream?: (args: unknown, options?: {
+            headers?: Record<string, string>;
+            signal?: AbortSignal;
+        }) => AsyncIterable<unknown> & {
+            finalMessage: () => Promise<unknown>;
+        };
+    };
+};
+export declare function generatePlanWithAnthropic(args: {
+    message: string;
+    slug: string;
+    currentPage: PageDoc;
+    contextPack: ReturnType<typeof 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;
+        pageSlug?: 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;
+    };
+    client?: PlannerAnthropicClient;
+    siteContextBlock?: string | null;
+    log?: {
+        warn: (obj: Record<string, unknown>, msg: string) => void;
+    };
+    forceFullSchemaContracts?: boolean;
+    componentsManifest?: BlockManifest;
+    lightweight?: boolean;
+    signal?: AbortSignal;
+    locale?: string;
+    imageSourceChoiceOpen?: boolean;
+    /**
+     * When set, enables Anthropic adaptive thinking at the given effort level.
+     * Adaptive thinking + `output_config.effort` is the current API — the legacy
+     * `budget_tokens` shape is rejected (400) on Opus 4.8 / Sonnet 5.
+     */
+    thinking?: {
+        effort: PlannerEffort;
+    };
+}): Promise<{
+    plan: EditPlan;
+    usage: TokenUsage;
+    schemaContext: PlannerSchemaContextMeta;
+    deferredNativeImageCalls?: DeferredNativeImageCall[];
+}>;