@runtypelabs/flue-otel 0.5.4 → 0.5.6

package/dist/index.d.cts

@@ -1,49 +1,49 @@
-import { Tracer } from '@opentelemetry/api';
-
+import { Tracer } from "@opentelemetry/api";
+//#region src/flue-types.d.ts
 /** Correlation fields stamped onto every delivered observation. */
 interface FlueEventEnvelope {
-    /** Durable event-format version. `3` on both supported lines. */
-    v?: number;
-    eventIndex?: number;
-    timestamp?: string;
-    instanceId?: string;
-    submissionId?: string;
-    agentName?: string;
-    conversationId?: string;
-    session?: string;
-    parentSession?: string;
-    taskId?: string;
-    harness?: string;
-    operationId?: string;
-    turnId?: string;
+  /** Durable event-format version. `3` on both supported lines. */
+  v?: number;
+  eventIndex?: number;
+  timestamp?: string;
+  instanceId?: string;
+  submissionId?: string;
+  agentName?: string;
+  conversationId?: string;
+  session?: string;
+  parentSession?: string;
+  taskId?: string;
+  harness?: string;
+  operationId?: string;
+  turnId?: string;
 }
 /** Token counts and cost for one model turn. Byte-identical on both lines. */
 interface FluePromptUsage {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  totalTokens: number;
+  cost?: {
     input: number;
     output: number;
     cacheRead: number;
     cacheWrite: number;
-    totalTokens: number;
-    cost?: {
-        input: number;
-        output: number;
-        cacheRead: number;
-        cacheWrite: number;
-        total: number;
-    };
+    total: number;
+  };
 }
 /** The non-content half of a model request. */
 interface FlueModelRequestInfo {
-    providerId?: string;
-    providerName?: string;
-    requestedModel?: string;
-    api?: string;
-    serverAddress?: string;
-    serverPort?: number;
-    reasoningLevel?: string;
-    maxTokens?: number;
-    temperature?: number;
-    contextCompacted?: true;
+  providerId?: string;
+  providerName?: string;
+  requestedModel?: string;
+  api?: string;
+  serverAddress?: string;
+  serverPort?: number;
+  reasoningLevel?: string;
+  maxTokens?: number;
+  temperature?: number;
+  contextCompacted?: true;
 }
 /**
  * The request's payload half. `tools` is read for its PRESENCE only (`runtype.tools.reported`).
@@ -51,41 +51,41 @@ interface FlueModelRequestInfo {
  * byte-identical on both lines, read only when message content is opted in — see `messages.ts`.
  */
 interface FlueModelRequestInput {
-    systemPrompt?: string;
-    messages?: unknown[];
-    tools?: unknown[];
+  systemPrompt?: string;
+  messages?: unknown[];
+  tools?: unknown[];
 }
 interface FlueModelRequest extends FlueModelRequestInfo {
-    input?: FlueModelRequestInput;
+  input?: FlueModelRequestInput;
 }
 interface FlueModelResponse {
-    responseId?: string;
-    responseModel?: string;
-    /** The assistant message this turn produced, in Flue's normalized `LlmAssistantMessage` shape. */
-    output?: unknown;
-    usage?: FluePromptUsage;
-    finishReason?: string;
-    /** 2.x only. The provider's raw finish value before normalization. */
-    providerFinishReason?: string;
-    /**
-     * The response's own gateway log id (e.g. Cloudflare AI Gateway's
-     * `cf-aig-log-id`), for correlating a specific turn with its entry in the
-     * gateway dashboard. Telemetry only — present only when the provider records
-     * one. The Workers AI provider attaches it today.
-     */
-    gatewayLogId?: string;
-    error?: FlueErrorInfo;
+  responseId?: string;
+  responseModel?: string;
+  /** The assistant message this turn produced, in Flue's normalized `LlmAssistantMessage` shape. */
+  output?: unknown;
+  usage?: FluePromptUsage;
+  finishReason?: string;
+  /** 2.x only. The provider's raw finish value before normalization. */
+  providerFinishReason?: string;
+  /**
+   * The response's own gateway log id (e.g. Cloudflare AI Gateway's
+   * `cf-aig-log-id`), for correlating a specific turn with its entry in the
+   * gateway dashboard. Telemetry only — present only when the provider records
+   * one. The Workers AI provider attaches it today.
+   */
+  gatewayLogId?: string;
+  error?: FlueErrorInfo;
 }
 /**
  * Classified error details. stack is described but never read or exported because it can expose
  * deployment paths.
  */
 interface FlueErrorInfo {
-    type?: string;
-    name?: string;
-    message?: string;
-    stack?: string;
-    meta?: Record<string, unknown>;
+  type?: string;
+  name?: string;
+  message?: string;
+  stack?: string;
+  meta?: Record<string, unknown>;
 }
 /** 1.x-only implementation-class axis; absent on 2.x. */
 type FlueToolSemanticType = 'function' | 'extension' | 'datastore';
@@ -96,10 +96,10 @@ type FlueToolOrigin = 'model' | 'caller' | 'framework' | 'adapter';
  * `toolType` exists only on 1.x, which is what `compat.ts` probes for.
  */
 interface FlueObservationDetail {
-    origin?: FlueToolOrigin;
-    toolType?: FlueToolSemanticType;
-    toolCallId?: string;
-    errorInfo?: FlueErrorInfo;
+  origin?: FlueToolOrigin;
+  toolType?: FlueToolSemanticType;
+  toolCallId?: string;
+  errorInfo?: FlueErrorInfo;
 }
 /**
  * The event variants this package acts on. Every other variant Flue emits is
@@ -107,69 +107,69 @@ interface FlueObservationDetail {
  * through the projection's switch untouched.
  */
 type FlueEventVariant = {
-    type: 'operation_start';
-    operationId: string;
-    operationKind: string;
+  type: 'operation_start';
+  operationId: string;
+  operationKind: string;
 } | {
-    type: 'operation';
-    operationId: string;
-    operationKind: string;
-    durationMs?: number;
-    isError?: boolean;
-    error?: unknown;
-    usage?: FluePromptUsage;
+  type: 'operation';
+  operationId: string;
+  operationKind: string;
+  durationMs?: number;
+  isError?: boolean;
+  error?: unknown;
+  usage?: FluePromptUsage;
 } | {
-    type: 'task_start';
-    taskId: string;
-    prompt?: string;
-    agent?: string;
+  type: 'task_start';
+  taskId: string;
+  prompt?: string;
+  agent?: string;
 } | {
-    type: 'task';
-    taskId: string;
-    agent?: string;
-    isError?: boolean;
-    result?: unknown;
+  type: 'task';
+  taskId: string;
+  agent?: string;
+  isError?: boolean;
+  result?: unknown;
 } | {
-    type: 'compaction_start';
-    reason?: string;
-    estimatedTokens?: number;
+  type: 'compaction_start';
+  reason?: string;
+  estimatedTokens?: number;
 } | {
-    type: 'compaction';
-    isError?: boolean;
-    error?: unknown;
-    usage?: FluePromptUsage;
+  type: 'compaction';
+  isError?: boolean;
+  error?: unknown;
+  usage?: FluePromptUsage;
 } | {
-    type: 'turn_request';
-    turnId: string;
-    purpose?: string;
-    request: FlueModelRequest;
+  type: 'turn_request';
+  turnId: string;
+  purpose?: string;
+  request: FlueModelRequest;
 } | {
-    type: 'turn';
-    turnId: string;
-    purpose?: string;
-    durationMs?: number;
-    request?: FlueModelRequestInfo;
-    response: FlueModelResponse;
-    isError?: boolean;
+  type: 'turn';
+  turnId: string;
+  purpose?: string;
+  durationMs?: number;
+  request?: FlueModelRequestInfo;
+  response: FlueModelResponse;
+  isError?: boolean;
 } | {
-    type: 'tool_start';
-    toolName: string;
-    toolCallId: string;
-    args?: unknown;
+  type: 'tool_start';
+  toolName: string;
+  toolCallId: string;
+  args?: unknown;
 } | {
-    type: 'tool';
-    toolName: string;
-    toolCallId: string;
-    isError?: boolean;
-    result?: unknown;
-    effectiveResult?: unknown;
-    durationMs?: number;
+  type: 'tool';
+  toolName: string;
+  toolCallId: string;
+  isError?: boolean;
+  result?: unknown;
+  effectiveResult?: unknown;
+  durationMs?: number;
 } | {
-    type: 'submission_settled';
-    submissionId: string;
-    outcome: string;
+  type: 'submission_settled';
+  submissionId: string;
+  outcome: string;
 } | {
-    type: string;
+  type: string;
 };
 /** One delivered observation: an event, its envelope, and its detail sidecar. */
 type FlueObservation = FlueEventVariant & FlueEventEnvelope & FlueObservationDetail;
@@ -178,50 +178,50 @@ type FlueObservation = FlueEventVariant & FlueEventEnvelope & FlueObservationDet
  * matters here — the fields this package needs all live on the envelope.
  */
 interface FlueEventContext {
-    readonly id?: string;
-    readonly agentName?: string;
+  readonly id?: string;
+  readonly agentName?: string;
 }
 /** W3C trace context offered by the host on a detached execution. */
 interface FlueTraceCarrier {
-    traceparent: string;
-    tracestate?: string;
+  traceparent: string;
+  tracestate?: string;
 }
 /**
  * The operation the interceptor wraps. `coordinator` exists on 2.x only; the
  * open arm makes an unknown future kind fall through rather than crash.
  */
 type FlueExecutionOperation = {
-    type: 'agent';
-    operationId: string;
-    operationKind?: string;
+  type: 'agent';
+  operationId: string;
+  operationKind?: string;
 } | {
-    type: 'model';
-    turnId: string;
+  type: 'model';
+  turnId: string;
 } | {
-    type: 'tool';
-    toolCallId: string;
-    toolName?: string;
+  type: 'tool';
+  toolCallId: string;
+  toolName?: string;
 } | {
-    type: 'task';
-    taskId: string;
+  type: 'task';
+  taskId: string;
 } | {
-    type: 'coordinator';
-    phase?: string;
+  type: 'coordinator';
+  phase?: string;
 } | {
-    type: string;
+  type: string;
 };
 interface FlueExecutionContext {
-    eventContext?: FlueEventContext;
-    instanceId?: string;
-    submissionId?: string;
-    agentName?: string;
-    conversationId?: string;
-    harness?: string;
-    session?: string;
-    operationId?: string;
-    turnId?: string;
-    taskId?: string;
-    traceCarrier?: FlueTraceCarrier;
+  eventContext?: FlueEventContext;
+  instanceId?: string;
+  submissionId?: string;
+  agentName?: string;
+  conversationId?: string;
+  harness?: string;
+  session?: string;
+  operationId?: string;
+  turnId?: string;
+  taskId?: string;
+  traceCarrier?: FlueTraceCarrier;
 }
 type FlueObservationSubscriber = (observation: FlueObservation, ctx: FlueEventContext) => void | Promise<void>;
 type FlueExecutionInterceptor = <T>(operation: FlueExecutionOperation, ctx: FlueExecutionContext, next: () => Promise<T>) => Promise<T>;
@@ -231,67 +231,69 @@ type FlueExecutionInterceptor = <T>(operation: FlueExecutionOperation, ctx: Flue
  * one of these.
  */
 interface FlueInstrumentation {
-    key?: symbol;
-    observe: FlueObservationSubscriber;
-    interceptor: FlueExecutionInterceptor;
-    dispose(): void | Promise<void>;
+  key?: symbol;
+  observe: FlueObservationSubscriber;
+  interceptor: FlueExecutionInterceptor;
+  dispose(): void | Promise<void>;
 }
-
+//#endregion
+//#region src/messages.d.ts
 /**
  * One semconv structured message, the element shape of `gen_ai.input.messages`
  * and `gen_ai.output.messages`. Text parts only; see the README's content section.
  */
 interface FlueContentMessage {
-    role: 'system' | 'user' | 'assistant';
-    parts: Array<{
-        type: 'text';
-        content: string;
-    }>;
+  role: 'system' | 'user' | 'assistant';
+  parts: Array<{
+    type: 'text';
+    content: string;
+  }>;
 }
-
+//#endregion
+//#region src/content.d.ts
 /**
  * What to emit. Every switch defaults to ON, so `{}` and an absent option both
  * emit everything; set a switch to `false` to drop that one kind, or pass
  * `content: false` to emit no content at all.
  */
 interface FlueContentOptions {
-    /**
-     * Emit the call's arguments as `gen_ai.tool.call.arguments` when the
-     * `execute_tool` span opens. Read from Flue's stable `tool_start.args`.
-     */
-    toolArguments?: boolean;
-    /**
-     * Emit successful tool results when the span closes; failed-tool payloads stay off the wire. Prefer
-     * effectiveResult when present, including undefined; otherwise use result.
-     */
-    toolResults?: boolean;
-    /**
-     * Emit the conversation the run was given as `gen_ai.input.messages` on the `invoke_agent` span:
-     * text-only user and assistant rows from Flue's normalized `turn_request.request.input.messages`,
-     * plus any user message a later turn's history carries, minus the run's own assistant rows.
-     */
-    inputMessages?: boolean;
-    /**
-     * Emit the run's final assistant text as `gen_ai.output.messages` on the `invoke_agent` span, read
-     * from the last agent turn whose `turn.response.output` carried text.
-     */
-    outputMessages?: boolean;
-    /**
-     * Emit the system prompt as `gen_ai.system_instructions` on the `invoke_agent` span, read from
-     * `turn_request.request.input.systemPrompt`. Usually the largest value a run carries; mind `maxChars`.
-     */
-    systemInstructions?: boolean;
-    /**
-     * Per-value UTF-16 code-unit ceiling, including the truncation marker. Defaults to
-     * DEFAULT_CONTENT_MAX_CHARS and clamps to INGEST_CONTENT_ATTRIBUTE_CEILING, above which ingest drops
-     * the whole attribute.
-     */
-    maxChars?: number;
-    /**
-     * Redact the raw value before encoding or truncation. Returning undefined or throwing suppresses only
-     * this attribute, not the span.
-     */
-    redact?: (value: unknown, context: FlueContentRedactContext) => unknown;
+  /**
+   * Emit the call's arguments as `gen_ai.tool.call.arguments` when the
+   * `execute_tool` span opens. Read from Flue's stable `tool_start.args`.
+   */
+  toolArguments?: boolean;
+  /**
+   * Emit successful tool results when the span closes; failed-tool payloads stay off the wire. Prefer
+   * effectiveResult when present, including undefined; otherwise use result.
+   */
+  toolResults?: boolean;
+  /**
+   * Emit the conversation the run was given as `gen_ai.input.messages` on the `invoke_agent` span:
+   * text-only user and assistant rows from Flue's normalized `turn_request.request.input.messages`,
+   * plus any user message a later turn's history carries, minus the run's own assistant rows.
+   */
+  inputMessages?: boolean;
+  /**
+   * Emit the run's final assistant text as `gen_ai.output.messages` on the `invoke_agent` span, read
+   * from the last agent turn whose `turn.response.output` carried text.
+   */
+  outputMessages?: boolean;
+  /**
+   * Emit the system prompt as `gen_ai.system_instructions` on the `invoke_agent` span, read from
+   * `turn_request.request.input.systemPrompt`. Usually the largest value a run carries; mind `maxChars`.
+   */
+  systemInstructions?: boolean;
+  /**
+   * Per-value UTF-16 code-unit ceiling, including the truncation marker. Defaults to
+   * DEFAULT_CONTENT_MAX_CHARS and clamps to INGEST_CONTENT_ATTRIBUTE_CEILING, above which ingest drops
+   * the whole attribute.
+   */
+  maxChars?: number;
+  /**
+   * Redact the raw value before encoding or truncation. Returning undefined or throwing suppresses only
+   * this attribute, not the span.
+   */
+  redact?: (value: unknown, context: FlueContentRedactContext) => unknown;
 }
 /**
  * What `redact` is looking at. Tool kinds receive the raw Flue payload; `input_messages` and
@@ -299,11 +301,11 @@ interface FlueContentOptions {
  * receives the prompt string.
  */
 type FlueContentRedactContext = {
-    kind: 'arguments' | 'result';
-    toolName: string;
+  kind: 'arguments' | 'result';
+  toolName: string;
 } | {
-    kind: 'input_messages' | 'output_messages' | 'system_instructions';
-    toolName?: undefined;
+  kind: 'input_messages' | 'output_messages' | 'system_instructions';
+  toolName?: undefined;
 };
 type FlueMessageContentKind = 'input_messages' | 'output_messages';
 /**
@@ -312,73 +314,74 @@ type FlueMessageContentKind = 'input_messages' | 'output_messages';
  * arguments plus result on one span sit well inside ingest's 384 KiB per-span
  * ceiling — a customer who raises it should know that ceiling exists.
  */
-declare const DEFAULT_CONTENT_MAX_CHARS = 65536;
+export declare const DEFAULT_CONTENT_MAX_CHARS = 65536;
 /**
  * Inline the private ingest per-attribute ceiling so npm installs need no private dependency.
  * tests/contract.test.ts pins equality.
  */
-declare const INGEST_CONTENT_ATTRIBUTE_CEILING = 262144;
+export declare const INGEST_CONTENT_ATTRIBUTE_CEILING = 262144;
 /** The resolved, always-complete policy the projection consults. */
 type FlueContentSetting = FlueContentOptions | false;
-
+//#endregion
+//#region src/projection.d.ts
 /** Attribute values OTLP can carry. Deliberately narrower than OTel's type. */
 type SpanAttributes = Record<string, string | number | boolean | string[]>;
 /** Where a span sits relative to the process boundary. */
 type ProjectedSpanKind = 'internal' | 'client';
 interface OpenSpanIntent {
-    kind: 'open';
-    /** Stable identity for the span; the driver keys its live-span map on it. */
-    ref: string;
-    name: string;
-    spanKind: ProjectedSpanKind;
-    /**
-     * The span this one nests under, when the projection knows it. Absent means
-     * "use whatever is active" — which, inside Flue's interceptor, is the
-     * enclosing span, so the driver's fallback repairs chains the correlation
-     * fields cannot express (a task nested inside another task, most notably).
-     */
-    parentRef?: string;
-    /** Flue's own event timestamp, ISO-8601. Spans stay on the runtime's clock. */
-    startTime?: string;
-    attributes: SpanAttributes;
-    /**
-     * Drop bookkeeping spans without a parent: ingest could otherwise treat a host shell or compaction
-     * span as a phantom run envelope.
-     */
-    requiresParent?: boolean;
+  kind: 'open';
+  /** Stable identity for the span; the driver keys its live-span map on it. */
+  ref: string;
+  name: string;
+  spanKind: ProjectedSpanKind;
+  /**
+   * The span this one nests under, when the projection knows it. Absent means
+   * "use whatever is active" — which, inside Flue's interceptor, is the
+   * enclosing span, so the driver's fallback repairs chains the correlation
+   * fields cannot express (a task nested inside another task, most notably).
+   */
+  parentRef?: string;
+  /** Flue's own event timestamp, ISO-8601. Spans stay on the runtime's clock. */
+  startTime?: string;
+  attributes: SpanAttributes;
+  /**
+   * Drop bookkeeping spans without a parent: ingest could otherwise treat a host shell or compaction
+   * span as a phantom run envelope.
+   */
+  requiresParent?: boolean;
 }
 interface UpdateSpanIntent {
-    kind: 'update';
-    ref: string;
-    attributes: SpanAttributes;
+  kind: 'update';
+  ref: string;
+  attributes: SpanAttributes;
 }
 interface CloseSpanIntent {
-    kind: 'close';
-    ref: string;
-    endTime?: string;
-    /**
-     * Failure type and exception class only. Error messages and stacks can expose prompts or deployment
-     * paths and are excluded even when tool-content export is enabled.
-     */
-    error?: {
-        type: string;
-        exceptionType?: string;
-    };
+  kind: 'close';
+  ref: string;
+  endTime?: string;
+  /**
+   * Failure type and exception class only. Error messages and stacks can expose prompts or deployment
+   * paths and are excluded even when tool-content export is enabled.
+   */
+  error?: {
+    type: string;
+    exceptionType?: string;
+  };
 }
 type SpanIntent = OpenSpanIntent | UpdateSpanIntent | CloseSpanIntent;
 interface FlueProjectionOptions {
-    /**
-     * Agent id by Flue agent name, stamped on the envelope. Resource attribution takes precedence;
-     * delegated subagents are not separate executions. Use runtypeFlueResourceAttributes for single-agent
-     * processes.
-     */
-    agents?: Record<string, string>;
-    /**
-     * Content: tool arguments and results on `execute_tool` spans, messages and the system prompt on
-     * the `invoke_agent` envelope. All ON by default; set a switch to `false` to drop one kind, or
-     * `content: false` for none. See {@link FlueContentOptions} for the size ceiling and redaction hook.
-     */
-    content?: FlueContentSetting;
+  /**
+   * Agent id by Flue agent name, stamped on the envelope. Resource attribution takes precedence;
+   * delegated subagents are not separate executions. Use runtypeFlueResourceAttributes for single-agent
+   * processes.
+   */
+  agents?: Record<string, string>;
+  /**
+   * Content: tool arguments and results on `execute_tool` spans, messages and the system prompt on
+   * the `invoke_agent` envelope. All ON by default; set a switch to `false` to drop one kind, or
+   * `content: false` for none. See {@link FlueContentOptions} for the size ceiling and redaction hook.
+   */
+  content?: FlueContentSetting;
 }
 /**
  * Resource attributes for the customer's `Resource`. Exported rather than set
@@ -386,74 +389,75 @@ interface FlueProjectionOptions {
  * processor, the exporter and the resource are all the application's, and a
  * library that reached into them would fight whatever the customer already runs.
  */
-declare function runtypeFlueResourceAttributes(resource?: {
-    agentId?: string | null;
+export declare function runtypeFlueResourceAttributes(resource?: {
+  agentId?: string | null;
 }): SpanAttributes;
-
+//#endregion
+//#region src/semconv.d.ts
 /**
  * GenAI semantic-convention attribute names. Mirrors the subset of
  * `packages/shared/src/gen-ai-semconv.ts` this instrumentation can populate
  * from Flue's STABLE observation plane.
  */
-declare const GEN_AI: {
-    readonly operationName: "gen_ai.operation.name";
-    readonly providerName: "gen_ai.provider.name";
-    readonly agentName: "gen_ai.agent.name";
-    readonly conversationId: "gen_ai.conversation.id";
-    readonly requestModel: "gen_ai.request.model";
-    readonly responseModel: "gen_ai.response.model";
-    readonly responseId: "gen_ai.response.id";
-    readonly requestStream: "gen_ai.request.stream";
-    readonly reasoningLevel: "gen_ai.request.reasoning.level";
-    readonly maxTokens: "gen_ai.request.max_tokens";
-    readonly temperature: "gen_ai.request.temperature";
-    readonly finishReasons: "gen_ai.response.finish_reasons";
-    readonly usageInputTokens: "gen_ai.usage.input_tokens";
-    readonly usageOutputTokens: "gen_ai.usage.output_tokens";
-    readonly usageCacheReadTokens: "gen_ai.usage.cache_read.input_tokens";
-    readonly usageCacheCreationTokens: "gen_ai.usage.cache_creation.input_tokens";
-    readonly toolName: "gen_ai.tool.name";
-    readonly toolCallId: "gen_ai.tool.call.id";
-    readonly toolType: "gen_ai.tool.type";
-    readonly conversationCompacted: "gen_ai.conversation.compacted";
-    readonly errorType: "error.type";
-    readonly serverAddress: "server.address";
-    readonly serverPort: "server.port";
+export declare const GEN_AI: {
+  readonly operationName: 'gen_ai.operation.name';
+  readonly providerName: 'gen_ai.provider.name';
+  readonly agentName: 'gen_ai.agent.name';
+  readonly conversationId: 'gen_ai.conversation.id';
+  readonly requestModel: 'gen_ai.request.model';
+  readonly responseModel: 'gen_ai.response.model';
+  readonly responseId: 'gen_ai.response.id';
+  readonly requestStream: 'gen_ai.request.stream';
+  readonly reasoningLevel: 'gen_ai.request.reasoning.level';
+  readonly maxTokens: 'gen_ai.request.max_tokens';
+  readonly temperature: 'gen_ai.request.temperature';
+  readonly finishReasons: 'gen_ai.response.finish_reasons';
+  readonly usageInputTokens: 'gen_ai.usage.input_tokens';
+  readonly usageOutputTokens: 'gen_ai.usage.output_tokens';
+  readonly usageCacheReadTokens: 'gen_ai.usage.cache_read.input_tokens';
+  readonly usageCacheCreationTokens: 'gen_ai.usage.cache_creation.input_tokens';
+  readonly toolName: 'gen_ai.tool.name';
+  readonly toolCallId: 'gen_ai.tool.call.id';
+  readonly toolType: 'gen_ai.tool.type';
+  readonly conversationCompacted: 'gen_ai.conversation.compacted';
+  readonly errorType: 'error.type';
+  readonly serverAddress: 'server.address';
+  readonly serverPort: 'server.port';
 };
 /**
  * Content attribute names, separate from the structural GEN_AI set. Tool content goes on
  * `execute_tool` spans, message content on the `invoke_agent` envelope; each kind can be switched
  * off through the content options. Mirrored in shared ingest semconv.
  */
-declare const GEN_AI_CONTENT: {
-    readonly inputMessages: "gen_ai.input.messages";
-    readonly outputMessages: "gen_ai.output.messages";
-    readonly systemInstructions: "gen_ai.system_instructions";
-    readonly toolCallArguments: "gen_ai.tool.call.arguments";
-    readonly toolCallResult: "gen_ai.tool.call.result";
+export declare const GEN_AI_CONTENT: {
+  readonly inputMessages: 'gen_ai.input.messages';
+  readonly outputMessages: 'gen_ai.output.messages';
+  readonly systemInstructions: 'gen_ai.system_instructions';
+  readonly toolCallArguments: 'gen_ai.tool.call.arguments';
+  readonly toolCallResult: 'gen_ai.tool.call.result';
 };
 /**
  * Runtype's extension vocabulary. Placement is part of the contract and the
  * reader enforces it — see the `RUNTYPE_ATTRIBUTES` doc block in the shared
  * module for which level each name belongs on.
  */
-declare const RUNTYPE: {
-    readonly agentId: "runtype.agent.id";
-    readonly schemaVersion: "runtype.schema.version";
-    readonly adapterName: "runtype.adapter.name";
-    readonly adapterVersion: "runtype.adapter.version";
-    readonly executionId: "runtype.execution.id";
-    readonly iteration: "runtype.iteration";
-    readonly iterations: "runtype.iterations";
-    readonly totalCost: "runtype.total_cost";
-    readonly stopReason: "runtype.stop_reason";
-    readonly toolsReported: "runtype.tools.reported";
-    readonly toolType: "runtype.tool.type";
-    readonly turnId: "runtype.turn.id";
-    readonly turnIndex: "runtype.turn.index";
-    readonly providerFinishReason: "runtype.provider.finish_reason";
-    readonly providerServiceTier: "runtype.provider.service_tier";
-    readonly gatewayLogId: "runtype.gateway.log_id";
+export declare const RUNTYPE: {
+  readonly agentId: 'runtype.agent.id';
+  readonly schemaVersion: 'runtype.schema.version';
+  readonly adapterName: 'runtype.adapter.name';
+  readonly adapterVersion: 'runtype.adapter.version';
+  readonly executionId: 'runtype.execution.id';
+  readonly iteration: 'runtype.iteration';
+  readonly iterations: 'runtype.iterations';
+  readonly totalCost: 'runtype.total_cost';
+  readonly stopReason: 'runtype.stop_reason';
+  readonly toolsReported: 'runtype.tools.reported';
+  readonly toolType: 'runtype.tool.type';
+  readonly turnId: 'runtype.turn.id';
+  readonly turnIndex: 'runtype.turn.index';
+  readonly providerFinishReason: 'runtype.provider.finish_reason';
+  readonly providerServiceTier: 'runtype.provider.service_tier';
+  readonly gatewayLogId: 'runtype.gateway.log_id';
 };
 /**
  * `runtype.tool.type` values — the closed domain that drives display and
@@ -461,7 +465,7 @@ declare const RUNTYPE: {
  * members this instrumentation can honestly assert are ever emitted (see
  * `projection.ts`).
  */
-declare const RUNTYPE_TOOL_TYPES: readonly ["flow", "mcp", "builtin", "custom", "external", "advisor", "subagent", "local", "data_connection", "search"];
+export declare const RUNTYPE_TOOL_TYPES: readonly ['flow', 'mcp', 'builtin', 'custom', 'external', 'advisor', 'subagent', 'local', 'data_connection', 'search'];
 type RuntypeToolType = (typeof RUNTYPE_TOOL_TYPES)[number];
 /**
  * Terminal stop reasons, in Runtype's own wire vocabulary
@@ -469,35 +473,37 @@ type RuntypeToolType = (typeof RUNTYPE_TOOL_TYPES)[number];
  * `runtype.stop_reason` is written to the run row verbatim, so an invented
  * value would render in the dashboard as a real fact.
  */
-declare const RUNTYPE_STOP_REASONS: readonly ["end_turn", "max_tool_calls", "length", "content_filter", "error", "unknown"];
+export declare const RUNTYPE_STOP_REASONS: readonly ['end_turn', 'max_tool_calls', 'length', 'content_filter', 'error', 'unknown'];
 type RuntypeStopReason = (typeof RUNTYPE_STOP_REASONS)[number];
 /** The version of the `runtype.*` vocabulary this package was built against. */
-declare const RUNTYPE_SCHEMA_VERSION = "1";
+export declare const RUNTYPE_SCHEMA_VERSION = "1";
 /** What this package reports itself as in `runtype.adapter.name`. */
-declare const ADAPTER_NAME = "@runtypelabs/flue-otel";
+export declare const ADAPTER_NAME = "@runtypelabs/flue-otel";
 /** What this package reports itself as in `runtype.adapter.version`. */
-declare const ADAPTER_VERSION: string;
-
+export declare const ADAPTER_VERSION: string;
+//#endregion
+//#region src/index.d.ts
 /**
  * The instrumentation key. Distinct from stock's
  * `Symbol.for('@flue/opentelemetry')` so `instrument()` treats the two as
  * different subscribers and composes them rather than replacing one.
  */
-declare const RUNTYPE_FLUE_INSTRUMENTATION_KEY: unique symbol;
-interface RuntypeFlueInstrumentationOptions extends FlueProjectionOptions {
-    /**
-     * Where spans are written. Defaults to the globally registered provider's
-     * tracer, which is what an application that called `setGlobalTracerProvider`
-     * (or `NodeSDK.start()`) already has. Pass one explicitly to route Runtype's
-     * spans through a provider separate from the rest of the process.
-     */
-    tracer?: Tracer;
+export declare const RUNTYPE_FLUE_INSTRUMENTATION_KEY: unique symbol;
+export interface RuntypeFlueInstrumentationOptions extends FlueProjectionOptions {
+  /**
+   * Where spans are written. Defaults to the globally registered provider's
+   * tracer, which is what an application that called `setGlobalTracerProvider`
+   * (or `NodeSDK.start()`) already has. Pass one explicitly to route Runtype's
+   * spans through a provider separate from the rest of the process.
+   */
+  tracer?: Tracer;
 }
 /**
  * Build an observe/interceptor pair for Flue's instrument(). The interceptor activates spans and joins
  * dispatched trace carriers. Configure the OTel SDK externally, and point only one instrumentation at
  * Runtype to avoid double counting.
  */
-declare function createRuntypeFlueInstrumentation(options?: RuntypeFlueInstrumentationOptions): FlueInstrumentation;
-
-export { ADAPTER_NAME, ADAPTER_VERSION, DEFAULT_CONTENT_MAX_CHARS, type FlueContentMessage, type FlueContentOptions, type FlueContentRedactContext, type FlueContentSetting, type FlueInstrumentation, type FlueMessageContentKind, type FlueProjectionOptions, GEN_AI, GEN_AI_CONTENT, INGEST_CONTENT_ATTRIBUTE_CEILING, RUNTYPE, RUNTYPE_FLUE_INSTRUMENTATION_KEY, RUNTYPE_SCHEMA_VERSION, RUNTYPE_STOP_REASONS, RUNTYPE_TOOL_TYPES, type RuntypeFlueInstrumentationOptions, type RuntypeStopReason, type RuntypeToolType, type SpanAttributes, type SpanIntent, createRuntypeFlueInstrumentation, runtypeFlueResourceAttributes };
+export declare function createRuntypeFlueInstrumentation(options?: RuntypeFlueInstrumentationOptions): FlueInstrumentation;
+//#endregion
+export type { FlueContentMessage, FlueContentOptions, FlueContentRedactContext, FlueContentSetting, FlueInstrumentation, FlueMessageContentKind, FlueProjectionOptions, RuntypeStopReason, RuntypeToolType, SpanAttributes, SpanIntent };
+export {}