@loopingai/core 0.7.1 → 0.8.0

package/dist/agent/anthropic/language-model.js

@@ -1,442 +0,0 @@
-// The class from `ai`, the types from `@ai-sdk/provider`. `ai` re-exports
-// `APICallError` and is a required peer, so the only thing this adapter needs the
-// provider package for is types — which erase at build, and which `ai` does not
-// re-export.
-import { APICallError, UnsupportedFunctionalityError } from "ai";
-import { CredentialRejectedError } from "../errors.js";
-import { ANTHROPIC_PROVIDER, collectSamplingWarnings, mapPrompt, mapToolChoice, mapTools } from "./prompt.js";
-/**
- * Anthropic `stop_reason` → the spec's unified finish reason.
- *
- * `raw` is always carried through: the unified set is lossy, and a caller
- * debugging a truncated round wants to know it was `max_tokens` specifically.
- */
-function mapFinishReason(stopReason) {
-    const raw = stopReason ?? undefined;
-    switch (stopReason) {
-        case "end_turn":
-        case "stop_sequence":
-            return { unified: "stop", raw };
-        case "max_tokens":
-            return { unified: "length", raw };
-        case "tool_use":
-            return { unified: "tool-calls", raw };
-        case "refusal":
-            return { unified: "content-filter", raw };
-        case "pause_turn":
-            return { unified: "other", raw };
-        default:
-            return { unified: "other", raw };
-    }
-}
-/** Anthropic usage → the spec's nested counters. */
-function mapUsage(usage) {
-    const cacheWrite = usage?.cache_creation_input_tokens ?? undefined;
-    const cacheRead = usage?.cache_read_input_tokens ?? undefined;
-    const noCache = usage?.input_tokens ?? undefined;
-    // `input_tokens` is the *uncached remainder*, so the true prompt size is the
-    // sum. Reporting only `input_tokens` as the total is the classic misread that
-    // makes a well-cached agent look like it is barely sending any context.
-    const total = noCache === undefined && cacheRead === undefined && cacheWrite === undefined
-        ? undefined
-        : (noCache ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
-    return {
-        inputTokens: { total, noCache, cacheRead, cacheWrite },
-        outputTokens: {
-            total: usage?.output_tokens ?? undefined,
-            text: undefined,
-            reasoning: undefined
-        }
-    };
-}
-/**
- * Anthropic content blocks → spec content parts.
- *
- * Two details that corrupt silently if missed:
- *
- * - `tool-call.input` is a **JSON string** on the result side, even though the
- *   same-named field on the prompt side is a parsed value.
- * - a `thinking` block's `signature` must survive into `providerMetadata`, or
- *   the next turn cannot replay it and the round after this one fails.
- */
-function mapContent(blocks) {
-    const content = [];
-    for (const block of blocks) {
-        switch (block.type) {
-            case "text":
-                content.push({ type: "text", text: block.text });
-                break;
-            case "thinking":
-                content.push({
-                    type: "reasoning",
-                    text: block.thinking,
-                    providerMetadata: {
-                        [ANTHROPIC_PROVIDER]: { signature: block.signature }
-                    }
-                });
-                break;
-            case "redacted_thinking":
-                content.push({
-                    type: "reasoning",
-                    text: "",
-                    providerMetadata: {
-                        [ANTHROPIC_PROVIDER]: { redactedData: block.data }
-                    }
-                });
-                break;
-            case "tool_use":
-                content.push({
-                    type: "tool-call",
-                    toolCallId: block.id,
-                    toolName: block.name,
-                    // Result side: a JSON string, not the object.
-                    input: JSON.stringify(block.input ?? {})
-                });
-                break;
-            default:
-                // Server-tool blocks (web search, code execution, …). Core never asks
-                // for them; ignoring is correct and quiet is fine — a warning per block
-                // would be noise on a feature nobody enabled.
-                break;
-        }
-    }
-    return content;
-}
-/**
- * Which authority refused, read off the response body the SDK parsed onto
- * `APIError.error`.
- *
- * Only the two authorities *core itself* puts on the path are recognised here.
- * They are unmistakable once you have seen them, and nothing else distinguishes
- * them — same status, same header set:
- *
- * ```jsonc
- * // AI Gateway, authentication enabled and no cf-aig-authorization sent
- * { "name": "AiGatewayError", "internalCode": 2009, "message": "Unauthorized" }
- * // Anthropic
- * { "type": "error", "error": { "type": "authentication_error", … } }
- * ```
- *
- * Matched on `name` **or** `internalCode`, because either alone is a single
- * upstream rename away from silently falling through.
- *
- * A deployment that puts its own intermediary between the two supplies
- * {@link AnthropicModelDeps.classifyAuthFailure}, which is consulted first —
- * that body's shape is the deployment's fact, not core's.
- *
- * `undefined` means "nothing here says a credential was refused", which is
- * distinct from `"unknown"` — see {@link asCredentialError}, where the two
- * differ by status.
- */
-function rejectedBy(body, classify) {
-    const declared = classify?.(body);
-    if (declared)
-        return declared;
-    if (typeof body !== "object" || body === null)
-        return undefined;
-    const parsed = body;
-    if (parsed.name === "AiGatewayError" || parsed.internalCode === 2009)
-        return "gateway";
-    if (parsed.error?.type === "authentication_error")
-        return "provider";
-    return undefined;
-}
-/**
- * Anthropic's `Headers` (or whatever the SDK put there) as the plain object the
- * AI SDK's retry logic indexes.
- *
- * `getRetryDelayInMs` reads `headers["retry-after-ms"]` and `headers["retry-after"]`
- * with bracket access — a `Headers` instance answers `undefined` to both, so the
- * wait silently degrades to plain exponential backoff and the provider's own
- * "come back in N seconds" is thrown away. Lowercased on the way in because HTTP
- * header names are case-insensitive and `Headers.forEach` is the only iteration
- * order we can rely on.
- */
-function plainHeaders(value) {
-    if (!value)
-        return undefined;
-    const out = {};
-    if (typeof value.forEach === "function") {
-        value.forEach((v, k) => {
-            out[k.toLowerCase()] = v;
-        });
-        return out;
-    }
-    if (typeof value !== "object")
-        return undefined;
-    for (const [k, v] of Object.entries(value)) {
-        if (typeof v === "string")
-            out[k.toLowerCase()] = v;
-    }
-    return out;
-}
-/**
- * A provider error in the shape the AI SDK's retry logic can act on.
- *
- * This is what makes `maxRetries` mean anything for this adapter. `ai`'s
- * `retryWithExponentialBackoffRespectingRetryHeaders` gates on
- * `APICallError.isInstance(error) && error.isRetryable`, so a raw
- * `@anthropic-ai/sdk` error — which is what this used to rethrow — is never
- * retried, however retryable it obviously is. A 429 went straight past the
- * retry, burned the fallback slot on a model sharing the same credential, threw,
- * and made the Workflow retry the entire round instead of waiting the two
- * seconds the provider asked for.
- *
- * `isRetryable` is deliberately not passed: `APICallError` derives it from the
- * status (408/409/429/5xx), which is exactly the policy we want and one fewer
- * place for the two to disagree.
- *
- * Credentials are handled *before* this — see the call site. A 401 must stay
- * non-retryable and non-fallback-able, and it reaches core as
- * {@link CredentialRejectedError} instead.
- */
-function asApiCallError(err, body) {
-    const source = err;
-    const status = source?.status;
-    // The gateway's provider-native URL is resolved per call inside the client, so
-    // the adapter does not hold it. The model id is the useful half anyway.
-    const url = `anthropic:messages:${body.model}`;
-    if (typeof status !== "number") {
-        // A transport failure: the request never reached a server that could answer
-        // with a status. The SDK raises `APIConnectionError` /
-        // `APIConnectionTimeoutError` for these, both built by `APIError.generate`
-        // with an explicitly `undefined` status — which is the shape matched below,
-        // since the SDK sets no distinguishing `name` and is an optional peer whose
-        // classes may exist twice in one bundle.
-        //
-        // Mapping it matters because *nothing else* would retry it. The client runs
-        // with `maxRetries: 0`, `isRetryable` is derived from a status this error
-        // does not have, and the message — "Connection error." — matches none of
-        // `isTransientAiError`'s fragments. A blip therefore burned the primary,
-        // burned the fallback, and failed the task as `exhausted`.
-        if (!isSdkError(source))
-            return undefined;
-        return new APICallError({
-            message: source?.message ?? "Anthropic request failed to connect",
-            url,
-            requestBodyValues: body,
-            // Explicit, because there is no status to derive it from. A connection
-            // that never opened is the definition of worth trying again.
-            isRetryable: true,
-            cause: err
-        });
-    }
-    return new APICallError({
-        message: source?.message ?? `Anthropic request failed with ${status}`,
-        url,
-        requestBodyValues: body,
-        statusCode: status,
-        responseHeaders: plainHeaders(source?.headers),
-        responseBody: source?.error === undefined ? undefined : JSON.stringify(source.error),
-        cause: err
-    });
-}
-/**
- * Whether this came out of the Anthropic SDK at all, as opposed to being a
- * programming error thrown from the same `try`.
- *
- * `APIError` assigns `status` and `type` unconditionally, so both are **own
- * properties even when undefined** — which is what separates a status-less
- * transport failure from a `TypeError`. Deliberately not `instanceof`: the SDK
- * is an optional peer and a bundle may hold two copies.
- */
-function isSdkError(err) {
-    return (err instanceof Error && "status" in err && "type" in err && "headers" in err);
-}
-/**
- * Recognise a rejected credential, and say whose.
- *
- * Structural rather than `instanceof Anthropic.AuthenticationError`: the SDK is
- * an optional peer, so a bundle can hold two copies, and this must not depend on
- * which one threw.
- *
- * ## Why 401 and 403 are not treated alike
- *
- * A `401` **is** an authentication failure — that is what the status means — so
- * an unrecognised body still yields `"unknown"`, which is the honest answer and
- * still stops the ladder.
- *
- * A `403` is authorization, and Anthropic uses it for `permission_error`: a
- * perfectly valid credential that lacks access to *this* model or resource.
- * Reporting that as a dead credential is doubly wrong — it sends an operator to
- * rotate a working token, and it skips the fallback slot, which is the one thing
- * that could still answer, because the fallback is a **different model** and may
- * well be permitted. So a `403` counts only when the body positively names a
- * refused credential; anything else falls through to {@link asApiCallError} and
- * the fallback is tried as usual.
- */
-function asCredentialError(err, classify) {
-    if (CredentialRejectedError.isInstance(err))
-        return err;
-    const status = err?.status;
-    if (status !== 401 && status !== 403)
-        return undefined;
-    const source = rejectedBy(err?.error, classify);
-    // A 403 nobody claimed is a permission problem, not a credential one.
-    if (source === undefined && status === 403)
-        return undefined;
-    const message = err instanceof Error ? err.message : "a credential was rejected";
-    return new CredentialRejectedError(message, {
-        status,
-        source: source ?? "unknown",
-        cause: err
-    });
-}
-export function createAnthropicLanguageModel(deps) {
-    const cache = deps.cache ?? "5m";
-    const ttl = cache === false ? undefined : cache;
-    return {
-        specificationVersion: "v4",
-        provider: ANTHROPIC_PROVIDER,
-        modelId: deps.modelId,
-        // Anthropic fetches image and PDF URLs itself, so the SDK need not download
-        // and re-encode them.
-        supportedUrls: {
-            "image/*": [/^https?:\/\/.+$/],
-            "application/pdf": [/^https?:\/\/.+$/]
-        },
-        async doGenerate(options) {
-            const warnings = [...collectSamplingWarnings(options)];
-            const { system, messages, warnings: promptWarnings } = mapPrompt(options.prompt, {
-                cache,
-                defaultMaxTokens: deps.defaultMaxTokens
-            });
-            warnings.push(...promptWarnings);
-            const tools = options.tools
-                ? mapTools(options.tools, ttl, warnings)
-                : undefined;
-            if (options.responseFormat?.type === "json") {
-                warnings.push({
-                    type: "unsupported",
-                    feature: "responseFormat",
-                    details: "structured outputs are not mapped yet; use a tool with a strict schema"
-                });
-            }
-            const effort = mapEffort(options.reasoning ?? deps.effort, warnings);
-            const body = {
-                model: deps.modelId,
-                max_tokens: options.maxOutputTokens ?? deps.defaultMaxTokens,
-                messages,
-                ...(system ? { system } : {}),
-                ...(tools ? { tools } : {}),
-                ...(options.toolChoice
-                    ? { tool_choice: mapToolChoice(options.toolChoice) }
-                    : {}),
-                ...(options.stopSequences?.length
-                    ? { stop_sequences: options.stopSequences }
-                    : {}),
-                ...(effort ? { output_config: { effort } } : {})
-            };
-            try {
-                // Streamed on the wire, accumulated here into the single result the
-                // spec returns. This is not an optimisation and not optional: the SDK
-                // refuses a NON-streaming request outright — before any network call —
-                // once `max_tokens` implies a response that could take more than ten
-                // minutes, at `(60 * 60 * max_tokens) / 128_000 > 600`, i.e. above
-                // 21,333 tokens. An agent whose whole point is long output would have
-                // to be capped below that ceiling to use `create`.
-                //
-                // `doStream` still throws: what streams is the transport, not this
-                // adapter's contract. Core calls `generateText`, which wants one
-                // result, and it gets one.
-                const client = await deps.client();
-                const response = await client.messages
-                    .stream(body, {
-                    ...(options.abortSignal ? { signal: options.abortSignal } : {}),
-                    headers: { ...deps.headers, ...stripUndefined(options.headers) }
-                })
-                    .finalMessage();
-                return {
-                    // `refusal` arrives as a normal 200 with empty or partial content, so
-                    // this must never assume `content[0]` exists.
-                    content: mapContent(response.content ?? []),
-                    finishReason: mapFinishReason(response.stop_reason),
-                    usage: mapUsage(response.usage),
-                    warnings,
-                    request: { body },
-                    response: { id: response.id, modelId: response.model }
-                };
-            }
-            catch (err) {
-                // Credentials first, and the order is the whole point: a 401 is a
-                // status the generic mapper below would happily wrap, and an
-                // `APICallError` is something core's ladder is allowed to fall back
-                // from. A dead token must stop the task instead.
-                const credential = asCredentialError(err, deps.classifyAuthFailure);
-                if (credential)
-                    throw credential;
-                // Everything else in the shape the SDK's retry and core's transient
-                // classifier can both read. See {@link asApiCallError}.
-                const apiError = asApiCallError(err, body);
-                if (apiError)
-                    throw apiError;
-                throw err;
-            }
-        },
-        /**
-         * Not implemented, deliberately. Core's loops call `generateText`, which
-         * never touches `doStream` — what streams is the transport inside
-         * `doGenerate`, not this adapter's contract. The spec's own error is the
-         * right one: it fails by name, and a caller reaching for `streamText` sees
-         * which method is missing rather than something half-formed.
-         */
-        doStream() {
-            throw new UnsupportedFunctionalityError({
-                functionality: "doStream",
-                message: "The Anthropic adapter implements doGenerate only. " +
-                    "Core's loops call generateText, which never streams. " +
-                    "Implement doStream in @loopingai/core/anthropic before using streamText."
-            });
-        }
-    };
-}
-/**
- * Reasoning effort → `output_config.effort`, or nothing.
- *
- * The two vocabularies overlap but are not the same, and the difference is a
- * 400 rather than a type error: the spec's `reasoning` includes `"minimal"`,
- * which Anthropic's `effort` does not define. Casting across them — which is
- * what this replaced — silences the one check that would have caught it.
- *
- * `provider-default` and `none` mean "say nothing", so the field is omitted and
- * the API picks. `minimal` is mapped down to the nearest real level rather than
- * dropped: the caller asked for *less* thinking, and omitting the field would
- * silently give them the API default of `high` — the opposite.
- */
-function mapEffort(reasoning, warnings) {
-    switch (reasoning) {
-        case undefined:
-        case "provider-default":
-        case "none":
-            return undefined;
-        case "low":
-        case "medium":
-        case "high":
-        case "xhigh":
-        case "max":
-            return reasoning;
-        case "minimal":
-            warnings.push({
-                type: "unsupported",
-                feature: "reasoning",
-                details: 'Anthropic has no "minimal" effort; sent "low" instead'
-            });
-            return "low";
-        default:
-            warnings.push({
-                type: "unsupported",
-                feature: "reasoning",
-                details: `unknown reasoning effort "${reasoning}"; the field was omitted`
-            });
-            return undefined;
-    }
-}
-/** The spec allows `undefined` header values; `fetch` does not. */
-function stripUndefined(headers) {
-    const out = {};
-    for (const [key, value] of Object.entries(headers ?? {})) {
-        if (value !== undefined)
-            out[key] = value;
-    }
-    return out;
-}

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

@@ -1,84 +0,0 @@
-import type Anthropic from "@anthropic-ai/sdk";
-import type { LanguageModelV4CallOptions, LanguageModelV4FunctionTool, LanguageModelV4Prompt, LanguageModelV4ProviderTool, LanguageModelV4ToolChoice, SharedV4Warning } from "@ai-sdk/provider";
-/**
- * The AI SDK prompt → Anthropic Messages request mapping.
- *
- * Split out from the model itself because it is pure: prompt in, request body
- * plus warnings out, no client and no I/O. That is what makes the sharp edges
- * below testable without a network or a cassette, and every one of them is a
- * silent-corruption bug rather than a loud one.
- *
- * Three shape mismatches do the real damage if you get them wrong:
- *
- * 1. **There is no `tool` role in the Messages API.** The AI SDK models tool
- *    results as their own role; Anthropic carries them as `tool_result` blocks
- *    inside a **user** turn.
- * 2. **`thinking` blocks are signed and must be replayed byte-for-byte.** Opus 5
- *    runs adaptive thinking by default and rejects a modified block. Core's loop
- *    is multi-turn tool use on every round, so it replays the previous assistant
- *    message every single time — drop or rebuild the signature and round two of
- *    every task 400s.
- * 3. **`input` is a parsed value on the way in and a JSON string on the way
- *    out.** `LanguageModelV4ToolCallPart.input` (prompt side) is `unknown`;
- *    `LanguageModelV4ToolCall.input` (result side) is `string`. Mixing them up
- *    type-checks and corrupts silently.
- */
-/** Namespaced provider key for anything we stash on a part. */
-export declare const ANTHROPIC_PROVIDER = "anthropic";
-/**
- * A tool-call id Anthropic will accept, from one it might not.
- *
- * The API validates this field against `^[a-zA-Z0-9_-]+$` and answers a
- * violation with a `400 invalid_request_error` naming the exact message index —
- * `messages.7.content.1.tool_use.id`. That is a *deterministic* failure on
- * replayed history, which makes it the worst kind: every retry and every
- * fallback re-sends the same poisoned message list and fails identically, so the
- * round burns its whole ladder without a single attempt that could have worked.
- * It cost a production task exactly that way.
- *
- * Applied to both sides of the pair — the assistant's `tool_use.id` and the
- * user turn's `tool_result.tool_use_id` — because the two must agree or the
- * request is malformed in a second, more confusing way. Since the mapping is a
- * pure function of the id, applying it independently at both call sites lands on
- * the same answer without threading state between them.
- *
- * This is a **backstop**, not the fix. Core's own generators emit safe ids
- * directly (see {@link file://../../subtasks/delegate.ts delegateToolCallId});
- * this catches the next generator someone writes, and any id that reaches the
- * adapter from outside core.
- *
- * Not injective, and deliberately not made so: two ids differing only in
- * unsafe characters collapse together. Adding a hash to avoid that would change
- * every id to guard against a collision that requires two synthetic calls in one
- * request whose ids differ *only* in punctuation. Provider-legible ids are worth
- * more than that.
- */
-export declare function providerSafeToolCallId(id: string): string;
-/**
- * How long a cache entry should live.
- *
- * `"5m"` is Anthropic's default and suits back-to-back model calls. `"1h"`
- * costs 2x on write instead of 1.25x and exists for agents whose rounds are
- * separated by long tool work — a container boot, an install, a test suite —
- * where a 5-minute entry has expired by the time the next round starts and the
- * whole prefix is re-billed at full price.
- */
-export type CacheTtl = "5m" | "1h";
-export interface PromptMappingOptions {
-    /** Cache TTL, or `false` to place no breakpoints at all. */
-    cache?: CacheTtl | false;
-    /** `max_tokens` when the caller supplied none. Anthropic requires the field. */
-    defaultMaxTokens: number;
-}
-export interface MappedPrompt {
-    system: Anthropic.TextBlockParam[] | undefined;
-    messages: Anthropic.MessageParam[];
-    warnings: SharedV4Warning[];
-}
-/** Map the prompt half of a call: system blocks + turns. */
-export declare function mapPrompt(prompt: LanguageModelV4Prompt, options: PromptMappingOptions): MappedPrompt;
-/** Map tool definitions, putting the frozen-prefix breakpoint on the last one. */
-export declare function mapTools(tools: Array<LanguageModelV4FunctionTool | LanguageModelV4ProviderTool>, ttl: CacheTtl | undefined, warnings: SharedV4Warning[]): Anthropic.ToolUnion[] | undefined;
-/** Map tool choice. Note V4 uses `{type:"required"}`, not the bare string. */
-export declare function mapToolChoice(toolChoice: LanguageModelV4ToolChoice | undefined): Anthropic.ToolChoice | undefined;
-export declare function collectSamplingWarnings(options: LanguageModelV4CallOptions): SharedV4Warning[];