weflayr 0.23.0 → 0.26.0

package/dist/src/instrumentation/cohere/get_chat_telemetry.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Chat token-usage enrichment complement for the Cohere v1 chat path.
+ *
+ * `@traceloop/instrumentation-cohere` creates the `cohere.chat` span but reads
+ * token usage from the obsolete `result.token_count.{prompt,response}_tokens`
+ * shape; modern cohere-ai returns usage under `meta.billedUnits` instead, so the
+ * traceloop span ends up with zero chat tokens. This thin complement backfills
+ * `gen_ai.usage.{input,output}_tokens` from `meta.billedUnits`, the same source
+ * traceloop already uses for the `generate` endpoint — bringing Node chat tokens
+ * to parity with the Python SDK (OpenLLMetry captures them natively, so there is
+ * no Python counterpart).
+ *
+ * It hooks the internal `CohereClient.prototype.__chat` (which the public `chat`
+ * delegates to synchronously) rather than the public `chat`: traceloop wraps
+ * `chat` and opens the span around it, so `__chat` runs while that span is the
+ * active span — letting this complement enrich it regardless of patch order.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereChatTokenUsageInstrumentor = void 0;
+const api_1 = require("@opentelemetry/api");
+function _billedUnits(result) {
+    // Public `chat` resolves to the response body, but `__chat` resolves to the
+    // Fern wrapper `{ data, rawResponse }`; read billedUnits off either shape.
+    const response = result && result.data ? result.data : result;
+    return response && response.meta ? response.meta.billedUnits : undefined;
+}
+function _setChatTokenUsage(span, result) {
+    const billedUnits = _billedUnits(result);
+    if (!billedUnits)
+        return;
+    if (typeof billedUnits.inputTokens === 'number') {
+        span.setAttribute('gen_ai.usage.input_tokens', billedUnits.inputTokens);
+    }
+    if (typeof billedUnits.outputTokens === 'number') {
+        span.setAttribute('gen_ai.usage.output_tokens', billedUnits.outputTokens);
+    }
+}
+class CohereChatTokenUsageInstrumentor {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    instrument() {
+        let CohereClient;
+        try {
+            ({ CohereClient } = require('cohere-ai/Client'));
+        }
+        catch (err) {
+            throw new Error('weflayr.autoInstrument(COHERE): the cohere-ai client is not installed. ' +
+                'Install it with: npm install cohere-ai\n' +
+                `Underlying error: ${err.message}`);
+        }
+        this._wrap(CohereClient.prototype, '__chat');
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+    _wrap(owner, methodName) {
+        const original = owner[methodName];
+        function wrapper(...args) {
+            // Captured synchronously, while traceloop's chat span is still active.
+            const span = api_1.trace.getActiveSpan();
+            const result = original.apply(this, args);
+            if (!span || !span.isRecording || !span.isRecording())
+                return result;
+            return Promise.resolve(result).then((response) => {
+                _setChatTokenUsage(span, response);
+                return response;
+            });
+        }
+        owner[methodName] = wrapper;
+        this._patched.push([owner, methodName, original]);
+    }
+}
+exports.CohereChatTokenUsageInstrumentor = CohereChatTokenUsageInstrumentor;

package/dist/src/instrumentation/cohere/get_embeddings_telemetry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hand-written OTel instrumentor for the Cohere embeddings endpoint.
+ *
+ * `@traceloop/instrumentation-cohere` (the package weflayr uses for Cohere on
+ * Node) wraps chat/generate/rerank but not `embed`, so this ships inside weflayr
+ * to cover it. OpenLLMetry's cohere instrumentor doesn't cover `embed` either, so
+ * the Python SDK has a mirror complement (`cohere_embeddings.py`) shaped to
+ * normalize identically. It is registered alongside the traceloop instrumentor
+ * whenever `autoInstrument({ aiSdks: 'cohere' })` runs.
+ *
+ * Embeddings are billed per input token, so the span records the input tokens
+ * Cohere returns under `gen_ai.usage.input_tokens`; there is no completion.
+ */
+export declare class CohereEmbeddingsInstrumentor {
+    private _patched;
+    instrument(): void;
+    uninstrument(): void;
+}

package/dist/src/instrumentation/cohere/get_embeddings_telemetry.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Hand-written OTel instrumentor for the Cohere embeddings endpoint.
+ *
+ * `@traceloop/instrumentation-cohere` (the package weflayr uses for Cohere on
+ * Node) wraps chat/generate/rerank but not `embed`, so this ships inside weflayr
+ * to cover it. OpenLLMetry's cohere instrumentor doesn't cover `embed` either, so
+ * the Python SDK has a mirror complement (`cohere_embeddings.py`) shaped to
+ * normalize identically. It is registered alongside the traceloop instrumentor
+ * whenever `autoInstrument({ aiSdks: 'cohere' })` runs.
+ *
+ * Embeddings are billed per input token, so the span records the input tokens
+ * Cohere returns under `gen_ai.usage.input_tokens`; there is no completion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereEmbeddingsInstrumentor = void 0;
+const api_1 = require("@opentelemetry/api");
+const TRACER_NAME = 'weflayr.instrumentation.cohere_embeddings';
+// Matches the gen_ai.system the cohere chat instrumentors set (Python + Node).
+const SYSTEM = 'Cohere';
+const EMBEDDINGS_OPERATION = 'embeddings';
+function _recordError(span, error) {
+    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error?.message ?? String(error) });
+    span.recordException(error);
+}
+function _wrapEmbed(owner, patched) {
+    const original = owner.embed;
+    function wrapper(request, ...rest) {
+        const span = api_1.trace.getTracer(TRACER_NAME).startSpan(EMBEDDINGS_OPERATION);
+        span.setAttribute('gen_ai.system', SYSTEM);
+        span.setAttribute('gen_ai.operation.name', EMBEDDINGS_OPERATION);
+        if (request && request.model) {
+            span.setAttribute('gen_ai.request.model', request.model);
+        }
+        // The embedded texts are the prompt; stamp one user message per text, like
+        // the chat path. The span processor strips it when content capture is off.
+        if (request && Array.isArray(request.texts) && request.texts.length) {
+            span.setAttribute('gen_ai.input.messages', JSON.stringify(request.texts.map((text) => ({
+                role: 'user',
+                parts: [{ type: 'text', content: text }],
+            }))));
+        }
+        return Promise.resolve(original.call(this, request, ...rest)).then((response) => {
+            // Node SDK reports the billed input tokens under camelCase keys.
+            const inputTokens = response?.meta?.billedUnits?.inputTokens ?? response?.meta?.tokens?.inputTokens;
+            if (inputTokens != null) {
+                span.setAttribute('gen_ai.usage.input_tokens', inputTokens);
+            }
+            span.end();
+            return response;
+        }, (error) => {
+            _recordError(span, error);
+            span.end();
+            throw error;
+        });
+    }
+    owner.embed = wrapper;
+    patched.push([owner, 'embed', original]);
+}
+class CohereEmbeddingsInstrumentor {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    instrument() {
+        let CohereClient;
+        let V2Client;
+        try {
+            // v1 `embed` is a prototype method on CohereClient; v2 `embed` lives on
+            // V2Client.prototype (CohereClientV2 binds it as an instance property, so
+            // it must be patched on the underlying V2Client class instead).
+            ({ CohereClient } = require('cohere-ai/Client'));
+            ({ V2Client } = require('cohere-ai/api/resources/v2/client/Client'));
+        }
+        catch (err) {
+            throw new Error('weflayr.autoInstrument(COHERE): the cohere-ai client is not installed. ' +
+                'Install it with: npm install cohere-ai\n' +
+                `Underlying error: ${err.message}`);
+        }
+        _wrapEmbed(CohereClient.prototype, this._patched);
+        _wrapEmbed(V2Client.prototype, this._patched);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.CohereEmbeddingsInstrumentor = CohereEmbeddingsInstrumentor;

package/dist/src/instrumentation/cohere/get_structured_output_schema_telemetry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Structured-output schema location for Cohere requests.
+ *
+ * Cohere pins an answer to a JSON schema with
+ * `responseFormat: { type: 'json_object', schema }`. The traceloop instrumentor
+ * records the request's model and sampling params but never the schema.
+ *
+ * The JS client sends camelCase (`responseFormat`) where the Python one sends
+ * snake_case, so both spellings are read: the instrumentor hands over whatever
+ * the caller passed.
+ */
+export declare function readStructuredOutputSchema(params: any): unknown;

package/dist/src/instrumentation/cohere/get_structured_output_schema_telemetry.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Structured-output schema location for Cohere requests.
+ *
+ * Cohere pins an answer to a JSON schema with
+ * `responseFormat: { type: 'json_object', schema }`. The traceloop instrumentor
+ * records the request's model and sampling params but never the schema.
+ *
+ * The JS client sends camelCase (`responseFormat`) where the Python one sends
+ * snake_case, so both spellings are read: the instrumentor hands over whatever
+ * the caller passed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStructuredOutputSchema = readStructuredOutputSchema;
+function readStructuredOutputSchema(params) {
+    const responseFormat = params && (params.responseFormat || params.response_format);
+    return responseFormat && responseFormat.schema;
+}

package/dist/src/instrumentation/cohere/get_tool_call_output_telemetry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Tool-call output parts for Cohere chat spans.
+ *
+ * `@traceloop/instrumentation-cohere` records the response as legacy indexed
+ * `gen_ai.completion.0.*` attributes, which carry a role and flat text and have
+ * no way to express a tool call, so the v1 client's `response.toolCalls` (bare
+ * `{name, parameters}` entries) reach the span nowhere.
+ *
+ * When the response carries tool calls this complement stamps the whole
+ * `gen_ai.output.messages` instead, in the standard role+parts shape, so the
+ * tool call normalizes to the same `tool_call` part every other provider
+ * produces. Calls without tool calls are left to the instrumentor's own
+ * attributes: there is nothing it fails to express about them.
+ *
+ * Like the chat token-usage complement it hooks the internal
+ * `CohereClient.prototype.__chat`, which runs while traceloop's `cohere.chat`
+ * span is active — so the stamp lands on that span regardless of patch order.
+ */
+export declare const OUTPUT_MESSAGES_ATTRIBUTE = "gen_ai.output.messages";
+/**
+ * The response as one assistant message, or [] when it carries no tool call
+ * (nothing the instrumentor's own attributes cannot express). The text the
+ * model emits alongside a tool call — its plan for using it — is kept as a
+ * leading text part so stamping this attribute loses nothing.
+ */
+export declare function buildOutputMessages(result: any): any[];
+export declare class CohereToolCallOutputInstrumentor {
+    private _patched;
+    instrument(): void;
+    uninstrument(): void;
+}

package/dist/src/instrumentation/cohere/get_tool_call_output_telemetry.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Tool-call output parts for Cohere chat spans.
+ *
+ * `@traceloop/instrumentation-cohere` records the response as legacy indexed
+ * `gen_ai.completion.0.*` attributes, which carry a role and flat text and have
+ * no way to express a tool call, so the v1 client's `response.toolCalls` (bare
+ * `{name, parameters}` entries) reach the span nowhere.
+ *
+ * When the response carries tool calls this complement stamps the whole
+ * `gen_ai.output.messages` instead, in the standard role+parts shape, so the
+ * tool call normalizes to the same `tool_call` part every other provider
+ * produces. Calls without tool calls are left to the instrumentor's own
+ * attributes: there is nothing it fails to express about them.
+ *
+ * Like the chat token-usage complement it hooks the internal
+ * `CohereClient.prototype.__chat`, which runs while traceloop's `cohere.chat`
+ * span is active — so the stamp lands on that span regardless of patch order.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereToolCallOutputInstrumentor = exports.OUTPUT_MESSAGES_ATTRIBUTE = void 0;
+exports.buildOutputMessages = buildOutputMessages;
+const api_1 = require("@opentelemetry/api");
+exports.OUTPUT_MESSAGES_ATTRIBUTE = 'gen_ai.output.messages';
+// Public `chat` resolves to the response body, but `__chat` resolves to the
+// Fern wrapper `{ data, rawResponse }`; read the response off either shape.
+function _responseBody(result) {
+    return result && result.data ? result.data : result;
+}
+/**
+ * The response as one assistant message, or [] when it carries no tool call
+ * (nothing the instrumentor's own attributes cannot express). The text the
+ * model emits alongside a tool call — its plan for using it — is kept as a
+ * leading text part so stamping this attribute loses nothing.
+ */
+function buildOutputMessages(result) {
+    const response = _responseBody(result);
+    const toolCalls = response && response.toolCalls;
+    if (!Array.isArray(toolCalls) || !toolCalls.length)
+        return [];
+    const parts = [];
+    if (response.text)
+        parts.push({ type: 'text', content: String(response.text) });
+    for (const toolCall of toolCalls) {
+        // v1 assigns no call id, so the part carries none — unlike the providers
+        // whose API returns one.
+        if (toolCall && toolCall.name) {
+            parts.push({
+                type: 'tool_call',
+                name: String(toolCall.name),
+                arguments: toolCall.parameters || {},
+            });
+        }
+    }
+    if (!parts.length)
+        return [];
+    const message = { role: 'assistant', parts };
+    if (response.finishReason)
+        message.finish_reason = String(response.finishReason);
+    return [message];
+}
+class CohereToolCallOutputInstrumentor {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    instrument() {
+        let CohereClient;
+        try {
+            ({ CohereClient } = require('cohere-ai/Client'));
+        }
+        catch (err) {
+            throw new Error('weflayr.autoInstrument(COHERE): the cohere-ai client is not installed. ' +
+                'Install it with: npm install cohere-ai\n' +
+                `Underlying error: ${err.message}`);
+        }
+        const owner = CohereClient.prototype;
+        const original = owner.__chat;
+        function wrapper(...args) {
+            // Captured synchronously, while traceloop's chat span is still active.
+            const span = api_1.trace.getActiveSpan();
+            const result = original.apply(this, args);
+            if (!span || !span.isRecording || !span.isRecording())
+                return result;
+            return Promise.resolve(result).then((response) => {
+                try {
+                    const messages = buildOutputMessages(response);
+                    if (messages.length) {
+                        span.setAttribute(exports.OUTPUT_MESSAGES_ATTRIBUTE, JSON.stringify(messages));
+                    }
+                }
+                catch {
+                    // Never break the caller's Cohere call over an enrichment failure.
+                }
+                return response;
+            });
+        }
+        owner.__chat = wrapper;
+        this._patched.push([owner, '__chat', original]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.CohereToolCallOutputInstrumentor = CohereToolCallOutputInstrumentor;

package/dist/src/instrumentation/cohere/get_tool_definitions_telemetry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Tool definitions for Cohere chat spans.
+ *
+ * `@traceloop/instrumentation-cohere` records the request's model and message
+ * but never its `tools`, so a tool-using call carries no
+ * `gen_ai.tool.definitions`.
+ *
+ * Like the chat token-usage complement it hooks the internal
+ * `CohereClient.prototype.__chat`, which runs while traceloop's `cohere.chat`
+ * span is active — so the stamp lands on that span regardless of patch order.
+ */
+export declare const TOOL_DEFINITIONS_ATTRIBUTE = "gen_ai.tool.definitions";
+/**
+ * The request's tool definitions in the shape they go on the wire.
+ *
+ * The complement sees the request before the JS client serializes it, where the
+ * parameters still sit under the camelCase `parameterDefinitions`; the client
+ * renames it to `parameter_definitions` on the way out, which is what the
+ * Python client passes in already. Renaming it here is what lets both SDKs
+ * normalize a Cohere tool definition identically.
+ */
+export declare function extractToolDefinitions(request: any): any[];
+export declare class CohereToolDefinitionsInstrumentor {
+    private _patched;
+    instrument(): void;
+    uninstrument(): void;
+}

package/dist/src/instrumentation/cohere/get_tool_definitions_telemetry.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Tool definitions for Cohere chat spans.
+ *
+ * `@traceloop/instrumentation-cohere` records the request's model and message
+ * but never its `tools`, so a tool-using call carries no
+ * `gen_ai.tool.definitions`.
+ *
+ * Like the chat token-usage complement it hooks the internal
+ * `CohereClient.prototype.__chat`, which runs while traceloop's `cohere.chat`
+ * span is active — so the stamp lands on that span regardless of patch order.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereToolDefinitionsInstrumentor = exports.TOOL_DEFINITIONS_ATTRIBUTE = void 0;
+exports.extractToolDefinitions = extractToolDefinitions;
+const api_1 = require("@opentelemetry/api");
+exports.TOOL_DEFINITIONS_ATTRIBUTE = 'gen_ai.tool.definitions';
+/**
+ * The request's tool definitions in the shape they go on the wire.
+ *
+ * The complement sees the request before the JS client serializes it, where the
+ * parameters still sit under the camelCase `parameterDefinitions`; the client
+ * renames it to `parameter_definitions` on the way out, which is what the
+ * Python client passes in already. Renaming it here is what lets both SDKs
+ * normalize a Cohere tool definition identically.
+ */
+function extractToolDefinitions(request) {
+    const tools = request && request.tools;
+    if (!Array.isArray(tools))
+        return [];
+    return tools
+        .filter((tool) => tool && tool.name)
+        .map(({ parameterDefinitions, ...tool }) => parameterDefinitions === undefined
+        ? tool
+        : { ...tool, parameter_definitions: parameterDefinitions });
+}
+class CohereToolDefinitionsInstrumentor {
+    // [ownerPrototype, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    instrument() {
+        let CohereClient;
+        try {
+            ({ CohereClient } = require('cohere-ai/Client'));
+        }
+        catch (err) {
+            throw new Error('weflayr.autoInstrument(COHERE): the cohere-ai client is not installed. ' +
+                'Install it with: npm install cohere-ai\n' +
+                `Underlying error: ${err.message}`);
+        }
+        const owner = CohereClient.prototype;
+        const original = owner.__chat;
+        function wrapper(...args) {
+            const span = api_1.trace.getActiveSpan();
+            try {
+                const definitions = extractToolDefinitions(args[0]);
+                if (definitions.length && span && span.isRecording && span.isRecording()) {
+                    span.setAttribute(exports.TOOL_DEFINITIONS_ATTRIBUTE, JSON.stringify(definitions));
+                }
+            }
+            catch {
+                // Never break the caller's Cohere call over an enrichment failure.
+            }
+            return original.apply(this, args);
+        }
+        owner.__chat = wrapper;
+        this._patched.push([owner, '__chat', original]);
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+    }
+}
+exports.CohereToolDefinitionsInstrumentor = CohereToolDefinitionsInstrumentor;

package/dist/src/instrumentation/cohere/set_telemetry_attributes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cohere telemetry complement — the registered orchestrator.
+ *
+ * Wires the weflayr-supplied patches the traceloop Cohere instrumentor misses:
+ *   - chat token usage (traceloop reads the obsolete usage shape and records
+ *     zero chat tokens),
+ *   - the embeddings endpoint it doesn't cover,
+ *   - the request's structured-output schema, and
+ *   - function calling: it records neither the request's tools nor the
+ *     response's tool calls.
+ */
+export declare class CohereTelemetryInstrumentor {
+    private _subInstrumentors;
+    constructor();
+    instrument(instrumentation: any): void;
+    uninstrument(): void;
+}

package/dist/src/instrumentation/cohere/set_telemetry_attributes.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Cohere telemetry complement — the registered orchestrator.
+ *
+ * Wires the weflayr-supplied patches the traceloop Cohere instrumentor misses:
+ *   - chat token usage (traceloop reads the obsolete usage shape and records
+ *     zero chat tokens),
+ *   - the embeddings endpoint it doesn't cover,
+ *   - the request's structured-output schema, and
+ *   - function calling: it records neither the request's tools nor the
+ *     response's tool calls.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CohereTelemetryInstrumentor = void 0;
+const get_structured_output_schema_telemetry_1 = require("../shared/get_structured_output_schema_telemetry");
+const get_chat_telemetry_1 = require("./get_chat_telemetry");
+const get_embeddings_telemetry_1 = require("./get_embeddings_telemetry");
+const get_structured_output_schema_telemetry_2 = require("./get_structured_output_schema_telemetry");
+const get_tool_call_output_telemetry_1 = require("./get_tool_call_output_telemetry");
+const get_tool_definitions_telemetry_1 = require("./get_tool_definitions_telemetry");
+class CohereTelemetryInstrumentor {
+    _subInstrumentors;
+    constructor() {
+        this._subInstrumentors = [
+            new get_chat_telemetry_1.CohereChatTokenUsageInstrumentor(),
+            new get_embeddings_telemetry_1.CohereEmbeddingsInstrumentor(),
+            new get_structured_output_schema_telemetry_1.TraceloopStructuredOutputSchemaInstrumentor(get_structured_output_schema_telemetry_2.readStructuredOutputSchema),
+            new get_tool_definitions_telemetry_1.CohereToolDefinitionsInstrumentor(),
+            new get_tool_call_output_telemetry_1.CohereToolCallOutputInstrumentor(),
+        ];
+    }
+    instrument(instrumentation) {
+        for (const sub of this._subInstrumentors)
+            sub.instrument(instrumentation);
+    }
+    uninstrument() {
+        // Newest first: the token-usage, tool-definition and tool-call complements
+        // all wrap `CohereClient.prototype.__chat`, so unwinding in instrument
+        // order would reinstall an earlier wrapper instead of the true original.
+        for (const sub of [...this._subInstrumentors].reverse())
+            sub.uninstrument();
+    }
+}
+exports.CohereTelemetryInstrumentor = CohereTelemetryInstrumentor;

package/dist/src/instrumentation/elevenlabs/full_instrumentation.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hand-written OTel instrumentor for the ElevenLabs audio clients.
+ *
+ * No official OpenTelemetry instrumentor exists for the ElevenLabs SDK (it's
+ * audio, not an LLM), so this ships inside weflayr. It wraps the Text-to-Speech
+ * and Speech-to-Text entrypoints to emit one `gen_ai.*` span per call, which
+ * flows through the standard span processor -> exporter with no new transport code.
+ *
+ * The billable unit differs by API, so each span records the one ElevenLabs bills:
+ *   - Text-to-Speech is billed per input character -> `gen_ai.usage.input_characters`.
+ *   - Speech-to-Text is billed per second of audio  -> `gen_ai.usage.input_seconds`.
+ *
+ * Entrypoints come in three result shapes, independent of which API they belong to:
+ *   - *byte stream* methods resolve to a `ReadableStream` of audio chunks;
+ *   - *object stream* methods resolve to an async-iterable of chunk objects;
+ *   - *unary* methods resolve to the full response.
+ * The HTTP request -- plus any error -- only happens while a stream is awaited
+ * and consumed, so the span is started eagerly (to capture the
+ * `propagateMetadata` context active at the call site) and ended once the result
+ * is exhausted (streams) or returned (unary), giving an `elapsed_ms` that covers
+ * the whole call. The per-second billable unit is read off the STT response.
+ */
+export declare class ElevenLabsInstrumentor {
+    private _patched;
+    instrument(): void;
+    uninstrument(): void;
+    private _wrap;
+}