@graphorin/observability 0.6.0 → 0.7.0

package/src/gen-ai/operation-mapping.ts

@@ -0,0 +1,89 @@
+/**
+ * Mapping table from Graphorin `SpanType` values to canonical
+ * `gen_ai.operation.name` enum values.
+ *
+ * The table mirrors the canonical-mapping reference table published
+ * in the architecture documentation and is the authoritative source
+ * for the `emitGenAIAttributes` helper.
+ *
+ * @packageDocumentation
+ */
+
+import type { SpanType } from '@graphorin/core';
+
+import type { GenAIOperationName } from './types.js';
+
+const TABLE: ReadonlyArray<readonly [SpanType, GenAIOperationName]> = Object.freeze([
+  // E8: match what the runtime actually emits (agent factory stamps
+  // `gen_ai.operation.name: 'invoke_agent'` on both run + step spans) and the
+  // OTel GenAI operation enum, which has `invoke_agent` and no step concept.
+  ['agent.run', 'invoke_agent'],
+  ['agent.step', 'invoke_agent'],
+  ['agent.handoff', 'agent.handoff'],
+  ['agent.suspend', 'agent.suspend'],
+  ['agent.resume', 'agent.resume'],
+
+  ['provider.generate', 'chat'],
+  ['provider.stream', 'chat'],
+
+  ['tool.execute', 'execute_tool'],
+  ['tool.approval', 'execute_tool'],
+
+  ['memory.read.working', 'memory.read'],
+  ['memory.read.session', 'memory.read'],
+  ['memory.read.episodic', 'memory.read'],
+  ['memory.read.semantic', 'memory.read'],
+  ['memory.read.procedural', 'memory.read'],
+  ['memory.read.shared', 'memory.read'],
+  ['memory.write.working', 'memory.write'],
+  ['memory.write.session', 'memory.write'],
+  ['memory.write.episodic', 'memory.write'],
+  ['memory.write.semantic', 'memory.write'],
+  ['memory.write.procedural', 'memory.write'],
+  ['memory.write.shared', 'memory.write'],
+  ['memory.search.working', 'memory.search'],
+  ['memory.search.session', 'memory.search'],
+  ['memory.search.episodic', 'memory.search'],
+  ['memory.search.semantic', 'memory.search'],
+  ['memory.search.procedural', 'memory.search'],
+  ['memory.search.shared', 'memory.search'],
+  ['memory.consolidate.light', 'memory.consolidate'],
+  ['memory.consolidate.standard', 'memory.consolidate'],
+  ['memory.consolidate.deep', 'memory.consolidate'],
+  ['memory.conflict', 'memory.conflict'],
+  ['memory.embed', 'embedding'],
+
+  ['workflow.run', 'workflow.run'],
+  ['workflow.step', 'workflow.step'],
+  ['workflow.task', 'workflow.task'],
+  ['workflow.checkpoint', 'workflow.checkpoint'],
+
+  ['skill.activate', 'skill.activate'],
+  ['skill.load', 'skill.load'],
+
+  ['mcp.connect', 'mcp.connect'],
+  ['mcp.call', 'mcp.call'],
+  ['mcp.list-tools', 'mcp.list-tools'],
+] as const);
+
+const LOOKUP = new Map<SpanType, GenAIOperationName>(TABLE);
+
+/**
+ * Resolve the canonical `gen_ai.operation.name` value for a Graphorin
+ * span type. Returns `undefined` if no mapping exists (e.g. for
+ * `replay.*` markers, which are emitted via a separate code path).
+ *
+ * @stable
+ */
+export function operationNameFor(type: SpanType): GenAIOperationName | undefined {
+  return LOOKUP.get(type);
+}
+
+/**
+ * Full canonical span-to-operation table - exposed for tooling
+ * (documentation generators, fixture tests) that need to introspect
+ * the mapping.
+ *
+ * @stable
+ */
+export const OPERATION_NAME_TABLE: ReadonlyArray<readonly [SpanType, GenAIOperationName]> = TABLE;

package/src/gen-ai/system-derivation.ts

@@ -0,0 +1,84 @@
+/**
+ * Auto-derivation lookup table for the `gen_ai.system` attribute.
+ *
+ * @packageDocumentation
+ */
+
+import type { GenAISystem } from './types.js';
+
+/**
+ * Canonical mapping from a provider class name (or substring) to the
+ * `gen_ai.system` enum value. The table is an export so consumers
+ * (e.g. provider adapters in Phase 06) can introspect or extend it.
+ *
+ * @stable
+ */
+export const PROVIDER_CLASS_TO_GEN_AI_SYSTEM: ReadonlyArray<readonly [RegExp, GenAISystem]> =
+  Object.freeze([
+    [/anthropic/i, 'anthropic'],
+    [/openai(?!compat)/i, 'openai'],
+    [/google|gemini/i, 'google'],
+    [/mistral/i, 'mistral'],
+    [/ollama/i, 'ollama'],
+    [/openrouter/i, 'openrouter'],
+    [/azure/i, 'azure_ai_inference'],
+    [/bedrock|aws/i, 'aws.bedrock'],
+    [/cohere/i, 'cohere'],
+    [/vertex/i, 'vertex_ai'],
+    [/llamacpp|llama-cpp|llama_cpp/i, 'graphorin-llamacpp'],
+    [/openaicompatible|openai-compatible/i, 'graphorin-openai-compatible'],
+  ] as const);
+
+const WARNED_CLASSES = new Set<string>();
+let WARN_SINK: (line: string) => void = (line) => console.warn(line);
+
+/**
+ * Override the WARN-once sink used for unrecognised provider class
+ * names. Useful in tests so the suite does not pollute stderr.
+ *
+ * @internal
+ */
+export function setGenAISystemWarnSink(sink: (line: string) => void): void {
+  WARN_SINK = sink;
+}
+
+/**
+ * Reset the WARN-once cache. Test-only.
+ *
+ * @internal
+ */
+export function _resetGenAISystemWarningsForTesting(): void {
+  WARNED_CLASSES.clear();
+}
+
+/**
+ * Derive the canonical `gen_ai.system` value from a provider class
+ * name. Returns `null` when the name does not match any known
+ * pattern; callers should declare `Provider.genAiSystem` explicitly
+ * in that case.
+ *
+ * The first time an unknown class name is seen, the function emits
+ * one structured WARN line to the configured sink so operators
+ * notice the gap. Subsequent lookups for the same class are silent.
+ *
+ * @stable
+ */
+export function deriveGenAISystem(providerClassName: string): GenAISystem | null {
+  for (const [regex, system] of PROVIDER_CLASS_TO_GEN_AI_SYSTEM) {
+    if (regex.test(providerClassName)) return system;
+  }
+  warnOnce(providerClassName);
+  return null;
+}
+
+function warnOnce(providerClassName: string): void {
+  if (WARNED_CLASSES.has(providerClassName)) return;
+  WARNED_CLASSES.add(providerClassName);
+  WARN_SINK(
+    `[graphorin/observability] WARN: provider class "${providerClassName}" is not in ` +
+      'the auto-derivation table for `gen_ai.system`. Declare `Provider.genAiSystem` ' +
+      'explicitly on the adapter so OpenTelemetry GenAI dashboards attribute the spans ' +
+      'correctly. See `@graphorin/observability/gen-ai` and the OpenTelemetry GenAI ' +
+      'semantic conventions for the canonical vendor enum.',
+  );
+}

package/src/gen-ai/types.ts

@@ -0,0 +1,143 @@
+/**
+ * Type definitions for the OpenTelemetry GenAI semantic-conventions
+ * conformance helpers.
+ *
+ * @packageDocumentation
+ */
+
+import type { SpanType } from '@graphorin/core';
+
+/**
+ * Canonical OpenTelemetry semantic-conventions vendor enum used as the
+ * value of the `gen_ai.system` attribute.
+ *
+ * @stable
+ */
+export type GenAISystem =
+  | 'anthropic'
+  | 'openai'
+  | 'google'
+  | 'mistral'
+  | 'ollama'
+  | 'openrouter'
+  | 'azure_ai_inference'
+  | 'aws.bedrock'
+  | 'cohere'
+  | 'vertex_ai'
+  | 'graphorin-llamacpp'
+  | 'graphorin-openai-compatible'
+  | (string & { readonly __genAiSystem?: never });
+
+/**
+ * `gen_ai.tool.type` enum value. Defaults to `'function'` for
+ * user-defined and MCP-derived tools without explicit declaration.
+ *
+ * @stable
+ */
+export type GenAIToolType =
+  | 'function'
+  | 'web_search'
+  | 'database'
+  | 'code_interpreter'
+  | 'image_generation'
+  | 'file_search';
+
+/**
+ * Canonical `gen_ai.operation.name` enum used per the OpenTelemetry
+ * GenAI semantic conventions for AI agent + framework spans.
+ *
+ * @stable
+ */
+export type GenAIOperationName =
+  // E8: `invoke_agent` is the canonical OTel GenAI agent operation and what
+  // the runtime emits; the legacy `agent.run`/`agent.step` members remain for
+  // compatibility with older recorded traces.
+  | 'invoke_agent'
+  | 'agent.run'
+  | 'agent.step'
+  | 'agent.handoff'
+  | 'agent.suspend'
+  | 'agent.resume'
+  | 'agent.fanout.spawned'
+  | 'agent.fanout.merged'
+  | 'agent.evaluator.iteration'
+  | 'chat'
+  | 'embedding'
+  | 'execute_tool'
+  | 'memory.read'
+  | 'memory.write'
+  | 'memory.search'
+  | 'memory.consolidate'
+  | 'memory.conflict'
+  | 'workflow.run'
+  | 'workflow.step'
+  | 'workflow.task'
+  | 'workflow.checkpoint'
+  | 'mcp.connect'
+  | 'mcp.call'
+  | 'mcp.list-tools'
+  | 'skill.activate'
+  | 'skill.load'
+  | 'replay.run'
+  | 'replay.skipped';
+
+/**
+ * Per-message event type used by {@link emitGenAIMessageEvents}.
+ *
+ * @stable
+ */
+export type GenAIMessageRole = 'system' | 'user' | 'assistant' | 'tool';
+
+/**
+ * Single per-message record passed to {@link emitGenAIMessageEvents}.
+ *
+ * @stable
+ */
+export interface GenAIMessage {
+  readonly role: GenAIMessageRole;
+  readonly content: string;
+  /** Optional model-specific metadata (tool calls, names, …). */
+  readonly toolCalls?: ReadonlyArray<{
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: string;
+  }>;
+  readonly toolCallId?: string;
+  readonly name?: string;
+}
+
+/**
+ * Per-span attribute payload expected by {@link emitGenAIAttributes}.
+ * The fields mirror the OpenTelemetry GenAI semantic conventions and
+ * are merged with the existing Graphorin-prefixed attributes - the
+ * `gen_ai.*` family is additive, never replacing.
+ *
+ * @stable
+ */
+export interface GenAIAttributes {
+  readonly system?: GenAISystem;
+  readonly requestModel?: string;
+  readonly responseModel?: string;
+  readonly responseId?: string;
+  readonly inputTokens?: number;
+  readonly outputTokens?: number;
+  readonly finishReasons?: ReadonlyArray<string>;
+  readonly operation?: GenAIOperationName;
+  readonly agentId?: string;
+  readonly agentName?: string;
+  readonly sessionId?: string;
+  readonly toolName?: string;
+  readonly toolType?: GenAIToolType;
+  readonly toolCallId?: string;
+  readonly toolDescription?: string;
+}
+
+/**
+ * Mapping from a Graphorin `SpanType` to the canonical
+ * `gen_ai.operation.name` value. Returns `undefined` for span types
+ * that do not have a canonical operation enum (`replay.*` is recorded
+ * as `'replay.run'` / `'replay.skipped'` per the doc table).
+ *
+ * @stable
+ */
+export type SpanTypeToOperationName = (type: SpanType) => GenAIOperationName | undefined;

package/src/index.ts

@@ -0,0 +1,36 @@
+/**
+ * @graphorin/observability - observability primitives for the
+ * Graphorin framework. Ships:
+ *
+ * - the typed `AISpan<T>` tracer over OpenTelemetry,
+ * - the **mandatory** `withValidation()` wrapper for every exporter,
+ * - the sensitivity-aware `RedactionValidator` with 14 built-in PII /
+ *   secret detection patterns,
+ * - OpenTelemetry GenAI semantic-conventions conformance helpers,
+ * - OpenInference span-kind emission,
+ * - the structured `Logger` with span correlation,
+ * - the append-only `JSONLExporter` for replay,
+ * - sanitized-by-default `Replay` primitives,
+ * - the hierarchical `CostTracker`,
+ * - and a minimal inline eval runner.
+ *
+ * The full documentation lives in the package `README.md`.
+ *
+ * @packageDocumentation
+ */
+
+/** Canonical version constant, derived from `package.json` at build time. */
+import pkg from '../package.json' with { type: 'json' };
+
+export const VERSION: string = pkg.version;
+
+export * from './cost/index.js';
+export * from './eval/index.js';
+export * from './exporters/index.js';
+export * from './gen-ai/index.js';
+export * from './logger/index.js';
+export * from './openinference/index.js';
+export * from './redaction/index.js';
+export * from './replay/index.js';
+export * from './telemetry/index.js';
+export * from './tracer/index.js';

package/src/logger/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Structured logger surface.
+ *
+ * @packageDocumentation
+ */
+
+export {
+  createLogger,
+  getCurrentSpanContext,
+  type LoggerFormat,
+  type LoggerOptions,
+  withCurrentSpan,
+} from './logger.js';

package/src/logger/logger.ts

@@ -0,0 +1,178 @@
+/**
+ * `createLogger(...)` - structured logger with optional span correlation.
+ *
+ * The logger is a thin wrapper around `console.{log,info,warn,error}`
+ * that adds:
+ *
+ * - structured fields,
+ * - JSON or pretty rendering,
+ * - automatic correlation with the current Graphorin span (the
+ *   {@link CurrentSpanContext} helper carries the live trace + span ids),
+ * - sensitivity-aware redaction via the supplied
+ *   {@link RedactionValidatorInstance}.
+ *
+ * @packageDocumentation
+ */
+
+import type { AISpan, LogFields, Logger, LogLevel, Sensitivity } from '@graphorin/core';
+
+import { createAsyncContext } from '@graphorin/core';
+
+import type { RedactionValidatorInstance } from '../redaction/types.js';
+
+/**
+ * @stable
+ */
+export type LoggerFormat = 'json' | 'pretty';
+
+/**
+ * Configuration shape for {@link createLogger}.
+ *
+ * @stable
+ */
+export interface LoggerOptions {
+  readonly level?: LogLevel;
+  readonly format?: LoggerFormat;
+  /** Optional validator. Logger fields flow through `validate(...)`. */
+  readonly redaction?: RedactionValidatorInstance;
+  /** Default sensitivity tier for fields. Defaults to `'internal'`. */
+  readonly defaultTier?: Sensitivity;
+  /**
+   * Sink that receives the rendered line. Defaults to writing to the
+   * appropriate `console.*` method.
+   */
+  readonly sink?: (level: LogLevel, line: string) => void;
+}
+
+const LEVELS: ReadonlyArray<LogLevel> = ['trace', 'debug', 'info', 'warn', 'error'] as const;
+
+/**
+ * @internal - context used to thread the current span id through nested
+ * async calls. Exposed via {@link withCurrentSpan} below.
+ */
+const SPAN_CONTEXT = createAsyncContext<{ traceId: string; spanId: string }>(
+  'graphorin.observability.current-span',
+);
+
+/**
+ * Run `fn` with the supplied span as the "current" log-correlation
+ * span. The logger picks up the trace + span ids automatically.
+ *
+ * @stable
+ */
+export function withCurrentSpan<R>(
+  span: AISpan | undefined,
+  fn: () => R | Promise<R>,
+): R | Promise<R> {
+  if (span === undefined) return fn();
+  return SPAN_CONTEXT.runAsync({ traceId: span.traceId, spanId: span.id }, async () => fn());
+}
+
+/**
+ * Read the current span context (if any). Useful for callers that
+ * want to attach span metadata to bespoke records.
+ *
+ * @stable
+ */
+export function getCurrentSpanContext():
+  | { readonly traceId: string; readonly spanId: string }
+  | undefined {
+  return SPAN_CONTEXT.get();
+}
+
+/**
+ * Build a {@link Logger} configured against the supplied options.
+ *
+ * @stable
+ */
+export function createLogger(opts: LoggerOptions = {}): Logger {
+  const minLevel = LEVELS.indexOf(opts.level ?? 'info');
+  const format = opts.format ?? 'json';
+  const redaction = opts.redaction;
+  const defaultTier: Sensitivity = opts.defaultTier ?? 'internal';
+  const sink = opts.sink ?? defaultSink;
+
+  function emit(level: LogLevel, message: string, fields?: LogFields): void {
+    const idx = LEVELS.indexOf(level);
+    if (idx < minLevel) return;
+
+    const span = SPAN_CONTEXT.get();
+    const safeFields = sanitizeFields(fields, redaction, defaultTier);
+
+    const payload: Record<string, unknown> = {
+      level,
+      time: new Date().toISOString(),
+      message,
+      ...safeFields,
+    };
+    if (span !== undefined) {
+      payload.traceId = span.traceId;
+      payload.spanId = span.spanId;
+    }
+
+    const line = format === 'json' ? JSON.stringify(payload) : prettyRender(payload);
+    sink(level, line);
+  }
+
+  return {
+    trace: (message, fields) => emit('trace', message, fields),
+    debug: (message, fields) => emit('debug', message, fields),
+    info: (message, fields) => emit('info', message, fields),
+    warn: (message, fields) => emit('warn', message, fields),
+    error: (message, fields) => emit('error', message, fields),
+    child(_bindings: LogFields): Logger {
+      const inherited = sanitizeFields(_bindings, redaction, defaultTier);
+      const parent = createLogger(opts);
+      return {
+        trace: (m, f) => parent.trace(m, { ...inherited, ...f }),
+        debug: (m, f) => parent.debug(m, { ...inherited, ...f }),
+        info: (m, f) => parent.info(m, { ...inherited, ...f }),
+        warn: (m, f) => parent.warn(m, { ...inherited, ...f }),
+        error: (m, f) => parent.error(m, { ...inherited, ...f }),
+        child(b: LogFields): Logger {
+          return parent.child({ ...inherited, ...b });
+        },
+      };
+    },
+  };
+}
+
+function sanitizeFields(
+  fields: LogFields | undefined,
+  validator: RedactionValidatorInstance | undefined,
+  tier: Sensitivity,
+): LogFields {
+  if (fields === undefined) return {};
+  if (validator === undefined) return { ...fields };
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(fields)) {
+    const result = validator.validate({ value: v, tier, context: { attribute: k } });
+    if (result === null) continue;
+    out[k] = result.value;
+  }
+  return out;
+}
+
+function defaultSink(level: LogLevel, line: string): void {
+  switch (level) {
+    case 'trace':
+    case 'debug':
+      console.debug(line);
+      return;
+    case 'info':
+      console.info(line);
+      return;
+    case 'warn':
+      console.warn(line);
+      return;
+    case 'error':
+      console.error(line);
+      return;
+  }
+}
+
+function prettyRender(payload: Record<string, unknown>): string {
+  const { level, time, message, ...rest } = payload;
+  const fields = Object.keys(rest).length === 0 ? '' : ` ${JSON.stringify(rest)}`;
+  return `[${String(time)}] ${String(level).toUpperCase()} ${String(message)}${fields}`;
+}

package/src/openinference/index.ts

@@ -0,0 +1,133 @@
+/**
+ * OpenInference span-kind emission. Adds the
+ * `openinference.span.kind` attribute (one of `AGENT`, `EVALUATOR`,
+ * `LLM`, `TOOL`, `RETRIEVER`, `EMBEDDING`, `CHAIN`) to applicable
+ * Graphorin spans.
+ *
+ * The mapping is the canonical table published in the architecture
+ * documentation. Span types without a clean OpenInference equivalent
+ * (`skill.*`, `mcp.connect`, `mcp.list-tools`, `replay.*`) are NOT
+ * emitted - the caller can introspect via {@link openInferenceKindFor}
+ * and decide whether to log a fallback attribute.
+ *
+ * @packageDocumentation
+ */
+
+import type { AISpan, SpanType } from '@graphorin/core';
+
+import { asGraphorinSpan } from '../tracer/tracer.js';
+
+/**
+ * Canonical OpenInference span-kind enum.
+ *
+ * @stable
+ */
+export type OpenInferenceSpanKind =
+  | 'AGENT'
+  | 'EVALUATOR'
+  | 'LLM'
+  | 'TOOL'
+  | 'RETRIEVER'
+  | 'EMBEDDING'
+  | 'CHAIN'
+  | 'RERANKER';
+
+const KIND_TABLE: ReadonlyArray<readonly [SpanType, OpenInferenceSpanKind]> = Object.freeze([
+  ['agent.run', 'AGENT'],
+  ['agent.step', 'AGENT'],
+  ['agent.handoff', 'AGENT'],
+  ['agent.suspend', 'AGENT'],
+  ['agent.resume', 'AGENT'],
+
+  ['provider.generate', 'LLM'],
+  ['provider.stream', 'LLM'],
+
+  ['tool.execute', 'TOOL'],
+  ['tool.approval', 'TOOL'],
+
+  ['memory.read.working', 'RETRIEVER'],
+  ['memory.read.session', 'RETRIEVER'],
+  ['memory.read.episodic', 'RETRIEVER'],
+  ['memory.read.semantic', 'RETRIEVER'],
+  ['memory.read.procedural', 'RETRIEVER'],
+  ['memory.read.shared', 'RETRIEVER'],
+  ['memory.write.working', 'RETRIEVER'],
+  ['memory.write.session', 'RETRIEVER'],
+  ['memory.write.episodic', 'RETRIEVER'],
+  ['memory.write.semantic', 'RETRIEVER'],
+  ['memory.write.procedural', 'RETRIEVER'],
+  ['memory.write.shared', 'RETRIEVER'],
+  ['memory.search.working', 'RETRIEVER'],
+  ['memory.search.session', 'RETRIEVER'],
+  ['memory.search.episodic', 'RETRIEVER'],
+  ['memory.search.semantic', 'RETRIEVER'],
+  ['memory.search.procedural', 'RETRIEVER'],
+  ['memory.search.shared', 'RETRIEVER'],
+
+  ['memory.embed', 'EMBEDDING'],
+
+  ['memory.consolidate.light', 'CHAIN'],
+  ['memory.consolidate.standard', 'CHAIN'],
+  ['memory.consolidate.deep', 'CHAIN'],
+  ['memory.conflict', 'CHAIN'],
+  ['workflow.run', 'CHAIN'],
+  ['workflow.step', 'CHAIN'],
+  ['workflow.task', 'CHAIN'],
+  ['workflow.checkpoint', 'CHAIN'],
+
+  ['mcp.call', 'TOOL'],
+] as const);
+
+/**
+ * Span types intentionally excluded from OpenInference span-kind
+ * emission per the canonical table - `skill.*`, `mcp.connect`,
+ * `mcp.list-tools`, and `replay.*` markers do not have a clean
+ * OpenInference equivalent.
+ *
+ * @stable
+ */
+export const OPEN_INFERENCE_EXCLUDED_TYPES: ReadonlyArray<SpanType> = Object.freeze([
+  'skill.activate',
+  'skill.load',
+  'mcp.connect',
+  'mcp.list-tools',
+] as const);
+
+const KIND_LOOKUP = new Map<SpanType, OpenInferenceSpanKind>(KIND_TABLE);
+
+/**
+ * Resolve the OpenInference span kind for a Graphorin span type.
+ * Returns `null` for types intentionally excluded from emission.
+ *
+ * @stable
+ */
+export function openInferenceKindFor<T extends SpanType>(type: T): OpenInferenceSpanKind | null {
+  return KIND_LOOKUP.get(type) ?? null;
+}
+
+/**
+ * Attach the `openinference.span.kind` attribute to a span. No-op for
+ * span types that lack a clean OpenInference equivalent. The attribute
+ * is tagged `'public'` because the enum value is bounded and contains
+ * no PII.
+ *
+ * @stable
+ */
+export function emitOpenInferenceKind<T extends SpanType>(span: AISpan<T>): void {
+  const kind = KIND_LOOKUP.get(span.type);
+  if (kind === undefined) return;
+  const gs = asGraphorinSpan(span);
+  if (gs !== null) {
+    gs.setAttribute('openinference.span.kind', kind, { sensitivity: 'public' });
+  } else {
+    span.setAttributes({ 'openinference.span.kind': kind });
+  }
+}
+
+/**
+ * Full canonical span-to-kind table - exposed for tooling and tests
+ * that need to introspect the mapping.
+ *
+ * @stable
+ */
+export const OPEN_INFERENCE_KIND_TABLE = KIND_TABLE;