@orthacms/copilot-provider-anthropic 0.0.0-reserve.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ortha CMS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @orthacms/copilot-provider-anthropic
+
+Part of [Ortha CMS](https://github.com/ortha-source/ortha-cms).
+
+```sh
+npm install @orthacms/copilot-provider-anthropic
+```

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createAnthropicProvider } from './lib/anthropic-provider';
+export type { AnthropicProviderConfig, AnthropicEffort } from './lib/config';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACnE,YAAY,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAnthropicProvider = void 0;
+var anthropic_provider_1 = require("./lib/anthropic-provider");
+Object.defineProperty(exports, "createAnthropicProvider", { enumerable: true, get: function () { return anthropic_provider_1.createAnthropicProvider; } });

package/dist/lib/anthropic-provider.d.ts

@@ -0,0 +1,23 @@
+import { type ModelProvider } from '@orthacms/copilot-domain';
+import type { AnthropicProviderConfig } from './config';
+/**
+ * Creates the native Claude adapter — the default for tool-heavy work, and the
+ * path on which native capabilities stay available
+ * ([ADR-0004](../../../../docs/adr/0004-model-agnostic-copilot-provider.md) §3).
+ *
+ * This file holds only the orchestration; the parts worth reading on their own
+ * live beside it — `client.ts` (lazy construction), `capabilities.ts` (the
+ * Models API probe), and `wire/` (the two mapping directions).
+ *
+ * @example
+ * ```typescript
+ * CopilotPlugin({
+ *     providers: {
+ *         anthropic: createAnthropicProvider(config.plugins.copilot.anthropic)
+ *     },
+ *     config: config.plugins.copilot
+ * });
+ * ```
+ */
+export declare function createAnthropicProvider(config: AnthropicProviderConfig): ModelProvider;
+//# sourceMappingURL=anthropic-provider.d.ts.map

package/dist/lib/anthropic-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-provider.d.ts","sourceRoot":"","sources":["../../src/lib/anthropic-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,KAAK,aAAa,EAGrB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAIxD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CACnC,MAAM,EAAE,uBAAuB,GAChC,aAAa,CAsFf"}

package/dist/lib/anthropic-provider.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAnthropicProvider = createAnthropicProvider;
+const copilot_domain_1 = require("@orthacms/copilot-domain");
+const capabilities_1 = require("./capabilities");
+const client_1 = require("./client");
+const request_1 = require("./wire/request");
+const response_1 = require("./wire/response");
+/**
+ * Creates the native Claude adapter — the default for tool-heavy work, and the
+ * path on which native capabilities stay available
+ * ([ADR-0004](../../../../docs/adr/0004-model-agnostic-copilot-provider.md) §3).
+ *
+ * This file holds only the orchestration; the parts worth reading on their own
+ * live beside it — `client.ts` (lazy construction), `capabilities.ts` (the
+ * Models API probe), and `wire/` (the two mapping directions).
+ *
+ * @example
+ * ```typescript
+ * CopilotPlugin({
+ *     providers: {
+ *         anthropic: createAnthropicProvider(config.plugins.copilot.anthropic)
+ *     },
+ *     config: config.plugins.copilot
+ * });
+ * ```
+ */
+function createAnthropicProvider(config) {
+    const client = (0, client_1.createLazyClient)(config);
+    const models = [...config.models];
+    // Cached per model: the probe is one network call per model, and a
+    // provider offering three shouldn't pay it three times per run.
+    const cachedCapabilities = new Map();
+    async function* stream(request, signal) {
+        // Resolved before the try: a run naming a model this provider doesn't
+        // offer is the caller's error, not an abort to be swallowed.
+        const model = (0, copilot_domain_1.resolveModel)(request.model, models);
+        // Opening the stream lives inside the try alongside iterating it: an
+        // already-aborted signal makes the SDK reject at construction, and
+        // that is still an abort rather than a failure the caller should see.
+        try {
+            const messageStream = client().messages.stream((0, request_1.toStreamParams)(request, config, model), signal ? { signal } : undefined);
+            for await (const event of messageStream) {
+                if (event.type === 'content_block_delta' &&
+                    event.delta.type === 'text_delta') {
+                    yield { type: 'text-delta', text: event.delta.text };
+                }
+            }
+            // Tool calls come from the assembled message rather than from
+            // `input_json_delta` fragments, so a call is emitted once, whole,
+            // and already parsed — the engine never sees half a call.
+            const message = await messageStream.finalMessage();
+            for (const block of message.content) {
+                if (block.type === 'tool_use') {
+                    yield {
+                        type: 'tool-call',
+                        id: block.id,
+                        name: block.name,
+                        input: block.input
+                    };
+                }
+            }
+            yield {
+                type: 'done',
+                stopReason: (0, response_1.toStopReason)(message.stop_reason),
+                usage: (0, response_1.toUsage)(message.usage)
+            };
+        }
+        catch (error) {
+            if ((0, copilot_domain_1.isAbortError)(error, signal)) {
+                yield (0, copilot_domain_1.abortedEvent)();
+                return;
+            }
+            throw error;
+        }
+    }
+    return {
+        models: () => models,
+        capabilities(model) {
+            const resolved = (0, copilot_domain_1.resolveModel)(model, models);
+            const cached = cachedCapabilities.get(resolved);
+            if (cached) {
+                return cached;
+            }
+            // The *promise* is cached, before it resolves, so two concurrent
+            // callers await one probe rather than two.
+            const probe = (0, capabilities_1.probeCapabilities)(client, resolved).catch(() => {
+                // A failed probe is **not** kept: caching it would pin a
+                // frontier model to the conservative fallback for the life of
+                // the process over one blip — the network comes back and the
+                // adapter never notices. Evicting costs at most one probe per
+                // call while the endpoint is unreachable.
+                cachedCapabilities.delete(resolved);
+                return (0, capabilities_1.fallbackCapabilities)(resolved);
+            });
+            cachedCapabilities.set(resolved, probe);
+            return probe;
+        },
+        stream
+    };
+}

package/dist/lib/capabilities.d.ts

@@ -0,0 +1,26 @@
+import type { ModelCapabilities } from '@orthacms/copilot-domain';
+import type { LazyClient } from './client';
+/**
+ * Probes the Models API for one model's live capability record.
+ *
+ * **Rejects** when the call can't be made, rather than returning the fallback
+ * itself: the caller caches this promise, and a fallback that resolved
+ * successfully would be cached as if it were an answer — pinning a frontier
+ * model to the conservative record for the life of the process over one
+ * network blip.
+ *
+ * The Models API exposes no tool-calling flag; every model it serves supports
+ * tool calling, so that stays `true` on both paths.
+ */
+export declare function probeCapabilities(client: LazyClient, model: string): Promise<ModelCapabilities>;
+/**
+ * What one model reports when the probe couldn't run — no network, no key, a
+ * gateway that doesn't proxy `/v1/models`.
+ *
+ * Conservative rather than "unsupported": reporting *unknown* as *unsupported*
+ * would drop a frontier model into degraded mode over a transient blip, which
+ * is a worse failure than being slightly optimistic about a model whose shape
+ * we know.
+ */
+export declare function fallbackCapabilities(model: string): ModelCapabilities;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/lib/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/lib/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CACnC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,CAAC,CAW5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAErE"}

package/dist/lib/capabilities.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeCapabilities = probeCapabilities;
+exports.fallbackCapabilities = fallbackCapabilities;
+const config_1 = require("./config");
+/**
+ * Probes the Models API for one model's live capability record.
+ *
+ * **Rejects** when the call can't be made, rather than returning the fallback
+ * itself: the caller caches this promise, and a fallback that resolved
+ * successfully would be cached as if it were an answer — pinning a frontier
+ * model to the conservative record for the life of the process over one
+ * network blip.
+ *
+ * The Models API exposes no tool-calling flag; every model it serves supports
+ * tool calling, so that stays `true` on both paths.
+ */
+async function probeCapabilities(client, model) {
+    const base = fallbackCapabilities(model);
+    const info = await client().models.retrieve(model);
+    return {
+        model: info.id,
+        toolCalling: true,
+        streaming: true,
+        vision: info.capabilities?.image_input.supported ?? base.vision,
+        contextWindow: info.max_input_tokens ?? base.contextWindow,
+        maxOutputTokens: info.max_tokens ?? base.maxOutputTokens
+    };
+}
+/**
+ * What one model reports when the probe couldn't run — no network, no key, a
+ * gateway that doesn't proxy `/v1/models`.
+ *
+ * Conservative rather than "unsupported": reporting *unknown* as *unsupported*
+ * would drop a frontier model into degraded mode over a transient blip, which
+ * is a worse failure than being slightly optimistic about a model whose shape
+ * we know.
+ */
+function fallbackCapabilities(model) {
+    return { ...config_1.FALLBACK_CAPABILITIES, model };
+}

package/dist/lib/client.d.ts

@@ -0,0 +1,15 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { AnthropicProviderConfig } from './config';
+/** Resolves the SDK client, constructing it on first call. */
+export type LazyClient = () => Anthropic;
+/**
+ * Builds a memoized client factory. The SDK client is constructed on **first
+ * use**, not up front: a host registers every provider it might route to, but
+ * an operator running local inference has no Anthropic key — and an unused
+ * adapter must not fail their boot.
+ *
+ * Selecting the provider without a key then fails at the moment it actually
+ * matters, with a message naming the fix.
+ */
+export declare function createLazyClient(config: AnthropicProviderConfig): LazyClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/lib/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/lib/client.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD,8DAA8D;AAC9D,MAAM,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC;AAEzC;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,GAAG,UAAU,CAwB5E"}

package/dist/lib/client.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLazyClient = createLazyClient;
+const tslib_1 = require("tslib");
+const sdk_1 = tslib_1.__importDefault(require("@anthropic-ai/sdk"));
+/**
+ * Builds a memoized client factory. The SDK client is constructed on **first
+ * use**, not up front: a host registers every provider it might route to, but
+ * an operator running local inference has no Anthropic key — and an unused
+ * adapter must not fail their boot.
+ *
+ * Selecting the provider without a key then fails at the moment it actually
+ * matters, with a message naming the fix.
+ */
+function createLazyClient(config) {
+    let client;
+    return () => {
+        if (!client) {
+            if (!config.apiKey) {
+                throw new Error('The Anthropic copilot provider was selected but no API key is configured. ' +
+                    'Set ANTHROPIC_API_KEY, or pick another provider in the model picker.');
+            }
+            client = new sdk_1.default({
+                apiKey: config.apiKey,
+                ...(config.baseUrl ? { baseURL: config.baseUrl } : {}),
+                ...(config.maxRetries === undefined
+                    ? {}
+                    : { maxRetries: config.maxRetries }),
+                ...(config.timeoutMs === undefined
+                    ? {}
+                    : { timeout: config.timeoutMs })
+            });
+        }
+        return client;
+    };
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,51 @@
+/**
+ * How much of the model's reasoning budget a run may spend. Higher settings
+ * trade tokens and latency for depth; `high` is the API default.
+ */
+export type AnthropicEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/** Options for `createAnthropicProvider`. */
+export interface AnthropicProviderConfig {
+    /** API key. Never leaves the server, and never reaches the browser. */
+    apiKey: string;
+    /**
+     * Model ids this provider offers, in preference order; the first is the
+     * default. Declaring several — a frontier model for hard work, a cheaper
+     * one for routine turns — lets a user switch mid-conversation without a
+     * redeploy.
+     */
+    models: readonly string[];
+    /** Overrides the API host — a gateway, a proxy, or a regional endpoint. */
+    baseUrl?: string;
+    /** Reasoning-budget setting. Omitted, the API's own default (`high`) applies. */
+    effort?: AnthropicEffort;
+    /** Retries on 429/5xx/connection errors. Defaults to the SDK's 2. */
+    maxRetries?: number;
+    /** Per-request timeout in milliseconds. Defaults to the SDK's 10 minutes. */
+    timeoutMs?: number;
+    /**
+     * Whether to send `cache_control` breakpoints. **Defaults to on**, and
+     * should stay on: a run is a loop over a stateless API, so every step
+     * resends the whole conversation and an uncached run's billed input grows
+     * roughly with the square of its step count. Cache reads are ~0.1x base
+     * input price, and the write premium (1.25x) is repaid by the second step.
+     *
+     * The escape hatch exists for a {@link baseUrl} gateway or proxy that
+     * rejects the field rather than passing it through — the symptom is a 400
+     * on every run, not a quiet loss of caching.
+     */
+    promptCaching?: boolean;
+}
+/**
+ * Fallback capabilities, used when the Models API can't be reached (no
+ * network, no key, a gateway that doesn't proxy `/v1/models`). Conservative on
+ * the two numbers and honest on the three flags: every current Claude model
+ * streams, calls tools natively, and accepts images.
+ */
+export declare const FALLBACK_CAPABILITIES: {
+    readonly toolCalling: true;
+    readonly streaming: true;
+    readonly vision: true;
+    readonly contextWindow: 200000;
+    readonly maxOutputTokens: 8192;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/lib/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,6CAA6C;AAC7C,MAAM,WAAW,uBAAuB;IACpC,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;CAMxB,CAAC"}

package/dist/lib/config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FALLBACK_CAPABILITIES = void 0;
+/**
+ * Fallback capabilities, used when the Models API can't be reached (no
+ * network, no key, a gateway that doesn't proxy `/v1/models`). Conservative on
+ * the two numbers and honest on the three flags: every current Claude model
+ * streams, calls tools natively, and accepts images.
+ */
+exports.FALLBACK_CAPABILITIES = {
+    toolCalling: true,
+    streaming: true,
+    vision: true,
+    contextWindow: 200_000,
+    maxOutputTokens: 8_192
+};

package/dist/lib/wire/request.d.ts

@@ -0,0 +1,42 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { MessageParam, Tool } from '@anthropic-ai/sdk/resources/messages';
+import type { ModelMessage, ModelRequest, ModelTool } from '@orthacms/copilot-domain';
+import type { AnthropicProviderConfig } from '../config';
+/**
+ * The body `messages.stream` accepts, derived from the method rather than
+ * imported by name — the SDK moves these aliases between barrels across
+ * releases, and the method signature is the thing we actually have to satisfy.
+ */
+type StreamParams = Parameters<Anthropic['messages']['stream']>[0];
+/** Maps the port's tool descriptors onto Anthropic's tool definitions. */
+export declare function toAnthropicTools(tools: readonly ModelTool[]): Tool[];
+/** Maps the port's block-structured turns onto Anthropic's message params. */
+export declare function toAnthropicMessages(messages: readonly ModelMessage[]): MessageParam[];
+/**
+ * Builds the streaming request body for an already-resolved `model`.
+ *
+ * **No `thinking` configuration is sent**, deliberately. On current models
+ * thinking is on by default, and turning it off makes them occasionally write
+ * a tool call into the *visible text* instead of emitting a tool-use block —
+ * the call then silently never runs, which for a tool-driven copilot is the
+ * worst available failure mode. The lever for cheaper runs is `config.effort`.
+ *
+ * No sampling parameters either: current models reject `temperature`, `top_p`
+ * and `top_k` outright, which is why the port never carried them.
+ *
+ * **Prompt caching is on unless the host turns it off.** A run is a loop, and
+ * the API is stateless, so step _n_ resends everything steps 1…_n_−1 already
+ * sent — the prompt grows every step while the *new* content is one tool
+ * result. Uncached, a run's billed input is roughly quadratic in its step
+ * count, which is what made the step ceiling behave like a cost ceiling. Cache
+ * reads are ~0.1x base input, so the resent prefix stops dominating and
+ * `maxTotalTokens` goes back to measuring new work.
+ *
+ * Placement follows the API's render order — `tools` → `system` → `messages` —
+ * so a single breakpoint at the end of `system` covers the tools with it. That
+ * one is the whole static prefix of every step in the run; the rest roll
+ * through the conversation ({@link withCacheBreakpoints}).
+ */
+export declare function toStreamParams(request: ModelRequest, config: AnthropicProviderConfig, model: string): StreamParams;
+export {};
+//# sourceMappingURL=request.d.ts.map

package/dist/lib/wire/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../src/lib/wire/request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAER,YAAY,EACZ,IAAI,EACP,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EACR,YAAY,EACZ,YAAY,EACZ,SAAS,EACZ,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEzD;;;;GAIG;AACH,KAAK,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAwBnE,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI,EAAE,CAMpE;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAC/B,QAAQ,EAAE,SAAS,YAAY,EAAE,GAClC,YAAY,EAAE,CAwBhB;AA0DD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAC1B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,MAAM,GACd,YAAY,CA4Cd"}

package/dist/lib/wire/request.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnthropicTools = toAnthropicTools;
+exports.toAnthropicMessages = toAnthropicMessages;
+exports.toStreamParams = toStreamParams;
+/** A five-minute cache entry — the API's default TTL. See {@link markCache}. */
+const EPHEMERAL = { type: 'ephemeral' };
+/**
+ * The API's ceiling on `cache_control` breakpoints in one request. Exceeding it
+ * is a 400, so the budget is spent deliberately: one on the static prefix
+ * (tools + system), the rest rolling through the conversation.
+ */
+const MAX_CACHE_BREAKPOINTS = 4;
+/**
+ * How far back a breakpoint may sit from the previous one and still find it.
+ *
+ * A breakpoint walks back **at most 20 content blocks** looking for an existing
+ * entry; past that it misses *silently* — no error, just a full-price prefill
+ * and a `cache_read_input_tokens` of zero. A step that asks for one tool adds
+ * two or three blocks and never comes close, but a turn requesting tools in
+ * parallel adds a `tool_use` and a `tool_result` per call and can clear 20 on
+ * its own. 15 leaves margin for the blocks the next step will append.
+ */
+const CACHE_LOOKBACK_MARGIN = 15;
+/** Maps the port's tool descriptors onto Anthropic's tool definitions. */
+function toAnthropicTools(tools) {
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.inputSchema
+    }));
+}
+/** Maps the port's block-structured turns onto Anthropic's message params. */
+function toAnthropicMessages(messages) {
+    return messages.map((message) => ({
+        role: message.role,
+        content: message.content.map((block) => {
+            switch (block.type) {
+                case 'text':
+                    return { type: 'text', text: block.text };
+                case 'tool_use':
+                    return {
+                        type: 'tool_use',
+                        id: block.id,
+                        name: block.name,
+                        input: block.input
+                    };
+                case 'tool_result':
+                    return {
+                        type: 'tool_result',
+                        tool_use_id: block.toolUseId,
+                        content: block.content,
+                        ...(block.isError ? { is_error: true } : {})
+                    };
+            }
+        })
+    }));
+}
+/** Returns `block` with a cache breakpoint on it. Never mutates the input. */
+function markCache(block) {
+    return { ...block, cache_control: EPHEMERAL };
+}
+/**
+ * Places rolling cache breakpoints through the conversation, newest first.
+ *
+ * The newest turn always gets one, so the *next* step reads everything this
+ * step sent rather than re-prefilling it. Older turns get one only when enough
+ * blocks have accumulated to threaten {@link CACHE_LOOKBACK_MARGIN} — an extra
+ * breakpoint is a cache *write*, so they are placed to keep the chain
+ * reachable, not on every turn.
+ *
+ * Returns a new array; `messages` is left alone.
+ */
+function withCacheBreakpoints(messages, budget) {
+    const marked = new Set();
+    let sinceLast = 0;
+    for (let i = messages.length - 1; i >= 0 && marked.size < budget; i -= 1) {
+        const content = messages[i].content;
+        // Always an array out of `toAnthropicMessages`, but the SDK's own type
+        // allows a bare string, and there is no block on a string to mark.
+        if (!Array.isArray(content) || content.length === 0) {
+            continue;
+        }
+        const isNewest = marked.size === 0;
+        if (isNewest || sinceLast + content.length >= CACHE_LOOKBACK_MARGIN) {
+            marked.add(i);
+            // The blocks of this message that sit *before* the one just marked
+            // still count toward the next breakpoint's walk back.
+            sinceLast = content.length - 1;
+        }
+        else {
+            sinceLast += content.length;
+        }
+    }
+    if (marked.size === 0) {
+        return messages;
+    }
+    return messages.map((message, index) => {
+        if (!marked.has(index) || !Array.isArray(message.content)) {
+            return message;
+        }
+        const content = [...message.content];
+        content[content.length - 1] = markCache(content[content.length - 1]);
+        return { ...message, content };
+    });
+}
+/**
+ * Builds the streaming request body for an already-resolved `model`.
+ *
+ * **No `thinking` configuration is sent**, deliberately. On current models
+ * thinking is on by default, and turning it off makes them occasionally write
+ * a tool call into the *visible text* instead of emitting a tool-use block —
+ * the call then silently never runs, which for a tool-driven copilot is the
+ * worst available failure mode. The lever for cheaper runs is `config.effort`.
+ *
+ * No sampling parameters either: current models reject `temperature`, `top_p`
+ * and `top_k` outright, which is why the port never carried them.
+ *
+ * **Prompt caching is on unless the host turns it off.** A run is a loop, and
+ * the API is stateless, so step _n_ resends everything steps 1…_n_−1 already
+ * sent — the prompt grows every step while the *new* content is one tool
+ * result. Uncached, a run's billed input is roughly quadratic in its step
+ * count, which is what made the step ceiling behave like a cost ceiling. Cache
+ * reads are ~0.1x base input, so the resent prefix stops dominating and
+ * `maxTotalTokens` goes back to measuring new work.
+ *
+ * Placement follows the API's render order — `tools` → `system` → `messages` —
+ * so a single breakpoint at the end of `system` covers the tools with it. That
+ * one is the whole static prefix of every step in the run; the rest roll
+ * through the conversation ({@link withCacheBreakpoints}).
+ */
+function toStreamParams(request, config, model) {
+    const tools = request.tools ?? [];
+    const anthropicTools = toAnthropicTools(tools);
+    const messages = toAnthropicMessages(request.messages);
+    // Off only by explicit opt-out: a `baseUrl` gateway that rejects the field
+    // is the case this exists for, and it is rarer than the loop it pays for.
+    const caching = config.promptCaching !== false;
+    // The breakpoint that matters most, on whichever block ends the static
+    // prefix. With a system prompt that is its last block — tools render ahead
+    // of it and are covered by the same entry. Without one, the last tool is
+    // the end of the prefix, and marking it is the only way to cache the tools
+    // at all. (Below the model's minimum cacheable prefix nothing is written;
+    // that is silent by design and costs nothing.)
+    const cacheSystem = caching && Boolean(request.system);
+    const cacheTools = caching && !cacheSystem && anthropicTools.length > 0;
+    if (cacheTools) {
+        anthropicTools[anthropicTools.length - 1] = markCache(anthropicTools[anthropicTools.length - 1]);
+    }
+    return {
+        model,
+        max_tokens: request.maxOutputTokens,
+        ...(request.system
+            ? {
+                system: cacheSystem
+                    ? [
+                        {
+                            type: 'text',
+                            text: request.system,
+                            cache_control: EPHEMERAL
+                        }
+                    ]
+                    : request.system
+            }
+            : {}),
+        messages: caching
+            ? withCacheBreakpoints(messages, MAX_CACHE_BREAKPOINTS - 1)
+            : messages,
+        ...(anthropicTools.length > 0 ? { tools: anthropicTools } : {}),
+        ...(config.effort ? { output_config: { effort: config.effort } } : {})
+    };
+}

package/dist/lib/wire/response.d.ts

@@ -0,0 +1,14 @@
+import type { StopReason, Usage } from '@anthropic-ai/sdk/resources/messages';
+import type { ModelStopReason, ModelUsage } from '@orthacms/copilot-domain';
+/** Maps Anthropic's stop reasons onto the port's smaller vocabulary. */
+export declare function toStopReason(stopReason: StopReason | null): ModelStopReason;
+/**
+ * Maps Anthropic's usage record onto the port's, dropping absent cache stats.
+ *
+ * The three input counts are **disjoint**: `input_tokens` is the uncached
+ * remainder only, and the whole prompt is `input_tokens` + the two cache
+ * figures. Reading only the first is how an agent that ran for an hour reports
+ * 4k of input.
+ */
+export declare function toUsage(usage: Usage): ModelUsage;
+//# sourceMappingURL=response.d.ts.map

package/dist/lib/wire/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/lib/wire/response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE5E,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,GAAG,eAAe,CAe3E;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAahD"}

package/dist/lib/wire/response.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStopReason = toStopReason;
+exports.toUsage = toUsage;
+/** Maps Anthropic's stop reasons onto the port's smaller vocabulary. */
+function toStopReason(stopReason) {
+    switch (stopReason) {
+        case 'tool_use':
+            return 'tool_use';
+        case 'refusal':
+            return 'refusal';
+        case 'max_tokens':
+        case 'model_context_window_exceeded':
+            // Both mean "ran out of room" — the answer is truncated either way.
+            return 'max_tokens';
+        default:
+            // `end_turn`, `stop_sequence`, `pause_turn` (unreachable without
+            // server-side tools, which this adapter never enables), and null.
+            return 'end';
+    }
+}
+/**
+ * Maps Anthropic's usage record onto the port's, dropping absent cache stats.
+ *
+ * The three input counts are **disjoint**: `input_tokens` is the uncached
+ * remainder only, and the whole prompt is `input_tokens` + the two cache
+ * figures. Reading only the first is how an agent that ran for an hour reports
+ * 4k of input.
+ */
+function toUsage(usage) {
+    const cached = usage.cache_read_input_tokens;
+    const written = usage.cache_creation_input_tokens;
+    return {
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        ...(cached === null || cached === undefined
+            ? {}
+            : { cachedInputTokens: cached }),
+        ...(written === null || written === undefined
+            ? {}
+            : { cacheWriteInputTokens: written })
+    };
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@orthacms/copilot-provider-anthropic",
+    "version": "0.0.0-reserve.0",
+    "description": "@orthacms/copilot-provider-anthropic — part of Ortha CMS.",
+    "license": "MIT",
+    "homepage": "https://github.com/ortha-source/ortha-cms/tree/main/packages/copilot/provider-anthropic",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/ortha-source/ortha-cms.git",
+        "directory": "packages/copilot/provider-anthropic"
+    },
+    "bugs": {
+        "url": "https://github.com/ortha-source/ortha-cms/issues"
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "dist"
+    ],
+    "dependencies": {
+        "@anthropic-ai/sdk": "^0.115.0",
+        "@orthacms/copilot-domain": "^0.0.1",
+        "tslib": "^2.3.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}