@oneuptime/common 11.3.25 → 11.3.28

package/build/dist/Server/Utils/LLM/LLMService.js

@@ -9,6 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
 import URL from "../../../Types/API/URL";
+import JSONFunctions from "../../../Types/JSONFunctions";
 import API from "../../../Utils/API";
 import LlmType from "../../../Types/LLM/LlmType";
 import BadDataException from "../../../Types/Exception/BadDataException";
@@ -21,6 +22,7 @@ class LLMService {
             case LlmType.OpenAI:
             case LlmType.Groq:
             case LlmType.Mistral:
+            case LlmType.OpenAICompatible:
                 return await this.getOpenAICompatibleCompletion(config, request);
             case LlmType.AzureOpenAI:
                 return await this.getAzureOpenAICompletion(config, request);
@@ -32,11 +34,227 @@ class LLMService {
                 throw new BadDataException(`Unsupported LLM type: ${config.llmType}`);
         }
     }
-    static async getOpenAICompatibleCompletion(config, request) {
+    /*
+     * OpenAI-compatible wire format (OpenAI, Groq, Mistral, Azure OpenAI).
+     */
+    static toOpenAIMessages(messages) {
+        return messages.map((msg) => {
+            if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length) {
+                return {
+                    role: "assistant",
+                    content: msg.content || null,
+                    tool_calls: msg.toolCalls.map((toolCall) => {
+                        return {
+                            id: toolCall.id,
+                            type: "function",
+                            function: {
+                                name: toolCall.name,
+                                arguments: JSON.stringify(toolCall.arguments),
+                            },
+                        };
+                    }),
+                };
+            }
+            if (msg.role === "tool") {
+                return {
+                    role: "tool",
+                    tool_call_id: msg.toolCallId || "",
+                    content: msg.content,
+                };
+            }
+            return {
+                role: msg.role,
+                content: msg.content,
+            };
+        });
+    }
+    static toOpenAITools(tools) {
+        return tools.map((tool) => {
+            return {
+                type: "function",
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.inputSchema,
+                },
+            };
+        });
+    }
+    static parseOpenAIToolCalls(message) {
+        const rawToolCalls = message["tool_calls"];
+        if (!rawToolCalls || rawToolCalls.length === 0) {
+            return undefined;
+        }
+        return rawToolCalls.map((rawToolCall, index) => {
+            const fn = rawToolCall["function"] || {};
+            const parsed = this.parseToolCallArguments(fn["arguments"] || "{}");
+            return {
+                id: rawToolCall["id"] || `tool_call_${index}`,
+                name: fn["name"] || "",
+                arguments: parsed.arguments,
+                argumentsParseError: parsed.error,
+            };
+        });
+    }
+    /*
+     * Models sometimes emit slightly malformed argument JSON (trailing commas,
+     * single quotes). Try strict JSON first, then tolerant JSON5, and report a
+     * parse error instead of silently executing with empty arguments.
+     */
+    static parseToolCallArguments(rawArguments) {
+        try {
+            return { arguments: JSON.parse(rawArguments) };
+        }
+        catch (_a) {
+            // fall through to tolerant parsing
+        }
+        try {
+            const parsed = JSONFunctions.parse(rawArguments);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return { arguments: parsed };
+            }
+            return {
+                arguments: {},
+                error: "Tool arguments were not a JSON object.",
+            };
+        }
+        catch (_b) {
+            return {
+                arguments: {},
+                error: "Tool arguments were malformed JSON and could not be parsed.",
+            };
+        }
+    }
+    static buildOpenAIRequestBody(modelName, request) {
         var _a;
-        if (!config.apiKey) {
+        const data = {
+            model: modelName,
+            messages: this.toOpenAIMessages(request.messages),
+            temperature: (_a = request.temperature) !== null && _a !== void 0 ? _a : 0.7,
+        };
+        if (request.maxTokens) {
+            data["max_tokens"] = request.maxTokens;
+        }
+        if (request.tools && request.tools.length > 0) {
+            data["tools"] = this.toOpenAITools(request.tools);
+        }
+        return data;
+    }
+    static parseOpenAIResponse(jsonData, providerName) {
+        var _a;
+        const choices = jsonData["choices"];
+        if (!choices || choices.length === 0) {
+            throw new BadDataException(`No response from ${providerName}`);
+        }
+        const message = choices[0]["message"];
+        const usage = jsonData["usage"];
+        const toolCalls = this.parseOpenAIToolCalls(message);
+        /*
+         * OpenAI (and Azure OpenAI) automatically cache a stable prompt prefix
+         * once it is long enough and report the cache hit under
+         * prompt_tokens_details.cached_tokens — surface it for cost visibility.
+         */
+        const cachedTokens = usage
+            ? (_a = usage["prompt_tokens_details"]) === null || _a === void 0 ? void 0 : _a["cached_tokens"]
+            : undefined;
+        return {
+            content: message["content"] || "",
+            toolCalls: toolCalls,
+            stopReason: toolCalls && toolCalls.length > 0 ? "tool_use" : "stop",
+            usage: usage
+                ? {
+                    promptTokens: usage["prompt_tokens"],
+                    completionTokens: usage["completion_tokens"],
+                    totalTokens: usage["total_tokens"],
+                    cachedInputTokens: cachedTokens || undefined,
+                }
+                : undefined,
+        };
+    }
+    /*
+     * Build the chat completions URL for an OpenAI-compatible server from the
+     * configured base URL. Users enter the base URL in a few different ways, and
+     * we normalize all of them onto the right endpoint instead of 404-ing:
+     *
+     *   - Already a full endpoint (".../chat/completions") -> used as-is.
+     *   - Includes a path (".../v1", ".../openai/v1") -> append "/chat/completions".
+     *   - Bare server root ("http://host:8000") -> append "/v1/chat/completions",
+     *     since vLLM, LocalAI and similar servers expose the OpenAI-compatible API
+     *     under /v1 by default. This is the most common self-hosted setup and the
+     *     easiest one for users to get wrong (omitting /v1 returns FastAPI's
+     *     {"detail":"Not Found"}).
+     *
+     * The endpoint segment is only ever appended to the PATH portion: any
+     * ?query or #fragment on the base URL is split off first and re-attached
+     * afterwards (otherwise "/chat/completions" would land inside the query or
+     * fragment). Trailing slashes are stripped so we never emit
+     * ".../v1//chat/completions", and the URL scheme is lower-cased because URL
+     * schemes are case-insensitive but downstream URL parsing only recognizes
+     * lowercase http/https.
+     */
+    static buildOpenAICompatibleChatCompletionsUrl(baseUrl) {
+        const raw = baseUrl.trim();
+        // Split off #fragment, then ?query, so we can operate on the path alone.
+        const fragmentIndex = raw.indexOf("#");
+        const fragment = fragmentIndex >= 0 ? raw.substring(fragmentIndex) : "";
+        const withoutFragment = fragmentIndex >= 0 ? raw.substring(0, fragmentIndex) : raw;
+        const queryIndex = withoutFragment.indexOf("?");
+        const query = queryIndex >= 0 ? withoutFragment.substring(queryIndex) : "";
+        let base = queryIndex >= 0
+            ? withoutFragment.substring(0, queryIndex)
+            : withoutFragment;
+        /*
+         * Lower-case the scheme (e.g. "HTTP://" -> "http://") and strip trailing
+         * slashes.
+         */
+        const schemeRegex = /^[a-z][a-z0-9+.-]*:\/\//i;
+        base = base
+            .replace(schemeRegex, (scheme) => {
+            return scheme.toLowerCase();
+        })
+            .replace(/\/+$/, "");
+        let path;
+        const fullEndpointRegex = /\/chat\/completions$/i;
+        const hasPathAfterHostRegex = /^[a-z][a-z0-9+.-]*:\/\/[^/]+\/.+/i;
+        if (fullEndpointRegex.test(base)) {
+            // The user already pointed us at the full endpoint.
+            path = base;
+        }
+        else if (hasPathAfterHostRegex.test(base)) {
+            /*
+             * The base URL carries a path after the host[:port] (e.g.
+             * "http://host:8000/v1" or ".../openai/v1") — trust it and only append
+             * the endpoint.
+             */
+            path = `${base}/chat/completions`;
+        }
+        else {
+            /*
+             * Bare server root ("http://host:8000") — add the conventional /v1
+             * prefix that OpenAI-compatible servers (vLLM, LocalAI, ...) use.
+             */
+            path = `${base}/v1/chat/completions`;
+        }
+        return `${path}${query}${fragment}`;
+    }
+    static async getOpenAICompatibleCompletion(config, request) {
+        /*
+         * Generic OpenAI-compatible servers (vLLM, LocalAI, etc.) are usually
+         * self-hosted, frequently keyless, and have no canonical endpoint or
+         * default model — so the API key is optional but the base URL and model
+         * name must be provided. The hosted providers (OpenAI, Groq, Mistral)
+         * keep requiring a key and fall back to sensible defaults.
+         */
+        const isGenericOpenAICompatible = config.llmType === LlmType.OpenAICompatible;
+        if (!isGenericOpenAICompatible && !config.apiKey) {
             throw new BadDataException(`${config.llmType} API key is required`);
         }
+        if (isGenericOpenAICompatible && !config.baseUrl) {
+            throw new BadDataException("Base URL is required for OpenAI-compatible providers (e.g. http://your-vllm-server:8000/v1)");
+        }
+        if (isGenericOpenAICompatible && !config.modelName) {
+            throw new BadDataException("Model Name is required for OpenAI-compatible providers. It must match a model your server exposes.");
+        }
         const defaultBaseUrls = {
             [LlmType.OpenAI]: "https://api.openai.com/v1",
             [LlmType.Groq]: "https://api.groq.com/openai/v1",
@@ -52,21 +270,11 @@ class LLMService {
             "https://api.openai.com/v1";
         const modelName = config.modelName || defaultModels[config.llmType] || "gpt-4o";
         const response = await API.post({
-            url: URL.fromString(`${baseUrl}/chat/completions`),
-            data: {
-                model: modelName,
-                messages: request.messages.map((msg) => {
-                    return {
-                        role: msg.role,
-                        content: msg.content,
-                    };
-                }),
-                temperature: (_a = request.temperature) !== null && _a !== void 0 ? _a : 0.7,
-            },
-            headers: {
-                Authorization: `Bearer ${config.apiKey}`,
-                "Content-Type": "application/json",
-            },
+            url: URL.fromString(this.buildOpenAICompatibleChatCompletionsUrl(baseUrl)),
+            data: this.buildOpenAIRequestBody(modelName, request),
+            headers: Object.assign({ "Content-Type": "application/json" }, (config.apiKey
+                ? { Authorization: `Bearer ${config.apiKey}` }
+                : {})),
             options: {
                 retries: 2,
                 exponentialBackoff: true,
@@ -82,23 +290,7 @@ class LLMService {
             logger.error(response, logAttributes);
             throw new BadDataException(`${config.llmType} API error: ${JSON.stringify(response.jsonData)}`);
         }
-        const jsonData = response.jsonData;
-        const choices = jsonData["choices"];
-        if (!choices || choices.length === 0) {
-            throw new BadDataException(`No response from ${config.llmType}`);
-        }
-        const message = choices[0]["message"];
-        const usage = jsonData["usage"];
-        return {
-            content: message["content"],
-            usage: usage
-                ? {
-                    promptTokens: usage["prompt_tokens"],
-                    completionTokens: usage["completion_tokens"],
-                    totalTokens: usage["total_tokens"],
-                }
-                : undefined,
-        };
+        return this.parseOpenAIResponse(response.jsonData, config.llmType);
     }
     static buildAzureOpenAIChatCompletionsUrl(baseUrl) {
         const trimmed = baseUrl.replace(/\/+$/, "");
@@ -112,7 +304,6 @@ class LLMService {
         return `${pathPart}/chat/completions?${params.toString()}`;
     }
     static async getAzureOpenAICompletion(config, request) {
-        var _a;
         if (!config.apiKey) {
             throw new BadDataException("Azure OpenAI API key is required");
         }
@@ -123,16 +314,7 @@ class LLMService {
         const requestUrl = LLMService.buildAzureOpenAIChatCompletionsUrl(config.baseUrl);
         const response = await API.post({
             url: URL.fromString(requestUrl),
-            data: {
-                model: modelName,
-                messages: request.messages.map((msg) => {
-                    return {
-                        role: msg.role,
-                        content: msg.content,
-                    };
-                }),
-                temperature: (_a = request.temperature) !== null && _a !== void 0 ? _a : 0.7,
-            },
+            data: this.buildOpenAIRequestBody(modelName, request),
             headers: {
                 "api-key": config.apiKey,
                 "Content-Type": "application/json",
@@ -152,23 +334,83 @@ class LLMService {
             logger.error(response, logAttributes);
             throw new BadDataException(`Azure OpenAI API error: ${JSON.stringify(response.jsonData)}`);
         }
-        const jsonData = response.jsonData;
-        const choices = jsonData["choices"];
-        if (!choices || choices.length === 0) {
-            throw new BadDataException("No response from Azure OpenAI");
-        }
-        const message = choices[0]["message"];
-        const usage = jsonData["usage"];
-        return {
-            content: message["content"],
-            usage: usage
-                ? {
-                    promptTokens: usage["prompt_tokens"],
-                    completionTokens: usage["completion_tokens"],
-                    totalTokens: usage["total_tokens"],
+        return this.parseOpenAIResponse(response.jsonData, "Azure OpenAI");
+    }
+    static toAnthropicMessages(messages) {
+        const anthropicMessages = [];
+        for (const msg of messages) {
+            if (msg.role === "system") {
+                continue; // hoisted separately
+            }
+            if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length) {
+                const contentBlocks = [];
+                if (msg.content) {
+                    contentBlocks.push({ type: "text", text: msg.content });
                 }
-                : undefined,
-        };
+                for (const toolCall of msg.toolCalls) {
+                    contentBlocks.push({
+                        type: "tool_use",
+                        id: toolCall.id,
+                        name: toolCall.name,
+                        input: toolCall.arguments,
+                    });
+                }
+                anthropicMessages.push({ role: "assistant", content: contentBlocks });
+                continue;
+            }
+            if (msg.role === "tool") {
+                const toolResultBlock = {
+                    type: "tool_result",
+                    tool_use_id: msg.toolCallId || "",
+                    content: msg.content,
+                };
+                /*
+                 * Tool results must be user messages. Merge consecutive tool
+                 * results into one user message so roles keep alternating.
+                 */
+                const lastMessage = anthropicMessages[anthropicMessages.length - 1];
+                if (lastMessage &&
+                    lastMessage["role"] === "user" &&
+                    Array.isArray(lastMessage["content"])) {
+                    lastMessage["content"].push(toolResultBlock);
+                }
+                else {
+                    anthropicMessages.push({
+                        role: "user",
+                        content: [toolResultBlock],
+                    });
+                }
+                continue;
+            }
+            /*
+             * Anthropic requires strictly alternating user/assistant turns and
+             * returns a 400 on two consecutive same-role messages. The agent loop
+             * can legitimately emit back-to-back user turns (e.g. a tool_result
+             * user message immediately followed by the "budget exhausted, answer
+             * now" nudge), so coalesce a run of same-role messages into one instead
+             * of failing the whole request.
+             */
+            const previousMessage = anthropicMessages[anthropicMessages.length - 1];
+            if (previousMessage && previousMessage["role"] === msg.role) {
+                if (typeof previousMessage["content"] === "string") {
+                    previousMessage["content"] =
+                        `${previousMessage["content"]}\n\n${msg.content}`;
+                    continue;
+                }
+                if (Array.isArray(previousMessage["content"])) {
+                    previousMessage["content"].push({
+                        type: "text",
+                        text: msg.content,
+                    });
+                    continue;
+                }
+            }
+            anthropicMessages.push({
+                role: msg.role,
+                content: msg.content,
+            });
+        }
+        return anthropicMessages;
     }
     static async getAnthropicCompletion(config, request) {
         var _a;
@@ -177,27 +419,50 @@ class LLMService {
         }
         const baseUrl = config.baseUrl || "https://api.anthropic.com/v1";
         const modelName = config.modelName || "claude-sonnet-4-20250514";
-        // Anthropic requires system message to be separate
         let systemMessage = "";
-        const userMessages = [];
         for (const msg of request.messages) {
             if (msg.role === "system") {
                 systemMessage = msg.content;
             }
-            else {
-                userMessages.push({
-                    role: msg.role,
-                    content: msg.content,
-                });
-            }
         }
         const requestData = {
             model: modelName,
-            messages: userMessages,
+            messages: this.toAnthropicMessages(request.messages),
             temperature: (_a = request.temperature) !== null && _a !== void 0 ? _a : 0.7,
+            // Anthropic requires max_tokens on every request.
+            max_tokens: request.maxTokens || LLMService.ANTHROPIC_DEFAULT_MAX_TOKENS,
         };
+        /*
+         * Prompt caching. The system prompt and tool definitions are the large,
+         * stable prefix re-sent on every turn of the agent loop, so caching them is
+         * the biggest single cost + latency lever (cached input is billed at ~10%).
+         * An ephemeral cache_control breakpoint on the system block and on the LAST
+         * tool caches the whole system + tools prefix. cache_control is GA under
+         * anthropic-version 2023-06-01, so no beta header is required.
+         */
         if (systemMessage) {
-            requestData["system"] = systemMessage;
+            requestData["system"] = [
+                {
+                    type: "text",
+                    text: systemMessage,
+                    cache_control: { type: "ephemeral" },
+                },
+            ];
+        }
+        if (request.tools && request.tools.length > 0) {
+            const anthropicTools = request.tools.map((tool) => {
+                return {
+                    name: tool.name,
+                    description: tool.description,
+                    input_schema: tool.inputSchema,
+                };
+            });
+            // A breakpoint on the last tool caches the entire tools block before it.
+            const lastTool = anthropicTools[anthropicTools.length - 1];
+            if (lastTool) {
+                lastTool["cache_control"] = { type: "ephemeral" };
+            }
+            requestData["tools"] = anthropicTools;
         }
         const response = await API.post({
             url: URL.fromString(`${baseUrl}/messages`),
@@ -227,46 +492,94 @@ class LLMService {
         if (!content || content.length === 0) {
             throw new BadDataException("No response from Anthropic");
         }
-        const textContent = content.find((c) => {
-            return c["type"] === "text";
+        const textContent = content
+            .filter((block) => {
+            return block["type"] === "text";
+        })
+            .map((block) => {
+            return block["text"];
+        })
+            .join("");
+        const toolCalls = content
+            .filter((block) => {
+            return block["type"] === "tool_use";
+        })
+            .map((block) => {
+            return {
+                id: block["id"] || "",
+                name: block["name"] || "",
+                arguments: block["input"] || {},
+            };
         });
-        if (!textContent) {
+        if (!textContent && toolCalls.length === 0) {
             throw new BadDataException("No text content in Anthropic response");
         }
         const usage = jsonData["usage"];
         return {
-            content: textContent["text"],
+            content: textContent,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            stopReason: jsonData["stop_reason"] === "tool_use" ? "tool_use" : "stop",
             usage: usage
                 ? {
-                    promptTokens: usage["input_tokens"],
-                    completionTokens: usage["output_tokens"],
+                    promptTokens: usage["input_tokens"] || 0,
+                    completionTokens: usage["output_tokens"] || 0,
+                    /*
+                     * Anthropic reports cache-read and cache-creation input tokens
+                     * separately from input_tokens. Surface them and fold them into
+                     * totalTokens so the logged total reflects the full billable input.
+                     */
+                    cachedInputTokens: usage["cache_read_input_tokens"] || undefined,
+                    cacheCreationTokens: usage["cache_creation_input_tokens"] || undefined,
                     totalTokens: (usage["input_tokens"] || 0) +
+                        (usage["cache_read_input_tokens"] || 0) +
+                        (usage["cache_creation_input_tokens"] || 0) +
                         (usage["output_tokens"] || 0),
                 }
                 : undefined,
         };
     }
+    /*
+     * Ollama native /api/chat. Deliberately NOT routed through the
+     * OpenAI-compatible branch: Ollama deployments are keyless by design and
+     * the OpenAI branch requires an API key.
+     */
     static async getOllamaCompletion(config, request) {
         var _a;
         if (!config.baseUrl) {
             throw new BadDataException("Ollama base URL is required");
         }
         const modelName = config.modelName || "llama2";
-        const response = await API.post({
-            url: URL.fromString(`${config.baseUrl}/api/chat`),
-            data: {
-                model: modelName,
-                messages: request.messages.map((msg) => {
+        const requestData = {
+            model: modelName,
+            messages: request.messages.map((msg) => {
+                if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length) {
                     return {
-                        role: msg.role,
-                        content: msg.content,
+                        role: "assistant",
+                        content: msg.content || "",
+                        tool_calls: msg.toolCalls.map((toolCall) => {
+                            return {
+                                function: {
+                                    name: toolCall.name,
+                                    arguments: toolCall.arguments,
+                                },
+                            };
+                        }),
                     };
-                }),
-                stream: false,
-                options: {
-                    temperature: (_a = request.temperature) !== null && _a !== void 0 ? _a : 0.7,
-                },
-            },
+                }
+                return {
+                    role: msg.role,
+                    content: msg.content,
+                };
+            }),
+            stream: false,
+            options: Object.assign({ temperature: (_a = request.temperature) !== null && _a !== void 0 ? _a : 0.7 }, (request.maxTokens ? { num_predict: request.maxTokens } : {})),
+        };
+        if (request.tools && request.tools.length > 0) {
+            requestData["tools"] = this.toOpenAITools(request.tools);
+        }
+        const response = await API.post({
+            url: URL.fromString(`${config.baseUrl}/api/chat`),
+            data: requestData,
             headers: {
                 "Content-Type": "application/json",
             },
@@ -290,9 +603,50 @@ class LLMService {
         if (!message) {
             throw new BadDataException("No response from Ollama");
         }
+        const rawToolCalls = message["tool_calls"];
+        let toolCalls = undefined;
+        if (rawToolCalls && rawToolCalls.length > 0) {
+            toolCalls = rawToolCalls.map((rawToolCall, index) => {
+                const fn = rawToolCall["function"] || {};
+                let parsedArguments = {};
+                let parseError = undefined;
+                const rawArguments = fn["arguments"];
+                if (typeof rawArguments === "string") {
+                    const parsed = this.parseToolCallArguments(rawArguments);
+                    parsedArguments = parsed.arguments;
+                    parseError = parsed.error;
+                }
+                else if (rawArguments && typeof rawArguments === "object") {
+                    parsedArguments = rawArguments;
+                }
+                // Ollama does not return tool-call ids; synthesize stable ones.
+                return {
+                    id: `tool_call_${index}`,
+                    name: fn["name"] || "",
+                    arguments: parsedArguments,
+                    argumentsParseError: parseError,
+                };
+            });
+        }
+        /*
+         * Ollama reports token counts on the final /api/chat response as
+         * prompt_eval_count (input) and eval_count (output). Populate usage from
+         * them so LlmLog, the AI dashboards and (costed self-hosted Ollama)
+         * billing are not silently blind to token spend.
+         */
+        const ollamaPromptTokens = jsonData["prompt_eval_count"] || 0;
+        const ollamaCompletionTokens = jsonData["eval_count"] || 0;
         return {
-            content: message["content"],
-            usage: undefined, // Ollama doesn't provide token usage in the same way
+            content: message["content"] || "",
+            toolCalls: toolCalls,
+            stopReason: toolCalls && toolCalls.length > 0 ? "tool_use" : "stop",
+            usage: ollamaPromptTokens || ollamaCompletionTokens
+                ? {
+                    promptTokens: ollamaPromptTokens,
+                    completionTokens: ollamaCompletionTokens,
+                    totalTokens: ollamaPromptTokens + ollamaCompletionTokens,
+                }
+                : undefined,
         };
     }
 }
@@ -301,6 +655,12 @@ class LLMService {
  * ?api-version=... in their configured base URL.
  */
 LLMService.AZURE_OPENAI_DEFAULT_API_VERSION = "2024-10-21";
+/*
+ * Anthropic wire format. System message is hoisted, tool results ride in
+ * user messages as tool_result blocks, and max_tokens is required by the
+ * API.
+ */
+LLMService.ANTHROPIC_DEFAULT_MAX_TOKENS = 4096;
 export default LLMService;
 __decorate([
     CaptureSpan(),