@sentry/junior 0.178.0 → 0.180.0

package/dist/chat/scheduled-tasks/types.d.ts

@@ -1,86 +1,135 @@
-/** Durable scheduled-task domain types owned by Junior core. */
-import type { SlackDestination, SystemActor } from "@sentry/junior-plugin-api";
 import { z } from "zod";
-export type ScheduledTaskStatus = "active" | "blocked" | "completed" | "deleted";
-export declare const scheduledTaskCredentialModeSchema: z.ZodEnum<{
+declare const scheduledTaskStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    blocked: "blocked";
+    active: "active";
+    deleted: "deleted";
+}>;
+export type ScheduledTaskStatus = z.output<typeof scheduledTaskStatusSchema>;
+declare const scheduledTaskCredentialModeSchema: z.ZodEnum<{
     system: "system";
     creator: "creator";
 }>;
-export type ScheduledTaskCredentialMode = z.infer<typeof scheduledTaskCredentialModeSchema>;
-export type ScheduledRunStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "skipped";
-export interface ScheduledTaskPrincipal {
-    slackUserId: string;
-    fullName?: string;
-    userName?: string;
-}
-export type ScheduledTaskExecutionActor = SystemActor;
+export type ScheduledTaskCredentialMode = z.output<typeof scheduledTaskCredentialModeSchema>;
+declare const scheduledRunStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    blocked: "blocked";
+    skipped: "skipped";
+}>;
+export type ScheduledRunStatus = z.output<typeof scheduledRunStatusSchema>;
+/** Validate the current scheduled-task domain shape. */
+export declare const scheduledTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    conversationAccess: z.ZodObject<{
+        audience: z.ZodEnum<{
+            channel: "channel";
+            direct: "direct";
+            group: "group";
+        }>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>;
+    }, z.core.$strict>;
+    createdAtMs: z.ZodNumber;
+    createdBy: z.ZodObject<{
+        slackUserId: z.ZodString;
+        fullName: z.ZodOptional<z.ZodString>;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    creatorIdentityId: z.ZodString;
+    credentialMode: z.ZodEnum<{
+        system: "system";
+        creator: "creator";
+    }>;
+    destination: z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>;
+    executionActor: z.ZodOptional<z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    lastRunAtMs: z.ZodOptional<z.ZodNumber>;
+    nextRunAtMs: z.ZodOptional<z.ZodNumber>;
+    originalRequest: z.ZodOptional<z.ZodString>;
+    runNowAtMs: z.ZodOptional<z.ZodNumber>;
+    schedule: z.ZodObject<{
+        description: z.ZodString;
+        kind: z.ZodEnum<{
+            one_off: "one_off";
+            recurring: "recurring";
+        }>;
+        recurrence: z.ZodOptional<z.ZodObject<{
+            dayOfMonth: z.ZodOptional<z.ZodNumber>;
+            frequency: z.ZodEnum<{
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                yearly: "yearly";
+            }>;
+            interval: z.ZodNumber;
+            month: z.ZodOptional<z.ZodNumber>;
+            startDate: z.ZodString;
+            time: z.ZodObject<{
+                hour: z.ZodNumber;
+                minute: z.ZodNumber;
+            }, z.core.$strict>;
+            weekdays: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strict>>;
+        timezone: z.ZodString;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        blocked: "blocked";
+        active: "active";
+        deleted: "deleted";
+    }>;
+    statusReason: z.ZodOptional<z.ZodString>;
+    task: z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strict>;
+    title: z.ZodOptional<z.ZodString>;
+    updatedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+/** Validate the current scheduled-run domain shape. */
+export declare const scheduledRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    attempt: z.ZodNumber;
+    claimedAtMs: z.ZodNumber;
+    completedAtMs: z.ZodOptional<z.ZodNumber>;
+    dispatchId: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    resultMessageTs: z.ZodOptional<z.ZodString>;
+    scheduledForMs: z.ZodNumber;
+    startedAtMs: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        blocked: "blocked";
+        skipped: "skipped";
+    }>;
+    taskId: z.ZodString;
+}, z.core.$strict>;
+export type ScheduledTask = z.output<typeof scheduledTaskSchema>;
+export type ScheduledRun = z.output<typeof scheduledRunSchema>;
+export type ScheduledTaskRecord = Omit<ScheduledTask, "title">;
+export type ScheduledTaskPrincipal = ScheduledTask["createdBy"];
+export type ScheduledTaskExecutionActor = NonNullable<ScheduledTask["executionActor"]>;
+export type ScheduledTaskConversationAccess = ScheduledTask["conversationAccess"];
+export type ScheduledTaskSchedule = ScheduledTask["schedule"];
+export type ScheduledTaskRecurrence = NonNullable<ScheduledTaskSchedule["recurrence"]>;
+export type ScheduledTaskSpec = ScheduledTask["task"];
+export type ScheduledCalendarFrequency = ScheduledTaskRecurrence["frequency"];
+export type ScheduledLocalTime = ScheduledTaskRecurrence["time"];
 export declare const SCHEDULED_TASK_SYSTEM_ACTOR: Readonly<{
     platform: "system";
     name: string;
 }>;
-export interface ScheduledTaskConversationAccess {
-    audience: "direct" | "group" | "channel";
-    visibility: "private" | "public";
-}
-export type ScheduledCalendarFrequency = "daily" | "weekly" | "monthly" | "yearly";
-export interface ScheduledLocalTime {
-    hour: number;
-    minute: number;
-}
-export interface ScheduledTaskRecurrence {
-    dayOfMonth?: number;
-    frequency: ScheduledCalendarFrequency;
-    interval: number;
-    month?: number;
-    startDate: string;
-    time: ScheduledLocalTime;
-    weekdays?: number[];
-}
-export interface ScheduledTaskSchedule {
-    description: string;
-    timezone: string;
-    kind: "one_off" | "recurring";
-    recurrence?: ScheduledTaskRecurrence;
-}
-export interface ScheduledTaskSpec {
-    text: string;
-}
-export interface ScheduledTask {
-    id: string;
-    createdAtMs: number;
-    createdBy: ScheduledTaskPrincipal;
-    /** Authoritative provider identity that created the task. */
-    creatorIdentityId: string;
-    conversationAccess: ScheduledTaskConversationAccess;
-    /** Selects system credentials or task-bound creator credential delegation. */
-    credentialMode: ScheduledTaskCredentialMode;
-    destination: SlackDestination;
-    executionActor?: ScheduledTaskExecutionActor;
-    lastRunAtMs?: number;
-    nextRunAtMs?: number;
-    originalRequest?: string;
-    runNowAtMs?: number;
-    schedule: ScheduledTaskSchedule;
-    status: ScheduledTaskStatus;
-    statusReason?: string;
-    task: ScheduledTaskSpec;
-    /**
-     * Short display title generated from the task instruction.
-     * SQL-backed column; never stored inside the JSON record payload.
-     */
-    title?: string;
-    updatedAtMs: number;
-}
-export interface ScheduledRun {
-    id: string;
-    attempt: number;
-    claimedAtMs: number;
-    completedAtMs?: number;
-    dispatchId?: string;
-    errorMessage?: string;
-    resultMessageTs?: string;
-    scheduledForMs: number;
-    startedAtMs?: number;
-    status: ScheduledRunStatus;
-    taskId: string;
-}
+export {};

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/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). */

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

@@ -2,8 +2,8 @@ import type { StateAdapter } from "chat";
 import type { ConversationStore } from "@/chat/conversations/store";
 import { type ConversationWorkQueue } from "./queue";
 import * as workState from "./state";
-export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS, CONVERSATION_WORK_MAX_RETRIES, CONVERSATION_WORK_STALE_ENQUEUE_MS, isFinalAttempt, isInvalidConversationRecordError, type AgentInput, type AttemptFailure, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type InboundMessageDelivery, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
-import type { AppendAndEnqueueInboundMessageResult, Conversation, InboundMessage } from "@/chat/task-execution/state";
+export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS, CONVERSATION_WORK_MAX_RETRIES, CONVERSATION_WORK_STALE_ENQUEUE_MS, isFinalAttempt, isInvalidConversationRecordError, type AgentInput, type AttemptFailure, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type CompleteConversationStopResult, type Conversation, type ConversationExecution, type ConversationStop, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type InboundMessageDelivery, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, type StopConversationWorkResult, } from "@/chat/task-execution/state";
+import type { AppendAndEnqueueExclusiveInboundMessageResult, AppendAndEnqueueInboundMessageResult, Conversation, InboundMessage } from "@/chat/task-execution/state";
 export type EnsureConversationWakeResult = {
     queueMessageId?: string;
     status: "enqueued";
@@ -63,6 +63,30 @@ export declare function appendAndEnqueueInboundMessage(args: {
     queue: ConversationWorkQueue;
     state?: StateAdapter;
 }): Promise<AppendAndEnqueueInboundMessageResult>;
+/** Persist exclusive inbound work and wake its worker when admitted. */
+export declare function appendAndEnqueueExclusiveInboundMessage(args: {
+    message: InboundMessage;
+    conversationStore?: ConversationStore;
+    nowMs?: number;
+    queue: ConversationWorkQueue;
+    state?: StateAdapter;
+}): Promise<AppendAndEnqueueExclusiveInboundMessageResult>;
+/** Persist a stop request for the current Conversation run. */
+export declare function stopConversationWork(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<workState.StopConversationWorkResult>;
+/** Finish an observed stop request under the current worker lease. */
+export declare function completeConversationStop(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    leaseToken: string;
+    nowMs?: number;
+    runId: string;
+    state?: StateAdapter;
+}): Promise<workState.CompleteConversationStopResult>;
 /** Clear an accepted wake marker after its delivery finds no runnable work. */
 export declare function clearConsumedConversationWake(args: {
     conversationId: string;
@@ -179,6 +203,8 @@ export declare function completeConversationWork(args: {
     madeProgress?: boolean;
     conversationStore?: ConversationStore;
     nowMs?: number;
+    /** Keep a raced stop runnable after a stop-aware adapter returns. */
+    resumeIfStopped?: boolean;
     state?: StateAdapter;
 }): Promise<"pending" | "completed" | "lost_lease">;
 /** Record one failed delivery attempt and dead-letter messages at their limit. */

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

@@ -12,6 +12,8 @@ export interface ConversationWorkerContext {
     publishExternally: boolean;
     /** True when the current execution slice must stop at its next safe boundary. */
     shouldYield(): boolean;
+    /** Return an AbortSignal backed by the durable Conversation stop request. */
+    stopSignal?(): AbortSignal;
 }
 export interface InboxAttempt {
     ack(): Promise<void>;
@@ -22,7 +24,8 @@ export interface InboxAttempt {
     messages: InboundMessage[];
 }
 export interface ConversationWorkerResult {
-    status: "completed" | "deferred" | "lost_lease" | "yielded";
+    /** `paused` waits for an external wake but must resume if a stop raced it. */
+    status: "completed" | "deferred" | "lost_lease" | "paused" | "yielded";
 }
 export interface ConversationWorkProcessResult {
     status: "active" | "completed" | "failed" | "lost_lease" | "no_work" | "pending_requeued" | "yielded";

package/dist/chat/tools/handoff/tool.d.ts

@@ -1,6 +1,6 @@
 import type { ToolRuntimeContext } from "@/chat/tools/types";
 export declare const HANDOFF_TOOL_NAME = "handoff";
-/** Create the runtime control for an in-place execution-profile switch. */
+/** Create the tool that switches the active model profile. */
 export declare function createHandoffTool(handoff: NonNullable<ToolRuntimeContext["handoff"]>): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("../definition").JsonSchemaObject;
     outputSchema: import("../definition").JsonSchemaObject;

package/dist/{chunk-534BO42N.js → chunk-2AYEVN7K.js}

@@ -6,14 +6,14 @@ import {
   isStale,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-AQHSXA3J.js";
+} from "./chunk-WVAMRKYG.js";
 import {
   getStateAdapter
-} from "./chunk-H6ZXBFGX.js";
+} from "./chunk-GA5NS74S.js";
 import {
   setSpanAttributes,
   withSpan
-} from "./chunk-UGWBJAGN.js";
+} from "./chunk-RAZG3YHC.js";
 
 // src/chat/sandbox/resources.ts
 var configuredResources;
@@ -57,9 +57,9 @@ function setSnapshotSpanAttributes(snapshot) {
     "app.sandbox.source": snapshot.snapshotId ? "snapshot" : "created",
     "app.sandbox.snapshot.cache_hit": snapshot.cacheHit,
     "app.sandbox.snapshot.resolve_outcome": snapshot.resolveOutcome,
-    ...snapshot.profileHash ? { "app.sandbox.snapshot.profile_hash": snapshot.profileHash } : {},
+    ...snapshot.profileHash ? { "app.sandbox.snapshot.profile_hash": snapshot.profileHash } : void 0,
     "app.sandbox.snapshot.dependency_count": snapshot.dependencyCount,
-    ...snapshot.rebuildReason ? { "app.sandbox.snapshot.rebuild_reason": snapshot.rebuildReason } : {}
+    ...snapshot.rebuildReason ? { "app.sandbox.snapshot.rebuild_reason": snapshot.rebuildReason } : void 0
   });
 }
 async function trace(name, op, attributes, callback) {
@@ -283,7 +283,7 @@ async function postinstall(sandbox, commands, signal, timeoutMs) {
           pathPrefix: `${SANDBOX_WORKSPACE_ROOT}/.junior/bin:$PATH`,
           signal,
           timeoutMs,
-          ...command.sudo !== void 0 ? { sudo: command.sudo } : {}
+          ...command.sudo !== void 0 ? { sudo: command.sudo } : void 0
         });
         if (result.exitCode !== 0) {
           const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
@@ -460,7 +460,7 @@ async function build(value, runtime, timeoutMs, signal, prepare) {
           runtime,
           signal,
           ...sandboxCredentials ?? {},
-          ...resources ? { resources } : {}
+          ...resources ? { resources } : void 0
         })
       );
       try {
@@ -680,7 +680,7 @@ async function resolve(params) {
         ),
         createdAtMs: lockResult.createdAtMs,
         buildDurationMs: lockResult.buildDurationMs,
-        ...rebuildReason ? { rebuildReason } : {}
+        ...rebuildReason ? { rebuildReason } : void 0
       };
     }
   );