@armoriq/sdk-dev 0.6.8 → 0.7.0

package/dist/observability/otel-session.js

@@ -0,0 +1,621 @@
+"use strict";
+/** Request-scoped native OTel span bridge for SDK and framework adapters. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelSession = void 0;
+exports.modelSystem = modelSystem;
+const crypto_1 = require("crypto");
+const api_1 = require("@opentelemetry/api");
+const content_capture_1 = require("./content-capture");
+const TASK_OUTCOME = Object.freeze({
+    ok: 'completed',
+    error: 'failed',
+    denied: 'denied',
+    cancelled: 'abandoned',
+    timeout: 'abandoned',
+    disconnected: 'abandoned',
+    bootstrap: 'unknown',
+    process_exit: 'abandoned',
+});
+const MAX_PLAN_STEP_ORDINAL = 999_999_999;
+/**
+ * The SDK's own enforcement vocabulary (`'allow' | 'block' | 'hold' | 'error'`,
+ * used throughout session.ts/client.ts/the framework integrations) is not the
+ * observability wire's vocabulary. The Python SDK's single mapping point,
+ * `_emit_enforce_policy_call`, maps its own allow/block/hold decision onto the
+ * wire's `allow`/`deny`/`hold` — this is the TypeScript equivalent of that one
+ * mapping point. `'error'` has no Python analog here: an enforcement error is
+ * not a policy verdict at all (Python represents it with `decision=None`, a
+ * distinct code path from this four-way SDK enum), so it passes through
+ * unmapped rather than being folded into the deny/hold/allow vocabulary.
+ */
+function toWirePolicyDecision(decision) {
+    return decision === 'block' ? 'deny' : decision;
+}
+/** Matches the shared Python/TypeScript fixture: `plan-step-N`, with no leading zeroes. */
+function canonicalPlanStepOrdinal(value) {
+    if (typeof value !== 'number'
+        || !Number.isSafeInteger(value)
+        || value < 0
+        || value > MAX_PLAN_STEP_ORDINAL) {
+        return undefined;
+    }
+    return value;
+}
+function errorType(error) {
+    if (!error)
+        return undefined;
+    if (error instanceof Error)
+        return error.name.slice(0, 128);
+    return 'Error';
+}
+/** Never export a stack: messages still pass through the shared projector. */
+function safeErrorSummary(error) {
+    if (!error)
+        return undefined;
+    if (error instanceof Error)
+        return { type: error.name.slice(0, 128), message: error.message.slice(0, 2_048) };
+    if (typeof error === 'string')
+        return { type: 'Error', message: error.slice(0, 2_048) };
+    return { type: 'Error', message: String(error).slice(0, 2_048) };
+}
+function asStatus(status) {
+    return status === 'ok' ? api_1.SpanStatusCode.OK : api_1.SpanStatusCode.ERROR;
+}
+/**
+ * Map a well-known model identifier to a `gen_ai.system` provider label.
+ * Matches the Python SDK's `armoriq_sdk/observability/otel_semantics.py`
+ * `model_system()`. Descriptive metadata only — an unrecognized model
+ * returns undefined rather than a guessed provider.
+ */
+function modelSystem(model) {
+    if (typeof model !== 'string')
+        return undefined;
+    const normalized = model.toLowerCase();
+    if (normalized.startsWith('gpt-') || normalized.startsWith('o1') || normalized.startsWith('o3') || normalized.startsWith('o4'))
+        return 'openai';
+    if (normalized.startsWith('claude-'))
+        return 'anthropic';
+    if (normalized.startsWith('gemini-') || normalized.startsWith('google/'))
+        return 'google';
+    return undefined;
+}
+/**
+ * This bridge owns only request span state. Providers and exporters stay in
+ * ArmorIQTelemetryRuntime, so concurrent sessions cannot affect each other or
+ * the host application's global OTel setup.
+ */
+class OtelSession {
+    runtime;
+    options;
+    root = null;
+    plan = null;
+    planId = null;
+    snapshot = null;
+    closed = false;
+    closing = false;
+    closePromise = null;
+    pendingToolContent = new Map();
+    constructor(runtime, options) {
+        this.runtime = runtime;
+        this.options = { ...options, traceName: options.traceName ?? 'armoriq.agent.run' };
+    }
+    get enabled() {
+        return !this.closed && !this.closing && this.runtime.config.enabled;
+    }
+    async attributes(values) {
+        const snapshot = await this.currentSnapshot();
+        if (!snapshot)
+            return {};
+        return this.runtime.safeAttributes(snapshot, values, this.attributeContext());
+    }
+    /** Explicit readiness path for setup/tests; normal request hooks never await it. */
+    async refreshPolicy() {
+        await this.runtime.policySnapshot({ awaitFresh: true });
+    }
+    async beginRoot(content = {}) {
+        const traceName = this.runtime.externalTraceName(this.options.traceName);
+        if (this.closed || this.closing || this.root)
+            return { span: this.root, name: traceName };
+        // A borrowed provider belongs to the application, so retain its active
+        // request parent. ArmorIQ-owned exporters stay rooted at ROOT_CONTEXT to
+        // prevent unrelated application trace context from crossing that boundary.
+        const parentContext = this.runtime.config.exporter === 'provider' ? api_1.context.active() : api_1.ROOT_CONTEXT;
+        const snapshot = await this.currentSnapshot();
+        const tracer = snapshot ? this.runtime.tracer(snapshot) : null;
+        if (!snapshot || !tracer)
+            return { span: null, name: traceName };
+        try {
+            const attrs = this.runtime.safeAttributes(snapshot, {
+                'armoriq.session_id': this.options.sessionId,
+                'gen_ai.operation.name': 'invoke_agent',
+                'armoriq.timing.provenance': 'measured',
+                ...(this.options.agentId ? { 'gen_ai.agent.name': this.options.agentId } : {}),
+                ...(this.options.agentId ? { 'armoriq.agent_id': this.options.agentId } : {}),
+                // A missing framework hook should remain visible as an SDK limitation,
+                // not look like a successful capture of an empty prompt.
+                'gen_ai.input.messages': content.input,
+            }, this.attributeContext());
+            this.root = tracer.startSpan(traceName, { attributes: attrs }, parentContext);
+            return { span: this.root, name: traceName };
+        }
+        catch {
+            return { span: null, name: traceName };
+        }
+    }
+    async startPlan(input) {
+        await this.endSpan(this.plan, 'ok');
+        this.plan = null;
+        this.planId = null;
+        const root = (await this.beginRoot()).span;
+        const snapshot = await this.currentSnapshot();
+        const tracer = snapshot ? this.runtime.tracer(snapshot) : null;
+        if (!root || !tracer || !snapshot)
+            return { span: null, name: 'armoriq.intent.plan' };
+        try {
+            const attrs = this.runtime.safeAttributes(snapshot, {
+                'gen_ai.operation.name': 'plan',
+                'armoriq.timing.provenance': 'measured',
+                ...(this.options.agentId ? { 'gen_ai.agent.name': this.options.agentId } : {}),
+                'armoriq.intent_plan_item_count': input.itemCount,
+                ...(input.planId ? { 'armoriq.intent_plan_id': input.planId } : {}),
+            }, this.attributeContext());
+            // Pass the parent context directly. `context.with()` can be a no-op when
+            // the application has not installed a context manager, which would turn
+            // every child into a separate trace.
+            this.plan = tracer.startSpan('armoriq.intent.plan', { attributes: attrs }, api_1.trace.setSpan(api_1.ROOT_CONTEXT, root));
+            this.planId = input.planId ?? `otel-plan-${this.plan.spanContext().spanId}`;
+            if (!input.planId) {
+                this.plan.setAttribute('armoriq.external_intent_plan_id', this.planId);
+            }
+            return { span: this.plan, name: 'armoriq.intent.plan' };
+        }
+        catch {
+            return { span: null, name: 'armoriq.intent.plan' };
+        }
+    }
+    async beginPolicy(input) {
+        return this.beginChild('armoriq.policy.evaluate', {
+            ...this.planItemAttributes(input),
+            'armoriq.policy.tool_name': input.toolName,
+            ...this.planItemOrdinalAttributes(input.itemOrdinal),
+            ...(input.toolCallId ? { 'gen_ai.tool.call.id': input.toolCallId } : {}),
+            ...(Object.prototype.hasOwnProperty.call(input, 'arguments') ? { 'gen_ai.tool.call.arguments': input.arguments } : {}),
+        });
+    }
+    async endPolicy(handle, result) {
+        const decision = result.decision;
+        await this.endSpan(handle.span, result.terminalStatus ?? (decision === 'allow' ? 'ok' : decision === 'block' ? 'denied' : 'error'), {
+            ...(decision ? { 'armoriq.policy.decision': toWirePolicyDecision(decision) } : {}),
+            ...(result.policyName ? { 'armoriq.policy.name': result.policyName } : {}),
+            ...(result.policyId ? { 'armoriq.policy.id': result.policyId } : {}),
+            ...(result.policyVersion ? { 'armoriq.policy.version': result.policyVersion } : {}),
+            ...(result.matchedRuleId ?? result.ruleId ? { 'armoriq.policy.rule_id': result.matchedRuleId ?? result.ruleId } : {}),
+            ...(result.policySource ? { 'armoriq.policy.source': result.policySource } : {}),
+            ...(result.policyReasonCode ? { 'armoriq.policy.reason_code': result.policyReasonCode } : {}),
+            ...(result.defaultAction ? { 'armoriq.policy.default_action': result.defaultAction } : {}),
+            'armoriq.intent_plan_item_status': decision === 'allow'
+                ? 'allowed'
+                : decision === 'hold'
+                    ? 'waiting'
+                    : decision === 'block'
+                        ? 'blocked'
+                        : 'failed',
+            ...(errorType(result.error) ? { 'error.type': errorType(result.error) } : {}),
+            ...(safeErrorSummary(result.error) ? { 'armoriq.observability.error.summary': safeErrorSummary(result.error) } : {}),
+        });
+    }
+    /** Record a decision that completed before telemetry started. */
+    async recordPolicy(input, result) {
+        const handle = await this.beginChild('armoriq.policy.evaluate', {
+            ...this.planItemAttributes(input),
+            'armoriq.policy.tool_name': input.toolName,
+            ...this.planItemOrdinalAttributes(input.itemOrdinal),
+            ...(input.toolCallId ? { 'gen_ai.tool.call.id': input.toolCallId } : {}),
+            ...(Object.prototype.hasOwnProperty.call(input, 'arguments') ? { 'gen_ai.tool.call.arguments': input.arguments } : {}),
+        }, 'post_hoc');
+        await this.endPolicy(handle, result);
+    }
+    async beginTool(input) {
+        return this.beginToolWithTiming(input, 'measured');
+    }
+    /** Record a tool that completed before this SDK observed its lifecycle. */
+    async recordTool(input, result) {
+        const timing = safeNonNegative(result.durationMs) === undefined ? 'post_hoc' : 'reported';
+        const handle = await this.beginToolWithTiming(input, timing);
+        await this.endTool(handle, result);
+    }
+    async beginToolWithTiming(input, timing) {
+        const operation = await this.beginOperationWithTiming({
+            category: input.operation?.category ?? 'tool',
+            name: input.operation?.name ?? 'armoriq.tool',
+            toolType: input.operation?.toolType ?? 'function',
+            ...input.operation,
+            toolName: input.toolName,
+            callId: input.toolCallId,
+            planItemOrdinal: input.itemOrdinal,
+        }, timing);
+        if (operation.span && Object.prototype.hasOwnProperty.call(input, 'arguments')) {
+            this.queueToolContent(operation.span, { toolArguments: input.arguments });
+        }
+        return operation;
+    }
+    /** SDK audit transport metadata; distinct from a framework tool execution. */
+    async beginAuditTool(input) {
+        return this.beginOperation({
+            category: 'tool',
+            name: 'tool.execute',
+            toolType: 'function',
+            toolName: input.toolName,
+            callId: input.toolCallId,
+            planItemOrdinal: input.itemOrdinal,
+        });
+    }
+    async beginOperation(input) {
+        return this.beginOperationWithTiming(input, 'measured');
+    }
+    async beginOperationWithTiming(input, timing) {
+        if (!isOperationCategory(input.category))
+            return { span: null, name: 'armoriq.operation' };
+        const toolName = safeIdentifier(input.toolName);
+        const planId = safeIdentifier(input.planId ?? this.planId);
+        const planItemOrdinal = canonicalPlanStepOrdinal(input.planItemOrdinal);
+        const values = {
+            'armoriq.operation.category': input.category,
+        };
+        const toolType = isToolType(input.toolType) ? input.toolType : defaultToolType(input.category);
+        if (toolType)
+            values['armoriq.tool.type'] = toolType;
+        if (toolName) {
+            values['armoriq.tool.name'] = toolName;
+            values['gen_ai.tool.name'] = toolName;
+            values['gen_ai.operation.name'] = 'execute_tool';
+            const callId = safeIdentifier(input.callId);
+            values['armoriq.tool.call_id'] = callId
+                ?? this.stableOperationCallId(input.category, toolName, planId, planItemOrdinal);
+            if (callId)
+                values['gen_ai.tool.call.id'] = callId;
+        }
+        const mcpServer = safeIdentifier(input.mcpServer);
+        if (mcpServer)
+            values['armoriq.mcp.server'] = mcpServer;
+        if (planId)
+            values['armoriq.intent_plan_id'] = planId;
+        const planItemId = safeIdentifier(input.planItemId)
+            ?? (planItemOrdinal === undefined ? undefined : `plan-step-${planItemOrdinal}`);
+        if (planItemId)
+            values['armoriq.intent_plan_item_id'] = planItemId;
+        if (planItemOrdinal !== undefined)
+            values['armoriq.intent_plan_item_ordinal'] = planItemOrdinal;
+        const executable = safeExecutable(input.executableName);
+        if (executable)
+            values['process.executable.name'] = executable;
+        Object.assign(values, terminalCommandAttributes(input.category, input));
+        const delegationId = safeIdentifier(input.delegationId);
+        if (delegationId)
+            values['armoriq.delegation.id'] = delegationId;
+        if (input.category === 'delegation' && isOperationOutcome(input.delegationOutcome))
+            values['armoriq.delegation.outcome'] = input.delegationOutcome;
+        if (input.category === 'approval' && isOperationOutcome(input.approvalOutcome))
+            values['armoriq.approval.outcome'] = input.approvalOutcome;
+        setSafeNumber(values, 'armoriq.approval.wait_ms', input.approvalWaitMs);
+        return this.beginChild(safeOperationName(input.name, input.category), values, timing);
+    }
+    async recordOperation(input) {
+        const handle = await this.beginOperationWithTiming(input, 'post_hoc');
+        await this.endOperation(handle, input);
+    }
+    async endOperation(handle, input) {
+        const values = {
+            'armoriq.operation.category': input.category,
+            ...terminalCommandAttributes(input.category, input),
+        };
+        const delegationId = safeIdentifier(input.delegationId);
+        if (delegationId)
+            values['armoriq.delegation.id'] = delegationId;
+        if (input.category === 'delegation' && isOperationOutcome(input.delegationOutcome))
+            values['armoriq.delegation.outcome'] = input.delegationOutcome;
+        if (input.category === 'approval' && isOperationOutcome(input.approvalOutcome))
+            values['armoriq.approval.outcome'] = input.approvalOutcome;
+        setSafeNumber(values, 'armoriq.approval.wait_ms', input.approvalWaitMs);
+        await this.endSpan(handle.span, operationStatus(input), values);
+    }
+    async endTool(handle, result) {
+        const durationMs = safeNonNegative(result.durationMs);
+        const terminalFacts = terminalCommandAttributes(commandCategoryForOperationName(handle.name), result);
+        if (handle.span && Object.prototype.hasOwnProperty.call(result, 'result')) {
+            this.queueToolContent(handle.span, { toolResult: result.result });
+        }
+        const pendingContent = this.takeToolContent(handle.span);
+        await this.endSpan(handle.span, result.outcome === 'success' ? 'ok' : result.outcome, {
+            ...(durationMs === undefined ? {} : { 'armoriq.duration_ms': durationMs }),
+            ...terminalFacts,
+            'armoriq.tool.outcome': result.outcome,
+            'armoriq.intent_plan_item_status': result.outcome === 'success'
+                ? 'succeeded'
+                : result.outcome === 'cancelled' || result.outcome === 'disconnected'
+                    ? 'skipped'
+                    : 'failed',
+            ...pendingContent,
+            ...(errorType(result.error) ? { 'error.type': errorType(result.error) } : {}),
+            ...(safeErrorSummary(result.error) ? { 'armoriq.observability.error.summary': safeErrorSummary(result.error) } : {}),
+        }, true);
+    }
+    async beginModel(model, content = {}) {
+        // Matches the Python SDK's span name (armoriq_sdk/observability/otel_semantics.py's
+        // SPAN_MODEL) and this span's own 'gen_ai.operation.name' attribute below —
+        // 'invoke' was never a defined OTel GenAI operation name.
+        const system = modelSystem(model);
+        return this.beginChild('gen_ai.chat', {
+            'gen_ai.operation.name': 'chat',
+            'gen_ai.request.model': model,
+            ...(system ? { 'gen_ai.system': system } : {}),
+            'gen_ai.input.messages': content.input,
+        });
+    }
+    async endModel(handle, values, error, terminalStatus, content = {}) {
+        const hasCost = Object.prototype.hasOwnProperty.call(values, 'gen_ai.usage.cost_usd');
+        const hasCostProvenance = Object.prototype.hasOwnProperty.call(values, 'armoriq.cost.provenance');
+        await this.endSpan(handle.span, terminalStatus ?? (error ? 'error' : 'ok'), {
+            ...values,
+            ...(hasCost && !hasCostProvenance ? { 'armoriq.cost.provenance': 'provider_reported' } : {}),
+            ...(Object.prototype.hasOwnProperty.call(content, 'output') ? { 'gen_ai.output.messages': content.output } : {}),
+            ...(errorType(error) ? { 'error.type': errorType(error) } : {}),
+            ...(safeErrorSummary(error) ? { 'armoriq.observability.error.summary': safeErrorSummary(error) } : {}),
+        });
+    }
+    /** End only the current plan and drain it; the request root remains usable. */
+    async flush(status = 'ok') {
+        if (this.closed || this.closing)
+            return;
+        await this.endSpan(this.plan, status);
+        this.plan = null;
+        this.planId = null;
+        await this.runtime.forceFlush();
+    }
+    async close(status = 'ok', taskOutcome, content = {}) {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closePromise = (async () => {
+            if (this.closed)
+                return;
+            this.closing = true;
+            await this.endSpan(this.plan, status);
+            this.plan = null;
+            this.planId = null;
+            await this.endSpan(this.root, status, {
+                'gen_ai.task.outcome': taskOutcome ?? TASK_OUTCOME[status],
+                // Always include the field. The projector renders a structured
+                // adapter-unavailable state instead of an invented empty response.
+                'gen_ai.output.messages': content.output,
+            });
+            this.root = null;
+            await this.runtime.close();
+            this.closed = true;
+        })().finally(() => {
+            this.pendingToolContent.clear();
+        }).catch(() => undefined);
+        return this.closePromise;
+    }
+    async beginChild(name, values, timingProvenance = 'measured') {
+        const root = (await this.beginRoot()).span;
+        const snapshot = await this.currentSnapshot();
+        const tracer = snapshot ? this.runtime.tracer(snapshot) : null;
+        if (!root || !tracer || !snapshot || this.closed || this.closing)
+            return { span: null, name };
+        try {
+            const parent = this.plan ?? root;
+            const attrs = this.runtime.safeAttributes(snapshot, {
+                'armoriq.timing.provenance': timingProvenance,
+                ...values,
+            }, this.attributeContext());
+            const span = tracer.startSpan(name, { attributes: attrs }, api_1.trace.setSpan(api_1.ROOT_CONTEXT, parent));
+            return { span, name };
+        }
+        catch {
+            return { span: null, name };
+        }
+    }
+    planItemAttributes(input) {
+        const itemOrdinal = canonicalPlanStepOrdinal(input.itemOrdinal);
+        if (itemOrdinal === undefined || !this.planId)
+            return {};
+        return {
+            'armoriq.intent_plan_id': this.planId,
+            'armoriq.intent_plan_item_id': `plan-step-${itemOrdinal}`,
+            'armoriq.intent_plan_item_ordinal': itemOrdinal,
+        };
+    }
+    stableOperationCallId(category, toolName, planId, itemOrdinal) {
+        const seed = [this.options.sessionId, planId ?? '', itemOrdinal ?? '', category, toolName].join('\u0000');
+        return `op-${(0, crypto_1.createHash)('sha256').update(seed).digest('hex').slice(0, 32)}`;
+    }
+    planItemOrdinalAttributes(itemOrdinal) {
+        const canonicalOrdinal = canonicalPlanStepOrdinal(itemOrdinal);
+        return canonicalOrdinal === undefined ? {} : { 'armoriq.intent_plan_item_ordinal': canonicalOrdinal };
+    }
+    async endSpan(span, status, values = {}, finalTool = false) {
+        if (!span)
+            return;
+        try {
+            const attrs = finalTool
+                ? await this.finalToolAttributes(values)
+                : await this.attributes(values);
+            span.setAttributes(attrs);
+            span.setStatus({ code: asStatus(status), message: status === 'ok' ? undefined : status });
+            span.end();
+        }
+        catch {
+            // Native telemetry stays fail-open.
+        }
+    }
+    async currentSnapshot() {
+        if (this.closed)
+            return null;
+        try {
+            this.snapshot = await this.runtime.policySnapshot();
+            return this.snapshot.captureMode === 'off' ? null : this.snapshot;
+        }
+        catch {
+            return null;
+        }
+    }
+    queueToolContent(span, content) {
+        try {
+            const buffered = (0, content_capture_1.bufferTelemetryContent)(content);
+            const previous = this.pendingToolContent.get(span);
+            if (!previous && this.pendingToolContent.size >= MAX_PENDING_TOOL_SPANS) {
+                const oldest = this.pendingToolContent.keys().next().value;
+                if (oldest)
+                    this.pendingToolContent.delete(oldest);
+            }
+            this.pendingToolContent.set(span, Object.freeze({
+                content: Object.freeze({ ...(previous?.content ?? {}), ...buffered.content }),
+                redacted: Boolean(previous?.redacted || buffered.redacted),
+                truncated: Boolean(previous?.truncated || buffered.truncated),
+            }));
+        }
+        catch {
+            // Never retain the original value when defensive sanitization fails.
+        }
+    }
+    takeToolContent(span) {
+        if (!span)
+            return {};
+        const pending = this.pendingToolContent.get(span);
+        this.pendingToolContent.delete(span);
+        if (!pending)
+            return {};
+        const values = {};
+        if (Object.prototype.hasOwnProperty.call(pending.content, 'toolArguments')) {
+            values['gen_ai.tool.call.arguments'] = pending.content.toolArguments;
+        }
+        if (Object.prototype.hasOwnProperty.call(pending.content, 'toolResult')) {
+            values['gen_ai.tool.call.result'] = pending.content.toolResult;
+        }
+        if (pending.redacted)
+            values['armoriq.observability.redaction.applied'] = true;
+        if (pending.truncated)
+            values['armoriq.observability.content.truncated'] = true;
+        return values;
+    }
+    async finalToolAttributes(values) {
+        try {
+            this.snapshot = await this.runtime.policySnapshot({ awaitFresh: true });
+            return this.runtime.finalToolAttributes(this.snapshot, values, this.attributeContext());
+        }
+        catch {
+            return {};
+        }
+    }
+    attributeContext() {
+        return { traceName: this.runtime.externalTraceName(this.options.traceName), sessionId: this.options.sessionId, userId: this.options.userId };
+    }
+}
+exports.OtelSession = OtelSession;
+const SAFE_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:/+-]{0,127}$/;
+const MAX_PENDING_TOOL_SPANS = 256;
+const SAFE_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const SAFE_EXECUTABLE = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
+const OPERATION_CATEGORIES = new Set(['tool', 'mcp', 'bash', 'cli', 'command', 'approval', 'delegation']);
+const OPERATION_OUTCOMES = new Set(['pending', 'approved', 'denied', 'expired', 'cancelled', 'failed']);
+const OPERATION_NAMES = new Set([
+    'tool.execute', 'armoriq.tool', 'mcp.execute', 'bash.execute', 'cli.execute', 'command.execute',
+    'approval.wait', 'delegation.wait', 'delegation.complete',
+]);
+function safeIdentifier(value) {
+    return typeof value === 'string' && (SAFE_IDENTIFIER.test(value) || SAFE_UUID.test(value)) ? value : undefined;
+}
+function safeExecutable(value) {
+    return typeof value === 'string' && SAFE_EXECUTABLE.test(value) ? value : undefined;
+}
+function isOperationCategory(value) {
+    return typeof value === 'string' && OPERATION_CATEGORIES.has(value);
+}
+function isOperationOutcome(value) {
+    return typeof value === 'string' && OPERATION_OUTCOMES.has(value);
+}
+function isToolType(value) {
+    return value === 'function' || value === 'mcp' || value === 'bash' || value === 'cli' || value === 'command';
+}
+function safeNonNegative(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.floor(value) : undefined;
+}
+function setSafeNumber(values, key, value) {
+    const number = safeNonNegative(value);
+    if (number !== undefined)
+        values[key] = number;
+}
+function setSafeCounter(values, key, value) {
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
+        values[key] = value;
+}
+function setSafeBoolean(values, key, value) {
+    if (typeof value === 'boolean')
+        values[key] = value;
+}
+function terminalCommandAttributes(category, facts) {
+    const values = {};
+    if (category !== 'bash' && category !== 'cli' && category !== 'command')
+        return values;
+    setSafeCounter(values, 'armoriq.command.exit_code', facts.exitCode);
+    setSafeCounter(values, 'armoriq.execution.retry_count', facts.retryCount);
+    setSafeCounter(values, 'armoriq.output.stdout_bytes', facts.stdoutBytes);
+    setSafeCounter(values, 'armoriq.output.stderr_bytes', facts.stderrBytes);
+    setSafeBoolean(values, 'armoriq.execution.timeout', facts.timeout);
+    setSafeBoolean(values, 'armoriq.execution.killed', facts.killed);
+    setSafeBoolean(values, 'armoriq.output.truncated', facts.truncated);
+    return values;
+}
+function commandCategoryForOperationName(value) {
+    if (value === 'bash.execute')
+        return 'bash';
+    if (value === 'cli.execute')
+        return 'cli';
+    return value === 'command.execute' ? 'command' : undefined;
+}
+function defaultToolType(category) {
+    if (category === 'tool')
+        return 'function';
+    return category === 'mcp' || category === 'bash' || category === 'cli' || category === 'command' ? category : undefined;
+}
+function defaultOperationName(category) {
+    return category === 'approval' || category === 'delegation' ? `${category}.wait` : `${category}.execute`;
+}
+function safeOperationName(value, category) {
+    return typeof value === 'string' && OPERATION_NAMES.has(value)
+        ? value
+        : defaultOperationName(category);
+}
+function operationStatus(input) {
+    const outcome = input.category === 'approval'
+        ? input.approvalOutcome
+        : input.category === 'delegation'
+            ? input.delegationOutcome
+            : undefined;
+    if (outcome === 'failed')
+        return 'error';
+    if (outcome === 'denied')
+        return 'denied';
+    if (outcome === 'cancelled')
+        return 'cancelled';
+    if (outcome === 'expired')
+        return 'timeout';
+    if (input.category === 'bash' || input.category === 'cli' || input.category === 'command') {
+        if (input.timeout === true)
+            return 'timeout';
+        if (input.killed === true)
+            return 'cancelled';
+        if (typeof input.exitCode === 'number' && Number.isSafeInteger(input.exitCode) && input.exitCode > 0)
+            return 'error';
+    }
+    if (input.operationOutcome === 'failed')
+        return 'error';
+    if (input.operationOutcome === 'cancelled')
+        return 'cancelled';
+    if (input.operationOutcome === 'timeout')
+        return 'timeout';
+    if (input.operationOutcome === 'disconnected')
+        return 'disconnected';
+    return 'ok';
+}
+//# sourceMappingURL=otel-session.js.map