@sentry/junior 0.72.0 → 0.73.0

package/dist/instrumentation.js

@@ -1,6 +1,8 @@
 import {
+  getDeploymentServiceVersion,
+  getDeploymentTelemetryAttributes,
   sentry_exports
-} from "./chunk-Z3YD6NHK.js";
+} from "./chunk-SJHUF3DP.js";
 import "./chunk-2KG3PWR4.js";
 
 // src/instrumentation.ts
@@ -22,16 +24,29 @@ function initSentry() {
   }
   const dsn = process.env.SENTRY_DSN;
   const enableLogs = getBoolean(process.env.SENTRY_ENABLE_LOGS, Boolean(dsn));
+  const serviceVersion = getDeploymentServiceVersion();
+  const deploymentSpanAttributes = getDeploymentTelemetryAttributes();
   sentry_exports.init({
     dsn,
     environment: process.env.SENTRY_ENVIRONMENT ?? process.env.VERCEL_ENV ?? process.env.NODE_ENV,
-    release: process.env.SENTRY_RELEASE ?? process.env.VERCEL_GIT_COMMIT_SHA,
+    release: serviceVersion,
     tracesSampleRate: getSampleRate(process.env.SENTRY_TRACES_SAMPLE_RATE, 1),
     sendDefaultPii: true,
     enabled: Boolean(dsn),
     enableLogs,
     registerEsmLoaderHooks: false,
     streamGenAiSpans: true,
+    // Keep deployment identity centralized so every emitted Sentry span carries it.
+    beforeSendSpan(span) {
+      if (Object.keys(deploymentSpanAttributes).length === 0) {
+        return span;
+      }
+      span.data = {
+        ...span.data,
+        ...deploymentSpanAttributes
+      };
+      return span;
+    },
     integrations: [
       sentry_exports.vercelAIIntegration({
         recordInputs: true,

package/dist/nitro.js

@@ -2,21 +2,20 @@ import {
   pluginCatalogConfigFromPluginSet,
   pluginHookRegistrationsFromPluginSet,
   resolveConversationWorkQueueTopic
-} from "./chunk-ICKIDP7G.js";
-import {
-  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
-  JUNIOR_HEARTBEAT_CRON_SCHEDULE,
-  JUNIOR_HEARTBEAT_ROUTE
-} from "./chunk-6YY4Q3D4.js";
-import "./chunk-XC33FJZN.js";
+} from "./chunk-UOTZ3EEQ.js";
+import "./chunk-V4VYUY4A.js";
 import {
   discoverInstalledPluginPackageContent,
   isValidPackageName,
   resolvePackageDir
 } from "./chunk-KVZL5NZS.js";
-import "./chunk-ZJQPA67D.js";
-import "./chunk-6GEYPE6T.js";
-import "./chunk-Z3YD6NHK.js";
+import "./chunk-WS2EG3GW.js";
+import "./chunk-3BYAPS6B.js";
+import {
+  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
+  JUNIOR_HEARTBEAT_CRON_SCHEDULE,
+  JUNIOR_HEARTBEAT_ROUTE
+} from "./chunk-SJHUF3DP.js";
 import "./chunk-2KG3PWR4.js";
 
 // src/nitro.ts

package/dist/reporting.js

@@ -2,42 +2,44 @@ import {
   GET,
   buildSentryConversationUrl,
   buildSentryTraceUrl,
-  buildSystemPrompt,
   formatSlackConversationRedactedLabel,
-  getAgentPluginOperationalReports,
-  getAgentTurnSessionRecord,
   getConversationDetails,
   getConversationDetailsForIds,
-  listAgentTurnSessionSummariesForConversation,
   resolveSlackConversationContextFromThreadId
-} from "./chunk-VSNA5KAB.js";
+} from "./chunk-ZDA2HYX5.js";
+import {
+  buildSystemPrompt,
+  getAgentPluginOperationalReports,
+  getAgentTurnSessionRecord,
+  listAgentTurnSessionSummariesForConversation
+} from "./chunk-UZVHXZ7V.js";
 import {
   discoverSkills
-} from "./chunk-55XEZFGD.js";
+} from "./chunk-OR6NQJ5E.js";
 import {
   getConversation,
   listConversationsByActivity
-} from "./chunk-HNMUVGSR.js";
-import "./chunk-XC33FJZN.js";
+} from "./chunk-AL5T52ZD.js";
+import "./chunk-V4VYUY4A.js";
 import "./chunk-G3E7SCME.js";
 import {
   getPluginPackageContent,
   getPluginProviders
-} from "./chunk-GB3AL54K.js";
+} from "./chunk-7Q5YOUUT.js";
 import {
   homeDir
 } from "./chunk-KVZL5NZS.js";
-import "./chunk-3FYPXHPL.js";
+import "./chunk-DIMX5F3T.js";
 import {
   canExposeConversationPayload,
   parseSlackThreadId,
   resolveConversationPrivacy
-} from "./chunk-ZJQPA67D.js";
-import "./chunk-PP7AGSBU.js";
+} from "./chunk-WS2EG3GW.js";
+import "./chunk-CYUI7JU5.js";
 import {
   isRecord
-} from "./chunk-6GEYPE6T.js";
-import "./chunk-Z3YD6NHK.js";
+} from "./chunk-3BYAPS6B.js";
+import "./chunk-SJHUF3DP.js";
 import "./chunk-2KG3PWR4.js";
 
 // src/reporting.ts
@@ -655,10 +657,10 @@ function isConversationMessage(message) {
 function countConversationMessages(transcript) {
   return transcript.filter(isConversationMessage).length;
 }
-function systemPromptMessage() {
+function systemPromptMessage(destination) {
   return {
     role: "system",
-    parts: [{ type: "text", text: buildSystemPrompt() }]
+    parts: [{ type: "text", text: buildSystemPrompt({ source: destination }) }]
   };
 }
 function turnScopedMessages(messages, turnStartMessageIndex) {
@@ -816,7 +818,7 @@ async function readConversationReport(conversationId) {
       );
       const transcriptMessageCount = countConversationMessages(normalizedTranscript);
       const transcript = canExposeTranscript ? [
-        ...scopedMessages.startsAtRunBoundary && normalizedTranscript.length > 0 ? [systemPromptMessage()] : [],
+        ...scopedMessages.startsAtRunBoundary && normalizedTranscript.length > 0 && sessionRecord?.destination ? [systemPromptMessage(sessionRecord.destination)] : [],
         ...normalizedTranscript
       ] : [];
       const transcriptMetadata = canExposeTranscript ? void 0 : normalizedTranscript.map(redactTranscriptMessage);

package/dist/runner-LMAM4OGD.js

@@ -0,0 +1,259 @@
+import {
+  buildConversationContext,
+  buildDeliveredTurnStatePatch,
+  coerceThreadArtifactsState,
+  generateAssistantReply,
+  getPersistedSandboxState,
+  getPersistedThreadState,
+  markConversationMessage,
+  markTurnFailed,
+  normalizeConversationText,
+  persistThreadStateById,
+  startActiveTurn,
+  updateConversationStats,
+  upsertConversationMessage
+} from "./chunk-OQSYYOLM.js";
+import {
+  commitMessages,
+  loadProjection
+} from "./chunk-UZVHXZ7V.js";
+import "./chunk-OR6NQJ5E.js";
+import {
+  coerceThreadConversationState
+} from "./chunk-M4FLLXXD.js";
+import "./chunk-AL5T52ZD.js";
+import "./chunk-V4VYUY4A.js";
+import "./chunk-RY6AL5C7.js";
+import "./chunk-G3E7SCME.js";
+import "./chunk-7Q5YOUUT.js";
+import "./chunk-KVZL5NZS.js";
+import "./chunk-DIMX5F3T.js";
+import {
+  stripRuntimeTurnContext,
+  trimTrailingAssistantMessages
+} from "./chunk-WS2EG3GW.js";
+import "./chunk-CYUI7JU5.js";
+import "./chunk-3BYAPS6B.js";
+import "./chunk-SJHUF3DP.js";
+import "./chunk-2KG3PWR4.js";
+
+// src/chat/local/runner.ts
+import { THREAD_STATE_TTL_MS } from "chat";
+import {
+  localDestinationSchema
+} from "@sentry/junior-plugin-api";
+var DELIVERED_STATE_PERSIST_ATTEMPTS = 3;
+function localDestination(conversationId) {
+  const parsed = localDestinationSchema.safeParse({
+    platform: "local",
+    conversationId
+  });
+  if (!parsed.success) {
+    throw new Error("Invalid local conversation id");
+  }
+  return parsed.data;
+}
+function localTurnId(sequence) {
+  return `local-turn-${sequence}`;
+}
+function localReply(reply) {
+  return {
+    ...reply.files ? { files: reply.files } : {},
+    text: reply.text
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function nextUserMessageSequence(conversation) {
+  return conversation.messages.filter((message) => message.role === "user").length + 1;
+}
+function preparedLocalPiMessages(messages) {
+  return stripRuntimeTurnContext(trimTrailingAssistantMessages(messages));
+}
+async function loadLocalPiMessages(args) {
+  const projection = await loadProjection({
+    conversationId: args.conversationId
+  });
+  if (args.fallback.length >= projection.length && args.fallback.length > 0) {
+    return preparedLocalPiMessages(args.fallback);
+  }
+  if (projection.length > 0) {
+    return preparedLocalPiMessages(projection);
+  }
+  return void 0;
+}
+async function persistDeliveredLocalTurnState(conversationId, patch) {
+  let lastError;
+  for (let attempt = 1; attempt <= DELIVERED_STATE_PERSIST_ATTEMPTS; attempt += 1) {
+    try {
+      await persistThreadStateById(conversationId, patch);
+      return;
+    } catch (error) {
+      lastError = error;
+      if (attempt < DELIVERED_STATE_PERSIST_ATTEMPTS) {
+        await sleep(attempt * 100);
+      }
+    }
+  }
+  throw lastError;
+}
+async function runLocalAgentTurn(input, deps) {
+  const text = input.message.trim();
+  if (!text) {
+    throw new Error("Local agent message must not be empty");
+  }
+  if (!deps.deliverReply) {
+    throw new Error("Local reply delivery is required");
+  }
+  const destination = localDestination(input.conversationId);
+  const generateAssistantReply2 = deps.generateAssistantReply ?? generateAssistantReply;
+  const now = deps.now ?? (() => Date.now());
+  const persisted = await getPersistedThreadState(input.conversationId);
+  const conversation = coerceThreadConversationState(persisted);
+  let artifacts = coerceThreadArtifactsState(persisted);
+  let { sandboxId, sandboxDependencyProfileHash } = getPersistedSandboxState(persisted);
+  const initialArtifacts = artifacts;
+  const initialSandboxId = sandboxId;
+  const initialSandboxDependencyProfileHash = sandboxDependencyProfileHash;
+  const sequence = nextUserMessageSequence(conversation);
+  const turnId = localTurnId(sequence);
+  const userMessageId = `${turnId}:user`;
+  const startedAtMs = now();
+  upsertConversationMessage(conversation, {
+    id: userMessageId,
+    role: "user",
+    text: normalizeConversationText(text),
+    createdAtMs: startedAtMs,
+    author: {
+      fullName: "Local CLI",
+      userId: "local-cli",
+      userName: "local"
+    },
+    meta: {
+      explicitMention: true,
+      replied: false
+    }
+  });
+  startActiveTurn({
+    conversation,
+    nextTurnId: turnId,
+    updateConversationStats
+  });
+  await persistThreadStateById(input.conversationId, { conversation });
+  let reply;
+  let completedState;
+  let piMessagesBeforeRun;
+  try {
+    const piMessages = await loadLocalPiMessages({
+      conversationId: input.conversationId,
+      fallback: conversation.piMessages
+    });
+    piMessagesBeforeRun = piMessages;
+    reply = await generateAssistantReply2(text, {
+      authorizationFlowMode: "disabled",
+      conversationContext: buildConversationContext(conversation, {
+        excludeMessageId: userMessageId
+      }),
+      artifactState: artifacts,
+      credentialContext: {
+        actor: { type: "system", id: "local-cli" }
+      },
+      destination,
+      requester: {
+        fullName: "Local CLI",
+        platform: "local",
+        userId: "local-cli",
+        userName: "local"
+      },
+      piMessages,
+      surface: "internal",
+      correlation: {
+        conversationId: input.conversationId,
+        turnId,
+        runId: turnId
+      },
+      sandbox: {
+        sandboxId,
+        sandboxDependencyProfileHash
+      },
+      onArtifactStateUpdated: async (nextArtifacts) => {
+        artifacts = nextArtifacts;
+        await persistThreadStateById(input.conversationId, {
+          artifacts,
+          conversation,
+          sandboxId,
+          sandboxDependencyProfileHash
+        });
+      },
+      onSandboxAcquired: async (sandbox) => {
+        sandboxId = sandbox.sandboxId;
+        sandboxDependencyProfileHash = sandbox.sandboxDependencyProfileHash;
+        await persistThreadStateById(input.conversationId, {
+          artifacts,
+          conversation,
+          sandboxId,
+          sandboxDependencyProfileHash
+        });
+      },
+      onStatus: async (status) => {
+        await deps.onStatus?.(status.text);
+      },
+      onTextDelta: deps.onTextDelta
+    });
+    completedState = buildDeliveredTurnStatePatch({
+      artifacts,
+      conversation,
+      reply,
+      sessionId: turnId,
+      userMessageId
+    });
+    await deps.deliverReply(localReply(reply));
+  } catch (error) {
+    if (reply) {
+      await commitMessages({
+        conversationId: input.conversationId,
+        messages: piMessagesBeforeRun ?? [],
+        ttlMs: THREAD_STATE_TTL_MS
+      });
+    }
+    markTurnFailed({
+      conversation,
+      nowMs: now(),
+      sessionId: turnId,
+      userMessageId,
+      markConversationMessage,
+      updateConversationStats
+    });
+    await persistThreadStateById(input.conversationId, {
+      artifacts: initialArtifacts,
+      conversation,
+      sandboxId: initialSandboxId ?? "",
+      sandboxDependencyProfileHash: initialSandboxDependencyProfileHash ?? ""
+    });
+    throw error;
+  }
+  await persistDeliveredLocalTurnState(input.conversationId, {
+    artifacts: completedState.artifacts ?? artifacts,
+    conversation: reply.piMessages ? {
+      ...completedState.conversation,
+      piMessages: reply.piMessages
+    } : completedState.conversation,
+    sandboxId: reply.sandboxId ?? sandboxId,
+    sandboxDependencyProfileHash: reply.sandboxDependencyProfileHash ?? sandboxDependencyProfileHash
+  });
+  if (reply.piMessages) {
+    await commitMessages({
+      conversationId: input.conversationId,
+      messages: reply.piMessages,
+      ttlMs: THREAD_STATE_TTL_MS
+    });
+  }
+  return {
+    conversationId: input.conversationId,
+    outcome: reply.diagnostics.outcome
+  };
+}
+export {
+  runLocalAgentTurn
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.72.0",
+  "version": "0.73.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -65,7 +65,7 @@
     "node-html-markdown": "^2.0.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.72.0"
+    "@sentry/junior-plugin-api": "0.73.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
@@ -78,7 +78,7 @@
     "typescript": "^6.0.3",
     "vercel": "^54.4.0",
     "vitest": "^4.1.7",
-    "@sentry/junior-scheduler": "0.72.0"
+    "@sentry/junior-scheduler": "0.73.0"
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",

package/dist/chunk-6YY4Q3D4.js

@@ -1,12 +0,0 @@
-// src/deployment.ts
-var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";
-var JUNIOR_HEARTBEAT_CRON_SCHEDULE = "* * * * *";
-var JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE = "/api/internal/agent/continue";
-var LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION = "api/internal/agent/continue.ts";
-
-export {
-  JUNIOR_HEARTBEAT_ROUTE,
-  JUNIOR_HEARTBEAT_CRON_SCHEDULE,
-  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
-  LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
-};

package/dist/chunk-Z3YD6NHK.js

@@ -1,12 +0,0 @@
-import {
-  __reExport
-} from "./chunk-2KG3PWR4.js";
-
-// src/chat/sentry.ts
-var sentry_exports = {};
-__reExport(sentry_exports, node_star);
-import * as node_star from "@sentry/node";
-
-export {
-  sentry_exports
-};