@sentry/junior 0.71.3 → 0.73.0

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.71.3",
+  "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.71.3"
+    "@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.71.3"
+    "@sentry/junior-scheduler": "0.73.0"
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",

package/dist/chat/runtime/timeout-resume-runner.d.ts

@@ -1,19 +0,0 @@
-import { type TurnContinuationRequest } from "@/chat/services/timeout-resume";
-/** Runtime ports for timeout continuation scheduling. */
-export interface TimeoutResumeRunnerOptions {
-    scheduleTurnTimeoutResume?: (request: TurnContinuationRequest) => Promise<void>;
-}
-/**
- * Resume one durable timeout continuation for a Slack thread.
- *
- * Returns false when the session became stale before generation began.
- */
-export declare function resumeTimedOutTurn(payload: TurnContinuationRequest, options?: TimeoutResumeRunnerOptions): Promise<boolean>;
-/**
- * Retry timeout continuation when the normal Slack thread lock is briefly busy.
- *
- * Returns false when the session became stale before generation began. A busy
- * lock that is rescheduled still returns true because runnable work remains
- * durable.
- */
-export declare function resumeTimedOutTurnWithLockRetry(payload: TurnContinuationRequest, options?: TimeoutResumeRunnerOptions): Promise<boolean>;

package/dist/chat/services/requester-identity.d.ts

@@ -1,19 +0,0 @@
-export interface ActorIdentityInput {
-    email?: string;
-    fullName?: string;
-    userId?: string;
-    userName?: string;
-}
-export interface SlackActorProfile {
-    email?: string;
-    fullName?: string;
-    userName?: string;
-}
-/** Keep actor ids exact at platform boundaries before they enter owned state. */
-export declare function parseActorUserId(value: unknown): string | undefined;
-/** Assert persisted actor ids without read-side repair. */
-export declare function isActorUserId(value: string | undefined): value is string;
-/** Keep authority ids exact while attaching optional presentation fields. */
-export declare function buildActorIdentity(requester: ActorIdentityInput | undefined, requesterId?: string): ActorIdentityInput | undefined;
-/** Use Slack profile data only as presentation around the exact user id. */
-export declare function slackActorIdentity(userId: string, profile: SlackActorProfile | null | undefined): ActorIdentityInput;

package/dist/chat/services/timeout-resume.d.ts

@@ -1,23 +0,0 @@
-import type { StateAdapter } from "chat";
-import type { Destination } from "@sentry/junior-plugin-api";
-import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
-export interface TurnContinuationRequest {
-    conversationId: string;
-    destination: Destination;
-    expectedVersion: number;
-    sessionId: string;
-}
-export interface ScheduleTurnTimeoutResumeOptions {
-    nowMs?: number;
-    queue?: ConversationWorkQueue;
-    state?: StateAdapter;
-}
-/** Build the callback request for an awaiting automatic turn continuation. */
-export declare function getAwaitingTurnContinuationRequest(args: {
-    conversationId: string;
-    sessionId: string;
-}): Promise<TurnContinuationRequest | undefined>;
-/** Schedule durable conversation work to resume a timed-out turn. */
-export declare function scheduleTurnTimeoutResume(request: TurnContinuationRequest, options?: ScheduleTurnTimeoutResumeOptions): Promise<void>;
-/** Verify and parse an authenticated timeout resume callback request. */
-export declare function verifyTurnTimeoutResumeRequest(request: Request): Promise<TurnContinuationRequest | undefined>;

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
-};

package/dist/handlers/turn-resume.d.ts

@@ -1,4 +0,0 @@
-import { type TimeoutResumeRunnerOptions } from "@/chat/runtime/timeout-resume-runner";
-import type { WaitUntilFn } from "@/handlers/types";
-/** Handle an authenticated internal timeout-resume callback. */
-export declare function POST(request: Request, waitUntil: WaitUntilFn, options?: TimeoutResumeRunnerOptions): Promise<Response>;