@sentry/junior 0.96.0 → 0.97.0

package/dist/chunk-AUUCAFDE.js

@@ -0,0 +1,546 @@
+import {
+  conversationSummaryFromStoredConversation
+} from "./chunk-ON6YKIQ7.js";
+import {
+  buildSentryConversationUrl,
+  buildSentryTraceUrl
+} from "./chunk-LVUKF5CE.js";
+import {
+  loadProjection,
+  projectSteps
+} from "./chunk-GUAP3H7O.js";
+import {
+  getAgentStepStore,
+  getConversationMessageStore
+} from "./chunk-35BNLDOJ.js";
+import {
+  unescapeXml,
+  unwrapCurrentInstruction
+} from "./chunk-EEZCY5WX.js";
+import {
+  canExposeConversationPayload
+} from "./chunk-LVA4I4H7.js";
+import {
+  isRecord
+} from "./chunk-OB42YVAE.js";
+
+// src/api/conversations/transcript.ts
+var SAFE_METADATA_KEY_LIMIT = 20;
+var LEGACY_ADVISOR_TASK_OPEN = "<advisor-task>\n";
+var LEGACY_ADVISOR_TASK_CLOSE = "\n</advisor-task>";
+var LEGACY_EXECUTOR_CONTEXT_OPEN = "<executor-context>\n";
+var LEGACY_EXECUTOR_CONTEXT_CLOSE = "\n</executor-context>";
+function unwrapLegacyAdvisorTask(text) {
+  if (!text.startsWith(LEGACY_ADVISOR_TASK_OPEN) || !text.endsWith(LEGACY_EXECUTOR_CONTEXT_CLOSE)) {
+    return void 0;
+  }
+  const taskEnd = text.indexOf(
+    LEGACY_ADVISOR_TASK_CLOSE,
+    LEGACY_ADVISOR_TASK_OPEN.length
+  );
+  if (taskEnd < 0) return void 0;
+  const contextStart = taskEnd + LEGACY_ADVISOR_TASK_CLOSE.length + 2;
+  if (!text.startsWith(LEGACY_EXECUTOR_CONTEXT_OPEN, contextStart)) {
+    return void 0;
+  }
+  const task = text.slice(LEGACY_ADVISOR_TASK_OPEN.length, taskEnd);
+  const context = text.slice(
+    contextStart + LEGACY_EXECUTOR_CONTEXT_OPEN.length,
+    -LEGACY_EXECUTOR_CONTEXT_CLOSE.length
+  );
+  return `${unescapeXml(task)}
+
+Executor context:
+${unescapeXml(context)}`;
+}
+function textPart(text) {
+  return { type: "text", text };
+}
+function recordField(value, names) {
+  for (const name of names) {
+    if (value[name] !== void 0) {
+      return value[name];
+    }
+  }
+  return void 0;
+}
+function normalizeTranscriptPart(part, options = {}) {
+  const displayText = (text) => {
+    if (options.unwrapCurrentTask) {
+      const instruction = unwrapCurrentInstruction(text);
+      if (instruction !== void 0) return instruction;
+    }
+    if (options.unwrapLegacyAdvisorTask) {
+      return unwrapLegacyAdvisorTask(text) ?? text;
+    }
+    return text;
+  };
+  if (typeof part === "string") {
+    return textPart(displayText(part));
+  }
+  if (!isRecord(part)) {
+    return { type: "unknown", output: part };
+  }
+  const rawType = typeof part.type === "string" ? part.type : "unknown";
+  if (rawType === "text") {
+    const text = recordField(part, ["text", "content"]);
+    return textPart(
+      typeof text === "string" ? displayText(text) : JSON.stringify(text) ?? ""
+    );
+  }
+  if (rawType === "toolCall") {
+    return {
+      type: "tool_call",
+      ...typeof part.id === "string" ? { id: part.id } : {},
+      ...typeof part.name === "string" ? { name: part.name } : {},
+      input: recordField(part, ["arguments", "input", "args"])
+    };
+  }
+  if (rawType === "toolResult") {
+    return {
+      type: "tool_result",
+      ...typeof part.id === "string" ? { id: part.id } : {},
+      ...typeof part.name === "string" ? { name: part.name } : {},
+      output: recordField(part, ["result", "output", "content"])
+    };
+  }
+  if (rawType === "thinking") {
+    return {
+      type: "thinking",
+      output: recordField(part, ["thinking", "text", "content", "output"])
+    };
+  }
+  return {
+    type: "unknown",
+    ...rawType !== "unknown" ? { sourceType: rawType } : {},
+    output: part
+  };
+}
+function normalizeToolResultMessage(record) {
+  const content = record.content;
+  let output = content;
+  if (Array.isArray(content) && content.length === 1 && isRecord(content[0])) {
+    const extracted = recordField(content[0], [
+      "text",
+      "content",
+      "output",
+      "result"
+    ]);
+    output = extracted !== void 0 ? extracted : content;
+  }
+  return {
+    type: "tool_result",
+    ...typeof record.toolCallId === "string" ? { id: record.toolCallId } : {},
+    ...typeof record.name === "string" ? { name: record.name } : typeof record.toolName === "string" ? { name: record.toolName } : {},
+    output
+  };
+}
+function normalizeTranscriptMessage(message) {
+  return normalizeMessage(message);
+}
+function normalizeSubagentTranscriptMessage(message, subagentKind) {
+  return normalizeMessage(message, {
+    unwrapLegacyAdvisorTask: subagentKind === "advisor"
+  });
+}
+function normalizeMessage(message, options = {}) {
+  const record = message;
+  const content = record.content;
+  const role = transcriptRole(record.role);
+  return {
+    role,
+    ...typeof record.timestamp === "number" ? { timestamp: record.timestamp } : {},
+    parts: role === "toolResult" ? [normalizeToolResultMessage(record)] : Array.isArray(content) ? content.map(
+      (part) => normalizeTranscriptPart(part, {
+        unwrapCurrentTask: role === "user",
+        unwrapLegacyAdvisorTask: options.unwrapLegacyAdvisorTask && role === "user"
+      })
+    ) : [
+      normalizeTranscriptPart(content, {
+        unwrapCurrentTask: role === "user",
+        unwrapLegacyAdvisorTask: options.unwrapLegacyAdvisorTask && role === "user"
+      })
+    ]
+  };
+}
+function transcriptRole(role) {
+  return role === "assistant" || role === "system" || role === "tool" || role === "toolResult" || role === "user" ? role : "unknown";
+}
+function serializedChars(value) {
+  if (typeof value === "string") return value.length;
+  return JSON.stringify(value)?.length ?? 0;
+}
+function serializedBytes(value) {
+  const serialized = typeof value === "string" ? value : JSON.stringify(value);
+  return new TextEncoder().encode(serialized ?? "").byteLength;
+}
+function payloadType(value) {
+  return Array.isArray(value) ? "array" : typeof value;
+}
+function payloadKeys(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const keys = Object.keys(value).slice(
+    0,
+    SAFE_METADATA_KEY_LIMIT
+  );
+  return keys.length > 0 ? keys : void 0;
+}
+function redactedPayloadFields(prefix, value) {
+  const keys = payloadKeys(value);
+  return {
+    [`${prefix}Type`]: payloadType(value),
+    [`${prefix}SizeBytes`]: serializedBytes(value),
+    [`${prefix}SizeChars`]: serializedChars(value),
+    ...keys ? { [`${prefix}Keys`]: keys } : {}
+  };
+}
+function redactTranscriptPart(part) {
+  if (part.type === "text") {
+    return {
+      type: "text",
+      redacted: true,
+      bytes: serializedBytes(part.text ?? ""),
+      chars: serializedChars(part.text ?? "")
+    };
+  }
+  if (part.type === "thinking") {
+    return {
+      type: "thinking",
+      redacted: true,
+      ...redactedPayloadFields("output", part.output)
+    };
+  }
+  if (part.type === "tool_call") {
+    return {
+      type: "tool_call",
+      redacted: true,
+      ...part.id ? { id: part.id } : {},
+      ...part.name ? { name: part.name } : {},
+      ...redactedPayloadFields("input", part.input)
+    };
+  }
+  if (part.type === "tool_result") {
+    return {
+      type: "tool_result",
+      redacted: true,
+      ...part.id ? { id: part.id } : {},
+      ...part.name ? { name: part.name } : {},
+      ...redactedPayloadFields("output", part.output)
+    };
+  }
+  return {
+    type: "unknown",
+    redacted: true,
+    ...part.sourceType ? { sourceType: part.sourceType } : {},
+    ...redactedPayloadFields("output", part.output ?? part.input ?? part.text)
+  };
+}
+function redactTranscriptMessage(message) {
+  return {
+    role: message.role,
+    ...typeof message.timestamp === "number" ? { timestamp: message.timestamp } : {},
+    parts: message.parts.map(redactTranscriptPart)
+  };
+}
+function isConversationMessageRole(role) {
+  return role === "user" || role === "assistant";
+}
+function hasTextPart(message) {
+  return message.parts.some((part) => {
+    if (part.type !== "text") return false;
+    if (part.redacted) return true;
+    return typeof part.text === "string" && part.text.trim().length > 0;
+  });
+}
+function isConversationMessage(message) {
+  if (!isConversationMessageRole(message.role)) return false;
+  if (message.role === "assistant") return hasTextPart(message);
+  return message.parts.length > 0;
+}
+function countConversationMessages(transcript) {
+  return transcript.filter(isConversationMessage).length;
+}
+function traceIdFromTranscript(transcript) {
+  for (const message of transcript) {
+    for (const part of message.parts) {
+      const text = part.text ?? (typeof part.output === "string" ? part.output : typeof part.input === "string" ? part.input : void 0);
+      const match = text?.match(
+        /\btrace[_-]?id["']?\s*[:=]\s*["']?([a-f0-9]{16,32})\b/i
+      );
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+  }
+  return void 0;
+}
+function subagentTranscriptReport(activity, options = {}) {
+  return {
+    type: "subagent",
+    ...options.subagentConversationId ? { subagentConversationId: options.subagentConversationId } : {},
+    createdAt: activity.createdAt,
+    id: activity.id,
+    ...activity.modelId ? { modelId: activity.modelId } : {},
+    status: activity.status,
+    ...options.subagentSentryConversationUrl ? { subagentSentryConversationUrl: options.subagentSentryConversationUrl } : {},
+    subagentKind: activity.subagentKind,
+    transcript: options.transcript ?? [],
+    transcriptAvailable: Boolean(options.transcript?.length),
+    ...activity.endedAt ? { endedAt: activity.endedAt } : {},
+    ...activity.outcome ? { outcome: activity.outcome } : {},
+    ...activity.parentToolCallId ? { parentToolCallId: activity.parentToolCallId } : {},
+    ...activity.reasoningLevel ? { reasoningLevel: activity.reasoningLevel } : {},
+    ...options.transcriptMessageCount !== void 0 ? { transcriptMessageCount: options.transcriptMessageCount } : {},
+    ...options.transcriptRedacted ? { transcriptRedacted: options.transcriptRedacted } : {},
+    ...options.transcriptRedactionReason ? { transcriptRedactionReason: options.transcriptRedactionReason } : {},
+    ...options.transcriptExpired ? { transcriptExpired: options.transcriptExpired } : {},
+    ...options.transcriptExpiredAt ? { transcriptExpiredAt: options.transcriptExpiredAt } : {},
+    ...options.unavailableReason ? { unavailableReason: options.unavailableReason } : {}
+  };
+}
+
+// src/api/conversations/activity.ts
+function toolResultStatuses(messages) {
+  const statuses = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const record = message;
+    if (record.role !== "toolResult" || typeof record.toolCallId !== "string") {
+      continue;
+    }
+    statuses.set(record.toolCallId, record.isError ? "error" : "completed");
+  }
+  return statuses;
+}
+function activityPayloadFields(args, canExposePayload) {
+  if (args === void 0) {
+    return {};
+  }
+  return canExposePayload ? { args } : { redacted: true, ...redactedPayloadFields("input", args) };
+}
+function buildConversationActivityFromSteps(args) {
+  const toolStatuses = toolResultStatuses(args.messages);
+  const subagentEnds = /* @__PURE__ */ new Map();
+  const subagentsByToolCallId = /* @__PURE__ */ new Map();
+  const orphanSubagents = [];
+  for (const step of args.steps) {
+    if (step.entry.type === "subagent_ended") {
+      subagentEnds.set(
+        step.entry.subagentInvocationId,
+        step
+      );
+    }
+  }
+  for (const step of args.steps) {
+    if (step.entry.type !== "subagent_started") {
+      continue;
+    }
+    const start = step;
+    const parentStatus = start.entry.parentToolCallId ? toolStatuses.get(start.entry.parentToolCallId) : void 0;
+    const activity = subagentActivityFromSteps(
+      start,
+      subagentEnds.get(start.entry.subagentInvocationId),
+      { canExposeTranscript: args.canExposePayload, parentStatus }
+    );
+    if (start.entry.parentToolCallId) {
+      subagentsByToolCallId.set(start.entry.parentToolCallId, [
+        ...subagentsByToolCallId.get(start.entry.parentToolCallId) ?? [],
+        activity
+      ]);
+      continue;
+    }
+    orphanSubagents.push(activity);
+  }
+  const rows = [];
+  for (const step of args.steps) {
+    if (step.entry.type !== "tool_execution_started") {
+      continue;
+    }
+    rows.push({
+      type: "tool_execution",
+      id: step.entry.toolCallId,
+      toolCallId: step.entry.toolCallId,
+      toolName: step.entry.toolName,
+      createdAt: new Date(step.createdAtMs).toISOString(),
+      status: toolStatuses.get(step.entry.toolCallId) ?? "running",
+      subagents: subagentsByToolCallId.get(step.entry.toolCallId) ?? [],
+      ...activityPayloadFields(step.entry.args, args.canExposePayload)
+    });
+  }
+  return [...rows, ...orphanSubagents].sort(
+    (left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt) || left.id.localeCompare(right.id)
+  );
+}
+function subagentActivityFromSteps(start, end, options = {}) {
+  return {
+    type: "subagent",
+    id: start.entry.subagentInvocationId,
+    subagentKind: start.entry.subagentKind,
+    ...start.entry.modelId ? { modelId: start.entry.modelId } : {},
+    ...start.entry.parentToolCallId ? { parentToolCallId: start.entry.parentToolCallId } : {},
+    ...start.entry.reasoningLevel ? { reasoningLevel: start.entry.reasoningLevel } : {},
+    createdAt: new Date(start.createdAtMs).toISOString(),
+    ...end ? {
+      endedAt: new Date(end.createdAtMs).toISOString(),
+      outcome: end.entry.outcome,
+      status: end.entry.outcome,
+      // Every subagent is a child conversation whose transcript loads on
+      // demand; expose the affordance only when the parent is public.
+      ...options.canExposeTranscript ? { transcriptAvailable: true } : {}
+    } : { status: options.parentStatus ?? "running" }
+  };
+}
+
+// src/api/conversations/detail-projection.ts
+async function currentRunContent(args) {
+  const steps = await args.stepStore.loadCurrentEpoch(args.conversationId);
+  const messages = projectSteps(steps).messages;
+  const transcript = messages.length > 0 ? messages.map((message) => normalizeTranscriptMessage(message)) : (await args.messageStore.list(args.conversationId)).map(
+    visibleMessageTranscript
+  );
+  return {
+    activity: buildConversationActivityFromSteps({
+      canExposePayload: args.canExposePayload,
+      steps,
+      messages
+    }),
+    transcript
+  };
+}
+function visibleMessageTranscript(message) {
+  return {
+    role: message.role,
+    timestamp: message.createdAtMs,
+    parts: [{ type: "text", text: message.text }]
+  };
+}
+async function buildConversationDetail(args) {
+  const { conversation } = args;
+  const conversationId = conversation.conversationId;
+  const nowMs = Date.now();
+  const stepStore = getAgentStepStore();
+  const messageStore = getConversationMessageStore();
+  const transcriptPurgedAtMs = conversation.transcriptPurgedAtMs;
+  const transcriptExpiredAt = transcriptPurgedAtMs !== void 0 ? new Date(transcriptPurgedAtMs).toISOString() : void 0;
+  const canExposeSqlContent = canExposeConversationPayload({
+    conversationId,
+    visibility: conversation.visibility
+  });
+  const currentContent = transcriptPurgedAtMs === void 0 ? await currentRunContent({
+    conversationId,
+    messageStore,
+    stepStore,
+    canExposePayload: canExposeSqlContent
+  }) : { activity: [], transcript: [] };
+  const currentTranscript = currentContent.transcript;
+  const traceId = canExposeSqlContent ? traceIdFromTranscript(currentTranscript) : void 0;
+  const sentryTraceUrl = traceId ? buildSentryTraceUrl(traceId) : void 0;
+  const sentryConversationUrl = buildSentryConversationUrl(conversationId);
+  return {
+    ...conversationSummaryFromStoredConversation({
+      conversation,
+      durationMs: args.durationMs,
+      nowMs,
+      usage: args.usage
+    }),
+    ...traceId ? { traceId } : {},
+    ...sentryTraceUrl ? { sentryTraceUrl } : {},
+    activity: currentContent.activity,
+    transcriptAvailable: transcriptExpiredAt === void 0 && canExposeSqlContent && currentTranscript.length > 0,
+    ...currentTranscript.length > 0 ? {
+      transcriptMessageCount: countConversationMessages(currentTranscript)
+    } : {},
+    ...!canExposeSqlContent && transcriptExpiredAt === void 0 ? {
+      transcriptMetadata: currentTranscript.map(redactTranscriptMessage),
+      transcriptRedacted: true,
+      transcriptRedactionReason: "non_public_conversation"
+    } : {},
+    ...transcriptExpiredAt !== void 0 ? {
+      transcriptExpired: true,
+      transcriptExpiredAt,
+      transcriptMetadata: []
+    } : {},
+    transcript: transcriptExpiredAt === void 0 && canExposeSqlContent ? currentTranscript : [],
+    generatedAt: new Date(nowMs).toISOString(),
+    ...sentryConversationUrl ? { sentryConversationUrl } : {}
+  };
+}
+async function buildConversationSubagent(conversation, subagentId) {
+  const conversationId = conversation.conversationId;
+  const stepStore = getAgentStepStore();
+  const parentSteps = await stepStore.loadHistory(conversationId);
+  if (conversation?.transcriptPurgedAtMs !== void 0) {
+    return {
+      type: "subagent",
+      createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      id: subagentId,
+      status: "completed",
+      subagentKind: "unknown",
+      transcript: [],
+      transcriptAvailable: false,
+      transcriptExpired: true,
+      transcriptExpiredAt: new Date(
+        conversation.transcriptPurgedAtMs
+      ).toISOString()
+    };
+  }
+  const start = parentSteps.find(
+    (step) => step.entry.type === "subagent_started" && step.entry.subagentInvocationId === subagentId
+  );
+  if (!start) {
+    return {
+      type: "subagent",
+      createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      id: subagentId,
+      status: "error",
+      subagentKind: "unknown",
+      transcript: [],
+      transcriptAvailable: false,
+      unavailableReason: "not_found"
+    };
+  }
+  const end = parentSteps.find(
+    (step) => step.entry.type === "subagent_ended" && step.entry.subagentInvocationId === subagentId
+  );
+  const childConversationId = start.entry.childConversationId;
+  const activity = subagentActivityFromSteps(start, end);
+  const subagentSentryConversationUrl = buildSentryConversationUrl(childConversationId);
+  const conversationFields = {
+    subagentConversationId: childConversationId,
+    ...subagentSentryConversationUrl ? { subagentSentryConversationUrl } : {}
+  };
+  const canExposeTranscript = canExposeConversationPayload({
+    conversationId,
+    visibility: conversation?.visibility
+  });
+  if (!canExposeTranscript) {
+    return subagentTranscriptReport(activity, {
+      ...conversationFields,
+      transcriptRedacted: true,
+      transcriptRedactionReason: "non_public_conversation"
+    });
+  }
+  const childMessages = await loadProjection({
+    conversationId: childConversationId
+  });
+  if (childMessages.length === 0) {
+    return subagentTranscriptReport(activity, {
+      ...conversationFields,
+      unavailableReason: "missing_transcript_ref"
+    });
+  }
+  const transcript = childMessages.map(
+    (message) => normalizeSubagentTranscriptMessage(message, activity.subagentKind)
+  );
+  return subagentTranscriptReport(activity, {
+    ...conversationFields,
+    transcript,
+    transcriptMessageCount: countConversationMessages(transcript)
+  });
+}
+
+export {
+  buildConversationDetail,
+  buildConversationSubagent
+};