@sentry/junior 0.179.0 → 0.181.0

package/dist/catalog-runtime-PMQWNIXA.js

@@ -0,0 +1,14 @@
+import {
+  pluginCatalogRuntime
+} from "./chunk-HEBMSITT.js";
+import "./chunk-4IX32NSL.js";
+import "./chunk-CEMMLV5L.js";
+import "./chunk-N7TMSOZH.js";
+import "./chunk-DWPN6SCH.js";
+import "./chunk-TXKUKMVO.js";
+import "./chunk-EBMRB6Z6.js";
+import "./chunk-PEQXYSSE.js";
+import "./chunk-TJHSAHQN.js";
+export {
+  pluginCatalogRuntime
+};

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

@@ -31,8 +31,6 @@ export interface AgentSandboxOptions {
     actor?: Actor;
     locationConfiguration?: LocationConfigurationService;
     configurationValues: Record<string, unknown>;
-    /** Durable-worker soft yield for long Workspace snapshot waits. */
-    shouldYield?: () => boolean;
     getActiveSkill(): Skill | null;
     prepareSandbox(workspace: SandboxWorkspace): void | Promise<void>;
     prepareWorkspace?(workspace: SandboxWorkspace, recipe: Workspace, signal?: AbortSignal): Promise<void>;

package/dist/chat/api-turns/routing.d.ts

@@ -10,6 +10,10 @@ declare const apiTurnMailboxMetadataSchema: z.ZodObject<{
     messageId: z.ZodString;
 }, z.core.$strict>;
 export type ApiTurnMailboxMetadata = z.output<typeof apiTurnMailboxMetadataSchema>;
+/** Return the active root API Turn for one Conversation, if it has one. */
+export declare function getActiveApiTurnId(conversationId: string): Promise<string | undefined>;
+/** Return the idle auth-paused root API Turn for one Conversation. */
+export declare function getAuthPausedApiTurnId(conversationId: string): Promise<string | undefined>;
 /**
  * Resolve API Turn work from mailbox metadata or an active checkpoint.
  *

package/dist/chat/api-turns/work.d.ts

@@ -47,6 +47,11 @@ export declare function createApiConversationId(args: {
     actorEmail: string;
     idempotencyKey: string;
 }): string;
+/** Build the retry-stable Message id used by one API mailbox request. */
+export declare function apiConversationMessageId(args: {
+    conversationId: string;
+    idempotencyKey: string;
+}): string;
 /** Stable turn id for one API mailbox message (matches getTurnUserMessage). */
 export declare function apiTurnIdForMessage(messageId: string): string;
 /** Rebuild the dashboard actor from durable conversation identity. */

package/dist/chat/config.d.ts

@@ -1,5 +1,5 @@
 import { type TurnReasoningLevel } from "@/chat/reasoning-level";
-import { type ExecutionProfileConfig } from "@/chat/model-profile";
+import { type ModelProfileConfig, type ModelProfile } from "@/chat/model-profile";
 export declare const DEFAULT_SQL_STATEMENT_TIMEOUT_MS = 30000;
 /**
  * Buffer between the Vercel function timeout and the agent turn timeout so
@@ -11,12 +11,13 @@ export declare const CONVERSATION_WORK_SOFT_YIELD_BUFFER_SECONDS = 40;
 export interface BotConfig {
     contextWindowTokens: number;
     crossActorMidRunMode: CrossActorMidRunMode;
+    defaultProfile: ModelProfile;
     embeddingModelId: string;
     fastModelId: string;
     guardianModelId: string;
     imageGenerationModelId: string;
     loadingMessages: string[];
-    profiles: Readonly<Record<string, ExecutionProfileConfig>>;
+    profiles: Readonly<Record<string, ModelProfileConfig>>;
     reasoningLevel?: TurnReasoningLevel;
     visionModelId?: string;
     maxSlicesPerTurn: number;
@@ -73,6 +74,8 @@ export interface SlackReactionConfig {
     completedReactionEmoji: string;
     processingReactionEmoji: string;
 }
+/** Apply profiles from createApp(). */
+export declare function setProfiles(profiles: Readonly<Record<string, string>> | undefined, defaultProfile: string | undefined): void;
 /** Return the current Slack reaction emoji config. */
 export declare function getSlackReactionConfig(): SlackReactionConfig;
 /** Apply Slack reaction emoji overrides from createApp() options, validating names. */

package/dist/chat/configuration/defaults.d.ts

@@ -1,4 +1,4 @@
 /** Store install-wide configuration defaults. */
-export declare function setConfigDefaults(defaults: Record<string, unknown> | undefined): void;
+export declare function setConfigDefaults(defaults: unknown): void;
 /** Return the install-wide configuration defaults (empty object when none set). */
 export declare function getConfigDefaults(): Record<string, unknown>;

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

@@ -145,14 +145,16 @@ export declare function recordSubscribedReplyRoute(args: {
     shouldReply: boolean;
     shouldUnsubscribe?: boolean;
 }): Promise<void>;
-/** Load a previously selected execution profile for a resumed turn. */
+/** Load a previously selected model profile for a resumed turn. */
 export declare function loadTurnRoute(args: {
     conversationId: string;
     turnId: string;
-}): Promise<Extract<ConversationEvent["data"], {
+}): Promise<(Extract<ConversationEvent["data"], {
     type: "turn_routed";
-}> | undefined>;
-/** Record the execution profile selected for one turn without changing agent history. */
+}> & {
+    seq: number;
+}) | undefined>;
+/** Record the model profile selected for one turn without changing agent history. */
 export declare function recordTurnRoute(args: {
     conversationId: string;
     turnId: string;

package/dist/chat/ingress/message-router.d.ts

@@ -1,5 +1,8 @@
+import { Message } from "chat";
 export type ThreadMessageKind = "new_mention" | "subscribed_message";
 /** Derive canonical Slack thread IDs from the raw event payload. */
+/** Rebuild a Message onto a normalized Slack thread id. */
+export declare function withNormalizedThreadId(message: Message, threadId: string): Message;
 export declare function normalizeIncomingSlackThreadId(threadId: string, message: unknown): string;
 /** Classify an incoming message as a mention or subscribed message. */
 export declare function determineThreadMessageKind(args: {

package/dist/chat/model-profile.d.ts

@@ -1,14 +1,12 @@
 import { z } from "zod";
 import type { BotConfig } from "@/chat/config";
 import type { TurnReasoningLevel } from "@/chat/reasoning-level";
-export declare const STANDARD_MODEL_PROFILE = "standard";
-export declare const DEFAULT_HANDOFF_MODEL_PROFILE = "handoff";
 /** Keep durable profile names stable and safe to expose in tool schemas. */
 export declare const modelProfileSchema: z.ZodString;
-/** A configured model role rather than a provider-specific model id. */
+/** A configured name for a model. */
 export type ModelProfile = z.output<typeof modelProfileSchema>;
-/** Runtime configuration for one named execution profile. */
-export interface ExecutionProfileConfig {
+/** Runtime configuration for one named model profile. */
+export interface ModelProfileConfig {
     modelId: string;
     reasoningLevel?: TurnReasoningLevel;
 }
@@ -16,9 +14,9 @@ export interface ExecutionProfileConfig {
 export declare class ModelProfileNotConfiguredError extends Error {
     constructor(profile: ModelProfile);
 }
-/** Resolve a stable model profile through the host-owned model catalog. */
+/** Resolve a model id from a configured profile. */
 export declare function modelIdForProfile(config: BotConfig, profile: ModelProfile): string;
-/** Resolve the standard execution profile's model. */
-export declare function standardModelId(config: BotConfig): string;
-/** Resolve a stable model profile through the host-owned profile catalog. */
-export declare function profileConfig(config: BotConfig, profile: ModelProfile): ExecutionProfileConfig;
+/** Resolve the configured default profile's model. */
+export declare function defaultModelId(config: BotConfig): string;
+/** Return one configured profile. */
+export declare function profileConfig(config: BotConfig, profile: ModelProfile): ModelProfileConfig;

package/dist/chat/pi/conversation-events.d.ts

@@ -13,7 +13,7 @@ export interface PiConversationProjection {
     messages: PiMessage[];
     provenance: ConversationMessageProvenance[];
     modelProfile: ModelProfile;
-    modelId: string | undefined;
+    replacementSeq: number | undefined;
 }
 /** Pi context with the source event sequence for every projected message. */
 export interface PiConversationEventProjection extends PiConversationProjection {
@@ -32,6 +32,7 @@ export declare function piMessageFromHistoryItem(data: AgentHistoryItem): PiMess
  * Host-only events are filtered, completed authorization becomes a synthetic
  * observation, and `maxSeq` reproduces an exact committed boundary.
  */
-export declare function projectConversationEvents(events: ConversationEvent[], options?: {
+export declare function projectConversationEvents(events: ConversationEvent[], options: {
+    defaultProfile: ModelProfile;
     maxSeq?: number;
 }): PiConversationEventProjection;

package/dist/chat/plugins/agent-hooks.d.ts

@@ -53,7 +53,7 @@ export declare function applyPluginFormatMarkdown(text: string): string;
 export declare function getPluginSystemPromptContributions(source: ToolRuntimeContext["source"]): Promise<PluginPromptContributionContext[]>;
 /** Collect request-scoped plugin prompt contributions. */
 export declare function getPluginUserPromptContributions(args: {
-    context: Pick<ToolRuntimeContext, "conversationId" | "destination" | "actor" | "source" | "userText">;
+    context: Pick<ToolRuntimeContext, "conversationId" | "locationId" | "destination" | "actor" | "resolveActorIdentity" | "source" | "userText">;
     turnId?: string;
 }): Promise<PluginPromptContributionContext[]>;
 /** Collect turn-scoped tools exposed by plugins. */

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

@@ -1,5 +1,42 @@
-import { type PluginTaskQueueMessage } from "./task-message";
+import { z } from "zod";
+/** Deploy topic name. Keep stable for Vercel queue wiring. */
 export declare const PLUGIN_TASK_QUEUE_TOPIC = "junior_plugin_tasks";
-export declare const PLUGIN_TASK_QUEUE_RETENTION_SECONDS: number;
-/** Send one plugin task wakeup through Vercel Queues. */
+export declare const pluginTaskParamsSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export type PluginTaskParams = z.output<typeof pluginTaskParamsSchema>;
+export declare const pluginTaskQueueMessageSchema: z.ZodObject<{
+    name: z.ZodString;
+    params: z.ZodObject<{
+        conversationId: z.ZodString;
+        sessionId: z.ZodString;
+    }, z.core.$strict>;
+    plugin: z.ZodString;
+}, z.core.$strict>;
+export type PluginTaskQueueMessage = z.output<typeof pluginTaskQueueMessageSchema>;
+/** Build the stable id used for delivery dedupe and tracing. */
+export declare function pluginTaskId(args: {
+    name: string;
+    params: PluginTaskParams;
+    plugin: string;
+}): string;
+/** Sign a plugin task message for tests and local checks. */
+export declare function signPluginTaskQueueMessage(message: PluginTaskQueueMessage, nowMs?: number): {
+    name: string;
+    params: {
+        conversationId: string;
+        sessionId: string;
+    };
+    plugin: string;
+} & {
+    signature: string;
+    signatureVersion: "v1";
+    signedAtMs: number;
+};
+/** Send one plugin task through the shared signed delivery path. */
 export declare function sendVercelPluginTask(message: PluginTaskQueueMessage): Promise<void>;
+/** Create the HTTP callback for plugin tasks. */
+export declare function createVercelPluginTaskCallback(): (request: Request) => Promise<Response>;
+/** Register the local-dev consumer for plugin tasks. */
+export declare function registerVercelPluginTaskDevConsumer(): (() => void) | undefined;

package/dist/chat/plugins/task-runner.d.ts

@@ -1,4 +1,4 @@
-import { type PluginTaskParams, type PluginTaskQueueMessage } from "./task-message";
+import { type PluginTaskParams, type PluginTaskQueueMessage } from "./task-queue";
 export interface ScheduleSessionCompletedPluginTasksOptions {
     send?: (message: PluginTaskQueueMessage) => Promise<void>;
 }

package/dist/chat/queue/callback.d.ts

@@ -0,0 +1,26 @@
+/** Shared Vercel Queue callback wiring for signed messages. */
+import { type MessageMetadata } from "@vercel/queue";
+import type { QueueRejectReason, QueueVerifyResult } from "./sign";
+export interface QueueCallbackOptions<Message> {
+    consumerGroup: string;
+    /** Use `null` when durable state already owns the attempt limit. */
+    maxDeliveries: number | null;
+    onRejected(reason: QueueRejectReason | string, metadata: MessageMetadata, error?: unknown): void;
+    permanentError?: (error: unknown) => string | undefined;
+    run(message: Message, metadata: MessageMetadata): Promise<void>;
+    /**
+     * Acknowledge without checking or running the message.
+     * Use for kill switches that must not depend on signing secrets.
+     */
+    skip?: (metadata: MessageMetadata) => boolean;
+    topic: string;
+    verify(value: unknown): QueueVerifyResult<Message>;
+    visibilityTimeoutSeconds?: number;
+}
+/** Build the HTTP callback and local-dev consumer for one signed queue. */
+export declare function queueCallback<Message>(options: QueueCallbackOptions<Message>): {
+    create: () => (requestOrEvent: Request | {
+        request: Request;
+    }) => Promise<Response>;
+    registerDev: () => (() => void) | undefined;
+};

package/dist/chat/queue/sign.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const QUEUE_SIGNATURE_MAX_AGE_MS: number;
+export type QueueRejectReason = "expired" | "malformed" | "signature_mismatch";
+export type QueueVerifyResult<Message> = {
+    status: "verified";
+    message: Message;
+} | {
+    status: "rejected";
+    reason: QueueRejectReason;
+} | {
+    status: "unavailable";
+    reason: "invalid_clock" | "missing_secret";
+};
+export interface QueueSignConfig<Message extends object, Version extends string> {
+    context: string;
+    maxAgeMs?: number;
+    schema: z.ZodType<Message>;
+    /** Kept for jobs that already signed with `:` instead of null bytes. */
+    separator?: string;
+    signatureVersion: Version;
+    parts(message: Message): readonly string[];
+}
+/** Sign one queue message. */
+export declare function signQueueMessage<Message extends object, Version extends string>(config: QueueSignConfig<Message, Version>, message: Message, nowMs?: number): Message & {
+    signature: string;
+    signatureVersion: Version;
+    signedAtMs: number;
+};
+/** Check one signed queue message. */
+export declare function verifyQueueMessage<Message extends object, Version extends string>(config: QueueSignConfig<Message, Version>, value: unknown, nowMs?: number): QueueVerifyResult<Message>;

package/dist/chat/sandbox/sandbox.d.ts

@@ -33,8 +33,6 @@ export interface SandboxOptions {
     skills: SkillMetadata[];
     referenceFiles: string[];
     timeoutMs?: number;
-    /** Durable-worker soft yield for long Workspace snapshot waits. */
-    shouldYield?: () => boolean;
     traceContext?: LogContext;
     tracePropagation?: SandboxEgressTracePropagationConfig;
     credentialEgress?: CredentialContext;

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

@@ -38,8 +38,6 @@ interface SandboxRuntimeOptions {
     skills: SkillMetadata[];
     referenceFiles: string[];
     timeoutMs?: number;
-    /** Durable-worker soft yield for long Workspace snapshot waits. */
-    shouldYield?: () => boolean;
     traceContext?: LogContext;
     commandEnv?: () => Promise<Record<string, string>>;
     createNetworkPolicy?: (egressId: string, traceHeaders?: TracePropagationHeaders) => NetworkPolicy | undefined;

package/dist/chat/sandbox/skill-sync.d.ts

@@ -8,7 +8,7 @@ export declare function resolveHostDataPath(referenceFiles: string[], sandboxPat
 export declare function isHostFileMissingError(error: unknown): boolean;
 /** Copy the current skill set and reference files into a sandbox. */
 export declare function syncSkillsToSandbox(params: {
-    sandbox: SandboxSession;
+    sandbox: Pick<SandboxSession, "mkDir" | "writeFiles">;
     skills: SkillMetadata[];
     referenceFiles?: string[];
     withSpan: <T>(name: string, op: string, attributes: Record<string, unknown>, callback: () => Promise<T>) => Promise<T>;

package/dist/chat/sandbox/snapshot/events.d.ts

@@ -0,0 +1,23 @@
+import type { ResourceEvent, SubscribableResource } from "@sentry/junior-plugin-api";
+export declare const WORKSPACE_SNAPSHOT_NAMESPACE = "junior";
+export declare const WORKSPACE_SNAPSHOT_RESOURCE_TYPE = "workspace_snapshot";
+export declare const WORKSPACE_SNAPSHOT_READY_EVENT = "workspace_snapshot.ready";
+export declare const WORKSPACE_SNAPSHOT_FAILED_EVENT = "workspace_snapshot.failed";
+/** Describe the events that report when a snapshot build ends. */
+export declare function workspaceSnapshotWatch(input: {
+    workspaceId: string;
+    workspaceName: string;
+}): SubscribableResource;
+type WorkspaceSnapshotResult = {
+    workspaceId: string;
+    resultId: string;
+    occurredAtMs?: number;
+} & ({
+    status: "ready";
+} | {
+    status: "failed";
+    error?: string | null;
+});
+/** Report that a Workspace snapshot build is ready or failed. */
+export declare function workspaceSnapshotFinishedEvent(input: WorkspaceSnapshotResult): ResourceEvent;
+export {};

package/dist/chat/sandbox/snapshot/job-callback.d.ts

@@ -0,0 +1,5 @@
+export declare const WORKSPACE_SNAPSHOT_JOB_DEV_CONSUMER_GROUP = "junior_workspace_snapshots_dev";
+/** Create the HTTP route for snapshot build messages. */
+export declare function createVercelWorkspaceSnapshotJobCallback(): (request: Request) => Promise<Response>;
+/** Receive snapshot build messages during local development. */
+export declare function registerVercelWorkspaceSnapshotJobDevConsumer(): (() => void) | undefined;

package/dist/chat/sandbox/snapshot/job-queue.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC = "junior_workspace_snapshots";
+declare const workspaceSnapshotJobMessageSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    profileHash: z.ZodString;
+}, z.core.$strict>;
+export type WorkspaceSnapshotJobMessage = z.output<typeof workspaceSnapshotJobMessageSchema>;
+/** Sign a Workspace snapshot job for tests and local checks. */
+export declare function signWorkspaceSnapshotJobMessage(message: WorkspaceSnapshotJobMessage, nowMs?: number): {
+    workspaceId: string;
+    profileHash: string;
+} & {
+    signature: string;
+    signatureVersion: "v1";
+    signedAtMs: number;
+};
+/** Check that a recent queue message came from Junior. */
+export declare function verifyWorkspaceSnapshotJobMessage(value: unknown, nowMs?: number): import("@/chat/queue/sign").QueueVerifyResult<{
+    workspaceId: string;
+    profileHash: string;
+}>;
+/** Send a job unless the same Workspace build already has one. */
+export declare function sendWorkspaceSnapshotJob(message: WorkspaceSnapshotJobMessage): Promise<void>;
+/** Send the next job for a Workspace build that is still running. */
+export declare function sendNextWorkspaceSnapshotJob(message: WorkspaceSnapshotJobMessage): Promise<void>;
+export {};

package/dist/chat/sandbox/snapshot/job-runner.d.ts

@@ -0,0 +1,11 @@
+import type { Workspace } from "@/chat/workspaces/types";
+import { type WorkspaceSnapshotJobMessage } from "./job-queue";
+/** Run a snapshot build and send another job if it needs more time. */
+export declare function processWorkspaceSnapshotJob(message: WorkspaceSnapshotJobMessage, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
+/** Start a snapshot build when no ready snapshot exists. */
+export declare function ensureWorkspaceSnapshotBuild(input: {
+    workspace: Workspace;
+    sendAgain?: boolean;
+}): Promise<"ready" | "building">;

package/dist/chat/sandbox/snapshot/not-ready-error.d.ts

@@ -0,0 +1,6 @@
+/** Report that a Workspace snapshot is not ready to use. */
+export declare class WorkspaceSnapshotNotReadyError extends Error {
+    constructor(workspaceName: string);
+}
+/** Check an error and its causes for a snapshot that is not ready. */
+export declare function isWorkspaceSnapshotNotReadyError(error: unknown): boolean;

package/dist/chat/sandbox/snapshot/workspace.d.ts

@@ -1,16 +1,22 @@
 import type { Snapshot } from "@/chat/sandbox/snapshot/resolve";
 import { type SandboxSession } from "@/chat/sandbox/workspace";
 import type { Workspace } from "@/chat/workspaces/types";
+/** Return the ready snapshot or report that the Workspace must build one. */
+export declare function requireReadyWorkspaceSnapshot(params: {
+    workspace: Workspace;
+    runtime: string;
+    staleSnapshotId?: string;
+}): Promise<Snapshot>;
 /**
- * Resolve a Workspace snapshot through resumable execution slices.
- * Cold builds have one shared one-hour budget across every execution slice.
+ * Continue a Workspace snapshot build from its saved state.
+ * The full build can run for up to one hour.
  */
 export declare function resolveWorkspaceSnapshot(params: {
     workspace: Workspace;
     runtime: string;
     staleSnapshotId?: string;
     signal?: AbortSignal;
-    shouldYield?: () => boolean;
+    shouldStop?: () => boolean;
     applyNetworkPolicy(sandbox: SandboxSession): Promise<unknown>;
     prepareRepositories?(sandbox: SandboxSession, workspace: Workspace, signal?: AbortSignal): Promise<void>;
     removeCredentialRoute: boolean;

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

@@ -2,8 +2,8 @@ import type { ThinkingLevel as AgentThinkingLevel } from "@earendil-works/pi-age
 import type { ThinkingLevel as ProviderThinkingLevel } from "@earendil-works/pi-ai";
 import { z } from "zod";
 import { type TurnReasoningLevel } from "@/chat/reasoning-level";
-import { type ModelProfile, type ExecutionProfileConfig } from "@/chat/model-profile";
-declare function createTurnRouteSchema(profiles: Readonly<Record<string, ExecutionProfileConfig>>): z.ZodObject<{
+import { type ModelProfile, type ModelProfileConfig } from "@/chat/model-profile";
+declare function createTurnRouteSchema(profiles: Readonly<Record<string, ModelProfileConfig>>): z.ZodObject<{
     reasoning_level: z.ZodEnum<{
         low: "low";
         medium: "medium";
@@ -49,9 +49,10 @@ export declare function selectTurnRoute(args: {
         threadId?: string;
     };
     currentTurnBlocks?: string[];
+    defaultProfile: ModelProfile;
     fastModelId: string;
     messageText: string;
-    profiles: Readonly<Record<string, ExecutionProfileConfig>>;
+    profiles: Readonly<Record<string, ModelProfileConfig>>;
 }): Promise<TurnRoute>;
 /** Convert a routing bucket into the Pi Agent reasoning setting for a main turn. */
 export declare function toPiReasoningLevel(level: TurnRoute["reasoningLevel"]): AgentThinkingLevel | "off";

package/dist/chat/services/turn-session-routing.d.ts

@@ -8,6 +8,7 @@ import type { Destination, Source } from "@sentry/junior-plugin-api";
 import type { ConversationStore } from "@/chat/conversations/store";
 export interface TurnSessionRouting {
     destination: Destination;
+    locationId?: string;
     source: Source;
 }
 /** Require conversation destination and session source from SQL. */

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

@@ -1,28 +1,17 @@
-import { z } from "zod";
+import { type QueueVerifyResult } from "@/chat/queue/sign";
 import { type ConversationQueueMessage } from "./queue";
 export declare const CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS: number;
-declare const signedConversationQueueMessageSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<2>;
-    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";
-} | {
-    reason: "expired" | "malformed" | "signature_mismatch";
-    status: "rejected";
-} | {
-    reason: "invalid_clock" | "missing_secret";
-    status: "unavailable";
-};
+export type ConversationQueueMessageVerificationResult = QueueVerifyResult<ConversationQueueMessage>;
 /** Sign a conversation queue payload before it crosses the public callback route. */
-export declare function signConversationQueueMessage(message: ConversationQueueMessage, nowMs?: number): SignedConversationQueueMessage;
+export declare function signConversationQueueMessage(message: ConversationQueueMessage, nowMs?: number): {
+    schemaVersion: 2;
+    conversationId: string;
+} & {
+    signature: string;
+    signatureVersion: "v2";
+    signedAtMs: number;
+};
 /** 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;
-export {};

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

@@ -86,6 +86,11 @@ export interface Lease {
     lastCheckInAtMs: number;
     token: string;
 }
+/** Durable request to stop the current Conversation run. */
+export interface ConversationStop {
+    inboundMessageIds: string[];
+    runId: string;
+}
 export interface ConversationExecution {
     inboundMessageIds: string[];
     lastCheckpointAtMs?: number;
@@ -97,6 +102,7 @@ export interface ConversationExecution {
     pendingMessages: InboundMessage[];
     runId?: string;
     status: ExecutionStatus;
+    stop?: ConversationStop;
     updatedAtMs?: number;
 }
 export interface Conversation {
@@ -143,6 +149,26 @@ export interface AppendInboundMessageResult {
 export interface AppendAndEnqueueInboundMessageResult extends AppendInboundMessageResult {
     queueMessageId?: string;
 }
+/** Result of requesting that the current Conversation run stop. */
+export type StopConversationWorkResult = {
+    status: "no_work";
+} | {
+    runId: string;
+    status: "requested";
+};
+/** Result of clearing one stop observed by the matching leased run. */
+export interface CompleteConversationStopResult {
+    status: "cleared" | "lost_lease" | "none";
+    removedInboundMessageIds: string[];
+}
+/** Result of an append that rejects new work while a Conversation is runnable. */
+export type AppendExclusiveInboundMessageResult = AppendInboundMessageResult | {
+    status: "active";
+};
+/** Exclusive append result with an optional queue delivery id. */
+export type AppendAndEnqueueExclusiveInboundMessageResult = AppendAndEnqueueInboundMessageResult | {
+    status: "active";
+};
 export interface RequestConversationWorkResult {
     status: "created" | "updated";
 }
@@ -168,6 +194,12 @@ export declare function appendInboundMessage(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<AppendInboundMessageResult>;
+/** Append only when the Conversation has no other runnable work. */
+export declare function appendExclusiveInboundMessage(args: {
+    message: InboundMessage;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<AppendExclusiveInboundMessageResult>;
 /** Mark a conversation runnable when there is no new mailbox message. */
 export declare function requestConversationWork(args: {
     conversationId: string;
@@ -256,6 +288,20 @@ export declare function ackMessages(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
+/** Persist a stop request for the current run without process affinity. */
+export declare function stopConversationWork(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<StopConversationWorkResult>;
+/** Clear one observed stop request and discard older human-facing mailbox work. */
+export declare function completeConversationStop(args: {
+    conversationId: string;
+    leaseToken: string;
+    nowMs?: number;
+    runId: string;
+    state?: StateAdapter;
+}): Promise<CompleteConversationStopResult>;
 /** Cancel human-facing pending mailbox rows without requiring a worker lease. */
 export declare function cancelHumanFacingPendingMessages(args: {
     conversationId: string;
@@ -301,6 +347,8 @@ export declare function completeConversationWork(args: {
     leaseToken: string;
     madeProgress?: boolean;
     nowMs?: number;
+    /** Keep a raced stop runnable after a stop-aware adapter returns. */
+    resumeIfStopped?: boolean;
     state?: StateAdapter;
 }): Promise<"completed" | "lost_lease" | "pending">;
 /** Failure outcome: `lost_lease` (another owner took over), `recorded` (retry counted), or `skipped` (durable progress was made). */