@sentry/junior 0.188.0 → 0.190.0

package/dist/{catalog-runtime-L4A6BJ3U.js → catalog-runtime-2OT7S3ZC.js}

@@ -1,14 +1,14 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-NZLZ4KYZ.js";
-import "./chunk-QIOUTXTZ.js";
+} from "./chunk-4PKEJK5B.js";
+import "./chunk-663DQH5W.js";
 import "./chunk-CEMMLV5L.js";
 import "./chunk-N7TMSOZH.js";
 import "./chunk-DWPN6SCH.js";
 import "./chunk-TXKUKMVO.js";
-import "./chunk-QIMN3FXL.js";
+import "./chunk-Y4WL4OYD.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-32XSSFZV.js";
+import "./chunk-JV7U4665.js";
 export {
   pluginCatalogRuntime
 };

package/dist/chat/actor.d.ts

@@ -69,9 +69,14 @@ export declare function createSlackActor(teamId: string, userId: string, profile
 export declare function parseStoredSlackActor(value: unknown): StoredSlackActor | undefined;
 /** Convert a runtime Slack actor into its durable session shape. */
 export declare function toStoredSlackActor(actor: SlackActor): StoredSlackActor;
-/** Resolve a Slack resume actor from stored profile data and the active actor. */
+/**
+ * Resolve a Slack resume actor from stored profile data and the active actor.
+ *
+ * TODO(dcramer): Require Actor and remove ID-only construction after no
+ * deployed Turn cursor can omit Actor.
+ */
 export declare function createSlackResumeActor(args: {
-    actor?: UserActor;
+    actor?: Actor;
     teamId: string;
     userId: string;
 }): SlackActor;

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

@@ -14,11 +14,9 @@ import { type AuthorizationPauseError } from "@/chat/services/auth-pause";
 import { type AgentTurnUsage } from "@/chat/usage";
 import { type AgentDurability } from "@/chat/agent/types";
 import type { PluginTurnContext } from "@/chat/plugins/prompt";
-import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 interface ResumeStateArgs {
     channelName?: string;
     destination: Destination;
-    destinationVisibility?: ConversationPrivacy;
     dispatchId?: string;
     durability: AgentDurability;
     recordActiveMcpProviders: () => Promise<void>;

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

@@ -2,7 +2,6 @@
 import type { Destination, ReplyAttribution, Source, SystemActor } from "@sentry/junior-plugin-api";
 import type { Location } from "@/chat/conversations/location";
 import type { LocationConfigurationService } 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";
@@ -101,13 +100,12 @@ export type AgentRunState = {
  *
  * The runner must commit the preceding agent boundary before invoking this
  * port; the accepted reply transaction appends only this message.
+ *
+ * TODO(dcramer): Remove Conversation Message persistence from Delivery
+ * implementations after the core Turn lifecycle stores each completed
+ * assistant Message.
  */
-export type Delivery = {
-    /** Location where this capability can send output, when outside Junior. */
-    location?: Location;
-    /** Send one accepted assistant message. */
-    send(message: AssistantMessage): void | Promise<void>;
-};
+export type Delivery = (message: AssistantMessage) => void | Promise<void>;
 /** Resume the agent turn after a transient or ambiguous delivery failure. */
 export declare class RetryableDeliveryError extends Error {
     constructor(cause: unknown);
@@ -178,9 +176,10 @@ export type AgentRun = {
     /** Credential authority projected from actor (plus optional subject). */
     credentialContext?: CredentialContext;
     source: Source;
+    /** Conversation Location available to this Run. */
+    location?: Location;
     destination: Destination;
     publishExternally?: boolean;
-    destinationVisibility?: ConversationPrivacy;
     surface?: AgentTurnSurface;
     dispatch?: AgentDispatch;
     /**
@@ -219,7 +218,7 @@ export declare function isAgentRunFeatureDisabled(disabledFeatures: readonly Age
 /** Resolve the explicit actor, dispatch actor, or credential actor for this run. */
 export declare function actorFromRun(run: Pick<AgentRun, "actor" | "dispatch" | "credentialContext">): Actor | undefined;
 /** Reject contradictory provider coordinates before the run touches state. */
-export declare function assertRunConsistency(run: Pick<AgentRun, "conversationId" | "source" | "destination" | "surface" | "publishExternally" | "actor" | "dispatch">): void;
+export declare function assertRunConsistency(run: Pick<AgentRun, "conversationId" | "source" | "location" | "destination" | "surface" | "actor" | "dispatch">): void;
 /** Route tool side effects to the tool channel when one overrides the destination. */
 export declare function toolInvocationDestination(run: Pick<AgentRun, "destination" | "toolChannelId">): Destination;
 /** Infer the run surface when the caller did not state one. */

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

@@ -12,7 +12,7 @@ import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
 import type { DispatchRecord, DispatchTurnContext, DispatchTurnResult } from "./types";
 export declare const AGENT_DISPATCH_MAX_AGE_MS: number;
-type DispatchRoutingContext = Pick<DispatchTurnContext, "credentialContext" | "destinationVisibility" | "dispatch" | "surface"> & {
+type DispatchRoutingContext = Pick<DispatchTurnContext, "credentialContext" | "dispatch" | "surface"> & {
     actor: DispatchRecord["actor"];
 };
 /** Restore the exact actor, credential, and dispatch routing for every slice. */
@@ -44,15 +44,6 @@ export declare function enqueueAgentDispatch(dispatch: DispatchRecord, options:
  * execution routing authority.
  */
 export declare function resolveAgentDispatchId(context: ConversationWorkerContext): Promise<string | undefined>;
-/**
- * Route leased work through dispatch execution when durable metadata owns it.
- *
- * The fallback retains ownership of every other conversation source.
- */
-export declare function createAgentDispatchWorkRouter(options: {
-    dispatchWorker: (context: ConversationWorkerContext, dispatchId: string) => Promise<ConversationWorkerResult>;
-    fallbackWorker: (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
-}): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
 /** Run one dispatch start or resume under the owning conversation lease. */
 export declare function createAgentDispatchConversationWorker(options: AgentDispatchConversationWorkerOptions): (context: ConversationWorkerContext, dispatchId: string) => Promise<ConversationWorkerResult>;
 export {};

package/dist/chat/agent-invocations/spawn.d.ts

@@ -7,6 +7,6 @@ type SpawnOptions = {
     queue: ConversationWorkQueue | (() => ConversationWorkQueue);
     state?: StateAdapter;
 };
-/** Bind one run's runtime-owned authority to the model-safe spawn capability. */
+/** Bind a Run's Actor and credentials to new Agent invocations. */
 export declare function bindSpawnAgent(run: AgentRun, options: SpawnOptions): SpawnAgent | undefined;
 export {};

package/dist/chat/agent-invocations/types.d.ts

@@ -85,10 +85,6 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         platform: z.ZodLiteral<"local">;
         conversationId: z.ZodString;
     }, z.core.$strict>], "platform">;
-    destinationVisibility: z.ZodOptional<z.ZodEnum<{
-        private: "private";
-        public: "public";
-    }>>;
     input: z.ZodString;
     invocationId: z.ZodString;
     mailboxStatus: z.ZodEnum<{
@@ -103,16 +99,10 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         xhigh: "xhigh";
         none: "none";
     }>>;
-    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        platform: z.ZodLiteral<"slack">;
+    source: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
@@ -120,29 +110,23 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
-        platform: z.ZodLiteral<"local">;
+        kind: z.ZodLiteral<"local">;
         visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
-        platform: z.ZodLiteral<"web">;
+        kind: z.ZodLiteral<"web">;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
         }>;
         conversationId: z.ZodString;
-    }, z.core.$strict>], "platform">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"resource_event">;
+        eventKey: z.ZodString;
+        eventType: z.ZodString;
+        identifier: z.ZodString;
+        namespace: z.ZodString;
+    }, z.core.$strict>], "kind">>;
     updatedAtMs: z.ZodNumber;
     status: z.ZodEnum<{
         pending: "pending";
@@ -228,10 +212,6 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         platform: z.ZodLiteral<"local">;
         conversationId: z.ZodString;
     }, z.core.$strict>], "platform">;
-    destinationVisibility: z.ZodOptional<z.ZodEnum<{
-        private: "private";
-        public: "public";
-    }>>;
     input: z.ZodString;
     invocationId: z.ZodString;
     mailboxStatus: z.ZodEnum<{
@@ -246,16 +226,10 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         xhigh: "xhigh";
         none: "none";
     }>>;
-    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        platform: z.ZodLiteral<"slack">;
+    source: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
@@ -263,29 +237,23 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
-        platform: z.ZodLiteral<"local">;
+        kind: z.ZodLiteral<"local">;
         visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
-        platform: z.ZodLiteral<"web">;
+        kind: z.ZodLiteral<"web">;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
         }>;
         conversationId: z.ZodString;
-    }, z.core.$strict>], "platform">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"resource_event">;
+        eventKey: z.ZodString;
+        eventType: z.ZodString;
+        identifier: z.ZodString;
+        namespace: z.ZodString;
+    }, z.core.$strict>], "kind">>;
     updatedAtMs: z.ZodNumber;
     result: z.ZodString;
     status: z.ZodLiteral<"completed">;
@@ -369,10 +337,6 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         platform: z.ZodLiteral<"local">;
         conversationId: z.ZodString;
     }, z.core.$strict>], "platform">;
-    destinationVisibility: z.ZodOptional<z.ZodEnum<{
-        private: "private";
-        public: "public";
-    }>>;
     input: z.ZodString;
     invocationId: z.ZodString;
     mailboxStatus: z.ZodEnum<{
@@ -387,16 +351,10 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         xhigh: "xhigh";
         none: "none";
     }>>;
-    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        platform: z.ZodLiteral<"slack">;
+    source: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
@@ -404,29 +362,23 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
-        platform: z.ZodLiteral<"local">;
+        kind: z.ZodLiteral<"local">;
         visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
-        platform: z.ZodLiteral<"web">;
+        kind: z.ZodLiteral<"web">;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
         }>;
         conversationId: z.ZodString;
-    }, z.core.$strict>], "platform">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"resource_event">;
+        eventKey: z.ZodString;
+        eventType: z.ZodString;
+        identifier: z.ZodString;
+        namespace: z.ZodString;
+    }, z.core.$strict>], "kind">>;
     updatedAtMs: z.ZodNumber;
     errorMessage: z.ZodString;
     status: z.ZodEnum<{
@@ -512,10 +464,6 @@ export declare const createAgentInvocationSchema: z.ZodObject<{
         platform: z.ZodLiteral<"local">;
         conversationId: z.ZodString;
     }, z.core.$strict>], "platform">;
-    destinationVisibility: z.ZodOptional<z.ZodEnum<{
-        private: "private";
-        public: "public";
-    }>>;
     idempotencyKey: z.ZodString;
     input: z.ZodString;
     parentConversationId: z.ZodString;
@@ -526,16 +474,10 @@ export declare const createAgentInvocationSchema: z.ZodObject<{
         xhigh: "xhigh";
         none: "none";
     }>>;
-    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        platform: z.ZodLiteral<"slack">;
+    source: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
@@ -543,29 +485,23 @@ export declare const createAgentInvocationSchema: z.ZodObject<{
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
-        platform: z.ZodLiteral<"local">;
+        kind: z.ZodLiteral<"local">;
         visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
-        location: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            provider: z.ZodString;
-            tenantId: z.ZodOptional<z.ZodString>;
-            providerId: z.ZodString;
-        }, z.core.$strict>>;
-        platform: z.ZodLiteral<"web">;
+        kind: z.ZodLiteral<"web">;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
         }>;
         conversationId: z.ZodString;
-    }, z.core.$strict>], "platform">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"resource_event">;
+        eventKey: z.ZodString;
+        eventType: z.ZodString;
+        identifier: z.ZodString;
+        namespace: z.ZodString;
+    }, z.core.$strict>], "kind">>;
 }, z.core.$strict>;
 export type AgentBinding = z.output<typeof agentBindingSchema>;
 export type AgentInvocation = z.output<typeof agentInvocationSchema>;

package/dist/chat/app/conversation-work.d.ts

@@ -4,26 +4,34 @@ import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 import type { VercelConversationWorkCallbackOptions } from "@/chat/task-execution/vercel-callback";
-import { type ApiTurnCancellation } from "@/chat/api-turns/cancellation";
 import { createSlackRuntime } from "./factory";
 import type { JuniorRuntimeServiceOverrides } from "./services";
+import { type ScheduleSessionCompletedPluginTasksOptions } from "@/chat/plugins/task-runner";
+type SlackRuntime = ReturnType<typeof createSlackRuntime>;
 interface ConversationWorkOptions {
     agentRunner: AgentRunner;
     conversationStore: ConversationStore;
     getSlackAdapter: () => SlackAdapter;
     queue: ConversationWorkQueue;
+    /**
+     * Optional plugin-task send path for completed Turns.
+     * Production omits this and uses the default Vercel queue sender.
+     */
+    sendPluginTask?: ScheduleSessionCompletedPluginTasksOptions["send"];
     services?: JuniorRuntimeServiceOverrides;
     state?: StateAdapter;
+    /**
+     * Optional wrapper around the composed Slack runtime.
+     * Eval harnesses use this so worker Delivery lands on TestThreads.
+     */
+    wrapRuntime?: (runtime: SlackRuntime) => SlackRuntime;
 }
-export type ConversationWorkCallbackOptions = VercelConversationWorkCallbackOptions & {
-    /** App-scoped Turn cancellation for Conversation API request handlers. */
-    apiTurnCancellation?: ApiTurnCancellation;
-};
+export type ConversationWorkCallbackOptions = VercelConversationWorkCallbackOptions;
 /**
- * Compose conversation work once for production and integration tests.
- * Environment-specific queue, state, Slack, and agent adapters stop here.
+ * Build conversation work once for production and integration tests.
+ * The app chooses the queue, state, Slack, and agent values here.
  */
 export declare function createConversationWork(options: ConversationWorkOptions): ConversationWorkCallbackOptions & {
-    runtime: ReturnType<typeof createSlackRuntime>;
+    runtime: SlackRuntime;
 };
 export {};

package/dist/chat/conversation-privacy.d.ts

@@ -2,21 +2,21 @@ import type { AssistantMessage, Message } from "@earendil-works/pi-ai";
 export type ConversationPrivacy = "public" | "private";
 type TraceAttributeValue = string | number | boolean | string[];
 /**
- * Resolve whether a conversation may expose raw payloads.
+ * Resolve whether a Conversation may expose full transcript and tool data.
  *
- * Explicit destination visibility is authoritative. Missing visibility is
- * observable and fails closed without inferring from identifiers.
+ * Read visibility from the stored Conversation. If it is missing, warn and
+ * treat the Conversation as private. Do not infer visibility from identifiers.
  */
 export declare function resolveConversationPrivacy(input: {
-    /** Live or persisted destination visibility, when the caller has one. */
+    /** Stored Conversation visibility, when known. */
     visibility?: ConversationPrivacy | "direct" | "unknown";
 }): ConversationPrivacy;
-/** Gate raw transcript/tool payload exposure to public conversations. */
+/** Return whether a public Conversation may expose transcript and tool data. */
 export declare function canExposeConversationPayload(input: {
-    /** Live or persisted destination visibility, when the caller has one. */
+    /** Conversation visibility, when known. */
     visibility?: ConversationPrivacy | "direct" | "unknown";
 }): boolean;
-/** Return the privacy mode bound to the current agent turn. */
+/** Return privacy for the current agent Turn. */
 export declare function getCurrentConversationPrivacy(): ConversationPrivacy | undefined;
 /** Bind one conversation privacy mode to all async work in a turn. */
 export declare function runWithConversationPrivacy<T>(privacy: ConversationPrivacy, callback: () => T): T;

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

@@ -0,0 +1,12 @@
+import { type Destination } from "@sentry/junior-plugin-api";
+/**
+ * Keep a stored Destination, or create the temporary local Destination.
+ *
+ * TODO(dcramer): Delete this module after Conversation and AgentRun use
+ * Location, and web and resource-event Turns no longer need a local
+ * Destination.
+ */
+export declare function resolveConversationDestination(args: {
+    conversationId: string;
+    existing?: Destination;
+}): Destination;

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

@@ -3,7 +3,7 @@ import { type ConversationMessageProvenance } from "@/chat/conversations/provena
 import type { AuthorizationKind, ConversationEvent } from "@/chat/conversations/history";
 import type { RepositoryInstructions } from "@/chat/repository-instructions";
 import type { JuniorSqlDatabase } from "@/db/db";
-import { type ProviderConversationBinding } from "@/chat/conversations/sql/bindings";
+import { type ProviderConversationReference } from "@/chat/conversations/sql/bindings";
 import { type PiConversationEventProjection, type PiConversationProjection } from "@/chat/pi/conversation-events";
 import type { ModelProfile } from "@/chat/model-profile";
 import type { TurnReasoningLevel } from "@/chat/reasoning-level";
@@ -90,7 +90,7 @@ export declare function commitAcceptedReply(args: {
     conversation: ThreadConversationState;
     conversationMessageId: string;
     conversationId: string;
-    providerConversationBindings?: Array<Omit<ProviderConversationBinding, "conversationId">>;
+    providerConversationBindings?: ProviderConversationReference[];
     repliedAtMs?: number;
 }): Promise<void>;
 /** Record a successful MCP provider connection for one credential subject without duplicating it. */

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

@@ -1,9 +1,18 @@
+import type { Destination } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import { type Location } from "@/chat/conversations/location";
+import type { SessionSource } from "@/chat/source";
 import type { juniorDestinations } from "@/db/schema";
 type LocationRow = typeof juniorDestinations.$inferSelect;
-/** Project one supported provider location from its linked SQL row. */
-export declare function locationFromRow(row: LocationRow | null): Location | undefined;
-/** Resolve conversation privacy from one linked provider-location row. */
-export declare function privacyFromLocationRow(row: LocationRow | null): ConversationPrivacy | undefined;
+/** Build the complete Location for one Conversation SQL write. */
+export declare function locationForWrite(args: {
+    destination: Destination | undefined;
+    destinationId: string | undefined;
+    location: Location | undefined;
+    sessionSource: SessionSource | undefined;
+}): Location | undefined;
+/** Read one complete Location from SQL. */
+export declare function locationFromRow(value: unknown, row: LocationRow | null, sessionSource: SessionSource | undefined): Location | undefined;
+/** Read confirmed visibility from one linked Location row. */
+export declare function visibilityFromLocationRow(row: LocationRow | null): ConversationPrivacy | undefined;
 export {};

package/dist/chat/{api-turns → conversations}/stop.d.ts

@@ -2,8 +2,8 @@ import type { StateAdapter } from "chat";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
 import { type StopConversationWorkResult } from "@/chat/task-execution/store";
-/** Stop the current API Turn and wake an idle durable resume when needed. */
-export declare function stopApiConversationTurn(args: {
+/** Stop the current Conversation Turn and wake an idle resume when needed. */
+export declare function stopConversationTurn(args: {
     conversationId: string;
     conversationStore?: ConversationStore;
     nowMs?: number;

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

@@ -18,9 +18,9 @@ export interface ConversationExecution {
  *
  * The final interface stores zero or one complete Location here. No Location
  * means the Conversation stays in Junior's API and UI. A Location names the
- * outside place where a provider can deliver the Conversation. Source may also
- * contain this Location so the agent can use it. Delivery contains it when
- * output may be sent there. Only Delivery allows output to be sent.
+ * outside place where a provider can deliver the Conversation. A Run carries
+ * this Location when the agent or tools need it. Source stays about the input.
+ * Delivery is created for the Location and allows output to be sent there.
  *
  * `destination` and `sessionSource` temporarily duplicate parts of that model.
  * Their field TODOs state when each legacy copy can be removed.
@@ -58,7 +58,7 @@ export interface Conversation {
      * rather than privacy-redacted (`../../../../../policies/data-redaction.md`).
      */
     transcriptPurgedAtMs?: number;
-    /** Persisted destination visibility. Undefined means no destination row exists. */
+    /** Confirmed Conversation visibility. Undefined means no confirmation exists. */
     visibility?: ConversationPrivacy;
 }
 /** Persist and read durable conversation metadata for reporting surfaces. */

package/dist/chat/conversations/structured-events.d.ts

@@ -19,7 +19,7 @@ export declare const authenticationUnlinkedEvent: import("@sentry/junior-plugin-
 }>;
 /** Junior-owned AGENTS.md bootstrap transition for the dashboard timeline. */
 export declare const agentsInstructionsUpdatedEvent: import("@sentry/junior-plugin-api").DefinedConversationEvent<{
-    action: "loaded" | "replaced" | "cleared";
+    action: "cleared" | "loaded" | "replaced";
     fingerprint: string;
     sources: {
         content: string;

package/dist/chat/{api-turns/authorization.d.ts → conversations/web-authorization.d.ts}

@@ -1,4 +1,5 @@
 import type { OAuthAuthorizationRequest } from "@/chat/oauth-authorization";
+/** Pending web authorization saved for one Actor and Conversation. */
 export interface WebAuthorizationState extends OAuthAuthorizationRequest {
     actorId: string;
     conversationId: string;