indusagi 0.12.32 → 0.12.33

package/local-dist-new/ml/adapters/anthropic.js

@@ -1,682 +0,0 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { getEnvApiKey } from "../env-api-keys.js";
-import { calculateCost } from "../models.js";
-import { BaseStreamHandler } from "../kit/base-stream-handler.js";
-import { AssistantMessageEventStream } from "../kit/event-stream.js";
-import { createAssistantMessageOutput } from "../kit/output-factory.js";
-import { mapStopReason as mapProviderStopReason, normalizeToolCallId } from "../kit/provider-consolidation.js";
-import { StreamEventHelper } from "../kit/stream-event-helper.js";
-import { parseStreamingJson } from "../kit/json-parse.js";
-import { sanitizeSurrogates } from "../kit/sanitize-unicode.js";
-import { adjustMaxTokensForThinking, buildBaseOptions, executeWithRetry, } from "./simple-options.js";
-import { transformMessages } from "./transform-messages.js";
-const ClaudeCodeNameCodec = {
-    version: "2.1.2",
-    canonicalToolNames: [
-        "Read",
-        "Write",
-        "Edit",
-        "Bash",
-        "Grep",
-        "Glob",
-        "AskUserQuestion",
-        "EnterPlanMode",
-        "ExitPlanMode",
-        "KillShell",
-        "NotebookEdit",
-        "Skill",
-        "Task",
-        "TaskOutput",
-        "TodoWrite",
-        "WebFetch",
-        "WebSearch",
-    ],
-    lookup: undefined,
-    ensureLookup() {
-        if (!this.lookup) {
-            this.lookup = new Map(this.canonicalToolNames.map((toolName) => [toolName.toLowerCase(), toolName]));
-        }
-        return this.lookup;
-    },
-    encode(name) {
-        const lookup = this.ensureLookup();
-        return lookup.get(name.toLowerCase()) ?? name;
-    },
-    decode(name, tools) {
-        if (tools && tools.length > 0) {
-            const lowerName = name.toLowerCase();
-            const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
-            if (matchedTool) {
-                return matchedTool.name;
-            }
-        }
-        return name;
-    },
-};
-/**
- * Convert content blocks to Anthropic API format
- */
-function convertContentBlocks(content) {
-    // If only text blocks, return as concatenated string for simplicity
-    const hasImages = content.some((c) => c.type === "image");
-    if (!hasImages) {
-        return sanitizeSurrogates(content.map((c) => c.text).join("\n"));
-    }
-    // If we have images, convert to content block array
-    const blocks = content.map((block) => {
-        if (block.type === "text") {
-            return {
-                type: "text",
-                text: sanitizeSurrogates(block.text),
-            };
-        }
-        return {
-            type: "image",
-            source: {
-                type: "base64",
-                media_type: block.mimeType,
-                data: block.data,
-            },
-        };
-    });
-    // If only images (no text), add placeholder text block
-    const hasText = blocks.some((b) => b.type === "text");
-    if (!hasText) {
-        blocks.unshift({
-            type: "text",
-            text: "(see attached image)",
-        });
-    }
-    return blocks;
-}
-/**
- * Builder for constructing Anthropic API request parameters.
- *
- * Centralizes logic for converting generic context/model/options into
- * Anthropic-specific `MessageCreateParamsStreaming`.
- */
-export class AnthropicRequestBuilder {
-    model;
-    context;
-    isOAuthToken;
-    options;
-    constructor(model, context, isOAuthToken, options) {
-        this.model = model;
-        this.context = context;
-        this.isOAuthToken = isOAuthToken;
-        this.options = options;
-    }
-    /**
-     * Build the streaming request parameters.
-     *
-     * @returns Anthropic SDK streaming parameters.
-     */
-    build() {
-        return buildParams(this.model, this.context, this.isOAuthToken, this.options);
-    }
-}
-function mergeHeaders(...headerSources) {
-    const merged = {};
-    for (const headers of headerSources) {
-        if (headers) {
-            Object.assign(merged, headers);
-        }
-    }
-    return merged;
-}
-/**
- * Anthropic-specific stream handler.
- *
- * Wraps the Anthropic SDK streaming API and emits standardized assistant events.
- */
-export class AnthropicStreamHandler extends BaseStreamHandler {
-    executeFn;
-    constructor(executeFn) {
-        super();
-        this.executeFn = executeFn;
-    }
-    /**
-     * Process the Anthropic stream by invoking the provided execute function.
-     */
-    async processStream() {
-        if (this.executeFn)
-            await this.executeFn();
-    }
-    /**
-     * Iterate over the raw Anthropic stream and invoke the event callback.
-     *
-     * @param anthropicStream - The raw iterable from Anthropic's SDK.
-     * @param onEvent - Callback invoked for each streaming event.
-     */
-    async process(anthropicStream, onEvent) {
-        for await (const event of anthropicStream)
-            onEvent(event);
-    }
-}
-class AnthropicEventReducer {
-    blocks;
-    output;
-    stream;
-    model;
-    contextTools;
-    oauthMode;
-    handlers;
-    constructor(blocks, output, stream, model, contextTools, oauthMode) {
-        this.blocks = blocks;
-        this.output = output;
-        this.stream = stream;
-        this.model = model;
-        this.contextTools = contextTools;
-        this.oauthMode = oauthMode;
-        this.handlers = {
-            message_start: (event) => this.onMessageStart(event),
-            content_block_start: (event) => this.onContentBlockStart(event),
-            content_block_delta: (event) => this.onContentBlockDelta(event),
-            content_block_stop: (event) => this.onContentBlockStop(event),
-            message_delta: (event) => this.onMessageDelta(event),
-        };
-    }
-    reduce(event) {
-        const handler = this.handlers[event.type];
-        if (handler) {
-            handler(event);
-        }
-    }
-    onMessageStart(event) {
-        this.updateUsage(event?.message?.usage);
-    }
-    onContentBlockStart(event) {
-        if (event.content_block.type === "text") {
-            const block = {
-                type: "text",
-                text: "",
-                index: event.index,
-            };
-            this.output.content.push(block);
-            this.stream.push({ type: "text_start", contentIndex: this.output.content.length - 1, partial: this.output });
-            return;
-        }
-        if (event.content_block.type === "thinking") {
-            const block = {
-                type: "thinking",
-                thinking: "",
-                thinkingSignature: "",
-                index: event.index,
-            };
-            this.output.content.push(block);
-            this.stream.push({ type: "thinking_start", contentIndex: this.output.content.length - 1, partial: this.output });
-            return;
-        }
-        if (event.content_block.type === "tool_use") {
-            const decodedName = this.oauthMode
-                ? ClaudeCodeNameCodec.decode(event.content_block.name, this.contextTools)
-                : event.content_block.name;
-            const block = {
-                type: "toolCall",
-                id: event.content_block.id,
-                name: decodedName,
-                arguments: event.content_block.input,
-                partialJson: "",
-                index: event.index,
-            };
-            this.output.content.push(block);
-            this.stream.push({ type: "toolcall_start", contentIndex: this.output.content.length - 1, partial: this.output });
-        }
-    }
-    onContentBlockDelta(event) {
-        const blockIndex = this.blocks.findIndex((block) => block.index === event.index);
-        const block = this.blocks[blockIndex];
-        if (!block) {
-            return;
-        }
-        if (event.delta.type === "text_delta" && block.type === "text") {
-            block.text += event.delta.text;
-            this.stream.push({
-                type: "text_delta",
-                contentIndex: blockIndex,
-                delta: event.delta.text,
-                partial: this.output,
-            });
-            return;
-        }
-        if (event.delta.type === "thinking_delta" && block.type === "thinking") {
-            block.thinking += event.delta.thinking;
-            this.stream.push({
-                type: "thinking_delta",
-                contentIndex: blockIndex,
-                delta: event.delta.thinking,
-                partial: this.output,
-            });
-            return;
-        }
-        if (event.delta.type === "input_json_delta" && block.type === "toolCall") {
-            block.partialJson += event.delta.partial_json;
-            block.arguments = parseStreamingJson(block.partialJson);
-            this.stream.push({
-                type: "toolcall_delta",
-                contentIndex: blockIndex,
-                delta: event.delta.partial_json,
-                partial: this.output,
-            });
-            return;
-        }
-        if (event.delta.type === "signature_delta" && block.type === "thinking") {
-            block.thinkingSignature = block.thinkingSignature || "";
-            block.thinkingSignature += event.delta.signature;
-        }
-    }
-    onContentBlockStop(event) {
-        const blockIndex = this.blocks.findIndex((block) => block.index === event.index);
-        const block = this.blocks[blockIndex];
-        if (!block) {
-            return;
-        }
-        delete block.index;
-        if (block.type === "text") {
-            this.stream.push({
-                type: "text_end",
-                contentIndex: blockIndex,
-                content: block.text,
-                partial: this.output,
-            });
-            return;
-        }
-        if (block.type === "thinking") {
-            this.stream.push({
-                type: "thinking_end",
-                contentIndex: blockIndex,
-                content: block.thinking,
-                partial: this.output,
-            });
-            return;
-        }
-        if (block.type === "toolCall") {
-            block.arguments = parseStreamingJson(block.partialJson);
-            delete block.partialJson;
-            this.stream.push({
-                type: "toolcall_end",
-                contentIndex: blockIndex,
-                toolCall: block,
-                partial: this.output,
-            });
-        }
-    }
-    onMessageDelta(event) {
-        if (event.delta.stop_reason) {
-            this.output.stopReason = mapProviderStopReason(event.delta.stop_reason, "anthropic");
-        }
-        this.updateUsage(event.usage);
-    }
-    updateUsage(usage) {
-        if (!usage) {
-            return;
-        }
-        this.output.usage.input = usage.input_tokens || 0;
-        this.output.usage.output = usage.output_tokens || 0;
-        this.output.usage.cacheRead = usage.cache_read_input_tokens || 0;
-        this.output.usage.cacheWrite = usage.cache_creation_input_tokens || 0;
-        this.output.usage.totalTokens =
-            this.output.usage.input + this.output.usage.output + this.output.usage.cacheRead + this.output.usage.cacheWrite;
-        calculateCost(this.model, this.output.usage);
-    }
-}
-export const streamAnthropic = (model, context, options) => {
-    const stream = new AssistantMessageEventStream();
-    const output = createAssistantMessageOutput(model);
-    const events = new StreamEventHelper(stream, output);
-    const handler = new AnthropicStreamHandler(async () => {
-        try {
-            const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
-            const { client, isOAuthToken } = createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers);
-            const params = new AnthropicRequestBuilder(model, context, isOAuthToken, options).build();
-            options?.onPayload?.(params);
-            events.start();
-            const blocks = output.content;
-            const streamHandler = new AnthropicStreamHandler();
-            const reducer = new AnthropicEventReducer(blocks, output, stream, model, context.tools, isOAuthToken);
-            await executeWithRetry(async () => {
-                const anthropicStream = client.messages.stream({ ...params, stream: true }, { signal: options?.signal });
-                await streamHandler.process(anthropicStream, (event) => {
-                    reducer.reduce(event);
-                });
-            }, {
-                maxAttempts: options?.signal ? 1 : 3,
-                baseDelayMs: 250,
-            });
-            if (options?.signal?.aborted) {
-                throw new Error("Request was aborted");
-            }
-            if (output.stopReason === "aborted" || output.stopReason === "error") {
-                throw new Error("An unknown error occurred");
-            }
-            stream.pushDone(output.stopReason, output);
-            stream.end();
-        }
-        catch (error) {
-            for (const block of output.content)
-                delete block.index;
-            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-            stream.pushError(output.stopReason, output);
-            stream.end();
-        }
-    });
-    void handler.run();
-    return stream;
-};
-export const streamSimpleAnthropic = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
-    if (!apiKey) {
-        throw new Error(`No API key for provider: ${model.provider}`);
-    }
-    const base = buildBaseOptions(model, options, apiKey);
-    if (!options?.reasoning) {
-        return streamAnthropic(model, context, { ...base, thinkingEnabled: false });
-    }
-    const adjusted = adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options.thinkingBudgets);
-    return streamAnthropic(model, context, {
-        ...base,
-        maxTokens: adjusted.maxTokens,
-        thinkingEnabled: true,
-        thinkingBudgetTokens: adjusted.thinkingBudget,
-    });
-};
-function isOAuthToken(apiKey) {
-    return apiKey.includes("sk-ant-oat");
-}
-function createClient(model, apiKey, interleavedThinking, optionsHeaders) {
-    const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
-    if (interleavedThinking) {
-        betaFeatures.push("interleaved-thinking-2025-05-14");
-    }
-    const oauthToken = isOAuthToken(apiKey);
-    if (oauthToken) {
-        // Stealth mode: Mimic Claude Code's headers exactly
-        const defaultHeaders = mergeHeaders({
-            accept: "application/json",
-            "anthropic-dangerous-direct-browser-access": "true",
-            "anthropic-beta": `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}`,
-            "user-agent": `claude-cli/${ClaudeCodeNameCodec.version} (external, cli)`,
-            "x-app": "cli",
-        }, model.headers, optionsHeaders);
-        const client = new Anthropic({
-            apiKey: null,
-            authToken: apiKey,
-            baseURL: model.baseUrl,
-            defaultHeaders,
-            dangerouslyAllowBrowser: true,
-        });
-        return { client, isOAuthToken: true };
-    }
-    const defaultHeaders = mergeHeaders({
-        accept: "application/json",
-        "anthropic-dangerous-direct-browser-access": "true",
-        "anthropic-beta": betaFeatures.join(","),
-    }, model.headers, optionsHeaders);
-    const client = new Anthropic({
-        apiKey,
-        baseURL: model.baseUrl,
-        dangerouslyAllowBrowser: true,
-        defaultHeaders,
-    });
-    return { client, isOAuthToken: false };
-}
-function buildParams(model, context, isOAuthToken, options) {
-    const params = {
-        model: model.id,
-        messages: convertMessages(context.messages, model, isOAuthToken),
-        max_tokens: options?.maxTokens || (model.maxTokens / 3) | 0,
-        stream: true,
-    };
-    // For OAuth tokens, we MUST include Claude Code identity
-    if (isOAuthToken) {
-        params.system = [
-            {
-                type: "text",
-                text: "You are Claude Code, Anthropic's official CLI for Claude.",
-                cache_control: {
-                    type: "ephemeral",
-                },
-            },
-        ];
-        if (context.systemPrompt) {
-            params.system.push({
-                type: "text",
-                text: sanitizeSurrogates(context.systemPrompt),
-                cache_control: {
-                    type: "ephemeral",
-                },
-            });
-        }
-    }
-    else if (context.systemPrompt) {
-        // Add cache control to system prompt for non-OAuth tokens
-        params.system = [
-            {
-                type: "text",
-                text: sanitizeSurrogates(context.systemPrompt),
-                cache_control: {
-                    type: "ephemeral",
-                },
-            },
-        ];
-    }
-    if (options?.temperature !== undefined) {
-        params.temperature = options.temperature;
-    }
-    if (context.tools) {
-        params.tools = convertTools(context.tools, isOAuthToken);
-    }
-    if (options?.thinkingEnabled && model.reasoning) {
-        params.thinking = {
-            type: "enabled",
-            budget_tokens: options.thinkingBudgetTokens || 1024,
-        };
-    }
-    if (options?.toolChoice) {
-        if (typeof options.toolChoice === "string") {
-            params.tool_choice = { type: options.toolChoice };
-        }
-        else {
-            params.tool_choice = options.toolChoice;
-        }
-    }
-    return params;
-}
-// Normalize tool call IDs to match Anthropic's required pattern and length
-class AnthropicMessageComposer {
-    model;
-    oauthMode;
-    constructor(model, oauthMode) {
-        this.model = model;
-        this.oauthMode = oauthMode;
-    }
-    compose(messages) {
-        const params = [];
-        const transformedMessages = transformMessages(messages, this.model, normalizeToolCallId);
-        for (let i = 0; i < transformedMessages.length; i++) {
-            const message = transformedMessages[i];
-            if (message.role === "user") {
-                const userParam = this.composeUserMessage(message);
-                if (userParam)
-                    params.push(userParam);
-                continue;
-            }
-            if (message.role === "assistant") {
-                const assistantParam = this.composeAssistantMessage(message);
-                if (assistantParam)
-                    params.push(assistantParam);
-                continue;
-            }
-            const groupedToolResults = this.composeToolResultBatch(transformedMessages, i);
-            params.push(groupedToolResults.param);
-            i = groupedToolResults.nextIndex;
-        }
-        applyCacheControlToLatestUserMessage(params);
-        return params;
-    }
-    composeUserMessage(message) {
-        if (typeof message.content === "string") {
-            if (message.content.trim().length === 0) {
-                return undefined;
-            }
-            return {
-                role: "user",
-                content: sanitizeSurrogates(message.content),
-            };
-        }
-        const blocks = message.content.map((item) => {
-            if (item.type === "text") {
-                return {
-                    type: "text",
-                    text: sanitizeSurrogates(item.text),
-                };
-            }
-            return {
-                type: "image",
-                source: {
-                    type: "base64",
-                    media_type: item.mimeType,
-                    data: item.data,
-                },
-            };
-        });
-        let filteredBlocks = !this.model?.input.includes("image") ? blocks.filter((block) => block.type !== "image") : blocks;
-        filteredBlocks = filteredBlocks.filter((block) => (block.type === "text" ? block.text.trim().length > 0 : true));
-        if (filteredBlocks.length === 0) {
-            return undefined;
-        }
-        return {
-            role: "user",
-            content: filteredBlocks,
-        };
-    }
-    composeAssistantMessage(message) {
-        const blocks = [];
-        for (const block of message.content) {
-            if (block.type === "text") {
-                if (block.text.trim().length === 0)
-                    continue;
-                blocks.push({ type: "text", text: sanitizeSurrogates(block.text) });
-                continue;
-            }
-            if (block.type === "thinking") {
-                if (block.thinking.trim().length === 0)
-                    continue;
-                if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
-                    blocks.push({ type: "text", text: sanitizeSurrogates(block.thinking) });
-                }
-                else {
-                    blocks.push({
-                        type: "thinking",
-                        thinking: sanitizeSurrogates(block.thinking),
-                        signature: block.thinkingSignature,
-                    });
-                }
-                continue;
-            }
-            if (block.type === "toolCall") {
-                blocks.push({
-                    type: "tool_use",
-                    id: block.id,
-                    name: this.oauthMode ? ClaudeCodeNameCodec.encode(block.name) : block.name,
-                    input: block.arguments,
-                });
-            }
-        }
-        if (blocks.length === 0) {
-            return undefined;
-        }
-        return {
-            role: "assistant",
-            content: blocks,
-        };
-    }
-    composeToolResultBatch(messages, startIndex) {
-        const toolResults = [];
-        const first = messages[startIndex];
-        toolResults.push({
-            type: "tool_result",
-            tool_use_id: first.toolCallId,
-            content: convertContentBlocks(first.content),
-            is_error: first.isError,
-        });
-        let cursor = startIndex + 1;
-        while (cursor < messages.length && messages[cursor].role === "toolResult") {
-            const next = messages[cursor];
-            toolResults.push({
-                type: "tool_result",
-                tool_use_id: next.toolCallId,
-                content: convertContentBlocks(next.content),
-                is_error: next.isError,
-            });
-            cursor++;
-        }
-        return {
-            param: { role: "user", content: toolResults },
-            nextIndex: cursor - 1,
-        };
-    }
-}
-class AnthropicToolMapper {
-    oauthMode;
-    constructor(oauthMode) {
-        this.oauthMode = oauthMode;
-    }
-    map(tools) {
-        if (!tools)
-            return [];
-        return tools.map((tool) => {
-            const jsonSchema = tool.parameters;
-            return {
-                name: this.oauthMode ? ClaudeCodeNameCodec.encode(tool.name) : tool.name,
-                description: tool.description,
-                input_schema: {
-                    type: "object",
-                    properties: jsonSchema.properties || {},
-                    required: jsonSchema.required || [],
-                },
-            };
-        });
-    }
-}
-function applyCacheControlToLatestUserMessage(params) {
-    if (params.length === 0)
-        return;
-    const lastMessage = params[params.length - 1];
-    if (lastMessage.role !== "user")
-        return;
-    if (!Array.isArray(lastMessage.content))
-        return;
-    const lastBlock = lastMessage.content[lastMessage.content.length - 1];
-    if (!lastBlock)
-        return;
-    if (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result") {
-        lastBlock.cache_control = { type: "ephemeral" };
-    }
-}
-function convertMessages(messages, model, isOAuthToken) {
-    return new AnthropicMessageComposer(model, isOAuthToken).compose(messages);
-}
-function convertTools(tools, isOAuthToken) {
-    return new AnthropicToolMapper(isOAuthToken).map(tools);
-}
-function mapStopReason(reason) {
-    switch (reason) {
-        case "end_turn":
-            return "stop";
-        case "max_tokens":
-            return "length";
-        case "tool_use":
-            return "toolUse";
-        case "refusal":
-            return "error";
-        case "pause_turn": // Stop is good enough -> resubmit
-            return "stop";
-        case "stop_sequence":
-            return "stop"; // We don't supply stop sequences, so this should never happen
-        default:
-            return "stop";
-    }
-}
-//# sourceMappingURL=anthropic.js.map