@sentry/junior 0.109.0 → 0.110.0

package/dist/app.js

@@ -6,21 +6,23 @@ import {
   processPluginTask,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-MXW4GL53.js";
+} from "./chunk-3UBQI73J.js";
 import {
   GET,
   buildSentryConversationUrl,
   conversationVisibilityFromSlackChannelType,
-  resolveRootVisibility,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-FWJRXN4F.js";
-import "./chunk-CEA3A3UA.js";
+} from "./chunk-3S7YYHBI.js";
+import "./chunk-2ZTTXTSZ.js";
 import {
+  ConversationQueueMessageRejectedError,
+  conversationQueueMessageSchema,
   getVercelConversationWorkQueue,
+  isConversationQueueMessageRejectedError,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-7Q6WCISF.js";
+} from "./chunk-MIAKQNYX.js";
 import {
   PLUGIN_TASK_QUEUE_TOPIC,
   createVercelQueueClient,
@@ -29,7 +31,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-MGUMR35T.js";
+} from "./chunk-Y5FK3CNG.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -82,7 +84,7 @@ import {
   splitSlackReplyText,
   startOAuthFlow,
   truncateStatusText
-} from "./chunk-IXKSQGIO.js";
+} from "./chunk-RHHRKSPI.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -141,8 +143,8 @@ import {
   turnHasReply,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-72OMGPDS.js";
-import "./chunk-HO5NT6OE.js";
+} from "./chunk-C5XAFTHY.js";
+import "./chunk-W6RJZG7F.js";
 import "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
@@ -161,12 +163,12 @@ import {
   validatePlugins,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-QY636HZU.js";
+} from "./chunk-2T7TIEXI.js";
 import {
   acquireActiveLock,
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-OUHNWH46.js";
+} from "./chunk-GK47NBDE.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -177,20 +179,25 @@ import {
   normalizeSlackConversationId,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId
-} from "./chunk-RGX4V75M.js";
+} from "./chunk-L5XQPJ7T.js";
 import {
   contextProvenance,
+  createSlackDestination,
+  destinationKey,
   getConversationEventStore,
   getConversationStore,
   getDb,
   getSqlExecutor,
   instructionProvenanceFor,
+  parseDestination,
+  requireSlackDestination,
+  sameDestination,
   withConversationEventLock
-} from "./chunk-FENLIFJD.js";
+} from "./chunk-4QU44P7Q.js";
 import {
   juniorConversationEvents,
   juniorConversations
-} from "./chunk-TMBRFULF.js";
+} from "./chunk-JQFJO5WH.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -214,7 +221,7 @@ import {
   standardModelId,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-JNAVF45E.js";
+} from "./chunk-WNOVRQ67.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -223,26 +230,19 @@ import {
   readSlackRawMessageContext,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-O3JMSZLI.js";
-import {
-  createSlackDestination,
-  destinationKey,
-  parseDestination,
-  requireSlackDestination,
-  sameDestination
-} from "./chunk-SYAQIR5Z.js";
+} from "./chunk-6Y5L4BOM.js";
 import {
   discoverSkills
-} from "./chunk-WHMOBKT7.js";
+} from "./chunk-SBOBTS27.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-3SXUV423.js";
+} from "./chunk-3TV7OEHL.js";
 import {
   buildOAuthTokenRequest,
   credentialSubjectSchema,
   hasRequiredOAuthScope,
   parseOAuthTokenResponse
-} from "./chunk-TT6GMXNA.js";
+} from "./chunk-Y3H2DN6F.js";
 import {
   createActor,
   createSlackActor,
@@ -251,7 +251,7 @@ import {
   isUserActor,
   parseActorUserId,
   parseStoredSlackActor
-} from "./chunk-PLB7MRCQ.js";
+} from "./chunk-C4MZ3GP5.js";
 import {
   buildTurnFailureResponse,
   createChatSdkLogger,
@@ -267,12 +267,14 @@ import {
   setTags,
   withContext,
   withSpan
-} from "./chunk-ISMWX44P.js";
+} from "./chunk-IYKPU7H6.js";
 import {
   isRecord,
+  parseSlackChannelId,
+  parseSlackMessageTs,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-OB42YVAE.js";
+} from "./chunk-42WRQLJ6.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
@@ -281,13 +283,11 @@ import {
   homeDir
 } from "./chunk-3V7OFJZC.js";
 import {
-  JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE,
-  parseSlackChannelId,
-  parseSlackMessageTs
-} from "./chunk-IVVGFRQQ.js";
+  JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
+} from "./chunk-W75ZPAGG.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-OCD3OZRK.js";
+} from "./chunk-ZKIOWEFL.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -2506,8 +2506,7 @@ async function ensureConversationWake(args) {
   }
   const queueResult = await args.queue.send(
     {
-      conversationId: args.conversationId,
-      destination: conversation.destination
+      conversationId: args.conversationId
     },
     {
       delayMs: args.delayMs,
@@ -3184,7 +3183,47 @@ async function GET2(request, waitUntil, options = {}) {
 import { timingSafeEqual as timingSafeEqual3 } from "crypto";
 
 // src/chat/conversations/sql/purge.ts
-import { and, asc, eq, inArray, isNull, sql } from "drizzle-orm";
+import { and, asc, eq as eq2, inArray, isNull, sql } from "drizzle-orm";
+
+// src/chat/conversations/sql/privacy.ts
+import { eq } from "drizzle-orm";
+import { alias } from "drizzle-orm/pg-core";
+var privacyRoot = alias(juniorConversations, "privacy_root");
+async function readRootCandidate(executor, conversationId) {
+  const rows = await executor.db().select({
+    requestedConversationId: juniorConversations.conversationId,
+    requestedParentConversationId: juniorConversations.parentConversationId,
+    requestedRootConversationId: juniorConversations.rootConversationId,
+    rootConversationId: privacyRoot.conversationId,
+    rootDestinationId: privacyRoot.destinationId,
+    rootParentConversationId: privacyRoot.parentConversationId,
+    rootRootConversationId: privacyRoot.rootConversationId
+  }).from(juniorConversations).leftJoin(
+    privacyRoot,
+    eq(privacyRoot.conversationId, juniorConversations.rootConversationId)
+  ).where(eq(juniorConversations.conversationId, conversationId));
+  const row = rows[0];
+  return row?.requestedRootConversationId !== null && (row?.requestedParentConversationId !== null || row?.requestedRootConversationId === row?.requestedConversationId) && row?.rootConversationId === row.requestedRootConversationId && row.rootRootConversationId === row.rootConversationId && row.rootParentConversationId === null && row.rootDestinationId !== null ? {
+    destinationId: row.rootDestinationId,
+    rootConversationId: row.rootConversationId
+  } : void 0;
+}
+async function readCandidateVisibility(executor, candidate) {
+  const destinations = await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq(juniorDestinations.id, candidate.destinationId)).for("share");
+  return {
+    rootConversationId: candidate.rootConversationId,
+    visibility: destinations[0]?.visibility ?? null
+  };
+}
+async function resolveRootVisibility(executor, conversationId) {
+  const candidate = await readRootCandidate(executor, conversationId);
+  if (!candidate) {
+    return { rootConversationId: conversationId, visibility: null };
+  }
+  return readCandidateVisibility(executor, candidate);
+}
+
+// src/chat/conversations/sql/purge.ts
 async function discoverConversationTree(executor, root) {
   const all = /* @__PURE__ */ new Map([
     [root.conversationId, root]
@@ -3253,7 +3292,7 @@ async function selectExpiredRoots(executor, args) {
     visibility: juniorDestinations.visibility
   }).from(juniorConversations).leftJoin(
     juniorDestinations,
-    eq(juniorDestinations.id, juniorConversations.destinationId)
+    eq2(juniorDestinations.id, juniorConversations.destinationId)
   ).where(
     and(
       isNull(juniorConversations.parentConversationId),
@@ -3274,7 +3313,7 @@ async function purgeConversationTree(executor, args) {
     const initialRoots = await executor.db().select({
       conversationId: juniorConversations.conversationId,
       parentConversationId: juniorConversations.parentConversationId
-    }).from(juniorConversations).where(eq(juniorConversations.conversationId, args.rootConversationId));
+    }).from(juniorConversations).where(eq2(juniorConversations.conversationId, args.rootConversationId));
     const initialRoot = initialRoots[0];
     if (!initialRoot || args.retention && initialRoot.parentConversationId !== null) {
       return { purged: false, conversations: 0 };
@@ -3296,14 +3335,14 @@ async function purgeConversationTree(executor, args) {
           destinationId: juniorConversations.destinationId,
           parentConversationId: juniorConversations.parentConversationId
         }).from(juniorConversations).where(
-          eq(juniorConversations.conversationId, args.rootConversationId)
+          eq2(juniorConversations.conversationId, args.rootConversationId)
         ).for("update");
         const root = roots[0];
         if (!root || args.retention && root.parentConversationId !== null) {
           return { purged: false, conversations: 0 };
         }
         const resolvedScrubMetadata = args.scrubMetadataFromRootVisibility ? (await resolveRootVisibility(executor, args.rootConversationId)).visibility !== "public" : args.scrubMetadata;
-        const destinations = root.destinationId ? await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq(juniorDestinations.id, root.destinationId)).for("share") : [];
+        const destinations = root.destinationId ? await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq2(juniorDestinations.id, root.destinationId)).for("share") : [];
         const isPublic = destinations[0]?.visibility === "public";
         const ids = tree.map((conversation) => conversation.conversationId);
         if (args.retention) {
@@ -7894,21 +7933,6 @@ import {
   registerDevConsumer
 } from "@vercel/queue";
 
-// src/chat/task-execution/queue.ts
-var ConversationQueueMessageRejectedError = class extends Error {
-  conversationId;
-  reason;
-  constructor(reason, message, options = {}) {
-    super(message);
-    this.name = "ConversationQueueMessageRejectedError";
-    this.reason = reason;
-    this.conversationId = options.conversationId;
-  }
-};
-function isConversationQueueMessageRejectedError(error) {
-  return error instanceof ConversationQueueMessageRejectedError;
-}
-
 // src/chat/task-execution/worker.ts
 var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;
 var CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 24e4;
@@ -8045,10 +8069,10 @@ async function processConversationWork(message, options) {
     }
     return { status: "no_work" };
   }
-  if (!initial.destination || !sameDestination(initial.destination, message.destination)) {
+  if (!initial.destination) {
     throw new ConversationQueueMessageRejectedError(
-      "destination_mismatch",
-      `Conversation work queue destination changed for ${conversationId}`,
+      "invalid_record",
+      `Conversation work is missing destination context for ${conversationId}`,
       { conversationId }
     );
   }
@@ -8400,18 +8424,11 @@ async function processConversationWork(message, options) {
 var CONVERSATION_WORK_VISIBILITY_TIMEOUT_BUFFER_SECONDS = 30;
 var CONVERSATION_WORK_DEV_CONSUMER_GROUP = "junior_conversation_work_dev";
 function parseConversationQueueMessage(message) {
-  const destination = parseDestination(
-    message?.destination
-  );
-  if (!message || typeof message !== "object" || typeof message.conversationId !== "string" || !message.conversationId.trim() || !destination) {
-    throw new Error(
-      "Conversation queue message is missing destination context"
-    );
+  const parsed = conversationQueueMessageSchema.safeParse(message);
+  if (!parsed.success) {
+    throw new Error("Conversation queue message is malformed");
   }
-  return {
-    conversationId: message.conversationId,
-    destination
-  };
+  return parsed.data;
 }
 function resolveConversationWorkVisibilityTimeoutSeconds(functionMaxDurationSeconds = getChatConfig().functionMaxDurationSeconds) {
   return functionMaxDurationSeconds + CONVERSATION_WORK_VISIBILITY_TIMEOUT_BUFFER_SECONDS;

package/dist/catalog-runtime-4GI22PXK.js

@@ -0,0 +1,16 @@
+import {
+  pluginCatalogRuntime
+} from "./chunk-3TV7OEHL.js";
+import "./chunk-Y3H2DN6F.js";
+import "./chunk-C4MZ3GP5.js";
+import "./chunk-IYKPU7H6.js";
+import "./chunk-42WRQLJ6.js";
+import "./chunk-6GWA276C.js";
+import "./chunk-B3IT5END.js";
+import "./chunk-3V7OFJZC.js";
+import "./chunk-W75ZPAGG.js";
+import "./chunk-ZKIOWEFL.js";
+import "./chunk-MLKGABMK.js";
+export {
+  pluginCatalogRuntime
+};

package/dist/chat/agent/resume.d.ts

@@ -15,6 +15,7 @@ import type { AgentRunOutcome } from "@/chat/runtime/agent-run-outcome";
 import type { AgentTurnSurface } from "@/chat/state/turn-session";
 import type { Actor } from "@/chat/actor";
 import { loadTurnSessionRecord, persistRunningSessionRecord } from "@/chat/services/turn-session-record";
+import { type AuthorizationPauseError } from "@/chat/services/auth-pause";
 import { type AgentTurnUsage } from "@/chat/usage";
 import { type AgentRunDurability } from "@/chat/agent/request";
 type LoadedSessionRecordState = Awaited<ReturnType<typeof loadTurnSessionRecord>>;
@@ -36,15 +37,14 @@ interface ResumeStateArgs {
     startedAtMs: number;
     surface: AgentTurnSurface;
 }
-interface ExpectedEndingTranslation {
-    outcome?: AgentRunOutcome;
-}
+type AuthPauseOutcome = Extract<AgentRunOutcome, {
+    status: "awaiting_auth";
+}>;
 /** Create the run's resume state: checkpoints, snapshots, and ending translation. */
 export declare function createResumeState(args: ResumeStateArgs): {
     readonly inputCommitted: boolean;
     readonly beforeMessageCount: number;
     readonly timedOut: boolean;
-    readonly cooperativeYieldError: CooperativeTurnYieldError | undefined;
     setTurnStartMessageIndex(index: number | undefined): void;
     setBeforeMessageCount(count: number): void;
     /** Adopt an already committed epoch replacement as every resume baseline. */
@@ -55,16 +55,15 @@ export declare function createResumeState(args: ResumeStateArgs): {
     commitInput(): Promise<void>;
     persistSafeBoundary(messages: PiMessage[], trailingMessageProvenance?: ConversationMessageProvenance[]): Promise<boolean>;
     requireDurableInputCheckpoint(messages: PiMessage[], trailingMessageProvenance?: ConversationMessageProvenance[]): Promise<boolean>;
-    yieldAtSafeBoundaryIfDue(currentMessages: PiMessage[]): void;
-    /**
-     * Persist the continuation for an expected run ending and translate it
-     * into an outcome; returns no outcome for genuine errors so the caller's
-     * error guards run.
-     */
-    translateExpectedEnding(args2: {
+    /** Prepare a cooperative yield at the current durable boundary. */
+    prepareYieldIfDue(currentMessages: PiMessage[]): CooperativeTurnYieldError | undefined;
+    /** Persist an auth pause; only a durable pause may return `awaiting_auth`. */
+    parkForAuth(pause: AuthorizationPauseError, currentUsage?: AgentTurnUsage): Promise<AuthPauseOutcome>;
+    /** Persist a yield, retry, or timeout as a suspended run. */
+    translateSuspension(ending: {
         currentUsage?: AgentTurnUsage;
         error: unknown;
-    }): Promise<ExpectedEndingTranslation>;
+    }): Promise<AgentRunOutcome | undefined>;
 };
 export type ResumeState = ReturnType<typeof createResumeState>;
 export {};

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

@@ -25,6 +25,7 @@ export declare const historyReplacementSchema: z.ZodObject<{
         type: z.ZodLiteral<"handoff">;
         modelProfile: z.ZodString;
         modelId: z.ZodString;
+        reasoningLevel: z.ZodOptional<z.ZodString>;
         triggeringToolCallId: z.ZodOptional<z.ZodString>;
         replacementHistory: z.ZodArray<z.ZodObject<{
             message: z.ZodPipe<z.ZodObject<{
@@ -237,6 +238,7 @@ export declare const conversationEventDataSchema: z.ZodUnion<readonly [z.ZodUnio
     type: z.ZodLiteral<"handoff">;
     modelProfile: z.ZodString;
     modelId: z.ZodString;
+    reasoningLevel: z.ZodOptional<z.ZodString>;
     triggeringToolCallId: z.ZodOptional<z.ZodString>;
     replacementHistory: z.ZodArray<z.ZodObject<{
         message: z.ZodPipe<z.ZodObject<{
@@ -479,6 +481,7 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"handoff">;
         modelProfile: z.ZodString;
         modelId: z.ZodString;
+        reasoningLevel: z.ZodOptional<z.ZodString>;
         triggeringToolCallId: z.ZodOptional<z.ZodString>;
         replacementHistory: z.ZodArray<z.ZodObject<{
             message: z.ZodPipe<z.ZodObject<{

package/dist/chat/conversations/sql/privacy.d.ts

@@ -1,27 +1,15 @@
 import type { JuniorSqlDatabase } from "@/db/db";
-import { juniorConversationEvents } from "@/db/schema";
 import type { JuniorDestinationVisibility } from "@/db/schema/destinations";
 /** Root conversation identity and its normalized destination visibility. */
 export interface RootConversationVisibility {
     rootConversationId: string;
     visibility: JuniorDestinationVisibility | null;
 }
-type ConversationEventPrivacySnapshot = RootConversationVisibility & {
-    events: Array<typeof juniorConversationEvents.$inferSelect>;
-};
-/**
- * Read selected event rows and their root privacy authority in one SQL snapshot.
- */
-export declare function readConversationEventPrivacySnapshot(executor: JuniorSqlDatabase, args: {
-    conversationId: string;
-    eventTypes: readonly string[];
-}): Promise<ConversationEventPrivacySnapshot | undefined>;
 /**
  * Resolve a conversation's privacy authority from its persisted root.
  *
- * Parent links are immutable after insertion. Missing, cyclic, or over-depth
- * lineage fails closed, while the root destination is locked so callers that
- * keep the transaction open receive a stable visibility decision.
+ * Missing or structurally invalid root metadata fails closed. The root
+ * destination is locked so callers that keep the transaction open receive a
+ * stable visibility decision.
  */
 export declare function resolveRootVisibility(executor: JuniorSqlDatabase, conversationId: string): Promise<RootConversationVisibility>;
-export {};

package/dist/chat/pi/messages.d.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 /** Permissive schema for durable Pi SDK messages whose content shape may evolve. */
 export declare const piMessageSchema: z.ZodPipe<z.ZodObject<{
     role: z.ZodString;
-}, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+}, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
     [x: string]: unknown;
     role: string;
 }>>;
@@ -12,7 +12,7 @@ export type PiMessage = z.output<typeof piMessageSchema>;
 export declare const piContentMessageSchema: z.ZodPipe<z.ZodObject<{
     content: z.ZodArray<z.ZodUnknown>;
     role: z.ZodString;
-}, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+}, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
     [x: string]: unknown;
     content: unknown[];
     role: string;

package/dist/chat/pi/sql-model-usage.d.ts

@@ -4,7 +4,10 @@ import { type AgentTurnUsage } from "@/chat/usage";
  * Aggregate real assistant calls by provider/model in SQL. Replayed history is
  * not another call; its tokens appear in the next call's input usage.
  */
-export declare function readConversationModelUsageFromSql(executor: JuniorSqlDatabase, conversationId: string): Promise<Array<{
+export declare function readConversationModelUsageFromSql(executor: JuniorSqlDatabase, options: {
+    conversationId: string;
+    includeDescendants?: boolean;
+}): Promise<Array<{
     modelId: string;
     usage: AgentTurnUsage;
 }>>;

package/dist/chat/services/auth-pause.d.ts

@@ -12,6 +12,10 @@ export declare class AuthorizationPauseError extends Error {
     readonly providerDisplayName: string;
     constructor(kind: AuthorizationPauseKind, provider: string, providerDisplayName: string, disposition: AuthorizationPauseDisposition);
 }
+/** Error indicating an authorization pause could not be made durable. */
+export declare class AuthPausePersistenceError extends Error {
+    constructor(conversationId: string, turnId: string, cause?: unknown);
+}
 /** Error indicating this turn cannot start an external authorization flow. */
 export declare class AuthorizationFlowDisabledError extends Error {
     readonly kind: AuthorizationPauseKind;

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

@@ -38,6 +38,7 @@ interface HandoffContextArgs {
     target: {
         modelId: string;
         modelProfile: ModelProfile;
+        reasoningLevel?: string;
     };
 }
 /** Build retained user messages for a compacted Pi replacement history. */

package/dist/chat/task-execution/queue-signing.d.ts

@@ -1,11 +1,13 @@
-import type { ConversationQueueMessage } from "./queue";
-declare const CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION = "v1";
+import { z } from "zod";
+import { type ConversationQueueMessage } from "./queue";
 export declare const CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS: number;
-interface SignedConversationQueueMessage extends ConversationQueueMessage {
-    signature: string;
-    signatureVersion: typeof CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION;
-    signedAtMs: number;
-}
+declare const signedConversationQueueMessageSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    signature: z.ZodString;
+    signatureVersion: z.ZodLiteral<"v2">;
+    signedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+type SignedConversationQueueMessage = z.output<typeof signedConversationQueueMessageSchema>;
 export type ConversationQueueMessageVerificationResult = {
     message: ConversationQueueMessage;
     status: "verified";
@@ -18,7 +20,7 @@ export type ConversationQueueMessageVerificationResult = {
 };
 /** Sign a conversation queue payload before it crosses the public callback route. */
 export declare function signConversationQueueMessage(message: ConversationQueueMessage, nowMs?: number): SignedConversationQueueMessage;
-/** Explain whether a queue payload is verified, rejected, or temporarily unverifiable. */
+/** Explain whether a queue payload is verified, rejected, or unavailable. */
 export declare function verifyConversationQueueMessage(value: unknown, nowMs?: number): ConversationQueueMessageVerificationResult;
 /** Verify a signed conversation queue payload from the Vercel Queue callback. */
 export declare function verifySignedConversationQueueMessage(value: unknown, nowMs?: number): ConversationQueueMessage | undefined;

package/dist/chat/task-execution/queue.d.ts

@@ -1,9 +1,11 @@
-import type { Destination } from "@sentry/junior-plugin-api";
-export interface ConversationQueueMessage {
-    conversationId: string;
-    destination: Destination;
-}
-export type ConversationQueueMessageRejectReason = "destination_mismatch" | "expired" | "invalid_record" | "malformed" | "signature_mismatch";
+import { z } from "zod";
+/** Validate the conversation work hint sent through Vercel Queue. */
+export declare const conversationQueueMessageSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+}, z.core.$strict>;
+/** Conversation work hint accepted by the queue callback and worker. */
+export type ConversationQueueMessage = z.output<typeof conversationQueueMessageSchema>;
+export type ConversationQueueMessageRejectReason = "expired" | "invalid_record" | "malformed" | "signature_mismatch";
 export declare class ConversationQueueMessageRejectedError extends Error {
     conversationId?: string;
     reason: ConversationQueueMessageRejectReason;
@@ -11,7 +13,7 @@ export declare class ConversationQueueMessageRejectedError extends Error {
         conversationId?: string;
     });
 }
-/** Return whether a queue payload was permanently rejected at the message boundary. */
+/** Return whether an error means the queue message was permanently rejected. */
 export declare function isConversationQueueMessageRejectedError(error: unknown): error is ConversationQueueMessageRejectedError;
 export interface ConversationQueueSendOptions {
     delayMs?: number;

package/dist/chat/task-execution/slack-work.d.ts

@@ -22,8 +22,8 @@ declare const slackConversationMessageMetadataSchema: z.ZodUnion<readonly [z.Zod
         _type: z.ZodLiteral<"chat:Message">;
         attachments: z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
-                image: "image";
                 file: "file";
+                image: "image";
                 audio: "audio";
                 video: "video";
             }>;
@@ -72,16 +72,16 @@ declare const slackConversationMessageMetadataSchema: z.ZodUnion<readonly [z.Zod
         channelId: z.ZodString;
         channelVisibility: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            private: "private";
             external: "external";
+            private: "private";
             workspace: "workspace";
         }>>;
         currentMessage: z.ZodOptional<z.ZodObject<{
             _type: z.ZodLiteral<"chat:Message">;
             attachments: z.ZodArray<z.ZodObject<{
                 type: z.ZodEnum<{
-                    image: "image";
                     file: "file";
+                    image: "image";
                     audio: "audio";
                     video: "video";
                 }>;
@@ -132,8 +132,8 @@ declare const slackConversationMessageMetadataSchema: z.ZodUnion<readonly [z.Zod
         _type: z.ZodLiteral<"chat:Message">;
         attachments: z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
-                image: "image";
                 file: "file";
+                image: "image";
                 audio: "audio";
                 video: "video";
             }>;
@@ -182,16 +182,16 @@ declare const slackConversationMessageMetadataSchema: z.ZodUnion<readonly [z.Zod
         channelId: z.ZodString;
         channelVisibility: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            private: "private";
             external: "external";
+            private: "private";
             workspace: "workspace";
         }>>;
         currentMessage: z.ZodOptional<z.ZodObject<{
             _type: z.ZodLiteral<"chat:Message">;
             attachments: z.ZodArray<z.ZodObject<{
                 type: z.ZodEnum<{
-                    image: "image";
                     file: "file";
+                    image: "image";
                     audio: "audio";
                     video: "video";
                 }>;