@sentry/junior 0.106.0 → 0.107.1

package/dist/{catalog-runtime-5CVM2DOF.js → catalog-runtime-FOFNPR3P.js}

@@ -1,7 +1,8 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-77LHNQK4.js";
-import "./chunk-AEWZ7F65.js";
+} from "./chunk-YIPD3L6L.js";
+import "./chunk-VIXFG2VC.js";
+import "./chunk-O24R4DCK.js";
 import "./chunk-OB42YVAE.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-B3IT5END.js";

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

@@ -49,7 +49,7 @@ export declare function toObservablePromptPart(part: UserContentPart): Record<st
 export declare function buildPromptInput(input: AgentRunInput): PromptInput;
 /**
  * Convert a mid-run user message into the Pi user message shape used for
- * steering injection and parked-conversation session-log appends, so both
+ * steering injection and parked-conversation event-log appends, so both
  * paths store identical durable history.
  */
 export declare function buildSteeringPiMessage(message: AgentRunSteeringMessage): PiMessage;

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

@@ -12,7 +12,7 @@ import type { ChannelConfigurationService } from "@/chat/configuration/types";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { CredentialContext } from "@/chat/credentials/context";
 import type { PiMessage } from "@/chat/pi/messages";
-import { type Actor } from "@/chat/actor";
+import type { Actor } from "@/chat/actor";
 import type { SandboxAcquiredState } from "@/chat/sandbox/sandbox";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import type { AuthorizationFlowMode } from "@/chat/services/auth-pause";
@@ -20,7 +20,7 @@ import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SlackConversationContext } from "@/chat/slack/conversation-context";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
-import type { PiMessageProvenance } from "@/chat/state/session-log";
+import type { ConversationMessageProvenance } from "@/chat/conversations/provenance";
 import type { AgentTurnSurface } from "@/chat/state/turn-session";
 import type { ToolExecutionReport } from "@/chat/tool-support/tool-execution-report";
 import type { SlackActionToken } from "@/chat/slack/action-token";
@@ -40,7 +40,7 @@ export interface AgentRunInstructionActor {
 export interface AgentRunSteeringMessage {
     actor?: AgentRunInstructionActor;
     /** Provenance of this queued/steered message, carrying its original author. */
-    provenance: PiMessageProvenance;
+    provenance: ConversationMessageProvenance;
     omittedImageAttachmentCount?: number;
     text: string;
     timestampMs?: number;
@@ -78,18 +78,6 @@ export interface AgentRunRouting {
         metadata?: Record<string, string>;
         plugin?: string;
     };
-    correlation?: {
-        conversationId?: string;
-        threadId?: string;
-        turnId?: string;
-        runId?: string;
-        channelId?: string;
-        channelName?: string;
-        teamId?: string;
-        messageTs?: string;
-        threadTs?: string;
-        actorId?: string;
-    };
     toolChannelId?: string;
 }
 /** Carries execution limits and dependency overrides for one run slice. */
@@ -127,15 +115,26 @@ export interface AgentRunState {
  * their failures never affect the run.
  */
 export interface AgentRunObservers {
-    onTextDelta?: (deltaText: string) => void | Promise<void>;
-    onAssistantMessageStart?: () => void | Promise<void>;
     onToolInvocation?: (invocation: {
-        toolName: string;
         params: Record<string, unknown>;
+        toolCallId: string;
+        toolName: string;
     }) => void | Promise<void>;
     onToolResult?: (result: ToolExecutionReport) => void | Promise<void>;
     onStatus?: (status: AssistantStatusSpec) => void | Promise<void>;
 }
+/** One completed tool-free assistant message ready for destination delivery. */
+export interface AgentAssistantMessage {
+    text: string;
+}
+/** Delivers completed tool-free assistant messages in model order. */
+export interface AgentRunDelivery {
+    onAssistantMessage: (message: AgentAssistantMessage) => void | Promise<void>;
+}
+/** Resume the agent turn after a transient or ambiguous delivery failure. */
+export declare class RetryableDeliveryError extends Error {
+    constructor(cause: unknown);
+}
 /** Carries durable-worker ports that commit or update resumable run state. */
 export interface AgentRunDurability {
     onInputCommitted?: () => void | Promise<void>;
@@ -148,25 +147,25 @@ export interface AgentRunDurability {
 }
 /** Groups the per-slice run request by the runtime role each field serves. */
 export interface AgentRunRequest {
+    /** Durable conversation advanced by this run. */
+    conversationId: string;
+    /** Stable turn advanced across this run and any continuation runs. */
+    turnId: string;
+    /** Optional bounded-run identifier used only for observability. */
+    runId?: string;
     input: AgentRunInput;
     routing: AgentRunRouting;
     policy?: AgentRunPolicy;
     state?: AgentRunState;
     observers?: AgentRunObservers;
+    delivery?: AgentRunDelivery;
     durability?: AgentRunDurability;
 }
-/** Extract conversation and session identifiers from correlation context. */
-export declare function getSessionIdentifiers(routing: AgentRunRouting): {
-    conversationId?: string;
-    sessionId?: string;
-};
-/** Derive the acting actor, filling platform and team from the destination. */
+/** Resolve the explicit actor or the system credential actor for this run. */
 export declare function actorFromRouting(routing: AgentRunRouting): Actor | undefined;
-/** Reject actor identities that do not belong to the active destination. */
-export declare function assertActorDestinationMatch(routing: AgentRunRouting): void;
-/** Reject legacy Slack correlation fields that conflict with the destination. */
-export declare function assertCorrelationDestinationMatch(routing: AgentRunRouting): void;
+/** Reject contradictory provider coordinates before the run touches state. */
+export declare function assertRunRoutingConsistency(request: Pick<AgentRunRequest, "conversationId" | "routing">): void;
 /** Route tool side effects to the tool channel when one overrides the destination. */
 export declare function toolInvocationDestination(routing: AgentRunRouting): Destination;
 /** Infer the run surface when the caller did not state one. */
-export declare function surfaceFromRouting(routing: AgentRunRouting): AgentTurnSurface | undefined;
+export declare function surfaceFromRouting(routing: AgentRunRouting): AgentTurnSurface;

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

@@ -9,14 +9,14 @@
  */
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
-import type { PiMessageProvenance } from "@/chat/state/session-log";
+import type { ConversationMessageProvenance } from "@/chat/conversations/provenance";
 import { CooperativeTurnYieldError } from "@/chat/runtime/turn";
 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 AgentTurnUsage } from "@/chat/usage";
-import type { AgentRunDurability } from "@/chat/agent/request";
+import { type AgentRunDurability } from "@/chat/agent/request";
 type LoadedSessionRecordState = Awaited<ReturnType<typeof loadTurnSessionRecord>>;
 type SessionRecordLogContext = NonNullable<Parameters<typeof persistRunningSessionRecord>[0]["logContext"]>;
 interface ResumeStateArgs {
@@ -30,11 +30,11 @@ interface ResumeStateArgs {
     recordActiveMcpProviders: () => Promise<void>;
     actor?: Actor;
     runSource: Source;
-    sessionConversationId?: string;
-    sessionId?: string;
+    conversationId: string;
+    turnId: string;
     sessionRecordState: LoadedSessionRecordState;
     startedAtMs: number;
-    surface?: AgentTurnSurface;
+    surface: AgentTurnSurface;
 }
 interface ExpectedEndingTranslation {
     outcome?: AgentRunOutcome;
@@ -53,8 +53,8 @@ export declare function createResumeState(args: ResumeStateArgs): {
     getResumeSnapshot(currentMessages: PiMessage[]): PiMessage[];
     markTimedOut(): void;
     commitInput(): Promise<void>;
-    persistSafeBoundary(messages: PiMessage[], trailingMessageProvenance?: PiMessageProvenance[]): Promise<boolean>;
-    requireDurableInputCheckpoint(messages: PiMessage[], trailingMessageProvenance?: PiMessageProvenance[]): Promise<boolean>;
+    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

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

@@ -2,19 +2,18 @@
  * Run session restore.
  *
  * Loads the persisted turn session projection for one run slice before the
- * tool and prompt phases need it, resolving the durable conversation and
- * session identifiers from routing.
+ * tool and prompt phases need it.
  */
 import { loadTurnSessionRecord } from "@/chat/services/turn-session-record";
-import { type AgentRunRouting } from "@/chat/agent/request";
 type LoadedSessionRecordState = Awaited<ReturnType<typeof loadTurnSessionRecord>>;
 /** Restore the persisted session projection for one run slice. */
-export declare function restoreSessionRecord(routing: AgentRunRouting): Promise<{
+export declare function restoreSessionRecord(args: {
+    conversationId: string;
+    turnId: string;
+}): Promise<{
     existingSessionRecord: LoadedSessionRecordState["existingSessionRecord"];
     currentSliceId: number;
     resumedFromSessionRecord: boolean;
-    sessionConversationId?: string;
-    sessionId?: string;
     sessionRecordState: LoadedSessionRecordState;
 }>;
 export {};

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

@@ -52,12 +52,12 @@ interface ToolWiringArgs {
     requestHandoff?: ToolRuntimeContext["handoff"];
     resume: ResumeState;
     routing: AgentRunRouting;
-    sessionConversationId?: string;
-    sessionId?: string;
+    conversationId: string;
+    turnId: string;
     skillSandbox: SkillSandbox;
     spanContext: LogContext;
     state: AgentRunState;
-    surface?: AgentTurnSurface;
+    surface: AgentTurnSurface;
     syncLoadedSkillNamesForResume: () => void;
     toolCalls: string[];
     userInput: string;

package/dist/chat/agent-dispatch/runner.d.ts

@@ -1,9 +1,11 @@
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
+import { type ConversationTurnLifecycle } from "@/chat/conversations/turn-lifecycle";
 import { scheduleSessionCompletedPluginTasks } from "@/chat/plugins/task-runner";
 import { scheduleDispatchCallback } from "./signing";
 import type { DispatchCallback } from "./types";
 export interface AgentDispatchRunnerDeps {
     agentRunner: AgentRunner;
+    turnLifecycle?: ConversationTurnLifecycle;
     scheduleCallback?: typeof scheduleDispatchCallback;
     scheduleSessionCompletedPluginTasks?: typeof scheduleSessionCompletedPluginTasks;
 }

package/dist/chat/config.d.ts

@@ -1,4 +1,5 @@
 import { type TurnReasoningLevel } from "@/chat/reasoning-level";
+import { type ExecutionProfileConfig } from "@/chat/model-profile";
 /**
  * Buffer between the Vercel function timeout and the agent turn timeout so
  * Junior can abort, persist, and schedule continuation before host teardown.
@@ -8,8 +9,7 @@ export interface BotConfig {
     embeddingModelId: string;
     fastModelId: string;
     loadingMessages: string[];
-    modelId: string;
-    modelProfiles: Readonly<Record<string, string>>;
+    profiles: Readonly<Record<string, ExecutionProfileConfig>>;
     reasoningLevel?: TurnReasoningLevel;
     modelContextWindowTokens?: number;
     visionModelId?: string;