@runtypelabs/flue-otel 0.3.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.3.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,11 +424,13 @@ 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 } : {}
+          ...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
+          } : {}
         }
       }
     ];
@@ -361,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 } : {},
@@ -403,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 } : {},
@@ -469,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 [
       {
@@ -514,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 } : {}
     };
@@ -558,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 } : {},
@@ -591,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 } : {},
@@ -653,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) {
@@ -776,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 } : {}
   };
 }
@@ -804,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.3.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,14 +28,15 @@
     "@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.25",
+    "@runtypelabs/shared": "3.41.0",
     "tsup": "^8.0.2",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.0",
-    "@runtypelabs/execution-ingest": "0.6.12",
-    "@runtypelabs/shared": "3.32.0"
+    "vitest": "^4.1.0"
   },
   "publishConfig": {
     "access": "public"
@@ -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"