@loopingai/core 0.7.1 → 0.8.1

package/dist/job/lifecycle.js

@@ -0,0 +1,230 @@
+import { isRearmable } from "./state.js";
+/**
+ * `WakeMap`'s own storage row, spelled here rather than imported.
+ *
+ * Importing `WAKE_KEY` would be a *value* import from `../alarm`, and this
+ * module is careful to reach that package only for types — a runtime edge would
+ * pull the whole alarm module into any bundle that imports `/job`. So the string
+ * is duplicated, and `lifecycle.spec.ts` asserts it still equals `WAKE_KEY`;
+ * specs never ship, so the check costs nothing at runtime and fails loudly if
+ * the two ever drift.
+ */
+const WAKE_MAP_KEY = "wake";
+const DEFAULT_STALE_MS = 5 * 60_000;
+const DEFAULT_WATCH_MS = 60_000;
+const DEFAULT_ARM_COOLDOWN_MS = 5 * 60_000;
+export class JobLifecycle {
+    #o;
+    /** `install` — the state record. */
+    stateKey;
+    /** `install:armed` — the stamp the arming path wrote, for the alarm to match. */
+    armedKey;
+    /** `install:last-armed` — the cooldown floor. */
+    lastArmedKey;
+    /** `install:context` — where the generation marker lives. */
+    contextKey;
+    /** `install-run` — the intent that *runs* a job. */
+    runIntent;
+    /** `install-watch` — the intent that re-attaches to one nobody is draining. */
+    watchIntent;
+    constructor(options) {
+        /**
+         * An id is a storage key, so a bad one is not a bad name — it is a write
+         * landing on somebody else's row.
+         *
+         * `"wake"` is the one that matters and the reason this guard exists: it is
+         * `WakeMap`'s single row, so a job with that id would overwrite the whole
+         * intent map on its first state write, and the `wake.set()` immediately
+         * after would then read job fields as intents. Every pending wake-up on the
+         * object — not just this job's — silently stops happening.
+         *
+         * Empty is rejected for the same reason one level down: it yields the
+         * intents `-run` and `-watch`, which two differently-broken callers would
+         * share.
+         */
+        if (!options.id)
+            throw new Error("a job id must be a non-empty string");
+        if (options.id === WAKE_MAP_KEY) {
+            throw new Error(`"${WAKE_MAP_KEY}" is reserved: it is WakeMap's storage row, and a job ` +
+                `with that id would overwrite every pending intent on this object`);
+        }
+        this.#o = {
+            ...options,
+            staleMs: options.staleMs ?? DEFAULT_STALE_MS,
+            watchMs: options.watchMs ?? DEFAULT_WATCH_MS,
+            armCooldownMs: options.armCooldownMs ?? DEFAULT_ARM_COOLDOWN_MS
+        };
+        this.stateKey = options.id;
+        this.armedKey = `${options.id}:armed`;
+        this.lastArmedKey = `${options.id}:last-armed`;
+        this.contextKey = `${options.id}:context`;
+        this.runIntent = `${options.id}-run`;
+        this.watchIntent = `${options.id}-watch`;
+    }
+    // --- the record ------------------------------------------------------------
+    /** The raw record, with no staleness repair. `idle` when nothing is written. */
+    async read() {
+        return ((await this.#o.storage.get(this.stateKey)) ??
+            { state: "idle" });
+    }
+    async write(state) {
+        await this.#o.storage.put(this.stateKey, state);
+    }
+    async context() {
+        return await this.#o.storage.get(this.contextKey);
+    }
+    /**
+     * Record which run this is, **before** spawning.
+     *
+     * The order is the whole point: a drain captures `startedAt` after the spawn,
+     * so a context written afterwards would let two runs share a generation.
+     */
+    async putContext(context) {
+        await this.#o.storage.put(this.contextKey, context);
+    }
+    // --- arming ----------------------------------------------------------------
+    /**
+     * Hand a cold job to the alarm, if one is not already pending.
+     *
+     * Returns the stamp it armed with, or `undefined` when it declined — the
+     * caller needs the stamp because it is what the alarm must present to
+     * {@link claim} to get past the single-flight guard.
+     *
+     * An arming caller must **not** own the run. The predecessor handed one to
+     * `ctx.waitUntil` from a gate poll that returned in milliseconds, and the
+     * drain was disposed underneath it mid-command. An alarm invocation belongs to
+     * the object rather than to any request, so nothing it awaits can be cut short.
+     */
+    async arm(placeholder) {
+        const state = await this.read();
+        if (!isRearmable(state))
+            return undefined;
+        const lastArmed = await this.#o.storage.get(this.lastArmedKey);
+        if (lastArmed !== undefined &&
+            Date.now() - lastArmed < this.#o.armCooldownMs)
+            return undefined;
+        const armedAt = Date.now();
+        await this.write({
+            ...placeholder,
+            state: "running",
+            startedAt: armedAt
+        });
+        await this.#o.storage.put(this.armedKey, armedAt);
+        // Kept even if the scheduling below fails, deliberately: a floor that only
+        // applied to *successful* arming would let a persistently failing schedule
+        // re-arm on every call into the object, which is what it exists to prevent.
+        await this.#o.storage.put(this.lastArmedKey, armedAt);
+        /**
+         * The placeholder and the alarm that owns it are two writes, and between
+         * them is the one window where this can strand a job: a `running` record no
+         * run intent points at, which every later {@link arm} then declines to
+         * replace *because* it is running.
+         *
+         * The staleness bound in {@link claim} would eventually free it, but only
+         * after a full timeout — so unwind instead, and leave the record exactly as
+         * re-armable as it was found.
+         */
+        try {
+            await this.#o.wake.set({ key: this.runIntent, notBefore: armedAt });
+        }
+        catch (err) {
+            await this.write(state);
+            await this.#o.storage.delete(this.armedKey).catch(() => { });
+            throw err;
+        }
+        return armedAt;
+    }
+    /** The stamp {@link arm} wrote, so the alarm can recognise its own placeholder. */
+    async armedAt() {
+        return await this.#o.storage.get(this.armedKey);
+    }
+    async clearArmed() {
+        await this.#o.storage.delete(this.armedKey);
+    }
+    // --- the single-flight guard ------------------------------------------------
+    /**
+     * Decide whether a new run may start.
+     *
+     * `takeOverArmedAt` is the one exemption and it is narrow on purpose. The
+     * alarm's placeholder *is* a `running` record for a job that has not started,
+     * so the alarm has to pass its own guard — and only its own. Matching the
+     * exact stamp it wrote is what stops this becoming "take over any running
+     * job", which is the displacement bug the guard exists to prevent: three
+     * callers spawning under one exec id in fifty seconds, each displacing the
+     * last, every displaced drain still attached and still writing verdicts.
+     *
+     * Applies the staleness bound **itself**, rather than trusting the caller to
+     * have repaired the record first. An earlier draft took an
+     * "already-repaired" state and said so in prose, which enforced nothing: the
+     * repaired and raw types are identical, so a caller passing a raw read got a
+     * `running` record that could never be claimed and a job wedged forever.
+     * `timeoutMs` is the job's own budget; see {@link isStale}.
+     */
+    claim(state, timeoutMs, takeOverArmedAt) {
+        if (state.state !== "running")
+            return { ok: true };
+        // The alarm presenting its own placeholder — the one narrow exemption.
+        if (state.startedAt === takeOverArmedAt)
+            return { ok: true };
+        // A record whose isolate is gone must not block every later run.
+        if (this.isStale(state, timeoutMs))
+            return { ok: true };
+        return { ok: false, current: state };
+    }
+    // --- staleness and re-attach -------------------------------------------------
+    /**
+     * Whether a `running` record has stood long enough to be presumed dead.
+     *
+     * `timeoutMs` is the job's own budget; the bound is that plus `staleMs`, so a
+     * job that is merely slow is never declared gone.
+     */
+    isStale(state, timeoutMs, now = Date.now()) {
+        return now - state.startedAt > timeoutMs + this.#o.staleMs;
+    }
+    /** Arm the watchdog that re-attaches to a job nobody is draining. */
+    async armWatch(now = Date.now()) {
+        await this.#o.wake.set({
+            key: this.watchIntent,
+            notBefore: now + this.#o.watchMs
+        });
+    }
+    /**
+     * Disarm the watchdog.
+     *
+     * Never call this from a superseded drain: the watchdog belongs to whichever
+     * run owns the record *now*, and clearing it there disarms the one recovery
+     * path the live run has.
+     */
+    async clearWatch() {
+        await this.#o.wake.clear(this.watchIntent).catch(() => { });
+    }
+    // --- generation --------------------------------------------------------------
+    /**
+     * A predicate a drain calls before every write, to ask whether it still owns
+     * the record.
+     *
+     * Captures the stamp once, at drain start, and compares it against disk each
+     * time. The closure also latches, so a drain can ask afterwards whether it was
+     * superseded — which is what decides if it may touch the watchdog.
+     */
+    generation(startedAt) {
+        let superseded = false;
+        return {
+            stillMine: async () => {
+                // The latch is checked *before* the read, not after. Ownership is not
+                // recoverable: once another run has owned this record, a stamp that
+                // happens to match again does not hand it back, and a drain that
+                // regained write access here would be the corruption the marker exists
+                // to prevent.
+                if (superseded)
+                    return false;
+                const now = await this.context();
+                if (now?.startedAt === startedAt)
+                    return true;
+                superseded = true;
+                return false;
+            },
+            superseded: () => superseded
+        };
+    }
+}

package/dist/job/state.d.ts

@@ -0,0 +1,92 @@
+/**
+ * The record an alarm-owned job writes about itself, and the shape a gate reads.
+ *
+ * This is the contract between two halves that do not own each other: the
+ * Durable Object *runs* the job, and something else — a shell tool, a subagent
+ * executor — refuses to proceed while one is in flight. A shape they agreed on
+ * informally would drift, and the drift shows up as a command running halfway
+ * through the job it was supposed to wait for.
+ *
+ * ## Why `TExtra` intersects rather than nests
+ *
+ * The obvious generic is `{ state: "running"; meta: TExtra }`. It is wrong here,
+ * and expensively so: every existing reader spells the job's own field at the
+ * top level (`status.command`), so nesting would rewrite every read site and
+ * every spec assertion in both consumers to buy nothing. Intersecting keeps
+ * `JobState<{ command: string }>` *byte-identical* to the hand-written union it
+ * replaces, which is what makes adopting this a type change and not a refactor.
+ *
+ * The cost of the choice is that `TExtra` must not collide with the field names
+ * below. That is a real constraint, and it is why they are named for the
+ * mechanism (`startedAt`, `finishedAt`, `exitCode`) rather than for any job.
+ */
+/**
+ * A job's durable state.
+ *
+ * Five variants, and the two that look redundant are not:
+ *
+ * - `idle` — nothing has ever run. There is no context recording *where* or
+ *   *what*, so a caller cannot re-drive it; that is the owner's job.
+ * - `skipped` — something looked and decided there was nothing to do. Terminal
+ *   and *correct*, which is why it is not `done`: a gate must not treat a
+ *   deliberate no-op as a failure to retry, and an arming path must not re-drive
+ *   it forever.
+ * - `running` — in flight, or believed to be. Never trusted without the
+ *   staleness bound in {@link JobLifecycle.claim}, because the isolate that
+ *   wrote it may be long gone.
+ * - `done` / `failed` — terminal, carrying enough to explain the outcome without
+ *   the caller reaching for the transcript.
+ */
+/** Nothing has ever run; no context exists naming what would. */
+export type IdleJob = {
+    state: "idle";
+};
+/** Something looked and decided there was nothing to do. Terminal and correct. */
+export type SkippedJob = {
+    state: "skipped";
+    reason: string;
+};
+/** In flight, or believed to be. Never trusted without the staleness bound. */
+export type RunningJob<TExtra = Record<never, never>> = {
+    state: "running";
+    startedAt: number;
+    tail?: string;
+} & TExtra;
+export type DoneJob<TExtra = Record<never, never>> = {
+    state: "done";
+    exitCode: number;
+    finishedAt: number;
+    ms: number;
+    tail?: string;
+} & TExtra;
+export type FailedJob<TExtra = Record<never, never>> = {
+    state: "failed";
+    finishedAt: number;
+    error: string;
+    exitCode?: number;
+    tail?: string;
+} & TExtra;
+/**
+ * A job's durable state.
+ *
+ * The variants are named types rather than inlined into the union because
+ * `Extract<JobState<TExtra>, { state: "running" }>` cannot narrow while `TExtra`
+ * is generic — the compiler has no way to prove `DoneJob & TExtra` does not also
+ * carry `state: "running"`. Naming them is what lets a caller say
+ * `RunningJob<TExtra>` and get its fields.
+ */
+export type JobState<TExtra = Record<never, never>> = IdleJob | SkippedJob | RunningJob<TExtra> | DoneJob<TExtra> | FailedJob<TExtra>;
+/**
+ * Whether a state is one a new run may start from.
+ *
+ * `done` and `failed` both qualify, and the second was a gap worth closing in
+ * the predecessor: arming used to require `done`, so one bad run left a record
+ * that declined to re-arm forever — one failure poisoning every task after it.
+ *
+ * `skipped` and `idle` are excluded for different reasons. `skipped` means the
+ * answer is already correct and permanent. `idle` means no context exists naming
+ * what to run, so there is nothing to re-drive.
+ */
+export declare function isRearmable<TExtra extends object>(state: JobState<TExtra>): boolean;
+/** Whether a state claims a job is in flight. Never conclusive on its own. */
+export declare function isRunning<TExtra extends object>(state: JobState<TExtra>): state is RunningJob<TExtra>;

package/dist/job/state.js

@@ -0,0 +1,40 @@
+/**
+ * The record an alarm-owned job writes about itself, and the shape a gate reads.
+ *
+ * This is the contract between two halves that do not own each other: the
+ * Durable Object *runs* the job, and something else — a shell tool, a subagent
+ * executor — refuses to proceed while one is in flight. A shape they agreed on
+ * informally would drift, and the drift shows up as a command running halfway
+ * through the job it was supposed to wait for.
+ *
+ * ## Why `TExtra` intersects rather than nests
+ *
+ * The obvious generic is `{ state: "running"; meta: TExtra }`. It is wrong here,
+ * and expensively so: every existing reader spells the job's own field at the
+ * top level (`status.command`), so nesting would rewrite every read site and
+ * every spec assertion in both consumers to buy nothing. Intersecting keeps
+ * `JobState<{ command: string }>` *byte-identical* to the hand-written union it
+ * replaces, which is what makes adopting this a type change and not a refactor.
+ *
+ * The cost of the choice is that `TExtra` must not collide with the field names
+ * below. That is a real constraint, and it is why they are named for the
+ * mechanism (`startedAt`, `finishedAt`, `exitCode`) rather than for any job.
+ */
+/**
+ * Whether a state is one a new run may start from.
+ *
+ * `done` and `failed` both qualify, and the second was a gap worth closing in
+ * the predecessor: arming used to require `done`, so one bad run left a record
+ * that declined to re-arm forever — one failure poisoning every task after it.
+ *
+ * `skipped` and `idle` are excluded for different reasons. `skipped` means the
+ * answer is already correct and permanent. `idle` means no context exists naming
+ * what to run, so there is nothing to re-drive.
+ */
+export function isRearmable(state) {
+    return state.state === "done" || state.state === "failed";
+}
+/** Whether a state claims a job is in flight. Never conclusive on its own. */
+export function isRunning(state) {
+    return state.state === "running";
+}

package/dist/round/subagent.d.ts

@@ -59,14 +59,17 @@ export declare abstract class RecipeSubagentHost<TEnv extends Cloudflare.Env & A
      * Which provider this facet's chunks run on. Mirrors
      * {@link file://../host/agent.ts LoopingAgent.modelRuntime}, and **must be
      * overridden to match it** — a facet that keeps the Workers AI default while
-     * its parent runs on Claude would silently execute every subtask on a
-     * different model than the round that delegated it.
+     * its parent runs on another provider would silently execute every subtask on
+     * a different model than the round that delegated it.
      *
      * The two seams take the same arguments precisely so that keeping them in step
      * needs no discipline: write the provider once as a
      * {@link file://../agent/model.ts ModelRuntimeFactory} and have both return
-     * it. Two hand-copied `createAnthropicModelRuntime({...})` bodies is what this
-     * shape exists to stop, because nothing type-checks their agreement.
+     * it. Two hand-copied runtime-construction bodies is what this shape exists to
+     * stop, because nothing type-checks their agreement.
+     *
+     * Note the cheapest way to satisfy this is to override *neither* seam, which
+     * is what an agent on core's default does.
      *
      * Takes the model config rather than reading `this.config`, because the facet
      * resolves its config inside `buildRuntime` and this is called from there.

package/dist/round/subagent.js

@@ -54,14 +54,17 @@ export class RecipeSubagentHost extends RecipeSubagentBase {
      * Which provider this facet's chunks run on. Mirrors
      * {@link file://../host/agent.ts LoopingAgent.modelRuntime}, and **must be
      * overridden to match it** — a facet that keeps the Workers AI default while
-     * its parent runs on Claude would silently execute every subtask on a
-     * different model than the round that delegated it.
+     * its parent runs on another provider would silently execute every subtask on
+     * a different model than the round that delegated it.
      *
      * The two seams take the same arguments precisely so that keeping them in step
      * needs no discipline: write the provider once as a
      * {@link file://../agent/model.ts ModelRuntimeFactory} and have both return
-     * it. Two hand-copied `createAnthropicModelRuntime({...})` bodies is what this
-     * shape exists to stop, because nothing type-checks their agreement.
+     * it. Two hand-copied runtime-construction bodies is what this shape exists to
+     * stop, because nothing type-checks their agreement.
+     *
+     * Note the cheapest way to satisfy this is to override *neither* seam, which
+     * is what an agent on core's default does.
      *
      * Takes the model config rather than reading `this.config`, because the facet
      * resolves its config inside `buildRuntime` and this is called from there.

package/dist/subtasks/delegate.d.ts

@@ -54,9 +54,10 @@ export declare function makeDelegateTool(types: SubtaskTypeRegistry, maxSubtasks
  * why it took a Claude-backed agent to surface it.
  *
  * Nothing persists this: both halves of the pair are rebuilt together on every
- * request, so changing the shape needs no migration. See
- * {@link file://../agent/anthropic/prompt.ts providerSafeToolCallId} for the
- * backstop that catches the next one of these.
+ * request, so changing the shape needs no migration. There is no longer a
+ * provider-side backstop in core — the adapter that carried one went with
+ * `./anthropic` in 0.8.0 — so a provider added here that validates tool-call ids
+ * needs to sanitize them on its own way out.
  */
 export declare function delegateToolCallId(taskId: string, round: number): string;
 /**

package/dist/subtasks/delegate.js

@@ -60,9 +60,10 @@ export function makeDelegateTool(types, maxSubtasks) {
  * why it took a Claude-backed agent to surface it.
  *
  * Nothing persists this: both halves of the pair are rebuilt together on every
- * request, so changing the shape needs no migration. See
- * {@link file://../agent/anthropic/prompt.ts providerSafeToolCallId} for the
- * backstop that catches the next one of these.
+ * request, so changing the shape needs no migration. There is no longer a
+ * provider-side backstop in core — the adapter that carried one went with
+ * `./anthropic` in 0.8.0 — so a provider added here that validates tool-call ids
+ * needs to sanitize them on its own way out.
  */
 export function delegateToolCallId(taskId, round) {
     return `task_${taskId}_round_${round}_delegate`;

package/dist/testing/mock-model.js

@@ -122,7 +122,7 @@ export function rateLimitedModel(failures, ...steps) {
                 if (calls <= failures) {
                     throw new APICallError({
                         message: "429 Wholesale Rate limited",
-                        url: "anthropic:messages:test",
+                        url: "mock:chat:test",
                         requestBodyValues: {},
                         statusCode: 429,
                         responseHeaders: { "retry-after": "0" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loopingai/core",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "description": "Shared, mandatory foundation for Looping agents on Cloudflare Workers: zero-trust A2A, durable task lifecycle, delegation and subagent runtime, test harness.",
   "keywords": [
     "a2a",
@@ -61,6 +61,10 @@
       "types": "./dist/alarm/index.d.ts",
       "import": "./dist/alarm/index.js"
     },
+    "./job": {
+      "types": "./dist/job/index.d.ts",
+      "import": "./dist/job/index.js"
+    },
     "./round": {
       "types": "./dist/round/index.d.ts",
       "import": "./dist/round/index.js"
@@ -94,10 +98,6 @@
       "import": "./dist/testing/vcr-global-setup.js"
     },
     "./eslint": "./eslint-rules/index.js",
-    "./anthropic": {
-      "types": "./dist/agent/anthropic/index.d.ts",
-      "import": "./dist/agent/anthropic/index.js"
-    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -112,7 +112,8 @@
     "test:watch": "vitest",
     "verify:exports": "node scripts/verify-exports.mjs",
     "prepack": "npm run build && npm run verify:exports",
-    "prepublishOnly": "npm run check && npm test && npm run verify:exports"
+    "prepublishOnly": "npm run check && npm test && npm run verify:exports",
+    "prepare": "husky"
   },
   "dependencies": {
     "@a2a-js/sdk": "^1.0.0",
@@ -123,8 +124,6 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@ai-sdk/provider": "^4.0.0",
-    "@anthropic-ai/sdk": "^0.116.0",
     "@cloudflare/vitest-pool-workers": ">=0.18",
     "@typescript-eslint/utils": ">=8",
     "agents": "^0.20.0",
@@ -133,12 +132,6 @@
     "workers-ai-provider": "^4.0.0"
   },
   "peerDependenciesMeta": {
-    "@ai-sdk/provider": {
-      "optional": true
-    },
-    "@anthropic-ai/sdk": {
-      "optional": true
-    },
     "@cloudflare/vitest-pool-workers": {
       "optional": true
     },
@@ -150,14 +143,13 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/provider": "^4.0.0",
-    "@anthropic-ai/sdk": "^0.116.0",
     "@cloudflare/vitest-pool-workers": "^0.20.1",
     "@types/node": "^26.1.1",
     "agents": "^0.20.0",
     "ai": "^7.0.52",
     "drizzle-kit": "^0.31.10",
     "eslint": "^10.8.0",
+    "husky": "^9.1.7",
     "prettier": "^3.9.6",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.66.0",

package/dist/agent/anthropic/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * `@loopingai/core/anthropic` — Claude as a second model provider.
- *
- * Its own subpath, and an **optional** peer dependency on `@anthropic-ai/sdk`,
- * for the same reason `/round` is not re-exported from the root barrel: an agent
- * that runs on Workers AI should not pay — in install size, in bundle bytes, or
- * in a dependency it must keep current — for a provider it never calls.
- *
- * What lives here is a provider, not a capability. It ships no tools, no prompt
- * copy and no policy; it satisfies {@link ModelRuntime} and stops.
- */
-export { CredentialRejectedError, type CredentialRejectedBy } from "../errors.js";
-export { createAnthropicLanguageModel, type AnthropicModelDeps } from "./language-model.js";
-export { createAnthropicModelRuntime, type AnthropicRuntimeDeps } from "./runtime.js";
-export { ANTHROPIC_PROVIDER, type CacheTtl } from "./prompt.js";

package/dist/agent/anthropic/index.js

@@ -1,19 +0,0 @@
-/**
- * `@loopingai/core/anthropic` — Claude as a second model provider.
- *
- * Its own subpath, and an **optional** peer dependency on `@anthropic-ai/sdk`,
- * for the same reason `/round` is not re-exported from the root barrel: an agent
- * that runs on Workers AI should not pay — in install size, in bundle bytes, or
- * in a dependency it must keep current — for a provider it never calls.
- *
- * What lives here is a provider, not a capability. It ships no tools, no prompt
- * copy and no policy; it satisfies {@link ModelRuntime} and stops.
- */
-// Re-exported, not owned: a rejected credential is a fact about the path to a
-// model, not about Anthropic, so the error lives with the rest of the provider
-// contract in {@link file://../errors.ts}. An agent that only imports this
-// subpath still gets it from one place.
-export { CredentialRejectedError } from "../errors.js";
-export { createAnthropicLanguageModel } from "./language-model.js";
-export { createAnthropicModelRuntime } from "./runtime.js";
-export { ANTHROPIC_PROVIDER } from "./prompt.js";

package/dist/agent/anthropic/language-model.d.ts

@@ -1,59 +0,0 @@
-import type Anthropic from "@anthropic-ai/sdk";
-import type { LanguageModelV4 } from "@ai-sdk/provider";
-import { type CredentialRejectedBy } from "../errors.js";
-import { type CacheTtl } from "./prompt.js";
-/**
- * A `LanguageModelV4` over `@anthropic-ai/sdk`, so core's loops can call Claude
- * without knowing they are.
- *
- * Every loop in core is written against `generateText` from `ai` and a
- * `LanguageModel` — {@link file://../../round/turn.ts turn.ts},
- * {@link file://../../subagent/run.ts run.ts} and
- * {@link file://../session.ts session.ts}. Satisfying that interface is what
- * keeps the round loop, the control-tool repair ladder, subtask execution and
- * the Workflow untouched by a second provider. The alternative — a bespoke
- * Messages-API loop for one agent — would have given all of that up.
- *
- * `ai@7` accepts `LanguageModelV2 | V3 | V4`; this targets **v4**, the newest
- * the installed `@ai-sdk/provider` defines.
- */
-/** How the adapter reaches the API. Everything is injected so nothing reads env. */
-export interface AnthropicModelDeps {
-    /**
-     * Constructed lazily by the runtime — see the note in
-     * {@link file://./runtime.ts}. Awaited, because building it has to resolve
-     * `env.AI.gateway(id).getUrl()`, which is async.
-     */
-    client: () => Anthropic | Promise<Anthropic>;
-    /** Anthropic model id, e.g. `claude-opus-5`. */
-    modelId: string;
-    /** `max_tokens` when a caller supplies none. Anthropic requires the field. */
-    defaultMaxTokens: number;
-    /** Prompt-cache TTL, or `false` to place no breakpoints. Defaults to `"5m"`. */
-    cache?: CacheTtl | false;
-    /**
-     * Reasoning effort, when the caller does not set one per-call.
-     *
-     * Maps to `output_config.effort`. Coding and agentic work wants `"xhigh"`;
-     * `"high"` is the API default. Core never picks this — an agent does.
-     */
-    effort?: "low" | "medium" | "high" | "xhigh" | "max";
-    /** Extra headers merged into every request (AI Gateway metadata lives here). */
-    headers?: Record<string, string>;
-    /**
-     * Recognise a deployment-specific authority in a `401`/`403` body.
-     *
-     * Consulted before the built-in shapes; return `undefined` to fall through to
-     * them. It exists because a deployment may put an authenticated intermediary
-     * between the gateway and Anthropic, and only that deployment knows what its
-     * refusal looks like — core recognising one particular proxy's error body
-     * would be exactly the deployment policy this package does not ship.
-     *
-     * The remedy is what makes it worth distinguishing at all: a proxy that mints
-     * its caller credential per request has no secret to rotate, so reporting its
-     * `401` as `credential` sends an operator to replace a working token. See
-     * {@link file://../errors.ts CredentialRejectedBy}.
-     */
-    classifyAuthFailure?: (body: unknown) => CredentialRejectedBy | undefined;
-}
-export declare function createAnthropicLanguageModel(deps: AnthropicModelDeps): LanguageModelV4;