@sentry/junior 0.102.3 → 0.104.0

package/dist/chunk-B5QS4AVO.js

@@ -1,319 +0,0 @@
-import {
-  ensureLegacyConversationImport
-} from "./chunk-VSAFV2GI.js";
-import {
-  contextProvenance,
-  getAgentStepStore
-} from "./chunk-QZGVPPIJ.js";
-
-// src/chat/conversations/projection.ts
-import { isDeepStrictEqual } from "util";
-function authorizationObservationMessage(entry, createdAtMs) {
-  const label = entry.kind === "mcp" ? "MCP authorization" : "Authorization";
-  return {
-    role: "user",
-    content: [
-      {
-        type: "text",
-        text: `${label} completed for provider "${entry.provider}". Continue the blocked request and retry the provider operation if needed.`
-      }
-    ],
-    timestamp: createdAtMs
-  };
-}
-function piEntryProvenance(entry) {
-  return entry.provenance ?? contextProvenance;
-}
-function projectSteps(steps, opts) {
-  const messages = [];
-  const provenance = [];
-  const seqs = [];
-  let modelProfile = "standard";
-  let modelId;
-  for (const step of steps) {
-    if (opts?.maxSeq !== void 0 && step.seq > opts.maxSeq) {
-      break;
-    }
-    if (step.entry.type === "context_epoch_started") {
-      modelProfile = step.entry.modelProfile ?? "standard";
-      modelId = step.entry.modelId;
-      continue;
-    }
-    if (step.entry.type === "pi_message") {
-      messages.push(step.entry.message);
-      provenance.push(piEntryProvenance(step.entry));
-      seqs.push(step.seq);
-      continue;
-    }
-    if (step.entry.type === "authorization_completed") {
-      messages.push(
-        authorizationObservationMessage(step.entry, step.createdAtMs)
-      );
-      provenance.push(contextProvenance);
-      seqs.push(step.seq);
-    }
-  }
-  return { messages, provenance, seqs, modelProfile, modelId };
-}
-function connectedMcpProvidersFromSteps(steps) {
-  const providers = /* @__PURE__ */ new Set();
-  for (const step of steps) {
-    if (step.entry.type === "mcp_provider_connected") {
-      providers.add(step.entry.provider);
-    }
-  }
-  return [...providers].sort((left, right) => left.localeCompare(right));
-}
-function isUserMessage(message) {
-  return message.role === "user";
-}
-function countMatchingPrefix(left, right) {
-  const limit = Math.min(left.length, right.length);
-  for (let index = 0; index < limit; index += 1) {
-    if (!isDeepStrictEqual(left[index], right[index])) {
-      return index;
-    }
-  }
-  return limit;
-}
-function resolveCommitProvenance(args) {
-  if (args.explicitProvenance) {
-    if (args.explicitProvenance.length !== args.nextMessages.length) {
-      throw new Error("commit provenance must align one-to-one with messages");
-    }
-    return args.explicitProvenance;
-  }
-  const matchingPrefix = args.matchingPrefix;
-  const provenance = args.nextMessages.map(
-    (_, index) => index < matchingPrefix ? args.existing.provenance[index] ?? contextProvenance : contextProvenance
-  );
-  if (args.newMessageProvenance) {
-    for (let index = args.nextMessages.length - 1; index >= matchingPrefix; index -= 1) {
-      if (isUserMessage(args.nextMessages[index])) {
-        provenance[index] = args.newMessageProvenance;
-        break;
-      }
-    }
-  }
-  if (args.trailingMessageProvenance) {
-    if (args.trailingMessageProvenance.length > provenance.length) {
-      throw new Error(
-        "trailing commit provenance cannot exceed committed messages"
-      );
-    }
-    const newMessageCount = args.nextMessages.length - matchingPrefix;
-    if (args.trailingMessageProvenance.length > newMessageCount) {
-      throw new Error(
-        "trailing commit provenance must align to newly committed messages"
-      );
-    }
-    const start = provenance.length - args.trailingMessageProvenance.length;
-    args.trailingMessageProvenance.forEach((entry, offset) => {
-      provenance[start + offset] = entry;
-    });
-  }
-  return provenance;
-}
-async function importLegacyIfNeeded(args) {
-  await ensureLegacyConversationImport({ conversationId: args.conversationId });
-}
-async function loadProjection(args) {
-  await importLegacyIfNeeded(args);
-  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
-  return projectSteps(steps).messages;
-}
-async function loadConversationProjection(args) {
-  await importLegacyIfNeeded(args);
-  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
-  const { messages, provenance, modelProfile, modelId } = projectSteps(steps);
-  return { messages, provenance, modelProfile, modelId };
-}
-async function openConversationProjection(args) {
-  await importLegacyIfNeeded(args);
-  const stepStore = getAgentStepStore();
-  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
-  const projection = projectSteps(steps);
-  if (steps.some(
-    (step) => step.entry.type === "context_epoch_started" || step.entry.type === "pi_message"
-  )) {
-    return projection;
-  }
-  await stepStore.startEpoch(args.conversationId, {
-    reason: "initial",
-    modelProfile: "standard",
-    modelId: args.modelId,
-    messages: []
-  });
-  return {
-    messages: projection.messages,
-    provenance: projection.provenance,
-    modelProfile: "standard",
-    modelId: args.modelId
-  };
-}
-async function loadTurnProjection(args) {
-  await importLegacyIfNeeded(args);
-  const stepStore = getAgentStepStore();
-  if (args.committedSeq < 0) {
-    return projectSteps(await stepStore.loadCurrentEpoch(args.conversationId));
-  }
-  const history = await stepStore.loadHistory(args.conversationId);
-  const committedStep = history.find((step) => step.seq === args.committedSeq);
-  if (!committedStep) {
-    return void 0;
-  }
-  const epochSteps = history.filter(
-    (step) => step.contextEpoch === committedStep.contextEpoch
-  );
-  return args.includeTail ? projectSteps(epochSteps) : projectSteps(epochSteps, { maxSeq: args.committedSeq });
-}
-async function loadConnectedMcpProviders(args) {
-  await importLegacyIfNeeded(args);
-  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
-  return connectedMcpProvidersFromSteps(steps);
-}
-function messageTimestamp(message) {
-  const timestamp = message.timestamp;
-  return typeof timestamp === "number" ? timestamp : Date.now();
-}
-async function commitMessages(args) {
-  const stepStore = getAgentStepStore();
-  const currentSteps = await stepStore.loadCurrentEpoch(args.conversationId);
-  const existing = projectSteps(currentSteps);
-  const matchingPrefix = countMatchingPrefix(existing.messages, args.messages);
-  const nextProvenance = resolveCommitProvenance({
-    existing,
-    nextMessages: args.messages,
-    matchingPrefix,
-    ...args.provenance ? { explicitProvenance: args.provenance } : {},
-    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {},
-    ...args.newMessageProvenance ? { newMessageProvenance: args.newMessageProvenance } : {}
-  });
-  if (currentSteps.length === 0) {
-    await stepStore.startEpoch(args.conversationId, {
-      reason: "initial",
-      modelProfile: "standard",
-      modelId: args.modelId,
-      messages: args.messages.map((message, index) => ({
-        message,
-        createdAtMs: messageTimestamp(message),
-        provenance: nextProvenance[index]
-      }))
-    });
-  } else if (matchingPrefix === existing.messages.length) {
-    const newMessages = args.messages.slice(matchingPrefix);
-    await stepStore.append(
-      args.conversationId,
-      newMessages.map((message, index) => ({
-        entry: {
-          type: "pi_message",
-          message,
-          provenance: nextProvenance[matchingPrefix + index]
-        },
-        createdAtMs: messageTimestamp(message)
-      }))
-    );
-  } else {
-    await stepStore.startEpoch(args.conversationId, {
-      reason: "rollback",
-      modelProfile: existing.modelProfile,
-      modelId: args.modelId,
-      messages: args.messages.map((message, index) => ({
-        message,
-        createdAtMs: messageTimestamp(message),
-        provenance: nextProvenance[index]
-      }))
-    });
-  }
-  const committed = projectSteps(
-    await stepStore.loadCurrentEpoch(args.conversationId)
-  );
-  return {
-    committedSeq: committed.seqs.at(-1) ?? -1,
-    messageSeqs: committed.seqs,
-    provenance: nextProvenance
-  };
-}
-async function recordMcpProviderConnected(args) {
-  const stepStore = getAgentStepStore();
-  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
-  if (connectedMcpProvidersFromSteps(steps).includes(args.provider)) {
-    return;
-  }
-  await stepStore.append(args.conversationId, [
-    {
-      entry: { type: "mcp_provider_connected", provider: args.provider },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-async function recordAuthorizationRequested(args) {
-  const stepStore = getAgentStepStore();
-  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
-  if (steps.some(
-    (step) => step.entry.type === "authorization_requested" && step.entry.authorizationId === args.authorizationId
-  )) {
-    return;
-  }
-  await stepStore.append(args.conversationId, [
-    {
-      entry: {
-        type: "authorization_requested",
-        kind: args.kind,
-        provider: args.provider,
-        actorId: args.actorId,
-        authorizationId: args.authorizationId,
-        delivery: args.delivery
-      },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-async function recordAuthorizationCompleted(args) {
-  const stepStore = getAgentStepStore();
-  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
-  if (steps.some(
-    (step) => step.entry.type === "authorization_completed" && step.entry.authorizationId === args.authorizationId
-  )) {
-    return;
-  }
-  await stepStore.append(args.conversationId, [
-    {
-      entry: {
-        type: "authorization_completed",
-        kind: args.kind,
-        provider: args.provider,
-        actorId: args.actorId,
-        authorizationId: args.authorizationId
-      },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-async function recordToolExecutionStarted(args) {
-  await getAgentStepStore().append(args.conversationId, [
-    {
-      entry: {
-        type: "tool_execution_started",
-        toolCallId: args.toolCallId,
-        toolName: args.toolName,
-        ...args.args !== void 0 ? { args: args.args } : {}
-      },
-      createdAtMs: args.createdAtMs ?? Date.now()
-    }
-  ]);
-}
-
-export {
-  projectSteps,
-  loadProjection,
-  loadConversationProjection,
-  openConversationProjection,
-  loadTurnProjection,
-  loadConnectedMcpProviders,
-  commitMessages,
-  recordMcpProviderConnected,
-  recordAuthorizationRequested,
-  recordAuthorizationCompleted,
-  recordToolExecutionStarted
-};

package/dist/chunk-F4CQEUTP.js

@@ -1,77 +0,0 @@
-import {
-  juniorConversations
-} from "./chunk-QZGVPPIJ.js";
-
-// src/api/conversations/aggregate.ts
-import { sql } from "drizzle-orm";
-function tokenValue() {
-  return sql`
-    CASE
-      WHEN ${juniorConversations.usage}->>'totalTokens' IS NOT NULL
-        THEN (${juniorConversations.usage}->>'totalTokens')::double precision
-      WHEN COALESCE(
-        ${juniorConversations.usage}->>'inputTokens',
-        ${juniorConversations.usage}->>'outputTokens',
-        ${juniorConversations.usage}->>'cachedInputTokens',
-        ${juniorConversations.usage}->>'cacheCreationTokens'
-      ) IS NOT NULL
-        THEN COALESCE((${juniorConversations.usage}->>'inputTokens')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->>'outputTokens')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->>'cachedInputTokens')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->>'cacheCreationTokens')::double precision, 0)
-      ELSE NULL
-    END
-  `;
-}
-function costValue() {
-  return sql`
-    CASE
-      WHEN ${juniorConversations.usage}->'cost'->>'total' IS NOT NULL
-        THEN (${juniorConversations.usage}->'cost'->>'total')::double precision
-      WHEN COALESCE(
-        ${juniorConversations.usage}->'cost'->>'input',
-        ${juniorConversations.usage}->'cost'->>'output',
-        ${juniorConversations.usage}->'cost'->>'cacheRead',
-        ${juniorConversations.usage}->'cost'->>'cacheWrite'
-      ) IS NOT NULL
-        THEN COALESCE((${juniorConversations.usage}->'cost'->>'input')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->'cost'->>'output')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->'cost'->>'cacheRead')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->'cost'->>'cacheWrite')::double precision, 0)
-      ELSE NULL
-    END
-  `;
-}
-function conversationAggregateColumns() {
-  return {
-    active: sql`COUNT(*) FILTER (
-      WHERE ${juniorConversations.executionStatus} NOT IN ('idle', 'failed')
-    )::integer`,
-    conversations: sql`COUNT(*)::integer`,
-    costUsd: sql`SUM(${costValue()})::double precision`,
-    durationMs: sql`COALESCE(SUM(${juniorConversations.durationMs}), 0)::double precision`,
-    failed: sql`COUNT(*) FILTER (
-      WHERE ${juniorConversations.executionStatus} = 'failed'
-    )::integer`,
-    tokens: sql`SUM(${tokenValue()})::double precision`
-  };
-}
-function conversationRangeColumns() {
-  return {
-    firstSeenAt: sql`MIN(${juniorConversations.createdAt})`.mapWith(
-      juniorConversations.createdAt
-    ),
-    lastSeenAt: sql`MAX(${juniorConversations.lastActivityAt})`.mapWith(
-      juniorConversations.lastActivityAt
-    )
-  };
-}
-function conversationActiveDaysColumn() {
-  return sql`COUNT(DISTINCT (${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC')::date)::integer`;
-}
-
-export {
-  conversationAggregateColumns,
-  conversationRangeColumns,
-  conversationActiveDaysColumn
-};

package/dist/chunk-HYDQULR2.js

@@ -1,214 +0,0 @@
-import {
-  usageSchema
-} from "./chunk-PDO5BLNM.js";
-
-// src/api/conversations/schema.ts
-import { z } from "zod";
-var conversationReportStatusSchema = z.enum([
-  "active",
-  "completed",
-  "failed"
-]);
-var conversationSurfaceSchema = z.enum([
-  "api",
-  "internal",
-  "scheduler",
-  "slack"
-]);
-var conversationUsageSchema = usageSchema;
-var actorIdentitySchema = z.object({
-  email: z.string().optional(),
-  fullName: z.string().optional(),
-  slackUserId: z.string().optional(),
-  slackUserName: z.string().optional()
-}).strict();
-var conversationSummaryReportSchema = z.object({
-  displayTitle: z.string(),
-  cumulativeDurationMs: z.number(),
-  cumulativeUsage: conversationUsageSchema.optional(),
-  conversationId: z.string(),
-  status: conversationReportStatusSchema,
-  startedAt: z.string(),
-  lastSeenAt: z.string(),
-  lastProgressAt: z.string(),
-  surface: conversationSurfaceSchema,
-  actorIdentity: actorIdentitySchema.optional(),
-  channel: z.string().optional(),
-  channelName: z.string().optional(),
-  channelNameRedacted: z.boolean().optional(),
-  locationId: z.string().optional(),
-  sentryTraceUrl: z.string().optional(),
-  traceId: z.string().optional()
-}).strict();
-var transcriptPartTypeSchema = z.enum([
-  "text",
-  "thinking",
-  "tool_call",
-  "tool_result",
-  "unknown"
-]);
-var transcriptPartSchema = z.object({
-  bytes: z.number().optional(),
-  chars: z.number().optional(),
-  id: z.string().optional(),
-  input: z.unknown().optional(),
-  inputKeys: z.array(z.string()).optional(),
-  inputSizeBytes: z.number().optional(),
-  inputSizeChars: z.number().optional(),
-  inputType: z.string().optional(),
-  name: z.string().optional(),
-  output: z.unknown().optional(),
-  outputKeys: z.array(z.string()).optional(),
-  outputSizeBytes: z.number().optional(),
-  outputSizeChars: z.number().optional(),
-  outputType: z.string().optional(),
-  redacted: z.boolean().optional(),
-  sourceType: z.string().optional(),
-  text: z.string().optional(),
-  type: transcriptPartTypeSchema
-}).strict();
-var transcriptRoleSchema = z.enum([
-  "assistant",
-  "system",
-  "tool",
-  "toolResult",
-  "unknown",
-  "user"
-]);
-var transcriptMessageSchema = z.object({
-  parts: z.array(transcriptPartSchema),
-  role: transcriptRoleSchema,
-  timestamp: z.number().optional()
-}).strict();
-var conversationActivityStatusSchema = z.enum([
-  "aborted",
-  "completed",
-  "error",
-  "running",
-  "success"
-]);
-var conversationSubagentActivityReportSchema = z.object({
-  type: z.literal("subagent"),
-  createdAt: z.string(),
-  endedAt: z.string().optional(),
-  id: z.string(),
-  modelId: z.string().optional(),
-  outcome: z.enum(["success", "error", "aborted"]).optional(),
-  parentToolCallId: z.string().optional(),
-  reasoningLevel: z.string().optional(),
-  status: conversationActivityStatusSchema,
-  subagentKind: z.string(),
-  transcriptAvailable: z.boolean().optional()
-}).strict();
-var conversationToolActivityReportSchema = z.object({
-  type: z.literal("tool_execution"),
-  args: z.unknown().optional(),
-  createdAt: z.string(),
-  id: z.string(),
-  inputKeys: z.array(z.string()).optional(),
-  inputSizeBytes: z.number().optional(),
-  inputSizeChars: z.number().optional(),
-  inputType: z.string().optional(),
-  redacted: z.boolean().optional(),
-  status: conversationActivityStatusSchema,
-  subagents: z.array(conversationSubagentActivityReportSchema),
-  toolCallId: z.string(),
-  toolName: z.string()
-}).strict();
-var conversationActivityReportSchema = z.discriminatedUnion("type", [
-  conversationToolActivityReportSchema,
-  conversationSubagentActivityReportSchema
-]);
-var conversationContextEventSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("context_compacted"),
-    createdAt: z.string(),
-    modelId: z.string().optional(),
-    summary: z.string().optional(),
-    transcriptIndex: z.number().int().nonnegative()
-  }).strict(),
-  z.object({
-    type: z.literal("model_handoff"),
-    createdAt: z.string(),
-    fromModelId: z.string().optional(),
-    message: z.string().optional(),
-    toModelId: z.string(),
-    transcriptIndex: z.number().int().nonnegative()
-  }).strict()
-]);
-var conversationDetailReportSchema = conversationSummaryReportSchema.extend({
-  activity: z.array(conversationActivityReportSchema).optional(),
-  modelId: z.string().optional(),
-  reasoningLevel: z.string().optional(),
-  contextEvents: z.array(conversationContextEventSchema).optional(),
-  transcriptAvailable: z.boolean(),
-  transcriptMetadata: z.array(transcriptMessageSchema).optional(),
-  transcriptMessageCount: z.number().optional(),
-  transcriptRedacted: z.boolean().optional(),
-  transcriptRedactionReason: z.literal("non_public_conversation").optional(),
-  transcriptExpired: z.boolean().optional(),
-  transcriptExpiredAt: z.string().optional(),
-  transcript: z.array(transcriptMessageSchema),
-  generatedAt: z.string(),
-  sentryConversationUrl: z.string().optional()
-}).strict();
-var conversationSubagentTranscriptReportSchema = z.object({
-  type: z.literal("subagent"),
-  createdAt: z.string(),
-  endedAt: z.string().optional(),
-  id: z.string(),
-  modelId: z.string().optional(),
-  outcome: z.enum(["success", "error", "aborted"]).optional(),
-  parentToolCallId: z.string().optional(),
-  reasoningLevel: z.string().optional(),
-  status: conversationActivityStatusSchema,
-  subagentConversationId: z.string().optional(),
-  subagentKind: z.string(),
-  subagentSentryConversationUrl: z.string().optional(),
-  transcript: z.array(transcriptMessageSchema),
-  transcriptAvailable: z.boolean(),
-  transcriptMessageCount: z.number().optional(),
-  transcriptRedacted: z.boolean().optional(),
-  transcriptRedactionReason: z.literal("non_public_conversation").optional(),
-  transcriptExpired: z.boolean().optional(),
-  transcriptExpiredAt: z.string().optional(),
-  unavailableReason: z.enum(["missing_transcript_range", "missing_transcript_ref", "not_found"]).optional()
-}).strict();
-var conversationFeedSchema = z.object({
-  conversations: z.array(conversationSummaryReportSchema),
-  source: z.literal("conversation_index"),
-  generatedAt: z.string()
-}).strict();
-var conversationStatsItemSchema = z.object({
-  active: z.number(),
-  conversations: z.number(),
-  durationMs: z.number(),
-  failed: z.number(),
-  label: z.string(),
-  costUsd: z.number().optional(),
-  tokens: z.number().optional()
-}).strict();
-var conversationStatsReportSchema = z.object({
-  active: z.number(),
-  conversations: z.number(),
-  durationMs: z.number(),
-  failed: z.number(),
-  generatedAt: z.string(),
-  locations: z.array(conversationStatsItemSchema),
-  actors: z.array(conversationStatsItemSchema),
-  source: z.literal("conversation_index"),
-  costUsd: z.number().optional(),
-  tokens: z.number().optional(),
-  windowEnd: z.string(),
-  windowStart: z.string()
-}).strict();
-
-export {
-  actorIdentitySchema,
-  conversationSummaryReportSchema,
-  conversationDetailReportSchema,
-  conversationSubagentTranscriptReportSchema,
-  conversationFeedSchema,
-  conversationStatsItemSchema,
-  conversationStatsReportSchema
-};