@volcengine/tls-observer-pi 0.0.1

package/dist/index.js

@@ -0,0 +1,2261 @@
+import { homedir, hostname, networkInterfaces, userInfo } from "node:os";
+import { createHash as external_node_crypto_createHash } from "node:crypto";
+import { tlsOpenapi } from "@volcengine/openapi";
+import "node:url";
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external_node_fs_promises_153e37e0 from "node:fs/promises";
+var package_namespaceObject = {
+    rE: "0.0.1"
+};
+function firstEnv(...names) {
+    for (const name of names){
+        const value = process.env[name];
+        if ('string' == typeof value && '' !== value.trim()) return value.trim();
+    }
+}
+function envDisabled(name) {
+    return /^(0|false|no|n|off)$/i.test(process.env[name] ?? '');
+}
+function envPositiveInteger(name, fallback) {
+    const value = Number.parseInt(process.env[name] ?? '', 10);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function parseEnvValue(raw) {
+    const value = raw.trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1).replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\'/g, "'");
+    return value;
+}
+function defaultEnvFile() {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.pi', 'agent', 'tls-observer-pi.env');
+}
+function defaultDataRoot() {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.pi', 'agent', 'tls-observer-pi');
+}
+function loadEnvFile(filePath) {
+    const target = filePath || firstEnv('PI_TLS_ENV_FILE') || defaultEnvFile();
+    let text;
+    try {
+        text = __rspack_external_node_fs_5ea92f0c.readFileSync(target, 'utf8');
+    } catch  {
+        return false;
+    }
+    for (const rawLine of text.split(/\r?\n/)){
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) continue;
+        const normalized = line.startsWith('export ') ? line.slice(7).trim() : line;
+        const match = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+        if (!match) continue;
+        const [, key, rawValue] = match;
+        process.env[key] ??= parseEnvValue(rawValue);
+    }
+    return true;
+}
+function mirroredTlsEnv() {
+    return {
+        ...process.env,
+        TRACE_TLS_ENDPOINT: firstEnv('PI_TLS_ENDPOINT', 'TRACE_TLS_ENDPOINT', 'TLS_ENDPOINT'),
+        TRACE_TLS_REGION: firstEnv('PI_TLS_REGION', 'TRACE_TLS_REGION', 'TLS_REGION'),
+        TRACE_TLS_TRACE_TOPIC_ID: firstEnv('PI_TLS_TRACE_TOPIC_ID', 'PI_TLS_TOPIC_ID', 'TRACE_TLS_TRACE_TOPIC_ID', 'TLS_TRACE_TOPIC_ID'),
+        TRACE_TLS_API_KEY: firstEnv('PI_TLS_API_KEY', 'TRACE_TLS_API_KEY', 'TLS_API_KEY'),
+        TRACE_TLS_AK: firstEnv('PI_TLS_AK', 'TRACE_TLS_AK', 'TLS_AK'),
+        TRACE_TLS_SK: firstEnv('PI_TLS_SK', 'TRACE_TLS_SK', 'TLS_SK'),
+        TRACE_TLS_EXPORT_TIMEOUT_MS: firstEnv('PI_TLS_EXPORT_TIMEOUT_MS', 'TRACE_TLS_EXPORT_TIMEOUT_MS'),
+        TLS_ENDPOINT: firstEnv('PI_TLS_ENDPOINT', 'TLS_ENDPOINT'),
+        TLS_REGION: firstEnv('PI_TLS_REGION', 'TLS_REGION'),
+        TLS_TRACE_TOPIC_ID: firstEnv('PI_TLS_TRACE_TOPIC_ID', 'PI_TLS_TOPIC_ID', 'TLS_TRACE_TOPIC_ID'),
+        TLS_API_KEY: firstEnv('PI_TLS_API_KEY', 'TLS_API_KEY'),
+        TLS_AK: firstEnv('PI_TLS_AK', 'TLS_AK'),
+        TLS_SK: firstEnv('PI_TLS_SK', 'TLS_SK'),
+        TLS_AUTH_MODE: firstEnv('PI_TLS_AUTH_MODE', 'TLS_AUTH_MODE'),
+        PI_TLS_CAPTURE_CONTENT: firstEnv('PI_TLS_CAPTURE_CONTENT')
+    };
+}
+function validateTlsConfig(env) {
+    const missing = [];
+    if (!env.TRACE_TLS_ENDPOINT) missing.push('PI_TLS_ENDPOINT, TRACE_TLS_ENDPOINT, or TLS_ENDPOINT');
+    if (!env.TRACE_TLS_REGION) missing.push('PI_TLS_REGION, TRACE_TLS_REGION, or TLS_REGION');
+    if (!env.TRACE_TLS_TRACE_TOPIC_ID) missing.push('PI_TLS_TRACE_TOPIC_ID, TRACE_TLS_TRACE_TOPIC_ID, or TLS_TRACE_TOPIC_ID');
+    const apiKey = env.TRACE_TLS_API_KEY;
+    const ak = env.TRACE_TLS_AK;
+    const sk = env.TRACE_TLS_SK;
+    if (!apiKey && (!ak || !sk)) missing.push('PI_TLS_API_KEY or PI_TLS_AK/PI_TLS_SK');
+    if (missing.length > 0) throw new Error(`Missing required Pi TLS config: ${missing.join(', ')}`);
+    if (apiKey && (ak || sk)) throw new Error('Pi TLS config must use API Key or AK/SK, not both');
+}
+function loadConfig() {
+    loadEnvFile();
+    const serviceName = firstEnv('PI_OTEL_SERVICE_NAME') || 'pi-plugin';
+    const enabled = !envDisabled('PI_TLS_EXPORT');
+    const env = mirroredTlsEnv();
+    if (enabled) validateTlsConfig(env);
+    return {
+        enabled,
+        dataRoot: firstEnv('PI_TLS_DATA_ROOT') || defaultDataRoot(),
+        captureContent: !envDisabled('PI_TLS_CAPTURE_CONTENT'),
+        serviceName,
+        serviceInstanceId: `${serviceName}@${hostname()}:${process.pid}`,
+        pluginVersion: package_namespaceObject.rE,
+        exportTimeoutMs: envPositiveInteger('PI_TLS_EXPORT_TIMEOUT_MS', 20000),
+        env
+    };
+}
+function stableHexId(seed, length) {
+    const normalized = String(seed ?? '');
+    const digest = external_node_crypto_createHash('sha256').update(normalized).digest('hex').slice(0, length);
+    return digest === '0'.repeat(length) ? '1'.padStart(length, '0') : digest;
+}
+function model_traceIdFromSeed(seed) {
+    return stableHexId(seed, 32);
+}
+function spanIdFromSeed(...parts) {
+    return stableHexId(parts.map((part)=>String(part ?? '')).join(':'), 16);
+}
+function model_toEpochMs(value, fallback = Date.now()) {
+    if (value instanceof Date) {
+        const time = value.getTime();
+        return Number.isFinite(time) ? time : fallback;
+    }
+    if ('number' == typeof value && Number.isFinite(value)) return value;
+    if ('string' == typeof value && '' !== value.trim()) {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed)) return parsed;
+    }
+    return fallback;
+}
+function isRecord(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function validateSpan(span, path) {
+    const errors = [];
+    if (!isRecord(span)) return [
+        `${path} must be an object`
+    ];
+    if ('string' != typeof span.name || '' === span.name.trim()) errors.push(`${path}.name is required`);
+    if (void 0 === span.startedAt && void 0 === span.start_time_unix_ms) errors.push(`${path}.startedAt is required`);
+    if (void 0 === span.endedAt && void 0 === span.end_time_unix_ms) errors.push(`${path}.endedAt is required`);
+    if (void 0 !== span.attributes && !isRecord(span.attributes)) errors.push(`${path}.attributes must be an object`);
+    return errors;
+}
+function validateCanonicalTrace(trace) {
+    const errors = [];
+    const warnings = [];
+    if (!isRecord(trace)) return {
+        valid: false,
+        errors: [
+            'trace must be an object'
+        ],
+        warnings
+    };
+    if (isRecord(trace.source)) {
+        const source = trace.source;
+        if ('string' != typeof source.tool || '' === source.tool.trim()) errors.push('source.tool is required');
+        if ('string' != typeof source.sessionId || '' === source.sessionId.trim()) errors.push('source.sessionId is required');
+    } else errors.push('source is required');
+    errors.push(...validateSpan(trace.root, 'root'));
+    if (Array.isArray(trace.spans)) for (const [index, span] of trace.spans.entries())errors.push(...validateSpan(span, `spans[${index}]`));
+    else errors.push('spans must be an array');
+    if (void 0 !== trace.messages && !Array.isArray(trace.messages)) errors.push('messages must be an array');
+    if (void 0 !== trace.diagnostics) if (isRecord(trace.diagnostics)) {
+        if (void 0 !== trace.diagnostics.warnings && !Array.isArray(trace.diagnostics.warnings)) warnings.push('diagnostics.warnings should be an array');
+    } else warnings.push('diagnostics should be an object');
+    return {
+        valid: 0 === errors.length,
+        errors,
+        warnings
+    };
+}
+function assertCanonicalTrace(trace) {
+    const result = validateCanonicalTrace(trace);
+    if (!result.valid) {
+        const error = new Error(`Invalid canonical trace: ${result.errors.join('; ')}`);
+        error.name = 'CanonicalTraceValidationError';
+        error.validation = result;
+        throw error;
+    }
+    return trace;
+}
+const DEFAULT_MAX_ATTR_LENGTH = 65536;
+const MAX_ATTR_LENGTH_ENV_KEYS = [
+    'TRACE_OTLP_ATTRIBUTE_VALUE_MAX_CHARS',
+    'CODEX_OTLP_ATTRIBUTE_VALUE_MAX_CHARS'
+];
+function resolveMaxAttrLength(env = process.env) {
+    for (const key of MAX_ATTR_LENGTH_ENV_KEYS){
+        const raw = env[key];
+        if (null == raw || '' === raw.trim()) continue;
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed) && parsed >= 0) return Math.trunc(parsed);
+    }
+    return DEFAULT_MAX_ATTR_LENGTH;
+}
+function truncateTextForAttr(value) {
+    return String(value ?? '').slice(0, resolveMaxAttrLength());
+}
+function safeStringify(value) {
+    const seen = new WeakSet();
+    return JSON.stringify(value, (_key, item)=>{
+        if (item && 'object' == typeof item) {
+            if (seen.has(item)) return '[Circular]';
+            seen.add(item);
+        }
+        return item;
+    });
+}
+function maskToken(value) {
+    if (value.length <= 8) return '***';
+    return `${value.slice(0, 3)}***${value.slice(-2)}`;
+}
+function redactSensitiveText(text) {
+    return String(text ?? '').replace(/\bAK[0-9A-Za-z]{16,}\b/g, maskToken).replace(/\b(Bearer\s+)([A-Za-z0-9._-]{8,})/gi, (_match, prefix, token)=>`${prefix}${maskToken(token)}`).replace(/\b(token|secret|password|passwd|api[_-]?key|access[_-]?key|sk)\s*[:=]\s*([^,\s"']{8,})/gi, (_match, key, secret)=>`${key}=***${String(secret).slice(-2)}`);
+}
+function attributes_serializeForAttr(value) {
+    const serialized = 'string' == typeof value ? value : safeStringify(value);
+    return redactSensitiveText(truncateTextForAttr(serialized ?? String(value)));
+}
+function spanKindName(span) {
+    const kind = String(span.span_kind ?? span.kind ?? '').toUpperCase();
+    if ('SERVER' === kind) return 'server';
+    if ('CLIENT' === kind) return 'client';
+    return 'internal';
+}
+function unixMsToUs(value) {
+    return String(1000 * Math.trunc(model_toEpochMs(value)));
+}
+function span_utils_hasError(span) {
+    const statusObjectCode = null != span.status && 'object' == typeof span.status ? span.status.code : void 0;
+    const statusCode = statusObjectCode ?? span.status_code ?? span.statusCode ?? span.status;
+    if (2 === statusCode || 'ERROR' === String(statusCode).toUpperCase()) return true;
+    return Object.entries(span.attributes ?? {}).some(([key, value])=>{
+        if (true === value && ('error' === key || key.endsWith('.error'))) return true;
+        if ('tool.error' === key && 'string' == typeof value && '' !== value.trim()) return true;
+        return false;
+    });
+}
+function spanDurationMs(span) {
+    if ('number' == typeof span.duration_ms && Number.isFinite(span.duration_ms)) return Math.max(0, Math.trunc(span.duration_ms));
+    const start = model_toEpochMs(span.start_time_unix_ms ?? span.startedAt);
+    const end = model_toEpochMs(span.end_time_unix_ms ?? span.endedAt, start);
+    return Math.max(0, Math.trunc(end - start));
+}
+const SCHEMA_FIELD_ORDER = [
+    'span.name',
+    'span.kind',
+    'tls.app.type',
+    'session.id',
+    'span.status.code',
+    'start_time_unix_us',
+    'end_time_unix_us',
+    'span.duration_us',
+    'service.name',
+    'service.instance.id',
+    'host.name',
+    'client.address',
+    'observed_time_unix_ms',
+    'telemetry.sdk.name',
+    'telemetry.sdk.language',
+    'telemetry.sdk.version',
+    'otel.scope.name',
+    'otel.scope.version',
+    'event.name',
+    'user.role',
+    'gen_ai.operation.name',
+    'gen_ai.provider.name',
+    'gen_ai.request.model',
+    'gen_ai.response.model',
+    'gen_ai.request.duration_ms',
+    'gen_ai.input.messages',
+    'gen_ai.output.messages',
+    'gen_ai.usage.input_tokens',
+    'gen_ai.usage.output_tokens',
+    'gen_ai.usage.reasoning.output_tokens',
+    'gen_ai.usage.cache_read.input_tokens',
+    'gen_ai.usage.cache_creation.input_tokens',
+    'gen_ai.usage.total_tokens',
+    'gen_ai.tool.name',
+    'gen_ai.tool.call.id',
+    'gen_ai.tool.call.arguments',
+    'gen_ai.tool.call.result',
+    'tool.error',
+    'error.type',
+    'error.message'
+];
+function normalizeOptions(options) {
+    if ('number' == typeof options) return {
+        observedTimeUnixMs: options,
+        version: '-'
+    };
+    return {
+        observedTimeUnixMs: options.observedTimeUnixMs ?? Date.now(),
+        version: options.version?.trim() || '-'
+    };
+}
+function hasMessages(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function stableFieldValue(value) {
+    if (null == value) return '';
+    if ('string' == typeof value) return attributes_serializeForAttr(value);
+    if ('number' == typeof value || 'boolean' == typeof value) return value;
+    return attributes_serializeForAttr(value);
+}
+function inferUserRole(span) {
+    const inputMessage = hasMessages(span.input) ? span.input.messages?.find((message)=>'string' == typeof message?.role) : void 0;
+    const role = inputMessage?.role;
+    if ('string' == typeof role && [
+        'assistant',
+        'system',
+        'tool',
+        'user'
+    ].includes(role)) return role;
+    return '';
+}
+function inferErrorMessage(span) {
+    const output = span.output;
+    if (null == output) return '';
+    if ('string' == typeof output) return output;
+    if ('object' == typeof output && 'error' in output && 'string' == typeof output.error) return output.error;
+    if ('object' == typeof output && 'error' in output && null != output.error) return attributes_serializeForAttr(output.error);
+    return '';
+}
+function schemaSourceAttribute(attributes, dotted, legacy) {
+    return attributes[dotted] ?? attributes[legacy] ?? '';
+}
+function normalizedSpanName(span) {
+    if ('model' === span.type) return 'llm.request';
+    if ('tool' === span.type) return 'tool.call';
+    if ('message' === span.type) return 'agent.turn';
+    return span.name ?? '';
+}
+function legacyToolErrorMessage(value) {
+    return 'string' == typeof value ? value : '';
+}
+function buildSchemaAlignedRecord(trace, span, options = {}) {
+    const { observedTimeUnixMs, version } = normalizeOptions(options);
+    const attributes = span.attributes ?? {};
+    const resource = trace.resource ?? {};
+    const isError = span_utils_hasError(span);
+    const isTool = 'tool' === span.type;
+    const isModel = 'model' === span.type;
+    const isMessage = 'message' === span.type;
+    const inputMessages = hasMessages(span.input) ? span.input.messages ?? attributes['gen_ai.input.messages'] : attributes['gen_ai.input.messages'];
+    const outputMessages = hasMessages(span.output) ? span.output.messages ?? attributes['gen_ai.output.messages'] : attributes['gen_ai.output.messages'];
+    const explicitErrorMessage = attributes['error.message'];
+    const spanName = normalizedSpanName(span);
+    const toolErrorMessage = isTool ? 'string' == typeof explicitErrorMessage && explicitErrorMessage || legacyToolErrorMessage(attributes['tool.error']) || inferErrorMessage(span) : '';
+    const record = {
+        'span.name': spanName,
+        'span.kind': spanKindName(span),
+        'tls.app.type': attributes['tls.app.type'] ?? 'codex',
+        'session.id': schemaSourceAttribute(attributes, 'session.id', 'codex.session_id'),
+        'span.status.code': isError ? 'ERROR' : 'UNSET',
+        start_time_unix_us: unixMsToUs(span.start_time_unix_ms ?? span.startedAt),
+        end_time_unix_us: unixMsToUs(span.end_time_unix_ms ?? span.endedAt),
+        'span.duration_us': String(1000 * spanDurationMs(span)),
+        'service.name': resource['service.name'] ?? "codex-transcript-stop-hook",
+        'service.instance.id': resource['service.instance.id'] ?? '',
+        'host.name': resource['host.name'] ?? '',
+        'client.address': '',
+        observed_time_unix_ms: observedTimeUnixMs,
+        'telemetry.sdk.name': resource['telemetry.sdk.name'] ?? "codex-transcript-stop-hook",
+        'telemetry.sdk.language': resource['telemetry.sdk.language'] ?? 'nodejs',
+        'telemetry.sdk.version': resource['telemetry.sdk.version'] ?? version,
+        'otel.scope.name': trace.scope?.name ?? "codex-transcript-stop-hook",
+        'otel.scope.version': trace.scope?.version ?? version,
+        'event.name': spanName,
+        'user.role': inferUserRole(span),
+        'gen_ai.operation.name': attributes['gen_ai.operation.name'] ?? (isModel ? 'chat' : isMessage ? 'invoke_agent' : ''),
+        'gen_ai.provider.name': attributes['gen_ai.provider.name'] ?? '',
+        'gen_ai.request.model': attributes['gen_ai.request.model'] ?? '',
+        'gen_ai.response.model': attributes['gen_ai.response.model'] ?? attributes['gen_ai.request.model'] ?? '',
+        'gen_ai.request.duration_ms': isModel ? spanDurationMs(span) : attributes['request.duration_ms'] ?? '',
+        'gen_ai.input.messages': inputMessages ?? '',
+        'gen_ai.output.messages': outputMessages ?? '',
+        'gen_ai.usage.input_tokens': attributes['gen_ai.usage.input_tokens'] ?? '',
+        'gen_ai.usage.output_tokens': attributes['gen_ai.usage.output_tokens'] ?? '',
+        'gen_ai.usage.reasoning.output_tokens': attributes['gen_ai.usage.reasoning.output_tokens'] ?? '',
+        'gen_ai.usage.cache_read.input_tokens': attributes['gen_ai.usage.cache_read.input_tokens'] ?? '',
+        'gen_ai.usage.cache_creation.input_tokens': attributes['gen_ai.usage.cache_creation.input_tokens'] ?? '',
+        'gen_ai.usage.total_tokens': attributes['gen_ai.usage.total_tokens'] ?? '',
+        'gen_ai.tool.name': isTool ? attributes['gen_ai.tool.name'] ?? attributes['tool.name'] ?? '' : '',
+        'gen_ai.tool.call.id': isTool ? attributes['gen_ai.tool.call.id'] ?? attributes['codex.tool_call_id'] ?? '' : '',
+        'gen_ai.tool.call.arguments': isTool ? span.input ?? '' : '',
+        'gen_ai.tool.call.result': isTool ? span.output ?? '' : '',
+        'tool.error': isTool ? isError : '',
+        'error.type': isError ? attributes['codex.tool_status'] ?? 'error' : '',
+        'error.message': isError ? toolErrorMessage : ''
+    };
+    const aligned = {};
+    for (const key of SCHEMA_FIELD_ORDER)aligned[key] = stableFieldValue(record[key]);
+    return aligned;
+}
+function buildSchemaAlignedRecords(trace, options = {}) {
+    if (!trace || !Array.isArray(trace.spans)) return [];
+    return trace.spans.map((span)=>buildSchemaAlignedRecord(trace, span, options));
+}
+new Set([
+    'trace.id',
+    'trace.state',
+    'span.id',
+    'parent.span.id',
+    'span.kind',
+    'span.name',
+    'span.status.code',
+    'span.status.message',
+    'span.events',
+    'span.links',
+    'event.type',
+    'event.name',
+    'service.name',
+    'service.instance.id',
+    'host.name',
+    'client.address',
+    'observed_time_unix_ms',
+    'telemetry.sdk.name',
+    'telemetry.sdk.language',
+    'telemetry.sdk.version',
+    'otel.scope.name',
+    'otel.scope.version',
+    'start_time_unix_us',
+    'end_time_unix_us',
+    'span.duration_us'
+]);
+new Set([
+    'session.id',
+    'app.thread.id',
+    'gen_ai.conversation.id',
+    'gen_ai.agent.id',
+    'app.run.id',
+    'app.turn.id',
+    'user.id',
+    'codex.input',
+    'codex.output',
+    'span_type',
+    'codex_span_type',
+    'codex_session_id',
+    'codex_thread_id',
+    'codex_conversation_id',
+    'codex_parent_conversation_id',
+    'codex_agent_id',
+    'codex_turn_id',
+    'codex_turn_index',
+    'codex_originator',
+    'codex_cli_version',
+    'codex_cwd',
+    "codex_transcript_path",
+    'codex_permission_mode',
+    'codex_agent_scope',
+    'codex_runtime_tags',
+    'codex_decision_tool_name',
+    'codex_decision_tool_call_id',
+    'codex_tool_call_id',
+    'codex_tool_status',
+    'codex_tool_exit_code',
+    'codex.system_tag_runtime',
+    'gen_ai.usage.input',
+    'gen_ai.usage.output',
+    'gen_ai.usage.totalTokens',
+    'gen_ai.usage.cacheRead',
+    'gen_ai.usage.reasoningOutput'
+]);
+function sourceAttributes(source) {
+    return {
+        'source.tool': source.tool,
+        'session.id': source.sessionId,
+        'app.turn.id': source.turnId,
+        'app.thread.id': source.threadId,
+        'gen_ai.conversation.id': source.conversationId,
+        'process.command.cwd': source.cwd,
+        'gen_ai.request.model': source.model,
+        ...source.attributes ?? {}
+    };
+}
+function resourceAttributes(trace, options) {
+    const source = trace.source ?? {};
+    return {
+        'service.name': options.serviceName ?? `${source.tool ?? 'agent'}-trace-hook`,
+        'service.instance.id': source.sessionId ?? '',
+        'host.name': hostname(),
+        'telemetry.sdk.name': 'agent-trace-reporter',
+        'telemetry.sdk.language': 'nodejs',
+        'telemetry.sdk.version': options.sdkVersion ?? '0.1.0',
+        ...options.resourceAttributes ?? {}
+    };
+}
+function canonicalSpanToLegacy(span, traceId, parentId, commonAttributes, index) {
+    const spanId = span.id ?? span.span_id ?? spanIdFromSeed(traceId, span.name, index);
+    const startedAt = span.start_time_unix_ms ?? span.startedAt;
+    const endedAt = span.end_time_unix_ms ?? span.endedAt;
+    return {
+        trace_id: traceId,
+        span_id: spanId,
+        parent_span_id: span.parentId ?? span.parent_span_id ?? parentId,
+        name: span.name,
+        type: span.type ?? 'internal',
+        span_kind: String(span.kind ?? 'internal').toUpperCase(),
+        start_time_unix_ms: model_toEpochMs(startedAt),
+        end_time_unix_ms: model_toEpochMs(endedAt, model_toEpochMs(startedAt)),
+        duration_ms: Math.max(0, model_toEpochMs(endedAt, model_toEpochMs(startedAt)) - model_toEpochMs(startedAt)),
+        status_code: 'error' === span.status ? 'ERROR' : 'UNSET',
+        input: span.input,
+        output: span.output,
+        attributes: {
+            ...commonAttributes,
+            ...span.attributes ?? {}
+        }
+    };
+}
+function canonicalTraceToOtelTrace(trace, options = {}) {
+    const seed = [
+        trace.source?.tool,
+        trace.source?.sessionId,
+        trace.source?.turnId,
+        trace.root?.name,
+        trace.root?.startedAt
+    ].join(':');
+    const traceId = trace.traceId ?? model_traceIdFromSeed(seed);
+    const commonAttributes = sourceAttributes(trace.source ?? {});
+    const root = canonicalSpanToLegacy(trace.root ?? {
+        name: 'root'
+    }, traceId, '', commonAttributes, 'root');
+    root.span_id = trace.root?.id ?? trace.spanId ?? spanIdFromSeed(traceId, 'root');
+    root.parent_span_id = '';
+    return {
+        traceId,
+        resource: resourceAttributes(trace, options),
+        scope: {
+            name: options.scopeName ?? 'agent-trace-reporter',
+            version: options.scopeVersion ?? '0.1.0'
+        },
+        spans: [
+            root,
+            ...(trace.spans ?? []).map((span, index)=>canonicalSpanToLegacy(span, traceId, root.span_id ?? '', commonAttributes, index))
+        ]
+    };
+}
+const TLS_ANONYMOUS_IDENTITY_HEADER = 'x-tls-anonymous-identity';
+const DEFAULT_FILE_NAME = 'agent-trace';
+const NO_RETRY_STATUS_CODES = [
+    400,
+    401,
+    403,
+    404
+];
+const producerEntries = new Map();
+function firstExternalIpv4() {
+    for (const items of Object.values(networkInterfaces()))for (const item of items ?? [])if ('IPv4' === item.family && !item.internal && item.address) return item.address;
+    return '127.0.0.1';
+}
+function normalizeProducerEndpoint(endpoint) {
+    const raw = endpoint.trim();
+    if (!raw) return raw;
+    try {
+        const url = new URL(/^https?:\/\//.test(raw) ? raw : `https://${raw}`);
+        return url.host || raw;
+    } catch  {
+        return raw.replace(/^https?:\/\//, '').replace(/\/.*$/, '');
+    }
+}
+function producerKey(config) {
+    return JSON.stringify({
+        endpoint: normalizeProducerEndpoint(config.endpoint),
+        region: config.region,
+        apiKey: config.apiKey || '',
+        ak: config.ak || '',
+        sk: config.sk || ''
+    });
+}
+function createProducer(config) {
+    const producerConfig = tlsOpenapi.Producer.getDefaultProducerConfig();
+    producerConfig.Endpoint = normalizeProducerEndpoint(config.endpoint);
+    producerConfig.Region = config.region;
+    producerConfig.NoRetryStatusCodeList = NO_RETRY_STATUS_CODES;
+    if (config.apiKey) {
+        producerConfig.AccessKeyID = '';
+        producerConfig.AccessKeySecret = '';
+        producerConfig.Headers = {
+            [TLS_ANONYMOUS_IDENTITY_HEADER]: config.apiKey
+        };
+    } else {
+        producerConfig.AccessKeyID = config.ak || '';
+        producerConfig.AccessKeySecret = config.sk || '';
+    }
+    const producer = new tlsOpenapi.Producer(producerConfig);
+    producer.Start();
+    return {
+        producer,
+        source: firstExternalIpv4(),
+        timeoutMs: config.timeoutMs
+    };
+}
+function timeoutError(label, timeoutMs) {
+    return new Error(`${label} timed out after ${timeoutMs}ms`);
+}
+function withTimeout(promise, timeoutMs, label) {
+    const effectiveTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.trunc(timeoutMs) : 20000;
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>reject(timeoutError(label, effectiveTimeoutMs)), effectiveTimeoutMs);
+        promise.then((value)=>{
+            clearTimeout(timer);
+            resolve(value);
+        }, (error)=>{
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function getProducer(config) {
+    const key = producerKey(config);
+    const existing = producerEntries.get(key);
+    if (existing) return existing;
+    const created = createProducer(config);
+    producerEntries.set(key, created);
+    return created;
+}
+function recordContents(record) {
+    return Object.entries(record).map(([Key, Value])=>({
+            Key,
+            Value
+        }));
+}
+async function sendTlsLogRecords(config, records, fileName = DEFAULT_FILE_NAME) {
+    if (0 === records.length) return;
+    const testMode = process.env.TRACE_TLS_TEST_PRODUCER_MODE;
+    const captureFile = process.env.TRACE_TLS_TEST_PRODUCER_CAPTURE_FILE;
+    if (testMode || captureFile) {
+        if (captureFile) {
+            await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(captureFile), {
+                recursive: true
+            });
+            await __rspack_external_node_fs_promises_153e37e0.appendFile(captureFile, `${JSON.stringify({
+                topic_id: config.traceTopicId,
+                endpoint: normalizeProducerEndpoint(config.endpoint),
+                region: config.region,
+                file_name: fileName,
+                records
+            })}\n`, 'utf8');
+        }
+        if ('fail' === testMode) throw new Error('TRACE_TLS_TEST_PRODUCER_MODE=fail');
+        return;
+    }
+    const entry = getProducer(config);
+    const logGroup = {
+        Logs: records.map((record)=>({
+                Time: Date.now(),
+                Contents: recordContents(record)
+            })),
+        Source: entry.source,
+        LogTags: [],
+        FileName: fileName
+    };
+    await withTimeout(new Promise((resolve, reject)=>{
+        let settled = false;
+        const settle = (fn, value)=>{
+            if (settled) return;
+            settled = true;
+            fn(value);
+        };
+        const resolveUnknown = resolve;
+        const sendPromise = entry.producer.SendLogs('', config.traceTopicId, entry.source, fileName, logGroup, {
+            Success: ()=>settle(resolveUnknown),
+            Fail: (result)=>{
+                const attempts = result?.Attempts ?? [];
+                const lastAttempt = attempts[attempts.length - 1] ?? {};
+                settle(reject, new Error(`TLS SendLogs failed topicId=${config.traceTopicId} requestId=${String(lastAttempt.RequestId ?? '')} errorCode=${String(lastAttempt.ErrorCode ?? '')} errorMessage=${String(lastAttempt.ErrorMessage ?? '')}`));
+            }
+        });
+        Promise.resolve(sendPromise).catch((error)=>settle(reject, error));
+    }), config.timeoutMs, 'TLS SendLogs');
+}
+function config_firstEnv(env, ...names) {
+    for (const name of names){
+        const value = env[name];
+        if ('string' == typeof value && '' !== value.trim()) return value.trim();
+    }
+}
+function tlsEndpointFromLegacyOtelEndpoint(value) {
+    if (!value) return;
+    try {
+        const url = new URL(/^https?:\/\//i.test(value) ? value : `https://${value}`);
+        return url.hostname || void 0;
+    } catch  {
+        return value.trim().replace(/^https?:\/\//i, '').replace(/\/.*$/, '').replace(/:\d+$/, '') || void 0;
+    }
+}
+function config_resolveTlsConfig(env) {
+    const disabled = /^(0|false|no)$/i.test(config_firstEnv(env, 'TRACE_TLS_EXPORT', 'CODEX_TLS_EXPORT') ?? '');
+    if (disabled) return {
+        enabled: false,
+        reason: 'disabled'
+    };
+    const endpoint = config_firstEnv(env, 'TRACE_TLS_ENDPOINT', 'CODEX_TLS_ENDPOINT') || tlsEndpointFromLegacyOtelEndpoint(config_firstEnv(env, 'TRACE_TLS_OTEL_ENDPOINT', 'CODEX_TLS_OTEL_ENDPOINT', 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'));
+    const region = config_firstEnv(env, 'TRACE_TLS_REGION', 'CODEX_TLS_REGION', 'TLS_REGION');
+    const traceTopicId = config_firstEnv(env, 'TRACE_TLS_TRACE_TOPIC_ID', 'TRACE_TLS_TOPIC_ID', 'CODEX_TLS_TRACE_TOPIC_ID', 'CODEX_TLS_TOPIC_ID', 'CODEX_TLS_TRACE_TOPICID', 'TLS_TRACE_TOPIC_ID');
+    const apiKey = config_firstEnv(env, 'TRACE_TLS_API_KEY', 'CODEX_TLS_API_KEY', 'TLS_API_KEY');
+    const ak = config_firstEnv(env, 'TRACE_TLS_AK', 'CODEX_TLS_AK', 'TLS_AK');
+    const sk = config_firstEnv(env, 'TRACE_TLS_SK', 'CODEX_TLS_SK', 'TLS_SK');
+    const timeoutMs = Number(config_firstEnv(env, 'TRACE_TLS_EXPORT_TIMEOUT_MS', 'CODEX_TLS_EXPORT_TIMEOUT_MS') ?? 20000);
+    const missing = [];
+    if (!endpoint) missing.push('TRACE_TLS_ENDPOINT or CODEX_TLS_ENDPOINT');
+    if (!region) missing.push('TRACE_TLS_REGION or CODEX_TLS_REGION');
+    if (!traceTopicId) missing.push('TRACE_TLS_TRACE_TOPIC_ID or CODEX_TLS_TRACE_TOPIC_ID');
+    if (!apiKey && (!ak || !sk)) missing.push('TRACE_TLS_API_KEY or TRACE_TLS_AK/TRACE_TLS_SK');
+    if (missing.length > 0 || !endpoint || !region || !traceTopicId) return {
+        enabled: false,
+        reason: 'missing_config',
+        missing
+    };
+    if (apiKey && (ak || sk)) return {
+        enabled: false,
+        reason: 'invalid_auth',
+        missing: [
+            'use apiKey or ak/sk, not both'
+        ]
+    };
+    return {
+        enabled: true,
+        endpoint,
+        region,
+        traceTopicId,
+        apiKey,
+        ak,
+        sk,
+        timeoutMs: Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 20000
+    };
+}
+const TLS_AUTH_RESOURCE_KEYS = {
+    traceTopicId: 'tls.otel.tracetopic',
+    apiKey: 'tls.otel.apikey',
+    ak: 'tls.otel.ak',
+    sk: 'tls.otel.sk',
+    region: 'tls.otel.region'
+};
+const TLS_AUTH_RESOURCE_CREDENTIAL_KEYS = new Set([
+    TLS_AUTH_RESOURCE_KEYS.apiKey,
+    TLS_AUTH_RESOURCE_KEYS.ak,
+    TLS_AUTH_RESOURCE_KEYS.sk
+]);
+function otlpAnyValueHasContent(value) {
+    if (!value || 'object' != typeof value) return false;
+    return Object.values(value).some((item)=>null != item && '' !== String(item).trim());
+}
+function otlpPayloadResourceAttributes(payload) {
+    return (payload.resourceSpans ?? []).flatMap((resourceSpan)=>{
+        const attributes = resourceSpan?.resource?.attributes;
+        return Array.isArray(attributes) ? attributes : [];
+    });
+}
+function otlpPayloadContainsTlsCredentials(body) {
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    } catch  {
+        return [
+            ...TLS_AUTH_RESOURCE_CREDENTIAL_KEYS
+        ].some((key)=>body.includes(key));
+    }
+    if ([
+        ...TLS_AUTH_RESOURCE_CREDENTIAL_KEYS
+    ].some((key)=>body.includes(key))) return true;
+    return otlpPayloadResourceAttributes(payload).some((attribute)=>TLS_AUTH_RESOURCE_CREDENTIAL_KEYS.has(attribute?.key) && otlpAnyValueHasContent(attribute?.value));
+}
+const ATTRIBUTE_PREFIXES = [
+    'gen_ai.',
+    'error.'
+];
+const ATTRIBUTE_KEYS = new Set([
+    'tool.error'
+]);
+const NUMERIC_ATTRIBUTE_KEYS = new Set([
+    'gen_ai.request.duration_ms',
+    'gen_ai.usage.input_tokens',
+    'gen_ai.usage.output_tokens',
+    'gen_ai.usage.reasoning.output_tokens',
+    'gen_ai.usage.cache_read.input_tokens',
+    'gen_ai.usage.cache_creation.input_tokens',
+    'gen_ai.usage.total_tokens'
+]);
+const TLS_AUTH_RESOURCE_KEY_SET = new Set(Object.values(TLS_AUTH_RESOURCE_KEYS));
+function stringifyLogValue(value) {
+    if (null == value) return '';
+    if ('string' == typeof value) return value;
+    if ('number' == typeof value || 'boolean' == typeof value) return String(value);
+    return attributes_serializeForAttr(value);
+}
+function stringifyRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value])=>[
+            key,
+            stringifyLogValue(value)
+        ]));
+}
+function traceIdOf(trace) {
+    return trace?.trace_id ?? trace?.traceId ?? '';
+}
+function spanIdOf(span) {
+    return span?.span_id ?? span?.id ?? '';
+}
+function parentSpanIdOf(span) {
+    return span?.parent_span_id ?? span?.parentId ?? '';
+}
+function records_traceSpansWithRoot(trace) {
+    const spans = trace?.spans ?? [];
+    const root = trace?.root;
+    if (!root) return spans;
+    const rootSpanId = spanIdOf(root);
+    if (rootSpanId && spans.some((span)=>spanIdOf(span) === rootSpanId)) return spans;
+    return [
+        root,
+        ...spans
+    ];
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value ?? {});
+    } catch  {
+        return '{}';
+    }
+}
+function normalizeSpanName(span, fallback = '') {
+    if (span?.type === 'model') return 'llm.request';
+    if (span?.type === 'tool') return 'tool.call';
+    if (span?.type === 'message') return 'agent.turn';
+    if ('codex_turn' === fallback) return 'agent.turn';
+    return fallback || span?.name || '';
+}
+function envelopeKind(span, name) {
+    if ('agent.turn' === name) return 'server';
+    if ('llm.request' === name || 'tool.call' === name) return 'client';
+    return span ? spanKindName(span) : 'internal';
+}
+function isEmptyAttributeValue(value) {
+    return null == value || '' === value;
+}
+function normalizeAttributeValue(key, value) {
+    if (isEmptyAttributeValue(value)) return;
+    if (NUMERIC_ATTRIBUTE_KEYS.has(key)) {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) return numeric;
+    }
+    if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value) return value;
+    return attributes_serializeForAttr(value);
+}
+function envelopeAttributes(record, span) {
+    const attributes = {};
+    const spanAttributes = span?.attributes ?? {};
+    const conversationId = record['gen_ai.conversation.id'] ?? spanAttributes['gen_ai.conversation.id'] ?? record['session.id'];
+    for (const [key, value] of Object.entries(record))if ('tls.app.type' === key || 'session.id' === key || 'gen_ai.conversation.id' === key || ATTRIBUTE_KEYS.has(key) || ATTRIBUTE_PREFIXES.some((prefix)=>key.startsWith(prefix))) {
+        const normalized = normalizeAttributeValue(key, value);
+        if (void 0 !== normalized) attributes[key] = normalized;
+    }
+    attributes['tls.app.type'] ??= 'codex';
+    if (!isEmptyAttributeValue(record['session.id'])) attributes['session.id'] ??= record['session.id'];
+    if (!isEmptyAttributeValue(conversationId)) attributes['gen_ai.conversation.id'] ??= conversationId;
+    if (span?.type === 'message') attributes['gen_ai.operation.name'] = 'invoke_agent';
+    if (span?.type === 'model') attributes['gen_ai.operation.name'] = 'chat';
+    return attributes;
+}
+function envelopeResource(trace, record) {
+    const resource = trace.resource ?? {};
+    return Object.fromEntries(Object.entries({
+        ...resource,
+        'service.instance.id': record['service.instance.id'] ?? resource['service.instance.id'],
+        'telemetry.sdk.language': record['telemetry.sdk.language'] ?? resource['telemetry.sdk.language'] ?? 'nodejs',
+        'telemetry.sdk.name': record['telemetry.sdk.name'] ?? resource['telemetry.sdk.name'] ?? "codex-transcript-stop-hook",
+        'telemetry.sdk.version': record['telemetry.sdk.version'] ?? resource['telemetry.sdk.version'] ?? '0.1.0'
+    }).filter(([key, value])=>!TLS_AUTH_RESOURCE_KEY_SET.has(key) && !isEmptyAttributeValue(value)));
+}
+function otlpEnvelopeRecord(trace, span, record) {
+    const name = normalizeSpanName(span, String(record['span.name'] ?? ''));
+    const start = String(record['start_time_unix_us'] ?? unixMsToUs(span?.start_time_unix_ms ?? span?.startedAt));
+    const end = String(record['end_time_unix_us'] ?? unixMsToUs(span?.end_time_unix_ms ?? span?.endedAt));
+    const duration = String(record['span.duration_us'] ?? 1000 * spanDurationMs(span ?? {}));
+    const error = span ? span_utils_hasError(span) : 'ERROR' === record['span.status.code'];
+    const resource = envelopeResource(trace, record);
+    const serviceName = stringifyLogValue(record['service.name'] ?? resource['service.name'] ?? "codex-transcript-stop-hook");
+    const host = stringifyLogValue(record['host.name'] ?? resource['host.name'] ?? '');
+    const scopeName = stringifyLogValue(record['otel.scope.name'] ?? trace.scope?.name ?? "codex-transcript-stop-hook");
+    const scopeVersion = stringifyLogValue(record['otel.scope.version'] ?? trace.scope?.version ?? '0.1.0');
+    return stringifyRecord({
+        Attributes: safeJsonStringify(envelopeAttributes(record, span)),
+        Duration: duration,
+        End: end,
+        Events: '[]',
+        Host: host,
+        Kind: envelopeKind(span, name),
+        Links: '[]',
+        Name: name,
+        OTLPName: scopeName,
+        OTLPVersion: scopeVersion,
+        ParentSpanID: parentSpanIdOf(span) || record['parent.span.id'] || '',
+        Resource: safeJsonStringify(resource),
+        ServiceName: serviceName,
+        SpanID: spanIdOf(span) || String(record['span.id'] ?? ''),
+        Start: start,
+        StatusCode: error ? 'ERROR' : 'OK',
+        StatusDescription: error ? record['error.message'] ?? '' : '',
+        TraceID: span?.trace_id ?? traceIdOf(trace) ?? record['trace.id'] ?? '',
+        TraceState: ''
+    });
+}
+function recordsFromTrace(trace) {
+    const spans = records_traceSpansWithRoot(trace);
+    const schemaRecords = buildSchemaAlignedRecords({
+        ...trace,
+        spans
+    });
+    return schemaRecords.map((record, index)=>otlpEnvelopeRecord(trace, spans[index], record));
+}
+function exporter_traceIdOf(trace) {
+    return trace?.trace_id ?? trace?.traceId ?? '';
+}
+function notifyRequestBody(options, request) {
+    if ('function' != typeof options.onRequestBody) return;
+    try {
+        options.onRequestBody(request);
+    } catch  {}
+}
+function endpointDiagnostics(config) {
+    return {
+        endpoint_host: normalizeProducerEndpoint(config.endpoint),
+        endpoint_path: 'SendLogs',
+        region: config.region
+    };
+}
+async function exportRecordsToTls(records, config, metadata = {}, options = {}, fileName = 'agent-trace') {
+    if (0 === records.length) return {
+        status: 'skipped',
+        reason: 'empty_records'
+    };
+    const body = JSON.stringify({
+        records
+    });
+    const startedAt = Date.now();
+    const traceId = 'string' == typeof metadata.trace_id ? metadata.trace_id : records[0]?.TraceID ?? records[0]?.['trace.id'] ?? '';
+    const spanCount = Number.isFinite(Number(metadata.span_count)) ? Number(metadata.span_count) : records.length;
+    notifyRequestBody(options, {
+        body,
+        attempt: 1,
+        request_kind: 'tls_log_records',
+        payload_bytes: Buffer.byteLength(body, 'utf8'),
+        record_count: records.length,
+        span_count: spanCount,
+        trace_id: traceId,
+        ...endpointDiagnostics(config)
+    });
+    try {
+        await sendTlsLogRecords(config, records, fileName);
+        return {
+            status: 'sent',
+            trace_id: traceId,
+            span_count: spanCount,
+            record_count: records.length,
+            payload_bytes: Buffer.byteLength(body, 'utf8'),
+            attempts: 1,
+            total_duration_ms: Date.now() - startedAt,
+            ...endpointDiagnostics(config)
+        };
+    } catch (error) {
+        return {
+            status: 'failed',
+            reason: 'producer_error',
+            message: error instanceof Error ? error.message : String(error),
+            trace_id: traceId,
+            span_count: spanCount,
+            record_count: records.length,
+            payload_bytes: Buffer.byteLength(body, 'utf8'),
+            attempts: 1,
+            total_duration_ms: Date.now() - startedAt,
+            error_name: error instanceof Error ? error.name : void 0,
+            ...endpointDiagnostics(config)
+        };
+    }
+}
+async function exportTraceToTls(trace, env = process.env, options = {}) {
+    const spans = records_traceSpansWithRoot(trace);
+    if (!trace || 0 === spans.length) return {
+        status: 'skipped',
+        reason: 'empty_trace'
+    };
+    const config = config_resolveTlsConfig(env);
+    if (!config.enabled) return {
+        status: 'skipped',
+        reason: config.reason,
+        missing: config.missing
+    };
+    return exportRecordsToTls(recordsFromTrace(trace), config, {
+        span_count: spans.length,
+        trace_id: exporter_traceIdOf(trace)
+    }, options, `${trace.source?.tool ?? 'agent'}-trace`);
+}
+function file_store_hasErrorCode(error, code) {
+    return 'object' == typeof error && null !== error && 'code' in error && error.code === code;
+}
+async function ensureParent(filePath) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+}
+async function writeJsonFile(filePath, value, options = {}) {
+    await ensureParent(filePath);
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    const writeOptions = options.mode ? {
+        encoding: 'utf8',
+        mode: options.mode
+    } : 'utf8';
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, writeOptions);
+    await __rspack_external_node_fs_promises_153e37e0.rename(tempPath, filePath);
+    if (options.mode) await __rspack_external_node_fs_promises_153e37e0.chmod(filePath, options.mode);
+}
+async function appendJsonl(filePath, value) {
+    await ensureParent(filePath);
+    await __rspack_external_node_fs_promises_153e37e0.appendFile(filePath, `${JSON.stringify(value)}\n`, 'utf8');
+}
+async function readJsonl(filePath) {
+    let text;
+    try {
+        text = await __rspack_external_node_fs_promises_153e37e0.readFile(filePath, 'utf8');
+    } catch (error) {
+        if (file_store_hasErrorCode(error, 'ENOENT')) return [];
+        throw error;
+    }
+    return text.split(/\r?\n/).filter(Boolean).map((line)=>JSON.parse(line));
+}
+function safeName(value) {
+    return String(value || 'trace').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 160) || 'trace';
+}
+async function writeFailedTraceCache(paths, key, trace, body, result, config = {}) {
+    if (result?.status !== 'failed') return {
+        persisted: false,
+        reason: 'not_failed'
+    };
+    if (!body) return {
+        persisted: false,
+        reason: 'missing_otlp_payload'
+    };
+    if (otlpPayloadContainsTlsCredentials(body)) return {
+        persisted: false,
+        reason: 'payload_contains_tls_credentials'
+    };
+    const now = Date.now();
+    const retryIntervalMs = config.retryIntervalMs ?? 300000;
+    const caseDir = __rspack_external_node_path_c5b9b54f.join(paths.failedTracesDir, `${safeName(key.slice(0, 16))}.${safeName(trace.source?.tool)}`);
+    const payloadPath = __rspack_external_node_path_c5b9b54f.join(caseDir, 'payload.otlp.json');
+    const manifestPath = __rspack_external_node_path_c5b9b54f.join(caseDir, 'manifest.json');
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(caseDir, {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(payloadPath, body, {
+        encoding: 'utf8',
+        mode: 384
+    });
+    await __rspack_external_node_fs_promises_153e37e0.chmod(payloadPath, 384);
+    const manifest = {
+        version: 1,
+        state: 'pending',
+        created_at: new Date(now).toISOString(),
+        updated_at: new Date(now).toISOString(),
+        next_retry_at: new Date(now + retryIntervalMs).toISOString(),
+        retry_interval_ms: retryIntervalMs,
+        retry_count: 0,
+        max_retry_count: config.maxRetryCount ?? 1,
+        dedup_key: key,
+        payload_path: payloadPath,
+        source_tool: trace.source?.tool,
+        session_id: trace.source?.sessionId,
+        turn_id: trace.source?.turnId,
+        span_count: (trace.spans?.length ?? 0) + 1,
+        payload_bytes: Buffer.byteLength(body, 'utf8'),
+        trace_export: result
+    };
+    await writeJsonFile(manifestPath, manifest, {
+        mode: 384
+    });
+    return {
+        persisted: true,
+        manifest_path: manifestPath,
+        next_retry_at: manifest.next_retry_at
+    };
+}
+function dedup_hasErrorCode(error, code) {
+    return 'object' == typeof error && null !== error && 'code' in error && error.code === code;
+}
+function dedupKeyForTrace(trace) {
+    const seed = [
+        trace.source?.tool,
+        trace.source?.sessionId,
+        trace.source?.turnId,
+        trace.source?.threadId,
+        trace.root?.name,
+        trace.root?.startedAt
+    ].join(':');
+    return external_node_crypto_createHash('sha256').update(seed).digest('hex');
+}
+async function hasUploaded(uploadedFile, key) {
+    return (await readJsonl(uploadedFile)).some((entry)=>entry.key === key);
+}
+async function markUploaded(uploadedFile, key, trace, result) {
+    await appendJsonl(uploadedFile, {
+        key,
+        source_tool: trace.source?.tool,
+        session_id: trace.source?.sessionId,
+        turn_id: trace.source?.turnId,
+        uploaded_at: new Date().toISOString(),
+        span_count: (trace.spans?.length ?? 0) + 1,
+        trace_export: {
+            status: result.status,
+            reason: result.reason
+        }
+    });
+}
+async function acquireLock(locksDir, key, timeoutMs = 120000) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(locksDir, {
+        recursive: true
+    });
+    const lockPath = __rspack_external_node_path_c5b9b54f.join(locksDir, `${key}.lock`);
+    try {
+        const handle = await __rspack_external_node_fs_promises_153e37e0.open(lockPath, 'wx');
+        await handle.writeFile(JSON.stringify({
+            pid: process.pid,
+            created_at: new Date().toISOString()
+        }));
+        await handle.close();
+        return {
+            acquired: true,
+            lockPath
+        };
+    } catch (error) {
+        if (!dedup_hasErrorCode(error, 'EEXIST')) throw error;
+    }
+    const stat = await __rspack_external_node_fs_promises_153e37e0.stat(lockPath).catch(()=>null);
+    if (stat && Date.now() - stat.mtimeMs > timeoutMs) {
+        await __rspack_external_node_fs_promises_153e37e0.rm(lockPath, {
+            force: true
+        });
+        return acquireLock(locksDir, key, timeoutMs);
+    }
+    return {
+        acquired: false,
+        lockPath,
+        reason: 'dedup_lock_timeout'
+    };
+}
+async function releaseLock(lock) {
+    if (lock?.acquired && lock.lockPath) await __rspack_external_node_fs_promises_153e37e0.rm(lock.lockPath, {
+        force: true
+    });
+}
+function paths_defaultDataRoot(source = 'agent') {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.codex', 'plugins', 'data', `storage-tls-${source}`);
+}
+function runtimePaths(config = {}) {
+    const source = config.sourceName ?? config.source?.tool ?? 'agent';
+    const dataRoot = __rspack_external_node_path_c5b9b54f.resolve(config.dataRoot ?? process.env.TRACE_TLS_DATA_ROOT ?? process.env.CODEX_TLS_DATA_ROOT ?? paths_defaultDataRoot(source));
+    return {
+        dataRoot,
+        sendLogPath: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'logs', 'send', 'latest.send-log.json'),
+        diagnosticsDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'logs', 'diagnostics'),
+        uploadedFile: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'state', 'dedup', 'uploaded.jsonl'),
+        locksDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'state', 'dedup', 'locks'),
+        failedTracesDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'state', 'failed-traces')
+    };
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function metadataForTrace(trace, otelTrace) {
+    return {
+        span_count: otelTrace.spans.length,
+        trace_id: otelTrace.traceId,
+        source_tool: trace.source?.tool,
+        session_id: trace.source?.sessionId,
+        turn_id: trace.source?.turnId
+    };
+}
+async function writeSendLog(paths, event) {
+    await writeJsonFile(paths.sendLogPath, {
+        generated_at: nowIso(),
+        ...event
+    });
+}
+async function runTracePipeline(input, adapter, config = {}) {
+    if (!adapter || 'function' != typeof adapter.load || 'function' != typeof adapter.toCanonical) throw new Error('A SourceAdapter with load() and toCanonical() is required');
+    if ('function' == typeof adapter.detect && !adapter.detect(input)) return {
+        status: 'skipped',
+        reason: 'adapter_not_detected',
+        adapter: adapter.name
+    };
+    const context = {
+        env: config.env ?? process.env,
+        dataRoot: config.dataRoot,
+        now: config.now ?? Date.now,
+        source: config.source ?? {}
+    };
+    const session = await adapter.load(input, context);
+    const trace = assertCanonicalTrace(await adapter.toCanonical(session, context));
+    const paths = runtimePaths({
+        ...config,
+        source: trace.source,
+        sourceName: trace.source?.tool
+    });
+    const key = config.dedupKey ?? dedupKeyForTrace(trace);
+    if (false !== config.dedup && await hasUploaded(paths.uploadedFile, key)) {
+        await writeSendLog(paths, {
+            status: 'deduped',
+            dedup_key: key,
+            source: trace.source
+        });
+        return {
+            status: 'deduped',
+            dedup_key: key
+        };
+    }
+    const lock = false === config.dedup ? {
+        acquired: true
+    } : await acquireLock(paths.locksDir, key, config.dedupLockTimeoutMs);
+    if (!lock.acquired) {
+        await writeSendLog(paths, {
+            status: 'skipped',
+            reason: lock.reason,
+            dedup_key: key,
+            source: trace.source
+        });
+        return {
+            status: 'skipped',
+            reason: lock.reason,
+            dedup_key: key
+        };
+    }
+    try {
+        const otelTrace = canonicalTraceToOtelTrace(trace, config.otel);
+        let capturedRequestBody = '';
+        const metadata = metadataForTrace(trace, otelTrace);
+        const traceExport = await exportTraceToTls(otelTrace, context.env, {
+            ...config.tlsOptions ?? {},
+            onRequestBody: (request)=>{
+                if ('string' == typeof request.body) capturedRequestBody = request.body;
+                config.tlsOptions?.onRequestBody?.(request);
+            }
+        });
+        let failedTraceCache = {
+            persisted: false,
+            reason: 'not_failed'
+        };
+        if ('sent' === traceExport.status && false !== config.dedup) await markUploaded(paths.uploadedFile, key, trace, traceExport);
+        else if ('failed' === traceExport.status) failedTraceCache = await writeFailedTraceCache(paths, key, trace, capturedRequestBody, traceExport, config.failedTraceCache);
+        await writeSendLog(paths, {
+            status: traceExport.status,
+            dedup_key: key,
+            source: trace.source,
+            trace_export: traceExport,
+            failed_trace_cache: failedTraceCache,
+            otlp: metadata
+        });
+        return {
+            status: traceExport.status,
+            dedup_key: key,
+            trace_export: traceExport,
+            failed_trace_cache: failedTraceCache
+        };
+    } finally{
+        await releaseLock(lock);
+    }
+}
+new Map();
+const TLS_APP_TYPE = 'pi';
+const ROOT_SPAN_NAME = 'agent.turn';
+const LLM_SPAN_NAME = 'llm.request';
+const TOOL_SPAN_NAME = 'tool.call';
+function pi_isRecord(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function firstString(...values) {
+    for (const value of values)if ('string' == typeof value && value.length > 0) return value;
+}
+function numberValue(value) {
+    return 'number' == typeof value && Number.isFinite(value) ? value : void 0;
+}
+function compactRecord(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value])=>null != value && '' !== value));
+}
+function captureEnabled(input, context) {
+    if ('boolean' == typeof input.captureContent) return input.captureContent;
+    const raw = context.env?.PI_TLS_CAPTURE_CONTENT ?? context.env?.TRACE_TLS_CAPTURE_CONTENT;
+    if (null == raw || '' === raw) return true;
+    return !/^(0|false|no|n|off)$/i.test(raw);
+}
+function safeContent(value, captureContent) {
+    return captureContent ? value : void 0;
+}
+function normalizedRole(role) {
+    if ('toolResult' === role || 'tool_result' === role) return 'tool';
+    if ('developer' === role) return 'system';
+    return role;
+}
+function rawToolCalls(value) {
+    if (!pi_isRecord(value)) return;
+    const calls = value.toolCalls ?? value.tool_calls;
+    if (!Array.isArray(calls)) return;
+    const normalized = calls.flatMap((call)=>{
+        if (!pi_isRecord(call)) return [];
+        const fn = pi_isRecord(call.function) ? call.function : {};
+        const id = firstString(call.id, call.toolCallId, call.callId);
+        if (!id) return [];
+        return [
+            {
+                id,
+                name: firstString(call.name, call.toolName, fn.name),
+                arguments: call.arguments ?? call.input ?? fn.arguments
+            }
+        ];
+    });
+    return normalized.length > 0 ? normalized : void 0;
+}
+function contentBlocks(content, toolCalls, captureContent) {
+    const blocks = [];
+    const seenToolCallIds = new Set();
+    const append = (item)=>{
+        if ('string' == typeof item) return void blocks.push(compactRecord({
+            type: 'text',
+            content: safeContent(item, captureContent)
+        }));
+        if (!pi_isRecord(item)) return;
+        const type = firstString(item.type) ?? 'unknown';
+        if ([
+            'text',
+            'input_text',
+            'output_text'
+        ].includes(type)) return void blocks.push(compactRecord({
+            type: 'text',
+            content: safeContent(item.text ?? item.content, captureContent)
+        }));
+        if ([
+            'thinking',
+            'reasoning'
+        ].includes(type)) return void blocks.push(compactRecord({
+            type: 'reasoning',
+            content: safeContent(item.thinking ?? item.text ?? item.content, captureContent)
+        }));
+        if ([
+            'toolCall',
+            'tool_call',
+            'tool_use',
+            'function_call'
+        ].includes(type)) {
+            const fn = pi_isRecord(item.function) ? item.function : {};
+            const id = firstString(item.id, item.toolCallId, item.callId, item.tool_use_id);
+            if (id) seenToolCallIds.add(id);
+            blocks.push(compactRecord({
+                type: 'tool_call',
+                id,
+                name: firstString(item.name, item.toolName, item.tool, fn.name),
+                arguments: safeContent(item.arguments ?? item.input ?? item.args ?? fn.arguments, captureContent)
+            }));
+            return;
+        }
+        if ('image' === type || 'image_url' === type || 'file' === type) {
+            const source = pi_isRecord(item.source) ? item.source : {};
+            blocks.push(compactRecord({
+                type: 'file',
+                id: item.filename ?? item.id,
+                url: safeContent(item.url ?? item.image_url ?? source.data, captureContent),
+                mime_type: item.mime ?? item.mimeType ?? item.media_type ?? source.media_type
+            }));
+            return;
+        }
+        blocks.push(compactRecord({
+            type,
+            value: safeContent(item, captureContent)
+        }));
+    };
+    if (Array.isArray(content)) content.forEach(append);
+    else if (void 0 !== content) append(content);
+    for (const toolCall of toolCalls ?? [])if (!seenToolCallIds.has(toolCall.id)) blocks.push(compactRecord({
+        type: 'tool_call',
+        id: toolCall.id,
+        name: toolCall.name,
+        arguments: safeContent(toolCall.arguments, captureContent)
+    }));
+    return blocks;
+}
+function toolResultContent(content) {
+    if (!Array.isArray(content)) return content;
+    const texts = content.map((item)=>{
+        if ('string' == typeof item) return item;
+        if (!pi_isRecord(item) || ![
+            'text',
+            'input_text',
+            'output_text'
+        ].includes(String(item.type))) return;
+        return firstString(item.text, item.content);
+    });
+    return texts.every((text)=>void 0 !== text) ? texts.join('\n') : content;
+}
+function messageTime(message, fallback) {
+    return numberValue(message.endedAt) ?? numberValue(message.createdAt) ?? fallback;
+}
+function usageAttributes(usage) {
+    if (!usage) return {};
+    const input = numberValue(usage.inputTokens) ?? 0;
+    const output = numberValue(usage.outputTokens) ?? 0;
+    const reasoning = numberValue(usage.reasoningOutputTokens) ?? 0;
+    const cacheRead = numberValue(usage.cacheReadInputTokens) ?? 0;
+    const cacheCreation = numberValue(usage.cacheCreationInputTokens) ?? 0;
+    const total = numberValue(usage.totalTokens) ?? (input || output || reasoning ? input + output + reasoning : 0);
+    return compactRecord({
+        'gen_ai.usage.input_tokens': input || void 0,
+        'gen_ai.usage.output_tokens': output || void 0,
+        'gen_ai.usage.reasoning.output_tokens': reasoning || void 0,
+        'gen_ai.usage.cache_read.input_tokens': cacheRead || void 0,
+        'gen_ai.usage.cache_creation.input_tokens': cacheCreation || void 0,
+        'gen_ai.usage.total_tokens': total || void 0
+    });
+}
+function sumUsage(requests) {
+    const keys = [
+        'gen_ai.usage.input_tokens',
+        'gen_ai.usage.output_tokens',
+        'gen_ai.usage.reasoning.output_tokens',
+        'gen_ai.usage.cache_read.input_tokens',
+        'gen_ai.usage.cache_creation.input_tokens',
+        'gen_ai.usage.total_tokens'
+    ];
+    const records = requests.map((request)=>usageAttributes(request.usage));
+    return compactRecord(Object.fromEntries(keys.map((key)=>[
+            key,
+            records.reduce((sum, record)=>{
+                const value = record[key];
+                return 'number' == typeof value && Number.isFinite(value) ? sum + value : sum;
+            }, 0) || void 0
+        ])));
+}
+function toGenAiMessages(messages, captureContent) {
+    return messages.map((message)=>{
+        const role = normalizedRole(message.role);
+        if ('tool' === role) return compactRecord({
+            role,
+            name: message.toolName,
+            tool_call_id: message.toolCallId,
+            content: safeContent(toolResultContent(message.content), captureContent)
+        });
+        return compactRecord({
+            role,
+            parts: contentBlocks(message.content, message.toolCalls, captureContent)
+        });
+    });
+}
+function promptMessages(input, captureContent) {
+    const userMessages = input.messages.filter((message)=>'user' === message.role);
+    if (userMessages.length > 0) return toGenAiMessages(userMessages, captureContent);
+    return [
+        compactRecord({
+            role: 'user',
+            content: safeContent(compactRecord({
+                prompt: input.prompt,
+                images: input.images,
+                context: input.context
+            }), captureContent)
+        })
+    ];
+}
+function turnOutputMessages(input, captureContent) {
+    return toGenAiMessages(input.messages.filter((message)=>[
+            'assistant',
+            'tool',
+            'toolResult',
+            'tool_result'
+        ].includes(message.role)), captureContent);
+}
+function toTraceMessages(messages, captureContent) {
+    return messages.map((message)=>({
+            role: message.role,
+            content: safeContent(message.content, captureContent),
+            timestamp: new Date(messageTime(message, Date.now())).toISOString(),
+            attributes: compactRecord({
+                'pi.message_id': message.id,
+                'pi.provider_request_id': message.providerRequestId,
+                'gen_ai.request.model': message.model,
+                'gen_ai.provider.name': message.provider
+            })
+        }));
+}
+function lastProviderRequest(input) {
+    return [
+        ...input.providerRequests
+    ].reverse()[0];
+}
+function pi_commonAttributes(input, pluginVersion) {
+    return compactRecord({
+        'tls.app.type': TLS_APP_TYPE,
+        'tls.plugin.version': pluginVersion,
+        'session.id': input.session.id,
+        'gen_ai.conversation.id': input.session.id,
+        'agent.name': 'pi',
+        'agent.version': input.session.version ?? pluginVersion,
+        'user.name': userInfo().username
+    });
+}
+function providerRequestInputMessages(request, input, captureContent) {
+    const payload = pi_isRecord(request.input) ? request.input : {};
+    const rawMessages = Array.isArray(request.input) ? request.input : Array.isArray(payload.messages) ? payload.messages : [];
+    const observedRawMessages = rawMessages.flatMap((message)=>{
+        if (!pi_isRecord(message)) return [];
+        return [
+            {
+                role: firstString(message.role) ?? 'unknown',
+                content: message.content ?? message.parts,
+                toolCallId: firstString(message.toolCallId, message.tool_call_id),
+                toolName: firstString(message.toolName, message.name),
+                toolCalls: rawToolCalls(message)
+            }
+        ];
+    });
+    const payloadSystemMessages = observedRawMessages.filter((message)=>'system' === normalizedRole(message.role));
+    const explicitSystem = payload.system ?? payload.instructions;
+    const systemMessages = payloadSystemMessages.length > 0 ? toGenAiMessages(payloadSystemMessages, captureContent) : void 0 !== explicitSystem ? toGenAiMessages([
+        {
+            role: 'system',
+            content: explicitSystem
+        }
+    ], captureContent) : [];
+    const outputIndex = input.messages.findIndex((message)=>message.providerRequestId === request.requestId && 'assistant' === message.role);
+    if (outputIndex >= 0) {
+        const currentTurnPrefix = input.messages.slice(0, outputIndex).filter((message)=>'system' !== normalizedRole(message.role));
+        return [
+            ...systemMessages,
+            ...toGenAiMessages(currentTurnPrefix, captureContent)
+        ];
+    }
+    const nonSystemRawMessages = observedRawMessages.filter((message)=>'system' !== normalizedRole(message.role));
+    const lastUserIndex = nonSystemRawMessages.map((message)=>normalizedRole(message.role)).lastIndexOf('user');
+    const currentTurnMessages = lastUserIndex >= 0 ? nonSystemRawMessages.slice(lastUserIndex) : nonSystemRawMessages;
+    return [
+        ...systemMessages,
+        ...toGenAiMessages(currentTurnMessages, captureContent)
+    ];
+}
+function providerRequestOutputMessages(request, input, captureContent) {
+    const messages = input.messages.filter((message)=>message.providerRequestId === request.requestId && 'assistant' === message.role);
+    if (messages.length > 0) return toGenAiMessages(messages, captureContent);
+    const rawOutput = pi_isRecord(request.output) ? request.output : void 0;
+    return [
+        ...toGenAiMessages([
+            {
+                role: 'assistant',
+                content: rawOutput?.content ?? request.output,
+                toolCalls: rawToolCalls(rawOutput)
+            }
+        ], captureContent)
+    ];
+}
+function detectPiInput(input) {
+    return pi_isRecord(input) && 'pi' === input.source && 'string' == typeof input.turnId && pi_isRecord(input.session);
+}
+async function loadPiTurn(input) {
+    if (!detectPiInput(input)) throw new Error('Pi adapter requires a turn snapshot');
+    return input;
+}
+async function toCanonicalPiTrace(input, context = {}) {
+    const captureContent = captureEnabled(input, context);
+    const pluginVersion = input.pluginVersion ?? context.version ?? '0.0.0';
+    const now = context.now?.() ?? Date.now();
+    const traceId = model_traceIdFromSeed(`pi:${input.session.id}:${input.turnId}`);
+    const rootSpanId = spanIdFromSeed(traceId, 'pi-turn', input.turnId);
+    const common = pi_commonAttributes(input, pluginVersion);
+    const rootStart = input.startedAt || now;
+    const requestEnds = input.providerRequests.map((request)=>request.endedAt ?? request.startedAt);
+    const toolEnds = input.toolCalls.map((tool)=>tool.endedAt ?? tool.startedAt ?? rootStart);
+    const rootEnd = Math.max(rootStart, input.endedAt ?? 0, ...requestEnds, ...toolEnds);
+    const lastRequest = lastProviderRequest(input);
+    const rootInputMessages = promptMessages(input, captureContent);
+    const rootOutputMessages = turnOutputMessages(input, captureContent);
+    const diagnosticsWarnings = [];
+    const root = {
+        id: rootSpanId,
+        name: ROOT_SPAN_NAME,
+        kind: 'server',
+        type: 'agent',
+        startedAt: rootStart,
+        endedAt: rootEnd,
+        status: input.providerRequests.some((request)=>'error' === request.status) || input.toolCalls.some((tool)=>'error' === tool.status) ? 'error' : 'unset',
+        input: {
+            messages: rootInputMessages
+        },
+        output: {
+            messages: rootOutputMessages
+        },
+        attributes: compactRecord({
+            ...common,
+            ...sumUsage(input.providerRequests),
+            'gen_ai.operation.name': 'invoke_agent',
+            'gen_ai.request.model': lastRequest?.model ?? input.model,
+            'gen_ai.provider.name': lastRequest?.provider ?? input.provider,
+            'gen_ai.input.messages': rootInputMessages,
+            'gen_ai.output.messages': rootOutputMessages
+        })
+    };
+    const spans = [];
+    const llmSpanIds = new Map();
+    input.providerRequests.forEach((request, index)=>{
+        const llmSpanId = spanIdFromSeed(traceId, 'pi-llm', request.requestId || index);
+        llmSpanIds.set(request.requestId, llmSpanId);
+        const llmInputMessages = providerRequestInputMessages(request, input, captureContent);
+        const llmOutputMessages = providerRequestOutputMessages(request, input, captureContent);
+        const startedAt = request.startedAt || rootStart;
+        const endedAt = Math.max(startedAt, request.endedAt ?? rootEnd);
+        spans.push({
+            id: llmSpanId,
+            parentId: rootSpanId,
+            name: LLM_SPAN_NAME,
+            kind: 'client',
+            type: 'model',
+            startedAt,
+            endedAt,
+            status: 'error' === request.status ? 'error' : 'unset',
+            input: {
+                messages: llmInputMessages
+            },
+            output: {
+                messages: llmOutputMessages
+            },
+            attributes: compactRecord({
+                ...common,
+                ...usageAttributes(request.usage),
+                'gen_ai.operation.name': 'chat',
+                'gen_ai.request.model': request.model ?? input.model,
+                'gen_ai.provider.name': request.provider ?? input.provider,
+                'gen_ai.input.messages': llmInputMessages,
+                'gen_ai.output.messages': llmOutputMessages,
+                'gen_ai.request.duration_ms': Math.max(0, endedAt - startedAt),
+                'error.message': 'error' === request.status ? request.error : void 0,
+                'pi.provider_request_id': request.requestId
+            })
+        });
+    });
+    for (const tool of input.toolCalls){
+        const parentId = tool.parentProviderRequestId ? llmSpanIds.get(tool.parentProviderRequestId) : void 0;
+        if (!parentId) diagnosticsWarnings.push(`pi.tool.parent_missing:${tool.toolCallId}`);
+        const startedAt = tool.startedAt ?? rootStart;
+        const endedAt = Math.max(startedAt, tool.endedAt ?? rootEnd);
+        spans.push({
+            id: spanIdFromSeed(traceId, 'pi-tool', tool.toolCallId),
+            parentId: parentId ?? rootSpanId,
+            name: TOOL_SPAN_NAME,
+            kind: 'client',
+            type: 'tool',
+            startedAt,
+            endedAt,
+            status: 'error' === tool.status ? 'error' : 'unset',
+            input: safeContent(tool.arguments, captureContent),
+            output: safeContent('error' === tool.status ? tool.error : tool.result, captureContent),
+            attributes: compactRecord({
+                ...common,
+                'gen_ai.tool.name': tool.name,
+                'gen_ai.tool.call.id': tool.toolCallId,
+                'gen_ai.tool.call.arguments': safeContent(tool.arguments, captureContent),
+                'gen_ai.tool.call.result': safeContent('error' === tool.status ? tool.error : tool.result, captureContent),
+                'tool.error': 'error' === tool.status || void 0,
+                'error.message': 'error' === tool.status ? tool.error : void 0,
+                'pi.parent_provider_request_id': tool.parentProviderRequestId
+            })
+        });
+    }
+    return {
+        source: {
+            tool: 'pi',
+            sessionId: input.session.id,
+            turnId: input.turnId,
+            threadId: input.session.id,
+            conversationId: input.session.id,
+            cwd: input.session.cwd,
+            model: lastRequest?.model ?? input.model
+        },
+        root,
+        spans,
+        messages: toTraceMessages(input.messages, captureContent),
+        metrics: {
+            inputTokens: numberValue(root.attributes?.['gen_ai.usage.input_tokens']),
+            outputTokens: numberValue(root.attributes?.['gen_ai.usage.output_tokens']),
+            totalTokens: numberValue(root.attributes?.['gen_ai.usage.total_tokens']),
+            toolCallCount: input.toolCalls.length,
+            latencyMs: Math.max(0, rootEnd - rootStart)
+        },
+        diagnostics: {
+            warnings: diagnosticsWarnings,
+            parser: {
+                provider_request_count: input.providerRequests.length,
+                tool_call_count: input.toolCalls.length
+            }
+        }
+    };
+}
+const piAdapter = {
+    name: 'pi',
+    detect: detectPiInput,
+    load: loadPiTurn,
+    toCanonical: toCanonicalPiTrace
+};
+function utils_isRecord(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function stringValue(value) {
+    return 'string' == typeof value && value.length > 0 ? value : void 0;
+}
+function numericValue(value) {
+    return 'number' == typeof value && Number.isFinite(value) ? value : void 0;
+}
+function nowMs() {
+    return Date.now();
+}
+function utils_compactRecord(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value])=>null != value && '' !== value));
+}
+function getRequestKey(event, fallback) {
+    return String(event.requestId ?? event.providerRequestId ?? event.messageId ?? event.turnId ?? event.turnIndex ?? event.id ?? fallback);
+}
+function getToolCallId(event) {
+    const id = event.toolCallId ?? event.id ?? event.callId ?? event.tool_use_id ?? event.toolUseId;
+    return null == id ? void 0 : String(id);
+}
+function getToolName(event) {
+    return String(event.toolName ?? event.name ?? event.tool ?? event.functionName ?? (utils_isRecord(event.call) ? event.call.name : void 0) ?? 'tool');
+}
+function getToolInput(event) {
+    return event.input ?? event.args ?? event.arguments ?? event.params ?? (utils_isRecord(event.call) ? event.call.input : void 0) ?? event;
+}
+function getProviderPayload(event) {
+    return event.request ?? event.payload ?? event.body ?? event.providerPayload ?? event.messages ?? event;
+}
+function getMessageFromEvent(event) {
+    if (utils_isRecord(event.message)) return event.message;
+    if (event.role || event.content) return event;
+}
+function extractTextContent(content) {
+    if ('string' == typeof content) return content;
+    if (!Array.isArray(content)) return;
+    const text = content.map((item)=>{
+        if (!utils_isRecord(item)) return '';
+        return 'text' === item.type && 'string' == typeof item.text ? item.text : '';
+    }).filter(Boolean).join('\n');
+    return text || void 0;
+}
+function extractAssistantOutput(message) {
+    if (!utils_isRecord(message)) return;
+    const text = extractTextContent(message.content);
+    if (text) return text;
+    const toolCalls = extractToolCalls(message);
+    if (toolCalls.length > 0) return {
+        toolCalls
+    };
+    return message.content ?? message;
+}
+function toolCallFromRecord(record) {
+    const id = record.id ?? record.toolCallId ?? record.callId ?? record.tool_use_id ?? record.toolUseId;
+    if (null == id) return;
+    return {
+        id: String(id),
+        name: stringValue(record.name) ?? stringValue(record.toolName) ?? stringValue(record.tool),
+        arguments: record.arguments ?? record.args ?? record.input ?? record.params
+    };
+}
+function extractToolCalls(messageOrEvent) {
+    if (!utils_isRecord(messageOrEvent)) return [];
+    const direct = messageOrEvent.toolCalls ?? messageOrEvent.tool_calls ?? messageOrEvent.function_calls;
+    if (Array.isArray(direct)) return direct.map((item)=>{
+        if (!utils_isRecord(item)) return;
+        const fromFunction = utils_isRecord(item.function) ? {
+            ...item,
+            name: item.function.name ?? item.name,
+            arguments: item.function.arguments ?? item.arguments
+        } : item;
+        return toolCallFromRecord(fromFunction);
+    }).filter((item)=>Boolean(item));
+    if (!Array.isArray(messageOrEvent.content)) return [];
+    return messageOrEvent.content.map((item)=>{
+        if (!utils_isRecord(item)) return;
+        const type = String(item.type ?? '');
+        if (![
+            'tool_use',
+            'tool_call',
+            'toolCall'
+        ].includes(type)) return;
+        return toolCallFromRecord({
+            ...item,
+            id: item.id ?? item.tool_use_id,
+            name: item.name ?? item.tool,
+            arguments: item.input ?? item.arguments
+        });
+    }).filter((item)=>Boolean(item));
+}
+function normalizeMessage(event) {
+    const message = getMessageFromEvent(event);
+    if (!message) return;
+    const toolCalls = extractToolCalls(message);
+    return {
+        id: stringValue(message.id) ?? stringValue(message.messageId),
+        role: stringValue(message.role) ?? 'unknown',
+        content: message.content,
+        model: stringValue(message.model) ?? stringValue(event.model),
+        provider: stringValue(message.provider) ?? stringValue(event.provider),
+        createdAt: numericValue(message.createdAt) ?? numericValue(event.createdAt),
+        endedAt: numericValue(message.endedAt) ?? numericValue(event.endedAt) ?? nowMs(),
+        providerRequestId: stringValue(event.requestId) ?? stringValue(event.providerRequestId),
+        toolCallId: stringValue(message.toolCallId) ?? stringValue(message.tool_call_id) ?? getToolCallId(event),
+        toolName: stringValue(message.toolName) ?? stringValue(message.name) ?? stringValue(event.toolName),
+        isError: Boolean(message.isError ?? message.error ?? event.isError ?? event.error) || void 0,
+        toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+    };
+}
+function extractUsage(messageOrEvent) {
+    const usage = messageOrEvent.usage ?? (utils_isRecord(messageOrEvent.message) ? messageOrEvent.message.usage : void 0);
+    if (!utils_isRecord(usage)) return;
+    const inputTokens = Number(usage.input ?? usage.inputTokens ?? usage.prompt_tokens ?? usage.promptTokens ?? 0);
+    const outputTokens = Number(usage.output ?? usage.outputTokens ?? usage.completion_tokens ?? usage.completionTokens ?? 0);
+    const cacheReadInputTokens = Number(usage.cacheRead ?? usage.cache_read ?? usage.cachedTokens ?? 0);
+    const cacheCreationInputTokens = Number(usage.cacheWrite ?? usage.cache_write ?? 0);
+    const reasoningOutputTokens = Number(usage.reasoning ?? usage.reasoningTokens ?? usage.reasoning_output_tokens ?? 0);
+    const totalTokens = Number(usage.total ?? usage.totalTokens ?? usage.total_tokens ?? inputTokens + outputTokens);
+    return utils_compactRecord({
+        inputTokens: inputTokens || void 0,
+        outputTokens: outputTokens || void 0,
+        cacheReadInputTokens: cacheReadInputTokens || void 0,
+        cacheCreationInputTokens: cacheCreationInputTokens || void 0,
+        reasoningOutputTokens: reasoningOutputTokens || void 0,
+        totalTokens: totalTokens || void 0
+    });
+}
+function extractResponseMetadata(event) {
+    return utils_compactRecord({
+        status: event.status ?? event.statusCode ?? event.httpStatus,
+        headers: event.headers,
+        responseHeaders: event.responseHeaders,
+        providerMetadata: event.providerMetadata ?? event.metadata,
+        requestId: event.requestId ?? event.providerRequestId
+    });
+}
+function extractToolResult(event) {
+    return event.output ?? event.result ?? event.error ?? event.content ?? event;
+}
+function sessionIdFromContext(ctx) {
+    if (!utils_isRecord(ctx)) return;
+    try {
+        const sessionManager = ctx.sessionManager;
+        if (!utils_isRecord(sessionManager) || 'function' != typeof sessionManager.getSessionFile) return;
+        const sessionFile = sessionManager.getSessionFile();
+        if ('string' != typeof sessionFile || !sessionFile) return;
+        const base = sessionFile.split(/[\\/]/).pop() ?? sessionFile;
+        return base.replace(/\.jsonl$/i, '');
+    } catch  {
+        return;
+    }
+}
+function eventSessionId(event, ctx) {
+    return stringValue(event.sessionId) ?? stringValue(event.sessionID) ?? (utils_isRecord(event.session) ? stringValue(event.session.id) : void 0) ?? sessionIdFromContext(ctx) ?? 'pi-session';
+}
+function eventCwd(event) {
+    const systemPromptOptions = utils_isRecord(event.systemPromptOptions) ? event.systemPromptOptions : void 0;
+    return stringValue(systemPromptOptions?.cwd) ?? stringValue(event.cwd);
+}
+function selectedModel(event, ctx) {
+    const eventModel = utils_isRecord(event.model) ? event.model : void 0;
+    const contextModel = utils_isRecord(ctx) && utils_isRecord(ctx.model) ? ctx.model : void 0;
+    return {
+        model: stringValue(eventModel?.id) ?? stringValue(event.model) ?? stringValue(contextModel?.id),
+        provider: stringValue(eventModel?.provider) ?? stringValue(event.provider) ?? stringValue(contextModel?.provider)
+    };
+}
+function eventTurnId(event, session) {
+    return String(event.turnId ?? event.turnIndex ?? event.messageId ?? event.id ?? `turn-${++session.turnSeq}`);
+}
+function requestLookupKey(event) {
+    const key = event.requestId ?? event.providerRequestId ?? event.messageId ?? event.turnId ?? event.turnIndex ?? event.id;
+    return null == key ? void 0 : String(key);
+}
+function createSession(sessionId) {
+    return {
+        sessionId,
+        turnSeq: 0,
+        requestSeq: 0,
+        toolSeq: 0,
+        turns: new Map(),
+        pendingExports: []
+    };
+}
+function createTurn(session, turnId, startedAt = nowMs()) {
+    return {
+        turnId,
+        sessionId: session.sessionId,
+        startedAt,
+        model: session.currentModel,
+        provider: session.currentProvider,
+        providerRequests: new Map(),
+        providerOrder: [],
+        toolCalls: new Map(),
+        toolOrder: [],
+        toolToProviderRequest: new Map(),
+        assistantMessages: [],
+        messages: [],
+        exportState: 'open'
+    };
+}
+class PiTlsTracer {
+    config;
+    sessions = new Map();
+    constructor(config){
+        this.config = config;
+    }
+    getSession(sessionId) {
+        const current = this.sessions.get(sessionId);
+        if (current) return current;
+        const created = createSession(sessionId);
+        this.sessions.set(sessionId, created);
+        return created;
+    }
+    getActiveTurn(session) {
+        return session.activeTurnId ? session.turns.get(session.activeTurnId) : void 0;
+    }
+    syncSessionModel(session, event, ctx) {
+        const selected = selectedModel(event, ctx);
+        session.currentModel = selected.model ?? session.currentModel;
+        session.currentProvider = selected.provider ?? session.currentProvider;
+    }
+    getOrCreateActiveTurn(event, ctx) {
+        const session = this.getSession(eventSessionId(event, ctx));
+        this.syncSessionModel(session, event, ctx);
+        let turn = this.getActiveTurn(session);
+        if (!turn || 'open' !== turn.exportState) {
+            const turnId = eventTurnId(event, session);
+            turn = session.turns.get(turnId) ?? createTurn(session, turnId);
+            session.turns.set(turn.turnId, turn);
+            session.activeTurnId = turn.turnId;
+        }
+        turn.model = turn.model ?? session.currentModel;
+        turn.provider = turn.provider ?? session.currentProvider;
+        return {
+            session,
+            turn
+        };
+    }
+    findRequest(turn, event) {
+        const key = requestLookupKey(event);
+        if (key && turn.providerRequests.has(key)) return turn.providerRequests.get(key);
+        if (turn.activeProviderRequestId) return turn.providerRequests.get(turn.activeProviderRequestId);
+        const lastKey = turn.providerOrder[turn.providerOrder.length - 1];
+        return lastKey ? turn.providerRequests.get(lastKey) : void 0;
+    }
+    bindToolCallToRequest(turn, toolCallId, requestId) {
+        turn.toolToProviderRequest.set(toolCallId, requestId);
+        const tool = turn.toolCalls.get(toolCallId);
+        if (tool) tool.parentProviderRequestId = requestId;
+        const request = turn.providerRequests.get(requestId);
+        if (request && !request.toolCallIds.includes(toolCallId)) request.toolCallIds.push(toolCallId);
+    }
+    getOrCreateTool(turn, event) {
+        const explicitId = getToolCallId(event);
+        const toolCallId = explicitId ?? `tool-${turn.toolOrder.length + 1}`;
+        const current = turn.toolCalls.get(toolCallId);
+        if (current) return current;
+        const created = {
+            toolCallId,
+            name: getToolName(event),
+            parentProviderRequestId: turn.toolToProviderRequest.get(toolCallId)
+        };
+        turn.toolCalls.set(toolCallId, created);
+        turn.toolOrder.push(toolCallId);
+        return created;
+    }
+    snapshot(session, turn) {
+        return {
+            source: 'pi',
+            session: {
+                id: session.sessionId,
+                cwd: turn.cwd ?? session.cwd,
+                version: session.agentVersion
+            },
+            turnId: turn.turnId,
+            startedAt: turn.startedAt,
+            endedAt: turn.endedAt ?? nowMs(),
+            prompt: turn.prompt,
+            images: turn.images,
+            context: turn.context,
+            model: turn.model ?? session.currentModel,
+            provider: turn.provider ?? session.currentProvider,
+            messages: turn.messages,
+            providerRequests: turn.providerOrder.map((key)=>turn.providerRequests.get(key)).filter((request)=>Boolean(request)),
+            toolCalls: turn.toolOrder.map((key)=>turn.toolCalls.get(key)).filter((tool)=>Boolean(tool)),
+            captureContent: this.config.captureContent,
+            pluginVersion: this.config.pluginVersion
+        };
+    }
+    trackPendingExport(session, task) {
+        session.pendingExports.push(task);
+        task.finally(()=>{
+            session.pendingExports = session.pendingExports.filter((pending)=>pending !== task);
+        });
+    }
+    exportTurn(session, turn) {
+        if ('ready' !== turn.exportState) return;
+        turn.exportState = 'exporting';
+        const snapshot = this.snapshot(session, turn);
+        const task = runTracePipeline(snapshot, piAdapter, {
+            env: this.config.env,
+            dataRoot: this.config.dataRoot,
+            sourceName: 'pi',
+            source: {
+                tool: 'pi',
+                sessionId: snapshot.session.id,
+                turnId: snapshot.turnId,
+                threadId: snapshot.session.id
+            },
+            otel: {
+                serviceName: this.config.serviceName,
+                sdkVersion: this.config.pluginVersion,
+                scopeName: 'tls-observer-pi',
+                scopeVersion: this.config.pluginVersion,
+                resourceAttributes: {
+                    'service.instance.id': this.config.serviceInstanceId,
+                    'tls.app.type': 'pi'
+                }
+            },
+            failedTraceCache: {
+                maxRetryCount: 1
+            }
+        }).then(()=>{
+            turn.exportState = 'exported';
+        }).catch(()=>{
+            turn.exportState = 'ready';
+        });
+        this.trackPendingExport(session, task);
+    }
+    handleSessionStart(event, ctx) {
+        const session = this.getSession(eventSessionId(event, ctx));
+        this.syncSessionModel(session, event, ctx);
+        session.activeTurnId = void 0;
+    }
+    handleModelSelect(event, ctx) {
+        const session = this.getSession(eventSessionId(event, ctx));
+        this.syncSessionModel(session, event, ctx);
+    }
+    handleAgentStart(event, ctx) {
+        const session = this.getSession(eventSessionId(event, ctx));
+        this.syncSessionModel(session, event, ctx);
+        const selected = selectedModel(event, ctx);
+        const turnId = eventTurnId(event, session);
+        const turn = session.turns.get(turnId) ?? createTurn(session, turnId);
+        turn.startedAt = turn.startedAt || nowMs();
+        turn.cwd = eventCwd(event) ?? turn.cwd;
+        session.cwd = turn.cwd ?? session.cwd;
+        turn.prompt = event.prompt ?? turn.prompt;
+        turn.images = event.images ?? turn.images;
+        turn.context = event.context ?? event.attachments ?? turn.context;
+        turn.model = selected.model ?? turn.model ?? session.currentModel;
+        turn.provider = selected.provider ?? turn.provider ?? session.currentProvider;
+        turn.exportState = 'open';
+        session.turns.set(turn.turnId, turn);
+        session.activeTurnId = turn.turnId;
+    }
+    handleTurnStart(event, ctx) {
+        this.getOrCreateActiveTurn(event, ctx);
+    }
+    handleProviderRequest(event, ctx) {
+        const { session, turn } = this.getOrCreateActiveTurn(event, ctx);
+        const selected = selectedModel(event, ctx);
+        turn.model = selected.model ?? turn.model ?? session.currentModel;
+        turn.provider = selected.provider ?? turn.provider ?? session.currentProvider;
+        const requestId = getRequestKey(event, `request-${++session.requestSeq}`);
+        const request = {
+            requestId,
+            startedAt: nowMs(),
+            model: selected.model ?? turn.model ?? session.currentModel,
+            provider: selected.provider ?? turn.provider ?? session.currentProvider,
+            input: getProviderPayload(event),
+            metadata: utils_compactRecord({
+                url: event.url,
+                method: event.method
+            }),
+            status: 'ok',
+            toolCallIds: []
+        };
+        turn.providerRequests.set(requestId, request);
+        if (!turn.providerOrder.includes(requestId)) turn.providerOrder.push(requestId);
+        turn.activeProviderRequestId = requestId;
+    }
+    handleProviderResponse(event, ctx) {
+        const { turn } = this.getOrCreateActiveTurn(event, ctx);
+        const request = this.findRequest(turn, event);
+        if (!request) return;
+        request.metadata = {
+            ...request.metadata ?? {},
+            ...extractResponseMetadata(event)
+        };
+        request.usage = extractUsage(event) ?? request.usage;
+        request.endedAt = request.endedAt ?? nowMs();
+        if (event.error || event.isError || Number(event.status ?? 0) >= 400) {
+            request.status = 'error';
+            request.error = event.error ?? event.status;
+        }
+    }
+    handleMessageUpdate(event, ctx) {
+        const { turn } = this.getOrCreateActiveTurn(event, ctx);
+        const request = this.findRequest(turn, event);
+        if (request && !request.completionStartAt) request.completionStartAt = nowMs();
+        const message = normalizeMessage(event);
+        if (message?.role === 'assistant') turn.latestAssistantOutput = extractAssistantOutput(message);
+    }
+    handleMessageEnd(event, ctx) {
+        const { turn } = this.getOrCreateActiveTurn(event, ctx);
+        const request = this.findRequest(turn, event);
+        const message = normalizeMessage(event);
+        if (!message) return;
+        if (request) message.providerRequestId = request.requestId;
+        turn.messages.push(message);
+        if ('assistant' === message.role) turn.assistantMessages.push(message);
+        if (request && 'assistant' === message.role) {
+            request.output = extractAssistantOutput(message);
+            request.endedAt = nowMs();
+            request.usage = extractUsage(event) ?? request.usage;
+            request.status = event.error || event.isError ? 'error' : request.status ?? 'ok';
+            request.error = event.error ?? request.error;
+            for (const toolCall of extractToolCalls(message)){
+                this.bindToolCallToRequest(turn, toolCall.id, request.requestId);
+                const tool = turn.toolCalls.get(toolCall.id) ?? {
+                    toolCallId: toolCall.id,
+                    name: toolCall.name ?? 'tool'
+                };
+                tool.parentProviderRequestId = request.requestId;
+                tool.name = toolCall.name ?? tool.name;
+                tool.arguments = toolCall.arguments ?? tool.arguments;
+                turn.toolCalls.set(toolCall.id, tool);
+                if (!turn.toolOrder.includes(toolCall.id)) turn.toolOrder.push(toolCall.id);
+            }
+        }
+    }
+    handleToolStart(event, ctx) {
+        const { turn } = this.getOrCreateActiveTurn(event, ctx);
+        const tool = this.getOrCreateTool(turn, event);
+        if (!tool) return;
+        tool.name = getToolName(event);
+        tool.arguments = getToolInput(event);
+        tool.startedAt = tool.startedAt ?? nowMs();
+        const parentRequestId = turn.toolToProviderRequest.get(tool.toolCallId) ?? stringValue(event.providerRequestId);
+        if (parentRequestId) tool.parentProviderRequestId = parentRequestId;
+    }
+    handleToolEnd(event, ctx) {
+        const { turn } = this.getOrCreateActiveTurn(event, ctx);
+        const tool = this.getOrCreateTool(turn, event);
+        if (!tool) return;
+        const isError = Boolean(event.isError ?? event.error ?? 'error' === event.status);
+        tool.result = extractToolResult(event);
+        tool.error = event.error;
+        tool.status = isError ? 'error' : 'ok';
+        tool.endedAt = nowMs();
+        if (!tool.parentProviderRequestId) tool.parentProviderRequestId = turn.toolToProviderRequest.get(tool.toolCallId);
+    }
+    handleTurnEnd(event, ctx) {
+        const { turn } = this.getOrCreateActiveTurn(event, ctx);
+        turn.endedAt = nowMs();
+    }
+    handleAgentEnd(event, ctx) {
+        const session = this.getSession(eventSessionId(event, ctx));
+        const turn = this.getActiveTurn(session);
+        if (!turn) return;
+        const message = normalizeMessage(event);
+        if (message) {
+            if ('assistant' === message.role) {
+                message.providerRequestId = message.providerRequestId ?? turn.activeProviderRequestId;
+                turn.assistantMessages.push(message);
+            }
+            turn.messages.push(message);
+        }
+        const finalOutput = message ? extractAssistantOutput(message) : turn.latestAssistantOutput;
+        const activeRequest = turn.activeProviderRequestId ? turn.providerRequests.get(turn.activeProviderRequestId) : void 0;
+        if (activeRequest && void 0 !== finalOutput && void 0 === activeRequest.output) {
+            activeRequest.output = finalOutput;
+            activeRequest.endedAt = activeRequest.endedAt ?? nowMs();
+        }
+        turn.endedAt = nowMs();
+        turn.exportState = 'ready';
+        this.exportTurn(session, turn);
+        session.activeTurnId = void 0;
+    }
+    async handleSessionShutdown(event, ctx) {
+        const session = this.getSession(eventSessionId(event, ctx));
+        const turn = this.getActiveTurn(session);
+        if (turn && 'open' === turn.exportState) {
+            turn.endedAt = nowMs();
+            turn.exportState = 'ready';
+            this.exportTurn(session, turn);
+            session.activeTurnId = void 0;
+        }
+        await this.flush(session.sessionId);
+    }
+    async flush(sessionID) {
+        const sessions = sessionID ? [
+            this.getSession(sessionID)
+        ] : [
+            ...this.sessions.values()
+        ];
+        await Promise.allSettled(sessions.flatMap((session)=>session.pendingExports));
+    }
+    get observedSessionCount() {
+        return this.sessions.size;
+    }
+    __getSessionForTest(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+}
+const TlsObserverPiPlugin = async (pi)=>{
+    const config = loadConfig();
+    if (!config.enabled) return;
+    const tracer = new PiTlsTracer(config);
+    pi.on('session_start', (event, ctx)=>{
+        tracer.handleSessionStart(event, ctx);
+    });
+    pi.on('model_select', (event, ctx)=>{
+        tracer.handleModelSelect(event, ctx);
+    });
+    pi.on('before_agent_start', (event, ctx)=>{
+        tracer.handleAgentStart(event, ctx);
+    });
+    pi.on('agent_start', (event, ctx)=>{
+        tracer.handleAgentStart(event, ctx);
+    });
+    pi.on('turn_start', (event, ctx)=>{
+        tracer.handleTurnStart(event, ctx);
+    });
+    pi.on('before_provider_request', (event, ctx)=>{
+        tracer.handleProviderRequest(event, ctx);
+    });
+    pi.on('after_provider_response', (event, ctx)=>{
+        tracer.handleProviderResponse(event, ctx);
+    });
+    pi.on('message_update', (event, ctx)=>{
+        tracer.handleMessageUpdate(event, ctx);
+    });
+    pi.on('message_end', (event, ctx)=>{
+        tracer.handleMessageEnd(event, ctx);
+    });
+    pi.on('tool_execution_start', (event, ctx)=>{
+        tracer.handleToolStart(event, ctx);
+    });
+    pi.on('tool_call', (event, ctx)=>{
+        tracer.handleToolStart(event, ctx);
+    });
+    pi.on('tool_result', (event, ctx)=>{
+        tracer.handleToolEnd(event, ctx);
+    });
+    pi.on('tool_execution_end', (event, ctx)=>{
+        tracer.handleToolEnd(event, ctx);
+    });
+    pi.on('turn_end', (event, ctx)=>{
+        tracer.handleTurnEnd(event, ctx);
+    });
+    pi.on('agent_end', (event, ctx)=>{
+        tracer.handleAgentEnd(event, ctx);
+    });
+    pi.on('session_shutdown', async (event, ctx)=>{
+        await tracer.handleSessionShutdown(event, ctx);
+    });
+};
+const src = TlsObserverPiPlugin;
+export default src;
+export { PiTlsTracer, TlsObserverPiPlugin, loadConfig };