@sentry/junior 0.96.0 → 0.97.1

package/dist/{chunk-YDVEH3SB.js → chunk-EEZCY5WX.js}

@@ -6,7 +6,7 @@ import {
   toGenAiMessageMetadata,
   toGenAiMessagesTraceAttributes,
   toGenAiTextMetadata
-} from "./chunk-GY34VGP5.js";
+} from "./chunk-LVA4I4H7.js";
 import {
   extractGenAiUsageAttributes,
   logException,
@@ -152,6 +152,16 @@ function hasRuntimeTurnContext(messages) {
     )
   );
 }
+function retainRuntimeTurnContext(messages) {
+  return messages.flatMap((message) => {
+    const content = getUserMessageContent(message);
+    if (!content) {
+      return [];
+    }
+    const runtimeContent = content.filter(isRuntimeTurnContextPart);
+    return runtimeContent.length > 0 ? [{ ...message, content: runtimeContent }] : [];
+  });
+}
 function instructionTextForProjection(text) {
   const withoutContext = text.replace(EMBEDDED_THREAD_CONTEXT_PATTERN, "").trim();
   return unwrapCurrentInstruction(withoutContext) ?? withoutContext;
@@ -531,6 +541,28 @@ function normalizeSlackEmojiName(value) {
   return SLACK_EMOJI_NAME_RE.test(normalized) ? normalized : null;
 }
 
+// src/chat/model-profile.ts
+import { z } from "zod";
+var STANDARD_MODEL_PROFILE = "standard";
+var DEFAULT_HANDOFF_MODEL_PROFILE = "handoff";
+var modelProfileSchema = z.string().regex(/^[a-z][a-z0-9_-]*$/);
+var ModelProfileNotConfiguredError = class extends Error {
+  constructor(profile) {
+    super(`Model profile "${profile}" is not configured`);
+    this.name = "ModelProfileNotConfiguredError";
+  }
+};
+function modelIdForProfile(config, profile) {
+  if (profile === STANDARD_MODEL_PROFILE) {
+    return config.modelId;
+  }
+  const modelId = Object.hasOwn(config.modelProfiles, profile) ? config.modelProfiles[profile] : void 0;
+  if (!modelId) {
+    throw new ModelProfileNotConfiguredError(profile);
+  }
+  return modelId;
+}
+
 // src/chat/config.ts
 var MIN_AGENT_TURN_TIMEOUT_MS = 10 * 1e3;
 var DEFAULT_AGENT_TURN_TIMEOUT_MS = 12 * 60 * 1e3;
@@ -538,14 +570,6 @@ var DEFAULT_FUNCTION_MAX_DURATION_SECONDS = 300;
 var DEFAULT_SLACK_SLASH_COMMAND = "/jr";
 var DEFAULT_PROCESSING_REACTION_EMOJI = "eyes";
 var DEFAULT_COMPLETED_REACTION_EMOJI = "white_check_mark";
-var ADVISOR_THINKING_LEVELS = [
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-var DEFAULT_ADVISOR_THINKING_LEVEL = "xhigh";
 var FUNCTION_TIMEOUT_BUFFER_SECONDS = 20;
 var DEFAULT_ASSISTANT_LOADING_MESSAGES = [
   "Consulting the orb",
@@ -604,18 +628,6 @@ function parseLoadingMessages(rawValue) {
     return value.trim();
   });
 }
-function parseAdvisorThinkingLevel(rawValue) {
-  const value = toOptionalTrimmed(rawValue);
-  if (!value) {
-    return DEFAULT_ADVISOR_THINKING_LEVEL;
-  }
-  if (ADVISOR_THINKING_LEVELS.includes(value)) {
-    return value;
-  }
-  throw new Error(
-    `AI_ADVISOR_THINKING_LEVEL must be one of: minimal, low, medium, high, xhigh`
-  );
-}
 function parseOptionalPositiveInteger(envName, rawValue) {
   const trimmed = toOptionalTrimmed(rawValue);
   if (trimmed === void 0) {
@@ -641,7 +653,7 @@ var DEFAULT_FAST_MODEL_ID = getModel(
   "vercel-ai-gateway",
   "openai/gpt-5.4-mini"
 ).id;
-var DEFAULT_ADVISOR_MODEL_ID = getModel(
+var DEFAULT_HANDOFF_MODEL_ID = getModel(
   "vercel-ai-gateway",
   "openai/gpt-5.6-sol"
 ).id;
@@ -655,11 +667,42 @@ function validateGatewayModelId(raw) {
 function validateEmbeddingModelId(raw) {
   return toOptionalTrimmed(raw);
 }
-function readAdvisorConfig(env) {
-  return {
-    modelId: validateGatewayModelId(env.AI_ADVISOR_MODEL) ?? DEFAULT_ADVISOR_MODEL_ID,
-    thinkingLevel: parseAdvisorThinkingLevel(env.AI_ADVISOR_THINKING_LEVEL)
+function parseModelProfiles(rawValue, handoffModelId) {
+  const profiles = {
+    [DEFAULT_HANDOFF_MODEL_PROFILE]: handoffModelId
   };
+  const trimmed = toOptionalTrimmed(rawValue);
+  if (trimmed === void 0) {
+    return profiles;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error("AI_MODEL_PROFILES must be a JSON object");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("AI_MODEL_PROFILES must be a JSON object");
+  }
+  for (const [profile, rawModelId] of Object.entries(parsed)) {
+    if (!modelProfileSchema.safeParse(profile).success) {
+      throw new Error(
+        `AI_MODEL_PROFILES profile "${profile}" must match ^[a-z][a-z0-9_-]*$`
+      );
+    }
+    if (profile === STANDARD_MODEL_PROFILE || profile === DEFAULT_HANDOFF_MODEL_PROFILE) {
+      throw new Error(`AI_MODEL_PROFILES profile "${profile}" is reserved`);
+    }
+    if (typeof rawModelId !== "string") {
+      throw new Error(`AI_MODEL_PROFILES.${profile} must be a model id string`);
+    }
+    const modelId = validateGatewayModelId(rawModelId);
+    if (!modelId) {
+      throw new Error(`AI_MODEL_PROFILES.${profile} must not be empty`);
+    }
+    profiles[profile] = modelId;
+  }
+  return profiles;
 }
 function parseReactionEmoji(envName, rawValue, defaultEmoji) {
   const trimmed = toOptionalTrimmed(rawValue);
@@ -679,9 +722,11 @@ function readBotConfig(env) {
   const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(functionMaxDurationSeconds);
   const modelId = validateGatewayModelId(env.AI_MODEL) ?? DEFAULT_MODEL_ID;
   const fastModelId = validateGatewayModelId(env.AI_FAST_MODEL ?? env.AI_MODEL) ?? DEFAULT_FAST_MODEL_ID;
+  const handoffModelId = validateGatewayModelId(env.AI_HANDOFF_MODEL) ?? DEFAULT_HANDOFF_MODEL_ID;
   return {
     userName: toOptionalTrimmed(env.JUNIOR_BOT_NAME) ?? "junior",
     modelId,
+    modelProfiles: parseModelProfiles(env.AI_MODEL_PROFILES, handoffModelId),
     modelContextWindowTokens: parseOptionalPositiveInteger(
       "AI_MODEL_CONTEXT_WINDOW_TOKENS",
       env.AI_MODEL_CONTEXT_WINDOW_TOKENS
@@ -693,8 +738,7 @@ function readBotConfig(env) {
     turnTimeoutMs: parseAgentTurnTimeoutMs(
       env.AGENT_TURN_TIMEOUT_MS,
       maxTurnTimeoutMs
-    ),
-    advisor: readAdvisorConfig(env)
+    )
   };
 }
 function readDatabaseUrl(env) {
@@ -1050,6 +1094,7 @@ export {
   getTerminalAssistantMessages,
   trimTrailingAssistantMessages,
   hasRuntimeTurnContext,
+  retainRuntimeTurnContext,
   instructionTextForProjection,
   stripRuntimeTurnContext,
   isProviderRetryError,
@@ -1065,6 +1110,11 @@ export {
   completeObject,
   embedTexts,
   normalizeSlackEmojiName,
+  STANDARD_MODEL_PROFILE,
+  DEFAULT_HANDOFF_MODEL_PROFILE,
+  modelProfileSchema,
+  ModelProfileNotConfiguredError,
+  modelIdForProfile,
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   getChatConfig,
   botConfig,

package/dist/{chunk-2NAZZPPS.js → chunk-EOWXRY5E.js}

@@ -1,6 +1,6 @@
 import {
   getStateAdapter
-} from "./chunk-YDVEH3SB.js";
+} from "./chunk-EEZCY5WX.js";
 import {
   logException,
   logInfo,

package/dist/{chunk-GQ3GK22G.js → chunk-FBHZJFHI.js}

@@ -1,11 +1,11 @@
 import {
   JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-5C6XTTFI.js";
+} from "./chunk-WJOSZOON.js";
 import {
   getChatConfig,
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-YDVEH3SB.js";
+} from "./chunk-EEZCY5WX.js";
 import {
   parseDestination,
   sameDestination

package/dist/{chunk-CZEX6KIQ.js → chunk-G3E7SCME.js}

@@ -1,25 +1,3 @@
-// src/chat/sleep.ts
-function sleep(ms, signal) {
-  if (!signal) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  return new Promise((resolve, reject) => {
-    if (signal.aborted) {
-      reject(signal.reason);
-      return;
-    }
-    const timeoutId = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timeoutId);
-      reject(signal.reason);
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
 // src/chat/sandbox/paths.ts
 function normalizeWorkspaceRoot(input) {
   const candidate = (input ?? "").trim();
@@ -42,7 +20,6 @@ function sandboxSkillFile(skillName) {
 }
 
 export {
-  sleep,
   SANDBOX_WORKSPACE_ROOT,
   SANDBOX_SKILLS_ROOT,
   SANDBOX_DATA_ROOT,

package/dist/chunk-GUAP3H7O.js

@@ -0,0 +1,319 @@
+import {
+  ensureLegacyConversationImport
+} from "./chunk-3F4OPKGF.js";
+import {
+  contextProvenance,
+  getAgentStepStore
+} from "./chunk-35BNLDOJ.js";
+
+// src/chat/conversations/projection.ts
+import { isDeepStrictEqual } from "util";
+function authorizationObservationMessage(entry, createdAtMs) {
+  const label = entry.kind === "mcp" ? "MCP authorization" : "Authorization";
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `${label} completed for provider "${entry.provider}". Continue the blocked request and retry the provider operation if needed.`
+      }
+    ],
+    timestamp: createdAtMs
+  };
+}
+function piEntryProvenance(entry) {
+  return entry.provenance ?? contextProvenance;
+}
+function projectSteps(steps, opts) {
+  const messages = [];
+  const provenance = [];
+  const seqs = [];
+  let modelProfile = "standard";
+  let modelId;
+  for (const step of steps) {
+    if (opts?.maxSeq !== void 0 && step.seq > opts.maxSeq) {
+      break;
+    }
+    if (step.entry.type === "context_epoch_started") {
+      modelProfile = step.entry.modelProfile ?? "standard";
+      modelId = step.entry.modelId;
+      continue;
+    }
+    if (step.entry.type === "pi_message") {
+      messages.push(step.entry.message);
+      provenance.push(piEntryProvenance(step.entry));
+      seqs.push(step.seq);
+      continue;
+    }
+    if (step.entry.type === "authorization_completed") {
+      messages.push(
+        authorizationObservationMessage(step.entry, step.createdAtMs)
+      );
+      provenance.push(contextProvenance);
+      seqs.push(step.seq);
+    }
+  }
+  return { messages, provenance, seqs, modelProfile, modelId };
+}
+function connectedMcpProvidersFromSteps(steps) {
+  const providers = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (step.entry.type === "mcp_provider_connected") {
+      providers.add(step.entry.provider);
+    }
+  }
+  return [...providers].sort((left, right) => left.localeCompare(right));
+}
+function isUserMessage(message) {
+  return message.role === "user";
+}
+function countMatchingPrefix(left, right) {
+  const limit = Math.min(left.length, right.length);
+  for (let index = 0; index < limit; index += 1) {
+    if (!isDeepStrictEqual(left[index], right[index])) {
+      return index;
+    }
+  }
+  return limit;
+}
+function resolveCommitProvenance(args) {
+  if (args.explicitProvenance) {
+    if (args.explicitProvenance.length !== args.nextMessages.length) {
+      throw new Error("commit provenance must align one-to-one with messages");
+    }
+    return args.explicitProvenance;
+  }
+  const matchingPrefix = args.matchingPrefix;
+  const provenance = args.nextMessages.map(
+    (_, index) => index < matchingPrefix ? args.existing.provenance[index] ?? contextProvenance : contextProvenance
+  );
+  if (args.newMessageProvenance) {
+    for (let index = args.nextMessages.length - 1; index >= matchingPrefix; index -= 1) {
+      if (isUserMessage(args.nextMessages[index])) {
+        provenance[index] = args.newMessageProvenance;
+        break;
+      }
+    }
+  }
+  if (args.trailingMessageProvenance) {
+    if (args.trailingMessageProvenance.length > provenance.length) {
+      throw new Error(
+        "trailing commit provenance cannot exceed committed messages"
+      );
+    }
+    const newMessageCount = args.nextMessages.length - matchingPrefix;
+    if (args.trailingMessageProvenance.length > newMessageCount) {
+      throw new Error(
+        "trailing commit provenance must align to newly committed messages"
+      );
+    }
+    const start = provenance.length - args.trailingMessageProvenance.length;
+    args.trailingMessageProvenance.forEach((entry, offset) => {
+      provenance[start + offset] = entry;
+    });
+  }
+  return provenance;
+}
+async function importLegacyIfNeeded(args) {
+  await ensureLegacyConversationImport({ conversationId: args.conversationId });
+}
+async function loadProjection(args) {
+  await importLegacyIfNeeded(args);
+  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
+  return projectSteps(steps).messages;
+}
+async function loadConversationProjection(args) {
+  await importLegacyIfNeeded(args);
+  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
+  const { messages, provenance, modelProfile, modelId } = projectSteps(steps);
+  return { messages, provenance, modelProfile, modelId };
+}
+async function openConversationProjection(args) {
+  await importLegacyIfNeeded(args);
+  const stepStore = getAgentStepStore();
+  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
+  const projection = projectSteps(steps);
+  if (steps.some(
+    (step) => step.entry.type === "context_epoch_started" || step.entry.type === "pi_message"
+  )) {
+    return projection;
+  }
+  await stepStore.startEpoch(args.conversationId, {
+    reason: "initial",
+    modelProfile: "standard",
+    modelId: args.modelId,
+    messages: []
+  });
+  return {
+    messages: projection.messages,
+    provenance: projection.provenance,
+    modelProfile: "standard",
+    modelId: args.modelId
+  };
+}
+async function loadTurnProjection(args) {
+  await importLegacyIfNeeded(args);
+  const stepStore = getAgentStepStore();
+  if (args.committedSeq < 0) {
+    return projectSteps(await stepStore.loadCurrentEpoch(args.conversationId));
+  }
+  const history = await stepStore.loadHistory(args.conversationId);
+  const committedStep = history.find((step) => step.seq === args.committedSeq);
+  if (!committedStep) {
+    return void 0;
+  }
+  const epochSteps = history.filter(
+    (step) => step.contextEpoch === committedStep.contextEpoch
+  );
+  return args.includeTail ? projectSteps(epochSteps) : projectSteps(epochSteps, { maxSeq: args.committedSeq });
+}
+async function loadConnectedMcpProviders(args) {
+  await importLegacyIfNeeded(args);
+  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
+  return connectedMcpProvidersFromSteps(steps);
+}
+function messageTimestamp(message) {
+  const timestamp = message.timestamp;
+  return typeof timestamp === "number" ? timestamp : Date.now();
+}
+async function commitMessages(args) {
+  const stepStore = getAgentStepStore();
+  const currentSteps = await stepStore.loadCurrentEpoch(args.conversationId);
+  const existing = projectSteps(currentSteps);
+  const matchingPrefix = countMatchingPrefix(existing.messages, args.messages);
+  const nextProvenance = resolveCommitProvenance({
+    existing,
+    nextMessages: args.messages,
+    matchingPrefix,
+    ...args.provenance ? { explicitProvenance: args.provenance } : {},
+    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {},
+    ...args.newMessageProvenance ? { newMessageProvenance: args.newMessageProvenance } : {}
+  });
+  if (currentSteps.length === 0) {
+    await stepStore.startEpoch(args.conversationId, {
+      reason: "initial",
+      modelProfile: "standard",
+      modelId: args.modelId,
+      messages: args.messages.map((message, index) => ({
+        message,
+        createdAtMs: messageTimestamp(message),
+        provenance: nextProvenance[index]
+      }))
+    });
+  } else if (matchingPrefix === existing.messages.length) {
+    const newMessages = args.messages.slice(matchingPrefix);
+    await stepStore.append(
+      args.conversationId,
+      newMessages.map((message, index) => ({
+        entry: {
+          type: "pi_message",
+          message,
+          provenance: nextProvenance[matchingPrefix + index]
+        },
+        createdAtMs: messageTimestamp(message)
+      }))
+    );
+  } else {
+    await stepStore.startEpoch(args.conversationId, {
+      reason: "rollback",
+      modelProfile: existing.modelProfile,
+      modelId: args.modelId,
+      messages: args.messages.map((message, index) => ({
+        message,
+        createdAtMs: messageTimestamp(message),
+        provenance: nextProvenance[index]
+      }))
+    });
+  }
+  const committed = projectSteps(
+    await stepStore.loadCurrentEpoch(args.conversationId)
+  );
+  return {
+    committedSeq: committed.seqs.at(-1) ?? -1,
+    messageSeqs: committed.seqs,
+    provenance: nextProvenance
+  };
+}
+async function recordMcpProviderConnected(args) {
+  const stepStore = getAgentStepStore();
+  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
+  if (connectedMcpProvidersFromSteps(steps).includes(args.provider)) {
+    return;
+  }
+  await stepStore.append(args.conversationId, [
+    {
+      entry: { type: "mcp_provider_connected", provider: args.provider },
+      createdAtMs: Date.now()
+    }
+  ]);
+}
+async function recordAuthorizationRequested(args) {
+  const stepStore = getAgentStepStore();
+  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
+  if (steps.some(
+    (step) => step.entry.type === "authorization_requested" && step.entry.authorizationId === args.authorizationId
+  )) {
+    return;
+  }
+  await stepStore.append(args.conversationId, [
+    {
+      entry: {
+        type: "authorization_requested",
+        kind: args.kind,
+        provider: args.provider,
+        actorId: args.actorId,
+        authorizationId: args.authorizationId,
+        delivery: args.delivery
+      },
+      createdAtMs: Date.now()
+    }
+  ]);
+}
+async function recordAuthorizationCompleted(args) {
+  const stepStore = getAgentStepStore();
+  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
+  if (steps.some(
+    (step) => step.entry.type === "authorization_completed" && step.entry.authorizationId === args.authorizationId
+  )) {
+    return;
+  }
+  await stepStore.append(args.conversationId, [
+    {
+      entry: {
+        type: "authorization_completed",
+        kind: args.kind,
+        provider: args.provider,
+        actorId: args.actorId,
+        authorizationId: args.authorizationId
+      },
+      createdAtMs: Date.now()
+    }
+  ]);
+}
+async function recordToolExecutionStarted(args) {
+  await getAgentStepStore().append(args.conversationId, [
+    {
+      entry: {
+        type: "tool_execution_started",
+        toolCallId: args.toolCallId,
+        toolName: args.toolName,
+        ...args.args !== void 0 ? { args: args.args } : {}
+      },
+      createdAtMs: args.createdAtMs ?? Date.now()
+    }
+  ]);
+}
+
+export {
+  projectSteps,
+  loadProjection,
+  loadConversationProjection,
+  openConversationProjection,
+  loadTurnProjection,
+  loadConnectedMcpProviders,
+  commitMessages,
+  recordMcpProviderConnected,
+  recordAuthorizationRequested,
+  recordAuthorizationCompleted,
+  recordToolExecutionStarted
+};

package/dist/{chunk-BYZWPRJA.js → chunk-H66UCBPW.js}

@@ -1,14 +1,16 @@
 import {
-  SANDBOX_WORKSPACE_ROOT,
+  SANDBOX_WORKSPACE_ROOT
+} from "./chunk-G3E7SCME.js";
+import {
   sleep
-} from "./chunk-CZEX6KIQ.js";
+} from "./chunk-4ZNGQH7C.js";
 import {
   getStateAdapter,
   toOptionalTrimmed
-} from "./chunk-YDVEH3SB.js";
+} from "./chunk-EEZCY5WX.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-L7CDEIVJ.js";
+} from "./chunk-LMJPRYHP.js";
 import {
   withSpan
 } from "./chunk-I35CTGPO.js";

package/dist/{chunk-L7CDEIVJ.js → chunk-LMJPRYHP.js}

@@ -6,9 +6,11 @@ import {
 } from "./chunk-I35CTGPO.js";
 import {
   discoverInstalledPluginPackageContent,
-  normalizePluginPackageNames,
+  normalizePluginPackageNames
+} from "./chunk-B3IT5END.js";
+import {
   pluginRoots
-} from "./chunk-6APU57E6.js";
+} from "./chunk-3V7OFJZC.js";
 
 // src/chat/plugins/registry.ts
 import { readFileSync, readdirSync, statSync } from "fs";