copillm 0.1.0

package/dist/translation/openaiAnthropic.js

@@ -0,0 +1,391 @@
+import { createHash } from "node:crypto";
+export class ProtocolTranslationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ProtocolTranslationError";
+        this.code = code;
+    }
+}
+export function anthropicToOpenAI(body) {
+    const request = parseAnthropicRequest(body);
+    const messages = [];
+    const systemText = translateSystemToText(request.system);
+    if (systemText !== null) {
+        messages.push({ role: "system", content: systemText });
+    }
+    for (const message of request.messages) {
+        messages.push(...translateAnthropicMessage(message));
+    }
+    const translated = {
+        model: request.model,
+        messages,
+        max_tokens: request.max_tokens ?? 1024
+    };
+    if (request.temperature !== undefined) {
+        translated.temperature = request.temperature;
+    }
+    if (request.stream !== undefined) {
+        translated.stream = request.stream;
+    }
+    if (request.tools && request.tools.length > 0) {
+        translated.tools = request.tools.map(translateToolDefinition);
+    }
+    if (request.tool_choice) {
+        translated.tool_choice = translateToolChoice(request.tool_choice);
+    }
+    return translated;
+}
+export function openAIToAnthropic(body) {
+    const payload = parseOpenAIResponse(body);
+    if (payload.choices.length !== 1) {
+        throw new ProtocolTranslationError("unsupported_multiple_choices", "OpenAI response has multiple choices; Anthropic response translation requires exactly one choice.");
+    }
+    const [choice] = payload.choices;
+    if (!choice.message) {
+        throw new ProtocolTranslationError("missing_choice_message", "OpenAI response choice is missing message content.");
+    }
+    const messageBlocks = translateOpenAIMessageBlocks(choice.message);
+    return {
+        id: deriveAnthropicMessageId(payload.id, payload),
+        type: "message",
+        role: "assistant",
+        model: payload.model,
+        content: messageBlocks,
+        stop_reason: mapFinishReason(choice.finish_reason),
+        stop_sequence: null,
+        usage: {
+            input_tokens: payload.usage?.prompt_tokens ?? 0,
+            output_tokens: payload.usage?.completion_tokens ?? 0,
+            cache_read_input_tokens: payload.usage?.prompt_tokens_details?.cached_tokens ?? 0
+        }
+    };
+}
+/**
+ * The `[1m]` suffix copillm appends to advertised model ids in
+ * `/anthropic/v1/models` so Claude Code unlocks its 1M-class autocompact
+ * budget for >=1M-context models. Upstream Copilot has never heard of the
+ * suffix and must always see the canonical id, so we strip it from any
+ * incoming request body before validation or translation. See
+ * `applyOneMillionAlias()` in `src/server/anthropicModelsResponse.ts`.
+ */
+export const ONE_M_ALIAS_SUFFIX = "[1m]";
+export function stripOneMillionAlias(model) {
+    return model.endsWith(ONE_M_ALIAS_SUFFIX)
+        ? model.slice(0, model.length - ONE_M_ALIAS_SUFFIX.length)
+        : model;
+}
+function parseAnthropicRequest(body) {
+    if (!isObject(body)) {
+        throw new ProtocolTranslationError("invalid_request", "Anthropic request body must be an object.");
+    }
+    if (typeof body.model !== "string" || body.model.length === 0) {
+        throw new ProtocolTranslationError("invalid_model", "Anthropic request model must be a non-empty string.");
+    }
+    const normalisedModel = stripOneMillionAlias(body.model);
+    if (normalisedModel.length === 0) {
+        throw new ProtocolTranslationError("invalid_model", "Anthropic request model must be a non-empty string.");
+    }
+    if (!Array.isArray(body.messages)) {
+        throw new ProtocolTranslationError("invalid_messages", "Anthropic request messages must be an array.");
+    }
+    const parsed = {
+        model: normalisedModel,
+        messages: body.messages
+    };
+    if (body.system !== undefined) {
+        parsed.system = body.system;
+    }
+    if (body.max_tokens !== undefined) {
+        parsed.max_tokens = body.max_tokens;
+    }
+    if (body.temperature !== undefined) {
+        parsed.temperature = body.temperature;
+    }
+    if (body.stream !== undefined) {
+        parsed.stream = body.stream;
+    }
+    if (body.tools !== undefined) {
+        parsed.tools = body.tools;
+    }
+    if (body.tool_choice !== undefined) {
+        parsed.tool_choice = body.tool_choice;
+    }
+    return parsed;
+}
+function parseOpenAIResponse(body) {
+    if (!isObject(body)) {
+        throw new ProtocolTranslationError("invalid_response", "OpenAI response body must be an object.");
+    }
+    if (!Array.isArray(body.choices)) {
+        throw new ProtocolTranslationError("missing_choices", "OpenAI response choices must be an array.");
+    }
+    const parsed = {
+        ...body,
+        choices: body.choices
+    };
+    return parsed;
+}
+function translateSystemToText(system) {
+    if (system === undefined) {
+        return null;
+    }
+    if (typeof system === "string") {
+        return system;
+    }
+    if (!Array.isArray(system)) {
+        throw new ProtocolTranslationError("invalid_system", "Anthropic system prompt must be a string or text blocks.");
+    }
+    return joinTextBlocks(system, "Anthropic system prompt");
+}
+function translateAnthropicMessage(message) {
+    if (message.role !== "assistant" && message.role !== "user") {
+        throw new ProtocolTranslationError("unsupported_message_role", `Unsupported Anthropic message role: ${String(message.role)}.`);
+    }
+    if (typeof message.content === "string") {
+        return [{ role: message.role, content: message.content }];
+    }
+    if (!Array.isArray(message.content)) {
+        throw new ProtocolTranslationError("invalid_message_content", "Anthropic message content must be a string or array.");
+    }
+    return message.role === "assistant"
+        ? translateAssistantMessageBlocks(message.content)
+        : translateUserMessageBlocks(message.content);
+}
+function translateAssistantMessageBlocks(blocks) {
+    const textSegments = [];
+    const toolCalls = [];
+    for (const block of blocks) {
+        if (!isObject(block) || typeof block.type !== "string") {
+            throw new ProtocolTranslationError("invalid_block", "Anthropic assistant message contains an invalid content block.");
+        }
+        if (block.type === "text") {
+            if (typeof block.text !== "string") {
+                throw new ProtocolTranslationError("invalid_text_block", "Anthropic text block must include string text.");
+            }
+            textSegments.push(block.text);
+            continue;
+        }
+        if (block.type === "tool_use") {
+            if (typeof block.id !== "string" || typeof block.name !== "string") {
+                throw new ProtocolTranslationError("invalid_tool_use", "Anthropic tool_use block requires id and name.");
+            }
+            toolCalls.push({
+                id: block.id,
+                type: "function",
+                function: {
+                    name: block.name,
+                    arguments: JSON.stringify(block.input ?? {})
+                }
+            });
+            continue;
+        }
+        if (block.type === "tool_result") {
+            throw new ProtocolTranslationError("invalid_tool_result_role", "Anthropic tool_result blocks are only supported in user messages.");
+        }
+        throw new ProtocolTranslationError("unsupported_block", `Unsupported Anthropic assistant block type: ${block.type}.`);
+    }
+    return [
+        {
+            role: "assistant",
+            content: textSegments.length > 0 ? textSegments.join("\n") : null,
+            ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {})
+        }
+    ];
+}
+function translateUserMessageBlocks(blocks) {
+    const translated = [];
+    const textSegments = [];
+    const flushText = () => {
+        if (textSegments.length > 0) {
+            translated.push({ role: "user", content: textSegments.join("\n") });
+            textSegments.length = 0;
+        }
+    };
+    for (const block of blocks) {
+        if (!isObject(block) || typeof block.type !== "string") {
+            throw new ProtocolTranslationError("invalid_block", "Anthropic user message contains an invalid content block.");
+        }
+        if (block.type === "text") {
+            if (typeof block.text !== "string") {
+                throw new ProtocolTranslationError("invalid_text_block", "Anthropic text block must include string text.");
+            }
+            textSegments.push(block.text);
+            continue;
+        }
+        if (block.type === "tool_result") {
+            if (typeof block.tool_use_id !== "string" || block.tool_use_id.length === 0) {
+                throw new ProtocolTranslationError("invalid_tool_result", "Anthropic tool_result requires non-empty tool_use_id.");
+            }
+            flushText();
+            const rawContent = translateToolResultContent(block.content);
+            const content = block.is_error ? `[tool_error] ${rawContent}` : rawContent;
+            translated.push({
+                role: "tool",
+                tool_call_id: block.tool_use_id,
+                content
+            });
+            continue;
+        }
+        if (block.type === "tool_use") {
+            throw new ProtocolTranslationError("invalid_tool_use_role", "Anthropic tool_use blocks are only supported in assistant messages.");
+        }
+        throw new ProtocolTranslationError("unsupported_block", `Unsupported Anthropic user block type: ${block.type}.`);
+    }
+    flushText();
+    if (translated.length === 0) {
+        translated.push({ role: "user", content: "" });
+    }
+    return translated;
+}
+function translateToolResultContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        throw new ProtocolTranslationError("invalid_tool_result_content", "Anthropic tool_result content must be string or text blocks.");
+    }
+    return joinTextBlocks(content, "Anthropic tool_result content");
+}
+function translateToolDefinition(tool) {
+    if (!isObject(tool) || typeof tool.name !== "string" || tool.name.length === 0) {
+        throw new ProtocolTranslationError("invalid_tool_definition", "Anthropic tool definitions require a non-empty name.");
+    }
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            ...(typeof tool.description === "string" ? { description: tool.description } : {}),
+            parameters: isObject(tool.input_schema) ? tool.input_schema : { type: "object", properties: {} }
+        }
+    };
+}
+function translateToolChoice(toolChoice) {
+    if (!isObject(toolChoice) || typeof toolChoice.type !== "string") {
+        throw new ProtocolTranslationError("invalid_tool_choice", "Anthropic tool_choice must be an object with a type.");
+    }
+    switch (toolChoice.type) {
+        case "auto":
+            return "auto";
+        case "any":
+            return "required";
+        case "tool":
+            if (typeof toolChoice.name !== "string" || toolChoice.name.length === 0) {
+                throw new ProtocolTranslationError("invalid_tool_choice", "Anthropic tool_choice.type=tool requires a name.");
+            }
+            return {
+                type: "function",
+                function: {
+                    name: toolChoice.name
+                }
+            };
+        case "none":
+            return "none";
+        default:
+            throw new ProtocolTranslationError("unsupported_tool_choice", `Unsupported Anthropic tool_choice type: ${toolChoice.type}.`);
+    }
+}
+function joinTextBlocks(blocks, contextLabel) {
+    return blocks
+        .map((block) => {
+        if (!isObject(block) || block.type !== "text" || typeof block.text !== "string") {
+            throw new ProtocolTranslationError("unsupported_block", `${contextLabel} only supports text blocks.`);
+        }
+        return block.text;
+    })
+        .join("\n");
+}
+function translateOpenAIMessageBlocks(message) {
+    if (message.role !== undefined && message.role !== "assistant") {
+        throw new ProtocolTranslationError("unsupported_message_role", `OpenAI response message role ${String(message.role)} cannot be translated to Anthropic assistant response.`);
+    }
+    const blocks = [];
+    blocks.push(...translateOpenAIContentToAnthropicBlocks(message.content));
+    if (message.tool_calls !== undefined) {
+        if (!Array.isArray(message.tool_calls)) {
+            throw new ProtocolTranslationError("invalid_tool_calls", "OpenAI tool_calls must be an array when present.");
+        }
+        for (const toolCall of message.tool_calls) {
+            if (!isObject(toolCall) || typeof toolCall.id !== "string" || !isObject(toolCall.function)) {
+                throw new ProtocolTranslationError("invalid_tool_call", "OpenAI tool_call is missing id/function fields.");
+            }
+            if (toolCall.type !== "function") {
+                throw new ProtocolTranslationError("unsupported_tool_call", "Only OpenAI function tool calls are supported.");
+            }
+            if (typeof toolCall.function.name !== "string") {
+                throw new ProtocolTranslationError("invalid_tool_call", "OpenAI tool_call.function.name must be a string.");
+            }
+            if (typeof toolCall.function.arguments !== "string") {
+                throw new ProtocolTranslationError("invalid_tool_call", "OpenAI tool_call.function.arguments must be a string.");
+            }
+            blocks.push({
+                type: "tool_use",
+                id: toolCall.id,
+                name: toolCall.function.name,
+                input: parseToolArguments(toolCall.function.arguments)
+            });
+        }
+    }
+    return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
+}
+function translateOpenAIContentToAnthropicBlocks(content) {
+    if (typeof content === "string") {
+        return content.length > 0 ? [{ type: "text", text: content }] : [];
+    }
+    if (content == null) {
+        return [];
+    }
+    if (!Array.isArray(content)) {
+        throw new ProtocolTranslationError("unsupported_content_shape", "OpenAI message content must be a string, null, or an array of content parts.");
+    }
+    const blocks = [];
+    for (const part of content) {
+        if (!isObject(part) || part.type !== "text" || typeof part.text !== "string") {
+            throw new ProtocolTranslationError("unsupported_content_part", "Only OpenAI text content parts are supported in Anthropic response translation.");
+        }
+        blocks.push({ type: "text", text: part.text });
+    }
+    return blocks;
+}
+function parseToolArguments(argumentsRaw) {
+    try {
+        return JSON.parse(argumentsRaw);
+    }
+    catch {
+        throw new ProtocolTranslationError("invalid_tool_arguments", "OpenAI tool call arguments must be valid JSON.");
+    }
+}
+function mapFinishReason(reason) {
+    if (reason == null) {
+        return null;
+    }
+    switch (reason) {
+        case "stop":
+            return "end_turn";
+        case "length":
+            return "max_tokens";
+        case "tool_calls":
+        case "function_call":
+            return "tool_use";
+        case "content_filter":
+            return "refusal";
+        default:
+            throw new ProtocolTranslationError("unsupported_finish_reason", `Unsupported OpenAI finish_reason: ${reason}.`);
+    }
+}
+function deriveAnthropicMessageId(openAIId, payload) {
+    const base = typeof openAIId === "string" && openAIId.length > 0
+        ? openAIId
+        : stableHash(JSON.stringify({ model: payload.model ?? "", choices: payload.choices ?? [] }));
+    const normalized = base.replace(/[^a-zA-Z0-9_-]/g, "");
+    if (normalized.startsWith("msg_")) {
+        return normalized;
+    }
+    return `msg_${normalized || stableHash(base)}`;
+}
+function stableHash(value) {
+    return createHash("sha1").update(value).digest("hex").slice(0, 24);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/translation/streamingOpenAIToAnthropic.js

@@ -0,0 +1,290 @@
+import { randomUUID } from "node:crypto";
+const PING_INTERVAL_MS = 1000;
+export async function translateOpenAIStreamToAnthropic(options) {
+    const { upstream, downstream } = options;
+    upstream.setEncoding("utf8");
+    let buffer = "";
+    let messageStarted = options.preEmittedMessageId !== undefined;
+    let messageId = options.preEmittedMessageId ?? null;
+    let modelName = options.fallbackModel ?? "";
+    let role = "assistant";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let stopReason = null;
+    const activeBlocks = new Map();
+    let nextAnthropicIndex = 0;
+    let streamErrored = false;
+    let pingTimer = null;
+    function startPings() {
+        if (pingTimer !== null) {
+            return;
+        }
+        pingTimer = setInterval(() => {
+            writeEvent("ping", { type: "ping" });
+        }, PING_INTERVAL_MS);
+        if (typeof pingTimer.unref === "function") {
+            pingTimer.unref();
+        }
+    }
+    function stopPings() {
+        if (pingTimer !== null) {
+            clearInterval(pingTimer);
+            pingTimer = null;
+        }
+    }
+    function writeEvent(eventName, data) {
+        downstream.write(`event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`);
+    }
+    function emitMessageStart() {
+        if (messageStarted) {
+            return;
+        }
+        messageStarted = true;
+        if (!messageId) {
+            messageId = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+        }
+        writeEvent("message_start", {
+            type: "message_start",
+            message: {
+                id: messageId,
+                type: "message",
+                role,
+                content: [],
+                model: modelName,
+                stop_reason: null,
+                stop_sequence: null,
+                usage: {
+                    input_tokens: inputTokens,
+                    cache_read_input_tokens: cacheReadTokens,
+                    output_tokens: 0
+                }
+            }
+        });
+    }
+    function ensureTextBlock() {
+        const existing = activeBlocks.get("text");
+        if (existing) {
+            return existing.anthropicIndex;
+        }
+        const index = nextAnthropicIndex;
+        nextAnthropicIndex += 1;
+        writeEvent("content_block_start", {
+            type: "content_block_start",
+            index,
+            content_block: { type: "text", text: "" }
+        });
+        activeBlocks.set("text", { anthropicIndex: index, kind: "text" });
+        return index;
+    }
+    function ensureToolBlock(toolIndex, id, name) {
+        const key = `tool:${toolIndex}`;
+        const existing = activeBlocks.get(key);
+        if (existing) {
+            return existing.anthropicIndex;
+        }
+        const textBlock = activeBlocks.get("text");
+        if (textBlock) {
+            writeEvent("content_block_stop", { type: "content_block_stop", index: textBlock.anthropicIndex });
+            activeBlocks.delete("text");
+        }
+        const index = nextAnthropicIndex;
+        nextAnthropicIndex += 1;
+        writeEvent("content_block_start", {
+            type: "content_block_start",
+            index,
+            content_block: { type: "tool_use", id, name, input: {} }
+        });
+        activeBlocks.set(key, { anthropicIndex: index, kind: "tool_use" });
+        return index;
+    }
+    function closeAllBlocks() {
+        const ordered = Array.from(activeBlocks.values()).sort((a, b) => a.anthropicIndex - b.anthropicIndex);
+        for (const block of ordered) {
+            writeEvent("content_block_stop", { type: "content_block_stop", index: block.anthropicIndex });
+        }
+        activeBlocks.clear();
+    }
+    function processChunk(parsed) {
+        if (parsed.id && !messageId) {
+            messageId = `msg_${parsed.id}`;
+        }
+        if (parsed.model && !modelName) {
+            modelName = parsed.model;
+        }
+        if (parsed.usage) {
+            if (typeof parsed.usage.prompt_tokens === "number") {
+                inputTokens = parsed.usage.prompt_tokens;
+            }
+            if (typeof parsed.usage.completion_tokens === "number") {
+                outputTokens = parsed.usage.completion_tokens;
+            }
+            const cached = parsed.usage.prompt_tokens_details?.cached_tokens;
+            if (typeof cached === "number") {
+                cacheReadTokens = cached;
+            }
+        }
+        const choice = parsed.choices?.[0];
+        if (!choice) {
+            return;
+        }
+        if (choice.delta?.role && typeof choice.delta.role === "string") {
+            role = choice.delta.role;
+        }
+        emitMessageStart();
+        const delta = choice.delta;
+        if (delta && typeof delta.content === "string" && delta.content.length > 0) {
+            const index = ensureTextBlock();
+            writeEvent("content_block_delta", {
+                type: "content_block_delta",
+                index,
+                delta: { type: "text_delta", text: delta.content }
+            });
+        }
+        if (delta && Array.isArray(delta.tool_calls)) {
+            for (const toolCall of delta.tool_calls) {
+                const toolIndex = typeof toolCall.index === "number" ? toolCall.index : 0;
+                const key = `tool:${toolIndex}`;
+                let blockIndex = null;
+                if (!activeBlocks.has(key)) {
+                    const id = typeof toolCall.id === "string" ? toolCall.id : "";
+                    const name = typeof toolCall.function?.name === "string" ? toolCall.function.name : "";
+                    if (id.length === 0 || name.length === 0) {
+                        continue;
+                    }
+                    blockIndex = ensureToolBlock(toolIndex, id, name);
+                }
+                else {
+                    blockIndex = activeBlocks.get(key).anthropicIndex;
+                }
+                const args = toolCall.function?.arguments;
+                if (typeof args === "string" && args.length > 0) {
+                    writeEvent("content_block_delta", {
+                        type: "content_block_delta",
+                        index: blockIndex,
+                        delta: { type: "input_json_delta", partial_json: args }
+                    });
+                }
+            }
+        }
+        if (typeof choice.finish_reason === "string" && choice.finish_reason.length > 0) {
+            stopReason = mapFinishReason(choice.finish_reason);
+        }
+    }
+    function processLine(line) {
+        if (line.length === 0) {
+            return;
+        }
+        if (!line.startsWith("data:")) {
+            return;
+        }
+        const payload = line.slice(5).trim();
+        if (payload.length === 0) {
+            return;
+        }
+        if (payload === "[DONE]") {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(payload);
+        }
+        catch {
+            return;
+        }
+        processChunk(parsed);
+    }
+    emitMessageStart();
+    startPings();
+    try {
+        for await (const chunk of upstream) {
+            const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+            buffer += text;
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf("\n")) >= 0) {
+                const rawLine = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+                buffer = buffer.slice(newlineIndex + 1);
+                processLine(rawLine);
+            }
+        }
+        if (buffer.length > 0) {
+            processLine(buffer.replace(/\r$/, ""));
+            buffer = "";
+        }
+    }
+    catch (error) {
+        streamErrored = true;
+        stopPings();
+        emitMessageStart();
+        closeAllBlocks();
+        writeEvent("message_delta", {
+            type: "message_delta",
+            delta: { stop_reason: "end_turn", stop_sequence: null },
+            usage: { input_tokens: inputTokens, output_tokens: outputTokens, cache_read_input_tokens: cacheReadTokens }
+        });
+        writeEvent("error", {
+            type: "error",
+            error: { type: "api_error", message: error instanceof Error ? error.message : "upstream stream error" }
+        });
+        writeEvent("message_stop", { type: "message_stop" });
+        downstream.end();
+        return;
+    }
+    if (streamErrored) {
+        return;
+    }
+    stopPings();
+    emitMessageStart();
+    closeAllBlocks();
+    writeEvent("message_delta", {
+        type: "message_delta",
+        delta: { stop_reason: stopReason ?? "end_turn", stop_sequence: null },
+        usage: { input_tokens: inputTokens, output_tokens: outputTokens, cache_read_input_tokens: cacheReadTokens }
+    });
+    writeEvent("message_stop", { type: "message_stop" });
+    downstream.end();
+}
+/**
+ * Write the Anthropic `message_start` event (and an initial ping) to the
+ * downstream SSE response immediately, before we begin awaiting the upstream
+ * Copilot response. This makes Claude Code render the assistant turn frame
+ * within milliseconds of the request, instead of waiting the full ~2s of
+ * upstream first-token latency before seeing any sign of life.
+ *
+ * The returned `messageId` MUST be passed to translateOpenAIStreamToAnthropic
+ * via `preEmittedMessageId` so it doesn't double-emit `message_start`.
+ */
+export function writeAnthropicPrelude(downstream, model) {
+    const messageId = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+    const messageStart = {
+        type: "message_start",
+        message: {
+            id: messageId,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, cache_read_input_tokens: 0, output_tokens: 0 }
+        }
+    };
+    downstream.write(`event: message_start\ndata: ${JSON.stringify(messageStart)}\n\n`);
+    downstream.write(`event: ping\ndata: ${JSON.stringify({ type: "ping" })}\n\n`);
+    return { messageId };
+}
+function mapFinishReason(reason) {
+    switch (reason) {
+        case "stop":
+            return "end_turn";
+        case "length":
+            return "max_tokens";
+        case "tool_calls":
+        case "function_call":
+            return "tool_use";
+        case "content_filter":
+            return "end_turn";
+        default:
+            return "end_turn";
+    }
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};