@sentry/junior 0.188.0 → 0.189.0

package/dist/chunk-O35GZCKL.js

@@ -0,0 +1,311 @@
+import {
+  usageSchema
+} from "./chunk-PDO5BLNM.js";
+import {
+  botConfig
+} from "./chunk-BYBSI5TI.js";
+import {
+  logWarn
+} from "./chunk-PY3EIEAF.js";
+
+// src/chat/conversations/structured-events.ts
+import {
+  conversationEventPresentationSchema,
+  defineConversationEvent
+} from "@sentry/junior-plugin-api";
+import { z } from "zod";
+var JUNIOR_NATIVE_EVENT_NAMESPACE = "junior";
+var authenticationEventContentSchema = z.object({
+  accountLabel: z.string().trim().min(1).max(120).optional(),
+  actorId: z.string().min(1),
+  authorizationId: z.string().min(1).optional(),
+  provider: z.string().regex(/^[a-z][a-z0-9-]*$/),
+  providerLabel: z.string().trim().min(1).max(80).optional()
+}).strict();
+var agentsInstructionsUpdatedContentSchema = z.object({
+  action: z.enum(["loaded", "replaced", "cleared"]),
+  directory: z.string().trim().min(1).max(500).optional(),
+  fingerprint: z.string().trim().min(1).max(128),
+  sources: z.array(
+    z.object({
+      content: z.string().min(1).max(32 * 1024),
+      path: z.string().trim().min(1).max(500)
+    }).strict()
+  ).max(32),
+  textBytes: z.number().int().nonnegative().optional()
+}).strict();
+function providerTitle(content) {
+  return content.providerLabel?.trim() || content.provider;
+}
+function agentsInstructionsTitle(action) {
+  if (action === "loaded") return "Loaded AGENTS.md";
+  if (action === "replaced") return "Updated AGENTS.md";
+  return "Cleared AGENTS.md";
+}
+function sourceFilename(sourcePath) {
+  return sourcePath.split("/").at(-1) || sourcePath;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} bytes`;
+  const kilobytes = bytes / 1024;
+  return `${Number.isInteger(kilobytes) ? kilobytes : kilobytes.toFixed(1)} KB`;
+}
+function agentsInstructionsPreview(content) {
+  const source = content.sources[0];
+  if (!source) return void 0;
+  const filename = sourceFilename(source.path);
+  const label = content.sources.length === 1 ? filename : `${content.sources.length} AGENTS.md files`;
+  return typeof content.textBytes === "number" ? `${label} \xB7 ${formatBytes(content.textBytes)}` : label;
+}
+var authenticationLinkedEvent = defineConversationEvent({
+  name: "authentication_linked",
+  version: 1,
+  schema: authenticationEventContentSchema,
+  renderEvent(event) {
+    const provider = providerTitle(event);
+    return {
+      icon: "link",
+      title: `${provider} connected`,
+      ...event.accountLabel ? { preview: `Connected as \`${event.accountLabel}\`` } : void 0,
+      details: [
+        {
+          title: `${provider} connected`,
+          ...event.accountLabel ? { description: `Connected as \`${event.accountLabel}\`` } : void 0,
+          metadata: [event.provider]
+        }
+      ]
+    };
+  }
+});
+var authenticationUnlinkedEvent = defineConversationEvent({
+  name: "authentication_unlinked",
+  version: 1,
+  schema: authenticationEventContentSchema,
+  renderEvent(event) {
+    const provider = providerTitle(event);
+    return {
+      icon: "key",
+      title: `${provider} disconnected`,
+      details: [
+        {
+          title: `${provider} disconnected`,
+          metadata: [event.provider]
+        }
+      ]
+    };
+  }
+});
+var agentsInstructionsUpdatedEvent = defineConversationEvent({
+  name: "agents_instructions_updated",
+  version: 1,
+  schema: agentsInstructionsUpdatedContentSchema,
+  renderEvent(event) {
+    const title = agentsInstructionsTitle(event.action);
+    const preview = agentsInstructionsPreview(event);
+    return {
+      icon: "brain",
+      title,
+      ...preview ? { preview } : void 0,
+      ...event.sources.length > 0 ? {
+        details: event.sources.map((source) => ({
+          title: sourceFilename(source.path),
+          content: source.content
+        }))
+      } : void 0
+    };
+  }
+});
+var NATIVE_EVENT_DEFINITIONS = [
+  authenticationLinkedEvent,
+  authenticationUnlinkedEvent,
+  agentsInstructionsUpdatedEvent
+];
+function getJuniorNativeEventDefinition(args) {
+  return NATIVE_EVENT_DEFINITIONS.find(
+    (definition) => definition.eventName === args.name && definition.version === args.version
+  );
+}
+function renderJuniorNativeConversationEvent(args) {
+  if (args.namespace !== JUNIOR_NATIVE_EVENT_NAMESPACE) return void 0;
+  const definition = getJuniorNativeEventDefinition(args);
+  if (!definition) return void 0;
+  const presentation = definition.renderEvent(definition.parse(args.content));
+  return presentation === void 0 ? void 0 : conversationEventPresentationSchema.parse(presentation);
+}
+
+// src/chat/usage.ts
+var agentTurnUsageSchema = usageSchema;
+var COMPONENT_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cachedInputTokens",
+  "cacheCreationTokens"
+];
+var COST_COMPONENT_FIELDS = [
+  "input",
+  "output",
+  "cacheRead",
+  "cacheWrite"
+];
+function hasAgentTurnUsage(usage) {
+  return Boolean(
+    usage && (Object.entries(usage).some(
+      ([field, value]) => field !== "cost" && typeof value === "number" && Number.isFinite(value)
+    ) || Object.values(usage.cost ?? {}).some(
+      (value) => typeof value === "number" && Number.isFinite(value)
+    ))
+  );
+}
+function getFiniteCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function getFiniteCost(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+}
+function addCost(left, right) {
+  return Math.round(((left ?? 0) + right) * 1e12) / 1e12;
+}
+function getComponentTotal(usage) {
+  let total;
+  for (const field of COMPONENT_USAGE_FIELDS) {
+    const value = getFiniteCount(usage[field]);
+    if (value === void 0) continue;
+    total = (total ?? 0) + value;
+  }
+  return total;
+}
+function addAgentTurnUsage(...usages) {
+  const components = {};
+  let componentTotal;
+  let totalOnlyTokens;
+  let reasoningTokens;
+  const cost = {};
+  for (const usage of usages) {
+    if (!usage) continue;
+    const reasoning = getFiniteCount(usage.reasoningTokens);
+    if (reasoning !== void 0) {
+      reasoningTokens = (reasoningTokens ?? 0) + reasoning;
+    }
+    if (usage.cost) {
+      for (const field of [...COST_COMPONENT_FIELDS, "total"]) {
+        const value = getFiniteCost(usage.cost[field]);
+        if (value === void 0) continue;
+        cost[field] = addCost(cost[field], value);
+      }
+    }
+    const usageComponentTotal = getComponentTotal(usage);
+    if (usageComponentTotal !== void 0) {
+      componentTotal = (componentTotal ?? 0) + usageComponentTotal;
+      for (const field of COMPONENT_USAGE_FIELDS) {
+        const value = getFiniteCount(usage[field]);
+        if (value === void 0) continue;
+        components[field] = (components[field] ?? 0) + value;
+      }
+      continue;
+    }
+    const totalTokens = getFiniteCount(usage.totalTokens);
+    if (totalTokens !== void 0) {
+      totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
+    }
+  }
+  if (totalOnlyTokens !== void 0) {
+    return {
+      totalTokens: totalOnlyTokens + (componentTotal ?? 0),
+      ...reasoningTokens !== void 0 ? { reasoningTokens } : void 0,
+      ...Object.keys(cost).length > 0 ? { cost } : void 0
+    };
+  }
+  const result = {
+    ...components,
+    ...reasoningTokens !== void 0 ? { reasoningTokens } : void 0,
+    ...Object.keys(cost).length > 0 ? { cost } : void 0
+  };
+  return hasAgentTurnUsage(result) ? result : void 0;
+}
+
+// src/chat/services/short-title.ts
+var SHORT_TITLE_MAX_LENGTH = 60;
+var TITLE_PROMPTS = {
+  conversation: [
+    "Generate a concise 5-8 word conversation title from the first user message below.",
+    "Capture the user's main request.",
+    "Reply with ONLY the title, with no quotes or trailing punctuation."
+  ],
+  task: [
+    "Generate a concise 5-8 word task title from the task instruction below.",
+    "Capture the task's main purpose.",
+    "Reply with ONLY the title, with no quotes or trailing punctuation."
+  ]
+};
+function normalizeShortTitle(value) {
+  return value.replace(/\s+/g, " ").trim().slice(0, SHORT_TITLE_MAX_LENGTH);
+}
+function fallbackShortTitle(sourceText, fallback = "Untitled") {
+  const firstLine = sourceText.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? "";
+  return normalizeShortTitle(firstLine) || fallback;
+}
+async function generateShortTitle(args) {
+  const sourceText = args.sourceText.trim();
+  if (!sourceText) return void 0;
+  try {
+    const result = await args.completeText({
+      modelId: botConfig.fastModelId,
+      temperature: 0,
+      promptName: `junior.${args.kind}_title`,
+      messages: [
+        {
+          role: "user",
+          content: [
+            ...TITLE_PROMPTS[args.kind],
+            "",
+            args.kind === "conversation" ? `First user message: ${sourceText.slice(0, 500)}` : `Task instruction: ${sourceText.slice(0, 500)}`
+          ].join("\n"),
+          timestamp: Date.now()
+        }
+      ],
+      metadata: {
+        modelId: botConfig.fastModelId
+      }
+    });
+    const title = normalizeShortTitle(result.text);
+    return title || void 0;
+  } catch (error) {
+    logWarn(`${args.kind}.title.generation.failed`, {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
+  }
+}
+async function resolveTaskTitle(args) {
+  const explicit = normalizeShortTitle(args.title ?? "");
+  if (explicit) return explicit;
+  return generateShortTitle({
+    completeText: args.completeText,
+    kind: "task",
+    sourceText: args.instruction
+  });
+}
+
+// src/chat/tools/execution/tool-input-error.ts
+var ToolInputError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ToolInputError";
+  }
+};
+
+export {
+  JUNIOR_NATIVE_EVENT_NAMESPACE,
+  authenticationLinkedEvent,
+  authenticationUnlinkedEvent,
+  agentsInstructionsUpdatedEvent,
+  renderJuniorNativeConversationEvent,
+  SHORT_TITLE_MAX_LENGTH,
+  fallbackShortTitle,
+  generateShortTitle,
+  resolveTaskTitle,
+  ToolInputError,
+  agentTurnUsageSchema,
+  hasAgentTurnUsage,
+  addAgentTurnUsage
+};

package/dist/{chunk-HCIVBCP5.js → chunk-OEIITG5F.js}

@@ -1,6 +1,6 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-NZLZ4KYZ.js";
+} from "./chunk-E3PDZPGV.js";
 
 // src/chat/plugins/validation.ts
 import { isDeepStrictEqual } from "util";

package/dist/{chunk-UVUXFRYN.js → chunk-PCPSX4ES.js}

@@ -1,3 +1,6 @@
+import {
+  isExperimentalFeatureEnabled
+} from "./chunk-2LYHWMR4.js";
 import {
   SlackActionError,
   applyPluginFormatMarkdown,
@@ -5,19 +8,19 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-QCGNHSMA.js";
+} from "./chunk-MI6ZBDTS.js";
 import {
   parseDestination
-} from "./chunk-IUUQWIG2.js";
+} from "./chunk-CUYFCI4G.js";
 import {
   getStateAdapter
-} from "./chunk-ZX7RSBQ6.js";
+} from "./chunk-5CXCGDIL.js";
 import {
   normalizeSlackEmojiName
-} from "./chunk-Q7O74WOO.js";
+} from "./chunk-BYBSI5TI.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-NZLZ4KYZ.js";
+} from "./chunk-E3PDZPGV.js";
 import {
   parseSlackMessageTs,
   parseSlackUserId
@@ -26,7 +29,198 @@ import {
   isRecord,
   logInfo,
   logWarn
-} from "./chunk-QIMN3FXL.js";
+} from "./chunk-PY3EIEAF.js";
+
+// src/chat/agent/types.ts
+var RetryableDeliveryError = class extends Error {
+  constructor(cause) {
+    super("Assistant delivery was transient or ambiguous", { cause });
+    this.name = "RetryableDeliveryError";
+  }
+};
+function isAgentRunFeatureDisabled(disabledFeatures, feature) {
+  return disabledFeatures?.includes(feature) ?? false;
+}
+function actorFromRun(run) {
+  if (run.dispatch?.actor) {
+    return run.dispatch.actor;
+  }
+  if (run.actor) {
+    return run.actor;
+  }
+  if (run.credentialContext && !("type" in run.credentialContext.actor)) {
+    return run.credentialContext.actor;
+  }
+  return void 0;
+}
+function assertRunConsistency(run) {
+  const { destination, source } = run;
+  switch (source.platform) {
+    case "slack": {
+      if (destination.platform !== "slack") {
+        throw new TypeError(
+          "Run source and destination platforms do not match"
+        );
+      }
+      if (source.teamId !== destination.teamId) {
+        throw new TypeError("Slack source and destination teams do not match");
+      }
+      break;
+    }
+    case "local": {
+      if (destination.platform !== "local") {
+        throw new TypeError(
+          "Run source and destination platforms do not match"
+        );
+      }
+      if (source.conversationId !== destination.conversationId) {
+        throw new TypeError(
+          "Source and destination conversation IDs do not match"
+        );
+      }
+      if (run.surface !== "internal" && destination.conversationId !== run.conversationId) {
+        throw new TypeError(
+          "Source, destination, and run conversation IDs do not match"
+        );
+      }
+      break;
+    }
+    case "web": {
+      if (run.surface !== "internal" && source.conversationId !== run.conversationId) {
+        throw new TypeError("Web source and run conversation IDs do not match");
+      }
+      switch (destination.platform) {
+        case "local": {
+          if (source.conversationId !== destination.conversationId) {
+            throw new TypeError(
+              "Source and destination conversation IDs do not match"
+            );
+          }
+          if (run.surface !== "internal" && destination.conversationId !== run.conversationId) {
+            throw new TypeError(
+              "Source, destination, and run conversation IDs do not match"
+            );
+          }
+          break;
+        }
+        case "slack":
+          break;
+      }
+      break;
+    }
+  }
+  const actor = run.dispatch?.actor ?? run.actor;
+  if (!actor || actor.platform === "system") {
+    return;
+  }
+  if (actor.platform !== source.platform) {
+    throw new TypeError(
+      `Actor platform "${actor.platform}" does not match Source platform "${source.platform}"`
+    );
+  }
+  if (actor.platform === "slack" && source.platform === "slack" && actor.teamId !== source.teamId) {
+    throw new TypeError("Slack Actor team does not match Source team");
+  }
+}
+function toolInvocationDestination(run) {
+  if (run.destination.platform !== "slack" || !run.toolChannelId) {
+    return run.destination;
+  }
+  return {
+    platform: "slack",
+    teamId: run.destination.teamId,
+    channelId: run.toolChannelId
+  };
+}
+function surfaceFromRun(run) {
+  if (run.surface) {
+    return run.surface;
+  }
+  if (run.source.platform === "slack") {
+    return "slack";
+  }
+  if (run.source.platform === "web") {
+    return "api";
+  }
+  return "internal";
+}
+
+// src/chat/runtime/agent-runner.ts
+var AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
+function createAgentRunner(execute, options) {
+  const attachmentStorage = options?.attachmentStorage;
+  const streamFn = options?.streamFn;
+  const tracePropagation = options?.tracePropagation;
+  const bindSpawnAgent = options?.bindSpawnAgent;
+  const canBindSpawn = Boolean(bindSpawnAgent) && isExperimentalFeatureEnabled("subagents");
+  return {
+    run: async (run) => {
+      const spawnAgent = bindSpawnAgent && canBindSpawn && !isAgentRunFeatureDisabled(run.disabledFeatures, "subagents") ? bindSpawnAgent(run) : void 0;
+      const nextRun = {
+        ...run,
+        environment: {
+          ...run.environment,
+          attachmentStorage: run.environment?.attachmentStorage ?? attachmentStorage,
+          sandboxTracePropagation: run.environment?.sandboxTracePropagation ?? tracePropagation
+        },
+        ...spawnAgent ? {
+          durability: {
+            ...run.durability,
+            spawnAgent
+          }
+        } : void 0
+      };
+      return await execute(nextRun, streamFn);
+    }
+  };
+}
+async function waitForAgentSettlement(runPromise) {
+  let timeoutId;
+  const settleGrace = new Promise((resolve) => {
+    timeoutId = setTimeout(resolve, AGENT_ABORT_SETTLE_GRACE_MS);
+    timeoutId.unref?.();
+  });
+  await Promise.race([
+    runPromise.then(
+      () => void 0,
+      () => void 0
+    ),
+    settleGrace
+  ]);
+  if (timeoutId) {
+    clearTimeout(timeoutId);
+  }
+}
+async function runAgentWithTimeout(agentRunner, run, timeoutMs) {
+  if (typeof timeoutMs !== "number") {
+    return await agentRunner.run(run);
+  }
+  const timeoutError = new Error(
+    `executeAgentRun timed out after ${timeoutMs}ms`
+  );
+  const abortController = new AbortController();
+  const signal = run.signal ? AbortSignal.any([run.signal, abortController.signal]) : abortController.signal;
+  const runPromise = agentRunner.run({ ...run, signal });
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      abortController.abort(timeoutError);
+      reject(timeoutError);
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([runPromise, timeoutPromise]);
+  } catch (error) {
+    if (abortController.signal.aborted) {
+      await waitForAgentSettlement(runPromise);
+    }
+    throw error;
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
 
 // src/chat/slack/outbound.ts
 var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
@@ -705,6 +899,12 @@ async function startOAuthFlow(provider, input) {
 }
 
 export {
+  RetryableDeliveryError,
+  isAgentRunFeatureDisabled,
+  actorFromRun,
+  assertRunConsistency,
+  toolInvocationDestination,
+  surfaceFromRun,
   getSlackMessagePermalink,
   postSlackMessage,
   uploadFilesToConversation,
@@ -719,5 +919,7 @@ export {
   formatProviderLabel,
   resolveBaseUrl,
   deliverOAuthAuthorization,
-  startOAuthFlow
+  startOAuthFlow,
+  createAgentRunner,
+  runAgentWithTimeout
 };

package/dist/{chunk-QIMN3FXL.js → chunk-PY3EIEAF.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-32XSSFZV.js";
+} from "./chunk-NY2F7BZA.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";