@sentry/junior 0.137.0 → 0.139.0

package/dist/chunk-Q6QZTTLS.js

@@ -0,0 +1,55 @@
+// src/chat/conversations/turn-lifecycle.ts
+var ConversationTurnLifecycleService = class {
+  constructor(events) {
+    this.events = events;
+  }
+  events;
+  /** Record the turn start once after every input message is durable. */
+  async start(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:started`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_started",
+          turnId: input.turnId,
+          inputMessageIds: input.inputMessageIds,
+          surface: input.surface
+        }
+      }
+    ]);
+  }
+  /** Record successful or intentional-silence completion once. */
+  async complete(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:terminal`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_completed",
+          turnId: input.turnId,
+          outcome: input.outcome
+        }
+      }
+    ]);
+  }
+  /** Record a classified failure once without accepting raw error details. */
+  async fail(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:terminal`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_failed",
+          turnId: input.turnId,
+          failureCode: input.failureCode,
+          ...input.eventId ? { eventId: input.eventId } : {}
+        }
+      }
+    ]);
+  }
+};
+
+export {
+  ConversationTurnLifecycleService
+};

package/dist/{chunk-ZFS67WIR.js → chunk-QTBKPZDA.js}

@@ -5,12 +5,12 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-RB4NJKEX.js";
+} from "./chunk-UDBUS533.js";
 import {
   TURN_REASONING_LEVELS,
   getChatConfig,
   modelProfileSchema
-} from "./chunk-UG6ZYPBI.js";
+} from "./chunk-75I3UBIL.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -20,7 +20,7 @@ import {
 } from "./chunk-F3B2YJ76.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-T6Z5S6PQ.js";
+} from "./chunk-2ECYPYKP.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -259,6 +259,12 @@ function privacyFromLocationRow(row) {
 
 // src/chat/conversations/sql/store.ts
 var CONVERSATION_MUTATION_LOCK_PREFIX = "junior_conversation";
+async function withConversationMutationLock(executor, conversationId, callback) {
+  return await executor.withLock(
+    `${CONVERSATION_MUTATION_LOCK_PREFIX}:${conversationId}`,
+    async () => await executor.transaction(callback)
+  );
+}
 function now() {
   return Date.now();
 }
@@ -549,6 +555,49 @@ var SqlStore = class {
   async bindProviderConversation(args) {
     await bindProviderConversation(this.executor, args);
   }
+  async createChild(args) {
+    const nowMs = args.nowMs ?? now();
+    await this.withConversationMutation(args.parentConversationId, async () => {
+      await this.withConversationMutation(
+        args.childConversationId,
+        async () => {
+          const existing = await this.get({
+            conversationId: args.childConversationId
+          });
+          if (existing) {
+            if (existing.lineage?.parentConversationId !== args.parentConversationId) {
+              throw new Error(
+                `Conversation lineage changed for ${args.childConversationId}`
+              );
+            }
+            return;
+          }
+          const parent = await this.get({
+            conversationId: args.parentConversationId
+          });
+          if (!parent) {
+            throw new Error(
+              `Conversation parent is missing for ${args.childConversationId}`
+            );
+          }
+          if (parent.lineage) {
+            throw new Error("Recursive agent delegation is not enabled");
+          }
+          const child = {
+            ...emptyConversation({
+              conversationId: args.childConversationId,
+              nowMs,
+              source: args.source
+            }),
+            lineage: {
+              parentConversationId: args.parentConversationId
+            }
+          };
+          await this.upsertConversation({ conversation: child });
+        }
+      );
+    });
+  }
   async get(args) {
     const row = await this.readConversationRow(args.conversationId);
     if (!row) {
@@ -695,9 +744,10 @@ var SqlStore = class {
   }
   /** Serialize all durable mutations for one conversation inside a SQL transaction. */
   async withConversationMutation(conversationId, callback) {
-    return await this.executor.withLock(
-      `${CONVERSATION_MUTATION_LOCK_PREFIX}:${conversationId}`,
-      async () => await this.executor.transaction(callback)
+    return await withConversationMutationLock(
+      this.executor,
+      conversationId,
+      callback
     );
   }
   async readConversationRow(conversationId) {
@@ -1666,6 +1716,7 @@ export {
   parseSessionSource,
   bindProviderConversation,
   locationFromRow,
+  withConversationMutationLock,
   instructionProvenanceFor,
   contextProvenance,
   sameActorIdentity,

package/dist/chunk-R776HKPK.js

@@ -0,0 +1,81 @@
+// src/chat/agent/request.ts
+function isAgentRunFeatureDisabled(policy, feature) {
+  return policy?.disabledFeatures?.includes(feature) ?? false;
+}
+var RetryableDeliveryError = class extends Error {
+  constructor(cause) {
+    super("Assistant delivery was transient or ambiguous", { cause });
+    this.name = "RetryableDeliveryError";
+  }
+};
+function actorFromRouting(routing) {
+  if (routing.dispatch?.actor) {
+    return routing.dispatch.actor;
+  }
+  if (routing.actor) {
+    return routing.actor;
+  }
+  if (routing.credentialContext && !("type" in routing.credentialContext.actor)) {
+    return routing.credentialContext.actor;
+  }
+  return void 0;
+}
+function assertRunRoutingConsistency(request) {
+  const { destination, source } = request.routing;
+  if (source.platform !== destination.platform) {
+    throw new TypeError("Run source and destination platforms do not match");
+  }
+  if (source.platform === "slack" && destination.platform === "slack") {
+    if (source.teamId !== destination.teamId) {
+      throw new TypeError("Slack source and destination teams do not match");
+    }
+  } else if (source.platform === "local" && destination.platform === "local") {
+    if (source.conversationId !== destination.conversationId) {
+      throw new TypeError(
+        "Local source and destination conversation IDs do not match"
+      );
+    }
+    if (request.routing.surface !== "internal" && destination.conversationId !== request.conversationId) {
+      throw new TypeError(
+        "Local source, destination, and run conversation IDs do not match"
+      );
+    }
+  }
+  const actor = request.routing.dispatch?.actor ?? request.routing.actor;
+  if (!actor || actor.platform === "system") {
+    return;
+  }
+  if (actor.platform !== destination.platform) {
+    throw new TypeError(
+      `Actor platform "${actor.platform}" does not match destination platform "${destination.platform}"`
+    );
+  }
+  if (actor.platform === "slack" && destination.platform === "slack" && actor.teamId !== destination.teamId) {
+    throw new TypeError("Slack actor team does not match destination team");
+  }
+}
+function toolInvocationDestination(routing) {
+  if (routing.destination.platform !== "slack" || !routing.toolChannelId) {
+    return routing.destination;
+  }
+  return {
+    platform: "slack",
+    teamId: routing.destination.teamId,
+    channelId: routing.toolChannelId
+  };
+}
+function surfaceFromRouting(routing) {
+  if (routing.surface) {
+    return routing.surface;
+  }
+  return routing.source.platform === "slack" ? "slack" : "internal";
+}
+
+export {
+  isAgentRunFeatureDisabled,
+  RetryableDeliveryError,
+  actorFromRouting,
+  assertRunRoutingConsistency,
+  toolInvocationDestination,
+  surfaceFromRouting
+};

package/dist/{chunk-77VDLF3Z.js → chunk-RUIXF3YQ.js}

@@ -74,6 +74,15 @@ var credentialContextSchema = z.union([
     subject: credentialSubjectSchema.optional()
   }).strict()
 ]);
+function credentialContextForActor(actor, subject) {
+  if (actor.platform === "system") {
+    return subject ? { actor, subject } : { actor };
+  }
+  if (subject) {
+    throw new TypeError("Delegated credential subjects require a system actor");
+  }
+  return { actor: { type: "user", userId: actor.userId } };
+}
 function credentialUserSubjectId(context) {
   if ("type" in context.actor) {
     return context.actor.userId;
@@ -84,5 +93,6 @@ function credentialUserSubjectId(context) {
 export {
   credentialSubjectSchema,
   credentialContextSchema,
+  credentialContextForActor,
   credentialUserSubjectId
 };