@sentry/junior 0.118.0 → 0.120.0

package/dist/chunk-H4HBKISO.js

@@ -0,0 +1,417 @@
+// src/chat/discovery.ts
+import fs, { statSync as statSync2 } from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/package-resolution.ts
+import { statSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+function isDirectory(targetPath) {
+  try {
+    return statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(targetPath) {
+  try {
+    return statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function uniqueResolvedPathsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = path.resolve(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function ancestorNodeModulesDirs(cwd) {
+  const dirs = [];
+  let current = path.resolve(cwd);
+  while (true) {
+    const nodeModulesDir = path.join(current, "node_modules");
+    if (isDirectory(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function packageDirInNodeModules(nodeModulesDir, packageName) {
+  const packageDir = path.join(nodeModulesDir, ...packageName.split("/"));
+  return isDirectory(packageDir) ? path.resolve(packageDir) : void 0;
+}
+function isValidPackageSegment(segment) {
+  return Boolean(segment) && segment !== "." && segment !== ".." && !segment.startsWith(".") && /^[A-Za-z0-9._~-]+$/.test(segment);
+}
+function isValidPackageName(packageName) {
+  if (!packageName || packageName.includes("\\") || path.isAbsolute(packageName)) {
+    return false;
+  }
+  const parts = packageName.split("/");
+  if (parts[0].startsWith("@")) {
+    return parts.length === 2 && parts[0].length > 1 && isValidPackageSegment(parts[0].slice(1)) && isValidPackageSegment(parts[1]);
+  }
+  return parts.length === 1 && isValidPackageSegment(parts[0]);
+}
+function findPackageRoot(entryPath) {
+  let dir = path.dirname(entryPath);
+  while (dir !== path.dirname(dir)) {
+    if (isFile(path.join(dir, "package.json"))) {
+      return path.resolve(dir);
+    }
+    dir = path.dirname(dir);
+  }
+  return void 0;
+}
+function findPackageNodeModulesDir(packageDir, packageName) {
+  const parts = path.resolve(packageDir).split(path.sep);
+  const packageParts = packageName.split("/");
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    if (parts[index] !== "node_modules") {
+      continue;
+    }
+    const candidatePackageParts = parts.slice(
+      index + 1,
+      index + 1 + packageParts.length
+    );
+    if (candidatePackageParts.join("/") !== packageParts.join("/")) {
+      continue;
+    }
+    return path.resolve(parts.slice(0, index + 1).join(path.sep) || path.sep);
+  }
+  return void 0;
+}
+function resolvePackageWithNode(cwd, packageName) {
+  let requireFromCwd;
+  try {
+    requireFromCwd = createRequire(path.join(cwd, "package.json"));
+  } catch {
+    return void 0;
+  }
+  for (const specifier of [`${packageName}/package.json`, packageName]) {
+    try {
+      const resolved = requireFromCwd.resolve(specifier);
+      const dir = specifier.endsWith("/package.json") ? path.dirname(resolved) : findPackageRoot(resolved);
+      if (!dir) {
+        continue;
+      }
+      const nodeModulesDir = findPackageNodeModulesDir(dir, packageName);
+      return {
+        dir,
+        ...nodeModulesDir ? { nodeModulesDir } : {}
+      };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function resolvePackageLocation(cwd, packageName, options) {
+  if (!isValidPackageName(packageName)) {
+    return void 0;
+  }
+  const nodeModulesDirs = uniqueResolvedPathsInOrder([
+    ...options?.nodeModulesDirs ?? [],
+    ...ancestorNodeModulesDirs(cwd)
+  ]);
+  for (const nodeModulesDir of nodeModulesDirs) {
+    const dir = packageDirInNodeModules(nodeModulesDir, packageName);
+    if (dir) {
+      return { dir, nodeModulesDir };
+    }
+  }
+  return resolvePackageWithNode(cwd, packageName);
+}
+function resolvePackageDir(cwd, packageName) {
+  return resolvePackageLocation(cwd, packageName)?.dir;
+}
+
+// src/chat/discovery.ts
+function isDirectory2(targetPath) {
+  try {
+    return statSync2(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile2(targetPath) {
+  try {
+    return statSync2(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function normalizePath(targetPath) {
+  return path2.resolve(targetPath);
+}
+function uniqueResolvedPathsInOrder2(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = normalizePath(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function isNodeModulesPath(candidatePath) {
+  return path2.basename(candidatePath) === "node_modules";
+}
+function isInsidePnpmStore(candidatePath) {
+  return candidatePath.split(path2.sep).includes(".pnpm");
+}
+function runningFromInstalledPackage() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const marker = `${path2.sep}node_modules${path2.sep}@sentry${path2.sep}junior${path2.sep}`;
+  return currentFile.includes(marker);
+}
+function listInstalledPackageNodeModulesDirs() {
+  if (!runningFromInstalledPackage()) {
+    return [];
+  }
+  const dirs = [];
+  let current = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)));
+  while (true) {
+    if (isNodeModulesPath(current) && !isInsidePnpmStore(current) && isDirectory2(current)) {
+      dirs.push(current);
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function listCwdAncestorNodeModulesDirs(cwd) {
+  const resolvedCwd = normalizePath(cwd);
+  const dirs = [];
+  let current = resolvedCwd;
+  while (true) {
+    const nodeModulesDir = path2.join(current, "node_modules");
+    if (isDirectory2(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    if (isFile2(path2.join(current, "package.json"))) {
+      break;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function discoverNodeModulesDirs(cwd = process.cwd(), options) {
+  const explicit = options?.candidateDirs?.filter((dir) => isDirectory2(dir)) ?? [];
+  if (explicit.length > 0) {
+    return uniqueResolvedPathsInOrder2(explicit);
+  }
+  return uniqueResolvedPathsInOrder2([
+    ...listInstalledPackageNodeModulesDirs(),
+    ...listCwdAncestorNodeModulesDirs(cwd)
+  ]);
+}
+function discoverProjectRoots(cwd = process.cwd(), options) {
+  const roots = discoverNodeModulesDirs(
+    cwd,
+    options?.nodeModulesDirs ? { candidateDirs: options.nodeModulesDirs } : void 0
+  ).map((nodeModulesDir) => path2.dirname(nodeModulesDir));
+  return uniqueResolvedPathsInOrder2([cwd, ...roots]);
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function pathExists(targetPath) {
+  try {
+    fs.accessSync(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasAnyDataMarkers(appDir) {
+  return pathExists(path2.join(appDir, "SOUL.md")) || pathExists(path2.join(appDir, "WORLD.md"));
+}
+function scoreAppCandidate(appDir) {
+  let score = 0;
+  if (pathExists(path2.join(appDir, "SOUL.md"))) {
+    score += 4;
+  }
+  if (pathExists(path2.join(appDir, "WORLD.md"))) {
+    score += 2;
+  }
+  if (pathExists(path2.join(appDir, "skills"))) {
+    score += 1;
+  }
+  if (pathExists(path2.join(appDir, "plugins"))) {
+    score += 1;
+  }
+  return score;
+}
+function resolveCandidateAppDirs(cwd, projectRoots) {
+  const roots = projectRoots ?? discoverProjectRoots(cwd);
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const appDir = path2.resolve(root, "app");
+    if (!pathExists(appDir)) {
+      continue;
+    }
+    if (seen.has(appDir)) {
+      continue;
+    }
+    seen.add(appDir);
+    resolved.push(appDir);
+  }
+  return resolved;
+}
+function homeDir() {
+  return resolveHomeDir();
+}
+function resolveHomeDir(cwd = process.cwd(), options) {
+  const resolvedCwd = path2.resolve(cwd);
+  const directApp = path2.resolve(resolvedCwd, "app");
+  if (pathExists(directApp) && hasAnyDataMarkers(directApp)) {
+    return directApp;
+  }
+  const candidates = resolveCandidateAppDirs(
+    resolvedCwd,
+    options?.projectRoots
+  );
+  if (candidates.length === 0) {
+    return directApp;
+  }
+  candidates.sort((left, right) => {
+    const leftScore = scoreAppCandidate(left);
+    const rightScore = scoreAppCandidate(right);
+    if (leftScore !== rightScore) {
+      return rightScore - leftScore;
+    }
+    const leftDistance = path2.relative(resolvedCwd, left).split(path2.sep).length;
+    const rightDistance = path2.relative(resolvedCwd, right).split(path2.sep).length;
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    return left.localeCompare(right);
+  });
+  return candidates[0];
+}
+function resolveContentRoots(subdir) {
+  if (subdir === "data") {
+    return [homeDir()];
+  }
+  return [path2.join(homeDir(), subdir)];
+}
+function builtInSkillsDir() {
+  const moduleDir = path2.dirname(fileURLToPath(import.meta.url));
+  if (path2.basename(moduleDir) === "dist") {
+    return path2.join(path2.dirname(moduleDir), "skills");
+  }
+  if (path2.basename(moduleDir) === "chat" && path2.basename(path2.dirname(moduleDir)) === "src") {
+    return path2.resolve(moduleDir, "../../skills");
+  }
+  const packageDir = resolvePackageDir(process.cwd(), "@sentry/junior");
+  return path2.join(packageDir ?? moduleDir, "skills");
+}
+function dataDir() {
+  return resolveContentRoots("data")[0];
+}
+function soulPath() {
+  return path2.join(dataDir(), "SOUL.md");
+}
+function worldPath() {
+  return path2.join(dataDir(), "WORLD.md");
+}
+function descriptionPath() {
+  return path2.join(dataDir(), "DESCRIPTION.md");
+}
+function skillsDir() {
+  return resolveContentRoots("skills")[0];
+}
+function pluginsDir() {
+  return resolveContentRoots("plugins")[0];
+}
+function dataRoots() {
+  return unique(resolveContentRoots("data"));
+}
+function skillRoots() {
+  return unique([builtInSkillsDir(), ...resolveContentRoots("skills")]);
+}
+function pluginRoots() {
+  return unique(resolveContentRoots("plugins"));
+}
+function soulPathCandidates() {
+  const candidates = dataRoots().map((root) => path2.join(root, "SOUL.md"));
+  return unique(candidates);
+}
+function worldPathCandidates() {
+  const candidates = dataRoots().map((root) => path2.join(root, "WORLD.md"));
+  return unique(candidates);
+}
+function descriptionPathCandidates() {
+  const candidates = dataRoots().map(
+    (root) => path2.join(root, "DESCRIPTION.md")
+  );
+  return unique(candidates);
+}
+var RESERVED_APP_FILES = /* @__PURE__ */ new Set([
+  "SOUL.md",
+  "WORLD.md",
+  "DESCRIPTION.md",
+  "ABOUT.md"
+]);
+function listReferenceFiles() {
+  const appDir = homeDir();
+  try {
+    const entries = fs.readdirSync(appDir, { withFileTypes: true });
+    return entries.filter(
+      (entry) => entry.isFile() && entry.name.endsWith(".md") && !RESERVED_APP_FILES.has(entry.name)
+    ).map((entry) => path2.join(appDir, entry.name)).sort();
+  } catch {
+    return [];
+  }
+}
+
+export {
+  isValidPackageName,
+  resolvePackageLocation,
+  resolvePackageDir,
+  isDirectory2 as isDirectory,
+  isFile2 as isFile,
+  discoverNodeModulesDirs,
+  discoverProjectRoots,
+  homeDir,
+  resolveHomeDir,
+  builtInSkillsDir,
+  dataDir,
+  soulPath,
+  worldPath,
+  descriptionPath,
+  skillsDir,
+  pluginsDir,
+  dataRoots,
+  skillRoots,
+  pluginRoots,
+  soulPathCandidates,
+  worldPathCandidates,
+  descriptionPathCandidates,
+  listReferenceFiles
+};

package/dist/{chunk-FXOYURO4.js → chunk-HDFGNU5E.js}

@@ -289,6 +289,7 @@ function toGenAiMessagesTraceAttributes(prefix, messages) {
   return {
     [`${prefix}.message_count`]: messages.length,
     [`${prefix}.content_chars`]: contentChars,
+    [`${prefix}.messages.size`]: contentChars,
     ...roles.size > 0 ? { [`${prefix}.roles`]: [...roles] } : {},
     ...partTypes.size > 0 ? { [`${prefix}.part_types`]: [...partTypes] } : {}
   };

package/dist/{chunk-PJPKHGLG.js → chunk-JQWP6V22.js}

@@ -13,17 +13,17 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-KC5EE27Y.js";
+} from "./chunk-M243JMZH.js";
 import {
   getStateAdapter,
   sleep
-} from "./chunk-3N3FMCKN.js";
+} from "./chunk-ALAKN7LR.js";
 import {
   botConfig,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-PWRFTDTY.js";
+} from "./chunk-VURFJVFH.js";
 import {
   toStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
@@ -32,7 +32,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-MLZFK4KP.js";
+} from "./chunk-ALYQOZG7.js";
 import {
   isRecord,
   toOptionalNumber,
@@ -2713,12 +2713,6 @@ function getChannelConfigurationServiceById(channelId) {
   });
 }
 
-// src/chat/interruption-marker.ts
-var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
-function getInterruptionMarker() {
-  return INTERRUPTED_MARKER;
-}
-
 // src/chat/services/pending-auth.ts
 var AUTH_LINK_REUSE_WINDOW_MS = 10 * 60 * 1e3;
 var NON_REQUEST_SKIPPED_REASON_PREFIXES = [
@@ -2840,7 +2834,6 @@ export {
   persistAuthPauseSessionRecord,
   persistContinuationSessionRecord,
   persistYieldSessionRecord,
-  getInterruptionMarker,
   JUNIOR_THREAD_STATE_TTL_MS,
   canReusePendingAuthLink,
   getConversationPendingAuth,

package/dist/{chunk-KC5EE27Y.js → chunk-M243JMZH.js}

@@ -9,13 +9,13 @@ import {
   TURN_REASONING_LEVELS,
   getChatConfig,
   modelProfileSchema
-} from "./chunk-PWRFTDTY.js";
+} from "./chunk-VURFJVFH.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-MLZFK4KP.js";
+} from "./chunk-ALYQOZG7.js";
 import {
   parseSlackChannelReferenceId,
   parseSlackTeamId

package/dist/{chunk-7SM3P4XR.js → chunk-O2ULQJWR.js}

@@ -126,9 +126,64 @@ var conversationReportToolCallSchema = z2.object({
     });
   }
 });
+var conversationReportReasoningPartSchema = z2.object({
+  type: z2.literal("reasoning"),
+  text: z2.string().min(1).optional(),
+  redacted: z2.literal(true).optional()
+}).strict().superRefine((data, context) => {
+  if (data.text === void 0 === (data.redacted !== true)) {
+    context.addIssue({
+      code: "custom",
+      message: "reasoning content must be text or explicitly redacted"
+    });
+  }
+});
+var conversationReportAssistantToolCallPartSchema = z2.object({
+  type: z2.literal("tool_call"),
+  toolCallId: z2.string().min(1)
+}).strict();
+var conversationReportAssistantMetadataSchema = z2.object({
+  parts: z2.array(
+    z2.discriminatedUnion("type", [
+      conversationReportReasoningPartSchema,
+      conversationReportAssistantToolCallPartSchema
+    ])
+  ).min(1)
+}).strict();
 var conversationReportToolCallsEventDataSchema = z2.object({
   type: z2.literal("tool_calls"),
-  calls: z2.array(conversationReportToolCallSchema).min(1)
+  calls: z2.array(conversationReportToolCallSchema).min(1),
+  assistant: conversationReportAssistantMetadataSchema.optional()
+}).strict().superRefine((data, context) => {
+  if (!data.assistant) return;
+  const callCounts = /* @__PURE__ */ new Map();
+  for (const call of data.calls) {
+    callCounts.set(
+      call.toolCallId,
+      (callCounts.get(call.toolCallId) ?? 0) + 1
+    );
+  }
+  const partCounts = /* @__PURE__ */ new Map();
+  for (const part of data.assistant.parts) {
+    if (part.type !== "tool_call") continue;
+    partCounts.set(
+      part.toolCallId,
+      (partCounts.get(part.toolCallId) ?? 0) + 1
+    );
+  }
+  if (callCounts.size !== partCounts.size || [...callCounts].some(
+    ([toolCallId, count]) => partCounts.get(toolCallId) !== count
+  )) {
+    context.addIssue({
+      code: "custom",
+      path: ["assistant", "parts"],
+      message: "assistant tool parts must reference every call exactly once"
+    });
+  }
+});
+var conversationReportAssistantMessageEventDataSchema = z2.object({
+  type: z2.literal("assistant_message"),
+  parts: z2.array(conversationReportReasoningPartSchema).min(1)
 }).strict();
 var conversationReportTurnLifecycleEventDataSchema = z2.discriminatedUnion(
   "state",
@@ -199,6 +254,7 @@ var conversationReportSubagentEventDataSchema = z2.object({
 var conversationReportEventDataSchema = z2.discriminatedUnion("type", [
   conversationReportMessageEventDataSchema,
   conversationReportMessageHandledEventDataSchema,
+  conversationReportAssistantMessageEventDataSchema,
   conversationReportToolCallsEventDataSchema,
   conversationReportTurnLifecycleEventDataSchema,
   conversationReportTurnContextEventDataSchema,
@@ -270,6 +326,31 @@ function validateConversationEvents(report, context) {
         message: "redacted event history must redact tool payloads"
       });
     }
+    if (report.eventHistory.status === "redacted" && event.data.type === "assistant_message" && event.data.parts.some((part) => part.text !== void 0)) {
+      context.addIssue({
+        code: "custom",
+        path: ["events", index, "data"],
+        message: "redacted event history must redact assistant messages"
+      });
+    }
+    if (report.eventHistory.status === "available" && event.data.type === "assistant_message" && event.data.parts.some((part) => part.redacted === true)) {
+      context.addIssue({
+        code: "custom",
+        path: ["events", index, "data"],
+        message: "available event history must expose reasoning"
+      });
+    }
+    if (event.data.type === "tool_calls" && (report.eventHistory.status === "redacted" && event.data.assistant?.parts.some(
+      (part) => part.type === "reasoning" && part.text !== void 0
+    ) || report.eventHistory.status === "available" && event.data.assistant?.parts.some(
+      (part) => part.type === "reasoning" && part.redacted === true
+    ))) {
+      context.addIssue({
+        code: "custom",
+        path: ["events", index, "data", "assistant"],
+        message: "assistant reasoning must match event history visibility"
+      });
+    }
   }
 }
 var conversationDetailReportSchema = conversationSummaryReportSchema.extend({