@runtypelabs/flue-otel 0.2.2 → 0.3.0

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
@@ -105,11 +107,15 @@ 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.
+- `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 +185,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 +226,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.3.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();
@@ -343,7 +426,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 +469,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 +502,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 +580,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 +609,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 +626,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 +645,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 +852,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 +875,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 +1069,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.3.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();
@@ -310,7 +390,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 +433,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 +466,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 +544,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 +573,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 +590,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 +609,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 +816,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 +839,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 +1038,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.3.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",
@@ -34,7 +34,8 @@
     "tsup": "^8.0.2",
     "typescript": "^6.0.3",
     "vitest": "^4.1.0",
-    "@runtypelabs/shared": "3.28.0"
+    "@runtypelabs/execution-ingest": "0.6.12",
+    "@runtypelabs/shared": "3.32.0"
   },
   "publishConfig": {
     "access": "public"