@moxxy/plugin-provider-anthropic 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Moxxy (moxxy.ai)
+
+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,54 @@
+# @moxxy/plugin-provider-anthropic
+
+The **Anthropic (Claude)** `LLMProvider` for [moxxy](https://moxxy.ai) — streams
+the Messages API with tool use and adaptive extended thinking, and translates
+moxxy's `ProviderRequest`/event shape ↔ the Anthropic wire format. Register it
+into a [`Session`](https://www.npmjs.com/package/@moxxy/core) to route turns to
+Claude.
+
+## Install
+
+```bash
+npm i @moxxy/core @moxxy/sdk @moxxy/mode-default @moxxy/plugin-provider-anthropic
+```
+
+## Usage
+
+```ts
+import { Session, runTurn, autoAllowResolver } from '@moxxy/core';
+import defaultModePlugin from '@moxxy/mode-default';
+import anthropicPlugin from '@moxxy/plugin-provider-anthropic';
+
+const session = new Session({ cwd: process.cwd(), permissionResolver: autoAllowResolver });
+session.pluginHost.registerStatic(defaultModePlugin);
+session.pluginHost.registerStatic(anthropicPlugin);
+
+session.providers.setActive('anthropic', {
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  // model: 'claude-opus-4-8',   // optional — defaults to the built-in catalog
+});
+
+for await (const e of runTurn(session, 'Write a haiku about TypeScript.')) {
+  if (e.type === 'assistant_chunk') process.stdout.write(e.delta);
+}
+```
+
+## Config
+
+| field | meaning |
+|---|---|
+| `apiKey` | your Anthropic API key (or wire it through the Session's `secretResolver`) |
+| `model` / `models` | pick / override the advertised model catalog |
+
+Mix it with [`@moxxy/plugin-provider-openai`](https://www.npmjs.com/package/@moxxy/plugin-provider-openai):
+register both and `setActive('anthropic' | 'openai', …)` to switch vendors per
+turn.
+
+## Exports
+
+`default` / `anthropicPlugin` (register this), `anthropicProviderDef`,
+`AnthropicProvider`, `anthropicModels`, `validateKey`.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { AnthropicProvider, anthropicModels, type AnthropicProviderConfig } from './provider.js';
+export { AnthropicProvider, anthropicModels };
+export type { AnthropicProviderConfig };
+export { toAnthropicMessages, toAnthropicTools } from './translate.js';
+export { validateKey, type ValidateKeyDeps, type ValidationResult } from './validate.js';
+export declare const anthropicProviderDef: import("@moxxy/sdk").ProviderDef;
+export declare const anthropicPlugin: import("@moxxy/sdk").Plugin;
+export default anthropicPlugin;
+//# 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":"AACA,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,KAAK,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAEjG,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,CAAC;AAC9C,YAAY,EAAE,uBAAuB,EAAE,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAIzF,eAAO,MAAM,oBAAoB,kCAK/B,CAAC;AAEH,eAAO,MAAM,eAAe,6BAI1B,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,19 @@
+import { defineProvider, definePlugin } from '@moxxy/sdk';
+import { AnthropicProvider, anthropicModels } from './provider.js';
+export { AnthropicProvider, anthropicModels };
+export { toAnthropicMessages, toAnthropicTools } from './translate.js';
+export { validateKey } from './validate.js';
+import { validateKey as validateAnthropicKey } from './validate.js';
+export const anthropicProviderDef = defineProvider({
+    name: 'anthropic',
+    models: [...anthropicModels],
+    createClient: (config) => new AnthropicProvider(config),
+    validateKey: (key) => validateAnthropicKey(key),
+});
+export const anthropicPlugin = definePlugin({
+    name: '@moxxy/plugin-provider-anthropic',
+    version: '0.0.0',
+    providers: [anthropicProviderDef],
+});
+export default anthropicPlugin;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAgC,MAAM,eAAe,CAAC;AAEjG,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,CAAC;AAE9C,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,EAAE,WAAW,EAA+C,MAAM,eAAe,CAAC;AAEzF,OAAO,EAAE,WAAW,IAAI,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAEpE,MAAM,CAAC,MAAM,oBAAoB,GAAG,cAAc,CAAC;IACjD,IAAI,EAAE,WAAW;IACjB,MAAM,EAAE,CAAC,GAAG,eAAe,CAAC;IAC5B,YAAY,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,iBAAiB,CAAC,MAAiC,CAAC;IAClF,WAAW,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,oBAAoB,CAAC,GAAG,CAAC;CAChD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,eAAe,GAAG,YAAY,CAAC;IAC1C,IAAI,EAAE,kCAAkC;IACxC,OAAO,EAAE,OAAO;IAChB,SAAS,EAAE,CAAC,oBAAoB,CAAC;CAClC,CAAC,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/dist/provider.d.ts

@@ -0,0 +1,99 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { LLMProvider, ModelDescriptor, ProviderEvent, ProviderRequest } from '@moxxy/sdk';
+export interface AnthropicProviderConfig {
+    readonly apiKey?: string;
+    readonly baseURL?: string;
+    readonly defaultModel?: string;
+    readonly client?: Anthropic;
+    /**
+     * Override the reported provider name (used in error context). Defaults
+     * to `'anthropic'`. The `claude-code` subscription provider reuses this
+     * class with `name: 'claude-code'` so errors/metering attribute correctly.
+     */
+    readonly name?: string;
+    /**
+     * Override the advertised model catalog. Defaults to the Anthropic catalog
+     * ({@link anthropicModels}). An Anthropic-compatible vendor that reuses this
+     * class (e.g. `@moxxy/plugin-provider-zai`'s GLM Coding Plan path, which
+     * points `baseURL` at z.ai's Anthropic Messages endpoint) passes its own
+     * descriptors so context-window lookups (compaction/elision budgets) and
+     * capability gating run against the vendor's models, not Claude's.
+     */
+    readonly models?: ReadonlyArray<ModelDescriptor>;
+    /**
+     * OAuth (Claude subscription) mode. When set, the client authenticates
+     * with `Authorization: Bearer <oauthToken>` instead of an `x-api-key`,
+     * and the request/response is otherwise the standard Messages API. Used
+     * by `@moxxy/plugin-provider-claude-code`; the plain `anthropic` provider
+     * leaves all of these unset and behaves exactly as before.
+     */
+    readonly oauthToken?: string;
+    /** `anthropic-beta` values sent with every OAuth-mode request (joined by `,`). */
+    readonly oauthBeta?: ReadonlyArray<string>;
+    /**
+     * Text injected as the FIRST system block in OAuth mode. Claude rejects
+     * subscription tokens unless the system prompt leads with the Claude Code
+     * identity line, so the provider prepends this ahead of the real system
+     * prompt (which follows as the next block).
+     */
+    readonly systemPreamble?: string;
+    /** Epoch-ms expiry of `oauthToken`, if known — drives proactive refresh. */
+    readonly oauthExpiresAt?: number;
+    /**
+     * Refresh callback. Returns a fresh access token (and its expiry). Invoked
+     * proactively just before a request when the current token is near expiry,
+     * and once more reactively if a request still comes back 401. Omit for
+     * non-refreshable tokens (e.g. a pasted `claude setup-token`).
+     */
+    readonly oauthRefresh?: () => Promise<{
+        readonly token: string;
+        readonly expiresAt?: number;
+    }>;
+}
+export declare const anthropicModels: ReadonlyArray<ModelDescriptor>;
+export declare class AnthropicProvider implements LLMProvider {
+    readonly name: string;
+    readonly models: ReadonlyArray<ModelDescriptor>;
+    private client;
+    private readonly defaultModel;
+    private readonly baseURL?;
+    private readonly oauth?;
+    private oauthToken?;
+    private oauthExpiresAt?;
+    constructor(config?: AnthropicProviderConfig);
+    /**
+     * Build an Anthropic client in OAuth (bearer) mode. `apiKey: null` stops
+     * the SDK from falling back to `ANTHROPIC_API_KEY` and suppresses the
+     * `x-api-key` header (its `apiKeyAuth()` returns `{}` when apiKey is null),
+     * so only `Authorization: Bearer <token>` goes out, plus the beta header.
+     */
+    private makeOauthClient;
+    /** Proactively refresh the bearer token when it's within the skew window. */
+    private ensureFreshOauth;
+    /** Force a token refresh and rebuild the client with the new bearer. */
+    private refreshOauthNow;
+    /**
+     * Build the `system` request field. In OAuth mode the Claude Code identity
+     * preamble MUST lead, so we always emit block form with the preamble first;
+     * the real system prompt follows (carrying the cache breakpoint if set).
+     * In apiKey mode the behaviour is unchanged: a bare string, upgraded to a
+     * single cache-marked block only when a system cache hint is present.
+     *
+     * `extraSystem` is `ProviderRequest.system` — the hook-injection side
+     * channel (e.g. the memory consolidation nudge), delivered IN ADDITION to
+     * the message-derived system prompt. It rides as a separate block AFTER
+     * the cache-marked one so volatile per-request text never busts the
+     * stable system-prefix cache.
+     */
+    private buildSystemParam;
+    stream(req: ProviderRequest): AsyncIterable<ProviderEvent>;
+    /**
+     * One streaming attempt. THROWS on transport/HTTP errors so `stream()` can
+     * decide whether to refresh-and-replay (OAuth 401) or surface the error;
+     * yields content events plus a terminal `message_end` on the happy path.
+     * Abort is terminal here (yields the abort error and returns).
+     */
+    private streamOnce;
+    countTokens(req: Pick<ProviderRequest, 'model' | 'messages' | 'system' | 'tools'>): Promise<number>;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,aAAa,EACb,eAAe,EAGhB,MAAM,YAAY,CAAC;AAOpB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,kFAAkF;IAClF,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChG;AAaD,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,eAAe,CAO1D,CAAC;AAEF,qBAAa,iBAAkB,YAAW,WAAW;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAGhD,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAS;IAElC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAIrB;IACF,OAAO,CAAC,UAAU,CAAC,CAAS;IAC5B,OAAO,CAAC,cAAc,CAAC,CAAS;gBAEpB,MAAM,GAAE,uBAA4B;IAyBhD;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAUvB,6EAA6E;YAC/D,gBAAgB;IAO9B,wEAAwE;YAC1D,eAAe;IAQ7B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,gBAAgB;IAwBjB,MAAM,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa,CAAC,aAAa,CAAC;IAsFjE;;;;;OAKG;YACY,UAAU;IAyJnB,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAkC1G"}

package/dist/provider.js

@@ -0,0 +1,438 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { estimateTextTokens, toFriendlyError } from '@moxxy/sdk';
+import { toAnthropicMessages, toAnthropicTools } from './translate.js';
+// Hardcoded model catalog (re-exported to @moxxy/plugin-provider-claude-code, which
+// reuses this provider class for the subscription path). Deriving it from the Models
+// API is a larger change (auth + caching) — deliberately deferred (TECH_DEBT P3 #8).
+// Values verified against the current Anthropic model catalog (2026-06): fable-5,
+// opus-4-8, opus-4-7 and opus-4-6 carry a 1M context window with a 128k streaming
+// ceiling; sonnet-4-6 is 1M/64k; haiku-4-5 is 200k/64k. fable-5 is Anthropic's most
+// capable model (always-on reasoning); the loop never sets `temperature`, which
+// fable-5/opus-4-8/4.7 reject — so they stream cleanly here, same as opus-4-7 already did.
+// `supportsReasoning` marks models that accept adaptive thinking (`thinking:
+// {type:'adaptive', display:'summarized'}`) — fable-5/opus-4-8/4-7/4-6 and sonnet-4-6
+// do; haiku-4-5 does not (effort/adaptive-thinking error there), so it stays off.
+export const anthropicModels = [
+    { id: 'claude-fable-5', contextWindow: 1_000_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true },
+    { id: 'claude-opus-4-8', contextWindow: 1_000_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true },
+    { id: 'claude-opus-4-7', contextWindow: 1_000_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true },
+    { id: 'claude-opus-4-6', contextWindow: 1_000_000, maxOutputTokens: 128_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true },
+    { id: 'claude-sonnet-4-6', contextWindow: 1_000_000, maxOutputTokens: 64_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true, supportsReasoning: true },
+    { id: 'claude-haiku-4-5-20251001', contextWindow: 200_000, maxOutputTokens: 64_000, supportsTools: true, supportsStreaming: true, supportsImages: true, supportsDocuments: true },
+];
+export class AnthropicProvider {
+    name;
+    models;
+    // Mutable so OAuth-mode refresh can swap in a client carrying the new
+    // bearer token; the plain apiKey client never changes after construction.
+    client;
+    defaultModel;
+    baseURL;
+    // Present only in OAuth (Claude subscription) mode.
+    oauth;
+    oauthToken;
+    oauthExpiresAt;
+    constructor(config = {}) {
+        this.name = config.name ?? 'anthropic';
+        this.models = config.models ?? anthropicModels;
+        this.defaultModel = config.defaultModel ?? 'claude-sonnet-4-6';
+        if (config.baseURL)
+            this.baseURL = config.baseURL;
+        if (config.oauthToken) {
+            this.oauthToken = config.oauthToken;
+            this.oauthExpiresAt = config.oauthExpiresAt;
+            this.oauth = {
+                beta: config.oauthBeta ?? [],
+                ...(config.systemPreamble ? { systemPreamble: config.systemPreamble } : {}),
+                ...(config.oauthRefresh ? { refresh: config.oauthRefresh } : {}),
+            };
+            this.client = config.client ?? this.makeOauthClient(config.oauthToken);
+        }
+        else {
+            this.client =
+                config.client ??
+                    new Anthropic({
+                        apiKey: config.apiKey ?? process.env.ANTHROPIC_API_KEY,
+                        ...(config.baseURL ? { baseURL: config.baseURL } : {}),
+                    });
+        }
+    }
+    /**
+     * Build an Anthropic client in OAuth (bearer) mode. `apiKey: null` stops
+     * the SDK from falling back to `ANTHROPIC_API_KEY` and suppresses the
+     * `x-api-key` header (its `apiKeyAuth()` returns `{}` when apiKey is null),
+     * so only `Authorization: Bearer <token>` goes out, plus the beta header.
+     */
+    makeOauthClient(token) {
+        const beta = this.oauth?.beta ?? [];
+        return new Anthropic({
+            apiKey: null,
+            authToken: token,
+            ...(beta.length > 0 ? { defaultHeaders: { 'anthropic-beta': beta.join(',') } } : {}),
+            ...(this.baseURL ? { baseURL: this.baseURL } : {}),
+        });
+    }
+    /** Proactively refresh the bearer token when it's within the skew window. */
+    async ensureFreshOauth() {
+        if (!this.oauth?.refresh)
+            return;
+        if (this.oauthExpiresAt === undefined)
+            return;
+        if (Date.now() + 60_000 < this.oauthExpiresAt)
+            return;
+        await this.refreshOauthNow();
+    }
+    /** Force a token refresh and rebuild the client with the new bearer. */
+    async refreshOauthNow() {
+        if (!this.oauth?.refresh)
+            throw new Error('no refresh callback');
+        const next = await this.oauth.refresh();
+        this.oauthToken = next.token;
+        this.oauthExpiresAt = next.expiresAt;
+        this.client = this.makeOauthClient(next.token);
+    }
+    /**
+     * Build the `system` request field. In OAuth mode the Claude Code identity
+     * preamble MUST lead, so we always emit block form with the preamble first;
+     * the real system prompt follows (carrying the cache breakpoint if set).
+     * In apiKey mode the behaviour is unchanged: a bare string, upgraded to a
+     * single cache-marked block only when a system cache hint is present.
+     *
+     * `extraSystem` is `ProviderRequest.system` — the hook-injection side
+     * channel (e.g. the memory consolidation nudge), delivered IN ADDITION to
+     * the message-derived system prompt. It rides as a separate block AFTER
+     * the cache-marked one so volatile per-request text never busts the
+     * stable system-prefix cache.
+     */
+    buildSystemParam(system, cacheSystem, extraSystem) {
+        const preamble = this.oauth?.systemPreamble;
+        if (preamble || extraSystem) {
+            const blocks = [];
+            if (preamble)
+                blocks.push({ type: 'text', text: preamble });
+            if (system) {
+                blocks.push(cacheSystem
+                    ? { type: 'text', text: system, cache_control: { type: 'ephemeral' } }
+                    : { type: 'text', text: system });
+            }
+            if (extraSystem)
+                blocks.push({ type: 'text', text: extraSystem });
+            return blocks.length > 0 ? blocks : undefined;
+        }
+        return cacheSystem && system
+            ? [{ type: 'text', text: system, cache_control: { type: 'ephemeral' } }]
+            : system;
+    }
+    async *stream(req) {
+        // Translate provider-neutral cache hints into Anthropic cache_control
+        // markers. `tools`/`system` mark those session-stable regions; a
+        // `{ messageIndex }` hint marks the end of that message (the rolling
+        // prefix breakpoint). Anthropic honors at most 4 breakpoints.
+        const hints = req.cacheHints ?? [];
+        const cacheTools = hints.some((h) => h.target === 'tools');
+        const cacheSystem = hints.some((h) => h.target === 'system');
+        const cacheMessageIndices = new Set();
+        for (const h of hints) {
+            if (typeof h.target === 'object')
+                cacheMessageIndices.add(h.target.messageIndex);
+        }
+        const { system, messages } = toAnthropicMessages(req.messages, { cacheMessageIndices });
+        const tools = req.tools && req.tools.length > 0
+            ? toAnthropicTools(req.tools, { cacheLast: cacheTools })
+            : undefined;
+        // OAuth mode prepends the Claude Code identity preamble as the first
+        // system block; apiKey mode keeps the prior string/cache-block behaviour.
+        // req.system (hook-injected extra system text) is appended last.
+        const systemParam = this.buildSystemParam(system, cacheSystem, req.system);
+        const model = req.model || this.defaultModel;
+        yield { type: 'message_start', model };
+        // In OAuth mode refresh the bearer proactively when it's near expiry, so
+        // we don't fire a request on a token we already knew was about to die.
+        if (this.oauth) {
+            try {
+                await this.ensureFreshOauth();
+            }
+            catch (err) {
+                yield { type: 'error', ...toFriendlyError(err, { provider: this.name }) };
+                return;
+            }
+        }
+        // NARROW cast: `messages`/`tools`/`systemParam` are our hand-rolled
+        // Anthropic shapes (e.g. `media_type: string`) which the SDK narrows to
+        // literal unions it can't see we never violate. The body is otherwise
+        // typed as the SDK's real `MessageStreamParams` — `model`/`max_tokens`/
+        // `temperature` are checked at compile time.
+        const requestBody = {
+            model,
+            max_tokens: req.maxTokens ?? 4096,
+            system: systemParam,
+            messages: messages,
+            tools: tools,
+            ...(req.temperature !== undefined ? { temperature: req.temperature } : {}),
+        };
+        // Reasoning: on supported models (gated upstream by `supportsReasoning`),
+        // enable adaptive thinking with summarized display so the model streams a
+        // readable reasoning summary (`display: 'omitted'` — the default — would
+        // stream empty thinking blocks). Adaptive thinking auto-enables interleaved
+        // thinking on the 4.6+ catalog, so no beta header is needed. `effort` maps
+        // to `output_config.effort`. Fields are attached via a cast because the
+        // pinned SDK's `MessageStreamParams` predates these params (same hand-rolled
+        // approach used for system/messages/tools above).
+        const reasoningOn = req.reasoning !== undefined && req.reasoning !== false;
+        if (reasoningOn) {
+            const effort = typeof req.reasoning === 'object' ? req.reasoning.effort : undefined;
+            const body = requestBody;
+            body.thinking = { type: 'adaptive', display: 'summarized' };
+            if (effort)
+                body.output_config = { effort };
+        }
+        // A 401 always arrives before any SSE body, so in OAuth mode we can force
+        // a single refresh and replay the request with no risk of duplicate output.
+        try {
+            yield* this.streamOnce(requestBody, req.signal);
+        }
+        catch (err) {
+            if (this.oauth?.refresh && isUnauthorized(err)) {
+                try {
+                    await this.refreshOauthNow();
+                    yield* this.streamOnce(requestBody, req.signal);
+                    return;
+                }
+                catch (retryErr) {
+                    yield { type: 'error', ...toFriendlyError(retryErr, { provider: this.name }) };
+                    return;
+                }
+            }
+            yield { type: 'error', ...toFriendlyError(err, { provider: this.name }) };
+        }
+    }
+    /**
+     * One streaming attempt. THROWS on transport/HTTP errors so `stream()` can
+     * decide whether to refresh-and-replay (OAuth 401) or surface the error;
+     * yields content events plus a terminal `message_end` on the happy path.
+     * Abort is terminal here (yields the abort error and returns).
+     */
+    async *streamOnce(requestBody, signal) {
+        const stream = this.client.messages.stream(requestBody, 
+        // Pass the AbortSignal into the SDK request options so cancelling
+        // tears down the underlying HTTP request. Without this, Esc only
+        // stopped our loop while the model kept generating upstream.
+        signal ? { signal } : undefined);
+        const pendingToolUses = new Map();
+        // Anthropic's stream events carry a block `index` on every delta/stop;
+        // we map that index to the tool_use id at content_block_start time so
+        // parallel tool_use blocks route their deltas correctly. Without this,
+        // we used to return the first key in `pendingToolUses` for every event,
+        // causing two parallel blocks to overwrite each other's partial JSON.
+        const blockIndexToId = new Map();
+        // Track which block indices are `thinking` blocks so their signature_delta
+        // accumulates and flushes as a reasoning_signature at content_block_stop.
+        const thinkingBlockIndices = new Set();
+        let pendingThinkingSig = '';
+        let stopReason = 'end_turn';
+        // Type as the SDK's `TokenUsage` (which carries the optional cache fields)
+        // so cacheReadTokens/cacheCreationTokens are first-class on the accumulator
+        // and the message_delta merge below is type-checked to preserve them —
+        // rather than the cache fields sneaking in only via a spread (which bypasses
+        // the excess-property check) against a narrower declared type.
+        let usage;
+        try {
+            for await (const event of stream) {
+                if (signal?.aborted) {
+                    yield { type: 'error', message: 'aborted', retryable: false };
+                    return;
+                }
+                switch (event.type) {
+                    case 'message_start': {
+                        // Anthropic reports cache hits/writes only on the message_start
+                        // usage block — `cache_read_input_tokens` (billed 0.1x) and
+                        // `cache_creation_input_tokens` (billed 1.25x). Capture them here
+                        // so the metering layer can prove cache savings; without this the
+                        // fields are silently dropped and cache wins are invisible.
+                        const u = event.message?.usage;
+                        usage = {
+                            inputTokens: u?.input_tokens ?? 0,
+                            outputTokens: u?.output_tokens ?? 0,
+                            ...(u?.cache_read_input_tokens !== undefined
+                                ? { cacheReadTokens: u.cache_read_input_tokens }
+                                : {}),
+                            ...(u?.cache_creation_input_tokens !== undefined
+                                ? { cacheCreationTokens: u.cache_creation_input_tokens }
+                                : {}),
+                        };
+                        break;
+                    }
+                    case 'content_block_start': {
+                        const block = event.content_block;
+                        if (block && block.type === 'tool_use') {
+                            pendingToolUses.set(block.id, { name: block.name, partial: '' });
+                            // Real Anthropic events carry `index` here; fall back to the
+                            // arrival ordinal when callers (e.g. test fakes) omit it.
+                            const idx = typeof event.index === 'number' ? event.index : blockIndexToId.size;
+                            blockIndexToId.set(idx, block.id);
+                            yield { type: 'tool_use_start', id: block.id, name: block.name };
+                        }
+                        else if (block && block.type === 'thinking') {
+                            if (typeof event.index === 'number')
+                                thinkingBlockIndices.add(event.index);
+                            pendingThinkingSig = '';
+                        }
+                        else if (block && block.type === 'redacted_thinking') {
+                            // No readable text — replay the opaque blob verbatim on round-trip.
+                            yield { type: 'reasoning_signature', redacted: true, ...(block.data ? { encrypted: block.data } : {}) };
+                        }
+                        break;
+                    }
+                    case 'content_block_delta': {
+                        const delta = event.delta;
+                        if (!delta)
+                            break;
+                        if (delta.type === 'text_delta' && typeof delta.text === 'string') {
+                            yield { type: 'text_delta', delta: delta.text };
+                        }
+                        else if (delta.type === 'thinking_delta' && typeof delta.thinking === 'string') {
+                            yield { type: 'reasoning_delta', delta: delta.thinking };
+                        }
+                        else if (delta.type === 'signature_delta' && typeof delta.signature === 'string') {
+                            pendingThinkingSig += delta.signature;
+                        }
+                        else if (delta.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
+                            const id = idOfBlock(event, blockIndexToId);
+                            if (id) {
+                                const t = pendingToolUses.get(id);
+                                if (t) {
+                                    t.partial += delta.partial_json;
+                                    yield { type: 'tool_use_delta', id, partialInput: delta.partial_json };
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    case 'content_block_stop': {
+                        if (typeof event.index === 'number' && thinkingBlockIndices.has(event.index)) {
+                            thinkingBlockIndices.delete(event.index);
+                            if (pendingThinkingSig)
+                                yield { type: 'reasoning_signature', signature: pendingThinkingSig };
+                            pendingThinkingSig = '';
+                            break;
+                        }
+                        const id = idOfBlock(event, blockIndexToId);
+                        if (id) {
+                            const t = pendingToolUses.get(id);
+                            if (t) {
+                                let parsed = {};
+                                try {
+                                    parsed = t.partial ? JSON.parse(t.partial) : {};
+                                }
+                                catch {
+                                    parsed = { _rawPartial: t.partial };
+                                }
+                                yield { type: 'tool_use_end', id, input: parsed };
+                                pendingToolUses.delete(id);
+                                if (typeof event.index === 'number')
+                                    blockIndexToId.delete(event.index);
+                            }
+                        }
+                        break;
+                    }
+                    case 'message_delta': {
+                        if (event.delta?.stop_reason) {
+                            stopReason = mapStopReason(event.delta.stop_reason);
+                        }
+                        if (event.usage) {
+                            // Preserve cache fields captured at message_start — the delta
+                            // usage only carries the final output_tokens count.
+                            usage = {
+                                ...usage,
+                                inputTokens: usage?.inputTokens ?? 0,
+                                outputTokens: event.usage.output_tokens ?? usage?.outputTokens ?? 0,
+                            };
+                        }
+                        break;
+                    }
+                    case 'message_stop':
+                        break;
+                }
+            }
+        }
+        catch (err) {
+            // A cancel surfaces as a thrown AbortError mid-await — report it as the
+            // clean terminal 'aborted' event. Every other error propagates so
+            // `stream()` can classify it (OAuth 401 → refresh+replay; else error).
+            if (signal?.aborted) {
+                yield { type: 'error', message: 'aborted', retryable: false };
+                return;
+            }
+            throw err;
+        }
+        yield { type: 'message_end', stopReason, usage };
+    }
+    async countTokens(req) {
+        const { system, messages } = toAnthropicMessages(req.messages);
+        const tools = req.tools && req.tools.length > 0 ? toAnthropicTools(req.tools) : undefined;
+        // Mirror stream(): in OAuth mode the request carries the identity preamble
+        // as an extra system block, and req.system (hook-injected extra system
+        // text) is appended as another — count both for a faithful estimate.
+        const parts = [this.oauth?.systemPreamble, system, req.system].filter((s) => typeof s === 'string' && s.length > 0);
+        const systemForCount = parts.length > 0 ? parts.join('\n\n') : undefined;
+        try {
+            // Mirror stream(): in OAuth mode refresh a near-expiry bearer before the
+            // request so a token we already knew was about to die doesn't 401 us
+            // straight into the (less accurate) text-estimate fallback below.
+            if (this.oauth)
+                await this.ensureFreshOauth();
+            const result = await this.client.messages.countTokens({
+                model: req.model || this.defaultModel,
+                ...(systemForCount !== undefined ? { system: systemForCount } : {}),
+                // NARROW cast: our hand-rolled message/tool shapes carry `media_type:
+                // string`, which the SDK narrows to a literal union it can't see we
+                // never violate. The method itself is fully typed (no `as unknown` on
+                // the resource anymore); only these two args need the structural cast.
+                messages: messages,
+                ...(tools !== undefined ? { tools: tools } : {}),
+            });
+            return result.input_tokens;
+        }
+        catch {
+            const blob = (systemForCount ?? '') +
+                messages.map((m) => JSON.stringify(m.content)).join('') +
+                JSON.stringify(tools ?? []);
+            return estimateTextTokens(blob);
+        }
+    }
+}
+function idOfBlock(event, blockIndexToId) {
+    if (typeof event.index === 'number') {
+        return blockIndexToId.get(event.index) ?? null;
+    }
+    // Fallback when `index` is missing (older SDKs / hand-rolled fakes): only
+    // unambiguous when exactly one tool_use is pending; otherwise refuse to
+    // guess and let the delta drop rather than misroute it.
+    if (blockIndexToId.size === 1) {
+        for (const id of blockIndexToId.values())
+            return id;
+    }
+    return null;
+}
+function mapStopReason(s) {
+    if (s === 'tool_use')
+        return 'tool_use';
+    if (s === 'max_tokens')
+        return 'max_tokens';
+    if (s === 'stop_sequence')
+        return 'stop_sequence';
+    if (s === 'end_turn')
+        return 'end_turn';
+    return 'error';
+}
+/**
+ * True when the SDK error is an HTTP 401. The Anthropic SDK throws
+ * `APIError` instances carrying a numeric `status`; an expired/revoked OAuth
+ * bearer is the only 401 we want to refresh-and-retry on.
+ */
+function isUnauthorized(err) {
+    return typeof err?.status === 'number'
+        ? err.status === 401
+        : false;
+}
+//# sourceMappingURL=provider.js.map