@sentry/junior 0.113.0 → 0.114.0

package/dist/chat/conversations/history.d.ts

@@ -62,6 +62,16 @@ export declare const historyReplacementSchema: z.ZodObject<{
         type: z.ZodLiteral<"compaction">;
         modelProfile: z.ZodString;
         modelId: z.ZodString;
+        details: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodLiteral<"capacity">;
+            estimatedInputTokens: z.ZodNumber;
+            replacementInputTokens: z.ZodOptional<z.ZodNumber>;
+            triggerTokens: z.ZodNumber;
+            inputLimitTokens: z.ZodNumber;
+            inputMessageCount: z.ZodNumber;
+            retainedMessageCount: z.ZodNumber;
+            summaryChars: z.ZodNumber;
+        }, z.core.$strict>>;
         replacementHistory: z.ZodArray<z.ZodObject<{
             message: z.ZodPipe<z.ZodObject<{
                 role: z.ZodString;
@@ -204,6 +214,24 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
         internal: "internal";
         scheduler: "scheduler";
     }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"turn_routed">;
+    turnId: z.ZodString;
+    modelProfile: z.ZodString;
+    modelId: z.ZodString;
+    reasoningLevel: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        none: "none";
+    }>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodEnum<{
+        configured: "configured";
+        inherited: "inherited";
+        router: "router";
+    }>;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"turn_completed">;
     turnId: z.ZodString;
@@ -275,6 +303,16 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
     type: z.ZodLiteral<"compaction">;
     modelProfile: z.ZodString;
     modelId: z.ZodString;
+    details: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodLiteral<"capacity">;
+        estimatedInputTokens: z.ZodNumber;
+        replacementInputTokens: z.ZodOptional<z.ZodNumber>;
+        triggerTokens: z.ZodNumber;
+        inputLimitTokens: z.ZodNumber;
+        inputMessageCount: z.ZodNumber;
+        retainedMessageCount: z.ZodNumber;
+        summaryChars: z.ZodNumber;
+    }, z.core.$strict>>;
     replacementHistory: z.ZodArray<z.ZodObject<{
         message: z.ZodPipe<z.ZodObject<{
             role: z.ZodString;
@@ -447,6 +485,24 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
             internal: "internal";
             scheduler: "scheduler";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"turn_routed">;
+        turnId: z.ZodString;
+        modelProfile: z.ZodString;
+        modelId: z.ZodString;
+        reasoningLevel: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            none: "none";
+        }>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodEnum<{
+            configured: "configured";
+            inherited: "inherited";
+            router: "router";
+        }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_completed">;
         turnId: z.ZodString;
@@ -518,6 +574,16 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"compaction">;
         modelProfile: z.ZodString;
         modelId: z.ZodString;
+        details: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodLiteral<"capacity">;
+            estimatedInputTokens: z.ZodNumber;
+            replacementInputTokens: z.ZodOptional<z.ZodNumber>;
+            triggerTokens: z.ZodNumber;
+            inputLimitTokens: z.ZodNumber;
+            inputMessageCount: z.ZodNumber;
+            retainedMessageCount: z.ZodNumber;
+            summaryChars: z.ZodNumber;
+        }, z.core.$strict>>;
         replacementHistory: z.ZodArray<z.ZodObject<{
             message: z.ZodPipe<z.ZodObject<{
                 role: z.ZodString;
@@ -717,6 +783,24 @@ export declare const newConversationEventSchema: z.ZodObject<{
             internal: "internal";
             scheduler: "scheduler";
         }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"turn_routed">;
+        turnId: z.ZodString;
+        modelProfile: z.ZodString;
+        modelId: z.ZodString;
+        reasoningLevel: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            none: "none";
+        }>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodEnum<{
+            configured: "configured";
+            inherited: "inherited";
+            router: "router";
+        }>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"turn_completed">;
         turnId: z.ZodString;
@@ -759,6 +843,8 @@ export interface ConversationEventStore {
     append(conversationId: string, events: NewConversationEvent[]): Promise<void>;
     /** Replace active model history with a compaction or handoff event. */
     replaceHistory(conversationId: string, replacement: HistoryReplacement): Promise<void>;
+    /** One event selected by its retry-stable key across history versions. */
+    loadByIdempotencyKey(conversationId: string, idempotencyKey: string): Promise<ConversationEvent | undefined>;
     /** Events of the current history version in `seq` order. */
     loadCurrentHistory(conversationId: string): Promise<ConversationEvent[]>;
     /** Events in the history version containing `seq`, when it exists. */

package/dist/chat/conversations/projection.d.ts

@@ -1,8 +1,10 @@
 import { type PiMessage } from "@/chat/pi/messages";
 import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
-import type { AuthorizationKind } from "@/chat/conversations/history";
+import type { AuthorizationKind, ConversationEvent } from "@/chat/conversations/history";
 import type { JuniorSqlDatabase } from "@/db/db";
 import { type PiConversationEventProjection, type PiConversationProjection } from "@/chat/pi/conversation-events";
+import type { ModelProfile } from "@/chat/model-profile";
+import type { TurnReasoningLevel } from "@/chat/reasoning-level";
 interface ScopedConversation {
     conversationId: string;
 }
@@ -77,6 +79,23 @@ export declare function recordAuthorizationCompleted(args: {
     actorId: string;
     authorizationId: string;
 }): Promise<void>;
+/** Load a previously selected execution profile for a resumed turn. */
+export declare function loadTurnRoute(args: {
+    conversationId: string;
+    turnId: string;
+}): Promise<Extract<ConversationEvent["data"], {
+    type: "turn_routed";
+}> | undefined>;
+/** Record the execution profile selected for one turn without changing agent history. */
+export declare function recordTurnRoute(args: {
+    conversationId: string;
+    turnId: string;
+    modelProfile: ModelProfile;
+    modelId: string;
+    reasoningLevel: TurnReasoningLevel;
+    confidence?: number;
+    source: "configured" | "inherited" | "router";
+}): Promise<void>;
 /** Record a host-observed parent tool start without adding it to Pi replay. */
 export declare function recordToolExecutionStarted(args: {
     conversationId: string;

package/dist/chat/services/context-budget.d.ts

@@ -1,14 +1,19 @@
 export interface ModelContextBudget {
     contextWindow: number;
-    maxTokens: number;
 }
 /** Estimate text tokens with the shared coarse heuristic used for local budgets. */
 export declare function estimateTextTokens(text: string): number;
 /** Derive the automatic compaction threshold from model context capacity. */
 export declare function calculateContextCompactionTriggerTokens(model: ModelContextBudget): number;
+/** Derive the maximum estimated input size with room for uncounted request overhead. */
+export declare function calculateContextInputLimitTokens(model: ModelContextBudget): number;
 /** Derive the post-compaction target from the automatic trigger threshold. */
 export declare function calculateContextCompactionTargetTokens(triggerTokens: number): number;
+/** Cap one model's advertised context capacity with the host bot configuration. */
+export declare function getModelContextBudget(modelId: string): ModelContextBudget;
 /** Resolve the automatic compaction threshold for the active agent model. */
-export declare function getAgentContextCompactionTriggerTokens(): number;
+export declare function getAgentContextCompactionTriggerTokens(modelId: string): number;
+/** Resolve the hard input ceiling for the active agent model. */
+export declare function getAgentContextInputLimitTokens(modelId: string): number;
 /** Resolve the visible conversation compaction threshold for the auxiliary model. */
 export declare function getConversationContextCompactionTriggerTokens(): number;

package/dist/chat/services/context-compaction.d.ts

@@ -1,5 +1,6 @@
 import type { completeText } from "@/chat/pi/client";
 import type { PiMessage } from "@/chat/pi/messages";
+import { type ConversationMessageProvenance } from "@/chat/conversations/provenance";
 import type { ThreadConversationState } from "@/chat/state/conversation";
 import { type ModelProfile } from "@/chat/model-profile";
 export interface ContextCompactorDeps {
@@ -13,7 +14,7 @@ export interface CompactContextArgs {
     conversation: ThreadConversationState;
     conversationContext?: string;
     conversationId: string;
-    onCompactionStart?: () => void;
+    onCompactionStart?: () => void | Promise<void>;
     piMessages: PiMessage[];
     metadata?: {
         channelId?: string;
@@ -21,6 +22,7 @@ export interface CompactContextArgs {
         runId?: string;
         threadId?: string;
     };
+    modelId: string;
 }
 export interface CompactContextResult {
     compacted: boolean;
@@ -41,10 +43,35 @@ interface HandoffContextArgs {
         reasoningLevel?: string;
     };
 }
+interface ActiveContextCompactionArgs {
+    conversationContext?: string;
+    conversationId: string;
+    metadata?: CompactContextArgs["metadata"];
+    modelId: string;
+    modelProfile: ModelProfile;
+    onCompactionStart?: () => void | Promise<void>;
+    pendingMessages?: Array<{
+        message: PiMessage;
+        provenance: ConversationMessageProvenance;
+    }>;
+    piMessages: PiMessage[];
+    signal?: AbortSignal;
+}
+/** Raised when Junior cannot compact history below the active model's hard ceiling. */
+export declare class ContextInputLimitExceededError extends Error {
+    readonly estimatedTokens: number;
+    readonly inputLimitTokens: number;
+    constructor(estimatedTokens: number, inputLimitTokens: number);
+}
 /** Build retained user messages for a compacted Pi replacement history. */
 export declare function selectRetainedUserMessages(messages: PiMessage[], maxTokens?: number): PiMessage[];
 /** Build the service that owns local context compaction. */
 export declare function createContextCompactor(deps: ContextCompactorDeps): ContextCompactor;
 /** Compact the active conversation and durably bind its selected handoff profile. */
 export declare function compactContextForHandoff(args: HandoffContextArgs, deps: Pick<ContextCompactorDeps, "completeText">): Promise<PiMessage[]>;
+/**
+ * Replace oversized active history at Pi's next-turn boundary before another
+ * provider request can observe it.
+ */
+export declare function compactActiveContextIfNeeded(args: ActiveContextCompactionArgs, deps: Pick<ContextCompactorDeps, "completeText">): Promise<CompactContextResult>;
 export {};

package/dist/chat/services/conversation-memory.d.ts

@@ -14,6 +14,7 @@ export interface ConversationMemoryService {
     generateThreadTitle: (sourceText: string) => Promise<string>;
 }
 export declare function generateConversationId(prefix: "assistant" | "backfill" | "compaction" | "turn"): string;
+/** Normalize message boundaries without changing transcript formatting. */
 export declare function normalizeConversationText(text: string): string;
 export declare function updateConversationStats(conversation: ThreadConversationState): void;
 export declare function upsertConversationMessage(conversation: ThreadConversationState, message: ConversationMessage): string;

package/dist/chat/services/provider-error.d.ts

@@ -12,6 +12,7 @@ interface ProviderErrorOptions {
     retryable?: boolean;
 }
 interface ProviderErrorDetails {
+    cause?: unknown;
     kind: ProviderErrorKind;
     modelId?: string;
     retryable: boolean;

package/dist/chat/services/turn-router.d.ts

@@ -20,6 +20,7 @@ export interface TurnRoute {
     profile: ModelProfile;
     reasoningLevel: TurnReasoningLevel;
     reason: string;
+    source?: "configured" | "inherited" | "router";
 }
 /** Preserve an explicitly configured reasoning level without invoking the router. */
 export declare function configuredTurnRoute(profile: ModelProfile, reasoningLevel: TurnReasoningLevel, source: "agent_config" | "default" | "profile"): TurnRoute;

package/dist/chat/tools/sandbox/edit-file.d.ts

@@ -9,7 +9,6 @@ interface EditFileResult {
     }];
     details: {
         data: {
-            diff: string;
             first_changed_line?: number;
             path: string;
             replacements: number;
@@ -21,6 +20,7 @@ interface EditFileResult {
         replacements: number;
         status: "success";
         target: string;
+        truncated: boolean;
     } | {
         data: {
             path: string;

package/dist/chat/tools/sandbox/text-edits.d.ts

@@ -20,6 +20,7 @@ export declare function prepareTextReplacementArguments<T extends TextReplacemen
 export declare function buildCompactDiff(oldContent: string, newContent: string): {
     diff: string;
     firstChangedLine?: number;
+    truncated: boolean;
 };
 /** Apply exact replacements to normalized text after validating uniqueness and overlap. */
 export declare function validateAndApplyTextEdits(content: string, edits: TextReplacement[], targetName: string): {

package/dist/{chunk-36UJA3OD.js → chunk-4FUEG3QY.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-NP7TYFYR.js";
+} from "./chunk-5CZ7RETL.js";
 
 // src/chat/logging.ts
 import path from "path";

package/dist/{chunk-NP7TYFYR.js → chunk-5CZ7RETL.js}

@@ -1,6 +1,6 @@
 import {
   JUNIOR_VERSION
-} from "./chunk-ZRSUCJGA.js";
+} from "./chunk-PM3PX42K.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";

package/dist/{chunk-DXRPHBOU.js → chunk-6QWPVTMO.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-MU6HHZEN.js";
 import {
   getStateAdapter
-} from "./chunk-HMRVILWZ.js";
+} from "./chunk-YU6PO42Q.js";
 import {
   contextProvenance,
   createSqlConversationEventStore,
@@ -15,7 +15,7 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-LLKDNPYV.js";
+} from "./chunk-FIGAF6KL.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -23,9 +23,8 @@ import {
   botConfig,
   escapeXml,
   resolveGatewayModel,
-  standardModelId,
   unwrapCurrentInstruction
-} from "./chunk-RCBUZGIT.js";
+} from "./chunk-ZGXH3REA.js";
 import {
   toStoredSlackActor
 } from "./chunk-C4MZ3GP5.js";
@@ -34,7 +33,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-36UJA3OD.js";
+} from "./chunk-4FUEG3QY.js";
 import {
   isRecord,
   parseSlackMessageTs,
@@ -451,6 +450,36 @@ async function recordAuthorizationCompleted(args) {
     }
   ]);
 }
+async function loadTurnRoute(args) {
+  const event = await getConversationEventStore().loadByIdempotencyKey(
+    args.conversationId,
+    `turn:${args.turnId}:routed`
+  );
+  if (!event) {
+    return void 0;
+  }
+  if (event.data.type !== "turn_routed" || event.data.turnId !== args.turnId) {
+    throw new Error(`Turn route key for "${args.turnId}" has invalid data`);
+  }
+  return event.data;
+}
+async function recordTurnRoute(args) {
+  await getConversationEventStore().append(args.conversationId, [
+    {
+      idempotencyKey: `turn:${args.turnId}:routed`,
+      createdAtMs: Date.now(),
+      data: {
+        type: "turn_routed",
+        turnId: args.turnId,
+        modelProfile: args.modelProfile,
+        modelId: args.modelId,
+        reasoningLevel: args.reasoningLevel,
+        ...args.confidence !== void 0 ? { confidence: args.confidence } : {},
+        source: args.source
+      }
+    }
+  ]);
+}
 async function recordToolExecutionStarted(args) {
   await getConversationEventStore().append(args.conversationId, [
     {
@@ -1588,11 +1617,10 @@ function buildConversationStatePatch(conversation) {
 }
 
 // src/chat/services/context-budget.ts
-var COMPACTION_TRIGGER_INPUT_RATIO = 0.75;
-var COMPACTION_OUTPUT_RESERVE_RATIO = 0.25;
+var COMPACTION_TRIGGER_RATIO = 0.9;
+var CONTEXT_INPUT_LIMIT_RATIO = 0.95;
 var COMPACTION_TARGET_RATIO = 0.8;
 var FALLBACK_CONTEXT_WINDOW_TOKENS = 4e5;
-var FALLBACK_MAX_OUTPUT_TOKENS = 128e3;
 function positiveInteger(value, fallback) {
   return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
@@ -1604,36 +1632,43 @@ function calculateContextCompactionTriggerTokens(model) {
     model.contextWindow,
     FALLBACK_CONTEXT_WINDOW_TOKENS
   );
-  const maxTokens = positiveInteger(
-    model.maxTokens,
-    FALLBACK_MAX_OUTPUT_TOKENS
-  );
-  const outputReserve = Math.min(
-    maxTokens,
-    Math.floor(contextWindow * COMPACTION_OUTPUT_RESERVE_RATIO)
-  );
-  const usableInputTokens = Math.max(1, contextWindow - outputReserve);
-  return Math.max(
-    1,
-    Math.floor(usableInputTokens * COMPACTION_TRIGGER_INPUT_RATIO)
+  return Math.max(1, Math.floor(contextWindow * COMPACTION_TRIGGER_RATIO));
+}
+function calculateContextInputLimitTokens(model) {
+  const contextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
   );
+  return Math.max(1, Math.floor(contextWindow * CONTEXT_INPUT_LIMIT_RATIO));
 }
 function calculateContextCompactionTargetTokens(triggerTokens) {
   return Math.max(1, Math.floor(triggerTokens * COMPACTION_TARGET_RATIO));
 }
-function getAgentContextCompactionTriggerTokens() {
-  const model = resolveGatewayModel(standardModelId(botConfig));
-  return calculateContextCompactionTriggerTokens({
-    contextWindow: botConfig.modelContextWindowTokens ?? model.contextWindow,
-    maxTokens: model.maxTokens
-  });
+function getModelContextBudget(modelId) {
+  const model = resolveGatewayModel(modelId);
+  const advertisedContextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  return {
+    contextWindow: Math.min(
+      botConfig.contextWindowTokens,
+      advertisedContextWindow
+    )
+  };
+}
+function getAgentContextCompactionTriggerTokens(modelId) {
+  return calculateContextCompactionTriggerTokens(
+    getModelContextBudget(modelId)
+  );
+}
+function getAgentContextInputLimitTokens(modelId) {
+  return calculateContextInputLimitTokens(getModelContextBudget(modelId));
 }
 function getConversationContextCompactionTriggerTokens() {
-  const model = resolveGatewayModel(botConfig.fastModelId);
-  return calculateContextCompactionTriggerTokens({
-    contextWindow: model.contextWindow,
-    maxTokens: model.maxTokens
-  });
+  return calculateContextCompactionTriggerTokens(
+    getModelContextBudget(botConfig.fastModelId)
+  );
 }
 
 // src/chat/services/conversation-memory.ts
@@ -1646,7 +1681,7 @@ function generateConversationId(prefix) {
   return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
 }
 function normalizeConversationText(text) {
-  return text.trim().replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS);
+  return text.replace(/\r\n?/g, "\n").trim();
 }
 function buildImageContextSuffix(message, conversation) {
   const byFileId = conversation?.vision.byFileId;
@@ -1662,6 +1697,7 @@ function buildImageContextSuffix(message, conversation) {
 }
 function renderConversationMessageLine(message, conversation) {
   const displayName = conversationAuthorDisplayName(message);
+  const text = message.text.replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS);
   const markers = [];
   if (message.meta?.replied === false) {
     markers.push(
@@ -1673,7 +1709,7 @@ function renderConversationMessageLine(message, conversation) {
   }
   const markerSuffix = markers.length > 0 ? ` (${markers.join("; ")})` : "";
   const imageContext = buildImageContextSuffix(message, conversation);
-  return `[${message.role}] ${displayName}: ${message.text}${imageContext}${markerSuffix}`;
+  return `[${message.role}] ${displayName}: ${text}${imageContext}${markerSuffix}`;
 }
 function conversationAuthorDisplayName(message) {
   const author = message.author;
@@ -2650,6 +2686,8 @@ export {
   recordMcpProviderConnected,
   recordAuthorizationRequested,
   recordAuthorizationCompleted,
+  loadTurnRoute,
+  recordTurnRoute,
   recordToolExecutionStarted,
   buildDeterministicTurnId,
   buildDeterministicAssistantMessageId,
@@ -2692,6 +2730,7 @@ export {
   persistConversationMessageSummaries,
   estimateTextTokens,
   getAgentContextCompactionTriggerTokens,
+  getAgentContextInputLimitTokens,
   normalizeConversationText,
   updateConversationStats,
   upsertConversationMessage,

package/dist/{chunk-WBB22ANL.js → chunk-ABPSDO6M.js}

@@ -20,28 +20,28 @@ import {
   normalizeToolNameFromResult,
   stripRuntimeTurnContext,
   updateConversationStats
-} from "./chunk-DXRPHBOU.js";
+} from "./chunk-6QWPVTMO.js";
 import {
   createPluginEmbedder,
   createPluginLogger,
   createPluginModel,
   createPluginState,
   getPlugins
-} from "./chunk-YJ44UT7D.js";
+} from "./chunk-VNNBSKCO.js";
 import {
   getStateAdapter
-} from "./chunk-HMRVILWZ.js";
+} from "./chunk-YU6PO42Q.js";
 import {
   getDb
-} from "./chunk-LLKDNPYV.js";
+} from "./chunk-FIGAF6KL.js";
 import {
   ProviderError,
   getProviderErrorAttributes,
   getProviderErrorUserMessage
-} from "./chunk-RCBUZGIT.js";
+} from "./chunk-ZGXH3REA.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-36UJA3OD.js";
+} from "./chunk-4FUEG3QY.js";
 import {
   parseSlackMessageTs
 } from "./chunk-42WRQLJ6.js";

package/dist/{chunk-LLKDNPYV.js → chunk-FIGAF6KL.js}

@@ -6,15 +6,16 @@ import {
   juniorUsers
 } from "./chunk-JQFJO5WH.js";
 import {
+  TURN_REASONING_LEVELS,
   getChatConfig,
   modelProfileSchema
-} from "./chunk-RCBUZGIT.js";
+} from "./chunk-ZGXH3REA.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-36UJA3OD.js";
+} from "./chunk-4FUEG3QY.js";
 import {
   parseSlackChannelReferenceId,
   parseSlackTeamId
@@ -809,6 +810,16 @@ var replacementHistoryMessageSchema = conversationMessageDataSchema.extend({
   sourceEventSeq: z2.number().int().nonnegative().optional()
 });
 var replacementHistorySchema = z2.array(replacementHistoryMessageSchema);
+var compactionDetailsSchema = z2.object({
+  reason: z2.literal("capacity"),
+  estimatedInputTokens: z2.number().int().nonnegative(),
+  replacementInputTokens: z2.number().int().nonnegative().optional(),
+  triggerTokens: z2.number().int().nonnegative(),
+  inputLimitTokens: z2.number().int().positive(),
+  inputMessageCount: z2.number().int().nonnegative(),
+  retainedMessageCount: z2.number().int().nonnegative(),
+  summaryChars: z2.number().int().nonnegative()
+}).strict();
 var historyReplacementEventDataSchema = z2.discriminatedUnion("type", [
   z2.object({
     type: z2.literal("handoff"),
@@ -822,6 +833,7 @@ var historyReplacementEventDataSchema = z2.discriminatedUnion("type", [
     type: z2.literal("compaction"),
     modelProfile: modelProfileSchema,
     modelId: z2.string().min(1),
+    details: compactionDetailsSchema.optional(),
     replacementHistory: replacementHistorySchema
   }).strict()
 ]);
@@ -919,6 +931,15 @@ var turnStartedEventDataSchema = z2.object({
   (data) => new Set(data.inputMessageIds).size === data.inputMessageIds.length,
   "turn input message ids must be unique"
 );
+var turnRoutedEventDataSchema = z2.object({
+  type: z2.literal("turn_routed"),
+  turnId: z2.string().min(1),
+  modelProfile: modelProfileSchema,
+  modelId: z2.string().min(1),
+  reasoningLevel: z2.enum(TURN_REASONING_LEVELS),
+  confidence: z2.number().min(0).max(1).optional(),
+  source: z2.enum(["configured", "inherited", "router"])
+}).strict();
 var turnCompletedEventDataSchema = z2.object({
   type: z2.literal("turn_completed"),
   turnId: z2.string().min(1),
@@ -960,6 +981,7 @@ var appendableConversationEventDataSchema = z2.union([
   messageHandledEventDataSchema,
   messagesSummarizedEventDataSchema,
   turnStartedEventDataSchema,
+  turnRoutedEventDataSchema,
   turnCompletedEventDataSchema,
   turnFailedEventDataSchema,
   subagentStartedEventDataSchema,
@@ -981,6 +1003,7 @@ var knownConversationEventTypeSchema = z2.enum([
   "message_handled",
   "messages_summarized",
   "turn_started",
+  "turn_routed",
   "turn_completed",
   "turn_failed",
   "subagent_started",
@@ -1219,6 +1242,15 @@ var SqlConversationEventStore = class {
     ).orderBy(asc2(juniorConversationEvents.seq));
     return rows.map(eventFromRow);
   }
+  async loadByIdempotencyKey(conversationId, idempotencyKey) {
+    const [row] = await this.executor.db().select().from(juniorConversationEvents).where(
+      and3(
+        eq3(juniorConversationEvents.conversationId, conversationId),
+        eq3(juniorConversationEvents.idempotencyKey, idempotencyKey)
+      )
+    ).limit(1);
+    return row ? eventFromRow(row) : void 0;
+  }
   async loadHistoryContaining(conversationId, seq, throughSeq) {
     const [boundary] = await this.executor.db().select({ historyVersion: juniorConversationEvents.historyVersion }).from(juniorConversationEvents).where(
       and3(

package/dist/{chunk-OXE5ZUTS.js → chunk-K2W4CK7K.js}

@@ -5,7 +5,7 @@ import {
   logInfo,
   logWarn,
   setSpanAttributes
-} from "./chunk-36UJA3OD.js";
+} from "./chunk-4FUEG3QY.js";
 import {
   discoverInstalledPluginPackageContent,
   normalizePluginPackageNames

package/dist/{chunk-K5BXPM74.js → chunk-O4GT7LYB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2ZTTXTSZ.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-QTS66GMR.js";
+} from "./chunk-RD7EJI7H.js";
 import {
   parseSlackThreadId
 } from "./chunk-6Y5L4BOM.js";

package/dist/{chunk-LR2SKL5Y.js → chunk-OSKEC4XU.js}

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