@sentry/junior 0.27.1 → 0.28.0

package/dist/app.js

@@ -25,7 +25,7 @@ import {
   sandboxSkillDir,
   sandboxSkillFile,
   toOptionalTrimmed
-} from "./chunk-4PVJHUEV.js";
+} from "./chunk-375D5V4U.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -2174,7 +2174,8 @@ async function completeText(params) {
     "gen_ai.request.model": params.modelId,
     ...systemInstructionsAttribute ? { "gen_ai.system_instructions": systemInstructionsAttribute } : {},
     ...requestMessagesAttribute ? { "gen_ai.input.messages": requestMessagesAttribute } : {},
-    "app.ai.auth_mode": apiKey ? "oidc" : "api_key"
+    "app.ai.auth_mode": apiKey ? "oidc" : "api_key",
+    ...params.thinkingLevel ? { "app.ai.reasoning_effort": params.thinkingLevel } : {}
   };
   setSpanAttributes(startAttributes);
   const message = await completeSimple(
@@ -2187,6 +2188,7 @@ async function completeText(params) {
       ...apiKey ? { apiKey } : {},
       temperature: params.temperature,
       maxTokens: params.maxTokens,
+      reasoning: params.thinkingLevel,
       signal: params.signal,
       metadata: params.metadata
     }
@@ -2205,7 +2207,8 @@ async function completeText(params) {
     "gen_ai.request.model": params.modelId,
     ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
     ...usageAttributes,
-    ...message.stopReason ? { "gen_ai.response.finish_reasons": [message.stopReason] } : {}
+    ...message.stopReason ? { "gen_ai.response.finish_reasons": [message.stopReason] } : {},
+    ...params.thinkingLevel ? { "app.ai.reasoning_effort": params.thinkingLevel } : {}
   };
   setSpanAttributes(endAttributes);
   if (message.stopReason === "error") {
@@ -2235,6 +2238,7 @@ async function completeObject(params) {
     ({ text } = await completeText({
       modelId: params.modelId,
       system: params.system,
+      thinkingLevel: params.thinkingLevel,
       temperature: params.temperature,
       maxTokens: params.maxTokens,
       signal: params.signal,
@@ -3354,7 +3358,6 @@ function buildSystemPrompt(params) {
       [
         "- For factual or external questions, run tools/skills first, then answer from evidence.",
         "- Use tool descriptions as the source of truth for when each tool should or should not be called.",
-        "- Use `reportProgress` only for sparse, meaningful progress updates. Pass a short user-facing status message, and do not call it for every tool or small substep.",
         "- When using CLI tools through `bash`, prefer deterministic non-interactive flags and avoid commands that wait for prompts or editors.",
         "- Keep routine setup and research steps silent in user-facing replies. Do not narrate duplicate checks, credential issuance, file writes, or similar internal progress unless the result is user-relevant.",
         "- If a routine prerequisite check finds nothing notable, omit it entirely from the final reply and report only the user-relevant outcome.",
@@ -3409,6 +3412,10 @@ function buildSystemPrompt(params) {
         "- Use Slack-friendly markdown, not full CommonMark. Prefer bold section labels over markdown headings, and use bullets and short code blocks when helpful.",
         "- Keep normal responses brief and scannable.",
         "- If depth is needed, start with a concise summary and then provide fuller detail.",
+        "- Prefer a single compact thread reply when the full answer comfortably fits within this inline budget.",
+        "- When canvas creation is available and a research or document-style answer would likely need continuation, multiple sections, or future reference value, create a Slack canvas and keep the thread reply to a short summary plus the canvas link.",
+        "- Typical canvas-first cases include long-form research summaries, timelines, bios or profiles, structured notes, plans, comparisons, and other reusable reference documents.",
+        "- Do not create a canvas for short factual answers that fit cleanly in one normal thread reply.",
         "- For tool-heavy research, discovery, or source-checking requests, do not send an initial acknowledgment. Start the visible reply only once you can present the actual answer.",
         "- Do not narrate tool execution or repeated status updates in the visible reply.",
         "- Avoid tables and markdown links like `[label](url)` unless explicitly requested. Prefer plain URLs or Slack-native entities when exact rendering matters.",
@@ -5064,7 +5071,7 @@ function createReadFileTool() {
 import { Type as Type6 } from "@sinclair/typebox";
 function createReportProgressTool() {
   return tool({
-    description: "Update assistant status with a short user-facing progress message. Use this sparingly for meaningful progress changes, not for every tool call or minor substep.",
+    description: "Update the user-visible assistant loading message with a short progress phase. For every non-trivial turn, call this early with the initial major work phase, then call it again only when the major phase meaningfully changes. Use concrete labels like Searching docs, Reviewing results, or Running checks. Skip trivial direct answers, generic filler, and minor substeps.",
     inputSchema: Type6.Object({
       message: Type6.String({
         minLength: 1,
@@ -5342,7 +5349,7 @@ function createOperationKey(toolName, input) {
 // src/chat/tools/slack/channel-post-message.ts
 function createSlackChannelPostMessageTool(context, state) {
   return tool({
-    description: "Post a message in the active Slack channel context (outside the thread). Use this when the user explicitly asks to post/send/share/say something in the channel. Do not use for normal thread replies or speculative broadcasts. Do not claim a channel message was posted unless this tool succeeds in this turn.",
+    description: "Post a message in the active Slack channel context (outside the thread). Use this only when the user explicitly asks to post/send/share/say something in the current channel. Do not use it for normal thread replies, speculative broadcasts, or requests targeting another named channel; explain that limitation instead. Do not claim a channel message was posted unless this tool succeeds in this turn.",
     inputSchema: Type9.Object({
       text: Type9.String({
         minLength: 1,
@@ -5665,7 +5672,7 @@ function mergeRecentCanvases(existing, created) {
 }
 function createSlackCanvasCreateTool(context, state) {
   return tool({
-    description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when content is too long for a thread reply or needs a persistent document. Do not use for short answers that fit in-thread.",
+    description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when the answer is better as a reusable document than a thread reply: long-form research, timelines, bios/profiles, structured notes, plans, comparisons, or anything likely to exceed one compact Slack reply. After creating it, keep the thread reply brief and include the canvas link. Do not use for short answers that fit cleanly in one normal thread reply.",
     inputSchema: Type11.Object({
       title: Type11.String({
         minLength: 1,
@@ -8711,7 +8718,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
 }
 
 // src/chat/tools/agent-tools.ts
-function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor, capabilityRuntime, pluginAuthOrchestration, hooks) {
+function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor, capabilityRuntime, pluginAuthOrchestration, onToolCall) {
   const shouldTrace = shouldEmitDevAgentTrace();
   return Object.entries(tools).map(([toolName, toolDef]) => ({
     name: toolName,
@@ -8721,7 +8728,7 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
     execute: async (toolCallId, params) => {
       const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
       const toolArgumentsAttribute = serializeGenAiAttribute(params);
-      hooks?.onToolCall?.(toolName);
+      onToolCall?.(toolName);
       const traceToolContext = {
         ...spanContext,
         conversationId: spanContext.conversationId,
@@ -9135,6 +9142,7 @@ function buildTurnResult(input) {
     shouldTrace,
     spanContext,
     usage,
+    thinkingSelection,
     correlation,
     assistantUserName
   } = input;
@@ -9210,6 +9218,7 @@ function buildTurnResult(input) {
     outcome: resolvedOutcome,
     modelId: botConfig.modelId,
     assistantMessageCount: assistantMessages.length,
+    thinkingLevel: thinkingSelection.thinkingLevel,
     toolCalls,
     toolResultCount: toolResults.length,
     toolErrorCount,
@@ -9232,6 +9241,120 @@ function buildTurnResult(input) {
   };
 }
 
+// src/chat/services/turn-thinking-level.ts
+import { z } from "zod";
+var CLASSIFIER_CONFIDENCE_THRESHOLD = 0.75;
+var MAX_ROUTER_CONTEXT_CHARS = 1200;
+var TURN_THINKING_LEVELS = ["none", "low", "medium", "high"];
+var turnExecutionProfileSchema = z.object({
+  thinking_level: z.enum(TURN_THINKING_LEVELS),
+  confidence: z.number().min(0).max(1),
+  reason: z.string().min(1)
+});
+var DEFAULT_THINKING_LEVEL = "low";
+function trimContextForRouter(text) {
+  const trimmed = text?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return trimmed.length <= MAX_ROUTER_CONTEXT_CHARS ? trimmed : trimmed.slice(-MAX_ROUTER_CONTEXT_CHARS);
+}
+function buildClassifierSystemPrompt() {
+  return [
+    "You route assistant turns to the cheapest thinking level that is still likely to succeed.",
+    "Choose exactly one bucket: none, low, medium, or high.",
+    "",
+    "Use none for greetings, acknowledgments, and trivial single-step asks.",
+    "Use low for straightforward explanations or simple one-step work.",
+    "Use medium for investigations, ambiguous asks, multi-step analysis, or likely multi-tool work.",
+    "Use high for code changes, debugging/root-cause analysis, research-heavy work, non-trivial drafting, or explicit requests to be thorough.",
+    "",
+    "Return JSON only with thinking_level, confidence, and reason."
+  ].join("\n");
+}
+function buildClassifierPrompt(args) {
+  const sections = [];
+  const context = trimContextForRouter(args.conversationContext);
+  if (context) {
+    sections.push("<thread-background>", context, "</thread-background>", "");
+  }
+  sections.push(
+    "<turn-context>",
+    `- active_skills: ${args.activeSkillNames.join(", ") || "none"}`,
+    `- attachment_count: ${args.attachmentCount}`,
+    "</turn-context>",
+    "",
+    '<current-instruction priority="highest">',
+    args.messageText.trim() || "[empty]",
+    "</current-instruction>"
+  );
+  for (const block of args.currentTurnBlocks ?? []) {
+    const trimmed = block.trim();
+    if (!trimmed) {
+      continue;
+    }
+    sections.push("", trimmed);
+  }
+  return sections.join("\n");
+}
+async function selectTurnThinkingLevel(args) {
+  const activeSkillNames = [...new Set(args.activeSkillNames ?? [])].sort();
+  try {
+    const result = await args.completeObject({
+      modelId: args.fastModelId,
+      schema: turnExecutionProfileSchema,
+      maxTokens: 120,
+      metadata: {
+        modelId: args.fastModelId,
+        threadId: args.context?.threadId ?? "",
+        channelId: args.context?.channelId ?? "",
+        requesterId: args.context?.requesterId ?? "",
+        runId: args.context?.runId ?? ""
+      },
+      prompt: buildClassifierPrompt({
+        activeSkillNames,
+        attachmentCount: args.attachmentCount ?? 0,
+        conversationContext: args.conversationContext,
+        currentTurnBlocks: args.currentTurnBlocks,
+        messageText: args.messageText
+      }),
+      thinkingLevel: "low",
+      system: buildClassifierSystemPrompt(),
+      temperature: 0
+    });
+    const parsed = turnExecutionProfileSchema.parse(result.object);
+    if (parsed.confidence < CLASSIFIER_CONFIDENCE_THRESHOLD) {
+      return {
+        confidence: parsed.confidence,
+        thinkingLevel: DEFAULT_THINKING_LEVEL,
+        reason: `low_confidence_default:${parsed.reason.trim()}`
+      };
+    }
+    return {
+      confidence: parsed.confidence,
+      thinkingLevel: parsed.thinking_level,
+      reason: parsed.reason.trim()
+    };
+  } catch {
+    return {
+      thinkingLevel: DEFAULT_THINKING_LEVEL,
+      reason: "classifier_error_default"
+    };
+  }
+}
+function toAgentThinkingLevel(level) {
+  switch (level) {
+    case "none":
+      return "off";
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+  }
+}
+
 // src/chat/state/turn-session-store.ts
 var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
 var AGENT_TURN_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -9509,6 +9632,7 @@ function createMcpAuthOrchestration(deps, abortAgent) {
 
 // src/chat/respond.ts
 var startupDiscoveryLogged = false;
+var MAX_ROUTER_ATTACHMENT_PREVIEW_CHARS = 2e3;
 function buildOmittedImageAttachmentNotice(count) {
   return [
     "<omitted-image-attachments>",
@@ -9519,6 +9643,89 @@ function buildOmittedImageAttachmentNotice(count) {
     "</omitted-image-attachments>"
   ].join("\n");
 }
+function trimRouterAttachmentText(text) {
+  const normalized = text.replaceAll("\0", " ").trim();
+  if (!normalized) {
+    return "";
+  }
+  return normalized.length <= MAX_ROUTER_ATTACHMENT_PREVIEW_CHARS ? normalized : `${normalized.slice(0, MAX_ROUTER_ATTACHMENT_PREVIEW_CHARS)}...`;
+}
+function supportsRouterTextPreview(mediaType) {
+  const baseMediaType = mediaType.split(";", 1)[0]?.trim().toLowerCase();
+  if (!baseMediaType) {
+    return false;
+  }
+  return baseMediaType.startsWith("text/") || baseMediaType === "application/json" || baseMediaType === "application/xml" || baseMediaType === "application/x-www-form-urlencoded" || baseMediaType.endsWith("+json") || baseMediaType.endsWith("+xml");
+}
+function buildRouterAttachmentBlock(attachment) {
+  if (attachment.promptText) {
+    return trimRouterAttachmentText(attachment.promptText);
+  }
+  const header = [
+    "<attachment>",
+    `filename: ${attachment.filename ?? "unnamed"}`,
+    `media_type: ${attachment.mediaType}`
+  ];
+  if (attachment.data && supportsRouterTextPreview(attachment.mediaType)) {
+    const preview = trimRouterAttachmentText(attachment.data.toString("utf8"));
+    if (preview) {
+      return [
+        ...header,
+        "<text-preview>",
+        preview,
+        "</text-preview>",
+        "</attachment>"
+      ].join("\n");
+    }
+  }
+  return [...header, "</attachment>"].join("\n");
+}
+function buildUserTurnInput(args) {
+  const routerBlocks = [];
+  const userContentParts = [
+    { type: "text", text: args.userTurnText }
+  ];
+  if (args.omittedImageAttachmentCount > 0) {
+    const omittedImagesNotice = buildOmittedImageAttachmentNotice(
+      args.omittedImageAttachmentCount
+    );
+    userContentParts.push({ type: "text", text: omittedImagesNotice });
+    routerBlocks.push(omittedImagesNotice);
+  }
+  for (const attachment of args.userAttachments ?? []) {
+    routerBlocks.push(buildRouterAttachmentBlock(attachment));
+    if (attachment.promptText) {
+      userContentParts.push({
+        type: "text",
+        text: attachment.promptText
+      });
+      continue;
+    }
+    if (attachment.mediaType.startsWith("image/")) {
+      if (!attachment.data) {
+        throw new Error("Image attachment is missing image data");
+      }
+      userContentParts.push({
+        type: "image",
+        data: attachment.data.toString("base64"),
+        mimeType: attachment.mediaType
+      });
+      continue;
+    }
+    if (!attachment.data) {
+      throw new Error("Attachment is missing attachment data");
+    }
+    userContentParts.push({
+      type: "text",
+      text: encodeNonImageAttachmentForPrompt({
+        data: attachment.data,
+        mediaType: attachment.mediaType,
+        filename: attachment.filename
+      })
+    });
+  }
+  return { routerBlocks, userContentParts };
+}
 function mcpToolsToDefinitions(mcpTools) {
   const defs = {};
   for (const tool2 of mcpTools) {
@@ -9546,6 +9753,7 @@ async function generateAssistantReply(messageText, context = {}) {
   let sandboxExecutor;
   let timedOut = false;
   let turnUsage;
+  let thinkingSelection;
   const getSandboxMetadata = () => sandboxExecutor ? {
     sandboxId: sandboxExecutor.getSandboxId(),
     sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash()
@@ -9724,6 +9932,34 @@ async function generateAssistantReply(messageText, context = {}) {
         turnContext: { traceId: getActiveTraceId() }
       }
     );
+    const { routerBlocks, userContentParts } = buildUserTurnInput({
+      omittedImageAttachmentCount: context.omittedImageAttachmentCount ?? 0,
+      userAttachments: context.userAttachments,
+      userTurnText
+    });
+    thinkingSelection = await selectTurnThinkingLevel({
+      activeSkillNames: activeSkills.map((skill) => skill.name),
+      attachmentCount: context.userAttachments?.length,
+      completeObject,
+      conversationContext: context.conversationContext,
+      context: {
+        threadId: context.correlation?.threadId,
+        channelId: context.correlation?.channelId,
+        requesterId: context.correlation?.requesterId,
+        runId: context.correlation?.runId
+      },
+      currentTurnBlocks: routerBlocks,
+      fastModelId: botConfig.fastModelId,
+      messageText: userInput
+    });
+    setSpanAttributes({
+      "gen_ai.request.model": botConfig.modelId,
+      "app.ai.reasoning_effort": thinkingSelection.thinkingLevel,
+      "app.ai.thinking_level_reason": thinkingSelection.reason,
+      ...thinkingSelection.confidence !== void 0 ? {
+        "app.ai.thinking_level_confidence": thinkingSelection.confidence
+      } : {}
+    });
     timeoutResumeMessages = [];
     const generatedFiles = [];
     const replyFiles = [];
@@ -9885,44 +10121,6 @@ async function generateAssistantReply(messageText, context = {}) {
       runtimeMetadata: getRuntimeMetadata(),
       threadParticipants: context.threadParticipants
     });
-    const userContentParts = [{ type: "text", text: userTurnText }];
-    const omittedImageAttachmentCount = context.omittedImageAttachmentCount ?? 0;
-    if (omittedImageAttachmentCount > 0) {
-      userContentParts.push({
-        type: "text",
-        text: buildOmittedImageAttachmentNotice(omittedImageAttachmentCount)
-      });
-    }
-    for (const attachment of context.userAttachments ?? []) {
-      if (attachment.promptText) {
-        userContentParts.push({
-          type: "text",
-          text: attachment.promptText
-        });
-      } else if (attachment.mediaType.startsWith("image/")) {
-        if (!attachment.data) {
-          throw new Error("Image attachment is missing image data");
-        }
-        userContentParts.push({
-          type: "image",
-          data: attachment.data.toString("base64"),
-          mimeType: attachment.mediaType
-        });
-      } else {
-        if (!attachment.data) {
-          throw new Error("Attachment is missing attachment data");
-        }
-        const promptAttachment = {
-          data: attachment.data,
-          mediaType: attachment.mediaType,
-          filename: attachment.filename
-        };
-        userContentParts.push({
-          type: "text",
-          text: encodeNonImageAttachmentForPrompt(promptAttachment)
-        });
-      }
-    }
     const inputMessagesAttribute = serializeGenAiAttribute([
       {
         role: "system",
@@ -9933,21 +10131,8 @@ async function generateAssistantReply(messageText, context = {}) {
         content: userContentParts.map((part) => toObservablePromptPart(part))
       }
     ]);
-    const agentToolHooks = {
-      onToolCall: (toolName) => {
-        toolCalls.push(toolName);
-        Promise.resolve(context.onToolCall?.(toolName)).catch((error) => {
-          logWarn(
-            "streaming_tool_call_error",
-            {},
-            {
-              "error.message": error instanceof Error ? error.message : String(error),
-              "gen_ai.tool.name": toolName
-            },
-            "Failed to deliver tool call event to stream coordinator"
-          );
-        });
-      }
+    const onToolCall = (toolName) => {
+      toolCalls.push(toolName);
     };
     const baseAgentTools = createAgentTools(
       tools,
@@ -9957,7 +10142,7 @@ async function generateAssistantReply(messageText, context = {}) {
       sandboxExecutor,
       capabilityRuntime,
       pluginAuth,
-      agentToolHooks
+      onToolCall
     );
     const agentTools = [...baseAgentTools];
     const syncMcpAgentTools = () => {
@@ -9971,7 +10156,7 @@ async function generateAssistantReply(messageText, context = {}) {
         sandboxExecutor,
         capabilityRuntime,
         pluginAuth,
-        agentToolHooks
+        onToolCall
       );
       agentTools.length = 0;
       agentTools.push(...baseAgentTools, ...mcpAgentTools);
@@ -9982,6 +10167,7 @@ async function generateAssistantReply(messageText, context = {}) {
       initialState: {
         systemPrompt: baseInstructions,
         model: resolveGatewayModel(botConfig.modelId),
+        thinkingLevel: toAgentThinkingLevel(thinkingSelection.thinkingLevel),
         tools: agentTools
       }
     });
@@ -10069,6 +10255,9 @@ async function generateAssistantReply(messageText, context = {}) {
                   "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
                   "gen_ai.operation.name": "invoke_agent",
                   "gen_ai.request.model": botConfig.modelId,
+                  ...thinkingSelection ? {
+                    "app.ai.reasoning_effort": thinkingSelection.thinkingLevel
+                  } : {},
                   "app.ai.turn_timeout_ms": botConfig.turnTimeoutMs
                 },
                 "Agent turn timed out and was aborted"
@@ -10113,6 +10302,7 @@ async function generateAssistantReply(messageText, context = {}) {
           "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
           "gen_ai.operation.name": "invoke_agent",
           "gen_ai.request.model": botConfig.modelId,
+          "app.ai.reasoning_effort": thinkingSelection.thinkingLevel,
           ...inputMessagesAttribute ? { "gen_ai.input.messages": inputMessagesAttribute } : {}
         }
       );
@@ -10144,6 +10334,7 @@ async function generateAssistantReply(messageText, context = {}) {
       shouldTrace,
       spanContext,
       usage: turnUsage,
+      thinkingSelection,
       correlation: context.correlation,
       assistantUserName: context.assistant?.userName
     });
@@ -10230,6 +10421,9 @@ async function generateAssistantReply(messageText, context = {}) {
         outcome: "provider_error",
         modelId: botConfig.modelId,
         assistantMessageCount: 0,
+        ...thinkingSelection ? {
+          thinkingLevel: thinkingSelection.thinkingLevel
+        } : {},
         toolCalls: [],
         toolResultCount: 0,
         toolErrorCount: 0,
@@ -12292,14 +12486,14 @@ async function POST(request, waitUntil) {
 }
 
 // src/chat/services/subscribed-decision.ts
-import { z } from "zod";
-var replyDecisionSchema = z.object({
-  should_reply: z.boolean().describe("Whether Junior should respond to this thread message."),
-  should_unsubscribe: z.boolean().optional().describe(
+import { z as z2 } from "zod";
+var replyDecisionSchema = z2.object({
+  should_reply: z2.boolean().describe("Whether Junior should respond to this thread message."),
+  should_unsubscribe: z2.boolean().optional().describe(
     "Whether Junior should unsubscribe from this thread because the user clearly asked it to stop participating."
   ),
-  confidence: z.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-  reason: z.string().optional().describe("Short reason for the decision.")
+  confidence: z2.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
+  reason: z2.string().optional().describe("Short reason for the decision.")
 });
 var ROUTER_CONFIDENCE_THRESHOLD = 0.8;
 var LEADING_SLACK_MENTION_RE = /^\s*<@([A-Z0-9]+)(?:\|([^>]+))?>[\s,:-]*/i;
@@ -13989,7 +14183,7 @@ function createReplyToThread(deps) {
             slackChannelId: channelId,
             runId,
             assistantUserName: botConfig.userName,
-            modelId: botConfig.modelId
+            modelId: reply.diagnostics.modelId
           };
           const diagnosticsAttributes = {
             "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
@@ -14000,6 +14194,9 @@ function createReplyToThread(deps) {
             "app.ai.tool_error_results": reply.diagnostics.toolErrorCount,
             "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
             "app.ai.used_primary_text": reply.diagnostics.usedPrimaryText,
+            ...reply.diagnostics.thinkingLevel ? {
+              "app.ai.reasoning_effort": reply.diagnostics.thinkingLevel
+            } : {},
             ...reply.diagnostics.stopReason ? {
               "gen_ai.response.finish_reasons": [
                 reply.diagnostics.stopReason

package/dist/{chunk-4PVJHUEV.js → chunk-375D5V4U.js}

@@ -84,8 +84,8 @@ function readBotConfig(env) {
   const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(functionMaxDurationSeconds);
   return {
     userName: env.JUNIOR_BOT_NAME ?? "junior",
-    modelId: env.AI_MODEL ?? "anthropic/claude-sonnet-4.6",
-    fastModelId: env.AI_FAST_MODEL ?? env.AI_MODEL ?? "anthropic/claude-haiku-4.5",
+    modelId: env.AI_MODEL ?? "openai/gpt-5.4",
+    fastModelId: env.AI_FAST_MODEL ?? env.AI_MODEL ?? "openai/gpt-5.4-mini",
     loadingMessages: parseLoadingMessages(env.JUNIOR_LOADING_MESSAGES),
     visionModelId: toOptionalTrimmed(env.AI_VISION_MODEL),
     turnTimeoutMs: parseAgentTurnTimeoutMs(

package/dist/cli/snapshot-warmup.js

@@ -1,7 +1,7 @@
 import {
   disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-4PVJHUEV.js";
+} from "../chunk-375D5V4U.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.27.1",
+  "version": "0.28.0",
   "private": false,
   "publishConfig": {
     "access": "public"