@volcengine/tls-observer-opencode 0.0.3

package/dist/index.js

@@ -0,0 +1,1997 @@
+import { homedir, hostname, networkInterfaces, userInfo as external_node_os_userInfo } from "node:os";
+import { createHash as external_node_crypto_createHash } from "node:crypto";
+import { tlsOpenapi } from "@volcengine/openapi";
+import "node:url";
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external_node_fs_promises_153e37e0 from "node:fs/promises";
+var package_namespaceObject = {
+    rE: "0.0.3"
+};
+function firstEnv(...names) {
+    for (const name of names){
+        const value = process.env[name];
+        if ('string' == typeof value && '' !== value.trim()) return value.trim();
+    }
+}
+function envDisabled(name) {
+    return /^(0|false|no|n|off)$/i.test(process.env[name] ?? '');
+}
+function 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 envPositiveInteger(name, fallback) {
+    const value = Number.parseInt(process.env[name] ?? '', 10);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function parseEnvValue(raw) {
+    const value = raw.trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1).replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\'/g, "'");
+    return value;
+}
+function defaultEnvFile() {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.config', 'opencode', 'tls-observer-opencode.env');
+}
+function defaultDataRoot() {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.config', 'opencode', 'plugins', 'data', 'tls-observer-opencode');
+}
+function loadEnvFile(filePath) {
+    const target = filePath || firstEnv('OPENCODE_TLS_ENV_FILE') || defaultEnvFile();
+    let text;
+    try {
+        text = __rspack_external_node_fs_5ea92f0c.readFileSync(target, 'utf8');
+    } catch  {
+        return false;
+    }
+    for (const rawLine of text.split(/\r?\n/)){
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) continue;
+        const normalized = line.startsWith('export ') ? line.slice(7).trim() : line;
+        const match = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+        if (!match) continue;
+        const [, key, rawValue] = match;
+        process.env[key] ??= parseEnvValue(rawValue);
+    }
+    return true;
+}
+function mirroredTlsEnv() {
+    return {
+        ...process.env,
+        TRACE_TLS_ENDPOINT: firstEnv('OPENCODE_TLS_ENDPOINT', 'TRACE_TLS_ENDPOINT', 'TLS_ENDPOINT'),
+        TRACE_TLS_REGION: firstEnv('OPENCODE_TLS_REGION', 'TRACE_TLS_REGION', 'TLS_REGION'),
+        TRACE_TLS_TRACE_TOPIC_ID: firstEnv('OPENCODE_TLS_TRACE_TOPIC_ID', 'OPENCODE_TLS_TOPIC_ID', 'TRACE_TLS_TRACE_TOPIC_ID', 'TLS_TRACE_TOPIC_ID'),
+        TRACE_TLS_API_KEY: firstEnv('OPENCODE_TLS_API_KEY', 'TRACE_TLS_API_KEY', 'TLS_API_KEY'),
+        TRACE_TLS_AK: firstEnv('OPENCODE_TLS_AK', 'TRACE_TLS_AK', 'TLS_AK'),
+        TRACE_TLS_SK: firstEnv('OPENCODE_TLS_SK', 'TRACE_TLS_SK', 'TLS_SK'),
+        TRACE_TLS_EXPORT_TIMEOUT_MS: firstEnv('OPENCODE_TLS_EXPORT_TIMEOUT_MS', 'TRACE_TLS_EXPORT_TIMEOUT_MS'),
+        TLS_ENDPOINT: firstEnv('OPENCODE_TLS_ENDPOINT', 'TLS_ENDPOINT'),
+        TLS_REGION: firstEnv('OPENCODE_TLS_REGION', 'TLS_REGION'),
+        TLS_TRACE_TOPIC_ID: firstEnv('OPENCODE_TLS_TRACE_TOPIC_ID', 'OPENCODE_TLS_TOPIC_ID', 'TLS_TRACE_TOPIC_ID'),
+        TLS_API_KEY: firstEnv('OPENCODE_TLS_API_KEY', 'TLS_API_KEY'),
+        TLS_AK: firstEnv('OPENCODE_TLS_AK', 'TLS_AK'),
+        TLS_SK: firstEnv('OPENCODE_TLS_SK', 'TLS_SK'),
+        TLS_AUTH_MODE: firstEnv('OPENCODE_TLS_AUTH_MODE', 'TLS_AUTH_MODE')
+    };
+}
+function validateTlsConfig(env) {
+    const missing = [];
+    if (!env.TRACE_TLS_ENDPOINT) missing.push('OPENCODE_TLS_ENDPOINT, TRACE_TLS_ENDPOINT, or TLS_ENDPOINT');
+    if (!env.TRACE_TLS_REGION) missing.push('OPENCODE_TLS_REGION, TRACE_TLS_REGION, or TLS_REGION');
+    if (!env.TRACE_TLS_TRACE_TOPIC_ID) missing.push('OPENCODE_TLS_TRACE_TOPIC_ID, TRACE_TLS_TRACE_TOPIC_ID, or TLS_TRACE_TOPIC_ID');
+    const apiKey = env.TRACE_TLS_API_KEY;
+    const ak = env.TRACE_TLS_AK;
+    const sk = env.TRACE_TLS_SK;
+    if (!apiKey && (!ak || !sk)) missing.push('OPENCODE_TLS_API_KEY or OPENCODE_TLS_AK/OPENCODE_TLS_SK');
+    if (missing.length > 0) throw new Error(`Missing required OpenCode TLS config: ${missing.join(', ')}`);
+    if (apiKey && (ak || sk)) throw new Error('OpenCode TLS config must use API Key or AK/SK, not both');
+}
+function loadConfig() {
+    loadEnvFile();
+    const serviceName = firstEnv('OPENCODE_OTEL_SERVICE_NAME') || 'opencode-plugin';
+    const enabled = !envDisabled('OPENCODE_TLS_EXPORT');
+    const env = mirroredTlsEnv();
+    if (enabled) validateTlsConfig(env);
+    return {
+        enabled,
+        dataRoot: firstEnv('OPENCODE_TLS_DATA_ROOT') || defaultDataRoot(),
+        captureContent: !envDisabled('OPENCODE_TLS_CAPTURE_CONTENT'),
+        debugArtifacts: envFlag('OPENCODE_TLS_DEBUG_ARTIFACTS', false),
+        serviceName,
+        serviceInstanceId: `${serviceName}@${hostname()}:${process.pid}`,
+        pluginVersion: package_namespaceObject.rE,
+        exportTimeoutMs: envPositiveInteger('OPENCODE_TLS_EXPORT_TIMEOUT_MS', 20000),
+        env
+    };
+}
+function stableHexId(seed, length) {
+    const normalized = String(seed ?? '');
+    const digest = external_node_crypto_createHash('sha256').update(normalized).digest('hex').slice(0, length);
+    return digest === '0'.repeat(length) ? '1'.padStart(length, '0') : digest;
+}
+function model_traceIdFromSeed(seed) {
+    return stableHexId(seed, 32);
+}
+function spanIdFromSeed(...parts) {
+    return stableHexId(parts.map((part)=>String(part ?? '')).join(':'), 16);
+}
+function model_toEpochMs(value, fallback = Date.now()) {
+    if (value instanceof Date) {
+        const time = value.getTime();
+        return Number.isFinite(time) ? time : fallback;
+    }
+    if ('number' == typeof value && Number.isFinite(value)) return value;
+    if ('string' == typeof value && '' !== value.trim()) {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed)) return parsed;
+    }
+    return fallback;
+}
+function isRecord(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function validateSpan(span, path) {
+    const errors = [];
+    if (!isRecord(span)) return [
+        `${path} must be an object`
+    ];
+    if ('string' != typeof span.name || '' === span.name.trim()) errors.push(`${path}.name is required`);
+    if (void 0 === span.startedAt && void 0 === span.start_time_unix_ms) errors.push(`${path}.startedAt is required`);
+    if (void 0 === span.endedAt && void 0 === span.end_time_unix_ms) errors.push(`${path}.endedAt is required`);
+    if (void 0 !== span.attributes && !isRecord(span.attributes)) errors.push(`${path}.attributes must be an object`);
+    return errors;
+}
+function validateCanonicalTrace(trace) {
+    const errors = [];
+    const warnings = [];
+    if (!isRecord(trace)) return {
+        valid: false,
+        errors: [
+            'trace must be an object'
+        ],
+        warnings
+    };
+    if (isRecord(trace.source)) {
+        const source = trace.source;
+        if ('string' != typeof source.tool || '' === source.tool.trim()) errors.push('source.tool is required');
+        if ('string' != typeof source.sessionId || '' === source.sessionId.trim()) errors.push('source.sessionId is required');
+    } else errors.push('source is required');
+    errors.push(...validateSpan(trace.root, 'root'));
+    if (Array.isArray(trace.spans)) for (const [index, span] of trace.spans.entries())errors.push(...validateSpan(span, `spans[${index}]`));
+    else errors.push('spans must be an array');
+    if (void 0 !== trace.messages && !Array.isArray(trace.messages)) errors.push('messages must be an array');
+    if (void 0 !== trace.diagnostics) if (isRecord(trace.diagnostics)) {
+        if (void 0 !== trace.diagnostics.warnings && !Array.isArray(trace.diagnostics.warnings)) warnings.push('diagnostics.warnings should be an array');
+    } else warnings.push('diagnostics should be an object');
+    return {
+        valid: 0 === errors.length,
+        errors,
+        warnings
+    };
+}
+function assertCanonicalTrace(trace) {
+    const result = validateCanonicalTrace(trace);
+    if (!result.valid) {
+        const error = new Error(`Invalid canonical trace: ${result.errors.join('; ')}`);
+        error.name = 'CanonicalTraceValidationError';
+        error.validation = result;
+        throw error;
+    }
+    return trace;
+}
+const DEFAULT_MAX_ATTR_LENGTH = 65536;
+const MAX_ATTR_LENGTH_ENV_KEYS = [
+    'TRACE_OTLP_ATTRIBUTE_VALUE_MAX_CHARS',
+    'CODEX_OTLP_ATTRIBUTE_VALUE_MAX_CHARS'
+];
+function resolveMaxAttrLength(env = process.env) {
+    for (const key of MAX_ATTR_LENGTH_ENV_KEYS){
+        const raw = env[key];
+        if (null == raw || '' === raw.trim()) continue;
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed) && parsed >= 0) return Math.trunc(parsed);
+    }
+    return DEFAULT_MAX_ATTR_LENGTH;
+}
+function truncateTextForAttr(value) {
+    return String(value ?? '').slice(0, resolveMaxAttrLength());
+}
+function safeStringify(value) {
+    const seen = new WeakSet();
+    return JSON.stringify(value, (_key, item)=>{
+        if (item && 'object' == typeof item) {
+            if (seen.has(item)) return '[Circular]';
+            seen.add(item);
+        }
+        return item;
+    });
+}
+function maskToken(value) {
+    if (value.length <= 8) return '***';
+    return `${value.slice(0, 3)}***${value.slice(-2)}`;
+}
+function redactSensitiveText(text) {
+    return String(text ?? '').replace(/\bAK[0-9A-Za-z]{16,}\b/g, maskToken).replace(/\b(Bearer\s+)([A-Za-z0-9._-]{8,})/gi, (_match, prefix, token)=>`${prefix}${maskToken(token)}`).replace(/\b(token|secret|password|passwd|api[_-]?key|access[_-]?key|sk)\s*[:=]\s*([^,\s"']{8,})/gi, (_match, key, secret)=>`${key}=***${String(secret).slice(-2)}`);
+}
+function attributes_serializeForAttr(value) {
+    const serialized = 'string' == typeof value ? value : safeStringify(value);
+    return redactSensitiveText(truncateTextForAttr(serialized ?? String(value)));
+}
+function spanKindName(span) {
+    const kind = String(span.span_kind ?? span.kind ?? '').toUpperCase();
+    if ('SERVER' === kind) return 'server';
+    if ('CLIENT' === kind) return 'client';
+    return 'internal';
+}
+function unixMsToUs(value) {
+    return String(1000 * Math.trunc(model_toEpochMs(value)));
+}
+function span_utils_hasError(span) {
+    const statusObjectCode = null != span.status && 'object' == typeof span.status ? span.status.code : void 0;
+    const statusCode = statusObjectCode ?? span.status_code ?? span.statusCode ?? span.status;
+    if (2 === statusCode || 'ERROR' === String(statusCode).toUpperCase()) return true;
+    return Object.entries(span.attributes ?? {}).some(([key, value])=>{
+        if (true === value && ('error' === key || key.endsWith('.error'))) return true;
+        if ('tool.error' === key && 'string' == typeof value && '' !== value.trim()) return true;
+        return false;
+    });
+}
+function spanDurationMs(span) {
+    if ('number' == typeof span.duration_ms && Number.isFinite(span.duration_ms)) return Math.max(0, Math.trunc(span.duration_ms));
+    const start = model_toEpochMs(span.start_time_unix_ms ?? span.startedAt);
+    const end = model_toEpochMs(span.end_time_unix_ms ?? span.endedAt, start);
+    return Math.max(0, Math.trunc(end - start));
+}
+const SCHEMA_FIELD_ORDER = [
+    'span.name',
+    'span.kind',
+    'tls.app.type',
+    'session.id',
+    'span.status.code',
+    'start_time_unix_us',
+    'end_time_unix_us',
+    'span.duration_us',
+    'service.name',
+    'service.instance.id',
+    'host.name',
+    'client.address',
+    'observed_time_unix_ms',
+    'telemetry.sdk.name',
+    'telemetry.sdk.language',
+    'telemetry.sdk.version',
+    'otel.scope.name',
+    'otel.scope.version',
+    'event.name',
+    'user.role',
+    'gen_ai.operation.name',
+    'gen_ai.provider.name',
+    'gen_ai.request.model',
+    'gen_ai.response.model',
+    'gen_ai.request.duration_ms',
+    'gen_ai.input.messages',
+    'gen_ai.output.messages',
+    'gen_ai.usage.input_tokens',
+    'gen_ai.usage.output_tokens',
+    'gen_ai.usage.reasoning.output_tokens',
+    'gen_ai.usage.cache_read.input_tokens',
+    'gen_ai.usage.cache_creation.input_tokens',
+    'gen_ai.usage.total_tokens',
+    'gen_ai.tool.name',
+    'gen_ai.tool.call.id',
+    'gen_ai.tool.call.arguments',
+    'gen_ai.tool.call.result',
+    'tool.error',
+    'error.type',
+    'error.message'
+];
+function normalizeOptions(options) {
+    if ('number' == typeof options) return {
+        observedTimeUnixMs: options,
+        version: '-'
+    };
+    return {
+        observedTimeUnixMs: options.observedTimeUnixMs ?? Date.now(),
+        version: options.version?.trim() || '-'
+    };
+}
+function hasMessages(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function stableFieldValue(value) {
+    if (null == value) return '';
+    if ('string' == typeof value) return attributes_serializeForAttr(value);
+    if ('number' == typeof value || 'boolean' == typeof value) return value;
+    return attributes_serializeForAttr(value);
+}
+function inferUserRole(span) {
+    const inputMessage = hasMessages(span.input) ? span.input.messages?.find((message)=>'string' == typeof message?.role) : void 0;
+    const role = inputMessage?.role;
+    if ('string' == typeof role && [
+        'assistant',
+        'system',
+        'tool',
+        'user'
+    ].includes(role)) return role;
+    return '';
+}
+function inferErrorMessage(span) {
+    const output = span.output;
+    if (null == output) return '';
+    if ('string' == typeof output) return output;
+    if ('object' == typeof output && 'error' in output && 'string' == typeof output.error) return output.error;
+    if ('object' == typeof output && 'error' in output && null != output.error) return attributes_serializeForAttr(output.error);
+    return '';
+}
+function schemaSourceAttribute(attributes, dotted, legacy) {
+    return attributes[dotted] ?? attributes[legacy] ?? '';
+}
+function normalizedSpanName(span) {
+    if ('model' === span.type) return 'llm.request';
+    if ('tool' === span.type) return 'tool.call';
+    if ('message' === span.type) return 'agent.turn';
+    return span.name ?? '';
+}
+function legacyToolErrorMessage(value) {
+    return 'string' == typeof value ? value : '';
+}
+function buildSchemaAlignedRecord(trace, span, options = {}) {
+    const { observedTimeUnixMs, version } = normalizeOptions(options);
+    const attributes = span.attributes ?? {};
+    const resource = trace.resource ?? {};
+    const isError = span_utils_hasError(span);
+    const isTool = 'tool' === span.type;
+    const isModel = 'model' === span.type;
+    const isMessage = 'message' === span.type;
+    const inputMessages = hasMessages(span.input) ? span.input.messages ?? attributes['gen_ai.input.messages'] : attributes['gen_ai.input.messages'];
+    const outputMessages = hasMessages(span.output) ? span.output.messages ?? attributes['gen_ai.output.messages'] : attributes['gen_ai.output.messages'];
+    const explicitErrorMessage = attributes['error.message'];
+    const spanName = normalizedSpanName(span);
+    const toolErrorMessage = isTool ? 'string' == typeof explicitErrorMessage && explicitErrorMessage || legacyToolErrorMessage(attributes['tool.error']) || inferErrorMessage(span) : '';
+    const record = {
+        'span.name': spanName,
+        'span.kind': spanKindName(span),
+        'tls.app.type': attributes['tls.app.type'] ?? 'codex',
+        'session.id': schemaSourceAttribute(attributes, 'session.id', 'codex.session_id'),
+        'span.status.code': isError ? 'ERROR' : 'UNSET',
+        start_time_unix_us: unixMsToUs(span.start_time_unix_ms ?? span.startedAt),
+        end_time_unix_us: unixMsToUs(span.end_time_unix_ms ?? span.endedAt),
+        'span.duration_us': String(1000 * spanDurationMs(span)),
+        'service.name': resource['service.name'] ?? "codex-transcript-stop-hook",
+        'service.instance.id': resource['service.instance.id'] ?? '',
+        'host.name': resource['host.name'] ?? '',
+        'client.address': '',
+        observed_time_unix_ms: observedTimeUnixMs,
+        'telemetry.sdk.name': resource['telemetry.sdk.name'] ?? "codex-transcript-stop-hook",
+        'telemetry.sdk.language': resource['telemetry.sdk.language'] ?? 'nodejs',
+        'telemetry.sdk.version': resource['telemetry.sdk.version'] ?? version,
+        'otel.scope.name': trace.scope?.name ?? "codex-transcript-stop-hook",
+        'otel.scope.version': trace.scope?.version ?? version,
+        'event.name': spanName,
+        'user.role': inferUserRole(span),
+        'gen_ai.operation.name': attributes['gen_ai.operation.name'] ?? (isModel ? 'chat' : isMessage ? 'invoke_agent' : ''),
+        'gen_ai.provider.name': attributes['gen_ai.provider.name'] ?? '',
+        'gen_ai.request.model': attributes['gen_ai.request.model'] ?? '',
+        'gen_ai.response.model': attributes['gen_ai.response.model'] ?? attributes['gen_ai.request.model'] ?? '',
+        'gen_ai.request.duration_ms': isModel ? spanDurationMs(span) : attributes['request.duration_ms'] ?? '',
+        'gen_ai.input.messages': inputMessages ?? '',
+        'gen_ai.output.messages': outputMessages ?? '',
+        'gen_ai.usage.input_tokens': attributes['gen_ai.usage.input_tokens'] ?? '',
+        'gen_ai.usage.output_tokens': attributes['gen_ai.usage.output_tokens'] ?? '',
+        'gen_ai.usage.reasoning.output_tokens': attributes['gen_ai.usage.reasoning.output_tokens'] ?? '',
+        'gen_ai.usage.cache_read.input_tokens': attributes['gen_ai.usage.cache_read.input_tokens'] ?? '',
+        'gen_ai.usage.cache_creation.input_tokens': attributes['gen_ai.usage.cache_creation.input_tokens'] ?? '',
+        'gen_ai.usage.total_tokens': attributes['gen_ai.usage.total_tokens'] ?? '',
+        'gen_ai.tool.name': isTool ? attributes['gen_ai.tool.name'] ?? attributes['tool.name'] ?? '' : '',
+        'gen_ai.tool.call.id': isTool ? attributes['gen_ai.tool.call.id'] ?? attributes['codex.tool_call_id'] ?? '' : '',
+        'gen_ai.tool.call.arguments': isTool ? span.input ?? '' : '',
+        'gen_ai.tool.call.result': isTool ? span.output ?? '' : '',
+        'tool.error': isTool ? isError : '',
+        'error.type': isError ? attributes['codex.tool_status'] ?? 'error' : '',
+        'error.message': isError ? toolErrorMessage : ''
+    };
+    const aligned = {};
+    for (const key of SCHEMA_FIELD_ORDER)aligned[key] = stableFieldValue(record[key]);
+    return aligned;
+}
+function buildSchemaAlignedRecords(trace, options = {}) {
+    if (!trace || !Array.isArray(trace.spans)) return [];
+    return trace.spans.map((span)=>buildSchemaAlignedRecord(trace, span, options));
+}
+new Set([
+    'trace.id',
+    'trace.state',
+    'span.id',
+    'parent.span.id',
+    'span.kind',
+    'span.name',
+    'span.status.code',
+    'span.status.message',
+    'span.events',
+    'span.links',
+    'event.type',
+    'event.name',
+    'service.name',
+    'service.instance.id',
+    'host.name',
+    'client.address',
+    'observed_time_unix_ms',
+    'telemetry.sdk.name',
+    'telemetry.sdk.language',
+    'telemetry.sdk.version',
+    'otel.scope.name',
+    'otel.scope.version',
+    'start_time_unix_us',
+    'end_time_unix_us',
+    'span.duration_us'
+]);
+new Set([
+    'session.id',
+    'app.thread.id',
+    'gen_ai.conversation.id',
+    'gen_ai.agent.id',
+    'app.run.id',
+    'app.turn.id',
+    'user.id',
+    'codex.input',
+    'codex.output',
+    'span_type',
+    'codex_span_type',
+    'codex_session_id',
+    'codex_thread_id',
+    'codex_conversation_id',
+    'codex_parent_conversation_id',
+    'codex_agent_id',
+    'codex_turn_id',
+    'codex_turn_index',
+    'codex_originator',
+    'codex_cli_version',
+    'codex_cwd',
+    "codex_transcript_path",
+    'codex_permission_mode',
+    'codex_agent_scope',
+    'codex_runtime_tags',
+    'codex_decision_tool_name',
+    'codex_decision_tool_call_id',
+    'codex_tool_call_id',
+    'codex_tool_status',
+    'codex_tool_exit_code',
+    'codex.system_tag_runtime',
+    'gen_ai.usage.input',
+    'gen_ai.usage.output',
+    'gen_ai.usage.totalTokens',
+    'gen_ai.usage.cacheRead',
+    'gen_ai.usage.reasoningOutput'
+]);
+function sourceAttributes(source) {
+    return {
+        'source.tool': source.tool,
+        'session.id': source.sessionId,
+        'app.turn.id': source.turnId,
+        'app.thread.id': source.threadId,
+        'gen_ai.conversation.id': source.conversationId,
+        'process.command.cwd': source.cwd,
+        'gen_ai.request.model': source.model,
+        ...source.attributes ?? {}
+    };
+}
+function resourceAttributes(trace, options) {
+    const source = trace.source ?? {};
+    return {
+        'service.name': options.serviceName ?? `${source.tool ?? 'agent'}-trace-hook`,
+        'service.instance.id': source.sessionId ?? '',
+        'host.name': hostname(),
+        'telemetry.sdk.name': 'agent-trace-reporter',
+        'telemetry.sdk.language': 'nodejs',
+        'telemetry.sdk.version': options.sdkVersion ?? '0.1.0',
+        ...options.resourceAttributes ?? {}
+    };
+}
+function canonicalSpanToLegacy(span, traceId, parentId, commonAttributes, index) {
+    const spanId = span.id ?? span.span_id ?? spanIdFromSeed(traceId, span.name, index);
+    const startedAt = span.start_time_unix_ms ?? span.startedAt;
+    const endedAt = span.end_time_unix_ms ?? span.endedAt;
+    return {
+        trace_id: traceId,
+        span_id: spanId,
+        parent_span_id: span.parentId ?? span.parent_span_id ?? parentId,
+        name: span.name,
+        type: span.type ?? 'internal',
+        span_kind: String(span.kind ?? 'internal').toUpperCase(),
+        start_time_unix_ms: model_toEpochMs(startedAt),
+        end_time_unix_ms: model_toEpochMs(endedAt, model_toEpochMs(startedAt)),
+        duration_ms: Math.max(0, model_toEpochMs(endedAt, model_toEpochMs(startedAt)) - model_toEpochMs(startedAt)),
+        status_code: 'error' === span.status ? 'ERROR' : 'UNSET',
+        input: span.input,
+        output: span.output,
+        attributes: {
+            ...commonAttributes,
+            ...span.attributes ?? {}
+        }
+    };
+}
+function canonicalTraceToOtelTrace(trace, options = {}) {
+    const seed = [
+        trace.source?.tool,
+        trace.source?.sessionId,
+        trace.source?.turnId,
+        trace.root?.name,
+        trace.root?.startedAt
+    ].join(':');
+    const traceId = trace.traceId ?? model_traceIdFromSeed(seed);
+    const commonAttributes = sourceAttributes(trace.source ?? {});
+    const root = canonicalSpanToLegacy(trace.root ?? {
+        name: 'root'
+    }, traceId, '', commonAttributes, 'root');
+    root.span_id = trace.root?.id ?? trace.spanId ?? spanIdFromSeed(traceId, 'root');
+    root.parent_span_id = '';
+    return {
+        traceId,
+        resource: resourceAttributes(trace, options),
+        scope: {
+            name: options.scopeName ?? 'agent-trace-reporter',
+            version: options.scopeVersion ?? '0.1.0'
+        },
+        spans: [
+            root,
+            ...(trace.spans ?? []).map((span, index)=>canonicalSpanToLegacy(span, traceId, root.span_id ?? '', commonAttributes, index))
+        ]
+    };
+}
+const TLS_ANONYMOUS_IDENTITY_HEADER = 'x-tls-anonymous-identity';
+const DEFAULT_FILE_NAME = 'agent-trace';
+const NO_RETRY_STATUS_CODES = [
+    400,
+    401,
+    403,
+    404
+];
+const producerEntries = new Map();
+function firstExternalIpv4() {
+    for (const items of Object.values(networkInterfaces()))for (const item of items ?? [])if ('IPv4' === item.family && !item.internal && item.address) return item.address;
+    return '127.0.0.1';
+}
+function normalizeProducerEndpoint(endpoint) {
+    const raw = endpoint.trim();
+    if (!raw) return raw;
+    try {
+        const url = new URL(/^https?:\/\//.test(raw) ? raw : `https://${raw}`);
+        return url.host || raw;
+    } catch  {
+        return raw.replace(/^https?:\/\//, '').replace(/\/.*$/, '');
+    }
+}
+function producerKey(config) {
+    return JSON.stringify({
+        endpoint: normalizeProducerEndpoint(config.endpoint),
+        region: config.region,
+        apiKey: config.apiKey || '',
+        ak: config.ak || '',
+        sk: config.sk || ''
+    });
+}
+function createProducer(config) {
+    const producerConfig = tlsOpenapi.Producer.getDefaultProducerConfig();
+    producerConfig.Endpoint = normalizeProducerEndpoint(config.endpoint);
+    producerConfig.Region = config.region;
+    producerConfig.NoRetryStatusCodeList = NO_RETRY_STATUS_CODES;
+    if (config.apiKey) {
+        producerConfig.AccessKeyID = '';
+        producerConfig.AccessKeySecret = '';
+        producerConfig.Headers = {
+            [TLS_ANONYMOUS_IDENTITY_HEADER]: config.apiKey
+        };
+    } else {
+        producerConfig.AccessKeyID = config.ak || '';
+        producerConfig.AccessKeySecret = config.sk || '';
+    }
+    const producer = new tlsOpenapi.Producer(producerConfig);
+    producer.Start();
+    return {
+        producer,
+        source: firstExternalIpv4(),
+        timeoutMs: config.timeoutMs
+    };
+}
+function timeoutError(label, timeoutMs) {
+    return new Error(`${label} timed out after ${timeoutMs}ms`);
+}
+function withTimeout(promise, timeoutMs, label) {
+    const effectiveTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.trunc(timeoutMs) : 20000;
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>reject(timeoutError(label, effectiveTimeoutMs)), effectiveTimeoutMs);
+        promise.then((value)=>{
+            clearTimeout(timer);
+            resolve(value);
+        }, (error)=>{
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function getProducer(config) {
+    const key = producerKey(config);
+    const existing = producerEntries.get(key);
+    if (existing) return existing;
+    const created = createProducer(config);
+    producerEntries.set(key, created);
+    return created;
+}
+function recordContents(record) {
+    return Object.entries(record).map(([Key, Value])=>({
+            Key,
+            Value
+        }));
+}
+async function sendTlsLogRecords(config, records, fileName = DEFAULT_FILE_NAME) {
+    if (0 === records.length) return;
+    const testMode = process.env.TRACE_TLS_TEST_PRODUCER_MODE;
+    const captureFile = process.env.TRACE_TLS_TEST_PRODUCER_CAPTURE_FILE;
+    if (testMode || captureFile) {
+        if (captureFile) {
+            await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(captureFile), {
+                recursive: true
+            });
+            await __rspack_external_node_fs_promises_153e37e0.appendFile(captureFile, `${JSON.stringify({
+                topic_id: config.traceTopicId,
+                endpoint: normalizeProducerEndpoint(config.endpoint),
+                region: config.region,
+                file_name: fileName,
+                records
+            })}\n`, 'utf8');
+        }
+        if ('fail' === testMode) throw new Error('TRACE_TLS_TEST_PRODUCER_MODE=fail');
+        return;
+    }
+    const entry = getProducer(config);
+    const logGroup = {
+        Logs: records.map((record)=>({
+                Time: Date.now(),
+                Contents: recordContents(record)
+            })),
+        Source: entry.source,
+        LogTags: [],
+        FileName: fileName
+    };
+    await withTimeout(new Promise((resolve, reject)=>{
+        let settled = false;
+        const settle = (fn, value)=>{
+            if (settled) return;
+            settled = true;
+            fn(value);
+        };
+        const resolveUnknown = resolve;
+        const sendPromise = entry.producer.SendLogs('', config.traceTopicId, entry.source, fileName, logGroup, {
+            Success: ()=>settle(resolveUnknown),
+            Fail: (result)=>{
+                const attempts = result?.Attempts ?? [];
+                const lastAttempt = attempts[attempts.length - 1] ?? {};
+                settle(reject, new Error(`TLS SendLogs failed topicId=${config.traceTopicId} requestId=${String(lastAttempt.RequestId ?? '')} errorCode=${String(lastAttempt.ErrorCode ?? '')} errorMessage=${String(lastAttempt.ErrorMessage ?? '')}`));
+            }
+        });
+        Promise.resolve(sendPromise).catch((error)=>settle(reject, error));
+    }), config.timeoutMs, 'TLS SendLogs');
+}
+function config_firstEnv(env, ...names) {
+    for (const name of names){
+        const value = env[name];
+        if ('string' == typeof value && '' !== value.trim()) return value.trim();
+    }
+}
+function tlsEndpointFromLegacyOtelEndpoint(value) {
+    if (!value) return;
+    try {
+        const url = new URL(/^https?:\/\//i.test(value) ? value : `https://${value}`);
+        return url.hostname || void 0;
+    } catch  {
+        return value.trim().replace(/^https?:\/\//i, '').replace(/\/.*$/, '').replace(/:\d+$/, '') || void 0;
+    }
+}
+function config_resolveTlsConfig(env) {
+    const disabled = /^(0|false|no)$/i.test(config_firstEnv(env, 'TRACE_TLS_EXPORT', 'CODEX_TLS_EXPORT') ?? '');
+    if (disabled) return {
+        enabled: false,
+        reason: 'disabled'
+    };
+    const endpoint = config_firstEnv(env, 'TRACE_TLS_ENDPOINT', 'CODEX_TLS_ENDPOINT') || tlsEndpointFromLegacyOtelEndpoint(config_firstEnv(env, 'TRACE_TLS_OTEL_ENDPOINT', 'CODEX_TLS_OTEL_ENDPOINT', 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'));
+    const region = config_firstEnv(env, 'TRACE_TLS_REGION', 'CODEX_TLS_REGION', 'TLS_REGION');
+    const traceTopicId = config_firstEnv(env, 'TRACE_TLS_TRACE_TOPIC_ID', 'TRACE_TLS_TOPIC_ID', 'CODEX_TLS_TRACE_TOPIC_ID', 'CODEX_TLS_TOPIC_ID', 'CODEX_TLS_TRACE_TOPICID', 'TLS_TRACE_TOPIC_ID');
+    const apiKey = config_firstEnv(env, 'TRACE_TLS_API_KEY', 'CODEX_TLS_API_KEY', 'TLS_API_KEY');
+    const ak = config_firstEnv(env, 'TRACE_TLS_AK', 'CODEX_TLS_AK', 'TLS_AK');
+    const sk = config_firstEnv(env, 'TRACE_TLS_SK', 'CODEX_TLS_SK', 'TLS_SK');
+    const timeoutMs = Number(config_firstEnv(env, 'TRACE_TLS_EXPORT_TIMEOUT_MS', 'CODEX_TLS_EXPORT_TIMEOUT_MS') ?? 20000);
+    const missing = [];
+    if (!endpoint) missing.push('TRACE_TLS_ENDPOINT or CODEX_TLS_ENDPOINT');
+    if (!region) missing.push('TRACE_TLS_REGION or CODEX_TLS_REGION');
+    if (!traceTopicId) missing.push('TRACE_TLS_TRACE_TOPIC_ID or CODEX_TLS_TRACE_TOPIC_ID');
+    if (!apiKey && (!ak || !sk)) missing.push('TRACE_TLS_API_KEY or TRACE_TLS_AK/TRACE_TLS_SK');
+    if (missing.length > 0 || !endpoint || !region || !traceTopicId) return {
+        enabled: false,
+        reason: 'missing_config',
+        missing
+    };
+    if (apiKey && (ak || sk)) return {
+        enabled: false,
+        reason: 'invalid_auth',
+        missing: [
+            'use apiKey or ak/sk, not both'
+        ]
+    };
+    return {
+        enabled: true,
+        endpoint,
+        region,
+        traceTopicId,
+        apiKey,
+        ak,
+        sk,
+        timeoutMs: Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 20000
+    };
+}
+const TLS_AUTH_RESOURCE_KEYS = {
+    traceTopicId: 'tls.otel.tracetopic',
+    apiKey: 'tls.otel.apikey',
+    ak: 'tls.otel.ak',
+    sk: 'tls.otel.sk',
+    region: 'tls.otel.region'
+};
+const TLS_AUTH_RESOURCE_CREDENTIAL_KEYS = new Set([
+    TLS_AUTH_RESOURCE_KEYS.apiKey,
+    TLS_AUTH_RESOURCE_KEYS.ak,
+    TLS_AUTH_RESOURCE_KEYS.sk
+]);
+function otlpAnyValueHasContent(value) {
+    if (!value || 'object' != typeof value) return false;
+    return Object.values(value).some((item)=>null != item && '' !== String(item).trim());
+}
+function otlpPayloadResourceAttributes(payload) {
+    return (payload.resourceSpans ?? []).flatMap((resourceSpan)=>{
+        const attributes = resourceSpan?.resource?.attributes;
+        return Array.isArray(attributes) ? attributes : [];
+    });
+}
+function otlpPayloadContainsTlsCredentials(body) {
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    } catch  {
+        return [
+            ...TLS_AUTH_RESOURCE_CREDENTIAL_KEYS
+        ].some((key)=>body.includes(key));
+    }
+    if ([
+        ...TLS_AUTH_RESOURCE_CREDENTIAL_KEYS
+    ].some((key)=>body.includes(key))) return true;
+    return otlpPayloadResourceAttributes(payload).some((attribute)=>TLS_AUTH_RESOURCE_CREDENTIAL_KEYS.has(attribute?.key) && otlpAnyValueHasContent(attribute?.value));
+}
+const ATTRIBUTE_PREFIXES = [
+    'gen_ai.',
+    'error.'
+];
+const ATTRIBUTE_KEYS = new Set([
+    'tool.error'
+]);
+const NUMERIC_ATTRIBUTE_KEYS = new Set([
+    'gen_ai.request.duration_ms',
+    'gen_ai.usage.input_tokens',
+    'gen_ai.usage.output_tokens',
+    'gen_ai.usage.reasoning.output_tokens',
+    'gen_ai.usage.cache_read.input_tokens',
+    'gen_ai.usage.cache_creation.input_tokens',
+    'gen_ai.usage.total_tokens'
+]);
+const TLS_AUTH_RESOURCE_KEY_SET = new Set(Object.values(TLS_AUTH_RESOURCE_KEYS));
+function stringifyLogValue(value) {
+    if (null == value) return '';
+    if ('string' == typeof value) return value;
+    if ('number' == typeof value || 'boolean' == typeof value) return String(value);
+    return attributes_serializeForAttr(value);
+}
+function stringifyRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value])=>[
+            key,
+            stringifyLogValue(value)
+        ]));
+}
+function traceIdOf(trace) {
+    return trace?.trace_id ?? trace?.traceId ?? '';
+}
+function spanIdOf(span) {
+    return span?.span_id ?? span?.id ?? '';
+}
+function parentSpanIdOf(span) {
+    return span?.parent_span_id ?? span?.parentId ?? '';
+}
+function records_traceSpansWithRoot(trace) {
+    const spans = trace?.spans ?? [];
+    const root = trace?.root;
+    if (!root) return spans;
+    const rootSpanId = spanIdOf(root);
+    if (rootSpanId && spans.some((span)=>spanIdOf(span) === rootSpanId)) return spans;
+    return [
+        root,
+        ...spans
+    ];
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value ?? {});
+    } catch  {
+        return '{}';
+    }
+}
+function normalizeSpanName(span, fallback = '') {
+    if (span?.type === 'model') return 'llm.request';
+    if (span?.type === 'tool') return 'tool.call';
+    if (span?.type === 'message') return 'agent.turn';
+    if ('codex_turn' === fallback) return 'agent.turn';
+    return fallback || span?.name || '';
+}
+function envelopeKind(span, name) {
+    if ('agent.turn' === name) return 'server';
+    if ('llm.request' === name || 'tool.call' === name) return 'client';
+    return span ? spanKindName(span) : 'internal';
+}
+function isEmptyAttributeValue(value) {
+    return null == value || '' === value;
+}
+function normalizeAttributeValue(key, value) {
+    if (isEmptyAttributeValue(value)) return;
+    if (NUMERIC_ATTRIBUTE_KEYS.has(key)) {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) return numeric;
+    }
+    if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value) return value;
+    return attributes_serializeForAttr(value);
+}
+function envelopeAttributes(record, span) {
+    const attributes = {};
+    const spanAttributes = span?.attributes ?? {};
+    const conversationId = record['gen_ai.conversation.id'] ?? spanAttributes['gen_ai.conversation.id'] ?? record['session.id'];
+    for (const [key, value] of Object.entries(record))if ('tls.app.type' === key || 'session.id' === key || 'gen_ai.conversation.id' === key || ATTRIBUTE_KEYS.has(key) || ATTRIBUTE_PREFIXES.some((prefix)=>key.startsWith(prefix))) {
+        const normalized = normalizeAttributeValue(key, value);
+        if (void 0 !== normalized) attributes[key] = normalized;
+    }
+    attributes['tls.app.type'] ??= 'codex';
+    if (!isEmptyAttributeValue(record['session.id'])) attributes['session.id'] ??= record['session.id'];
+    if (!isEmptyAttributeValue(conversationId)) attributes['gen_ai.conversation.id'] ??= conversationId;
+    if (span?.type === 'message') attributes['gen_ai.operation.name'] = 'invoke_agent';
+    if (span?.type === 'model') attributes['gen_ai.operation.name'] = 'chat';
+    return attributes;
+}
+function envelopeResource(trace, record) {
+    const resource = trace.resource ?? {};
+    return Object.fromEntries(Object.entries({
+        ...resource,
+        'service.instance.id': record['service.instance.id'] ?? resource['service.instance.id'],
+        'telemetry.sdk.language': record['telemetry.sdk.language'] ?? resource['telemetry.sdk.language'] ?? 'nodejs',
+        'telemetry.sdk.name': record['telemetry.sdk.name'] ?? resource['telemetry.sdk.name'] ?? "codex-transcript-stop-hook",
+        'telemetry.sdk.version': record['telemetry.sdk.version'] ?? resource['telemetry.sdk.version'] ?? '0.1.0'
+    }).filter(([key, value])=>!TLS_AUTH_RESOURCE_KEY_SET.has(key) && !isEmptyAttributeValue(value)));
+}
+function otlpEnvelopeRecord(trace, span, record) {
+    const name = normalizeSpanName(span, String(record['span.name'] ?? ''));
+    const start = String(record['start_time_unix_us'] ?? unixMsToUs(span?.start_time_unix_ms ?? span?.startedAt));
+    const end = String(record['end_time_unix_us'] ?? unixMsToUs(span?.end_time_unix_ms ?? span?.endedAt));
+    const duration = String(record['span.duration_us'] ?? 1000 * spanDurationMs(span ?? {}));
+    const error = span ? span_utils_hasError(span) : 'ERROR' === record['span.status.code'];
+    const resource = envelopeResource(trace, record);
+    const serviceName = stringifyLogValue(record['service.name'] ?? resource['service.name'] ?? "codex-transcript-stop-hook");
+    const host = stringifyLogValue(record['host.name'] ?? resource['host.name'] ?? '');
+    const scopeName = stringifyLogValue(record['otel.scope.name'] ?? trace.scope?.name ?? "codex-transcript-stop-hook");
+    const scopeVersion = stringifyLogValue(record['otel.scope.version'] ?? trace.scope?.version ?? '0.1.0');
+    return stringifyRecord({
+        Attributes: safeJsonStringify(envelopeAttributes(record, span)),
+        Duration: duration,
+        End: end,
+        Events: '[]',
+        Host: host,
+        Kind: envelopeKind(span, name),
+        Links: '[]',
+        Name: name,
+        OTLPName: scopeName,
+        OTLPVersion: scopeVersion,
+        ParentSpanID: parentSpanIdOf(span) || record['parent.span.id'] || '',
+        Resource: safeJsonStringify(resource),
+        ServiceName: serviceName,
+        SpanID: spanIdOf(span) || String(record['span.id'] ?? ''),
+        Start: start,
+        StatusCode: error ? 'ERROR' : 'OK',
+        StatusDescription: error ? record['error.message'] ?? '' : '',
+        TraceID: span?.trace_id ?? traceIdOf(trace) ?? record['trace.id'] ?? '',
+        TraceState: ''
+    });
+}
+function recordsFromTrace(trace) {
+    const spans = records_traceSpansWithRoot(trace);
+    const schemaRecords = buildSchemaAlignedRecords({
+        ...trace,
+        spans
+    });
+    return schemaRecords.map((record, index)=>otlpEnvelopeRecord(trace, spans[index], record));
+}
+function exporter_traceIdOf(trace) {
+    return trace?.trace_id ?? trace?.traceId ?? '';
+}
+function notifyRequestBody(options, request) {
+    if ('function' != typeof options.onRequestBody) return;
+    try {
+        options.onRequestBody(request);
+    } catch  {}
+}
+function endpointDiagnostics(config) {
+    return {
+        endpoint_host: normalizeProducerEndpoint(config.endpoint),
+        endpoint_path: 'SendLogs',
+        region: config.region
+    };
+}
+async function exportRecordsToTls(records, config, metadata = {}, options = {}, fileName = 'agent-trace') {
+    if (0 === records.length) return {
+        status: 'skipped',
+        reason: 'empty_records'
+    };
+    const body = JSON.stringify({
+        records
+    });
+    const startedAt = Date.now();
+    const traceId = 'string' == typeof metadata.trace_id ? metadata.trace_id : records[0]?.TraceID ?? records[0]?.['trace.id'] ?? '';
+    const spanCount = Number.isFinite(Number(metadata.span_count)) ? Number(metadata.span_count) : records.length;
+    notifyRequestBody(options, {
+        body,
+        attempt: 1,
+        request_kind: 'tls_log_records',
+        payload_bytes: Buffer.byteLength(body, 'utf8'),
+        record_count: records.length,
+        span_count: spanCount,
+        trace_id: traceId,
+        ...endpointDiagnostics(config)
+    });
+    try {
+        await sendTlsLogRecords(config, records, fileName);
+        return {
+            status: 'sent',
+            trace_id: traceId,
+            span_count: spanCount,
+            record_count: records.length,
+            payload_bytes: Buffer.byteLength(body, 'utf8'),
+            attempts: 1,
+            total_duration_ms: Date.now() - startedAt,
+            ...endpointDiagnostics(config)
+        };
+    } catch (error) {
+        return {
+            status: 'failed',
+            reason: 'producer_error',
+            message: error instanceof Error ? error.message : String(error),
+            trace_id: traceId,
+            span_count: spanCount,
+            record_count: records.length,
+            payload_bytes: Buffer.byteLength(body, 'utf8'),
+            attempts: 1,
+            total_duration_ms: Date.now() - startedAt,
+            error_name: error instanceof Error ? error.name : void 0,
+            ...endpointDiagnostics(config)
+        };
+    }
+}
+async function exportTraceToTls(trace, env = process.env, options = {}) {
+    const spans = records_traceSpansWithRoot(trace);
+    if (!trace || 0 === spans.length) return {
+        status: 'skipped',
+        reason: 'empty_trace'
+    };
+    const config = config_resolveTlsConfig(env);
+    if (!config.enabled) return {
+        status: 'skipped',
+        reason: config.reason,
+        missing: config.missing
+    };
+    return exportRecordsToTls(recordsFromTrace(trace), config, {
+        span_count: spans.length,
+        trace_id: exporter_traceIdOf(trace)
+    }, options, `${trace.source?.tool ?? 'agent'}-trace`);
+}
+function file_store_hasErrorCode(error, code) {
+    return 'object' == typeof error && null !== error && 'code' in error && error.code === code;
+}
+async function ensureParent(filePath) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+}
+async function writeJsonFile(filePath, value, options = {}) {
+    await ensureParent(filePath);
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    const writeOptions = options.mode ? {
+        encoding: 'utf8',
+        mode: options.mode
+    } : 'utf8';
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, writeOptions);
+    await __rspack_external_node_fs_promises_153e37e0.rename(tempPath, filePath);
+    if (options.mode) await __rspack_external_node_fs_promises_153e37e0.chmod(filePath, options.mode);
+}
+async function appendJsonl(filePath, value) {
+    await ensureParent(filePath);
+    await __rspack_external_node_fs_promises_153e37e0.appendFile(filePath, `${JSON.stringify(value)}\n`, 'utf8');
+}
+async function readJsonl(filePath) {
+    let text;
+    try {
+        text = await __rspack_external_node_fs_promises_153e37e0.readFile(filePath, 'utf8');
+    } catch (error) {
+        if (file_store_hasErrorCode(error, 'ENOENT')) return [];
+        throw error;
+    }
+    return text.split(/\r?\n/).filter(Boolean).map((line)=>JSON.parse(line));
+}
+function safeName(value) {
+    return String(value || 'trace').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 160) || 'trace';
+}
+async function writeFailedTraceCache(paths, key, trace, body, result, config = {}) {
+    if (result?.status !== 'failed') return {
+        persisted: false,
+        reason: 'not_failed'
+    };
+    if (!body) return {
+        persisted: false,
+        reason: 'missing_otlp_payload'
+    };
+    if (otlpPayloadContainsTlsCredentials(body)) return {
+        persisted: false,
+        reason: 'payload_contains_tls_credentials'
+    };
+    const now = Date.now();
+    const retryIntervalMs = config.retryIntervalMs ?? 300000;
+    const caseDir = __rspack_external_node_path_c5b9b54f.join(paths.failedTracesDir, `${safeName(key.slice(0, 16))}.${safeName(trace.source?.tool)}`);
+    const payloadPath = __rspack_external_node_path_c5b9b54f.join(caseDir, 'payload.otlp.json');
+    const manifestPath = __rspack_external_node_path_c5b9b54f.join(caseDir, 'manifest.json');
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(caseDir, {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.writeFile(payloadPath, body, {
+        encoding: 'utf8',
+        mode: 384
+    });
+    await __rspack_external_node_fs_promises_153e37e0.chmod(payloadPath, 384);
+    const manifest = {
+        version: 1,
+        state: 'pending',
+        created_at: new Date(now).toISOString(),
+        updated_at: new Date(now).toISOString(),
+        next_retry_at: new Date(now + retryIntervalMs).toISOString(),
+        retry_interval_ms: retryIntervalMs,
+        retry_count: 0,
+        max_retry_count: config.maxRetryCount ?? 1,
+        dedup_key: key,
+        payload_path: payloadPath,
+        source_tool: trace.source?.tool,
+        session_id: trace.source?.sessionId,
+        turn_id: trace.source?.turnId,
+        span_count: (trace.spans?.length ?? 0) + 1,
+        payload_bytes: Buffer.byteLength(body, 'utf8'),
+        trace_export: result
+    };
+    await writeJsonFile(manifestPath, manifest, {
+        mode: 384
+    });
+    return {
+        persisted: true,
+        manifest_path: manifestPath,
+        next_retry_at: manifest.next_retry_at
+    };
+}
+function dedup_hasErrorCode(error, code) {
+    return 'object' == typeof error && null !== error && 'code' in error && error.code === code;
+}
+function dedupKeyForTrace(trace) {
+    const seed = [
+        trace.source?.tool,
+        trace.source?.sessionId,
+        trace.source?.turnId,
+        trace.source?.threadId,
+        trace.root?.name,
+        trace.root?.startedAt
+    ].join(':');
+    return external_node_crypto_createHash('sha256').update(seed).digest('hex');
+}
+async function hasUploaded(uploadedFile, key) {
+    return (await readJsonl(uploadedFile)).some((entry)=>entry.key === key);
+}
+async function markUploaded(uploadedFile, key, trace, result) {
+    await appendJsonl(uploadedFile, {
+        key,
+        source_tool: trace.source?.tool,
+        session_id: trace.source?.sessionId,
+        turn_id: trace.source?.turnId,
+        uploaded_at: new Date().toISOString(),
+        span_count: (trace.spans?.length ?? 0) + 1,
+        trace_export: {
+            status: result.status,
+            reason: result.reason
+        }
+    });
+}
+async function acquireLock(locksDir, key, timeoutMs = 120000) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(locksDir, {
+        recursive: true
+    });
+    const lockPath = __rspack_external_node_path_c5b9b54f.join(locksDir, `${key}.lock`);
+    try {
+        const handle = await __rspack_external_node_fs_promises_153e37e0.open(lockPath, 'wx');
+        await handle.writeFile(JSON.stringify({
+            pid: process.pid,
+            created_at: new Date().toISOString()
+        }));
+        await handle.close();
+        return {
+            acquired: true,
+            lockPath
+        };
+    } catch (error) {
+        if (!dedup_hasErrorCode(error, 'EEXIST')) throw error;
+    }
+    const stat = await __rspack_external_node_fs_promises_153e37e0.stat(lockPath).catch(()=>null);
+    if (stat && Date.now() - stat.mtimeMs > timeoutMs) {
+        await __rspack_external_node_fs_promises_153e37e0.rm(lockPath, {
+            force: true
+        });
+        return acquireLock(locksDir, key, timeoutMs);
+    }
+    return {
+        acquired: false,
+        lockPath,
+        reason: 'dedup_lock_timeout'
+    };
+}
+async function releaseLock(lock) {
+    if (lock?.acquired && lock.lockPath) await __rspack_external_node_fs_promises_153e37e0.rm(lock.lockPath, {
+        force: true
+    });
+}
+function paths_defaultDataRoot(source = 'agent') {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.codex', 'plugins', 'data', `storage-tls-${source}`);
+}
+function runtimePaths(config = {}) {
+    const source = config.sourceName ?? config.source?.tool ?? 'agent';
+    const dataRoot = __rspack_external_node_path_c5b9b54f.resolve(config.dataRoot ?? process.env.TRACE_TLS_DATA_ROOT ?? process.env.CODEX_TLS_DATA_ROOT ?? paths_defaultDataRoot(source));
+    return {
+        dataRoot,
+        sendLogPath: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'logs', 'send', 'latest.send-log.json'),
+        diagnosticsDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'logs', 'diagnostics'),
+        uploadedFile: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'state', 'dedup', 'uploaded.jsonl'),
+        locksDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'state', 'dedup', 'locks'),
+        failedTracesDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'state', 'failed-traces')
+    };
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function metadataForTrace(trace, otelTrace) {
+    return {
+        span_count: otelTrace.spans.length,
+        trace_id: otelTrace.traceId,
+        source_tool: trace.source?.tool,
+        session_id: trace.source?.sessionId,
+        turn_id: trace.source?.turnId
+    };
+}
+async function writeSendLog(paths, event) {
+    await writeJsonFile(paths.sendLogPath, {
+        generated_at: nowIso(),
+        ...event
+    });
+}
+async function runTracePipeline(input, adapter, config = {}) {
+    if (!adapter || 'function' != typeof adapter.load || 'function' != typeof adapter.toCanonical) throw new Error('A SourceAdapter with load() and toCanonical() is required');
+    if ('function' == typeof adapter.detect && !adapter.detect(input)) return {
+        status: 'skipped',
+        reason: 'adapter_not_detected',
+        adapter: adapter.name
+    };
+    const context = {
+        env: config.env ?? process.env,
+        dataRoot: config.dataRoot,
+        now: config.now ?? Date.now,
+        source: config.source ?? {}
+    };
+    const session = await adapter.load(input, context);
+    const trace = assertCanonicalTrace(await adapter.toCanonical(session, context));
+    const paths = runtimePaths({
+        ...config,
+        source: trace.source,
+        sourceName: trace.source?.tool
+    });
+    const key = config.dedupKey ?? dedupKeyForTrace(trace);
+    if (false !== config.dedup && await hasUploaded(paths.uploadedFile, key)) {
+        await writeSendLog(paths, {
+            status: 'deduped',
+            dedup_key: key,
+            source: trace.source
+        });
+        return {
+            status: 'deduped',
+            dedup_key: key
+        };
+    }
+    const lock = false === config.dedup ? {
+        acquired: true
+    } : await acquireLock(paths.locksDir, key, config.dedupLockTimeoutMs);
+    if (!lock.acquired) {
+        await writeSendLog(paths, {
+            status: 'skipped',
+            reason: lock.reason,
+            dedup_key: key,
+            source: trace.source
+        });
+        return {
+            status: 'skipped',
+            reason: lock.reason,
+            dedup_key: key
+        };
+    }
+    try {
+        const otelTrace = canonicalTraceToOtelTrace(trace, config.otel);
+        let capturedRequestBody = '';
+        const metadata = metadataForTrace(trace, otelTrace);
+        const traceExport = await exportTraceToTls(otelTrace, context.env, {
+            ...config.tlsOptions ?? {},
+            onRequestBody: (request)=>{
+                if ('string' == typeof request.body) capturedRequestBody = request.body;
+                config.tlsOptions?.onRequestBody?.(request);
+            }
+        });
+        let failedTraceCache = {
+            persisted: false,
+            reason: 'not_failed'
+        };
+        if ('sent' === traceExport.status && false !== config.dedup) await markUploaded(paths.uploadedFile, key, trace, traceExport);
+        else if ('failed' === traceExport.status) failedTraceCache = await writeFailedTraceCache(paths, key, trace, capturedRequestBody, traceExport, config.failedTraceCache);
+        await writeSendLog(paths, {
+            status: traceExport.status,
+            dedup_key: key,
+            source: trace.source,
+            trace_export: traceExport,
+            failed_trace_cache: failedTraceCache,
+            otlp: metadata
+        });
+        return {
+            status: traceExport.status,
+            dedup_key: key,
+            trace_export: traceExport,
+            failed_trace_cache: failedTraceCache
+        };
+    } finally{
+        await releaseLock(lock);
+    }
+}
+new Map();
+const TLS_APP_TYPE = 'opencode';
+const ROOT_SPAN_NAME = 'agent.turn';
+const LLM_SPAN_NAME = 'llm.request';
+const TOOL_SPAN_NAME = 'tool.call';
+function opencode_isRecord(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function textValue(value) {
+    return 'string' == typeof value && value.length > 0 ? value : void 0;
+}
+function firstString(...values) {
+    for (const value of values){
+        const text = textValue(value);
+        if (text) return text;
+    }
+}
+function numberValue(value) {
+    return 'number' == typeof value && Number.isFinite(value) ? value : void 0;
+}
+function compactRecord(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value])=>null != value && '' !== value));
+}
+function captureEnabled(input, context) {
+    if ('boolean' == typeof input.captureContent) return input.captureContent;
+    const raw = context.env?.OPENCODE_TLS_CAPTURE_CONTENT;
+    if (null == raw || '' === raw) return true;
+    return !/^(0|false|no|n|off)$/i.test(raw);
+}
+function sortAndMergeParts(parts) {
+    const merged = new Map();
+    for (const part of parts)if (part?.id) merged.set(part.id, {
+        ...merged.get(part.id) ?? {},
+        ...part
+    });
+    return [
+        ...merged.values()
+    ];
+}
+function partTime(part) {
+    return {
+        start: numberValue(part.time?.start),
+        end: numberValue(part.time?.end),
+        observed: numberValue(part.receivedAt)
+    };
+}
+function latestPartTime(parts, fallback) {
+    let value = fallback;
+    for (const part of parts){
+        const timing = partTime(part);
+        value = Math.max(value, timing.end ?? 0, timing.start ?? 0, timing.observed ?? 0);
+    }
+    return value;
+}
+function messageStart(message, fallback) {
+    const created = opencode_isRecord(message.info?.time) ? numberValue(message.info.time.created) : void 0;
+    return created ?? fallback;
+}
+function messageEnd(message, fallback) {
+    return latestPartTime(sortAndMergeParts(message.parts), fallback);
+}
+function safeContent(value, captureContent) {
+    if (!captureContent) return;
+    return value;
+}
+function contentBlock(part, captureContent) {
+    if ('step-start' === part.type || 'step-finish' === part.type) return [];
+    if ('text' === part.type) return [
+        compactRecord({
+            type: 'text',
+            content: safeContent(part.text, captureContent),
+            metadata: part.metadata
+        })
+    ];
+    if ('reasoning' === part.type) return [
+        compactRecord({
+            type: 'reasoning',
+            content: safeContent(part.text, captureContent),
+            metadata: part.metadata
+        })
+    ];
+    if ('file' === part.type) return [
+        compactRecord({
+            type: 'file',
+            id: part.filename ?? part.id,
+            url: safeContent(part.url, captureContent),
+            mime_type: part.mime
+        })
+    ];
+    if ('tool' === part.type) {
+        const state = opencode_isRecord(part.state) ? part.state : {};
+        return [
+            compactRecord({
+                type: 'tool_call',
+                id: part.callID,
+                name: part.tool,
+                arguments: safeContent(state.input, captureContent)
+            })
+        ];
+    }
+    if ('compaction' === part.type) return [
+        compactRecord({
+            type: 'compaction',
+            auto: part.auto
+        })
+    ];
+    return [
+        compactRecord({
+            type: part.type || 'unknown',
+            value: safeContent(part, captureContent)
+        })
+    ];
+}
+function roleOf(message) {
+    return firstString(message.info?.role) ?? 'unknown';
+}
+function toGenAiMessages(messages, captureContent) {
+    return messages.flatMap((message)=>{
+        const parts = sortAndMergeParts(message.parts);
+        const role = roleOf(message);
+        const primary = compactRecord({
+            role,
+            parts: parts.flatMap((part)=>contentBlock(part, captureContent))
+        });
+        const toolResults = parts.flatMap((part)=>{
+            if ('tool' !== part.type) return [];
+            const state = opencode_isRecord(part.state) ? part.state : {};
+            const status = firstString(state.status);
+            if ('completed' !== status && 'success' !== status && 'error' !== status) return [];
+            return [
+                compactRecord({
+                    role: 'tool',
+                    name: part.tool,
+                    tool_call_id: part.callID,
+                    content: safeContent('error' === status ? state.error : state.output, captureContent)
+                })
+            ];
+        });
+        return [
+            primary,
+            ...toolResults
+        ];
+    });
+}
+function toTraceMessages(messages, captureContent) {
+    return messages.map((message)=>({
+            role: roleOf(message),
+            content: toGenAiMessages([
+                message
+            ], captureContent),
+            timestamp: new Date(messageStart(message, Date.now())).toISOString(),
+            attributes: compactRecord({
+                'opencode.message_id': message.info?.id,
+                'opencode.parent_message_id': message.info?.parentID,
+                'opencode.agent': message.info?.agent,
+                'opencode.mode': message.info?.mode
+            })
+        }));
+}
+function stepFinish(message) {
+    return sortAndMergeParts(message.parts).find((part)=>'step-finish' === part.type);
+}
+function usageFromStep(part) {
+    const tokens = opencode_isRecord(part?.tokens) ? part.tokens : {};
+    const cache = opencode_isRecord(tokens.cache) ? tokens.cache : {};
+    const input = numberValue(tokens.input) ?? 0;
+    const output = numberValue(tokens.output) ?? 0;
+    const reasoning = numberValue(tokens.reasoning) ?? 0;
+    const cacheRead = numberValue(cache.read) ?? 0;
+    const cacheWrite = numberValue(cache.write) ?? 0;
+    return compactRecord({
+        'gen_ai.usage.input_tokens': input || void 0,
+        'gen_ai.usage.output_tokens': output || void 0,
+        'gen_ai.usage.reasoning.output_tokens': reasoning || void 0,
+        'gen_ai.usage.cache_read.input_tokens': cacheRead || void 0,
+        'gen_ai.usage.cache_creation.input_tokens': cacheWrite || void 0,
+        'gen_ai.usage.total_tokens': input || output || reasoning ? input + output + reasoning : void 0
+    });
+}
+function sumUsage(records) {
+    const keys = [
+        'gen_ai.usage.input_tokens',
+        'gen_ai.usage.output_tokens',
+        'gen_ai.usage.reasoning.output_tokens',
+        'gen_ai.usage.cache_read.input_tokens',
+        'gen_ai.usage.cache_creation.input_tokens',
+        'gen_ai.usage.total_tokens'
+    ];
+    return compactRecord(Object.fromEntries(keys.map((key)=>[
+            key,
+            records.reduce((sum, record)=>{
+                const value = record[key];
+                return 'number' == typeof value && Number.isFinite(value) ? sum + value : sum;
+            }, 0) || void 0
+        ])));
+}
+function modelInfo(message) {
+    const systemModel = opencode_isRecord(message.systemPrompt?.model) ? message.systemPrompt.model : {};
+    const api = opencode_isRecord(systemModel.api) ? systemModel.api : {};
+    return {
+        model: firstString(systemModel.id, message.info?.modelID),
+        provider: firstString(systemModel.providerID, message.info?.providerID),
+        displayName: firstString(systemModel.name),
+        apiModel: firstString(api.id)
+    };
+}
+function systemMessages(message) {
+    const system = message.systemPrompt?.system;
+    if (!Array.isArray(system) || 0 === system.length) return [];
+    return [
+        {
+            role: 'system',
+            content: system.join('\n')
+        }
+    ];
+}
+function messageId(message) {
+    return firstString(message.info?.id);
+}
+function currentTurnMessagesBefore(messages, message) {
+    const id = messageId(message);
+    const index = messages.findIndex((candidate)=>{
+        const candidateId = messageId(candidate);
+        return id ? candidateId === id : candidate === message;
+    });
+    return index >= 0 ? messages.slice(0, index) : [];
+}
+function toolParts(message) {
+    return sortAndMergeParts(message.parts).filter((part)=>'tool' === part.type);
+}
+function toolSpan(traceId, rootSpanId, message, part, fallbackStart, fallbackEnd, common, captureContent) {
+    const state = opencode_isRecord(part.state) ? part.state : {};
+    const status = firstString(state.status);
+    const errored = 'error' === status;
+    const start = numberValue(opencode_isRecord(state.time) ? state.time.start : void 0) ?? fallbackStart;
+    const end = numberValue(opencode_isRecord(state.time) ? state.time.end : void 0) ?? fallbackEnd;
+    const result = errored ? state.error : state.output;
+    const callId = firstString(part.callID, part.id) ?? part.id;
+    return {
+        id: spanIdFromSeed(traceId, 'opencode-tool', callId),
+        parentId: rootSpanId,
+        name: TOOL_SPAN_NAME,
+        kind: 'client',
+        type: 'tool',
+        startedAt: start,
+        endedAt: Math.max(start, end),
+        status: errored ? 'error' : 'unset',
+        input: safeContent(state.input, captureContent),
+        output: safeContent(result, captureContent),
+        attributes: compactRecord({
+            ...common,
+            'gen_ai.tool.name': part.tool,
+            'gen_ai.tool.call.id': callId,
+            'gen_ai.tool.call.arguments': safeContent(state.input, captureContent),
+            'gen_ai.tool.call.result': safeContent(result, captureContent),
+            'tool.error': errored || void 0,
+            'error.message': errored ? state.error : void 0
+        })
+    };
+}
+function assistantMessages(input) {
+    return input.messages.filter((message)=>'assistant' === roleOf(message));
+}
+function userMessages(input) {
+    return input.messages.filter((message)=>'user' === roleOf(message));
+}
+function finalAssistantMessage(input) {
+    return [
+        ...assistantMessages(input)
+    ].reverse()[0];
+}
+function opencode_commonAttributes(input, pluginVersion) {
+    const agentMessage = finalAssistantMessage(input) ?? input.messages[0];
+    return compactRecord({
+        'tls.app.type': TLS_APP_TYPE,
+        'tls.plugin.version': pluginVersion,
+        'session.id': input.session.id,
+        'gen_ai.conversation.id': input.session.id,
+        'agent.name': firstString(agentMessage?.info?.agent, agentMessage?.info?.mode),
+        'agent.version': input.session.version ?? pluginVersion,
+        'user.name': external_node_os_userInfo().username
+    });
+}
+function detectOpenCodeInput(input) {
+    return opencode_isRecord(input) && 'opencode' === input.source && 'string' == typeof input.turnId;
+}
+async function loadOpenCodeTurn(input) {
+    if (!detectOpenCodeInput(input)) throw new Error('OpenCode adapter requires a turn snapshot');
+    return input;
+}
+async function toCanonicalOpenCodeTrace(input, context = {}) {
+    const captureContent = captureEnabled(input, context);
+    const pluginVersion = input.pluginVersion ?? context.version ?? '0.0.0';
+    const now = context.now?.() ?? Date.now();
+    const traceId = model_traceIdFromSeed(`opencode:${input.session.id}:${input.turnId}`);
+    const rootSpanId = spanIdFromSeed(traceId, 'opencode-turn', input.turnId);
+    const users = userMessages(input);
+    const assistants = assistantMessages(input);
+    const start = users[0] ? messageStart(users[0], now) : now;
+    const endCandidates = assistants.map((message)=>messageEnd(message, start));
+    const end = Math.max(start, input.completedAt ?? 0, ...endCandidates);
+    const common = opencode_commonAttributes(input, pluginVersion);
+    const llmUsageRecords = assistants.map((message)=>usageFromStep(stepFinish(message)));
+    const lastModel = modelInfo(finalAssistantMessage(input) ?? assistants[0] ?? input.messages[0]);
+    const inputMessages = toGenAiMessages(users, captureContent);
+    const outputMessages = toGenAiMessages(assistants, captureContent);
+    const root = {
+        id: rootSpanId,
+        name: ROOT_SPAN_NAME,
+        kind: 'server',
+        type: 'agent',
+        startedAt: start,
+        endedAt: end,
+        status: 'unset',
+        input: {
+            messages: inputMessages
+        },
+        output: {
+            messages: outputMessages
+        },
+        attributes: compactRecord({
+            ...common,
+            ...sumUsage(llmUsageRecords),
+            'gen_ai.operation.name': 'invoke_agent',
+            'gen_ai.request.model': lastModel.model,
+            'gen_ai.provider.name': lastModel.provider,
+            'gen_ai.input.messages': inputMessages,
+            'gen_ai.output.messages': outputMessages
+        })
+    };
+    const spans = [];
+    assistants.forEach((message, index)=>{
+        const llmStart = messageStart(message, start);
+        const llmEnd = Math.max(llmStart, messageEnd(message, llmStart));
+        const model = modelInfo(message);
+        const llmInputMessages = [
+            ...systemMessages(message),
+            ...toGenAiMessages(currentTurnMessagesBefore(input.messages, message), captureContent)
+        ];
+        const llmOutputMessages = toGenAiMessages([
+            message
+        ], captureContent);
+        const llmSpanId = spanIdFromSeed(traceId, 'opencode-llm', message.info?.id ?? index);
+        spans.push({
+            id: llmSpanId,
+            parentId: rootSpanId,
+            name: LLM_SPAN_NAME,
+            kind: 'client',
+            type: 'model',
+            startedAt: llmStart,
+            endedAt: llmEnd,
+            status: 'unset',
+            input: {
+                messages: llmInputMessages
+            },
+            output: {
+                messages: llmOutputMessages
+            },
+            attributes: compactRecord({
+                ...common,
+                ...usageFromStep(stepFinish(message)),
+                'gen_ai.operation.name': 'chat',
+                'gen_ai.request.model': model.model,
+                'gen_ai.provider.name': model.provider,
+                'gen_ai.input.messages': llmInputMessages,
+                'gen_ai.output.messages': llmOutputMessages
+            })
+        });
+        for (const part of toolParts(message))spans.push(toolSpan(traceId, llmSpanId, message, part, llmStart, llmEnd, common, captureContent));
+    });
+    return {
+        source: {
+            tool: 'opencode',
+            sessionId: input.session.id,
+            turnId: input.turnId,
+            threadId: input.session.id,
+            conversationId: input.session.id,
+            cwd: firstString(common['opencode.cwd']),
+            model: lastModel.model,
+            attributes: compactRecord({
+                'opencode.parent_session_id': input.session.parentID,
+                'opencode.session_title': input.session.title
+            })
+        },
+        root,
+        spans,
+        messages: toTraceMessages(input.messages, captureContent),
+        metrics: {
+            inputTokens: numberValue(root.attributes?.['gen_ai.usage.input_tokens']),
+            outputTokens: numberValue(root.attributes?.['gen_ai.usage.output_tokens']),
+            totalTokens: numberValue(root.attributes?.['gen_ai.usage.total_tokens']),
+            toolCallCount: spans.filter((span)=>'tool' === span.type).length,
+            latencyMs: Math.max(0, end - start)
+        },
+        diagnostics: {
+            warnings: [],
+            parser: {
+                assistant_message_count: assistants.length,
+                user_message_count: users.length
+            }
+        }
+    };
+}
+const opencodeAdapter = {
+    name: 'opencode',
+    detect: detectOpenCodeInput,
+    load: loadOpenCodeTurn,
+    toCanonical: toCanonicalOpenCodeTrace
+};
+function tracer_isRecord(value) {
+    return null != value && 'object' == typeof value && !Array.isArray(value);
+}
+function stringValue(value) {
+    return 'string' == typeof value && value.length > 0 ? value : void 0;
+}
+function numericValue(value) {
+    return 'number' == typeof value && Number.isFinite(value) ? value : void 0;
+}
+function eventTimestamp(properties) {
+    const time = properties.time;
+    if ('number' == typeof time && Number.isFinite(time)) return time;
+    if (tracer_isRecord(time)) return numericValue(time.receivedAt);
+}
+function sessionIDOf(event) {
+    const properties = event.properties ?? {};
+    const direct = stringValue(properties.sessionID);
+    if (direct) return direct;
+    const info = tracer_isRecord(properties.info) ? properties.info : void 0;
+    const fromInfo = stringValue(info?.id) ?? stringValue(info?.sessionID);
+    if (fromInfo) return fromInfo;
+    const part = tracer_isRecord(properties.part) ? properties.part : void 0;
+    return stringValue(part?.sessionID);
+}
+function messageIDOf(message) {
+    return stringValue(message.info?.id);
+}
+function messageRole(message) {
+    return stringValue(message.info?.role);
+}
+function parentMessageID(message) {
+    const info = message.info;
+    return stringValue(info?.parentID);
+}
+function mergedParts(parts) {
+    const byId = new Map();
+    for (const part of parts){
+        if (!part?.id) continue;
+        const existing = byId.get(part.id) ?? {};
+        byId.set(part.id, {
+            ...existing,
+            ...part
+        });
+    }
+    return [
+        ...byId.values()
+    ];
+}
+function finishPart(message) {
+    return mergedParts(message.parts).find((part)=>'step-finish' === part.type);
+}
+function messageIsComplete(message) {
+    const role = messageRole(message);
+    if ('user' === role) return message.parts.length > 0;
+    if ('assistant' === role) return Boolean(finishPart(message));
+    return false;
+}
+function turnIsReady(turn) {
+    return turn.messages.some((message)=>{
+        const part = finishPart(message);
+        return part && 'stop' === part.reason;
+    });
+}
+function toObservedHistory(items) {
+    return items.map((item)=>({
+            info: item.info,
+            parts: item.parts.map((part)=>({
+                    ...part
+                })),
+            completed: true
+        }));
+}
+function toAdapterMessage(message) {
+    return {
+        info: message.info,
+        parts: mergedParts(message.parts),
+        systemPrompt: message.promptContext ? {
+            model: message.promptContext.model,
+            system: message.promptContext.system ?? []
+        } : void 0
+    };
+}
+function observedSessionInfo(sessionID, session) {
+    return {
+        id: session.info?.id ?? sessionID,
+        parentID: session.parentID ?? session.info?.parentID,
+        directory: session.info?.directory,
+        title: session.info?.title,
+        version: session.info?.version
+    };
+}
+function trackPendingExport(session, task) {
+    session.pendingExports.push(task);
+    task.finally(()=>{
+        session.pendingExports = session.pendingExports.filter((pending)=>pending !== task);
+    });
+}
+class OpenCodeTlsTracer {
+    config;
+    sessions = new Map();
+    constructor(config){
+        this.config = config;
+    }
+    getSession(sessionID) {
+        const current = this.sessions.get(sessionID);
+        if (current) return current;
+        const created = {
+            sessionID,
+            messages: new Map(),
+            turns: new Map(),
+            pendingExports: []
+        };
+        this.sessions.set(sessionID, created);
+        return created;
+    }
+    getMessage(sessionID, messageID) {
+        const session = this.getSession(sessionID);
+        const current = session.messages.get(messageID);
+        if (current) return current;
+        const created = {
+            parts: [],
+            completed: false
+        };
+        session.messages.set(messageID, created);
+        return created;
+    }
+    async loadHistory(sessionID, loader, options = {}) {
+        const session = this.getSession(sessionID);
+        if (session.history && !options.refresh) return;
+        try {
+            session.history = toObservedHistory(await loader(sessionID));
+        } catch  {
+            session.history = [];
+        }
+    }
+    updateSessionInfo(sessionID, info) {
+        const session = this.getSession(sessionID);
+        session.parentID = stringValue(info.parentID) ?? session.parentID;
+        session.info = {
+            id: stringValue(info.id) ?? sessionID,
+            parentID: stringValue(info.parentID),
+            directory: stringValue(info.directory),
+            title: stringValue(info.title),
+            version: stringValue(info.version)
+        };
+    }
+    attachPromptContextIfReady(sessionID, message) {
+        const session = this.getSession(sessionID);
+        if (!session.pendingSystemPrompt || 'assistant' !== messageRole(message)) return;
+        message.promptContext = session.pendingSystemPrompt;
+        session.pendingSystemPrompt = void 0;
+    }
+    registerCompletedMessage(sessionID, message) {
+        if (!messageIsComplete(message) || message.completed) return;
+        message.completed = true;
+        const role = messageRole(message);
+        const turnId = 'user' === role ? messageIDOf(message) : parentMessageID(message);
+        if (!turnId) return;
+        const session = this.getSession(sessionID);
+        const turn = session.turns.get(turnId) ?? {
+            turnId,
+            messages: [],
+            exportState: 'open'
+        };
+        if (!turn.messages.includes(message)) turn.messages.push(message);
+        if (turnIsReady(turn) && 'open' === turn.exportState) turn.exportState = 'ready';
+        session.turns.set(turnId, turn);
+        return turn;
+    }
+    exportTurn(sessionID, turn) {
+        if ('ready' !== turn.exportState) return;
+        turn.exportState = 'exporting';
+        const session = this.getSession(sessionID);
+        const snapshot = {
+            source: 'opencode',
+            session: observedSessionInfo(sessionID, session),
+            turnId: turn.turnId,
+            messages: turn.messages.map(toAdapterMessage),
+            history: session.history?.map(toAdapterMessage) ?? [],
+            captureContent: this.config.captureContent,
+            pluginVersion: this.config.pluginVersion
+        };
+        const task = runTracePipeline(snapshot, opencodeAdapter, {
+            env: this.config.env,
+            dataRoot: this.config.dataRoot,
+            sourceName: 'opencode',
+            source: {
+                tool: 'opencode',
+                sessionId: snapshot.session.id,
+                turnId: snapshot.turnId,
+                threadId: snapshot.session.id
+            },
+            otel: {
+                serviceName: this.config.serviceName,
+                sdkVersion: this.config.pluginVersion,
+                scopeName: 'tls-observer-opencode',
+                scopeVersion: this.config.pluginVersion,
+                resourceAttributes: {
+                    'service.instance.id': this.config.serviceInstanceId,
+                    'tls.app.type': 'opencode'
+                }
+            },
+            failedTraceCache: {
+                maxRetryCount: 1
+            }
+        }).then(()=>{
+            turn.exportState = 'exported';
+        }).catch(()=>{
+            turn.exportState = 'ready';
+        });
+        trackPendingExport(session, task);
+    }
+    async handleSystemPrompt(input, output, loader) {
+        if (!input.sessionID) return;
+        await this.loadHistory(input.sessionID, loader);
+        const session = this.getSession(input.sessionID);
+        session.pendingSystemPrompt = {
+            model: input.model,
+            system: output.system
+        };
+    }
+    async handleEvent(event, loader) {
+        if ('server.instance.disposed' === event.type) return void await this.flush();
+        const sessionID = sessionIDOf(event);
+        if (!sessionID) return;
+        await this.loadHistory(sessionID, loader);
+        const session = this.getSession(sessionID);
+        const properties = event.properties ?? {};
+        let changedMessageID;
+        if (('session.created' === event.type || 'session.updated' === event.type) && tracer_isRecord(properties.info)) this.updateSessionInfo(sessionID, properties.info);
+        if ('message.updated' === event.type && tracer_isRecord(properties.info)) {
+            const id = stringValue(properties.info.id);
+            if (id) {
+                const message = this.getMessage(sessionID, id);
+                message.info = properties.info;
+                this.attachPromptContextIfReady(sessionID, message);
+                changedMessageID = id;
+            }
+        }
+        if ('message.part.updated' === event.type && tracer_isRecord(properties.part)) {
+            const part = properties.part;
+            const messageID = stringValue(part.messageID);
+            if (messageID) {
+                const message = this.getMessage(sessionID, messageID);
+                message.parts.push({
+                    ...part,
+                    receivedAt: eventTimestamp(properties)
+                });
+                changedMessageID = messageID;
+            }
+        }
+        if ('message.part.removed' === event.type) {
+            const messageID = stringValue(properties.messageID);
+            const partID = stringValue(properties.partID);
+            if (messageID && partID) {
+                const message = this.getMessage(sessionID, messageID);
+                message.parts = message.parts.filter((part)=>part.id !== partID);
+                changedMessageID = messageID;
+            }
+        }
+        if ('message.removed' === event.type) {
+            const messageID = stringValue(properties.messageID);
+            if (messageID) {
+                session.messages.delete(messageID);
+                for (const turn of session.turns.values())turn.messages = turn.messages.filter((message)=>messageIDOf(message) !== messageID);
+            }
+        }
+        if (changedMessageID) {
+            const message = session.messages.get(changedMessageID);
+            if (message) {
+                const turn = this.registerCompletedMessage(sessionID, message);
+                if (turn?.exportState === 'ready') this.exportTurn(sessionID, turn);
+            }
+        }
+        if ('session.idle' === event.type) await this.flush(sessionID);
+        if ('session.deleted' === event.type) {
+            await this.flush(sessionID);
+            this.sessions.delete(sessionID);
+        }
+    }
+    async flush(sessionID) {
+        const sessions = sessionID ? [
+            this.getSession(sessionID)
+        ] : [
+            ...this.sessions.values()
+        ];
+        await Promise.allSettled(sessions.flatMap((session)=>session.pendingExports));
+    }
+    get observedSessionCount() {
+        return this.sessions.size;
+    }
+}
+async function loadSessionMessages(ctx, sessionID) {
+    const result = await ctx.client.session.messages({
+        path: {
+            id: sessionID
+        }
+    });
+    if (result.error) throw result.error;
+    return result.data;
+}
+const TlsObserverOpenCodePlugin = async (ctx)=>{
+    const config = loadConfig();
+    if (!config.enabled) return {};
+    const tracer = new OpenCodeTlsTracer(config);
+    const history = (sessionID)=>loadSessionMessages(ctx, sessionID);
+    return {
+        'experimental.chat.system.transform': async (input, output)=>{
+            await tracer.handleSystemPrompt(input, output, history);
+        },
+        event: async ({ event })=>{
+            await tracer.handleEvent(event, history);
+        },
+        dispose: async ()=>{
+            await tracer.flush();
+        }
+    };
+};
+const src = TlsObserverOpenCodePlugin;
+export default src;
+export { OpenCodeTlsTracer, TlsObserverOpenCodePlugin, loadConfig };