Runtime

export interface PropagationContext {
  version: number
  rootUuid?: string
  parentUuid: string
  traceparent?: string
  tracestate?: string
}

export interface RuntimeRegistrationOwner {
  kind: RuntimeRegistrationOwnerKind
  pluginKind?: string
  componentOrdinal?: number
}

export interface RuntimeRegistrationIdentity {
  kind: RuntimeRegistrationKind
  localName: string
  effectiveName: string
  owner: RuntimeRegistrationOwner
}

export interface AtofExporterConfig {
  /** Sink type: `"file"` (default) or `"stream"`. */
  type?: string
  /** Output directory. Defaults to the current working directory. */
  outputDirectory?: string
  /** `"append"` (default) or `"overwrite"`. */
  mode?: string
  /** Output filename. Defaults to `nemo-relay-events-YYYY-MM-DD-HH.MM.SS.jsonl`. */
  filename?: string
  /** Stream endpoint URL. Required when `type` is `"stream"`. */
  url?: string
  /** `"http_post"` (default), `"websocket"`, or `"ndjson"`. */
  transport?: string
  /** Extra stream headers as string key/value pairs. */
  headers?: Json
  /** Header names mapped to environment variables that supply their values. */
  headerEnv?: Json
  /** Per-stream timeout in milliseconds. */
  timeoutMillis?: number
  /** Field name policy applied before sending stream events. */
  fieldNamePolicy?: string
}

export interface OpenTelemetryConfig {
  /** `"full"`, `"gen_ai"`, or `"openinference"`. */
  type: "full" | "gen_ai" | "openinference"
  /** `"http_binary"` (default) or `"grpc"`. */
  transport?: string
  /** OTLP endpoint, such as `http://localhost:4318/v1/traces`. */
  endpoint: string
  /** Extra exporter headers/metadata as string key/value pairs. */
  headers?: Json
  /** Header names mapped to environment variables resolved during subscriber activation. */
  headerEnv?: Record<string, string>
  /** Extra OpenTelemetry resource attributes as string key/value pairs. */
  resourceAttributes?: Json
  /** `service.name` resource attribute. Defaults to `"unknown_service"`. */
  serviceName?: string
  /** Optional `service.namespace` resource attribute. */
  serviceNamespace?: string
  /** Optional `service.version` resource attribute. */
  serviceVersion?: string
  /** Instrumentation scope name. Defaults to `"opentelemetry"`. */
  instrumentationScope?: string
  /** Export timeout in milliseconds. Defaults to `3000`. */
  timeoutMillis?: number
  /** Completed scope lineage retention in milliseconds as a `bigint`. Defaults to `60000`. */
  completedSpanContextTtlMillis?: bigint
  /** Mark projection for full and OpenInference exporters. Defaults to `"inherit"`. */
  markProjection?: "inherit" | "event" | "tool"
  /** Mark names excluded from full and OpenInference projections. */
  markExcludeNames?: Array<string>
  /** Attribute aliases for full and OpenInference projections. */
  attributeMappings?: Json
  /** Literal Event metadata prefixes copied to top-level OTLP attributes. */
  promoteMetadataPrefixes?: Array<string>
  /** Literal root-scope Event metadata prefixes copied to OTLP resource attributes. */
  promoteResourceMetadataPrefixes?: Array<string>
}

export interface OpenTelemetryFileSinkConfig {
  /** `"full"`, `"gen_ai"`, or `"openinference"`. */
  type: "full" | "gen_ai" | "openinference"
  /** Directory containing the output file. */
  outputDirectory: string
  /** Output filename. Defaults to a name derived from `format`. */
  filename?: string
  /** `"json_lines"` (default) or `"proto"`. */
  format?: "json_lines" | "proto"
  /** `"overwrite"` (default) or `"append"`. */
  mode?: "append" | "overwrite"
  /** Extra OpenTelemetry resource attributes as string key/value pairs. */
  resourceAttributes?: Json
  /** `service.name` resource attribute. Defaults to `"unknown_service"`. */
  serviceName?: string
  /** Optional `service.namespace` resource attribute. */
  serviceNamespace?: string
  /** Optional `service.version` resource attribute. */
  serviceVersion?: string
  /** Instrumentation scope name. Defaults to `"opentelemetry"`. */
  instrumentationScope?: string
  /** Completed scope lineage retention in milliseconds as a `bigint`. Defaults to `60000`. */
  completedSpanContextTtlMillis?: bigint
  /** Mark projection for full and OpenInference exporters. Defaults to `"inherit"`. */
  markProjection?: "inherit" | "event" | "tool"
  /** Mark names excluded from full and OpenInference projections. */
  markExcludeNames?: Array<string>
  /** Attribute aliases for full and OpenInference projections. */
  attributeMappings?: Json
  /** Literal Event metadata prefixes copied to top-level OTLP attributes. */
  promoteMetadataPrefixes?: Array<string>
  /** Literal root-scope Event metadata prefixes copied to OTLP resource attributes. */
  promoteResourceMetadataPrefixes?: Array<string>
}

export interface OpenTelemetryLogConfig {
  /** OTLP endpoint. Bare HTTP origins append `/v1/logs`. */
  endpoint: string
  /** `"http_binary"` (default) or `"grpc"`. */
  transport?: "http_binary" | "grpc"
  /** Extra exporter headers/metadata as string key/value pairs. */
  headers?: Record<string, string>
  /** Header names mapped to environment variables resolved during subscriber activation. */
  headerEnv?: Record<string, string>
  /** Extra OpenTelemetry resource attributes as string key/value pairs. */
  resourceAttributes?: Record<string, string>
  /** `service.name` resource attribute. Defaults to `"unknown_service"`. */
  serviceName?: string
  /** Optional `service.namespace` resource attribute. */
  serviceNamespace?: string
  /** Optional `service.version` resource attribute. */
  serviceVersion?: string
  /** Instrumentation scope name. Defaults to `"opentelemetry"`. */
  instrumentationScope?: string
  /** Export timeout in milliseconds. Defaults to `3000`. */
  timeoutMillis?: number
  /** Minimum severity exported. Defaults to `LogSeverity.Info`. */
  minimumSeverity?: LogSeverity
  /** Maximum queued log records. Defaults to `2048`. */
  maxQueueSize?: number
  /** Maximum records per export batch. Defaults to `512`. */
  maxExportBatchSize?: number
  /** Maximum delay before a partial batch is exported. Defaults to `1000`. */
  scheduledDelayMillis?: number
  /** Completed scope lineage retention in milliseconds as a `bigint`. Defaults to `60000`. */
  completedSpanContextTtlMillis?: bigint
}

export interface OpenTelemetryMetricConfig {
  /** OTLP endpoint. Bare HTTP origins append `/v1/metrics`. */
  endpoint: string
  /** `"http_binary"` (default) or `"grpc"`. */
  transport?: "http_binary" | "grpc"
  /** Extra exporter headers/metadata as string key/value pairs. */
  headers?: Record<string, string>
  /** Header names mapped to environment variables resolved during subscriber activation. */
  headerEnv?: Record<string, string>
  /** Extra OpenTelemetry resource attributes as string key/value pairs. */
  resourceAttributes?: Record<string, string>
  /** `service.name` resource attribute. Defaults to `"unknown_service"`. */
  serviceName?: string
  /** Optional `service.namespace` resource attribute. */
  serviceNamespace?: string
  /** Optional `service.version` resource attribute. */
  serviceVersion?: string
  /** Instrumentation scope name. Defaults to `"opentelemetry"`. */
  instrumentationScope?: string
  /** Export timeout in milliseconds. Defaults to `3000`. */
  timeoutMillis?: number
  /** Collection interval in milliseconds. Defaults to `60000`. */
  exportIntervalMillis?: number
  /** Preferred aggregation temporality. Defaults to cumulative. */
  temporality?: MetricTemporality
  /** Maximum number of retained instrument descriptors. Defaults to `256`. */
  maxInstruments?: number
  /** Maximum series cardinality per instrument. Defaults to `2000`. */
  cardinalityLimit?: number
}

export interface JsLlmCodecIdentity {
  kind: string
  id?: string
}

export interface DataSchema {
  name: string
  version: string
}

export interface MetricMeasurement {
  name: string
  kind: MetricKind
  valueType: MetricValueType
  value: number
  unit?: string
  description?: string
  attributes?: Json
  boundaries?: Array<number>
}

export interface ToolExecutionResult {
  result: Json
  annotation?: Json
}

export interface ToolExecutionContext {
  toolName: string
  args: Json
  toolCallId: string | null
}

export interface PendingMarkSpec {
  name: string
  category?: string | null
  categoryProfile?: Json
  data?: Json
  dataSchema?: { name: string; version: string } | null
  metadata?: Json
  severity?: 'trace' | 'debug' | 'info' | 'warn' | 'warning' | 'error' | null
}

export interface EventSanitizeFields {
  data?: Json
  categoryProfile?: Json
  metadata?: Json
}

export interface ResourceMeasurement<
  T extends number | bigint,
  U extends DurationUnit | CapacityUnit | DataUnit | BandwidthUnit | CpuUnit | UtilizationUnit | CountUnit,
> {
  value: T;
  unit: U;
}

export interface ResourceLimitEventCount {
  resource: 'cpu' | 'memory' | 'processes';
  event: 'throttled' | 'high' | 'maximum' | 'out_of_memory' | 'terminated';
  count: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
}

export interface AcceleratorDeviceMetrics {
  vendor: AcceleratorVendor;
  deviceIdentifier: string;
  deviceIndex: number | null;
  memoryUsed: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  computeUtilization: ResourceMeasurement<number, UtilizationUnit> | null;
}

export interface AcceleratorProcessMetrics {
  vendor: AcceleratorVendor;
  deviceIdentifier: string;
  deviceIndex: number | null;
  processId: number;
  memoryUsed: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  computeUtilization: ResourceMeasurement<number, UtilizationUnit> | null;
}

export interface FilesystemCapacityMetrics {
  path: string;
  totalCapacity: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  availableCapacity: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  freeCapacity: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
}

export interface CpuMetrics {
  userTime: ResourceMeasurement<ResourceNumeric, DurationUnit> | null;
  systemTime: ResourceMeasurement<ResourceNumeric, DurationUnit> | null;
  totalTime: ResourceMeasurement<ResourceNumeric, DurationUnit> | null;
  consumptionRate: ResourceMeasurement<number, CpuUnit> | null;
  throttledTime: ResourceMeasurement<ResourceNumeric, DurationUnit> | null;
  effectiveLimit: ResourceMeasurement<number, CpuUnit> | null;
  somePressureStallTime: ResourceMeasurement<ResourceNumeric, DurationUnit> | null;
  fullPressureStallTime: ResourceMeasurement<ResourceNumeric, DurationUnit> | null;
  limitEvents: ResourceLimitEventCount[];
}

export interface MemoryMetrics {
  systemUsed: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  systemTotal: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  systemAvailable: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  resident: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  private: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  physicalFootprint: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  virtualMemory: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  peakResident: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  limit: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  environmentAccounted: ResourceMeasurement<ResourceNumeric, CapacityUnit> | null;
  somePressureStallTime: ResourceMeasurement<ResourceNumeric, DurationUnit> | null;
  fullPressureStallTime: ResourceMeasurement<ResourceNumeric, DurationUnit> | null;
  outOfMemoryEventCount: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  limitEvents: ResourceLimitEventCount[];
}

export interface ProcessMetrics {
  activeCount: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  descendantCount: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  threadCount: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  lifetimeCreationCount: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  openFileDescriptorCount: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  windowsHandleCount: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  limitEvents: ResourceLimitEventCount[];
}

export interface DiskMetrics {
  readData: ResourceMeasurement<ResourceNumeric, DataUnit> | null;
  writeData: ResourceMeasurement<ResourceNumeric, DataUnit> | null;
  readThroughput: ResourceMeasurement<number, BandwidthUnit> | null;
  writeThroughput: ResourceMeasurement<number, BandwidthUnit> | null;
  readOperations: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  writeOperations: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  filesystems: FilesystemCapacityMetrics[];
}

export interface GpuMetrics {
  deviceMetrics: AcceleratorDeviceMetrics[] | null;
  processMetrics: AcceleratorProcessMetrics[] | null;
}

export interface NetworkTrafficMetrics {
  receivedData: ResourceMeasurement<ResourceNumeric, DataUnit> | null;
  transmittedData: ResourceMeasurement<ResourceNumeric, DataUnit> | null;
  receiveThroughput: ResourceMeasurement<number, BandwidthUnit> | null;
  transmitThroughput: ResourceMeasurement<number, BandwidthUnit> | null;
  receivedPackets: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  transmittedPackets: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  receiveErrors: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
  transmitErrors: ResourceMeasurement<ResourceNumeric, CountUnit> | null;
}

export interface NetworkInterfaceMetrics {
  name: string;
  traffic: NetworkTrafficMetrics;
}

export interface NetworkMetrics {
  measurementScope: 'global';
  system: NetworkTrafficMetrics;
  interfaces: NetworkInterfaceMetrics[];
}

export interface ProcessSamplingMetadata {
  visibleProcesses: ResourceNumeric;
  sampledProcesses: ResourceNumeric;
  /** Readable process counts keyed by canonical snake_case measurement paths. */
  fieldSampledProcesses: Record<string, ResourceNumeric>;
}

export interface ResourceMetricsSnapshot {
  timestamp: string;
  operatingSystem: ResourceOperatingSystem;
  measurementScope: ResourceMeasurementScope;
  processSampling: ProcessSamplingMetadata | null;
  cpu: CpuMetrics | null;
  memory: MemoryMetrics | null;
  process: ProcessMetrics | null;
  disk: DiskMetrics | null;
  gpu: GpuMetrics | null;
  network: NetworkMetrics | null;
}

export interface LlmSanitizeRequestContext {
  codec: LlmCodecIdentity;
  /** Resolve the active codec for this callback. Do not retain the result after the callback returns. */
  resolveCodec(): import('./typed').LlmCodec | null;
}

export interface LlmSanitizeResponseContext {
  codec: LlmCodecIdentity;
  /** Resolve the active codec for this callback. Do not retain the result after the callback returns. */
  resolveCodec(): import('./typed').LlmResponseCodec | null;
}

export interface LlmExecutionContext {
  /** Request codec identity plus optional decode and encode capability. */
  requestCodec: LlmRequestContext;
  /** Unary response codec identity plus optional decode capability; `null` for streaming execution. */
  responseCodec: LlmResponseContext | null;
}

export interface LlmOptimizationDataSchema {
  name: string;
  version: string;
}

export interface LlmOptimizationModel {
  model: string;
  provider?: string;
}

export interface LlmOptimizationModelTransition {
  baseline?: LlmOptimizationModel;
  effective?: LlmOptimizationModel;
}

export interface LlmOptimizationTokens {
  /** Token counts must be non-negative JavaScript safe integers. */
  prompt_tokens?: number;
  /** Token counts must be non-negative JavaScript safe integers. */
  completion_tokens?: number;
  /** Token counts must be non-negative JavaScript safe integers. */
  cache_read_tokens?: number;
  /** Token counts must be non-negative JavaScript safe integers. */
  cache_write_tokens?: number;
  /** Token counts must be non-negative JavaScript safe integers. */
  total_tokens?: number;
}

export interface LlmOptimizationTokenImpact {
  baseline?: LlmOptimizationTokens;
  effective?: LlmOptimizationTokens;
  saved?: LlmOptimizationTokens;
  quality?: 'observed' | 'estimated';
  estimation_method?: string;
}

export interface LlmOptimizationContribution {
  id?: string;
  /** Relay ordering must remain within JavaScript's safe-integer range. */
  sequence?: number;
  producer: string;
  kind: 'input_compression' | 'model_routing' | (string & {});
  applied: boolean;
  model_transition?: LlmOptimizationModelTransition;
  token_impact?: LlmOptimizationTokenImpact;
  payload_schema?: LlmOptimizationDataSchema;
  payload?: Json;
  [key: string]: Json | undefined;
}

export interface LlmRequestInterceptOutcome {
  request: Json;
  annotated?: Json | null;
  pendingMarks?: PendingMarkSpec[];
  optimizationContributions?: LlmOptimizationContribution[];
}

export declare class AtifExporter {
  /**
   * Create a new ATIF exporter.
   *
   * `sessionId` identifies the session. `agentName` and `agentVersion` describe the agent.
   * Optional `modelName` records the LLM model used.
   */
  constructor(sessionId: string, agentName: string, agentVersion: string, modelName?: string | undefined | null)
  /**
   * Register this exporter as an event subscriber with the given name.
   *
   * Throws if a subscriber with the same `name` already exists.
   */
  register(name: string): void
  /**
   * Deregister this exporter's event subscriber by name.
   *
   * Returns `true` if a subscriber with that name was found and removed.
   */
  deregister(name: string): boolean
  /**
   * Export the collected trajectory as a JSON string.
   *
   * Returns a JSON-serialized `AtifTrajectory`.
   */
  exportJson(): string
  /** Clear all collected events from the exporter. */
  clear(): void
}

export declare class AtofExporter {
  /**
   * Create a new Agent Trajectory Observability Format (ATOF) JSONL exporter
   * from a config object.
   */
  constructor(config?: AtofExporterConfig | undefined | null)
  /** Return the JSONL output path, or `null` for a stream sink. */
  get path(): string | null
  /** Register this exporter globally with the given name. */
  register(name: string): void
  /** Deregister a subscriber by name. */
  deregister(name: string): boolean
  /**
   * Outside subscriber and middleware callbacks, wait for queued subscriber delivery, then
   * flush the file sink or ask the stream sink to drain for up to its timeout. A stream timeout
   * is logged and does not by itself return an error.
   */
  forceFlush(): void
  /**
   * Outside subscriber and middleware callbacks, wait for queued subscriber delivery, then
   * flush the file sink or ask the stream sink to drain and close up to its timeout. A stream
   * timeout is logged and does not by itself return an error.
   */
  shutdown(): void
}

export declare class OpenTelemetrySubscriber {
  /** Create a new OpenTelemetry subscriber from a config object. */
  constructor(config: OpenTelemetryConfig)
  /** Create a subscriber that writes OTLP to a local file. */
  static fileSink(config: OpenTelemetryFileSinkConfig): OpenTelemetrySubscriber
  /** Register this subscriber globally with the given name. */
  register(name: string): void
  /** Deregister a subscriber by name. */
  deregister(name: string): boolean
  /**
   * Force a flush of finished spans through the exporter.
   *
   * A successful flush updates `runtimeDiagnostics()` with queue drops observed so far.
   */
  forceFlush(): void
  /** Return bounded runtime diagnostics recorded by this subscriber. */
  runtimeDiagnostics(): Array<{ code: string; message: string; count: number }>
  /** Shut down the underlying tracer provider. */
  shutdown(): void
}

export declare class OpenTelemetryLogSubscriber {
  /** Create a log subscriber from a config object. */
  constructor(config: OpenTelemetryLogConfig)
  /** Register this subscriber globally with the given name. */
  register(name: string): void
  /** Deregister a subscriber by name. */
  deregister(name: string): boolean
  /**
   * Flush queued Relay events and the OTLP log processor.
   *
   * A successful flush updates `runtimeDiagnostics()` with queue drops observed so far.
   */
  forceFlush(): void
  /** Return bounded runtime diagnostics recorded by this subscriber. */
  runtimeDiagnostics(): Array<{ code: string; message: string; count: number }>
  /** Shut down the underlying logger provider. */
  shutdown(): void
}

export declare class OpenTelemetryMetricSubscriber {
  /** Create a metric subscriber from a config object. */
  constructor(config: OpenTelemetryMetricConfig)
  /** Register this subscriber globally with the given name. */
  register(name: string): void
  /** Deregister a subscriber by name. */
  deregister(name: string): boolean
  /** Collect and export current metric aggregates immediately. */
  forceFlush(): void
  /** Return bounded runtime diagnostics recorded by this subscriber. */
  runtimeDiagnostics(): Array<{ code: string; message: string; count: number }>
  /** Shut down the underlying meter provider. */
  shutdown(): void
}

export declare class AdaptiveRuntime {
  /**
   * Create an adaptive runtime wrapper from config.
   *
   * The runtime is constructed lazily when `register()` is awaited.
   */
  constructor(config: Json)
  /**
   * Register all configured adaptive runtime features.
   *
   * `register()` and `shutdown()` both temporarily take ownership of the
   * runtime state, so concurrent calls are mutually exclusive by design.
   * Once either operation takes the state, another concurrent registration or
   * shutdown attempt fails with "adaptive runtime already shut down". This
   * prevents double-registration and shutdown-during-registration races.
   */
  register(): Promise<void>
  /** Deregister all previously registered adaptive runtime features. */
  deregister(): void
  /** Shut down the adaptive runtime and consume its Rust runtime state. */
  shutdown(): Promise<void>
  /** Block until the telemetry drain has processed pending events. */
  waitForIdle(): void
  /** Return the validation report captured during runtime construction. */
  report(): Json
  /** Bind the runtime's ACG request rewrite to a scope. */
  bindScope(scopeHandle: ScopeHandle): void
  /** Build cache request facts for an annotated LLM request. */
  buildCacheRequestFacts(options: Json): Json | null
}

export declare class PluginHostActivation {
  /** Return the validation report produced by activation. */
  get report(): Json
  /**
   * Return whether this activation handle has not begun teardown.
   *
   * Failed teardown leaves the activation active so `close()` can retry.
   */
  get isActive(): boolean
  /**
   * Clear plugin callbacks before unloading libraries and workers.
   *
   * This method is idempotent, including when concurrent callers race to
   * close the same activation.
   */
  close(): Promise<void>
  /**
   * Supply the structured disposal signature to napi-rs declaration generation.
   *
   * Module initialization installs `close()` under the actual well-known
   * symbol and removes this string-named declaration shim from the prototype.
   */
  [Symbol.asyncDispose](): Promise<void>
}

export declare class LlmStream {
  /**
   * Retrieve the next chunk from the stream.
   *
   * Returns the next JSON chunk, or `null` when the stream is exhausted.
   * Throws if the underlying stream encountered an error.
   */
  next(): Promise<Json | null>
  /** Stop the producer and wait for its cleanup to complete. */
  close(): Promise<void>
}

export declare class ScopeStack {
  /** Creates a new isolated scope stack with its own root scope. */
  constructor()
}

export declare class ScopeHandle {
  /** The unique identifier for this scope. */
  get uuid(): string
  /** The human-readable name of this scope. */
  get name(): string
  /** The type of this scope (Agent, Tool, Llm, etc.). */
  get scopeType(): ScopeType
  /** Bitfield of scope attributes (e.g., PARALLEL, RELOCATABLE). */
  get attributes(): number
  /** The UUID of this scope's parent, or `null` if this is the root scope. */
  get parentUuid(): string | null
  /** Optional user-defined data associated with this scope. */
  get data(): any | null
  /** Optional metadata associated with this scope. */
  get metadata(): any | null
}

export declare class ToolHandle {
  /** The unique identifier for this tool call. */
  get uuid(): string
  /** The name of the tool being called. */
  get name(): string
  /** Bitfield of tool attributes (e.g., LOCAL). */
  get attributes(): number
  /** The UUID of the parent scope that initiated this tool call, or `null`. */
  get parentUuid(): string | null
}

export declare class LlmHandle {
  /** The unique identifier for this LLM call. */
  get uuid(): string
  /** The name of the LLM provider being called. */
  get name(): string
  /** Bitfield of LLM attributes (e.g., STATELESS, STREAMING). */
  get attributes(): number
  /** The UUID of the parent scope that initiated this LLM call, or `null`. */
  get parentUuid(): string | null
}

export declare class LlmRequest {
  /** Create a new LLM request from headers and content. */
  constructor(headers: any, content: any)
  /** The metadata headers as a JSON object. */
  get headers(): any
  /** The request payload as a JSON value. */
  get content(): any
}

export declare class OpenAIChatCodec {
  constructor()
  /** Decode an opaque LLM request into structured form. */
  decode(request: Json): Json
  /** Encode structured changes back into an opaque LLM request. */
  encode(annotated: Json, original: Json): Json
  /** Decode a raw LLM response into structured form. */
  decodeResponse(response: Json): Json
}

export declare class OpenAIResponsesCodec {
  constructor()
  /** Decode an opaque LLM request into structured form. */
  decode(request: Json): Json
  /** Encode structured changes back into an opaque LLM request. */
  encode(annotated: Json, original: Json): Json
  /** Decode a raw LLM response into structured form. */
  decodeResponse(response: Json): Json
}

export declare class GeminiGenerateContentCodec {
  constructor()
  /** Decode an opaque LLM request into structured form. */
  decode(request: Json): Json
  /** Encode structured changes back into an opaque LLM request. */
  encode(annotated: Json, original: Json): Json
  /** Decode a raw LLM response into structured form. */
  decodeResponse(response: Json): Json
}

export declare class AnthropicMessagesCodec {
  constructor()
  /** Decode an opaque LLM request into structured form. */
  decode(request: Json): Json
  /** Encode structured changes back into an opaque LLM request. */
  encode(annotated: Json, original: Json): Json
  /** Decode a raw LLM response into structured form. */
  decodeResponse(response: Json): Json
}

export declare class OCIGenAIChatCodec {
  constructor()
  /** Decode an opaque LLM request into structured form. */
  decode(request: Json): Json
  /** Encode structured changes back into an opaque LLM request. */
  encode(annotated: Json, original: Json): Json
  /** Decode a raw LLM response into structured form. */
  decodeResponse(response: Json): Json
}

export const enum RuntimeRegistrationKind {
  Subscriber = 'subscriber',
  EventMetadataInjector = 'event_metadata_injector',
  MarkSanitizeGuardrail = 'mark_sanitize_guardrail',
  ScopeSanitizeStartGuardrail = 'scope_sanitize_start_guardrail',
  ScopeSanitizeEndGuardrail = 'scope_sanitize_end_guardrail',
  ToolSanitizeRequestGuardrail = 'tool_sanitize_request_guardrail',
  ToolSanitizeResponseGuardrail = 'tool_sanitize_response_guardrail',
  ToolConditionalExecutionGuardrail = 'tool_conditional_execution_guardrail',
  ToolRequestIntercept = 'tool_request_intercept',
  ToolExecutionIntercept = 'tool_execution_intercept',
  LlmSanitizeRequestGuardrail = 'llm_sanitize_request_guardrail',
  LlmSanitizeResponseGuardrail = 'llm_sanitize_response_guardrail',
  LlmConditionalExecutionGuardrail = 'llm_conditional_execution_guardrail',
  LlmRequestIntercept = 'llm_request_intercept',
  LlmExecutionIntercept = 'llm_execution_intercept',
  LlmStreamExecutionIntercept = 'llm_stream_execution_intercept'
}

export const enum RuntimeRegistrationOwnerKind {
  Core = 'core',
  GlobalApi = 'global_api',
  Plugin = 'plugin'
}

export const enum DurationUnit {
  /** Microseconds. */
  Microseconds = 'microseconds',
  /** Milliseconds. */
  Milliseconds = 'milliseconds',
  /** Seconds. */
  Seconds = 'seconds',
  /** Minutes. */
  Minutes = 'minutes'
}

export const enum CapacityUnit {
  /** Bytes. */
  Bytes = 'bytes',
  /** Kilobytes. */
  Kilobytes = 'kilobytes',
  /** Megabytes. */
  Megabytes = 'megabytes',
  /** Gigabytes. */
  Gigabytes = 'gigabytes',
  /** Terabytes. */
  Terabytes = 'terabytes',
  /** Kibibytes. */
  Kibibytes = 'kibibytes',
  /** Mebibytes. */
  Mebibytes = 'mebibytes',
  /** Gibibytes. */
  Gibibytes = 'gibibytes',
  /** Tebibytes. */
  Tebibytes = 'tebibytes'
}

export const enum DataUnit {
  /** Bytes. */
  Bytes = 'bytes',
  /** Kilobytes. */
  Kilobytes = 'kilobytes',
  /** Megabytes. */
  Megabytes = 'megabytes',
  /** Gigabytes. */
  Gigabytes = 'gigabytes',
  /** Terabytes. */
  Terabytes = 'terabytes',
  /** Kibibytes. */
  Kibibytes = 'kibibytes',
  /** Mebibytes. */
  Mebibytes = 'mebibytes',
  /** Gibibytes. */
  Gibibytes = 'gibibytes',
  /** Tebibytes. */
  Tebibytes = 'tebibytes'
}

export const enum BandwidthUnit {
  /** Bytes per second. */
  BytesPerSecond = 'bytes_per_second',
  /** Kibibytes per second. */
  KibibytesPerSecond = 'kibibytes_per_second',
  /** Mebibytes per second. */
  MebibytesPerSecond = 'mebibytes_per_second',
  /** Gibibytes per second. */
  GibibytesPerSecond = 'gibibytes_per_second',
  /** Bits per second. */
  BitsPerSecond = 'bits_per_second',
  /** Megabits per second. */
  MegabitsPerSecond = 'megabits_per_second',
  /** Gigabits per second. */
  GigabitsPerSecond = 'gigabits_per_second'
}

export const enum CpuUnit {
  /** Logical processors. */
  LogicalProcessors = 'logical_processors',
  /** Millicores. */
  Millicores = 'millicores'
}

export const enum UtilizationUnit {
  /** Percentage. */
  Percentage = 'percentage',
  /** Fraction. */
  Fraction = 'fraction'
}

export const enum CountUnit {
  /** Processes. */
  Processes = 'processes',
  /** Threads. */
  Threads = 'threads',
  /** File descriptors. */
  FileDescriptors = 'file_descriptors',
  /** Handles. */
  Handles = 'handles',
  /** Events. */
  Events = 'events',
  /** Operations. */
  Operations = 'operations',
  /** Packets. */
  Packets = 'packets',
  /** Errors. */
  Errors = 'errors'
}

export const enum ScopeType {
  /** An autonomous agent scope. */
  Agent = 0,
  /** A generic function invocation scope. */
  Function = 1,
  /** A tool execution scope. */
  Tool = 2,
  /** A large language model call scope. */
  Llm = 3,
  /** A retriever (vector search / RAG) scope. */
  Retriever = 4,
  /** An embedding model scope. */
  Embedder = 5,
  /** A reranker model scope. */
  Reranker = 6,
  /** A guardrail evaluation scope. */
  Guardrail = 7,
  /** An evaluator / scoring scope. */
  Evaluator = 8,
  /** A user-defined custom scope type. */
  Custom = 9,
  /** An unknown or unclassified scope type. */
  Unknown = 10
}

export const enum LogSeverity {
  Trace = 0,
  Debug = 1,
  Info = 2,
  Warn = 3,
  Error = 4
}

export const enum MetricKind {
  Counter = 0,
  UpDownCounter = 1,
  Gauge = 2,
  Histogram = 3
}

export const enum MetricValueType {
  U64 = 0,
  I64 = 1,
  F64 = 2
}

export const enum MetricTemporality {
  Cumulative = 0,
  Delta = 1,
  LowMemory = 2
}

export declare function log(level: string, message: string, target?: string | undefined | null, fields?: Json | undefined | null): void

export declare function trace(message: string, target?: string | undefined | null, fields?: Json | undefined | null): void

export declare function debug(message: string, target?: string | undefined | null, fields?: Json | undefined | null): void

export declare function info(message: string, target?: string | undefined | null, fields?: Json | undefined | null): void

export declare function warn(message: string, target?: string | undefined | null, fields?: Json | undefined | null): void

export declare function collectResourceMetrics(): Promise<ResourceMetricsSnapshot>

export declare function error(message: string, target?: string | undefined | null, fields?: Json | undefined | null): void

export declare function pushStreamChunk(streamId: number, chunk: Json): boolean

export declare function endStream(streamId: number): void

export declare function createScopeStack(): ScopeStack

export declare function capturePropagationContext(): PropagationContext

export declare function captureRootlessPropagationContext(): PropagationContext

export declare function capturePropagationContextWithRoot(rootUuid?: string | undefined | null): PropagationContext

export declare function captureTraceparent(): string

export declare function propagationContextToJson(context: PropagationContext): string

export declare function propagationContextToTraceparent(context: PropagationContext): string

export declare function propagationContextFromJson(value: string): PropagationContext

export declare function createScopeStackFromPropagation(context: PropagationContext): ScopeStack

export declare function withScopeStack(stack: ScopeStack, callback: (...args: any[]) => any): unknown

export declare function currentScopeStack(): ScopeStack

export declare function setThreadScopeStack(stack: ScopeStack): void

export declare function scopeStackActive(): boolean