@runtypelabs/flue-otel 0.2.2 → 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,105 @@
+# @runtypelabs/flue-otel
+
+## 0.4.0
+
+### Minor Changes
+
+- 21f5bbb: Make the producing instrumentation's version detectable server-side. `@runtypelabs/flue-otel` now stamps `runtype.adapter.name` / `runtype.adapter.version` on each run's `invoke_agent` span, so a trace identifies its producer without the customer wiring `runtypeFlueResourceAttributes` into their SDK `Resource`. OTLP trace ingest resolves the pair (resource level first, envelope span second) and records it on the run's log row as `otlpAdapterName` / `otlpAdapterVersion`, regardless of logging policy.
+
+## 0.3.0
+
+### Minor Changes
+
+- 01df868: Add an opt-in `content` option that emits tool arguments (`gen_ai.tool.call.arguments`, at span open) and tool results (`gen_ai.tool.call.result`, before span end) on `execute_tool` spans, so a Flue run's tool cards in Runtype show their input and output. Off by default; per-kind switches, a per-value `maxChars` ceiling with an explicit truncation marker (clamped to the ingest per-attribute ceiling), and a `redact` hook. A failed tool's result, the host's shell call, and prompts/completions are still never sent.
+
+## 0.2.2
+
+### Patch Changes
+
+- 5f00348: Carry Workers AI `gatewayLogId` and `providerFinishReason` onto the chat span
+
+  Flue's `turn` event carries two allowlisted raw-provider fields that
+  `@runtypelabs/flue-otel` previously dropped. Both are now emitted on the `chat`
+  span as `runtype.*` extension attributes, gated on presence so an absent value
+  costs nothing:
+  - `runtype.gateway.log_id` — the response's own gateway log id (e.g.
+    Cloudflare AI Gateway's `cf-aig-log-id`), a pointer to the request in the
+    customer's own AI Gateway dashboard without shipping the content.
+  - `runtype.provider.finish_reason` — the provider's exact finish value before
+    normalization (e.g. Workers AI's `tool_calls` behind the normalized
+    `toolUse`), for diagnosis when a run stops unexpectedly.
+
+  Both attribute names are added to the shared `RUNTYPE_ATTRIBUTES` vocabulary
+  (`packages/shared/src/otlp-runtype-semconv.ts`) so the emit side and the ingest
+  side stay in step. They are additive diagnostics and do not count toward the
+  achieved fidelity tier.
+
+## 0.2.1
+
+### Patch Changes
+
+- 625c455: Rewrite the README from first principles. It now leads with install, quick
+  start and the no-SDK recipe, then configuration, attribution, shutdown, and
+  what the package emits, instead of narrating how the package differs from
+  earlier instrumentations.
+
+## 0.2.0
+
+### Minor Changes
+
+- 2439b84: New package: `@runtypelabs/flue-otel`, an OpenTelemetry instrumentation for Flue
+  agents that reports runs to Runtype at `t2-runtype` fidelity.
+
+  Stock `@flue/opentelemetry` already exports GenAI semconv spans, and the ingest
+  normalizer shipped in #7336 lifts those to t2 by reading Flue's own `flue.*`
+  identifiers. This package is the client-side complement, for the facts a
+  server-side normalizer structurally cannot reach:
+  - **Absolute loop position.** `runtype.turn.index` / `runtype.iteration` are
+    deliberately NOT derived at ingest, because 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.
+  - **A run-level usage roll-up on the envelope.** Summed from `turn` leaves, so a
+    split export cannot lose the total: the batch carrying the terminal carries
+    the complete sum by construction.
+  - **Per-agent attribution for N agents in one process**, via the span-level
+    `runtype.agent.id` placement, keyed by Flue agent name.
+  - **One `invoke_agent` span per trace.** Stock opens a nested one for every
+    `task` delegation, which is a coin flip over which invocation bounds the run
+    (ingest's envelope selection is first-match over exporter-controlled array
+    order). Here a delegation is reported as an `execute_tool` span typed
+    `subagent`, and the sub-agent's work gets a non-agent `flue.task` span.
+
+  Works on both Flue lines (`>=1.0.0-beta.9` and 2.x) from one entry point, via a
+  capability probe rather than version comparison. Depends on `@opentelemetry/api`
+  only — no SDK, no provider, no exporter, no flush; the application owns those.
+
+  Emits no content in this release: no prompts, completions, tool arguments or
+  results, error messages, or stack traces.
+
+  `@runtypelabs/shared` exports the wire stop-reason tuple as `WIRE_STOP_REASONS`
+  (the zod enum is now derived from it, so the two cannot disagree). The ingest
+  reader writes `runtype.stop_reason` to `agent_executions.stop_reason` verbatim
+  with no enum validation, so an external producer has to spell those six strings
+  itself; exporting the tuple is what lets the producer's contract test pin its
+  copy and turn a rename into a red build instead of a silently wrong column.
+
+### Patch Changes
+
+- 3b4f69c: License `@runtypelabs/flue-otel` under MIT rather than Apache-2.0, and ship the
+  license text in the published tarball.
+
+  The package declared `Apache-2.0` in `package.json` and in its README while
+  carrying no license file at all, so the published artifact asserted a grant
+  whose terms it never included. `LICENSE` is now added to `files`, matching how
+  every other published package here (`cli`, `python-sdk`, `ruby-sdk`,
+  `java-sdk`, `php-sdk`) ships its license.
+
+- 3b4f69c: Normalize package authorship and copyright metadata.
+
+  The `author` field reads `Runtype` rather than `Runtype Labs` across every
+  workspace package that set it, and the copyright holder in each license file is
+  now `Runtype, Inc` — replacing `Travrse Labs, Inc` in the CLI and the four Fern
+  SDKs, and the `Runtype Labs` that the new `flue-otel` license was written with.
+
+  Metadata only: no source, dependency, or behavior change.

package/README.md

@@ -10,8 +10,9 @@ token usage, cost, loop iterations, tool calls and stop reason.
 - Works with Flue `>=1.0.0-beta.9` and 2.x from one entry point.
 - Depends on `@opentelemetry/api` only. It brings no SDK, provider, exporter or
   sampler; it writes through whatever your application has registered.
-- Emits identifiers, structure and metrics only. No prompts, completions, tool
-  arguments, tool results, error messages or stack traces reach the wire.
+- Emits identifiers, structure and metrics by default. No prompts, completions,
+  tool arguments, tool results, error messages or stack traces reach the wire
+  unless you opt in; the one opt-in is [tool content](#tool-content).
 
 Full guide: [Instrumenting a Flue agent](https://docs.runtype.com/developer-guides/guides/flue-instrumentation).
 
@@ -84,10 +85,11 @@ process.on('beforeExit', () => void provider.shutdown())
 
 `createRuntypeFlueInstrumentation(options?)` accepts:
 
-| Option   | Type                     | Purpose                                                                                                                                                                      |
-| -------- | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `agents` | `Record<string, string>` | Runtype agent id per Flue agent name, e.g. `{ triage: 'agent_01j...' }`. Stamped as `runtype.agent.id` on that agent's `invoke_agent` span. See [Attribution](#attribution). |
-| `tracer` | `Tracer`                 | Where spans are written. Defaults to `trace.getTracer('@runtypelabs/flue-otel')` on the global provider. Pass one to route Runtype spans through a separate provider.        |
+| Option    | Type                     | Purpose                                                                                                                                                                      |
+| --------- | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `agents`  | `Record<string, string>` | Runtype agent id per Flue agent name, e.g. `{ triage: 'agent_01j...' }`. Stamped as `runtype.agent.id` on that agent's `invoke_agent` span. See [Attribution](#attribution). |
+| `tracer`  | `Tracer`                 | Where spans are written. Defaults to `trace.getTracer('@runtypelabs/flue-otel')` on the global provider. Pass one to route Runtype spans through a separate provider.        |
+| `content` | `FlueContentOptions`     | Opt in to tool arguments and results on `execute_tool` spans. Off by default. See [Tool content](#tool-content).                                                             |
 
 The returned object implements Flue's full `FlueInstrumentation` contract:
 `observe` (builds spans from Flue's observation stream), `interceptor` (makes
@@ -104,12 +106,19 @@ subscriber. Its key is exported as `RUNTYPE_FLUE_INSTRUMENTATION_KEY`.
 
 - `runtypeFlueResourceAttributes({ agentId? })` builds the `runtype.*` resource
   attributes (`schema.version`, `adapter.name`, `adapter.version`, and
-  `agent.id` when given). Spread it into your SDK `Resource`.
-- `GEN_AI` and `RUNTYPE`: the attribute-name constants this package emits.
+  `agent.id` when given). Spread it into your SDK `Resource`. The adapter pair
+  is also stamped on each run's `invoke_agent` span, so Runtype can tell which
+  version produced a trace even when the resource is not wired; the resource
+  placement still wins where both are present.
+- `GEN_AI` and `RUNTYPE`: the attribute-name constants this package emits by
+  default; `GEN_AI_CONTENT`: the two it emits under the `content` opt-in.
+- `DEFAULT_CONTENT_MAX_CHARS` and `INGEST_CONTENT_ATTRIBUTE_CEILING`: the
+  content size defaults, see [Tool content](#tool-content).
 - `RUNTYPE_STOP_REASONS`, `RUNTYPE_TOOL_TYPES`, `RUNTYPE_SCHEMA_VERSION`,
   `ADAPTER_NAME`, `ADAPTER_VERSION`, plus the `RuntypeStopReason`,
   `RuntypeToolType`, `FlueInstrumentation`, `FlueProjectionOptions`,
-  `SpanAttributes` and `SpanIntent` types.
+  `FlueContentOptions`, `FlueContentRedactContext`, `SpanAttributes` and
+  `SpanIntent` types.
 
 ## Attribution
 
@@ -179,7 +188,7 @@ backends.
 | -------------------------------------------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `invoke_agent <agent>`                                         | once per agent invocation               | `gen_ai.agent.name`, `gen_ai.conversation.id`, the run's request/response model, summed token usage across every turn (`gen_ai.usage.*`), `runtype.stop_reason`, `runtype.tools.reported`, the highest loop iteration (`runtype.iteration`), `runtype.execution.id`, and `runtype.agent.id` when `agents` names the agent                                                                                                                                     |
 | `chat <model>`                                                 | once per model turn                     | `gen_ai.provider.name`, request/response model, response id, finish reason, per-turn usage, request parameters (`max_tokens`, `temperature`, reasoning level, server address), `runtype.turn.id` / `runtype.turn.index` / `runtype.iteration`, and `runtype.provider.finish_reason` / `runtype.gateway.log_id` when the provider records them (Workers AI attaches both — the gateway log id is a pointer to that exact request in your AI Gateway dashboard) |
-| `execute_tool <tool>`                                          | once per model-requested tool call      | `gen_ai.tool.name`, `gen_ai.tool.call.id`, the loop position it belongs to, `gen_ai.tool.type` (`function`) for every tool except a sub-agent delegation, and `runtype.tool.type` when the tool's class is known                                                                                                                                                                                                                                              |
+| `execute_tool <tool>`                                          | once per model-requested tool call      | `gen_ai.tool.name`, `gen_ai.tool.call.id`, the loop position it belongs to, `gen_ai.tool.type` (`function`) for every tool except a sub-agent delegation, and `runtype.tool.type` when the tool's class is known, and `gen_ai.tool.call.arguments` / `gen_ai.tool.call.result` only under the [`content`](#tool-content) opt-in                                                                                                                               |
 | `flue.task <agent>`, `flue.compaction`, `flue.operation shell` | delegation, compaction, host shell call | correlation ids only; framework structure, not agent invocations                                                                                                                                                                                                                                                                                                                                                                                              |
 
 Every span also carries Flue's own `flue.*` correlation attributes
@@ -220,6 +229,73 @@ Rules the projection follows:
 
 An absent attribute costs one column. A wrong one renders as a measurement.
 
+## Tool content
+
+By default an `execute_tool` span says which tool ran and how long it took, and
+Runtype's trace view shows its card as "No tool content in this trace". To see
+arguments and results on that card, opt in:
+
+```ts
+createRuntypeFlueInstrumentation({
+  content: {
+    toolArguments: true, // gen_ai.tool.call.arguments, set when the span opens
+    toolResults: true, // gen_ai.tool.call.result, set just before the span ends
+    maxChars: 65_536, // per value, marker included; this is the default
+    redact: (value, { kind, toolName }) => value, // optional; return undefined to drop
+  },
+})
+```
+
+Each switch is independent and defaults to off, so `{}` changes nothing. The
+values come from Flue's stable `tool_start.args` and `tool.result` payloads
+(2.x's `effectiveResult`, what the model was actually shown, when present).
+
+The attribute names are the GenAI semconv `gen_ai.tool.call.arguments` and
+`gen_ai.tool.call.result` (exported as `GEN_AI_CONTENT`), which Runtype reads
+onto the tool card's input and output. The two are encoded differently because
+Runtype projects them differently:
+
+- **Arguments are always a JSON object**, since that is the only shape the
+  reader projects. A non-object value (a bare string, an array) is carried as
+  `{ "value": ... }` rather than dropped. Over `maxChars`, the object is not
+  cut in place (a mid-document cut is not JSON and would be discarded); it is
+  replaced by `{ "truncated": "<head of the JSON>…[truncated N chars]" }`.
+- **A result is text**: a string as-is, anything else as JSON. Over `maxChars`
+  it is cut and ends in `…[truncated N chars]`, so a cut value never looks
+  complete.
+
+Ceilings worth knowing, because they decide what Runtype keeps:
+
+- `maxChars` defaults to `DEFAULT_CONTENT_MAX_CHARS` (64 KiB) and is clamped to
+  `INGEST_CONTENT_ATTRIBUTE_CEILING` (256 KiB). Runtype drops a single content
+  attribute above that ceiling **whole** rather than cutting it, which is why
+  the package cuts first.
+- One span may carry at most 384 KiB of content across every attribute, and one
+  export request at most 2 MiB of content. Arguments plus result at the default
+  fit inside the per-span ceiling; raise `maxChars` with that in mind.
+- Content makes spans large. A `BatchSpanProcessor` at its default 512 spans per
+  request can push an export past Runtype's 8 MiB request bound, which rejects
+  the whole batch (envelope and usage included, not only the content). With
+  both switches on, set `maxExportBatchSize` to something like 64.
+
+What is still never sent, whatever you set:
+
+- **A failed tool's result.** On both Flue lines it is commonly the error
+  payload, and error messages stay off the wire. The span still closes with its
+  error type and exception class name.
+- **The host's own shell call** (`session.shell()`), which is not a tool row.
+- **Prompts and completions.** They live on `AgentMessage`, which Flue marks
+  unstable. This package will read them once Flue exposes a stable shape. One
+  edge to know: a delegation to a sub-agent is a tool call, and its
+  **arguments carry the prompt handed to that sub-agent**. If that matters for
+  your deployment, drop it with `redact` (return `undefined` when `toolName`
+  is the delegation tool).
+
+`redact` runs on the raw value before encoding, so it can address fields by
+name; it receives `{ kind: 'arguments' | 'result', toolName }`. Returning
+`undefined` drops the attribute for that call. If it throws, the attribute is
+dropped and the span is otherwise unaffected.
+
 ## Flue compatibility
 
 The instrumentation reads only Flue's stable observation surface: event type

package/dist/index.cjs

@@ -22,7 +22,10 @@ var index_exports = {};
 __export(index_exports, {
   ADAPTER_NAME: () => ADAPTER_NAME,
   ADAPTER_VERSION: () => ADAPTER_VERSION,
+  DEFAULT_CONTENT_MAX_CHARS: () => DEFAULT_CONTENT_MAX_CHARS,
   GEN_AI: () => GEN_AI,
+  GEN_AI_CONTENT: () => GEN_AI_CONTENT,
+  INGEST_CONTENT_ATTRIBUTE_CEILING: () => INGEST_CONTENT_ATTRIBUTE_CEILING,
   RUNTYPE: () => RUNTYPE,
   RUNTYPE_FLUE_INSTRUMENTATION_KEY: () => RUNTYPE_FLUE_INSTRUMENTATION_KEY,
   RUNTYPE_SCHEMA_VERSION: () => RUNTYPE_SCHEMA_VERSION,
@@ -75,8 +78,83 @@ function mapSettlementOutcome(outcome) {
   return void 0;
 }
 
+// src/content.ts
+var DEFAULT_CONTENT_MAX_CHARS = 65536;
+var INGEST_CONTENT_ATTRIBUTE_CEILING = 262144;
+function resolveContentPolicy(options) {
+  const requested = options?.maxChars;
+  const maxChars = typeof requested === "number" && Number.isFinite(requested) && requested > 0 ? Math.min(Math.floor(requested), INGEST_CONTENT_ATTRIBUTE_CEILING) : DEFAULT_CONTENT_MAX_CHARS;
+  return {
+    toolArguments: options?.toolArguments === true,
+    toolResults: options?.toolResults === true,
+    maxChars,
+    redact: options?.redact
+  };
+}
+function encodeContentValue(value, policy, context3) {
+  if (value === void 0) return void 0;
+  let redacted = value;
+  if (policy.redact) {
+    try {
+      redacted = policy.redact(value, context3);
+    } catch {
+      return void 0;
+    }
+    if (redacted === void 0) return void 0;
+  }
+  if (context3.kind === "arguments") return encodeArguments(redacted, policy.maxChars);
+  const encoded = stringify(redacted);
+  if (encoded === void 0) return void 0;
+  return truncate(encoded, policy.maxChars);
+}
+function encodeArguments(value, maxChars) {
+  const shaped = isPlainObject(value) ? value : { value };
+  const encoded = stringify(shaped);
+  if (encoded === void 0) return void 0;
+  if (encoded.length <= maxChars) return encoded;
+  let budget = maxChars - TRUNCATED_WRAPPER_OVERHEAD;
+  for (let round = 0; round < 8 && budget > 0; round += 1) {
+    const wrapped = JSON.stringify({ truncated: truncate(encoded, budget) });
+    if (wrapped.length <= maxChars) return wrapped;
+    budget -= wrapped.length - maxChars;
+  }
+  return JSON.stringify({ truncated: truncate(encoded, Math.max(0, budget)) });
+}
+var TRUNCATED_WRAPPER_OVERHEAD = 16;
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    const encoded = JSON.stringify(value);
+    return typeof encoded === "string" ? encoded : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function truncate(value, maxChars) {
+  if (value.length <= maxChars) return value;
+  const upperBound = truncationMarker(value.length);
+  let keep = Math.max(0, maxChars - upperBound.length);
+  let marker = truncationMarker(value.length - keep);
+  keep = Math.max(0, maxChars - marker.length);
+  marker = truncationMarker(value.length - keep);
+  if (keep > 0 && isHighSurrogate(value.charCodeAt(keep - 1))) {
+    keep -= 1;
+    marker = truncationMarker(value.length - keep);
+  }
+  return value.slice(0, keep) + marker;
+}
+function truncationMarker(droppedChars) {
+  return `\u2026[truncated ${droppedChars} chars]`;
+}
+function isHighSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+
 // package.json
-var version = "0.2.2";
+var version = "0.4.0";
 
 // src/semconv.ts
 var GEN_AI = {
@@ -104,6 +182,10 @@ var GEN_AI = {
   serverAddress: "server.address",
   serverPort: "server.port"
 };
+var GEN_AI_CONTENT = {
+  toolCallArguments: "gen_ai.tool.call.arguments",
+  toolCallResult: "gen_ai.tool.call.result"
+};
 var GEN_AI_OPERATION_INVOKE_AGENT = "invoke_agent";
 var GEN_AI_OPERATION_CHAT = "chat";
 var GEN_AI_OPERATION_EXECUTE_TOOL = "execute_tool";
@@ -173,6 +255,7 @@ function runtypeFlueResourceAttributes(resource) {
   };
 }
 function createFlueProjection(options = {}) {
+  const content = resolveContentPolicy(options.content);
   const open = /* @__PURE__ */ new Map();
   const envelopes = /* @__PURE__ */ new Map();
   const envelopeByChain = /* @__PURE__ */ new Map();
@@ -257,7 +340,12 @@ function createFlueProjection(options = {}) {
           // any inbound id; it does not key the row, which stays derived from
           // the trace id.
           ...isEnvelope && event.submissionId ? { [RUNTYPE.executionId]: event.submissionId } : {},
-          ...isEnvelope && agentId ? { [RUNTYPE.agentId]: agentId } : {}
+          ...isEnvelope && agentId ? { [RUNTYPE.agentId]: agentId } : {},
+          // WHY(README.md): the resource placement is the customer's to wire and is routinely skipped.
+          ...isEnvelope ? {
+            [RUNTYPE.adapterName]: ADAPTER_NAME,
+            [RUNTYPE.adapterVersion]: ADAPTER_VERSION
+          } : {}
         }
       }
     ];
@@ -343,7 +431,12 @@ function createFlueProjection(options = {}) {
     const ref = compactionKey(event);
     if (open.has(ref)) return [];
     const parentRef = resolveParentRef(event);
-    open.set(ref, { ref, ...parentRef ? { parentRef } : {}, chainKey: chainKey(event), isTask: false });
+    open.set(ref, {
+      ref,
+      ...parentRef ? { parentRef } : {},
+      chainKey: chainKey(event),
+      isTask: false
+    });
     const reason = readString(event, "reason");
     return [
       {
@@ -381,7 +474,12 @@ function createFlueProjection(options = {}) {
     const purpose = readString(event, "purpose") ?? "agent";
     const compactionRef = compactionKey(event);
     const parentRef = purpose !== "agent" && open.has(compactionRef) ? compactionRef : resolveParentRef(event);
-    open.set(ref, { ref, ...parentRef ? { parentRef } : {}, chainKey: chainKey(event), isTask: false });
+    open.set(ref, {
+      ref,
+      ...parentRef ? { parentRef } : {},
+      chainKey: chainKey(event),
+      isTask: false
+    });
     const envelopeRef = resolveEnvelopeRef(event);
     const envelope = envelopeRef ? envelopes.get(envelopeRef) : void 0;
     let position;
@@ -409,7 +507,8 @@ function createFlueProjection(options = {}) {
       if (position) turnPositions.set(ref, position);
     }
     if (envelope) {
-      if (!envelope.modelPinned && purpose === "agent") envelope.requestModel = request.requestedModel;
+      if (!envelope.modelPinned && purpose === "agent")
+        envelope.requestModel = request.requestedModel;
       if (Array.isArray(request.input?.tools)) envelope.toolsReported = true;
     }
     return [
@@ -486,7 +585,12 @@ function createFlueProjection(options = {}) {
     const ref = toolKey(event);
     if (open.has(ref)) return [];
     const parentRef = resolveParentRef(event);
-    open.set(ref, { ref, ...parentRef ? { parentRef } : {}, chainKey: chainKey(event), isTask: false });
+    open.set(ref, {
+      ref,
+      ...parentRef ? { parentRef } : {},
+      chainKey: chainKey(event),
+      isTask: false
+    });
     const position = turnPositions.get(turnKey(event));
     if (isCallerShellCall(toolName, event)) {
       return [
@@ -510,6 +614,10 @@ function createFlueProjection(options = {}) {
     }
     const isDelegation = isTaskDelegationTool(toolName, event);
     const toolType = resolveToolType(toolName, event);
+    const args = content.toolArguments ? encodeContentValue(readUnknown(event, "args"), content, {
+      kind: "arguments",
+      toolName
+    }) : void 0;
     return [
       {
         kind: "open",
@@ -523,6 +631,7 @@ function createFlueProjection(options = {}) {
           [GEN_AI.operationName]: GEN_AI_OPERATION_EXECUTE_TOOL,
           [GEN_AI.toolName]: toolName,
           [GEN_AI.toolCallId]: toolCallId,
+          ...args !== void 0 ? { [GEN_AI_CONTENT.toolCallArguments]: args } : {},
           // The semconv `gen_ai.tool.type` domain is the transport-level one
           // (`function` / `extension` / `datastore`); a sub-agent delegation is
           // not a plain function call, so it is left unclaimed there while
@@ -541,9 +650,22 @@ function createFlueProjection(options = {}) {
     const ref = toolKey(event);
     if (!open.has(ref)) return [];
     const intents = sweepDescendants(ref, event.timestamp);
-    intents.push(
-      closeIntent(ref, event, readBoolean(event, "isError") === true, readErrorInfo(event))
-    );
+    const isError = readBoolean(event, "isError") === true;
+    const toolName = readString(event, "toolName");
+    if (content.toolResults && !isError && toolName && !isCallerShellCall(toolName, event)) {
+      const result = encodeContentValue(readToolResult(event), content, {
+        kind: "result",
+        toolName
+      });
+      if (result !== void 0) {
+        intents.push({
+          kind: "update",
+          ref,
+          attributes: { [GEN_AI_CONTENT.toolCallResult]: result }
+        });
+      }
+    }
+    intents.push(closeIntent(ref, event, isError, readErrorInfo(event)));
     open.delete(ref);
     return intents;
   }
@@ -735,6 +857,13 @@ function readErrorInfo(event) {
   const detail = event.errorInfo;
   return detail !== null && typeof detail === "object" ? detail : void 0;
 }
+function readUnknown(event, key) {
+  return event[key];
+}
+function readToolResult(event) {
+  const record = event;
+  return Object.prototype.hasOwnProperty.call(record, "effectiveResult") ? record.effectiveResult : record.result;
+}
 function readString(event, key) {
   const value = event[key];
   return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -751,7 +880,12 @@ function positiveNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
 function chainKey(value) {
-  return identityKey("chain", [value.instanceId, value.harness, value.conversationId, value.session]);
+  return identityKey("chain", [
+    value.instanceId,
+    value.harness,
+    value.conversationId,
+    value.session
+  ]);
 }
 function operationKey(value) {
   return identityKey("operation", [
@@ -940,7 +1074,10 @@ function readIdField(operation, key) {
 0 && (module.exports = {
   ADAPTER_NAME,
   ADAPTER_VERSION,
+  DEFAULT_CONTENT_MAX_CHARS,
   GEN_AI,
+  GEN_AI_CONTENT,
+  INGEST_CONTENT_ATTRIBUTE_CEILING,
   RUNTYPE,
   RUNTYPE_FLUE_INSTRUMENTATION_KEY,
   RUNTYPE_SCHEMA_VERSION,

package/dist/index.d.cts

@@ -193,12 +193,14 @@ type FlueEventVariant = {
     type: 'tool_start';
     toolName: string;
     toolCallId: string;
+    args?: unknown;
 } | {
     type: 'tool';
     toolName: string;
     toolCallId: string;
     isError?: boolean;
     result?: unknown;
+    effectiveResult?: unknown;
     durationMs?: number;
 } | {
     type: 'submission_settled';
@@ -273,6 +275,117 @@ interface FlueInstrumentation {
     dispose(): void | Promise<void>;
 }
 
+/**
+ * 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}.
+ */
+/**
+ * What to emit, per tool span. Every field is optional and every default is
+ * OFF; passing `{}` changes nothing.
+ */
+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 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.
+     */
+    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.
+     */
+    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?: (value: unknown, context: FlueContentRedactContext) => unknown;
+}
+interface FlueContentRedactContext {
+    kind: 'arguments' | 'result';
+    toolName: string;
+}
+/**
+ * The default per-value ceiling: 64 KiB of ASCII. Large enough for any
+ * realistic tool argument object and most results, and small enough that
+ * 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;
+/**
+ * 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.
+ */
+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`.
@@ -378,8 +491,8 @@ interface CloseSpanIntent {
      * 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. This release emits no
-     * content at all, so neither is read.
+     * exposes filesystem paths and deployment layout. Neither is read under any
+     * setting; the `content` opt-in covers tool payloads only.
      */
     error?: {
         type: string;
@@ -402,6 +515,13 @@ interface FlueProjectionOptions {
      * runs inside the delegating agent's trace, and one trace is one execution.
      */
     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?: FlueContentOptions;
 }
 /**
  * Resource attributes for the customer's `Resource`. Exported rather than set
@@ -465,6 +585,18 @@ declare const GEN_AI: {
     readonly serverAddress: "server.address";
     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.
+ */
+declare const GEN_AI_CONTENT: {
+    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
@@ -534,12 +666,13 @@ declare const ADAPTER_VERSION: string;
  * 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** in this release — no prompts, no completions, no
+ * 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. Content is a later,
- * explicitly opted-in increment; until then the safety story needs no
- * qualifiers, which is the right default for a package landing inside a
- * PHI-bearing process.
+ * 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
  *
@@ -582,4 +715,4 @@ interface RuntypeFlueInstrumentationOptions extends FlueProjectionOptions {
  */
 declare function createRuntypeFlueInstrumentation(options?: RuntypeFlueInstrumentationOptions): FlueInstrumentation;
 
-export { ADAPTER_NAME, ADAPTER_VERSION, type FlueInstrumentation, type FlueProjectionOptions, GEN_AI, 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 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 };

package/dist/index.d.ts

@@ -193,12 +193,14 @@ type FlueEventVariant = {
     type: 'tool_start';
     toolName: string;
     toolCallId: string;
+    args?: unknown;
 } | {
     type: 'tool';
     toolName: string;
     toolCallId: string;
     isError?: boolean;
     result?: unknown;
+    effectiveResult?: unknown;
     durationMs?: number;
 } | {
     type: 'submission_settled';
@@ -273,6 +275,117 @@ interface FlueInstrumentation {
     dispose(): void | Promise<void>;
 }
 
+/**
+ * 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}.
+ */
+/**
+ * What to emit, per tool span. Every field is optional and every default is
+ * OFF; passing `{}` changes nothing.
+ */
+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 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.
+     */
+    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.
+     */
+    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?: (value: unknown, context: FlueContentRedactContext) => unknown;
+}
+interface FlueContentRedactContext {
+    kind: 'arguments' | 'result';
+    toolName: string;
+}
+/**
+ * The default per-value ceiling: 64 KiB of ASCII. Large enough for any
+ * realistic tool argument object and most results, and small enough that
+ * 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;
+/**
+ * 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.
+ */
+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`.
@@ -378,8 +491,8 @@ interface CloseSpanIntent {
      * 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. This release emits no
-     * content at all, so neither is read.
+     * exposes filesystem paths and deployment layout. Neither is read under any
+     * setting; the `content` opt-in covers tool payloads only.
      */
     error?: {
         type: string;
@@ -402,6 +515,13 @@ interface FlueProjectionOptions {
      * runs inside the delegating agent's trace, and one trace is one execution.
      */
     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?: FlueContentOptions;
 }
 /**
  * Resource attributes for the customer's `Resource`. Exported rather than set
@@ -465,6 +585,18 @@ declare const GEN_AI: {
     readonly serverAddress: "server.address";
     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.
+ */
+declare const GEN_AI_CONTENT: {
+    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
@@ -534,12 +666,13 @@ declare const ADAPTER_VERSION: string;
  * 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** in this release — no prompts, no completions, no
+ * 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. Content is a later,
- * explicitly opted-in increment; until then the safety story needs no
- * qualifiers, which is the right default for a package landing inside a
- * PHI-bearing process.
+ * 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
  *
@@ -582,4 +715,4 @@ interface RuntypeFlueInstrumentationOptions extends FlueProjectionOptions {
  */
 declare function createRuntypeFlueInstrumentation(options?: RuntypeFlueInstrumentationOptions): FlueInstrumentation;
 
-export { ADAPTER_NAME, ADAPTER_VERSION, type FlueInstrumentation, type FlueProjectionOptions, GEN_AI, 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 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 };

package/dist/index.mjs

@@ -42,8 +42,83 @@ function mapSettlementOutcome(outcome) {
   return void 0;
 }
 
+// src/content.ts
+var DEFAULT_CONTENT_MAX_CHARS = 65536;
+var INGEST_CONTENT_ATTRIBUTE_CEILING = 262144;
+function resolveContentPolicy(options) {
+  const requested = options?.maxChars;
+  const maxChars = typeof requested === "number" && Number.isFinite(requested) && requested > 0 ? Math.min(Math.floor(requested), INGEST_CONTENT_ATTRIBUTE_CEILING) : DEFAULT_CONTENT_MAX_CHARS;
+  return {
+    toolArguments: options?.toolArguments === true,
+    toolResults: options?.toolResults === true,
+    maxChars,
+    redact: options?.redact
+  };
+}
+function encodeContentValue(value, policy, context3) {
+  if (value === void 0) return void 0;
+  let redacted = value;
+  if (policy.redact) {
+    try {
+      redacted = policy.redact(value, context3);
+    } catch {
+      return void 0;
+    }
+    if (redacted === void 0) return void 0;
+  }
+  if (context3.kind === "arguments") return encodeArguments(redacted, policy.maxChars);
+  const encoded = stringify(redacted);
+  if (encoded === void 0) return void 0;
+  return truncate(encoded, policy.maxChars);
+}
+function encodeArguments(value, maxChars) {
+  const shaped = isPlainObject(value) ? value : { value };
+  const encoded = stringify(shaped);
+  if (encoded === void 0) return void 0;
+  if (encoded.length <= maxChars) return encoded;
+  let budget = maxChars - TRUNCATED_WRAPPER_OVERHEAD;
+  for (let round = 0; round < 8 && budget > 0; round += 1) {
+    const wrapped = JSON.stringify({ truncated: truncate(encoded, budget) });
+    if (wrapped.length <= maxChars) return wrapped;
+    budget -= wrapped.length - maxChars;
+  }
+  return JSON.stringify({ truncated: truncate(encoded, Math.max(0, budget)) });
+}
+var TRUNCATED_WRAPPER_OVERHEAD = 16;
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    const encoded = JSON.stringify(value);
+    return typeof encoded === "string" ? encoded : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function truncate(value, maxChars) {
+  if (value.length <= maxChars) return value;
+  const upperBound = truncationMarker(value.length);
+  let keep = Math.max(0, maxChars - upperBound.length);
+  let marker = truncationMarker(value.length - keep);
+  keep = Math.max(0, maxChars - marker.length);
+  marker = truncationMarker(value.length - keep);
+  if (keep > 0 && isHighSurrogate(value.charCodeAt(keep - 1))) {
+    keep -= 1;
+    marker = truncationMarker(value.length - keep);
+  }
+  return value.slice(0, keep) + marker;
+}
+function truncationMarker(droppedChars) {
+  return `\u2026[truncated ${droppedChars} chars]`;
+}
+function isHighSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+
 // package.json
-var version = "0.2.2";
+var version = "0.4.0";
 
 // src/semconv.ts
 var GEN_AI = {
@@ -71,6 +146,10 @@ var GEN_AI = {
   serverAddress: "server.address",
   serverPort: "server.port"
 };
+var GEN_AI_CONTENT = {
+  toolCallArguments: "gen_ai.tool.call.arguments",
+  toolCallResult: "gen_ai.tool.call.result"
+};
 var GEN_AI_OPERATION_INVOKE_AGENT = "invoke_agent";
 var GEN_AI_OPERATION_CHAT = "chat";
 var GEN_AI_OPERATION_EXECUTE_TOOL = "execute_tool";
@@ -140,6 +219,7 @@ function runtypeFlueResourceAttributes(resource) {
   };
 }
 function createFlueProjection(options = {}) {
+  const content = resolveContentPolicy(options.content);
   const open = /* @__PURE__ */ new Map();
   const envelopes = /* @__PURE__ */ new Map();
   const envelopeByChain = /* @__PURE__ */ new Map();
@@ -224,7 +304,12 @@ function createFlueProjection(options = {}) {
           // any inbound id; it does not key the row, which stays derived from
           // the trace id.
           ...isEnvelope && event.submissionId ? { [RUNTYPE.executionId]: event.submissionId } : {},
-          ...isEnvelope && agentId ? { [RUNTYPE.agentId]: agentId } : {}
+          ...isEnvelope && agentId ? { [RUNTYPE.agentId]: agentId } : {},
+          // WHY(README.md): the resource placement is the customer's to wire and is routinely skipped.
+          ...isEnvelope ? {
+            [RUNTYPE.adapterName]: ADAPTER_NAME,
+            [RUNTYPE.adapterVersion]: ADAPTER_VERSION
+          } : {}
         }
       }
     ];
@@ -310,7 +395,12 @@ function createFlueProjection(options = {}) {
     const ref = compactionKey(event);
     if (open.has(ref)) return [];
     const parentRef = resolveParentRef(event);
-    open.set(ref, { ref, ...parentRef ? { parentRef } : {}, chainKey: chainKey(event), isTask: false });
+    open.set(ref, {
+      ref,
+      ...parentRef ? { parentRef } : {},
+      chainKey: chainKey(event),
+      isTask: false
+    });
     const reason = readString(event, "reason");
     return [
       {
@@ -348,7 +438,12 @@ function createFlueProjection(options = {}) {
     const purpose = readString(event, "purpose") ?? "agent";
     const compactionRef = compactionKey(event);
     const parentRef = purpose !== "agent" && open.has(compactionRef) ? compactionRef : resolveParentRef(event);
-    open.set(ref, { ref, ...parentRef ? { parentRef } : {}, chainKey: chainKey(event), isTask: false });
+    open.set(ref, {
+      ref,
+      ...parentRef ? { parentRef } : {},
+      chainKey: chainKey(event),
+      isTask: false
+    });
     const envelopeRef = resolveEnvelopeRef(event);
     const envelope = envelopeRef ? envelopes.get(envelopeRef) : void 0;
     let position;
@@ -376,7 +471,8 @@ function createFlueProjection(options = {}) {
       if (position) turnPositions.set(ref, position);
     }
     if (envelope) {
-      if (!envelope.modelPinned && purpose === "agent") envelope.requestModel = request.requestedModel;
+      if (!envelope.modelPinned && purpose === "agent")
+        envelope.requestModel = request.requestedModel;
       if (Array.isArray(request.input?.tools)) envelope.toolsReported = true;
     }
     return [
@@ -453,7 +549,12 @@ function createFlueProjection(options = {}) {
     const ref = toolKey(event);
     if (open.has(ref)) return [];
     const parentRef = resolveParentRef(event);
-    open.set(ref, { ref, ...parentRef ? { parentRef } : {}, chainKey: chainKey(event), isTask: false });
+    open.set(ref, {
+      ref,
+      ...parentRef ? { parentRef } : {},
+      chainKey: chainKey(event),
+      isTask: false
+    });
     const position = turnPositions.get(turnKey(event));
     if (isCallerShellCall(toolName, event)) {
       return [
@@ -477,6 +578,10 @@ function createFlueProjection(options = {}) {
     }
     const isDelegation = isTaskDelegationTool(toolName, event);
     const toolType = resolveToolType(toolName, event);
+    const args = content.toolArguments ? encodeContentValue(readUnknown(event, "args"), content, {
+      kind: "arguments",
+      toolName
+    }) : void 0;
     return [
       {
         kind: "open",
@@ -490,6 +595,7 @@ function createFlueProjection(options = {}) {
           [GEN_AI.operationName]: GEN_AI_OPERATION_EXECUTE_TOOL,
           [GEN_AI.toolName]: toolName,
           [GEN_AI.toolCallId]: toolCallId,
+          ...args !== void 0 ? { [GEN_AI_CONTENT.toolCallArguments]: args } : {},
           // The semconv `gen_ai.tool.type` domain is the transport-level one
           // (`function` / `extension` / `datastore`); a sub-agent delegation is
           // not a plain function call, so it is left unclaimed there while
@@ -508,9 +614,22 @@ function createFlueProjection(options = {}) {
     const ref = toolKey(event);
     if (!open.has(ref)) return [];
     const intents = sweepDescendants(ref, event.timestamp);
-    intents.push(
-      closeIntent(ref, event, readBoolean(event, "isError") === true, readErrorInfo(event))
-    );
+    const isError = readBoolean(event, "isError") === true;
+    const toolName = readString(event, "toolName");
+    if (content.toolResults && !isError && toolName && !isCallerShellCall(toolName, event)) {
+      const result = encodeContentValue(readToolResult(event), content, {
+        kind: "result",
+        toolName
+      });
+      if (result !== void 0) {
+        intents.push({
+          kind: "update",
+          ref,
+          attributes: { [GEN_AI_CONTENT.toolCallResult]: result }
+        });
+      }
+    }
+    intents.push(closeIntent(ref, event, isError, readErrorInfo(event)));
     open.delete(ref);
     return intents;
   }
@@ -702,6 +821,13 @@ function readErrorInfo(event) {
   const detail = event.errorInfo;
   return detail !== null && typeof detail === "object" ? detail : void 0;
 }
+function readUnknown(event, key) {
+  return event[key];
+}
+function readToolResult(event) {
+  const record = event;
+  return Object.prototype.hasOwnProperty.call(record, "effectiveResult") ? record.effectiveResult : record.result;
+}
 function readString(event, key) {
   const value = event[key];
   return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -718,7 +844,12 @@ function positiveNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
 function chainKey(value) {
-  return identityKey("chain", [value.instanceId, value.harness, value.conversationId, value.session]);
+  return identityKey("chain", [
+    value.instanceId,
+    value.harness,
+    value.conversationId,
+    value.session
+  ]);
 }
 function operationKey(value) {
   return identityKey("operation", [
@@ -912,7 +1043,10 @@ function readIdField(operation, key) {
 export {
   ADAPTER_NAME,
   ADAPTER_VERSION,
+  DEFAULT_CONTENT_MAX_CHARS,
   GEN_AI,
+  GEN_AI_CONTENT,
+  INGEST_CONTENT_ATTRIBUTE_CEILING,
   RUNTYPE,
   RUNTYPE_FLUE_INSTRUMENTATION_KEY,
   RUNTYPE_SCHEMA_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/flue-otel",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "OpenTelemetry instrumentation for Flue agents that emits GenAI semconv spans plus Runtype's runtype.* extension vocabulary, so a Flue run lands in Runtype at full fidelity.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -31,10 +31,11 @@
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/context-async-hooks": "^2.1.0",
     "@opentelemetry/sdk-trace-base": "^2.1.0",
+    "@runtypelabs/execution-ingest": "0.6.18",
+    "@runtypelabs/shared": "3.35.1",
     "tsup": "^8.0.2",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.0",
-    "@runtypelabs/shared": "3.28.0"
+    "vitest": "^4.1.0"
   },
   "publishConfig": {
     "access": "public"