@runtypelabs/flue-otel 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1,41 +1,5 @@
 import { Tracer } from '@opentelemetry/api';
 
-/**
- * The Flue observation surface this package reads, declared structurally.
- *
- * ## Why these are hand-declared rather than imported from `@flue/runtime`
- *
- * Two reasons, and the second is the load-bearing one.
- *
- * 1. `@flue/runtime` is a PEER dependency with no dev counterpart: its tree is
- *    ~43 packages, and pulling it into the root lockfile for type resolution
- *    alone is the cost this monorepo already refuses for `examples/flue-persona`
- *    (root `CLAUDE.md`, "examples/* is deliberately NOT a pnpm workspace").
- *
- * 2. The package supports BOTH the 1.x and 2.x lines from one entry point, and
- *    their declarations are not the same type. 1.x has `run_start`/`run_end`,
- *    envelope `runId`/`dispatchId`, and `FlueObservationDetail.toolType`; 2.x
- *    removes all of those and adds `toolcall_delta`, the `submission_*` family,
- *    and `FlueErrorInfo.meta`/`.stack`. Importing EITHER line's types would make
- *    the compiler enforce a shape the other line does not have. What this
- *    package actually consumes is the INTERSECTION — the observation plane Flue
- *    publishes as stable — so that is what is declared here.
- *
- * ## What is safe to read
- *
- * Flue's published stability boundary (flueframework.com/docs/reference/events)
- * covers the event type names, the envelope/correlation fields, and the
- * normalized `turn_request` / `turn` / `tool_*` / `task` / `operation` /
- * `compaction` / `log` / `submission_settled` payloads. It EXPLICITLY excludes
- * `AgentMessage`, which appears on `message_start` / `message_end` /
- * `turn_messages` / `agent_end` — so none of those four are read here, and the
- * type below does not even name the field. That exclusion is why the stock
- * projection survived the 1.x → 2.x rewrite unchanged, and it is the same
- * reason this one will.
- *
- * Fields the two lines disagree on are declared OPTIONAL and probed at runtime
- * (`compat.ts`), never version-compared.
- */
 /** Correlation fields stamped onto every delivered observation. */
 interface FlueEventEnvelope {
     /** Durable event-format version. `3` on both supported lines. */
@@ -82,12 +46,13 @@ interface FlueModelRequestInfo {
     contextCompacted?: true;
 }
 /**
- * The request's payload half. Only `tools` is read, and only for its PRESENCE:
- * `runtype.tools.reported` is the assertion "my tool set is complete", which
- * needs to know the array exists, not what is in it. Message content is
- * deliberately untouched in this release — see the README's content section.
+ * The request's payload half. `tools` is read for its PRESENCE only (`runtype.tools.reported`).
+ * `messages` and `systemPrompt` are Flue's normalized `LlmMessage` history and system prompt,
+ * byte-identical on both lines, read only when message content is opted in — see `messages.ts`.
  */
 interface FlueModelRequestInput {
+    systemPrompt?: string;
+    messages?: unknown[];
     tools?: unknown[];
 }
 interface FlueModelRequest extends FlueModelRequestInfo {
@@ -96,6 +61,8 @@ interface FlueModelRequest extends FlueModelRequestInfo {
 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. */
@@ -110,13 +77,8 @@ interface FlueModelResponse {
     error?: FlueErrorInfo;
 }
 /**
- * Classified error details on a live observation.
- *
- * `stack` is declared so the type is honest about what arrives, and is NEVER
- * read: it exposes filesystem paths and deployment layout, which is exactly the
- * class of value a vendor package landing in a healthcare stack must not put on
- * a wire the customer did not opt into. Flue's own durable serializers drop it
- * for the same reason.
+ * Classified error details. stack is described but never read or exported because it can expose
+ * deployment paths.
  */
 interface FlueErrorInfo {
     type?: string;
@@ -276,58 +238,21 @@ interface FlueInstrumentation {
 }
 
 /**
- * Opt-in tool content: `gen_ai.tool.call.arguments` and
- * `gen_ai.tool.call.result` on `execute_tool` spans.
- *
- * PURE, like `projection.ts`: value in, attribute string out. The projection
- * decides WHEN to call this (arguments when the tool span opens, the result
- * just before it closes); this module decides WHAT reaches the wire and how
- * much of it.
- *
- * ## Why opt-in, and why only tools
- *
- * The package's default contract is that no content leaves the process, and
- * that stays the default: an instrumentation that lands inside a PHI-bearing
- * process must not start shipping tool payloads because of a version bump.
- * The `content` option is the explicit decision, and it is per kind, so a
- * deployment can export the arguments it controls without the results a
- * third-party API returns.
- *
- * Tool content is the one kind this release can emit honestly. Flue declares
- * `tool_start.args` and `tool.result` stable, so both are on the same payloads
- * the span lifecycle already reads. Prompts and completions are NOT here:
- * they live on `AgentMessage`, which Flue marks unstable and this package
- * refuses to read (see `flue-types.ts`).
- *
- * ## The read-side contract this honours
- *
- * Runtype's ingest reads exactly these two attributes off an `execute_tool`
- * span (`packages/shared/src/otlp-runtype-semconv.ts`,
- * `GEN_AI_CONTENT_ATTRIBUTES`) and projects them to the tool card's input and
- * output. The value is a STRING: a JSON document is parsed back, anything
- * that does not parse is kept as plain text. It is admitted under a budget
- * (`packages/execution-ingest/src/ingest-content.ts`): a single attribute over
- * `MAX_CONTENT_ATTRIBUTE_CHARS` (256 KiB) is dropped WHOLE, not cut, and one
- * span may carry at most `MAX_CONTENT_SPAN_CHARS` (384 KiB) across every
- * content attribute. Both ceilings are why `maxChars` exists and why its
- * default sits where it does: arguments plus result at the default each fit
- * inside the per-span ceiling with room to spare, and a value this module has
- * already cut can never trip the per-attribute drop.
- *
- * The canonical `gen_ai.tool.call.*` names are emitted for every value,
- * string or not. Stock `@flue/opentelemetry` routes a stringified non-object
- * to `flue.tool.call.*` instead; ingest reads that alias only as a fallback,
- * and the semconv attribute type is a string either way, so there is nothing
- * to gain from the split.
- *
- * The two kinds are encoded differently because ingest projects them
- * differently: a RESULT is any text (a string as-is, anything else as JSON,
- * cut in place when over budget), while ARGUMENTS are always a JSON object,
- * see {@link encodeArguments}.
+ * 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;
+    }>;
+}
+
 /**
- * What to emit, per tool span. Every field is optional and every default is
- * OFF; passing `{}` changes nothing.
+ * 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 {
     /**
@@ -336,40 +261,51 @@ interface FlueContentOptions {
      */
     toolArguments?: boolean;
     /**
-     * Emit the tool's return value as `gen_ai.tool.call.result` just before the
-     * `execute_tool` span closes. Read from Flue's stable `tool.result` (2.x's
-     * `effectiveResult` — what the model was actually shown — when present).
-     *
-     * A FAILED tool's result is never emitted: on both Flue lines it commonly
-     * IS the error payload, and error messages stay off the wire under every
-     * setting of this option. The span still closes with its error type and
-     * exception class name, as before.
+     * 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;
     /**
-     * Ceiling on ONE emitted value, in UTF-16 code units, marker included.
-     * Defaults to {@link DEFAULT_CONTENT_MAX_CHARS}. A longer value is cut and
-     * ends in an explicit `…[truncated N chars]` marker, so a cut value never
-     * masquerades as complete.
-     *
-     * Clamped to {@link INGEST_CONTENT_ATTRIBUTE_CEILING}: above that, Runtype's
-     * ingest drops the attribute whole, which is strictly worse than a cut.
+     * Emit the conversation the run's first model turn 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`. Later turns of the same run only add tool traffic.
+     */
+    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;
     /**
-     * Rewrite a value before it is encoded. Runs on the RAW value, before
-     * stringification and truncation, so a redaction can address fields by name.
-     * Return `undefined` to suppress the attribute for this call entirely.
-     *
-     * An exception thrown here suppresses the attribute and nothing else: the
-     * span still opens and closes normally.
+     * 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;
 }
-interface FlueContentRedactContext {
+/**
+ * What `redact` is looking at. Tool kinds receive the raw Flue payload; `input_messages` and
+ * `output_messages` receive the projected {@link FlueContentMessage} array; `system_instructions`
+ * receives the prompt string.
+ */
+type FlueContentRedactContext = {
     kind: 'arguments' | 'result';
     toolName: string;
-}
+} | {
+    kind: 'input_messages' | 'output_messages' | 'system_instructions';
+    toolName?: undefined;
+};
+type FlueMessageContentKind = 'input_messages' | 'output_messages';
 /**
  * The default per-value ceiling: 64 KiB of ASCII. Large enough for any
  * realistic tool argument object and most results, and small enough that
@@ -378,67 +314,12 @@ interface FlueContentRedactContext {
  */
 declare const DEFAULT_CONTENT_MAX_CHARS = 65536;
 /**
- * Runtype ingest's per-attribute ceiling (`MAX_CONTENT_ATTRIBUTE_CHARS` in
- * `packages/execution-ingest/src/ingest-content.ts`), inlined for the same
- * reason `semconv.ts` inlines the attribute names — that package is private
- * and cannot resolve for a customer installing from npm. `tests/contract.test.ts`
- * pins the two equal.
+ * 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;
-
-/**
- * Flue observations → span intents. PURE: no `@opentelemetry/api`, no clock, no
- * I/O. `spans.ts` is the only module that touches a `Tracer`.
- *
- * The split is what makes the emit contract testable. Every attribute this
- * package puts on the wire is decided here, from a synthesized observation, and
- * asserted in `tests/projection.test.ts` against both the 1.x and 2.x shapes —
- * so a mapping regression is a unit-test failure rather than something only a
- * live export against a real agent would show.
- *
- * ## What is emitted, and why exactly this
- *
- * The read side is `packages/execution-ingest/src/otel-trace-ingest-service.ts`.
- * What it reads is this module's specification, so each choice below is a
- * consequence of a rule stated there:
- *
- * - **`invoke_agent` is the ENVELOPE and there is exactly one per trace.**
- *   `selectEnvelopeSpan` takes the first ARRAY-order `invoke_agent` span, and
- *   array order is exporter-controlled. A second one — which stock
- *   `@flue/opentelemetry` opens for every `task` delegation — is therefore a
- *   coin flip over which invocation bounds the run, whose status closes it, and
- *   (via `resolveTraceAgentId`'s span-level source) which agent it files under.
- *   So a delegated sub-agent gets a `flue.task` span with NO
- *   `gen_ai.operation.name`, and the delegation itself is reported where it
- *   actually belongs: as the `execute_tool` span for the `task` tool, typed
- *   `subagent`. Stock does the opposite — it suppresses that tool span and
- *   opens the nested `invoke_agent` — which is the one place this projection
- *   deliberately diverges from it.
- *
- * - **Usage is rolled up ONTO the envelope, summed from `turn` leaves.**
- *   `projectUsage` prefers an envelope roll-up precisely because a
- *   `BatchSpanProcessor` flushes children before their parent, so the batch
- *   carrying the terminal may hold no model calls at all. Flue's own docs say
- *   to sum model-turn leaves rather than the `operation` roll-up, because
- *   nested duration and usage values overlap. Both point the same way: sum
- *   `turn.response.usage`, put the total on `invoke_agent`.
- *
- * - **The envelope carries the model.** Stock puts none there, which left the
- *   envelope's log record showing no model at all; the server-side normalizer
- *   now lifts one, but only for traces it recognizes as Flue's. Emitting it
- *   directly is F1 and costs one attribute. Both ids come off the SAME turn, so
- *   the request-model fallback can never price one call's served model against
- *   another's requested one.
- *
- * - **`runtype.turn.index` / `runtype.iteration` ARE derived here, and are not
- *   derivable at ingest.** The server-side normalizer deliberately refuses
- *   them: Flue puts no absolute ordinal on the wire, and ranking opaque turn
- *   ids ranks whatever the export batch happened to carry — a five-turn run
- *   whose closing batch holds two turns would be recorded as two iterations.
- *   In-process the count is exact, because we see every `turn_request` in
- *   order. This is the clearest thing this package buys that a normalizer
- *   structurally cannot.
- */
+/** The resolved, always-complete policy the projection consults. */
+type FlueContentSetting = FlueContentOptions | false;
 
 /** Attribute values OTLP can carry. Deliberately narrower than OTel's type. */
 type SpanAttributes = Record<string, string | number | boolean | string[]>;
@@ -461,20 +342,8 @@ interface OpenSpanIntent {
     startTime?: string;
     attributes: SpanAttributes;
     /**
-     * Drop this span entirely rather than start it as the root of a new trace.
-     *
-     * Set on framework bookkeeping that only means anything INSIDE a run —
-     * `flue.operation shell` and `flue.compaction`. Both can occur outside one:
-     * `session.shell()` and `session.compact()` are public host APIs, and Flue
-     * intercepts only `prompt` and `skill` operations, so neither has a parent
-     * span or an active context to inherit.
-     *
-     * Started as a root, such a span becomes the ONLY span in its trace — and
-     * ingest's `selectEnvelopeSpan` falls back to the first parentless span when
-     * a trace carries no agent invocation, so it would be read as the envelope
-     * of a run and write a phantom execution row for every host-initiated shell
-     * command. This is the same reasoning `index.ts` applies to `coordinator`
-     * operations, applied to the other two paths that reach the same state.
+     * Drop bookkeeping spans without a parent: ingest could otherwise treat a host shell or compaction
+     * span as a phantom run envelope.
      */
     requiresParent?: boolean;
 }
@@ -488,11 +357,8 @@ interface CloseSpanIntent {
     ref: string;
     endTime?: string;
     /**
-     * Present when the span failed. Carries the error TYPE and the exception
-     * class NAME only — never a message and never a stack. Both are content: a
-     * provider error message routinely quotes the prompt back, and a stack
-     * exposes filesystem paths and deployment layout. Neither is read under any
-     * setting; the `content` opt-in covers tool payloads only.
+     * 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;
@@ -502,26 +368,17 @@ interface CloseSpanIntent {
 type SpanIntent = OpenSpanIntent | UpdateSpanIntent | CloseSpanIntent;
 interface FlueProjectionOptions {
     /**
-     * Runtype agent id per Flue agent name, e.g. `{ triage: 'agent_01j...' }`.
-     *
-     * Stamped on the ENVELOPE span as `runtype.agent.id` — the ratified second
-     * attribution placement, for the one shape a `Resource` cannot express: a
-     * single process running several Runtype agents. A single-agent deployment
-     * should set the resource attribute instead (see
-     * {@link runtypeFlueResourceAttributes} and the README recipe), which the
-     * ingest reader prefers.
-     *
-     * A delegated sub-agent is deliberately NOT attributed separately: its work
-     * runs inside the delegating agent's trace, and one trace is one execution.
+     * 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>;
     /**
-     * Opt in to tool content on `execute_tool` spans. Default: nothing. See
-     * {@link FlueContentOptions} for the per-kind switches, the size ceiling
-     * and the redaction hook, and `content.ts` for the read-side contract they
-     * honour.
+     * 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?: FlueContentOptions;
+    content?: FlueContentSetting;
 }
 /**
  * Resource attributes for the customer's `Resource`. Exported rather than set
@@ -533,28 +390,6 @@ declare function runtypeFlueResourceAttributes(resource?: {
     agentId?: string | null;
 }): SpanAttributes;
 
-/**
- * The attribute vocabulary this instrumentation emits: the GenAI semantic
- * conventions plus Runtype's ratified `runtype.*` extension names.
- *
- * ## Why the literals are inlined rather than imported
- *
- * The canonical home for the `runtype.*` names is
- * `packages/shared/src/otlp-runtype-semconv.ts`, and this module is a
- * CONSUMER of that contract, never a fork of it. But `@runtypelabs/shared` is
- * `private: true` and is not published to npm, while this package is — so a
- * runtime import would resolve in the monorepo and fail for every customer who
- * installs `@runtypelabs/flue-otel` from the registry.
- *
- * The discipline that keeps a copy from becoming a fork is
- * `tests/contract.test.ts`: a DEV-ONLY cross-import that asserts every literal
- * here is identical to the shared module's. A rename on either side is a red
- * build, in the same PR, which is the only mechanism that actually holds. It is
- * the same posture `examples/flue-persona` uses for the unified SSE vocabulary.
- *
- * Exact strings are load-bearing: a misspelled attribute fails no build — it
- * silently empties a column of every ingested run.
- */
 /**
  * GenAI semantic-convention attribute names. Mirrors the subset of
  * `packages/shared/src/gen-ai-semconv.ts` this instrumentation can populate
@@ -586,14 +421,14 @@ declare const GEN_AI: {
     readonly serverPort: "server.port";
 };
 /**
- * GenAI semconv CONTENT attribute names — the semconv Opt-In set. Kept apart
- * from {@link GEN_AI} on purpose: that table is what this package emits by
- * DEFAULT, and the contract test pins that no content name is in it. These
- * two reach the wire only under the `content` option (`content.ts`), and only
- * on `execute_tool` spans. Mirrors `GEN_AI_CONTENT_ATTRIBUTES` in
- * `packages/shared/src/otlp-runtype-semconv.ts`, which is what ingest reads.
+ * 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";
 };
@@ -640,52 +475,6 @@ declare const ADAPTER_NAME = "@runtypelabs/flue-otel";
 /** What this package reports itself as in `runtype.adapter.version`. */
 declare const ADAPTER_VERSION: string;
 
-/**
- * `@runtypelabs/flue-otel` — Runtype's OpenTelemetry instrumentation for Flue
- * agents.
- *
- * Install it with Flue's `instrument()` and every agent run becomes a trace of
- * GenAI-semconv spans carrying Runtype's `runtype.*` extension vocabulary, so
- * the run lands in Runtype at `t2-runtype` fidelity — full parity with a native
- * run — instead of the generic tier a stock export reaches.
- *
- * ```ts
- * import { instrument } from '@flue/runtime'
- * import { createRuntypeFlueInstrumentation } from '@runtypelabs/flue-otel'
- *
- * const stop = instrument(createRuntypeFlueInstrumentation())
- * ```
- *
- * ## What it is not
- *
- * It owns **no** OpenTelemetry SDK. There is no `@opentelemetry/sdk-*`
- * dependency, no provider, no exporter, no sampler, no flush. The application
- * configures those, this package writes spans through whatever is registered,
- * and the README carries the twelve-line recipe for a process that has none
- * yet. That is deliberate: a vendor package that installs its own tracing
- * pipeline fights the one the customer already runs, and in a stack exporting
- * to two backends it silently wins one of those fights.
- *
- * It also emits **no content by default** — no prompts, no completions, no
- * tool arguments or results, no error messages, no stack traces. Only
- * identifiers, structure and metrics reach the wire, which is the right
- * default for a package landing inside a PHI-bearing process. The one
- * explicit opt-in is `content`: tool arguments and results on `execute_tool`
- * spans, per kind, size-capped and redactable (`content.ts`). Prompts and
- * completions remain off the table until Flue exposes a stable message shape.
- *
- * ## Composing with other instrumentations
- *
- * Flue's `instrument()` composes — an error reporter and a tracer can subscribe
- * side by side — and this instrumentation carries its own `key`, so installing
- * it never replaces `@flue/opentelemetry`.
- *
- * **Point exactly one instrumentation at Runtype.** If both this package and a
- * stock `@flue/opentelemetry` export to the same Runtype endpoint, ingest sees
- * two `invoke_agent` spans for one run and the usage DOUBLES. Running both is
- * fine when they export to different backends.
- */
-
 /**
  * The instrumentation key. Distinct from stock's
  * `Symbol.for('@flue/opentelemetry')` so `instrument()` treats the two as
@@ -702,17 +491,10 @@ interface RuntypeFlueInstrumentationOptions extends FlueProjectionOptions {
     tracer?: Tracer;
 }
 /**
- * Build the instrumentation. Install it with Flue's `instrument()`, which
- * returns a disposer.
- *
- * The returned object implements the FULL `FlueInstrumentation` contract, not
- * just `observe`. The `interceptor` half is not optional in practice: it is
- * what makes each span the OTel ACTIVE context around the real agent, model and
- * tool work, so the platform's own HTTP and database spans nest inside the run
- * instead of landing in a separate trace — and it is the only place Flue offers
- * `executionContext.traceCarrier`, the W3C context that joins a dispatched run
- * to the trace that started it.
+ * 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 FlueContentOptions, type FlueContentRedactContext, type FlueInstrumentation, 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 { 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 };