@runtypelabs/flue-otel 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -42,35 +42,156 @@ function mapSettlementOutcome(outcome) {
   return void 0;
 }
 
+// src/messages.ts
+var ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant"]);
+var FLUE_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
+var SIGNAL_MESSAGE = /^\s*<([A-Za-z][\w-]*)\b[^>]*>[\s\S]*<\/\1>\s*$/;
+function projectFlueMessages(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    const message = projectFlueMessage(entry);
+    if (message) out.push(message);
+  }
+  return out;
+}
+function projectFlueMessage(value) {
+  if (!isRecord(value)) return void 0;
+  const role = value.role;
+  if (typeof role !== "string" || !FLUE_ROLES.has(role)) return void 0;
+  const text = flueMessageText(value.content);
+  if (text === "") return void 0;
+  if (role === "user" && SIGNAL_MESSAGE.test(text)) return void 0;
+  return { role, parts: [{ type: "text", content: text }] };
+}
+function flueMessageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const texts = [];
+  for (const part of content) {
+    if (!isRecord(part) || part.type !== "text") continue;
+    if (typeof part.text === "string" && part.text.length > 0) texts.push(part.text);
+  }
+  return texts.join("\n");
+}
+function normalizeContentMessages(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    const role = entry.role;
+    if (typeof role !== "string" || !ROLES.has(role)) continue;
+    const text = contentMessageText(entry);
+    if (text === "") continue;
+    out.push({ role, parts: [{ type: "text", content: text }] });
+  }
+  return out;
+}
+function contentTextOf(value) {
+  if (typeof value === "string") return value;
+  return Array.isArray(value) ? contentMessageText({ parts: value }) : "";
+}
+function contentMessageText(message) {
+  if (typeof message.content === "string") return message.content;
+  const parts = Array.isArray(message.parts) ? message.parts : Array.isArray(message.content) ? message.content : [];
+  const texts = [];
+  for (const part of parts) {
+    if (!isRecord(part) || part.type !== "text") continue;
+    const text = typeof part.content === "string" && part.content.length > 0 ? part.content : typeof part.text === "string" && part.text.length > 0 ? part.text : "";
+    if (text !== "") texts.push(text);
+  }
+  return texts.join("\n");
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/content.ts
 var DEFAULT_CONTENT_MAX_CHARS = 65536;
 var INGEST_CONTENT_ATTRIBUTE_CEILING = 262144;
-function resolveContentPolicy(options) {
+var INGEST_CONTENT_SPAN_CEILING = 393216;
+function resolveContentPolicy(setting) {
+  const options = setting === false ? void 0 : setting;
+  const on = (value) => setting !== false && value !== false;
   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,
+    toolArguments: on(options?.toolArguments),
+    toolResults: on(options?.toolResults),
+    inputMessages: on(options?.inputMessages),
+    outputMessages: on(options?.outputMessages),
+    systemInstructions: on(options?.systemInstructions),
     maxChars,
+    envelopeMaxChars: Math.min(maxChars, Math.floor(INGEST_CONTENT_SPAN_CEILING / 3)),
     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;
-  }
+  const redacted = applyRedact(value, policy, context3);
+  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 encodeMessagesValue(messages, policy, kind) {
+  if (messages.length === 0) return void 0;
+  const redacted = applyRedact(messages, policy, { kind });
+  if (redacted === void 0) return void 0;
+  const all = normalizeContentMessages(redacted);
+  if (all.length === 0) return void 0;
+  const maxChars = policy.envelopeMaxChars;
+  let start = all.length;
+  let total = 2;
+  while (start > 0) {
+    const length = JSON.stringify(all[start - 1]).length + (start < all.length ? 1 : 0);
+    if (total + length > maxChars) break;
+    total += length;
+    start -= 1;
+  }
+  if (start === 0) return JSON.stringify(all);
+  if (start < all.length) return JSON.stringify(all.slice(start));
+  return encodeTruncatedMessage(all[all.length - 1], maxChars);
+}
+function encodeSystemInstructionsValue(value, policy) {
+  if (value.length === 0) return void 0;
+  const redacted = applyRedact(value, policy, { kind: "system_instructions" });
+  if (redacted === void 0) return void 0;
+  const text = contentTextOf(redacted);
+  if (text.length === 0) return void 0;
+  return encodeTextParts(text, policy.envelopeMaxChars);
+}
+function encodeTruncatedMessage(message, maxChars) {
+  const text = message.parts.map((part) => part.content).join("\n");
+  return fitJson(
+    (cut) => JSON.stringify([{ role: message.role, parts: [{ type: "text", content: cut }] }]),
+    text,
+    maxChars
+  );
+}
+function encodeTextParts(text, maxChars) {
+  return fitJson((cut) => JSON.stringify([{ type: "text", content: cut }]), text, maxChars);
+}
+function fitJson(wrap, text, maxChars) {
+  let encoded = wrap(text);
+  if (encoded.length <= maxChars) return encoded;
+  let budget = maxChars - wrap("").length;
+  for (let round = 0; round < 8 && budget > 0; round += 1) {
+    encoded = wrap(truncate(text, budget));
+    if (encoded.length <= maxChars) return encoded;
+    budget -= encoded.length - maxChars;
+  }
+  return void 0;
+}
+function applyRedact(value, policy, context3) {
+  if (!policy.redact) return value;
+  try {
+    return policy.redact(value, context3);
+  } catch {
+    return void 0;
+  }
+}
 function encodeArguments(value, maxChars) {
   const shaped = isPlainObject(value) ? value : { value };
   const encoded = stringify(shaped);
@@ -118,7 +239,7 @@ function isHighSurrogate(code) {
 }
 
 // package.json
-var version = "0.4.0";
+var version = "0.5.0";
 
 // src/semconv.ts
 var GEN_AI = {
@@ -147,6 +268,9 @@ var GEN_AI = {
   serverPort: "server.port"
 };
 var GEN_AI_CONTENT = {
+  inputMessages: "gen_ai.input.messages",
+  outputMessages: "gen_ai.output.messages",
+  systemInstructions: "gen_ai.system_instructions",
   toolCallArguments: "gen_ai.tool.call.arguments",
   toolCallResult: "gen_ai.tool.call.result"
 };
@@ -300,9 +424,6 @@ function createFlueProjection(options = {}) {
           ...isEnvelope ? { [GEN_AI.operationName]: GEN_AI_OPERATION_INVOKE_AGENT } : {},
           ...isEnvelope && event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
           ...isEnvelope && event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
-          // The execution id LIFTS the tier and is claim-checked at ingest like
-          // 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 } : {},
           // WHY(README.md): the resource placement is the customer's to wire and is routinely skipped.
@@ -366,9 +487,7 @@ function createFlueProjection(options = {}) {
       {
         kind: "open",
         ref,
-        // Deliberately NOT `invoke_agent`: see this module's header. A second
-        // agent-invocation span in the trace is a coin flip over which one
-        // becomes the run's envelope.
+        // WHY(packages/flue-otel/src/projection.ts): Use a task span, not invoke_agent; one trace is persisted as one execution.
         name: agent ? `flue.task ${agent}` : "flue.task",
         spanKind: "internal",
         ...parentRef ? { parentRef } : {},
@@ -408,8 +527,6 @@ function createFlueProjection(options = {}) {
         ref,
         name: "flue.compaction",
         spanKind: "internal",
-        // `session.compact()` is callable by the host outside any turn, and a
-        // `compact` operation is not intercepted, so this can be parentless.
         requiresParent: true,
         ...parentRef ? { parentRef } : {},
         ...event.timestamp ? { startTime: event.timestamp } : {},
@@ -474,6 +591,7 @@ function createFlueProjection(options = {}) {
       if (!envelope.modelPinned && purpose === "agent")
         envelope.requestModel = request.requestedModel;
       if (Array.isArray(request.input?.tools)) envelope.toolsReported = true;
+      if (position?.atEnvelopeScope) captureInput(envelope, request);
     }
     return [
       {
@@ -519,20 +637,16 @@ function createFlueProjection(options = {}) {
       if (purpose === "agent" && response.finishReason) {
         envelope.lastFinishReason = response.finishReason;
       }
+      if (content.outputMessages && purpose === "agent" && !event.taskId && !isError) {
+        const output = projectFlueMessage(response.output);
+        if (output?.role === "assistant") envelope.outputMessage = output;
+      }
     }
     const attributes = {
       ...response.responseModel ? { [GEN_AI.responseModel]: response.responseModel } : {},
       ...response.responseId ? { [GEN_AI.responseId]: response.responseId } : {},
       ...response.finishReason ? { [GEN_AI.finishReasons]: [response.finishReason] } : {},
       ...usageAttributes(response.usage),
-      // Provider-diagnostic pointers, emitted only when Flue actually provides
-      // them. Both are optional and provider-dependent (Workers AI attaches
-      // both today); an absent value costs one column, a synthesized one would
-      // render as a measurement. `gatewayLogId` is a pointer to the content
-      // without shipping the content — a customer can click through to that
-      // exact request in their own AI Gateway dashboard. `providerFinishReason`
-      // is the provider's exact finish value before normalization, which our
-      // `GEN_AI.finishReasons` above deliberately hides.
       ...response.providerFinishReason ? { [RUNTYPE.providerFinishReason]: response.providerFinishReason } : {},
       ...response.gatewayLogId ? { [RUNTYPE.gatewayLogId]: response.gatewayLogId } : {}
     };
@@ -563,8 +677,6 @@ function createFlueProjection(options = {}) {
           ref,
           name: "flue.operation shell",
           spanKind: "internal",
-          // `session.shell()` is callable by the host outside any turn, and a
-          // `shell` operation is not intercepted, so this can be parentless.
           requiresParent: true,
           ...parentRef ? { parentRef } : {},
           ...event.timestamp ? { startTime: event.timestamp } : {},
@@ -596,10 +708,6 @@ function createFlueProjection(options = {}) {
           [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
-          // `runtype.tool.type` says what it actually is.
           ...isDelegation ? {} : { [GEN_AI.toolType]: "function" },
           ...toolType ? { [RUNTYPE.toolType]: toolType } : {},
           ...event.origin ? { [FLUE.toolOrigin]: event.origin } : {},
@@ -658,10 +766,28 @@ function createFlueProjection(options = {}) {
       } : {},
       ...stopReason ? { [RUNTYPE.stopReason]: stopReason } : {},
       ...envelope.toolsReported ? { [RUNTYPE.toolsReported]: true } : {},
-      // The highest loop position reached. Ingest records `max + 1` as the run's
-      // iteration count, so the envelope alone reports it correctly even when
-      // the batch carrying the model turns flushed earlier.
-      ...envelope.maxIteration !== null ? { [RUNTYPE.iteration]: envelope.maxIteration } : {}
+      ...envelope.maxIteration !== null ? { [RUNTYPE.iteration]: envelope.maxIteration } : {},
+      ...envelopeContentAttributes(envelope)
+    };
+  }
+  function captureInput(envelope, request) {
+    const input = request.input;
+    if (content.inputMessages) {
+      const messages = projectFlueMessages(input?.messages);
+      if (messages.length > 0) envelope.inputMessages = messages;
+    }
+    if (content.systemInstructions && typeof input?.systemPrompt === "string") {
+      envelope.systemInstructions = input.systemPrompt;
+    }
+  }
+  function envelopeContentAttributes(envelope) {
+    const input = envelope.inputMessages ? encodeMessagesValue(envelope.inputMessages, content, "input_messages") : void 0;
+    const system = envelope.systemInstructions ? encodeSystemInstructionsValue(envelope.systemInstructions, content) : void 0;
+    const output = envelope.outputMessage ? encodeMessagesValue([envelope.outputMessage], content, "output_messages") : void 0;
+    return {
+      ...input !== void 0 ? { [GEN_AI_CONTENT.inputMessages]: input } : {},
+      ...system !== void 0 ? { [GEN_AI_CONTENT.systemInstructions]: system } : {},
+      ...output !== void 0 ? { [GEN_AI_CONTENT.outputMessages]: output } : {}
     };
   }
   function resolveEnvelopeRef(event) {
@@ -781,9 +907,7 @@ function positionAttributes(position) {
   return {
     ...position.turnId ? { [RUNTYPE.turnId]: position.turnId } : {},
     [RUNTYPE.turnIndex]: position.index,
-    // Only the root agent's loop has an ITERATION. A delegated sub-agent's
-    // turns would otherwise inflate the run's iteration count, which ingest
-    // computes as the highest position across every span in the trace.
+    // WHY(packages/flue-otel/src/projection.ts): Do not stamp delegated turns with root iteration positions; they would inflate the run iteration count.
     ...position.atEnvelopeScope ? { [RUNTYPE.iteration]: position.index } : {}
   };
 }
@@ -809,9 +933,6 @@ function closeIntent(ref, event, isError, errorInfo) {
     ...isError ? {
       error: {
         type: errorInfo?.type ?? "_OTHER",
-        // The class NAME only. `errorInfo.message` and `.stack` are content
-        // and this release emits none: a provider message routinely quotes
-        // the prompt back, and a stack ships filesystem layout.
         ...errorInfo?.name ? { exceptionType: errorInfo.name } : {}
       }
     } : {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/flue-otel",
-  "version": "0.4.0",
+  "version": "0.5.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",
@@ -28,11 +28,12 @@
     "@opentelemetry/api": "^1.9.0"
   },
   "devDependencies": {
+    "@flue/runtime": "^2.0.3",
     "@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",
+    "@runtypelabs/execution-ingest": "0.6.25",
+    "@runtypelabs/shared": "3.41.0",
     "tsup": "^8.0.2",
     "typescript": "^6.0.3",
     "vitest": "^4.1.0"
@@ -68,7 +69,7 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "clean": "rm -rf dist",
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.tests.json",
     "test": "vitest run",
     "test:watch": "vitest watch",
     "lint": "eslint . --max-warnings 0"

package/CHANGELOG.md

@@ -1,105 +0,0 @@
-# @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.