@veryfront/ext-llm-anthropic 0.1.985

package/esm/anthropic-request-builder.js

@@ -0,0 +1,403 @@
+import { readProviderOptions, stringifyJsonValue, unwrapToolInputSchema, } from "veryfront/provider/shared";
+function normalizeAnthropicToolChoice(toolChoice) {
+    if (typeof toolChoice === "string") {
+        return { type: toolChoice };
+    }
+    return toolChoice;
+}
+function toSnakeCaseRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [
+        key.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`),
+        value,
+    ]));
+}
+function deepSnakeCase(value) {
+    if (Array.isArray(value)) {
+        return value.map(deepSnakeCase);
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, v]) => [
+            key.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`),
+            deepSnakeCase(v),
+        ]));
+    }
+    return value;
+}
+function pushAnthropicUserContent(messages, content) {
+    if (content.length === 0) {
+        return;
+    }
+    const lastMessage = messages.at(-1);
+    if (lastMessage?.role === "user") {
+        lastMessage.content.push(...content);
+        return;
+    }
+    messages.push({
+        role: "user",
+        content,
+    });
+}
+function toAnthropicUserContent(parts) {
+    const content = [];
+    for (const part of parts) {
+        if (part.type === "text") {
+            if (part.text.length > 0) {
+                content.push({ type: "text", text: part.text });
+            }
+            continue;
+        }
+        if (part.type === "image" || part.mediaType.startsWith("image/")) {
+            content.push({
+                type: "image",
+                source: {
+                    type: "url",
+                    url: part.url,
+                },
+            });
+        }
+    }
+    return content;
+}
+function resolveAnthropicCacheControlBlock(ttl) {
+    if (ttl === undefined || ttl === false) {
+        return undefined;
+    }
+    if (ttl === "1h") {
+        return { type: "ephemeral", ttl: "1h" };
+    }
+    return { type: "ephemeral" };
+}
+function toAnthropicMessages(prompt, systemCacheControl) {
+    const systemParts = [];
+    const messages = [];
+    const lastUserIndex = prompt.findLastIndex((message) => message.role === "user");
+    const lastHistoricalAssistantTextIndex = prompt.findLastIndex((message, index) => index < lastUserIndex &&
+        message.role === "assistant" &&
+        message.content.some((part) => part.type === "text" && part.text.length > 0));
+    let skippingHistoricalToolResults = false;
+    let pendingToolUseIds = new Set();
+    for (const [index, message] of prompt.entries()) {
+        switch (message.role) {
+            case "system":
+                skippingHistoricalToolResults = false;
+                pendingToolUseIds = new Set();
+                if (message.content.length > 0) {
+                    systemParts.push(message.content);
+                }
+                break;
+            case "user":
+                skippingHistoricalToolResults = false;
+                pendingToolUseIds = new Set();
+                pushAnthropicUserContent(messages, toAnthropicUserContent(message.content));
+                break;
+            case "assistant": {
+                skippingHistoricalToolResults = false;
+                const shouldCompactCompletedToolRound = index < lastHistoricalAssistantTextIndex &&
+                    message.content.some((part) => part.type === "tool-call");
+                const assistantContent = shouldCompactCompletedToolRound
+                    ? message.content.filter((part) => part.type === "text" && part.text.length > 0)
+                    : message.content;
+                if (assistantContent.length === 0) {
+                    skippingHistoricalToolResults = shouldCompactCompletedToolRound;
+                    pendingToolUseIds = new Set();
+                    break;
+                }
+                pendingToolUseIds = new Set(assistantContent.flatMap((part) => part.type === "tool-call" ? [part.toolCallId] : []));
+                messages.push({
+                    role: "assistant",
+                    content: assistantContent.map((part) => {
+                        if (part.type === "text") {
+                            return { type: "text", text: part.text };
+                        }
+                        if (part.type === "reasoning") {
+                            if (typeof part.redactedData === "string") {
+                                return {
+                                    type: "redacted_thinking",
+                                    data: part.redactedData,
+                                };
+                            }
+                            return {
+                                type: "thinking",
+                                thinking: part.text ?? "",
+                                ...(typeof part.signature === "string" ? { signature: part.signature } : {}),
+                            };
+                        }
+                        return {
+                            type: "tool_use",
+                            id: part.toolCallId,
+                            name: part.toolName,
+                            input: part.input,
+                        };
+                    }),
+                });
+                skippingHistoricalToolResults = shouldCompactCompletedToolRound;
+                break;
+            }
+            case "tool": {
+                if (skippingHistoricalToolResults) {
+                    break;
+                }
+                const matchingToolResults = message.content.filter((part) => pendingToolUseIds.has(part.toolCallId));
+                if (matchingToolResults.length === 0) {
+                    break;
+                }
+                pushAnthropicUserContent(messages, matchingToolResults.map((part) => ({
+                    type: "tool_result",
+                    tool_use_id: part.toolCallId,
+                    content: stringifyJsonValue(part.output.value),
+                })));
+                for (const part of matchingToolResults) {
+                    pendingToolUseIds.delete(part.toolCallId);
+                }
+                break;
+            }
+        }
+    }
+    if (systemParts.length === 0) {
+        return { messages };
+    }
+    const joined = systemParts.join("\n\n");
+    if (systemCacheControl) {
+        return {
+            system: [{
+                    type: "text",
+                    text: joined,
+                    cache_control: systemCacheControl,
+                }],
+            messages,
+        };
+    }
+    return { system: joined, messages };
+}
+const ANTHROPIC_TOOL_VERSION_ALIASES = {
+    code_execution: "code_execution_20260120",
+    computer_use: "computer_20250124",
+    computer: "computer_20250124",
+    text_editor: "text_editor_20250728",
+    bash: "bash_20250124",
+    memory: "memory_20250818",
+    web_search: "web_search_20250305",
+    web_fetch: "web_fetch_20250910",
+};
+function resolveAnthropicProviderType(rawType) {
+    if (/_\d{8}$/.test(rawType)) {
+        return rawType;
+    }
+    return ANTHROPIC_TOOL_VERSION_ALIASES[rawType] ?? rawType;
+}
+function toAnthropicTools(tools, toolsCacheControl) {
+    if (!tools) {
+        return undefined;
+    }
+    const normalized = [];
+    for (const tool of tools) {
+        if (tool.type === "function") {
+            normalized.push({
+                name: tool.name,
+                ...(typeof tool.description === "string" ? { description: tool.description } : {}),
+                input_schema: unwrapToolInputSchema(tool.inputSchema),
+            });
+            continue;
+        }
+        if (!tool.id.startsWith("anthropic.")) {
+            continue;
+        }
+        const rawType = tool.id.slice("anthropic.".length);
+        if (rawType.length === 0) {
+            continue;
+        }
+        normalized.push({
+            type: resolveAnthropicProviderType(rawType),
+            name: tool.name,
+            ...toSnakeCaseRecord(tool.args),
+        });
+    }
+    if (normalized.length === 0) {
+        return undefined;
+    }
+    if (toolsCacheControl) {
+        const lastIndex = normalized.length - 1;
+        normalized[lastIndex] = {
+            ...normalized[lastIndex],
+            cache_control: toolsCacheControl,
+        };
+    }
+    return normalized;
+}
+function getAnthropicModelCapabilities(modelId) {
+    if (modelId.includes("claude-opus-4-6")) {
+        return { maxOutputTokens: 128_000, isKnownModel: true };
+    }
+    if (modelId.includes("claude-sonnet-4-6")) {
+        return { maxOutputTokens: 64_000, isKnownModel: true };
+    }
+    if (modelId.includes("claude-sonnet-4-5") ||
+        modelId.includes("claude-opus-4-5") ||
+        modelId.includes("claude-haiku-4-5")) {
+        return { maxOutputTokens: 64_000, isKnownModel: true };
+    }
+    if (modelId.includes("claude-opus-4-1")) {
+        return { maxOutputTokens: 32_000, isKnownModel: true };
+    }
+    if (modelId.includes("claude-sonnet-4-")) {
+        return { maxOutputTokens: 64_000, isKnownModel: true };
+    }
+    if (modelId.includes("claude-opus-4-")) {
+        return { maxOutputTokens: 32_000, isKnownModel: true };
+    }
+    if (modelId.includes("claude-3-haiku")) {
+        return { maxOutputTokens: 4096, isKnownModel: true };
+    }
+    return { maxOutputTokens: 4096, isKnownModel: false };
+}
+function resolveAnthropicMaxTokens(modelId, callerMaxOutputTokens) {
+    const { maxOutputTokens: modelMax, isKnownModel } = getAnthropicModelCapabilities(modelId);
+    const requested = callerMaxOutputTokens ?? modelMax;
+    if (isKnownModel && requested > modelMax) {
+        return modelMax;
+    }
+    return requested;
+}
+function resolveAnthropicThinkingBudget(option) {
+    if (!option || option.enabled !== true) {
+        return undefined;
+    }
+    if (typeof option.budgetTokens === "number" && option.budgetTokens >= 1024) {
+        return option.budgetTokens;
+    }
+    switch (option.effort) {
+        case "low":
+            return 1024;
+        case "high":
+            return 16_384;
+        case "max":
+            return 32_768;
+        case "medium":
+        default:
+            return 4096;
+    }
+}
+function resolveAnthropicProviderThinkingBudget(options) {
+    const thinking = options.thinking;
+    if (thinking === null || typeof thinking !== "object" || Array.isArray(thinking)) {
+        return undefined;
+    }
+    const record = thinking;
+    if (record.type !== "enabled") {
+        return undefined;
+    }
+    const budgetTokens = record.budget_tokens;
+    if (typeof budgetTokens === "number" && Number.isFinite(budgetTokens) && budgetTokens >= 1024) {
+        return budgetTokens;
+    }
+    return undefined;
+}
+export function buildAnthropicMessagesRequest(modelId, providerName, options, stream, warnings) {
+    const systemCacheControl = resolveAnthropicCacheControlBlock(options.cacheControl?.system);
+    const toolsCacheControl = resolveAnthropicCacheControlBlock(options.cacheControl?.tools);
+    const { system, messages } = toAnthropicMessages(options.prompt, systemCacheControl);
+    const anthropicTools = toAnthropicTools(options.tools, toolsCacheControl);
+    const rawProviderOptions = readProviderOptions(options.providerOptions, "anthropic", providerName);
+    const thinkingBudget = resolveAnthropicThinkingBudget(options.reasoning);
+    const providerThinkingBudget = resolveAnthropicProviderThinkingBudget(rawProviderOptions);
+    const effectiveThinkingBudget = thinkingBudget ?? providerThinkingBudget;
+    const thinkingEnabled = effectiveThinkingBudget !== undefined;
+    if (options.presencePenalty !== undefined) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "anthropic",
+            setting: "presencePenalty",
+            details: "Anthropic Messages API has no equivalent and the value was dropped.",
+        });
+    }
+    if (options.frequencyPenalty !== undefined) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "anthropic",
+            setting: "frequencyPenalty",
+            details: "Anthropic Messages API has no equivalent and the value was dropped.",
+        });
+    }
+    if (options.seed !== undefined) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "anthropic",
+            setting: "seed",
+            details: "Anthropic Messages API does not support deterministic seeding.",
+        });
+    }
+    if (options.topK !== undefined) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "anthropic",
+            setting: "topK",
+            details: "Anthropic Messages API does not expose top_k on this surface.",
+        });
+    }
+    if (options.stopSequences && options.stopSequences.length > 4) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "anthropic",
+            setting: "stopSequences",
+            details: `Anthropic accepts at most 4 stop sequences; ${options.stopSequences.length} were provided and the extras were truncated.`,
+        });
+    }
+    if (thinkingEnabled && options.temperature !== undefined) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "anthropic",
+            setting: "temperature",
+            details: "Dropped because Anthropic rejects sampling params when extended thinking is enabled.",
+        });
+    }
+    if (thinkingEnabled && options.topP !== undefined) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "anthropic",
+            setting: "topP",
+            details: "Dropped because Anthropic rejects sampling params when extended thinking is enabled.",
+        });
+    }
+    if (options.responseFormat && options.responseFormat.type !== "text") {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "anthropic",
+            setting: "responseFormat",
+            details: "Anthropic Messages API does not have a structured-output response_format equivalent. Use a tool with the schema as input_schema instead.",
+        });
+    }
+    const baseMaxTokens = resolveAnthropicMaxTokens(modelId, options.maxOutputTokens);
+    const maxTokens = thinkingEnabled
+        ? Math.min(baseMaxTokens + (effectiveThinkingBudget ?? 0), getAnthropicModelCapabilities(modelId).maxOutputTokens)
+        : baseMaxTokens;
+    const body = {
+        model: modelId,
+        messages,
+        max_tokens: maxTokens,
+        ...(stream ? { stream: true } : {}),
+        ...(system ? { system } : {}),
+        ...(!thinkingEnabled && options.temperature !== undefined
+            ? { temperature: options.temperature }
+            : {}),
+        ...(!thinkingEnabled && options.topP !== undefined ? { top_p: options.topP } : {}),
+        ...(options.stopSequences && options.stopSequences.length > 0
+            ? { stop_sequences: options.stopSequences.slice(0, 4) }
+            : {}),
+        ...(anthropicTools ? { tools: anthropicTools } : {}),
+        ...(options.toolChoice !== undefined
+            ? { tool_choice: normalizeAnthropicToolChoice(options.toolChoice) }
+            : {}),
+        ...(thinkingBudget !== undefined
+            ? { thinking: { type: "enabled", budget_tokens: thinkingBudget } }
+            : {}),
+        ...(typeof options.userId === "string" && options.userId.length > 0
+            ? { metadata: { user_id: options.userId } }
+            : {}),
+        ...(options.mcpServers && options.mcpServers.length > 0
+            ? { mcp_servers: deepSnakeCase(options.mcpServers) }
+            : {}),
+        ...(options.anthropicContainer !== undefined ? { container: options.anthropicContainer } : {}),
+    };
+    Object.assign(body, rawProviderOptions);
+    return body;
+}

package/esm/anthropic-stream.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeUsage } from "veryfront/provider/shared";
+type AnthropicStreamOptions = {
+    clientToolUseTrailingUsageGraceMs?: number;
+};
+export declare function normalizeAnthropicFinishReason(raw: unknown): string | {
+    unified: string;
+    raw: string;
+} | null;
+export declare function extractAnthropicUsage(payload: unknown): RuntimeUsage | undefined;
+export declare function streamAnthropicCompatibleParts(stream: ReadableStream<Uint8Array>, options?: AnthropicStreamOptions): AsyncIterable<unknown>;
+export {};
+//# sourceMappingURL=anthropic-stream.d.ts.map

package/esm/anthropic-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-stream.d.ts","sourceRoot":"","sources":["../src/anthropic-stream.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAgB9D,KAAK,sBAAsB,GAAG;IAC5B,iCAAiC,CAAC,EAAE,MAAM,CAAC;CAC5C,CAAC;AAmBF,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,OAAO,GACX,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgBlD;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CA+DhF;AAqED,wBAAuB,8BAA8B,CACnD,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EAClC,OAAO,GAAE,sBAA2B,GACnC,aAAa,CAAC,OAAO,CAAC,CAoUxB"}