@volcengine/tls-observer-trae 0.0.2

package/dist/index.js

@@ -0,0 +1,2604 @@
+import { homedir, hostname, networkInterfaces, userInfo } from "node:os";
+import { tlsOpenapi } from "@volcengine/openapi";
+import { createHash as external_node_crypto_createHash, randomUUID } from "node:crypto";
+import "node:url";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import * as __rspack_external_node_fs_promises_153e37e0 from "node:fs/promises";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+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');
+}
+async function closeTraceLogProducers() {
+    const entries = [
+        ...producerEntries.values()
+    ];
+    producerEntries.clear();
+    await Promise.allSettled(entries.map((entry)=>{
+        const closeTimeoutMs = Math.min(Math.max(entry.timeoutMs || 20000, 1000), 5000);
+        return withTimeout(Promise.resolve(entry.producer.Close()), closeTimeoutMs, 'TLS Producer Close');
+    }));
+}
+function 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(firstEnv(env, 'TRACE_TLS_EXPORT', 'CODEX_TLS_EXPORT') ?? '');
+    if (disabled) return {
+        enabled: false,
+        reason: 'disabled'
+    };
+    const endpoint = firstEnv(env, 'TRACE_TLS_ENDPOINT', 'CODEX_TLS_ENDPOINT') || tlsEndpointFromLegacyOtelEndpoint(firstEnv(env, 'TRACE_TLS_OTEL_ENDPOINT', 'CODEX_TLS_OTEL_ENDPOINT', 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'));
+    const region = firstEnv(env, 'TRACE_TLS_REGION', 'CODEX_TLS_REGION', 'TLS_REGION');
+    const traceTopicId = 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 = firstEnv(env, 'TRACE_TLS_API_KEY', 'CODEX_TLS_API_KEY', 'TLS_API_KEY');
+    const ak = firstEnv(env, 'TRACE_TLS_AK', 'CODEX_TLS_AK', 'TLS_AK');
+    const sk = firstEnv(env, 'TRACE_TLS_SK', 'CODEX_TLS_SK', 'TLS_SK');
+    const timeoutMs = Number(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 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 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;
+}
+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));
+}
+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 config_firstEnv(...names) {
+    for (const name of names){
+        const value = process.env[name];
+        if ('string' == typeof value && '' !== value.trim()) return value.trim();
+    }
+}
+function envFlag(name, defaultValue = false) {
+    const value = process.env[name];
+    if (void 0 === value || '' === value) return defaultValue;
+    return /^(1|true|yes|y|on)$/i.test(value);
+}
+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 defaultDataRoot() {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.trae-cn', 'plugins', 'data', 'tls-observer-trae');
+}
+function defaultEnvFile() {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.trae-cn', 'tls-observer-trae.env');
+}
+function config_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 loadEnvFile(filePath) {
+    const target = filePath || config_firstEnv('TRAE_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] ??= config_parseEnvValue(rawValue);
+    }
+    return true;
+}
+function loadConfig() {
+    loadEnvFile();
+    const dataRoot = config_firstEnv('TRAE_TLS_DATA_ROOT', 'TRAE_PLUGIN_DATA') || defaultDataRoot();
+    const serviceName = config_firstEnv('TRAE_OTEL_SERVICE_NAME') || 'trae-contextfs-hook';
+    const exportRetries = Math.min(envPositiveInteger('TRAE_TLS_EXPORT_TIMEOUT_RETRIES', 1), 3);
+    return {
+        enabled: !envDisabled('TRAE_TLS_EXPORT'),
+        dataRoot,
+        turnStateFilePath: config_firstEnv('TRAE_TLS_TURN_STATE_FILE') || __rspack_external_node_path_c5b9b54f.join(dataRoot, 'state', 'trae-turn-state.json'),
+        sendLogsDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'logs', 'send'),
+        diagnosticLogMaxBytes: envPositiveInteger('TRAE_TLS_DIAGNOSTIC_LOG_MAX_BYTES', 5242880),
+        diagnosticLogMaxFiles: envPositiveInteger('TRAE_TLS_DIAGNOSTIC_LOG_MAX_FILES', 3),
+        captureContent: !envDisabled('TRAE_TLS_CAPTURE_CONTENT'),
+        debugArtifacts: envFlag('TRAE_TLS_DEBUG_ARTIFACTS', false),
+        serviceName,
+        serviceInstanceId: `${serviceName}@${hostname()}:${process.pid}`,
+        ctxCli: config_firstEnv('TRAE_CONTEXTFS_CLI') || 'ctx-cli',
+        ctxCliTimeoutMs: envPositiveInteger('TRAE_CONTEXTFS_TIMEOUT_MS', 10000),
+        tlsEndpoint: config_firstEnv('TRAE_TLS_ENDPOINT', 'TRACE_TLS_ENDPOINT', 'TLS_ENDPOINT'),
+        otelEndpoint: config_firstEnv('TRAE_TLS_OTEL_ENDPOINT', 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'),
+        region: config_firstEnv('TRAE_TLS_REGION', 'TLS_REGION'),
+        traceTopicId: config_firstEnv('TRAE_TLS_TRACE_TOPIC_ID', 'TRAE_TLS_TOPIC_ID', 'TLS_TRACE_TOPIC_ID'),
+        apiKey: config_firstEnv('TRAE_TLS_API_KEY', 'TLS_API_KEY'),
+        ak: config_firstEnv('TRAE_TLS_AK', 'TLS_AK'),
+        sk: config_firstEnv('TRAE_TLS_SK', 'TLS_SK'),
+        authMode: 'resource' === config_firstEnv('TRAE_TLS_AUTH_MODE', 'TLS_AUTH_MODE') ? 'resource' : 'header',
+        exportTimeoutMs: envPositiveInteger('TRAE_TLS_EXPORT_TIMEOUT_MS', 20000),
+        exportTimeoutRetries: exportRetries
+    };
+}
+function localIdentityMetadata() {
+    return {
+        'user.name': userInfo().username
+    };
+}
+async function readStdinJson() {
+    const text = await new Promise((resolve, reject)=>{
+        let input = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk)=>{
+            input += chunk;
+        });
+        process.stdin.on('end', ()=>resolve(input));
+        process.stdin.on('error', reject);
+    });
+    if (!text.trim()) return {};
+    return JSON.parse(text);
+}
+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))
+        ]
+    };
+}
+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 = 'trae';
+const ROOT_SPAN_NAME = 'agent.turn';
+const LLM_SPAN_NAME = 'llm.request';
+const TOOL_SPAN_NAME = 'tool.call';
+function trae_isRecord(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function detectTraeInput(input) {
+    return input?.tool === 'trae' || input?.source_tool === 'trae' || Array.isArray(input?.messages) || Array.isArray(input?.lines) || Array.isArray(input?.jsonl);
+}
+async function loadTraeSession(input) {
+    if (!detectTraeInput(input)) throw new Error('Trae adapter requires tool=trae and messages/lines/jsonl');
+    const messages = normalizeMessages(input.messages ?? input.lines ?? input.jsonl ?? []);
+    return {
+        ...input,
+        messages
+    };
+}
+function parseJsonLine(line) {
+    if (trae_isRecord(line)) return line;
+    if ('string' != typeof line || !line.trim()) return;
+    try {
+        const parsed = JSON.parse(line);
+        return trae_isRecord(parsed) ? parsed : void 0;
+    } catch  {
+        return;
+    }
+}
+function normalizeMessages(raw) {
+    return raw.map(parseJsonLine).filter((line)=>Boolean(line));
+}
+function compactText(value) {
+    if ('string' == typeof value) return value;
+    if (Array.isArray(value)) return value.map((item)=>{
+        if ('string' == typeof item) return item;
+        if (trae_isRecord(item)) return item.text ?? item.content ?? item.value ?? '';
+        return '';
+    }).filter(Boolean).join('\n');
+    if (trae_isRecord(value)) return value.text ?? value.content ?? JSON.stringify(value);
+    return null == value ? '' : String(value);
+}
+function extractUserInput(text) {
+    const matches = [
+        ...text.matchAll(/<user_input>\s*([\s\S]*?)\s*<\/user_input>/g)
+    ];
+    const last = matches.at(-1)?.[1]?.trim();
+    if (last) return last;
+    return text.trim();
+}
+function messageContent(message) {
+    const text = compactText(message.content);
+    if ('user' === message.role) return extractUserInput(text);
+    return text;
+}
+function eventTime(message, fallbackMs) {
+    const raw = message.timestamp ?? message.created_at ?? message.createdAt ?? message.time;
+    if ('number' == typeof raw && Number.isFinite(raw)) return new Date(raw).toISOString();
+    if ('string' == typeof raw && raw.trim()) {
+        const parsed = Date.parse(raw);
+        if (Number.isFinite(parsed)) return new Date(parsed).toISOString();
+    }
+    return new Date(fallbackMs).toISOString();
+}
+function parseArguments(value) {
+    if ('string' != typeof value) return value;
+    try {
+        return JSON.parse(value);
+    } catch  {
+        return value;
+    }
+}
+function toolCallFromToolMessage(message, index) {
+    const output = compactText(message.content ?? message.output ?? message.result ?? message.response ?? '');
+    return {
+        id: message.tool_call_id ?? `tool-${index + 1}`,
+        name: message.llm_tool_name ?? message.tool_name ?? message.name ?? 'tool',
+        input: parseArguments(message.tool_input ?? message.input),
+        output,
+        timestamp: message.timestamp,
+        start_time_ms: message.start_time_ms ?? message.startTimeMs,
+        end_time_ms: message.end_time_ms ?? message.endTimeMs,
+        is_error: Boolean(message.is_error || message.error),
+        error: message.error,
+        raw: message
+    };
+}
+function usageFromMessage(message) {
+    const usage = trae_isRecord(message.usage) ? message.usage : {};
+    const result = {
+        input_tokens: usage.input_tokens ?? usage.inputTokens ?? usage.prompt_tokens ?? usage.promptTokens,
+        output_tokens: usage.output_tokens ?? usage.outputTokens ?? usage.completion_tokens ?? usage.completionTokens,
+        cache_read_input_tokens: usage.cache_read_input_tokens ?? usage.cacheReadInputTokens ?? usage.cached_input_tokens ?? usage.cachedInputTokens,
+        reasoning_output_tokens: usage.reasoning_output_tokens ?? usage.reasoningOutputTokens ?? usage.reasoning_tokens ?? usage.reasoningTokens,
+        total_tokens: usage.total_tokens ?? usage.totalTokens,
+        estimated: usage.estimated,
+        token_estimate_method: usage.token_estimate_method ?? usage.tokenEstimateMethod
+    };
+    if ('number' != typeof result.total_tokens) {
+        const input = result.input_tokens;
+        const output = result.output_tokens;
+        if ('number' == typeof input || 'number' == typeof output) result.total_tokens = (input ?? 0) + (output ?? 0);
+    }
+    return result;
+}
+function sumUsage(messages, sessionUsage = {}) {
+    const hasSessionUsage = 'number' == typeof (sessionUsage.input_tokens ?? sessionUsage.inputTokens) || 'number' == typeof (sessionUsage.output_tokens ?? sessionUsage.outputTokens) || 'number' == typeof (sessionUsage.total_tokens ?? sessionUsage.totalTokens);
+    const total = {
+        input_tokens: sessionUsage.input_tokens ?? sessionUsage.inputTokens,
+        output_tokens: sessionUsage.output_tokens ?? sessionUsage.outputTokens,
+        cache_read_input_tokens: sessionUsage.cache_read_input_tokens ?? sessionUsage.cacheReadInputTokens,
+        reasoning_output_tokens: sessionUsage.reasoning_output_tokens ?? sessionUsage.reasoningOutputTokens,
+        total_tokens: sessionUsage.total_tokens ?? sessionUsage.totalTokens,
+        estimated: sessionUsage.estimated,
+        token_estimate_method: sessionUsage.token_estimate_method ?? sessionUsage.tokenEstimateMethod
+    };
+    if (hasSessionUsage) return total;
+    for (const message of messages){
+        const usage = usageFromMessage(message);
+        for (const key of [
+            'input_tokens',
+            'output_tokens',
+            'cache_read_input_tokens',
+            'reasoning_output_tokens',
+            'total_tokens'
+        ])if ('number' == typeof usage[key]) total[key] = (total[key] ?? 0) + usage[key];
+    }
+    if ('number' != typeof total.total_tokens) {
+        const input = total.input_tokens;
+        const output = total.output_tokens;
+        if ('number' == typeof input || 'number' == typeof output) total.total_tokens = (input ?? 0) + (output ?? 0);
+    }
+    return total;
+}
+function hasUsageTokens(usage) {
+    return 'number' == typeof usage.input_tokens || 'number' == typeof usage.output_tokens || 'number' == typeof usage.total_tokens;
+}
+function sourceSpecificAttributes(session, common) {
+    return Object.fromEntries(Object.entries({
+        'trae.hook_event_name': session.hook_event_name ?? session.hookEventName,
+        'trae.operation_id': session.operation_id ?? session.operationId,
+        'trae.trace_id': session.trace_id ?? session.traceId,
+        'gen_ai.agent.name': common['agent.name'],
+        ...session.attributes ?? {}
+    }).filter(([key, value])=>{
+        if (key.startsWith('gen_ai.usage.') || key.startsWith('trae.usage.')) return false;
+        return null != value && '' !== value;
+    }));
+}
+function shouldCaptureContent(session) {
+    return false !== session.capture_content && false !== session.captureContent;
+}
+function maybeCaptured(session, value) {
+    return shouldCaptureContent(session) ? value : '[content capture disabled]';
+}
+function otelMessage(session, message) {
+    return {
+        role: message.role,
+        parts: [
+            {
+                type: 'text',
+                content: maybeCaptured(session, messageContent(message))
+            }
+        ]
+    };
+}
+function messagesPayload(messages) {
+    return messages && messages.length > 0 ? {
+        messages
+    } : void 0;
+}
+function providerName(session, message) {
+    return firstString(message?.provider, message?.provider_name, message?.providerName, session.provider, session.provider_name, session.providerName, session.model_provider, session.modelProvider) ?? 'trae';
+}
+function firstString(...values) {
+    for (const value of values)if ('string' == typeof value && value.trim()) return value.trim();
+}
+function baseAttributes(session) {
+    return {
+        'session.id': session.session_id ?? session.sessionId,
+        'tls.app.type': TLS_APP_TYPE,
+        'tls.plugin.version': session.plugin_version ?? session.pluginVersion,
+        'agent.name': TLS_APP_TYPE,
+        'agent.version': session.agent_version,
+        'user.name': session.user_name ?? session.userName ?? session.email ?? session.attributes?.['user.name']
+    };
+}
+function previousUserMessage(session, assistantIndex) {
+    for(let index = assistantIndex - 1; index >= 0; index -= 1)if (session.messages[index]?.role === 'user') return [
+        otelMessage(session, session.messages[index])
+    ];
+}
+function firstUserMessages(session) {
+    const user = session.messages.find((message)=>'user' === message.role);
+    return user ? [
+        otelMessage(session, user)
+    ] : void 0;
+}
+function rootOutputMessages(session) {
+    const messages = session.messages.filter((message)=>'assistant' === message.role && true !== message.synthetic_tool_request).map((message)=>otelMessage(session, message));
+    return messages.length > 0 ? messages : void 0;
+}
+function assistantSpans(session, rootId, startedAt, endedAt) {
+    const common = baseAttributes(session);
+    sumUsage(session.messages, session.usage);
+    const assistantMessages = session.messages.filter((message)=>'assistant' === message.role && true !== message.synthetic_tool_request);
+    return session.messages.map((message, index)=>({
+            message,
+            index
+        })).filter(({ message })=>'assistant' === message.role && true !== message.synthetic_tool_request).map(({ message, index })=>{
+        const id = spanIdFromSeed(session.session_id, session.turn_id, index, 'llm');
+        const messageStartedAt = eventTime(message, Date.parse(startedAt) + index);
+        const inputMessages = previousUserMessage(session, index);
+        const outputMessages = [
+            otelMessage(session, message)
+        ];
+        const messageUsage = usageFromMessage(message);
+        hasUsageTokens(messageUsage) || assistantMessages.length;
+        return {
+            id,
+            parentId: rootId,
+            name: LLM_SPAN_NAME,
+            kind: 'client',
+            type: 'model',
+            startedAt: message.started_at ?? messageStartedAt,
+            endedAt: message.ended_at ?? messageStartedAt,
+            status: message.error ? 'error' : 'unset',
+            input: messagesPayload(inputMessages),
+            output: messagesPayload(outputMessages),
+            attributes: {
+                ...common,
+                'source.tool': 'trae',
+                'gen_ai.system': 'trae',
+                'gen_ai.request.model': message.model ?? session.model,
+                'gen_ai.provider.name': providerName(session, message),
+                'gen_ai.operation.name': 'chat',
+                'gen_ai.input.messages': inputMessages,
+                'gen_ai.output.messages': outputMessages,
+                'trae.message.index': index,
+                'trae.message.role': message.role,
+                'trae.message.id': message.id ?? message.message_id ?? message.messageId
+            }
+        };
+    });
+}
+function toolSpans(session, rootId, startedAt) {
+    const spans = [];
+    const common = baseAttributes(session);
+    for (const [index, message] of session.messages.entries()){
+        if ('tool' !== message.role) continue;
+        const call = toolCallFromToolMessage(message, index);
+        const resultOutput = call.output;
+        const toolStartedAt = 'number' == typeof call.start_time_ms && Number.isFinite(call.start_time_ms) ? new Date(call.start_time_ms).toISOString() : call.timestamp ? eventTime(call, Date.parse(startedAt) + index) : eventTime(message, Date.parse(startedAt) + index);
+        const toolEndedAt = 'number' == typeof call.end_time_ms && Number.isFinite(call.end_time_ms) ? new Date(call.end_time_ms).toISOString() : eventTime(message, Date.parse(toolStartedAt) + 1);
+        spans.push({
+            id: spanIdFromSeed(session.session_id, session.turn_id, call.id, index, 'tool'),
+            parentId: rootId,
+            name: TOOL_SPAN_NAME,
+            kind: 'client',
+            type: 'tool',
+            startedAt: toolStartedAt,
+            endedAt: toolEndedAt,
+            status: call.is_error || call.error ? 'error' : 'unset',
+            input: maybeCaptured(session, call.input),
+            output: maybeCaptured(session, resultOutput),
+            attributes: {
+                ...common,
+                'tool.error': Boolean(call.is_error || call.error),
+                'gen_ai.tool.name': call.name,
+                'gen_ai.tool.call.id': call.id,
+                'gen_ai.tool.call.arguments': maybeCaptured(session, call.input),
+                'gen_ai.tool.call.result': maybeCaptured(session, resultOutput),
+                'trae.message.index': index
+            }
+        });
+    }
+    return spans;
+}
+function canonicalMessages(session) {
+    return session.messages.filter((message)=>[
+            'user',
+            'assistant',
+            'tool'
+        ].includes(String(message.role))).map((message, index)=>({
+            role: message.role,
+            content: maybeCaptured(session, messageContent(message)),
+            timestamp: eventTime(message, (session.started_at_ms ?? Date.now()) + index),
+            attributes: {
+                'trae.message.index': index,
+                'trae.message.id': message.id ?? message.message_id ?? message.messageId,
+                'trae.tool_call_id': message.tool_call_id
+            }
+        }));
+}
+function rootTimes(session) {
+    const now = Date.now();
+    const first = session.messages[0] ?? {};
+    const last = session.messages.at(-1) ?? first;
+    return {
+        startedAt: eventTime(first, session.started_at_ms ?? now),
+        endedAt: eventTime(last, session.ended_at_ms ?? session.started_at_ms ?? now)
+    };
+}
+async function toCanonicalTraeTrace(session) {
+    const { startedAt, endedAt } = rootTimes(session);
+    const sessionId = session.session_id ?? session.sessionId ?? 'trae-session';
+    const turnId = session.turn_id ?? session.turnId ?? session.message_id ?? session.messageId;
+    const rootId = session.root_span_id ?? spanIdFromSeed(sessionId, turnId ?? 'turn', 'root');
+    const usage = sumUsage(session.messages, session.usage);
+    const toolSpanList = toolSpans({
+        ...session,
+        session_id: sessionId,
+        turn_id: turnId
+    }, rootId, startedAt);
+    const normalizedSession = {
+        ...session,
+        session_id: sessionId,
+        turn_id: turnId
+    };
+    const rootInputMessages = firstUserMessages(normalizedSession);
+    const rootOutputMessageList = rootOutputMessages(normalizedSession);
+    const common = baseAttributes(normalizedSession);
+    const warnings = [];
+    if (!session.messages.some((message)=>'assistant' === message.role)) warnings.push('Trae hook turn does not contain an assistant message yet');
+    if ('number' != typeof usage.input_tokens && 'number' != typeof usage.output_tokens) warnings.push('Trae token usage was not found in hook payload or messages');
+    return {
+        source: {
+            tool: 'trae',
+            sessionId,
+            turnId,
+            threadId: session.thread_id ?? session.threadId,
+            conversationId: session.conversation_id ?? session.conversationId,
+            cwd: session.cwd,
+            model: session.model,
+            attributes: sourceSpecificAttributes(session, common)
+        },
+        root: {
+            id: rootId,
+            name: ROOT_SPAN_NAME,
+            kind: 'server',
+            type: 'agent',
+            startedAt,
+            endedAt,
+            status: session.error ? 'error' : 'unset',
+            input: messagesPayload(rootInputMessages),
+            output: messagesPayload(rootOutputMessageList),
+            attributes: {
+                ...common,
+                'gen_ai.request.model': session.model,
+                'gen_ai.provider.name': providerName(session),
+                'gen_ai.operation.name': 'agent',
+                'gen_ai.input.messages': rootInputMessages,
+                'gen_ai.output.messages': rootOutputMessageList
+            }
+        },
+        spans: [
+            ...toolSpanList,
+            ...assistantSpans(normalizedSession, rootId, startedAt, endedAt)
+        ],
+        messages: canonicalMessages(session),
+        metrics: {
+            inputTokens: usage.input_tokens,
+            outputTokens: usage.output_tokens,
+            totalTokens: usage.total_tokens,
+            toolCallCount: toolSpanList.length
+        },
+        diagnostics: {
+            warnings,
+            incomplete: !session.messages.some((message)=>'assistant' === message.role),
+            parser: {
+                contextfs_files: session.contextfs_files ?? session.contextfsFiles
+            }
+        }
+    };
+}
+const traeAdapter = {
+    name: 'trae',
+    detect: detectTraeInput,
+    load: loadTraeSession,
+    toCanonical: toCanonicalTraeTrace
+};
+async function writeTextFileAtomic(filePath, text, options = {}) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+    const tempPath = __rspack_external_node_path_c5b9b54f.join(__rspack_external_node_path_c5b9b54f.dirname(filePath), `.${__rspack_external_node_path_c5b9b54f.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+    let renamed = false;
+    try {
+        await __rspack_external_node_fs_promises_153e37e0.writeFile(tempPath, text, {
+            encoding: 'utf8',
+            ...void 0 === options.mode ? {} : {
+                mode: options.mode
+            }
+        });
+        await __rspack_external_node_fs_promises_153e37e0.rename(tempPath, filePath);
+        renamed = true;
+        if (void 0 !== options.mode) await __rspack_external_node_fs_promises_153e37e0.chmod(filePath, options.mode);
+    } finally{
+        if (!renamed) await __rspack_external_node_fs_promises_153e37e0.rm(tempPath, {
+            force: true
+        }).catch(()=>void 0);
+    }
+}
+const DEFAULT_MAX_FILES = 3;
+const LOCK_STALE_MS = 30000;
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_RETRY_MS = 25;
+async function appendJsonlFile(filePath, values) {
+    const entries = Array.isArray(values) ? values : [
+        values
+    ];
+    if (0 === entries.length) return;
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.appendFile(filePath, `${entries.map((entry)=>JSON.stringify(entry)).join('\n')}\n`, 'utf8');
+}
+async function delay(ms) {
+    await new Promise((resolve)=>setTimeout(resolve, ms));
+}
+async function withJsonlFileLock(filePath, action) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+    const lockPath = `${filePath}.lock`;
+    const startedAt = Date.now();
+    while(true)try {
+        const handle = await __rspack_external_node_fs_promises_153e37e0.open(lockPath, 'wx');
+        try {
+            await handle.writeFile(`${process.pid}:${new Date().toISOString()}\n`, 'utf8');
+            return await action();
+        } finally{
+            await handle.close().catch(()=>void 0);
+            await __rspack_external_node_fs_promises_153e37e0.rm(lockPath, {
+                force: true
+            }).catch(()=>void 0);
+        }
+    } catch (error) {
+        if ('EEXIST' !== error.code) throw error;
+        try {
+            const stat = await __rspack_external_node_fs_promises_153e37e0.stat(lockPath);
+            if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                await __rspack_external_node_fs_promises_153e37e0.rm(lockPath, {
+                    force: true
+                }).catch(()=>void 0);
+                continue;
+            }
+        } catch (statError) {
+            if ('ENOENT' === statError.code) continue;
+            throw statError;
+        }
+        if (Date.now() - startedAt > LOCK_TIMEOUT_MS) throw new Error(`Timed out waiting for JSONL file lock: ${lockPath}`);
+        await delay(LOCK_RETRY_MS);
+    }
+}
+function rotatedFileName(filePath, now = new Date()) {
+    const dir = __rspack_external_node_path_c5b9b54f.dirname(filePath);
+    const ext = __rspack_external_node_path_c5b9b54f.extname(filePath);
+    const base = __rspack_external_node_path_c5b9b54f.basename(filePath, ext);
+    const stamp = now.toISOString().replace(/[-:.TZ]/g, '').slice(0, 17);
+    return __rspack_external_node_path_c5b9b54f.join(dir, `${base}.${stamp}.${process.pid}.${randomUUID()}${ext || '.jsonl'}`);
+}
+function rotatedFilePattern(filePath) {
+    const ext = __rspack_external_node_path_c5b9b54f.extname(filePath);
+    const base = __rspack_external_node_path_c5b9b54f.basename(filePath, ext).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedExt = (ext || '.jsonl').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^${base}\\.\\d{17}\\.\\d+\\.[0-9a-f-]+${escapedExt}$`);
+}
+async function pruneRotatedJsonlFiles(filePath, maxFiles) {
+    const maxRotatedFiles = Math.max(0, maxFiles - 1);
+    const dir = __rspack_external_node_path_c5b9b54f.dirname(filePath);
+    const pattern = rotatedFilePattern(filePath);
+    let entries;
+    try {
+        entries = await __rspack_external_node_fs_promises_153e37e0.readdir(dir);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    const rotated = entries.filter((entry)=>pattern.test(entry)).sort((left, right)=>right.localeCompare(left)).map((entry)=>__rspack_external_node_path_c5b9b54f.join(dir, entry));
+    await Promise.all(rotated.slice(maxRotatedFiles).map((target)=>__rspack_external_node_fs_promises_153e37e0.rm(target, {
+            force: true
+        })));
+}
+async function rotateActiveJsonlFile(filePath, maxFiles) {
+    await __rspack_external_node_fs_promises_153e37e0.rename(filePath, rotatedFileName(filePath)).catch(async (error)=>{
+        if ('ENOENT' !== error.code) throw error;
+    });
+    await pruneRotatedJsonlFiles(filePath, maxFiles);
+}
+async function trimJsonlFileByBytes(filePath, maxBytes) {
+    if (maxBytes <= 0) return void await __rspack_external_node_fs_promises_153e37e0.rm(filePath, {
+        force: true
+    }).catch(()=>void 0);
+    let stat;
+    try {
+        stat = await __rspack_external_node_fs_promises_153e37e0.stat(filePath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    if (stat.size <= maxBytes) return;
+    const lines = (await __rspack_external_node_fs_promises_153e37e0.readFile(filePath, 'utf8')).split(/\r?\n/).filter(Boolean);
+    const kept = [];
+    let keptBytes = 0;
+    for(let index = lines.length - 1; index >= 0; index -= 1){
+        const line = lines[index];
+        const lineBytes = Buffer.byteLength(`${line}\n`, 'utf8');
+        if (kept.length > 0 && keptBytes + lineBytes > maxBytes) break;
+        kept.push(line);
+        keptBytes += lineBytes;
+        if (keptBytes >= maxBytes) break;
+    }
+    await writeTextFileAtomic(filePath, kept.length ? `${kept.reverse().join('\n')}\n` : '');
+}
+async function appendBoundedJsonlFile(filePath, values, maxBytes, options = {}) {
+    const entries = Array.isArray(values) ? values : [
+        values
+    ];
+    if (0 === entries.length) return;
+    if ('rotate' !== options.strategy) return void await withJsonlFileLock(filePath, async ()=>{
+        await appendJsonlFile(filePath, entries);
+        await trimJsonlFileByBytes(filePath, maxBytes);
+    });
+    await withJsonlFileLock(filePath, async ()=>{
+        const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+        if (maxBytes <= 0 || maxFiles <= 0) {
+            await __rspack_external_node_fs_promises_153e37e0.rm(filePath, {
+                force: true
+            }).catch(()=>void 0);
+            await pruneRotatedJsonlFiles(filePath, 0);
+            return;
+        }
+        let currentBytes = 0;
+        try {
+            currentBytes = (await __rspack_external_node_fs_promises_153e37e0.stat(filePath)).size;
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        for (const entry of entries){
+            const line = `${JSON.stringify(entry)}\n`;
+            const lineBytes = Buffer.byteLength(line, 'utf8');
+            if (currentBytes > 0 && currentBytes + lineBytes > maxBytes) {
+                await rotateActiveJsonlFile(filePath, maxFiles);
+                currentBytes = 0;
+            }
+            await __rspack_external_node_fs_promises_153e37e0.appendFile(filePath, line, 'utf8');
+            currentBytes += lineBytes;
+        }
+        await pruneRotatedJsonlFiles(filePath, maxFiles);
+    });
+}
+const execFileAsync = promisify(execFile);
+const REQUIRED_CFS_ENV = [
+    'CFS_TOKEN',
+    'CFS_IPC_NAME'
+];
+function contextfs_isRecord(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function contextfs_firstString(...values) {
+    for (const value of values)if ('string' == typeof value && value.trim()) return value.trim();
+}
+function sessionIdFromInput(input) {
+    return contextfs_firstString(input.session_id);
+}
+function turnIdFromInput(input) {}
+function contextFsEnvStatus(env = process.env) {
+    const missing = REQUIRED_CFS_ENV.filter((key)=>!env[key]?.trim());
+    return {
+        ready: 0 === missing.length,
+        missing,
+        cfsTokenPresent: Boolean(env.CFS_TOKEN?.trim()),
+        cfsIpcNamePresent: Boolean(env.CFS_IPC_NAME?.trim()),
+        cfsTransport: env.CFS_TRANSPORT?.trim() || 'ipc'
+    };
+}
+function parseContextFsListing(stdout) {
+    return stdout.split(/\r?\n/).map((line)=>line.trim()).filter(Boolean).map((line)=>line.split(/\s+/).at(-1) || line).filter((line)=>line.endsWith('.jsonl'));
+}
+function parseJsonl(text) {
+    const messages = [];
+    const errors = [];
+    for (const [index, rawLine] of text.split(/\r?\n/).entries()){
+        const line = rawLine.trim();
+        if (line) try {
+            const parsed = JSON.parse(line);
+            if (contextfs_isRecord(parsed)) messages.push(parsed);
+        } catch (error) {
+            errors.push(`line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        messages,
+        errors
+    };
+}
+function contextFsChildEnv(env = process.env) {
+    return {
+        ...env,
+        CFS_TRANSPORT: env.CFS_TRANSPORT?.trim() || 'ipc'
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function ctxCli(config, args, env) {
+    const { stdout } = await execFileAsync(config.ctxCli, args, {
+        timeout: config.ctxCliTimeoutMs,
+        env: contextFsChildEnv(env),
+        maxBuffer: 20971520
+    });
+    return stdout;
+}
+function selectHistoryFiles(files, turnId) {
+    if (!turnId) return files;
+    const exact = files.filter((file)=>file.includes(turnId));
+    return exact.length > 0 ? exact : files;
+}
+async function readContextFsTurn(options) {
+    const envStatus = contextFsEnvStatus(options.env);
+    if (!envStatus.ready) return {
+        files: [],
+        messages: [],
+        errors: [
+            `missing required ContextFS environment: ${envStatus.missing.join(', ')}`
+        ],
+        missingEnv: envStatus.missing,
+        envStatus
+    };
+    const baseUri = `context://history/${options.sessionId}/`;
+    let listing = '';
+    try {
+        listing = await ctxCli(options.config, [
+            'ls',
+            baseUri
+        ], options.env);
+    } catch (error) {
+        return {
+            files: [],
+            messages: [],
+            errors: [
+                `ctx-cli ls ${baseUri} failed: ${errorMessage(error)}`
+            ],
+            envStatus
+        };
+    }
+    const files = selectHistoryFiles(parseContextFsListing(listing), options.turnId);
+    const messages = [];
+    const errors = [];
+    for (const file of files){
+        const uri = file.startsWith('context://') ? file : `${baseUri}${file}`;
+        try {
+            const text = await ctxCli(options.config, [
+                'cat',
+                uri
+            ], options.env);
+            const parsed = parseJsonl(text);
+            messages.push(...parsed.messages);
+            errors.push(...parsed.errors.map((error)=>`${file}: ${error}`));
+        } catch (error) {
+            errors.push(`${file}: ${errorMessage(error)}`);
+        }
+    }
+    return {
+        files,
+        messages,
+        errors,
+        envStatus
+    };
+}
+const state_LOCK_TIMEOUT_MS = 5000;
+const state_LOCK_RETRY_MS = 20;
+const SESSION_MAX_AGE_MS = 86400000;
+function state_sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+function emptyState() {
+    return {
+        version: 1,
+        sessions: {}
+    };
+}
+function state_lockPath(stateFilePath) {
+    return `${stateFilePath}.lock`;
+}
+async function state_acquireLock(stateFilePath) {
+    const lock = state_lockPath(stateFilePath);
+    const deadline = Date.now() + state_LOCK_TIMEOUT_MS;
+    __rspack_external_node_fs_5ea92f0c.mkdirSync(__rspack_external_node_path_c5b9b54f.dirname(stateFilePath), {
+        recursive: true
+    });
+    while(Date.now() < deadline)try {
+        const fd = __rspack_external_node_fs_5ea92f0c.openSync(lock, 'wx');
+        __rspack_external_node_fs_5ea92f0c.closeSync(fd);
+        return;
+    } catch  {
+        await state_sleep(state_LOCK_RETRY_MS);
+    }
+    try {
+        __rspack_external_node_fs_5ea92f0c.unlinkSync(lock);
+    } catch  {}
+    const fd = __rspack_external_node_fs_5ea92f0c.openSync(lock, 'wx');
+    __rspack_external_node_fs_5ea92f0c.closeSync(fd);
+}
+function state_releaseLock(stateFilePath) {
+    try {
+        __rspack_external_node_fs_5ea92f0c.unlinkSync(state_lockPath(stateFilePath));
+    } catch  {}
+}
+function loadState(stateFilePath) {
+    try {
+        const state = JSON.parse(__rspack_external_node_fs_5ea92f0c.readFileSync(stateFilePath, 'utf8'));
+        if (1 !== state.version || !state.sessions || 'object' != typeof state.sessions) return emptyState();
+        return state;
+    } catch  {
+        return emptyState();
+    }
+}
+function getSessionState(state, sessionId) {
+    return state.sessions[sessionId] ?? {
+        sessionId,
+        active: false,
+        messages: [],
+        pendingToolUses: {},
+        createdAt: '',
+        updatedAt: ''
+    };
+}
+function pruneOldSessions(state, now = Date.now()) {
+    const cutoff = now - SESSION_MAX_AGE_MS;
+    const sessions = {};
+    for (const [sessionId, session] of Object.entries(state.sessions ?? {})){
+        const updatedMs = session.updatedAt ? new Date(session.updatedAt).getTime() : 0;
+        if (session.active || updatedMs >= cutoff) sessions[sessionId] = session;
+    }
+    return {
+        version: 1,
+        sessions
+    };
+}
+async function atomicUpdateState(stateFilePath, fn) {
+    await state_acquireLock(stateFilePath);
+    try {
+        const next = pruneOldSessions(fn(loadState(stateFilePath)));
+        __rspack_external_node_fs_5ea92f0c.mkdirSync(__rspack_external_node_path_c5b9b54f.dirname(stateFilePath), {
+            recursive: true
+        });
+        __rspack_external_node_fs_5ea92f0c.writeFileSync(stateFilePath, `${JSON.stringify(next, null, 2)}\n`, {
+            encoding: 'utf8',
+            mode: 384
+        });
+        __rspack_external_node_fs_5ea92f0c.chmodSync(stateFilePath, 384);
+    } finally{
+        state_releaseLock(stateFilePath);
+    }
+}
+function clearedActiveSession(session, updates = {}) {
+    return {
+        ...session,
+        ...updates,
+        active: false,
+        turnId: void 0,
+        hookEventName: void 0,
+        messages: [],
+        usage: void 0,
+        pendingToolUses: {},
+        updatedAt: new Date().toISOString()
+    };
+}
+async function saveTurnStartState(stateFilePath, turn) {
+    await atomicUpdateState(stateFilePath, (state)=>({
+            version: 1,
+            sessions: {
+                ...state.sessions,
+                [turn.sessionId]: turn
+            }
+        }));
+}
+function readTurnStartState(stateFilePath, sessionId) {
+    return loadState(stateFilePath).sessions[sessionId];
+}
+function hookEventName(input) {
+    return 'string' == typeof input.hook_event_name ? input.hook_event_name : void 0;
+}
+function normalizedHookEventName(input) {
+    return String(hookEventName(input) ?? '').trim();
+}
+function tracer_isRecord(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function cwdFromInput(input) {
+    return 'string' == typeof input.cwd && input.cwd.trim() ? input.cwd.trim() : process.cwd();
+}
+function agentIdFromInput(input) {
+    return 'string' == typeof input.agent_id && input.agent_id.trim() ? input.agent_id.trim() : void 0;
+}
+function agentNameFromInput(input) {
+    if ('string' == typeof input.agent_type && input.agent_type.trim()) return input.agent_type.trim();
+    return agentIdFromInput(input);
+}
+function userNameFromInput(input) {
+    if ('string' == typeof input.email && input.email.trim()) return input.email.trim();
+    if ('string' == typeof input.user_name && input.user_name.trim()) return input.user_name.trim();
+    if ('string' == typeof input.userName && input.userName.trim()) return input.userName.trim();
+}
+function modelFromInput(input) {
+    return 'string' == typeof input.model && input.model.trim() ? input.model.trim() : void 0;
+}
+function timestampFromInput(_input, fallback = Date.now()) {
+    return new Date(fallback).toISOString();
+}
+function numberValue(value) {
+    if ('number' == typeof value && Number.isFinite(value)) return value;
+    if ('string' == typeof value && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) return parsed;
+    }
+}
+function usageFromRecord(record) {
+    const usage = tracer_isRecord(record.usage) ? record.usage : {};
+    const result = {
+        input_tokens: numberValue(usage.input_tokens),
+        output_tokens: numberValue(usage.output_tokens),
+        cache_read_input_tokens: numberValue(usage.cache_read_input_tokens),
+        reasoning_output_tokens: numberValue(usage.reasoning_output_tokens),
+        total_tokens: numberValue(usage.total_tokens)
+    };
+    if (void 0 === result.total_tokens && (void 0 !== result.input_tokens || void 0 !== result.output_tokens)) result.total_tokens = (result.input_tokens ?? 0) + (result.output_tokens ?? 0);
+    return result;
+}
+function tracer_hasUsageTokens(usage) {
+    return Boolean(usage && ('number' == typeof usage.input_tokens || 'number' == typeof usage.output_tokens || 'number' == typeof usage.total_tokens));
+}
+function mergeUsage(...usages) {
+    const result = {};
+    for (const usage of usages)if (usage) {
+        for (const key of [
+            'input_tokens',
+            'output_tokens',
+            'cache_read_input_tokens',
+            'reasoning_output_tokens',
+            'total_tokens'
+        ])if ('number' == typeof usage[key]) result[key] = usage[key];
+        if (void 0 !== usage.estimated) result.estimated = usage.estimated;
+        if (usage.token_estimate_method) result.token_estimate_method = usage.token_estimate_method;
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+}
+function tracer_compactText(value) {
+    if ('string' == typeof value) return value;
+    if (Array.isArray(value)) return value.map(tracer_compactText).filter(Boolean).join('\n');
+    if (tracer_isRecord(value)) {
+        const text = 'string' == typeof value.content ? value.content : void 0;
+        if ('string' == typeof text) return text;
+        return JSON.stringify(value);
+    }
+    return null == value ? '' : String(value);
+}
+function estimateTokens(value) {
+    const text = tracer_compactText(value);
+    if (!text) return 0;
+    const cjkCount = text.match(/[\u3400-\u9fff]/g)?.length ?? 0;
+    const nonCjk = text.replace(/[\u3400-\u9fff]/g, '');
+    const latinWordCount = nonCjk.match(/[A-Za-z0-9_]+/g)?.length ?? 0;
+    const otherChars = nonCjk.replace(/[A-Za-z0-9_\s]/g, '').length;
+    return Math.max(1, Math.ceil(cjkCount + 1.3 * latinWordCount + otherChars / 2));
+}
+function estimateTurnUsage(messages) {
+    const finalAssistantIndex = [
+        ...messages
+    ].reverse().findIndex((message)=>'assistant' === message.role);
+    if (finalAssistantIndex < 0) return;
+    const assistantIndex = messages.length - 1 - finalAssistantIndex;
+    const inputMessages = messages.slice(0, assistantIndex);
+    const outputMessage = messages[assistantIndex];
+    const inputTokens = inputMessages.reduce((sum, message)=>{
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls.reduce((toolSum, call)=>toolSum + estimateTokens(call.input), 0) : 0;
+        return sum + estimateTokens(message.content) + toolCalls;
+    }, 0);
+    const outputTokens = estimateTokens(outputMessage.content);
+    if (0 === inputTokens && 0 === outputTokens) return;
+    return {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: inputTokens + outputTokens,
+        estimated: true,
+        token_estimate_method: 'estimated_from_hook_messages_when_trae_hook_payload_does_not_include_model_token_usage'
+    };
+}
+function usageWithFallback(messages, usage) {
+    if (tracer_hasUsageTokens(usage)) return usage;
+    return estimateTurnUsage(messages);
+}
+function messageWithUsage(message, usage) {
+    if (!tracer_hasUsageTokens(usage) || tracer_hasUsageTokens(message.usage)) return message;
+    return {
+        ...message,
+        usage
+    };
+}
+function userMessageFromInput(input) {
+    const content = 'string' == typeof input.prompt && input.prompt.trim() ? input.prompt : void 0;
+    if (!content) return;
+    return {
+        role: 'user',
+        content,
+        timestamp: timestampFromInput(input)
+    };
+}
+function assistantMessageFromStop(input) {
+    return {
+        role: 'assistant',
+        content: 'string' == typeof input.last_assistant_message ? input.last_assistant_message : 'string' == typeof input.text_content ? input.text_content : '',
+        timestamp: timestampFromInput(input),
+        usage: usageFromRecord(input)
+    };
+}
+function toolNameFromInput(input) {
+    if ('string' == typeof input.llm_tool_name && input.llm_tool_name.trim()) return input.llm_tool_name.trim();
+    if ('string' == typeof input.tool_name && input.tool_name.trim()) return input.tool_name.trim();
+    return 'tool';
+}
+function toolCallIdFromInput(input, name) {
+    if ('string' == typeof input.tool_call_id && input.tool_call_id.trim()) return input.tool_call_id.trim();
+    return 'string' == typeof input.tool_use_id && input.tool_use_id.trim() ? input.tool_use_id.trim() : `${name}-${Date.now()}`;
+}
+function toolOutputFromInput(input) {
+    return input.tool_response;
+}
+function toolInputFromInput(input) {
+    return input.tool_input;
+}
+function pendingToolUseFromInput(input, fallbackMs = Date.now()) {
+    const name = toolNameFromInput(input);
+    const id = toolCallIdFromInput(input, name);
+    return {
+        tool_call_id: id,
+        tool_name: 'string' == typeof input.tool_name ? input.tool_name : void 0,
+        llm_tool_name: 'string' == typeof input.llm_tool_name ? input.llm_tool_name : void 0,
+        tool_input: toolInputFromInput(input),
+        start_time_ms: fallbackMs,
+        timestamp: timestampFromInput(input, fallbackMs)
+    };
+}
+function appendToolMessages(messages, input, pendingToolUse) {
+    const name = toolNameFromInput(input);
+    const id = toolCallIdFromInput(input, name);
+    const endMs = Date.now();
+    const endedAt = timestampFromInput(input, endMs);
+    const startMs = pendingToolUse?.start_time_ms ?? endMs;
+    const inputValue = void 0 !== input.tool_input ? toolInputFromInput(input) : pendingToolUse?.tool_input;
+    const outputValue = toolOutputFromInput(input);
+    const isError = Boolean(tracer_isRecord(input.tool_response) && (input.tool_response.error_code || input.tool_response.error_msg));
+    const nextMessages = [
+        ...messages
+    ];
+    const resultMessage = {
+        role: 'tool',
+        tool_call_id: id,
+        tool_name: 'string' == typeof input.tool_name ? input.tool_name : pendingToolUse?.tool_name ?? name,
+        llm_tool_name: 'string' == typeof input.llm_tool_name ? input.llm_tool_name : pendingToolUse?.llm_tool_name,
+        tool_input: inputValue,
+        start_time_ms: startMs,
+        end_time_ms: endMs,
+        content: outputValue ?? '',
+        timestamp: endedAt,
+        is_error: isError,
+        error: input.error
+    };
+    const existingResultIndex = nextMessages.findIndex((message)=>'tool' === message.role && message.tool_call_id === id);
+    if (existingResultIndex >= 0) nextMessages[existingResultIndex] = resultMessage;
+    else nextMessages.push(resultMessage);
+    return nextMessages;
+}
+function shouldWriteSendLog(config, record) {
+    if (config.debugArtifacts) return true;
+    const status = String(record.status ?? record.export_status ?? '').toLowerCase();
+    const reason = String(record.reason ?? '').toLowerCase();
+    return 'failed' === status || 'error' === status || reason.includes('error') || reason.includes('failed') || reason.includes('failure');
+}
+async function tracer_writeSendLog(config, record) {
+    if (!shouldWriteSendLog(config, record)) return;
+    const log = {
+        generated_at: new Date().toISOString(),
+        ...record
+    };
+    const jsonl = __rspack_external_node_path_c5b9b54f.join(config.dataRoot, 'logs', 'diagnostics', 'send-log.jsonl');
+    await appendBoundedJsonlFile(jsonl, log, config.diagnosticLogMaxBytes, {
+        strategy: 'rotate',
+        maxFiles: config.diagnosticLogMaxFiles
+    });
+}
+function hasAssistant(messages) {
+    return messages.some((message)=>'assistant' === message.role);
+}
+function internalTurnId(sessionId, createdAt) {
+    return `${sessionId}:${Date.parse(createdAt) || Date.now()}`;
+}
+function buildTurnStartState(input, sessionId) {
+    const now = new Date().toISOString();
+    const userMessage = userMessageFromInput(input);
+    return {
+        sessionId,
+        active: true,
+        turnId: internalTurnId(sessionId, now),
+        cwd: cwdFromInput(input),
+        agentId: agentIdFromInput(input),
+        agentName: agentNameFromInput(input),
+        userName: userNameFromInput(input),
+        model: modelFromInput(input),
+        hookEventName: hookEventName(input),
+        messages: userMessage ? [
+            userMessage
+        ] : [],
+        usage: mergeUsage(usageFromRecord(input)),
+        pendingToolUses: {},
+        createdAt: now,
+        updatedAt: now
+    };
+}
+function mergeTurnState(input, sessionId, state) {
+    const now = new Date().toISOString();
+    return {
+        sessionId,
+        active: state?.active ?? true,
+        turnId: state?.turnId ?? internalTurnId(sessionId, now),
+        cwd: state?.cwd ?? cwdFromInput(input),
+        agentId: state?.agentId ?? agentIdFromInput(input),
+        agentName: state?.agentName ?? agentNameFromInput(input),
+        userName: userNameFromInput(input) ?? state?.userName,
+        model: modelFromInput(input) ?? state?.model,
+        hookEventName: state?.hookEventName ?? hookEventName(input),
+        messages: state?.messages ? [
+            ...state.messages
+        ] : [],
+        usage: state?.usage,
+        pendingToolUses: {
+            ...state?.pendingToolUses ?? {}
+        },
+        createdAt: state?.createdAt ?? now,
+        updatedAt: now
+    };
+}
+function pipelineEnv(config) {
+    return {
+        ...process.env,
+        TRACE_TLS_EXPORT: config.enabled ? '1' : '0',
+        TRACE_TLS_ENDPOINT: config.tlsEndpoint,
+        TRACE_TLS_OTEL_ENDPOINT: config.otelEndpoint,
+        TRACE_TLS_REGION: config.region,
+        TRACE_TLS_TRACE_TOPIC_ID: config.traceTopicId,
+        TRACE_TLS_API_KEY: config.apiKey,
+        TRACE_TLS_AK: config.ak,
+        TRACE_TLS_SK: config.sk,
+        TRACE_TLS_AUTH_MODE: config.authMode,
+        TRACE_TLS_EXPORT_TIMEOUT_MS: String(config.exportTimeoutMs),
+        TRACE_TLS_EXPORT_TIMEOUT_RETRIES: String(config.exportTimeoutRetries),
+        OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: config.otelEndpoint,
+        TLS_REGION: config.region,
+        TLS_TRACE_TOPIC_ID: config.traceTopicId,
+        TLS_API_KEY: config.apiKey,
+        TLS_AK: config.ak,
+        TLS_SK: config.sk,
+        TLS_AUTH_MODE: config.authMode,
+        TLS_EXPORT_TIMEOUT_MS: String(config.exportTimeoutMs),
+        TLS_EXPORT_TIMEOUT_RETRIES: String(config.exportTimeoutRetries)
+    };
+}
+async function traceTraeSession(options) {
+    const { input, config } = options;
+    if (!config.enabled) {
+        const result = {
+            status: 'skipped',
+            reason: 'trae_tls_export_disabled'
+        };
+        await tracer_writeSendLog(config, result);
+        return result;
+    }
+    const sessionId = sessionIdFromInput(input);
+    if (!sessionId) {
+        const result = {
+            status: 'skipped',
+            reason: 'missing_session_id'
+        };
+        await tracer_writeSendLog(config, {
+            ...result,
+            hook_input_keys: Object.keys(input).sort()
+        });
+        return result;
+    }
+    const event = normalizedHookEventName(input);
+    if (/^UserPromptSubmit$/i.test(event)) {
+        const state = buildTurnStartState(input, sessionId);
+        await saveTurnStartState(config.turnStateFilePath, state);
+        const result = {
+            status: 'recorded',
+            reason: 'turn_start_recorded',
+            source: {
+                tool: 'trae',
+                sessionId,
+                turnId: state.turnId
+            },
+            hook_event_name: event,
+            turn_state_file: config.turnStateFilePath,
+            message_count: state.messages?.length ?? 0
+        };
+        await tracer_writeSendLog(config, result);
+        return result;
+    }
+    if (/^PreToolUse$/i.test(event)) {
+        let updatedState;
+        let turnStateFound = false;
+        const startMs = Date.now();
+        await atomicUpdateState(config.turnStateFilePath, (stateFile)=>{
+            const storedState = stateFile.sessions[sessionId];
+            turnStateFound = Boolean(storedState);
+            const state = mergeTurnState(input, sessionId, storedState);
+            const pending = pendingToolUseFromInput(input, startMs);
+            state.pendingToolUses = {
+                ...state.pendingToolUses ?? {},
+                [pending.tool_call_id]: pending
+            };
+            state.updatedAt = new Date().toISOString();
+            updatedState = state;
+            return {
+                version: 1,
+                sessions: {
+                    ...stateFile.sessions,
+                    [sessionId]: state
+                }
+            };
+        });
+        const result = {
+            status: 'recorded',
+            reason: 'tool_use_started',
+            source: {
+                tool: 'trae',
+                sessionId,
+                turnId: updatedState?.turnId
+            },
+            hook_event_name: event,
+            turn_state_found: turnStateFound,
+            turn_state_file: config.turnStateFilePath,
+            tool_name: toolNameFromInput(input),
+            message_count: updatedState?.messages?.length ?? 0
+        };
+        await tracer_writeSendLog(config, result);
+        return result;
+    }
+    if (/^PostToolUse$/i.test(event)) {
+        let updatedState;
+        let turnStateFound = false;
+        let outputFound = false;
+        await atomicUpdateState(config.turnStateFilePath, (stateFile)=>{
+            const storedState = stateFile.sessions[sessionId];
+            turnStateFound = Boolean(storedState);
+            const state = mergeTurnState(input, sessionId, storedState);
+            const id = toolCallIdFromInput(input, toolNameFromInput(input));
+            outputFound = void 0 !== toolOutputFromInput(input);
+            state.messages = appendToolMessages(state.messages ?? [], input, state.pendingToolUses?.[id]);
+            state.usage = mergeUsage(state.usage, usageFromRecord(input));
+            if (state.pendingToolUses?.[id]) {
+                state.pendingToolUses = {
+                    ...state.pendingToolUses
+                };
+                delete state.pendingToolUses[id];
+            }
+            state.updatedAt = new Date().toISOString();
+            updatedState = state;
+            return {
+                version: 1,
+                sessions: {
+                    ...stateFile.sessions,
+                    [sessionId]: state
+                }
+            };
+        });
+        const result = {
+            status: 'recorded',
+            reason: 'tool_use_recorded',
+            source: {
+                tool: 'trae',
+                sessionId,
+                turnId: updatedState?.turnId
+            },
+            hook_event_name: event,
+            turn_state_found: turnStateFound,
+            turn_state_file: config.turnStateFilePath,
+            tool_name: toolNameFromInput(input),
+            tool_output_found: outputFound,
+            hook_input_keys: Object.keys(input).sort(),
+            message_count: updatedState?.messages?.length ?? 0
+        };
+        await tracer_writeSendLog(config, result);
+        return result;
+    }
+    if (event && !/^Stop$/i.test(event)) {
+        const result = {
+            status: 'skipped',
+            reason: 'unsupported_hook_event',
+            source: {
+                tool: 'trae',
+                sessionId
+            },
+            hook_event_name: event
+        };
+        await tracer_writeSendLog(config, result);
+        return result;
+    }
+    const storedState = readTurnStartState(config.turnStateFilePath, sessionId);
+    const turnState = mergeTurnState(input, sessionId, storedState);
+    const turnId = turnState.turnId ?? internalTurnId(sessionId, turnState.createdAt);
+    const assistantMessage = assistantMessageFromStop(input);
+    const initialMessages = [
+        ...turnState.messages ?? [],
+        assistantMessage
+    ];
+    const usage = usageWithFallback(initialMessages, mergeUsage(turnState.usage, usageFromRecord(input), usageFromRecord(assistantMessage)));
+    const messages = [
+        ...turnState.messages ?? [],
+        messageWithUsage(assistantMessage, usage)
+    ];
+    if (!hasAssistant(messages)) {
+        const result = {
+            status: 'skipped',
+            reason: 'assistant_message_not_found',
+            source: {
+                tool: 'trae',
+                sessionId,
+                turnId
+            },
+            hook_event_name: event || 'Stop',
+            turn_state_found: Boolean(storedState)
+        };
+        await tracer_writeSendLog(config, result);
+        return result;
+    }
+    const snapshot = {
+        tool: 'trae',
+        session_id: sessionId,
+        turn_id: turnId,
+        cwd: turnState.cwd,
+        plugin_version: process.env.TRAE_TLS_PLUGIN_VERSION ?? '0.0.1',
+        agent_id: turnState.agentId ?? agentIdFromInput(input),
+        agent_name: turnState.agentName ?? agentNameFromInput(input),
+        user_name: turnState.userName ?? userNameFromInput(input),
+        model: turnState.model ?? modelFromInput(input),
+        hook_event_name: event || 'Stop',
+        capture_content: config.captureContent,
+        usage,
+        messages,
+        attributes: {
+            ...localIdentityMetadata()
+        }
+    };
+    const result = await runTracePipeline(snapshot, traeAdapter, {
+        dataRoot: config.dataRoot,
+        sourceName: 'trae',
+        env: pipelineEnv(config),
+        otel: {
+            serviceName: config.serviceName,
+            resourceAttributes: {
+                'service.instance.id': config.serviceInstanceId,
+                'tls.app.type': 'trae'
+            },
+            scopeName: 'tls-observer-trae'
+        },
+        tlsOptions: {}
+    });
+    await tracer_writeSendLog(config, {
+        status: 'sent',
+        reason: 'stop_hook_trace_sent',
+        source: {
+            tool: 'trae',
+            sessionId,
+            turnId
+        },
+        hook_event_name: event || 'Stop',
+        turn_state_found: Boolean(storedState),
+        message_count: messages.length,
+        usage,
+        pipeline_result: result
+    });
+    await atomicUpdateState(config.turnStateFilePath, (state)=>{
+        const latestSession = getSessionState(state, sessionId);
+        return {
+            version: 1,
+            sessions: {
+                ...state.sessions,
+                [sessionId]: clearedActiveSession(latestSession, {
+                    cwd: turnState.cwd,
+                    agentId: turnState.agentId,
+                    agentName: turnState.agentName,
+                    userName: turnState.userName,
+                    model: turnState.model
+                })
+            }
+        };
+    });
+    return result;
+}
+async function main() {
+    try {
+        const input = await readStdinJson();
+        const config = loadConfig();
+        await __rspack_external_node_fs_promises_153e37e0.mkdir(config.dataRoot, {
+            recursive: true
+        });
+        await traceTraeSession({
+            input,
+            config
+        });
+    } finally{
+        await closeTraceLogProducers();
+    }
+}
+main().catch(async (error)=>{
+    try {
+        const config = loadConfig();
+        await tracer_writeSendLog(config, {
+            status: 'failed',
+            reason: 'hook_error',
+            message: error instanceof Error ? error.stack || error.message : String(error)
+        });
+    } catch  {}
+    process.exit(0);
+});
+export { contextFsEnvStatus, loadConfig, loadEnvFile, readContextFsTurn, sessionIdFromInput, traceTraeSession, turnIdFromInput };