@cyanheads/mcp-ts-core 0.12.7 → 0.12.8

package/dist/utils/internal/performance.js

@@ -50,28 +50,6 @@ function getActiveRequestsGauge() {
     activeRequests ??= createUpDownCounter('mcp.requests.active', 'Number of in-flight tool, resource, and prompt handler executions', '{requests}');
     return activeRequests;
 }
-/**
- * @deprecated No longer needed. `globalThis.performance.now` is universally
- * available on Node ≥24 and Bun ≥1.3. Kept as a no-op export to avoid a
- * breaking change for consumers that call it during startup.
- */
-export function loadPerfHooks() {
-    // performance is an ambient global declared by @types/node (perf_hooks.d.ts)
-    // and available in all supported environments (Node ≥24, Bun ≥1.3, workerd).
-    return Promise.resolve({ performance });
-}
-/**
- * @deprecated No longer needed. `nowMs` now delegates directly to
- * `globalThis.performance.now()`, which is universally available on Node ≥24
- * and Bun ≥1.3. This function is a no-op and will be removed in a future
- * major release.
- *
- * @returns A promise that resolves immediately.
- */
-export function initHighResTimer(_perfLoader) {
-    // No-op: globalThis.performance.now is guaranteed on all supported floors.
-    return Promise.resolve();
-}
 /**
  * Returns the current time in milliseconds using `globalThis.performance.now()`.
  *
@@ -169,89 +147,40 @@ const toBytes = (payload) => {
         }
     }
 };
-// ==========================================================================
-// Tool execution measurement
-// ==========================================================================
-/*
- * Measured-region semantics, settled in #346 and shared by
- * {@link measureToolExecution} and {@link measureResourceExecution}.
- *
- * The measured region spans everything that decides the client-visible
- * outcome: the handler **and** the response pipeline that follows it
- * (output-schema validation, `format()`, the enrichment merge and its trailer
- * render). Telemetry that closed when the handler returned reported a
- * successful call while the client was handed `isError: true`.
- *
- * Two consequences of that width:
- *
- * 1. `mcp.*.duration` covers validation, formatting, and the merge, not the
- *    handler alone. It is time-to-produce-the-result, which is what the
- *    caller waited for.
- * 2. The callback's return value is the assembled client result, so it is no
- *    longer what `mcp.*.output_bytes` should measure — `content[]` re-renders
- *    the same data the structured payload carries, and counting both would
- *    silently redefine an existing series. Callers therefore designate the
- *    payload explicitly via the `recordOutput` argument, which also feeds
- *    partial-success detection. `output_bytes` keeps measuring the handler's
- *    returned domain value, unchanged from 0.12.2. When nothing is
- *    designated, the callback's return value is measured — the single-value
- *    form for callers with no assembly step.
- */
 /**
- * Wraps a tool's logic function with observability: an OpenTelemetry span,
- * OTel metric counters/histogram, payload size capture, and structured log.
- *
- * The caller supplies the raw tool logic as `toolLogicFn`; this function handles
- * all instrumentation so tool handlers stay free of telemetry boilerplate.
- *
- * On success the resolved value is passed through transparently.
- * On failure the error is re-thrown after being recorded on the span and metrics;
- * `McpError` instances surface their numeric `code` as the error code attribute.
- * A failure anywhere in the callback — handler or response pipeline — is
- * recorded, and no output-size histogram is emitted for it.
- *
- * @template T - The resolved type of the tool's return value.
- * @param toolLogicFn - Async function containing the tool's business logic and
- *   the response assembly that follows it. Receives `context` re-bound to the
- *   execution span this function opens, so a handler context built from it
- *   correlates to the span the handler actually runs in rather than to the
- *   enclosing request span, plus `recordOutput` — call it with the handler's
- *   domain value to designate what `mcp.tool.output_bytes` and partial-success
- *   detection measure. Without a call, the callback's return value is measured.
- * @param context - Request context extended with `toolName`; used for span/log correlation.
- * @param inputPayload - The raw input object passed to the tool, serialized to compute byte size.
- * @param successAttributes - Optional thunk evaluated after a successful run; its
- *   returned key/value map is set on the span as extra attributes. Lets callers
- *   attach post-hoc signals (e.g. `mcp.tool.enriched`) without coupling this
- *   function to their domain. Not called on the error path.
- * @returns A promise that resolves with the tool's return value or rejects with the original error.
+ * Opens `<spanPrefix>:<name>`, runs `logic` inside it with `context` re-bound
+ * to that span, and settles the outcome the same way for every kind: an
+ * `input_required` signal is protocol control flow and counts as success
+ * (recording it as a failure would mark the span ERROR, count an error, and
+ * log `isSuccess: false` for every legitimate multi-round-trip request); an
+ * `McpError` surfaces its numeric code; anything else is `UNHANDLED_ERROR` or
+ * `UNKNOWN_ERROR`. The in-flight gauge and duration bracket the whole run.
  */
-export async function measureToolExecution(toolLogicFn, context, inputPayload, successAttributes) {
+async function measure(kind, name, context, startAttributes, logic, hooks) {
     const tracer = trace.getTracer(config.openTelemetry.serviceName, config.openTelemetry.serviceVersion);
-    const { toolName } = context;
-    return await tracer.startActiveSpan(`tool_execution:${toolName}`, async (span) => {
+    return await tracer.startActiveSpan(`${kind.spanPrefix}:${name}`, async (span) => {
         // The span is active from here down, so everything below — the handler
-        // context the logic function builds and this function's own completion log
-        // — correlates to `tool_execution:*` rather than to whatever was active
-        // when the caller built `context`.
+        // context the logic function builds and the completion log — correlates
+        // to this span rather than to whatever was active when the caller built
+        // `context`.
         const spanContext = withActiveSpan(context);
         const activeGauge = getActiveRequestsGauge();
         activeGauge.add(1);
         const t0 = nowMs();
-        const inputBytes = toBytes(inputPayload);
         span.setAttributes({
-            [ATTR_CODE_FUNCTION_NAME]: toolName,
-            [ATTR_CODE_NAMESPACE]: 'mcp-tools',
-            [ATTR_MCP_TOOL_INPUT_BYTES]: inputBytes,
+            [ATTR_CODE_FUNCTION_NAME]: name,
+            [ATTR_CODE_NAMESPACE]: kind.namespace,
+            ...startAttributes,
         });
-        let ok = false;
-        let inputRequired = false;
-        let errorCode;
-        let errorCategory;
-        let outputBytes = 0;
-        let partialSuccess = false;
-        let batchSucceeded;
-        let batchFailed;
+        const outcome = {
+            durationMs: 0,
+            errorCategory: undefined,
+            errorCode: undefined,
+            inputRequired: false,
+            measuredOutput: undefined,
+            ok: false,
+            outputBytes: 0,
+        };
         let designatedOutput;
         let outputDesignated = false;
         const recordOutput = (payload) => {
@@ -259,59 +188,29 @@ export async function measureToolExecution(toolLogicFn, context, inputPayload, s
             outputDesignated = true;
         };
         try {
-            const result = await toolLogicFn(spanContext, recordOutput);
-            ok = true;
-            const measuredOutput = outputDesignated ? designatedOutput : result;
-            outputBytes = toBytes(measuredOutput);
-            // Detect partial success: the measured payload contains a non-empty `failed` array.
-            // Convention-based — matches the batch response pattern recommended by the design skill.
-            if (measuredOutput != null &&
-                typeof measuredOutput === 'object' &&
-                !Array.isArray(measuredOutput)) {
-                const obj = measuredOutput;
-                if (Array.isArray(obj.failed) && obj.failed.length > 0) {
-                    partialSuccess = true;
-                    batchFailed = obj.failed.length;
-                    if (Array.isArray(obj.succeeded))
-                        batchSucceeded = obj.succeeded.length;
-                }
-            }
+            const result = await logic(spanContext, recordOutput);
+            outcome.ok = true;
+            outcome.measuredOutput = outputDesignated ? designatedOutput : result;
+            outcome.outputBytes = toBytes(outcome.measuredOutput);
             span.setStatus({ code: SpanStatusCode.OK });
-            span.setAttribute(ATTR_MCP_TOOL_OUTPUT_BYTES, outputBytes);
-            if (partialSuccess) {
-                span.setAttribute(ATTR_MCP_TOOL_PARTIAL_SUCCESS, true);
-                if (batchFailed !== undefined)
-                    span.setAttribute(ATTR_MCP_TOOL_BATCH_FAILED, batchFailed);
-                if (batchSucceeded !== undefined)
-                    span.setAttribute(ATTR_MCP_TOOL_BATCH_SUCCEEDED, batchSucceeded);
-            }
-            if (successAttributes) {
-                for (const [key, value] of Object.entries(successAttributes())) {
-                    span.setAttribute(key, value);
-                }
-            }
+            hooks.onSuccess(span, outcome);
             return result;
-            // `ctx.requestInput(...)` unwinds the handler as a thrown signal, but the
-            // round ended in `input_required` — protocol control flow, not a failure.
-            // Recording it as one would mark the span ERROR, increment the error
-            // counter, and log `isSuccess: false` for every legitimate
-            // multi-round-trip request.
         }
         catch (err) {
             if (isInputRequiredSignal(err)) {
-                ok = true;
-                inputRequired = true;
+                outcome.ok = true;
+                outcome.inputRequired = true;
                 span.setStatus({ code: SpanStatusCode.OK });
-                span.setAttribute(ATTR_MCP_TOOL_INPUT_REQUIRED, true);
+                span.setAttribute(kind.attrs.inputRequired, true);
                 throw err;
             }
             if (err instanceof McpError) {
-                errorCode = String(err.code);
-                errorCategory = getErrorCategory(err.code);
+                outcome.errorCode = String(err.code);
+                outcome.errorCategory = getErrorCategory(err.code);
             }
             else {
-                errorCode = err instanceof Error ? 'UNHANDLED_ERROR' : 'UNKNOWN_ERROR';
-                errorCategory = 'server';
+                outcome.errorCode = err instanceof Error ? 'UNHANDLED_ERROR' : 'UNKNOWN_ERROR';
+                outcome.errorCategory = 'server';
             }
             if (err instanceof Error)
                 span.recordException(err);
@@ -323,16 +222,97 @@ export async function measureToolExecution(toolLogicFn, context, inputPayload, s
         }
         finally {
             activeGauge.add(-1);
-            const t1 = nowMs();
-            const durationMs = Math.round((t1 - t0) * 100) / 100;
+            outcome.durationMs = Math.round((nowMs() - t0) * 100) / 100;
             span.setAttributes({
-                [ATTR_MCP_TOOL_DURATION_MS]: durationMs,
-                [ATTR_MCP_TOOL_SUCCESS]: ok,
+                [kind.attrs.durationMs]: outcome.durationMs,
+                [kind.attrs.success]: outcome.ok,
             });
-            if (errorCode)
-                span.setAttribute(ATTR_MCP_TOOL_ERROR_CODE, errorCode);
+            if (outcome.errorCode)
+                span.setAttribute(kind.attrs.errorCode, outcome.errorCode);
             span.end();
-            // Record to OTel metric instruments (durable across restarts)
+            hooks.onSettled(spanContext, outcome);
+        }
+    });
+}
+// ==========================================================================
+// Tool execution measurement
+// ==========================================================================
+const TOOL_KIND = {
+    attrs: {
+        durationMs: ATTR_MCP_TOOL_DURATION_MS,
+        errorCode: ATTR_MCP_TOOL_ERROR_CODE,
+        inputRequired: ATTR_MCP_TOOL_INPUT_REQUIRED,
+        success: ATTR_MCP_TOOL_SUCCESS,
+    },
+    namespace: 'mcp-tools',
+    spanPrefix: 'tool_execution',
+};
+/**
+ * Convention-based partial-success detection: a measured payload carrying a
+ * non-empty `failed` array — the batch response shape the design skill
+ * recommends. `batchSucceeded` is reported only when a `succeeded` array sits
+ * beside it.
+ */
+function detectPartialSuccess(output) {
+    if (output == null || typeof output !== 'object' || Array.isArray(output))
+        return undefined;
+    const { failed, succeeded } = output;
+    if (!Array.isArray(failed) || failed.length === 0)
+        return undefined;
+    return {
+        batchFailed: failed.length,
+        batchSucceeded: Array.isArray(succeeded) ? succeeded.length : undefined,
+    };
+}
+/**
+ * Wraps a tool's logic function with observability: an OpenTelemetry span,
+ * OTel metric counters/histogram, payload size capture, and structured log.
+ *
+ * On success the resolved value is passed through transparently. On failure
+ * the error is re-thrown after being recorded on the span and metrics;
+ * `McpError` instances surface their numeric `code` as the error code
+ * attribute. A failure anywhere in the callback — handler or response
+ * pipeline — is recorded, and no output-size histogram is emitted for it.
+ *
+ * @template T - The resolved type of the tool's return value.
+ * @param toolLogicFn - Async function containing the tool's business logic and
+ *   the response assembly that follows it. Receives `context` re-bound to the
+ *   execution span this function opens, so a handler context built from it
+ *   correlates to the span the handler actually runs in rather than to the
+ *   enclosing request span, plus `recordOutput` — call it with the handler's
+ *   domain value to designate what `mcp.tool.output_bytes` and partial-success
+ *   detection measure. Without a call, the callback's return value is measured.
+ * @param context - Request context extended with `toolName`; used for span/log correlation.
+ * @param inputPayload - The raw input object passed to the tool, serialized to compute byte size.
+ * @param successAttributes - Optional thunk evaluated after a successful run; its
+ *   returned key/value map is set on the span as extra attributes. Lets callers
+ *   attach post-hoc signals (e.g. `mcp.tool.enriched`) without coupling this
+ *   function to their domain. Not called on the error path.
+ * @returns A promise that resolves with the tool's return value or rejects with the original error.
+ */
+export async function measureToolExecution(toolLogicFn, context, inputPayload, successAttributes) {
+    const { toolName } = context;
+    const inputBytes = toBytes(inputPayload);
+    let partial;
+    return await measure(TOOL_KIND, toolName, context, { [ATTR_MCP_TOOL_INPUT_BYTES]: inputBytes }, toolLogicFn, {
+        onSuccess: (span, outcome) => {
+            span.setAttribute(ATTR_MCP_TOOL_OUTPUT_BYTES, outcome.outputBytes);
+            partial = detectPartialSuccess(outcome.measuredOutput);
+            if (partial) {
+                span.setAttribute(ATTR_MCP_TOOL_PARTIAL_SUCCESS, true);
+                span.setAttribute(ATTR_MCP_TOOL_BATCH_FAILED, partial.batchFailed);
+                if (partial.batchSucceeded !== undefined) {
+                    span.setAttribute(ATTR_MCP_TOOL_BATCH_SUCCEEDED, partial.batchSucceeded);
+                }
+            }
+            if (successAttributes) {
+                for (const [key, value] of Object.entries(successAttributes())) {
+                    span.setAttribute(key, value);
+                }
+            }
+        },
+        onSettled: (spanContext, outcome) => {
+            const { durationMs, errorCategory, errorCode, inputRequired, ok, outputBytes } = outcome;
             const m = getToolMetrics();
             const metricAttrs = { [ATTR_MCP_TOOL_NAME]: toolName, [ATTR_MCP_TOOL_SUCCESS]: ok };
             const toolAttrs = { [ATTR_MCP_TOOL_NAME]: toolName };
@@ -362,10 +342,14 @@ export async function measureToolExecution(toolLogicFn, context, inputPayload, s
                     inputBytes,
                     outputBytes,
                     ...(inputRequired && { inputRequired }),
-                    ...(partialSuccess && { partialSuccess, batchSucceeded, batchFailed }),
+                    ...(partial && {
+                        partialSuccess: true,
+                        batchSucceeded: partial.batchSucceeded,
+                        batchFailed: partial.batchFailed,
+                    }),
                 },
             }));
-        }
+        },
     });
 }
 // ==========================================================================
@@ -382,10 +366,20 @@ function getResourceMetrics() {
     resourceOutputBytes ??= createHistogram('mcp.resource.output_bytes', 'Resource output payload size', 'bytes');
     return { resourceReadCounter, resourceReadDuration, resourceReadErrors, resourceOutputBytes };
 }
+const RESOURCE_KIND = {
+    attrs: {
+        durationMs: ATTR_MCP_RESOURCE_DURATION_MS,
+        errorCode: ATTR_MCP_RESOURCE_ERROR_CODE,
+        inputRequired: ATTR_MCP_RESOURCE_INPUT_REQUIRED,
+        success: ATTR_MCP_RESOURCE_SUCCESS,
+    },
+    namespace: 'mcp-resources',
+    spanPrefix: 'resource_read',
+};
 /**
  * Wraps a resource handler with observability: OTel span, metric counters/histogram,
  * and a structured log. Mirrors {@link measureToolExecution} but tuned for resource reads,
- * including the measured-region semantics documented there.
+ * including the measured-region semantics documented above.
  *
  * @template T - The resolved type of the resource handler's return value.
  * @param resourceLogicFn - Async function containing the resource handler and the
@@ -398,76 +392,13 @@ function getResourceMetrics() {
  * @returns A promise that resolves with the handler's return value or rejects with the original error.
  */
 export async function measureResourceExecution(resourceLogicFn, context, meta) {
-    const tracer = trace.getTracer(config.openTelemetry.serviceName, config.openTelemetry.serviceVersion);
     const { resourceName } = context;
-    return await tracer.startActiveSpan(`resource_read:${resourceName}`, async (span) => {
-        // Active from here down — see the note in `measureToolExecution`.
-        const spanContext = withActiveSpan(context);
-        const activeGauge = getActiveRequestsGauge();
-        activeGauge.add(1);
-        const t0 = nowMs();
-        span.setAttributes({
-            [ATTR_CODE_FUNCTION_NAME]: resourceName,
-            [ATTR_CODE_NAMESPACE]: 'mcp-resources',
-            [ATTR_MCP_RESOURCE_URI]: meta.uri,
-            [ATTR_MCP_RESOURCE_MIME_TYPE]: meta.mimeType,
-        });
-        let ok = false;
-        let inputRequired = false;
-        let errorCode;
-        let outputBytes = 0;
-        let designatedOutput;
-        let outputDesignated = false;
-        const recordOutput = (payload) => {
-            designatedOutput = payload;
-            outputDesignated = true;
-        };
-        try {
-            const result = await resourceLogicFn(spanContext, recordOutput);
-            ok = true;
-            outputBytes = toBytes(outputDesignated ? designatedOutput : result);
-            span.setStatus({ code: SpanStatusCode.OK });
-            span.setAttribute(ATTR_MCP_RESOURCE_SIZE_BYTES, outputBytes);
-            return result;
-            // `ctx.requestInput(...)` unwinds the handler as a thrown signal, but the
-            // round ended in `input_required` — protocol control flow, not a failure.
-            // Recording it as one would mark the span ERROR, increment the error
-            // counter, and log `isSuccess: false` for every legitimate
-            // multi-round-trip request.
-        }
-        catch (err) {
-            if (isInputRequiredSignal(err)) {
-                ok = true;
-                inputRequired = true;
-                span.setStatus({ code: SpanStatusCode.OK });
-                span.setAttribute(ATTR_MCP_RESOURCE_INPUT_REQUIRED, true);
-                throw err;
-            }
-            if (err instanceof McpError)
-                errorCode = String(err.code);
-            else if (err instanceof Error)
-                errorCode = 'UNHANDLED_ERROR';
-            else
-                errorCode = 'UNKNOWN_ERROR';
-            if (err instanceof Error)
-                span.recordException(err);
-            span.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: err instanceof Error ? err.message : String(err),
-            });
-            throw err;
-        }
-        finally {
-            activeGauge.add(-1);
-            const t1 = nowMs();
-            const durationMs = Math.round((t1 - t0) * 100) / 100;
-            span.setAttributes({
-                [ATTR_MCP_RESOURCE_DURATION_MS]: durationMs,
-                [ATTR_MCP_RESOURCE_SUCCESS]: ok,
-            });
-            if (errorCode)
-                span.setAttribute(ATTR_MCP_RESOURCE_ERROR_CODE, errorCode);
-            span.end();
+    return await measure(RESOURCE_KIND, resourceName, context, { [ATTR_MCP_RESOURCE_URI]: meta.uri, [ATTR_MCP_RESOURCE_MIME_TYPE]: meta.mimeType }, resourceLogicFn, {
+        onSuccess: (span, outcome) => {
+            span.setAttribute(ATTR_MCP_RESOURCE_SIZE_BYTES, outcome.outputBytes);
+        },
+        onSettled: (spanContext, outcome) => {
+            const { durationMs, errorCode, inputRequired, ok, outputBytes } = outcome;
             const m = getResourceMetrics();
             const metricAttrs = {
                 [ATTR_MCP_RESOURCE_NAME]: resourceName,
@@ -492,7 +423,7 @@ export async function measureResourceExecution(resourceLogicFn, context, meta) {
                     mimeType: meta.mimeType,
                 },
             }));
-        }
+        },
     });
 }
 // ==========================================================================
@@ -520,14 +451,23 @@ function getPromptMetrics() {
         promptMessageCount,
     };
 }
+const PROMPT_KIND = {
+    attrs: {
+        durationMs: ATTR_MCP_PROMPT_DURATION_MS,
+        errorCode: ATTR_MCP_PROMPT_ERROR_CODE,
+        inputRequired: ATTR_MCP_PROMPT_INPUT_REQUIRED,
+        success: ATTR_MCP_PROMPT_SUCCESS,
+    },
+    namespace: 'mcp-prompts',
+    spanPrefix: 'prompt_generation',
+};
 /**
  * Wraps a prompt generate function with observability: an OpenTelemetry span,
  * OTel metric counters/histograms, payload size capture, and structured log.
  *
- * Prompts can now perform meaningful work (conditional logic, async data fetches,
+ * Prompts can perform meaningful work (conditional logic, async data fetches,
  * multi-message assembly), so they get the same instrumentation depth as tools
- * and resources. Kept symmetric to {@link measureToolExecution} and
- * {@link measureResourceExecution}.
+ * and resources.
  *
  * @template T - The resolved type of the prompt generate function's return value.
  * @param promptLogicFn - Zero-argument async function containing the prompt's generate logic.
@@ -536,79 +476,18 @@ function getPromptMetrics() {
  * @returns A promise that resolves with the generate result or rejects with the original error.
  */
 export async function measurePromptGeneration(promptLogicFn, context, inputPayload) {
-    const tracer = trace.getTracer(config.openTelemetry.serviceName, config.openTelemetry.serviceVersion);
     const { promptName } = context;
-    return await tracer.startActiveSpan(`prompt_generation:${promptName}`, async (span) => {
-        // Active from here down — see the note in `measureToolExecution`. Prompt
-        // generators take no handler context, so this only re-binds the completion
-        // log below.
-        const spanContext = withActiveSpan(context);
-        const activeGauge = getActiveRequestsGauge();
-        activeGauge.add(1);
-        const t0 = nowMs();
-        const inputBytes = toBytes(inputPayload);
-        span.setAttributes({
-            [ATTR_CODE_FUNCTION_NAME]: promptName,
-            [ATTR_CODE_NAMESPACE]: 'mcp-prompts',
-            [ATTR_MCP_PROMPT_INPUT_BYTES]: inputBytes,
-        });
-        let ok = false;
-        let inputRequired = false;
-        let errorCode;
-        let errorCategory;
-        let outputBytes = 0;
-        let messageCount = 0;
-        try {
-            const result = await promptLogicFn();
-            ok = true;
-            outputBytes = toBytes(result);
-            if (Array.isArray(result))
-                messageCount = result.length;
-            span.setStatus({ code: SpanStatusCode.OK });
-            span.setAttribute(ATTR_MCP_PROMPT_OUTPUT_BYTES, outputBytes);
+    const inputBytes = toBytes(inputPayload);
+    let messageCount = 0;
+    return await measure(PROMPT_KIND, promptName, context, { [ATTR_MCP_PROMPT_INPUT_BYTES]: inputBytes }, promptLogicFn, {
+        onSuccess: (span, outcome) => {
+            if (Array.isArray(outcome.measuredOutput))
+                messageCount = outcome.measuredOutput.length;
+            span.setAttribute(ATTR_MCP_PROMPT_OUTPUT_BYTES, outcome.outputBytes);
             span.setAttribute(ATTR_MCP_PROMPT_MESSAGE_COUNT, messageCount);
-            return result;
-            // `ctx.requestInput(...)` unwinds the handler as a thrown signal, but the
-            // round ended in `input_required` — protocol control flow, not a failure.
-            // Recording it as one would mark the span ERROR, increment the error
-            // counter, and log `isSuccess: false` for every legitimate
-            // multi-round-trip request.
-        }
-        catch (err) {
-            if (isInputRequiredSignal(err)) {
-                ok = true;
-                inputRequired = true;
-                span.setStatus({ code: SpanStatusCode.OK });
-                span.setAttribute(ATTR_MCP_PROMPT_INPUT_REQUIRED, true);
-                throw err;
-            }
-            if (err instanceof McpError) {
-                errorCode = String(err.code);
-                errorCategory = getErrorCategory(err.code);
-            }
-            else {
-                errorCode = err instanceof Error ? 'UNHANDLED_ERROR' : 'UNKNOWN_ERROR';
-                errorCategory = 'server';
-            }
-            if (err instanceof Error)
-                span.recordException(err);
-            span.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: err instanceof Error ? err.message : String(err),
-            });
-            throw err;
-        }
-        finally {
-            activeGauge.add(-1);
-            const t1 = nowMs();
-            const durationMs = Math.round((t1 - t0) * 100) / 100;
-            span.setAttributes({
-                [ATTR_MCP_PROMPT_DURATION_MS]: durationMs,
-                [ATTR_MCP_PROMPT_SUCCESS]: ok,
-            });
-            if (errorCode)
-                span.setAttribute(ATTR_MCP_PROMPT_ERROR_CODE, errorCode);
-            span.end();
+        },
+        onSettled: (spanContext, outcome) => {
+            const { durationMs, errorCategory, errorCode, inputRequired, ok, outputBytes } = outcome;
             const m = getPromptMetrics();
             const metricAttrs = { [ATTR_MCP_PROMPT_NAME]: promptName, [ATTR_MCP_PROMPT_SUCCESS]: ok };
             const promptAttrs = { [ATTR_MCP_PROMPT_NAME]: promptName };
@@ -626,10 +505,9 @@ export async function measurePromptGeneration(promptLogicFn, context, inputPaylo
                 });
             }
             const logFn = ok ? logger.info : logger.error;
-            const promptMessage = ok
+            logFn.call(logger, ok
                 ? TELEMETRY_LOG_MESSAGES.promptGenerationFinished
-                : TELEMETRY_LOG_MESSAGES.promptGenerationFailed;
-            logFn.call(logger, promptMessage, withExtra(spanContext, {
+                : TELEMETRY_LOG_MESSAGES.promptGenerationFailed, withExtra(spanContext, {
                 promptName,
                 metrics: {
                     durationMs,
@@ -641,7 +519,7 @@ export async function measurePromptGeneration(promptLogicFn, context, inputPaylo
                     ...(inputRequired && { inputRequired }),
                 },
             }));
-        }
+        },
     });
 }
 //# sourceMappingURL=performance.js.map