@sentry/junior 0.98.0 → 0.100.0

package/dist/{chunk-UAMKJPDF.js → chunk-2RNOB32R.js}

@@ -1,11 +1,17 @@
 // src/api/schema.ts
 import { z } from "zod";
 var conversationParamsSchema = z.object({ conversationId: z.string().min(1) }).strict();
+var conversationFeedQuerySchema = z.object({
+  actorEmail: z.string().trim().email().transform((value) => value.toLowerCase()).optional()
+}).strict();
 var subagentParamsSchema = conversationParamsSchema.extend({ subagentId: z.string().min(1) }).strict();
 var personParamsSchema = z.object({ email: z.string().trim().min(1) }).strict();
+var locationParamsSchema = z.object({ locationId: z.string().min(1) }).strict();
 
 export {
   conversationParamsSchema,
+  conversationFeedQuerySchema,
   subagentParamsSchema,
-  personParamsSchema
+  personParamsSchema,
+  locationParamsSchema
 };

package/dist/{chunk-NJEDJFK4.js → chunk-2T7DCRAW.js}

@@ -5,7 +5,7 @@ import {
   getChatConfig,
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-EEZCY5WX.js";
+} from "./chunk-A7X2FDUO.js";
 import {
   parseDestination,
   sameDestination

package/dist/{chunk-DPHWDS6I.js → chunk-45DMFMY2.js}

@@ -10,14 +10,14 @@ import {
   persistRunningSessionRecord,
   persistTimeoutSessionRecord,
   persistYieldSessionRecord
-} from "./chunk-WJ7STXT6.js";
+} from "./chunk-NSOCZGOH.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-6DTVCPLO.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
-} from "./chunk-OL6XQ23W.js";
+} from "./chunk-IVXL57YF.js";
 import {
   loadConnectedMcpProviders,
   loadConversationProjection,
@@ -25,12 +25,12 @@ import {
   recordAuthorizationRequested,
   recordMcpProviderConnected,
   recordToolExecutionStarted
-} from "./chunk-DHHU2WSG.js";
+} from "./chunk-IQIBZXGB.js";
 import {
   estimateTextTokens,
   getAgentContextCompactionTriggerTokens,
   updateConversationStats
-} from "./chunk-IO65E4ZD.js";
+} from "./chunk-JPQISMMJ.js";
 import {
   buildNonInteractiveShellScript,
   createSandboxInstance,
@@ -40,7 +40,7 @@ import {
   isSnapshotMissingError,
   resolveRuntimeDependencySnapshot,
   runNonInteractiveCommand
-} from "./chunk-H66UCBPW.js";
+} from "./chunk-XJA7BPHS.js";
 import {
   privateTraceResultAttributes
 } from "./chunk-CM5EZD5F.js";
@@ -52,7 +52,7 @@ import {
   getPlugins,
   getSlackToolContext,
   resolveChannelCapabilities
-} from "./chunk-FTTFV6DC.js";
+} from "./chunk-TPTJEHUE.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -62,10 +62,10 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-WTYEKPXU.js";
+} from "./chunk-FP5N5OWZ.js";
 import {
   createPluginLogger
-} from "./chunk-EOWXRY5E.js";
+} from "./chunk-PWC24W5F.js";
 import {
   contextProvenance,
   getAgentStepStore,
@@ -74,7 +74,7 @@ import {
   getDb,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-OGHXZ4KQ.js";
+} from "./chunk-VHRM6GNH.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -94,6 +94,7 @@ import {
   ModelProfileNotConfiguredError,
   STANDARD_MODEL_PROFILE,
   TURN_CONTEXT_TAG,
+  TURN_REASONING_LEVELS,
   acquireActiveLock,
   botConfig,
   completeObject,
@@ -119,7 +120,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   unwrapCurrentInstruction
-} from "./chunk-EEZCY5WX.js";
+} from "./chunk-A7X2FDUO.js";
 import {
   parseSlackThreadId,
   resolveConversationPrivacy,
@@ -687,7 +688,7 @@ function buildTurnResult(input) {
     shouldTrace,
     spanContext,
     usage,
-    thinkingSelection,
+    reasoningSelection,
     correlation,
     assistantUserName,
     modelId
@@ -817,7 +818,7 @@ function buildTurnResult(input) {
     outcome: resolvedOutcome,
     modelId,
     assistantMessageCount: assistantMessages.length,
-    thinkingLevel: thinkingSelection.thinkingLevel,
+    reasoningLevel: reasoningSelection.reasoningLevel,
     toolCalls,
     toolResultCount: toolResults.length,
     toolErrorCount,
@@ -840,20 +841,13 @@ function buildTurnResult(input) {
   };
 }
 
-// src/chat/services/turn-thinking-level.ts
+// src/chat/services/turn-reasoning-level.ts
 import { z } from "zod";
 var CLASSIFIER_CONFIDENCE_THRESHOLD = 0.75;
 var MAX_ROUTER_CONTEXT_CHARS = 8e3;
 var ROUTER_CONTEXT_HEAD_CHARS = 3e3;
 var ROUTER_CONTEXT_TAIL_CHARS = 5e3;
 var TRUNCATION_MARKER = "\n\u2026[truncated]\u2026\n";
-var TURN_THINKING_LEVELS = [
-  "none",
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
 var CONFIDENCE_LABELS = {
   low: 0.5,
   medium: CLASSIFIER_CONFIDENCE_THRESHOLD,
@@ -874,15 +868,15 @@ function coerceClassifierConfidence(value) {
   return CONFIDENCE_LABELS[trimmed] ?? value;
 }
 var turnExecutionProfileSchema = z.object({
-  thinking_level: z.enum(TURN_THINKING_LEVELS),
+  reasoning_level: z.enum(TURN_REASONING_LEVELS),
   confidence: z.preprocess(
     coerceClassifierConfidence,
     z.number().min(0).max(1)
   ),
   reason: z.string().min(1)
 });
-var DEFAULT_THINKING_LEVEL = "medium";
-var THINKING_LEVEL_RANK = {
+var CLASSIFIER_FALLBACK_REASONING_LEVEL = "medium";
+var REASONING_LEVEL_RANK = {
   none: 0,
   low: 1,
   medium: 2,
@@ -911,7 +905,7 @@ function trimContextForRouter(text) {
 }
 function buildClassifierSystemPrompt() {
   return [
-    "You route assistant turns to the thinking level most likely to produce a complete, source-grounded answer.",
+    "You route assistant turns to the reasoning level most likely to produce a complete, source-grounded answer.",
     "Choose exactly one bucket: none, low, medium, high, or xhigh.",
     "",
     "Use none only for greetings, acknowledgments, and turns that need no substantive assistant work.",
@@ -923,7 +917,7 @@ function buildClassifierSystemPrompt() {
     "",
     "Classify based on the substance of the task, not the length of the current message. When the current instruction is a short affirmation (for example: 'go', 'do it', 'yes please', 'proceed') and prior thread context contains a pending task, classify the pending task \u2014 not the affirmation.",
     "",
-    "Return JSON only with thinking_level, confidence, and reason.",
+    "Return JSON only with reasoning_level, confidence, and reason.",
     "confidence must be a number from 0 to 1, not a word label."
   ].join("\n");
 }
@@ -952,7 +946,13 @@ function buildClassifierPrompt(args) {
   }
   return sections.join("\n");
 }
-async function selectTurnThinkingLevel(args) {
+function configuredTurnReasoningLevel(reasoningLevel, source) {
+  return {
+    reasoningLevel,
+    reason: `configured:${source}`
+  };
+}
+async function selectTurnReasoningLevel(args) {
   const trimmedContext = trimContextForRouter(args.conversationContext);
   const instructionLength = args.messageText.trim().length;
   const turnBlockCount = (args.currentTurnBlocks ?? []).filter(
@@ -971,8 +971,8 @@ async function selectTurnThinkingLevel(args) {
     modelId: args.fastModelId
   };
   return withSpan(
-    "chat.route_thinking",
-    "chat.route_thinking",
+    "chat.route_reasoning",
+    "chat.route_reasoning",
     logContext,
     async () => {
       setSpanAttributes({
@@ -994,29 +994,29 @@ async function selectTurnThinkingLevel(args) {
         },
         prompt
       });
-      const normalizedSelection = applyThinkingFloor(selection, {
+      const normalizedSelection = applyReasoningFloor(selection, {
         minimum: trimmedContext || turnBlockCount > 0 ? "medium" : void 0
       });
       setSpanAttributes({
-        "app.ai.thinking_level": normalizedSelection.thinkingLevel,
-        "app.ai.thinking_level_reason": normalizedSelection.reason,
+        "app.ai.reasoning_level": normalizedSelection.reasoningLevel,
+        "app.ai.reasoning_level_reason": normalizedSelection.reason,
         ...normalizedSelection.confidence !== void 0 ? {
-          "app.ai.thinking_level_confidence": normalizedSelection.confidence
+          "app.ai.reasoning_level_confidence": normalizedSelection.confidence
         } : {}
       });
       return normalizedSelection;
     }
   );
 }
-function applyThinkingFloor(selection, args) {
+function applyReasoningFloor(selection, args) {
   const minimum = args.minimum;
-  if (!minimum || selection.thinkingLevel === "none" || THINKING_LEVEL_RANK[selection.thinkingLevel] >= THINKING_LEVEL_RANK[minimum]) {
+  if (!minimum || selection.reasoningLevel === "none" || REASONING_LEVEL_RANK[selection.reasoningLevel] >= REASONING_LEVEL_RANK[minimum]) {
     return selection;
   }
   return {
     ...selection,
-    thinkingLevel: minimum,
-    reason: `thinking_floor:${minimum}:${selection.reason}`
+    reasoningLevel: minimum,
+    reason: `reasoning_floor:${minimum}:${selection.reason}`
   };
 }
 async function classifyTurn(args) {
@@ -1036,23 +1036,23 @@ async function classifyTurn(args) {
     if (parsed.confidence < CLASSIFIER_CONFIDENCE_THRESHOLD) {
       return {
         confidence: parsed.confidence,
-        thinkingLevel: DEFAULT_THINKING_LEVEL,
+        reasoningLevel: CLASSIFIER_FALLBACK_REASONING_LEVEL,
         reason: `low_confidence_medium_default:${reason}`
       };
     }
     return {
       confidence: parsed.confidence,
-      thinkingLevel: parsed.thinking_level,
+      reasoningLevel: parsed.reasoning_level,
       reason
     };
   } catch {
     return {
-      thinkingLevel: DEFAULT_THINKING_LEVEL,
+      reasoningLevel: CLASSIFIER_FALLBACK_REASONING_LEVEL,
       reason: "classifier_error_default"
     };
   }
 }
-function toAgentThinkingLevel(level) {
+function toPiReasoningLevel(level) {
   switch (level) {
     case "none":
       return "off";
@@ -6680,7 +6680,9 @@ function stableSerialize(value) {
     return `[${value.map((entry) => stableSerialize(entry)).join(",")}]`;
   }
   if (value && typeof value === "object") {
-    const entries = Object.entries(value).sort((a, b) => a[0].localeCompare(b[0]));
+    const entries = Object.entries(value).sort(
+      (a, b) => a[0].localeCompare(b[0])
+    );
     return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableSerialize(entry)}`).join(",")}}`;
   }
   const serialized = JSON.stringify(value);
@@ -15124,9 +15126,19 @@ function createContextCompactor(deps) {
   };
 }
 async function compactContextForHandoff(args, deps) {
-  const summary = await summarizeContext(args, deps);
-  const message = userMessage(`${MODEL_HANDOFF_SUMMARY_PREFIX}
-${summary}`);
+  const runtimeMessage = args.runtimeContext.at(-1);
+  if (!runtimeMessage) {
+    throw new Error("Handoff requires the current runtime turn context");
+  }
+  const summary = `${MODEL_HANDOFF_SUMMARY_PREFIX}
+${await summarizeContext(args, deps)}`;
+  const message = {
+    ...runtimeMessage,
+    content: [
+      ...runtimeMessage.content,
+      { type: "text", text: renderCurrentInstruction(summary) }
+    ]
+  };
   const messages = [message];
   args.signal?.throwIfAborted();
   await getAgentStepStore().startEpoch(args.conversationId, {
@@ -15213,7 +15225,11 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
   let canRecordMcpProviders = false;
   let turnUsage;
   let handoffPhaseUsage;
-  let thinkingSelection;
+  const configuredReasoningLevel = policy.reasoningLevel ?? botConfig.reasoningLevel;
+  let reasoningSelection = configuredReasoningLevel ? configuredTurnReasoningLevel(
+    configuredReasoningLevel,
+    policy.reasoningLevel ? "agent_config" : "default"
+  ) : void 0;
   let activeModelProfile = STANDARD_MODEL_PROFILE;
   let activeModelId = modelIdForProfile(botConfig, activeModelProfile);
   const actor = actorFromRouting(routing);
@@ -15327,7 +15343,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       destination: routing.destination,
       durability,
       getLoadedSkillNames: () => loadedSkillNamesForResume,
-      getReasoningLevel: () => thinkingSelection?.thinkingLevel,
+      getReasoningLevel: () => reasoningSelection?.reasoningLevel,
       logContext: sessionRecordLogContext,
       getModelId: () => activeModelId,
       recordActiveMcpProviders,
@@ -15384,7 +15400,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     });
     const { routerBlocks, userContentParts } = buildPromptInput(input);
     const preAgentPromptMessages = () => existingSessionRecord?.piMessages ?? [...input.piMessages ?? []];
-    thinkingSelection = await selectTurnThinkingLevel({
+    reasoningSelection ??= await selectTurnReasoningLevel({
       completeObject,
       conversationContext: input.conversationContext,
       context: {
@@ -15399,10 +15415,10 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     });
     setSpanAttributes({
       "gen_ai.request.model": activeModelId,
-      "gen_ai.request.reasoning.level": thinkingSelection.thinkingLevel,
-      "app.ai.thinking_level_reason": thinkingSelection.reason,
-      ...thinkingSelection.confidence !== void 0 ? {
-        "app.ai.thinking_level_confidence": thinkingSelection.confidence
+      "gen_ai.request.reasoning.level": reasoningSelection.reasoningLevel,
+      "app.ai.reasoning_level_reason": reasoningSelection.reason,
+      ...reasoningSelection.confidence !== void 0 ? {
+        "app.ai.reasoning_level_confidence": reasoningSelection.confidence
       } : {}
     });
     const generatedFiles = [];
@@ -15429,8 +15445,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
           modelProfile: profile
         };
         const handoffModel = resolveGatewayModel(target.modelId);
-        const handoffThinkingLevel = toAgentThinkingLevel(
-          thinkingSelection.thinkingLevel
+        const handoffThinkingLevel = toPiReasoningLevel(
+          reasoningSelection.reasoningLevel
         );
         void (async () => {
           await observers.onStatus?.({ text: "Switching models" });
@@ -15449,6 +15465,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
             conversationContext: input.conversationContext,
             conversationId: sessionConversationId,
             piMessages: sourceMessages,
+            runtimeContext,
             signal: signal2,
             target,
             metadata: {
@@ -15462,7 +15479,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         );
         handoffPhaseUsage = phaseUsage;
         pendingHandoff = {
-          messages: [...handoffMessages, ...runtimeContext],
+          messages: handoffMessages,
           model: handoffModel,
           thinkingLevel: handoffThinkingLevel
         };
@@ -15662,7 +15679,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
           runResume.adoptCommittedBoundary(replacement);
           setSpanAttributes({
             "gen_ai.request.model": activeModelId,
-            "gen_ai.request.reasoning.level": thinkingSelection.thinkingLevel,
+            "gen_ai.request.reasoning.level": reasoningSelection.reasoningLevel,
             "app.ai.model_profile": activeModelProfile
           });
           update = {
@@ -15682,7 +15699,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       initialState: {
         systemPrompt: baseInstructions,
         model: resolveGatewayModel(activeModelId),
-        thinkingLevel: toAgentThinkingLevel(thinkingSelection.thinkingLevel),
+        thinkingLevel: toPiReasoningLevel(reasoningSelection.reasoningLevel),
         tools: wiring.agentTools
       }
     });
@@ -15751,7 +15768,6 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         "gen_ai.invoke_agent",
         spanContext,
         async () => {
-          let promptResult;
           const freshPromptMessage = {
             role: "user",
             content: promptContentParts,
@@ -15813,8 +15829,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
                     "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
                     "gen_ai.operation.name": "invoke_agent",
                     "gen_ai.request.model": activeModelId,
-                    ...thinkingSelection ? {
-                      "gen_ai.request.reasoning.level": thinkingSelection.thinkingLevel
+                    ...reasoningSelection ? {
+                      "gen_ai.request.reasoning.level": reasoningSelection.reasoningLevel
                     } : {},
                     "app.ai.turn_timeout_ms": turnTimeoutBudgetMs,
                     "app.ai.turn_deadline_remaining_ms": Math.max(
@@ -15859,7 +15875,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
           let run = shouldPromptAgent ? agent.prompt(freshPromptMessage) : agent.continue();
           let retryUsage;
           for (let attempt = 0; ; attempt += 1) {
-            promptResult = await runAgentStep(run);
+            await runAgentStep(run);
             signal?.throwIfAborted();
             if (runResume.cooperativeYieldError) {
               throw runResume.cooperativeYieldError;
@@ -15871,11 +15887,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
             const outputMessagesAttribute = serializeGenAiAttribute(
               conversationPrivacy !== "public" ? outputMessages.map(toGenAiMessageMetadata) : outputMessages.map(toCanonicalOutputMessage)
             );
-            const usageSummary = extractGenAiUsageSummary(
-              promptResult,
-              agent.state,
-              ...outputMessages
-            );
+            const usageSummary = extractGenAiUsageSummary(...outputMessages);
             const currentUsage = hasAgentTurnUsage(usageSummary) ? usageSummary : void 0;
             const currentPhaseUsage = addAgentTurnUsage(
               retryUsage,
@@ -15930,7 +15942,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
           ...sessionConversationId ? { "app.ai.session.conversation_id": sessionConversationId } : {},
           ...sessionId ? { "app.ai.turn.session_id": sessionId } : {},
           ...currentSliceId ? { "app.ai.turn.slice_id": currentSliceId } : {},
-          "gen_ai.request.reasoning.level": thinkingSelection.thinkingLevel,
+          "gen_ai.request.reasoning.level": reasoningSelection.reasoningLevel,
           ...toGenAiMessagesTraceAttributes("app.ai.input", inputMessages),
           ...inputMessagesAttribute ? { "gen_ai.input.messages": inputMessagesAttribute } : {}
         }
@@ -15956,7 +15968,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         shouldTrace,
         spanContext,
         usage: turnUsage,
-        thinkingSelection,
+        reasoningSelection,
         correlation: routing.correlation,
         assistantUserName: botConfig.userName,
         modelId: activeModelId
@@ -16012,8 +16024,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
           outcome: "provider_error",
           modelId: activeModelId,
           assistantMessageCount: 0,
-          ...thinkingSelection ? {
-            thinkingLevel: thinkingSelection.thinkingLevel
+          ...reasoningSelection ? {
+            reasoningLevel: reasoningSelection.reasoningLevel
           } : {},
           toolCalls: [],
           toolResultCount: 0,

package/dist/chunk-4AQUWWEM.js

@@ -0,0 +1,75 @@
+import {
+  actorIdentitySchema,
+  conversationStatsItemSchema,
+  conversationSummaryReportSchema
+} from "./chunk-MM5UFDAC.js";
+import {
+  juniorDestinationKindSchema
+} from "./chunk-FXFQNHRU.js";
+
+// src/api/activity.ts
+import { z } from "zod";
+var dailyConversationActivitySchema = z.object({
+  active: z.number(),
+  conversations: z.number(),
+  date: z.string(),
+  durationMs: z.number(),
+  failed: z.number(),
+  tokens: z.number().optional()
+}).strict();
+function emptyActivityDay(date) {
+  return {
+    active: 0,
+    conversations: 0,
+    date,
+    durationMs: 0,
+    failed: 0
+  };
+}
+function activityDays(days, nowMs, count) {
+  const items = [];
+  const end = new Date(nowMs);
+  end.setUTCHours(0, 0, 0, 0);
+  const start = new Date(end);
+  start.setUTCDate(start.getUTCDate() - (count - 1));
+  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+    const date = cursor.toISOString().slice(0, 10);
+    items.push(days.get(date) ?? emptyActivityDay(date));
+  }
+  return items;
+}
+
+// src/api/locations/schema.ts
+import { z as z2 } from "zod";
+var locationSummaryReportSchema = conversationStatsItemSchema.extend({
+  id: z2.string(),
+  firstSeenAt: z2.string(),
+  kind: juniorDestinationKindSchema,
+  lastSeenAt: z2.string(),
+  provider: z2.string(),
+  providerDestinationId: z2.string(),
+  visibility: z2.literal("public")
+}).strict();
+var locationActorSummaryReportSchema = conversationStatsItemSchema.extend({ actor: actorIdentitySchema }).strict();
+var locationDirectoryReportSchema = z2.object({
+  generatedAt: z2.string(),
+  locations: z2.array(locationSummaryReportSchema),
+  privateActivity: conversationStatsItemSchema,
+  source: z2.literal("conversation_index")
+}).strict();
+var locationDetailReportSchema = locationSummaryReportSchema.extend({
+  activityDays: z2.array(dailyConversationActivitySchema),
+  actors: z2.array(locationActorSummaryReportSchema),
+  generatedAt: z2.string(),
+  recentConversations: z2.array(conversationSummaryReportSchema),
+  source: z2.literal("conversation_index"),
+  windowEnd: z2.string(),
+  windowStart: z2.string()
+}).strict();
+
+export {
+  dailyConversationActivitySchema,
+  activityDays,
+  locationDirectoryReportSchema,
+  locationDetailReportSchema
+};

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

@@ -541,11 +541,24 @@ function normalizeSlackEmojiName(value) {
   return SLACK_EMOJI_NAME_RE.test(normalized) ? normalized : null;
 }
 
-// src/chat/model-profile.ts
+// src/chat/reasoning-level.ts
 import { z } from "zod";
+var TURN_REASONING_LEVELS = [
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+function parseTurnReasoningLevel(value) {
+  return z.enum(TURN_REASONING_LEVELS).parse(value);
+}
+
+// src/chat/model-profile.ts
+import { z as z2 } from "zod";
 var STANDARD_MODEL_PROFILE = "standard";
 var DEFAULT_HANDOFF_MODEL_PROFILE = "handoff";
-var modelProfileSchema = z.string().regex(/^[a-z][a-z0-9_-]*$/);
+var modelProfileSchema = z2.string().regex(/^[a-z][a-z0-9_-]*$/);
 var ModelProfileNotConfiguredError = class extends Error {
   constructor(profile) {
     super(`Model profile "${profile}" is not configured`);
@@ -721,6 +734,7 @@ function readBotConfig(env) {
   const functionMaxDurationSeconds = resolveFunctionMaxDurationSeconds(env);
   const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(functionMaxDurationSeconds);
   const modelId = validateGatewayModelId(env.AI_MODEL) ?? DEFAULT_MODEL_ID;
+  const reasoningLevel = toOptionalTrimmed(env.AI_REASONING_LEVEL);
   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 {
@@ -731,6 +745,7 @@ function readBotConfig(env) {
       "AI_MODEL_CONTEXT_WINDOW_TOKENS",
       env.AI_MODEL_CONTEXT_WINDOW_TOKENS
     ),
+    reasoningLevel: reasoningLevel === void 0 ? void 0 : parseTurnReasoningLevel(reasoningLevel),
     fastModelId,
     embeddingModelId: validateEmbeddingModelId(env.AI_EMBEDDING_MODEL) ?? DEFAULT_EMBEDDING_MODEL_ID,
     loadingMessages: parseLoadingMessages(env.JUNIOR_LOADING_MESSAGES),
@@ -1110,6 +1125,7 @@ export {
   completeObject,
   embedTexts,
   normalizeSlackEmojiName,
+  TURN_REASONING_LEVELS,
   STANDARD_MODEL_PROFILE,
   DEFAULT_HANDOFF_MODEL_PROFILE,
   modelProfileSchema,

package/dist/{chunk-WTYEKPXU.js → chunk-FP5N5OWZ.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-4ZNGQH7C.js";
 import {
   getSlackBotToken
-} from "./chunk-EEZCY5WX.js";
+} from "./chunk-A7X2FDUO.js";
 import {
   logWarn,
   setSpanAttributes,

package/dist/chunk-FXFQNHRU.js

@@ -0,0 +1,48 @@
+// src/db/schema/timestamps.ts
+import { timestamp } from "drizzle-orm/pg-core";
+var timestamptz = (name) => timestamp(name, { withTimezone: true });
+
+// src/db/schema/destinations.ts
+import { index, jsonb, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
+import { z } from "zod";
+var juniorDestinationKindSchema = z.enum([
+  "channel",
+  "dm",
+  "group",
+  "local_conversation",
+  "thread",
+  "web_session"
+]);
+var juniorDestinations = pgTable(
+  "junior_destinations",
+  {
+    id: text("id").primaryKey(),
+    provider: text("provider").notNull(),
+    providerTenantId: text("provider_tenant_id").notNull().default(""),
+    providerDestinationId: text("provider_destination_id").notNull(),
+    kind: text("kind").$type().notNull(),
+    parentDestinationId: text("parent_destination_id"),
+    displayName: text("display_name"),
+    visibility: text("visibility").$type().notNull().default("unknown"),
+    metadata: jsonb("metadata_json"),
+    createdAt: timestamptz("created_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull()
+  },
+  (table) => [
+    uniqueIndex("junior_destinations_provider_destination_uidx").on(
+      table.provider,
+      table.providerTenantId,
+      table.providerDestinationId
+    ),
+    index("junior_destinations_provider_kind_idx").on(
+      table.provider,
+      table.kind
+    )
+  ]
+);
+
+export {
+  timestamptz,
+  juniorDestinationKindSchema,
+  juniorDestinations
+};