@sentry/junior 0.136.1 → 0.138.0

package/dist/chunk-PB3CXNVL.js

@@ -0,0 +1,41 @@
+import {
+  createAndEnqueueAgentInvocation
+} from "./chunk-ZBSMCXKV.js";
+import {
+  actorFromRouting,
+  toolInvocationDestination
+} from "./chunk-R776HKPK.js";
+
+// src/chat/agent-invocations/spawn.ts
+function bindSpawnAgent(request, options) {
+  const actor = actorFromRouting(request.routing);
+  if (!actor) {
+    return void 0;
+  }
+  return async (input, call) => {
+    call.signal?.throwIfAborted();
+    const queue = typeof options.queue === "function" ? options.queue() : options.queue;
+    const invocation = await createAndEnqueueAgentInvocation(
+      {
+        actor,
+        ...input.name ? { agentName: input.name } : {},
+        ...request.routing.credentialContext ? { credentialContext: request.routing.credentialContext } : {},
+        destination: toolInvocationDestination(request.routing),
+        ...request.routing.destinationVisibility ? {
+          destinationVisibility: request.routing.destinationVisibility
+        } : {},
+        idempotencyKey: `${request.turnId}:${call.toolCallId}`,
+        input: input.task,
+        parentConversationId: request.conversationId,
+        ...input.reasoningLevel ? { reasoningLevel: input.reasoningLevel } : {},
+        source: request.routing.source
+      },
+      { ...options, queue }
+    );
+    return { invocationId: invocation.invocationId };
+  };
+}
+
+export {
+  bindSpawnAgent
+};

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-3QNJOHKG.js → chunk-QS527AV5.js}

@@ -1,6 +1,6 @@
 import {
   createPluginCatalogRuntime
-} from "./chunk-VH6MI4L7.js";
+} from "./chunk-KFRHRSCJ.js";
 
 // src/chat/plugins/catalog-runtime.ts
 var pluginCatalogRuntime = createPluginCatalogRuntime();

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