@sentry/junior 0.71.3 → 0.73.0

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

@@ -1,59 +1,85 @@
 import type { StateAdapter } from "chat";
 import type { Destination } from "@sentry/junior-plugin-api";
+import { type StoredSlackRequester } from "@/chat/requester";
 import type { ConversationWorkQueue } from "./queue";
+export declare const CONVERSATION_BY_ACTIVITY_INDEX_KEY = "junior:conversation:by-activity";
+export declare const CONVERSATION_ACTIVE_INDEX_KEY = "junior:conversation:active";
 export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
 export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
 export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
-export declare const CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES = 5;
-export type InboundMessageSource = "plugin" | "scheduler" | "slack";
-export interface AgentInputMessage {
+export type Source = "api" | "internal" | "local" | "plugin" | "scheduler" | "slack";
+export type ExecutionStatus = "awaiting_resume" | "idle" | "pending" | "running";
+export interface AgentInput {
     attachments?: unknown[];
     authorId?: string;
     metadata?: Record<string, unknown>;
     text: string;
 }
-export interface InboundMessageRecord {
+export interface InboundMessage {
     conversationId: string;
     createdAtMs: number;
     destination: Destination;
     inboundMessageId: string;
     injectedAtMs?: number;
-    input: AgentInputMessage;
+    input: AgentInput;
     receivedAtMs: number;
-    source: InboundMessageSource;
+    source: Source;
 }
-export interface ConversationLease {
+export interface Lease {
+    acquiredAtMs: number;
+    expiresAtMs: number;
+    lastCheckInAtMs: number;
+    token: string;
+}
+export interface ConversationExecution {
+    inboundMessageIds: string[];
+    lastCheckpointAtMs?: number;
+    lastEnqueuedAtMs?: number;
+    lease?: Lease;
+    pendingCount: number;
+    pendingMessages: InboundMessage[];
+    runId?: string;
+    status: ExecutionStatus;
+    updatedAtMs?: number;
+}
+export interface Conversation {
+    channelName?: string;
+    conversationId: string;
+    createdAtMs: number;
+    destination?: Destination;
+    execution: ConversationExecution;
+    lastActivityAtMs: number;
+    requester?: StoredSlackRequester;
+    schemaVersion: 1;
+    source?: Source;
+    title?: string;
+    updatedAtMs: number;
+}
+export interface ConversationWorkLease {
     acquiredAtMs: number;
     lastCheckInAtMs: number;
     leaseExpiresAtMs: number;
     leaseToken: string;
 }
-export interface ConversationWorkState {
-    consecutiveFailureCount: number;
-    conversationId: string;
-    destination: Destination;
+export interface ConversationWorkState extends Conversation {
     lastEnqueuedAtMs?: number;
-    lastFailureAtMs?: number;
-    lease?: ConversationLease;
-    messages: InboundMessageRecord[];
+    lease?: ConversationWorkLease;
+    messages: InboundMessage[];
     needsRun: boolean;
-    schemaVersion: 1;
-    terminallyFailedAtMs?: number;
-    updatedAtMs: number;
 }
-export interface ConversationLeaseAcquired {
+export interface StartConversationWorkAcquired {
     leaseExpiresAtMs: number;
     leaseToken: string;
     status: "acquired";
 }
-export interface ConversationLeaseActive {
+export interface StartConversationWorkActive {
     leaseExpiresAtMs: number;
     status: "active";
 }
-export interface ConversationLeaseNoWork {
+export interface StartConversationWorkNoWork {
     status: "no_work";
 }
-export type ConversationLeaseStartResult = ConversationLeaseAcquired | ConversationLeaseActive | ConversationLeaseNoWork;
+export type StartConversationWorkResult = StartConversationWorkAcquired | StartConversationWorkActive | StartConversationWorkNoWork;
 export interface AppendInboundMessageResult {
     status: "appended" | "duplicate";
 }
@@ -63,24 +89,29 @@ export interface AppendAndEnqueueInboundMessageResult extends AppendInboundMessa
 export interface RequestConversationWorkResult {
     status: "created" | "updated";
 }
-/** Return a persisted conversation work record, if one exists. */
+/** Return a persisted conversation record, if one exists. */
+export declare function getConversation(args: {
+    conversationId: string;
+    state?: StateAdapter;
+}): Promise<Conversation | undefined>;
+/** Return a persisted conversation record, if one exists. */
 export declare function getConversationWorkState(args: {
     conversationId: string;
     state?: StateAdapter;
 }): Promise<ConversationWorkState | undefined>;
 /** Count mailbox messages that have not yet reached the session log. */
-export declare function countPendingConversationMessages(state: ConversationWorkState): number;
+export declare function countPendingConversationMessages(conversation: Conversation): number;
 /** Return whether a conversation has pending or resumable execution work. */
-export declare function hasRunnableConversationWork(state: ConversationWorkState): boolean;
+export declare function hasRunnableConversationWork(conversation: Conversation): boolean;
 /** Persist one inbound message idempotently in its conversation mailbox. */
 export declare function appendInboundMessage(args: {
-    message: InboundMessageRecord;
+    message: InboundMessage;
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<AppendInboundMessageResult>;
 /** Persist inbound work and send the queue nudge that wakes a worker. */
 export declare function appendAndEnqueueInboundMessage(args: {
-    message: InboundMessageRecord;
+    message: InboundMessage;
     nowMs?: number;
     queue: ConversationWorkQueue;
     state?: StateAdapter;
@@ -92,6 +123,18 @@ export declare function requestConversationWork(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<RequestConversationWorkResult>;
+/** Record visible conversation activity without making the conversation runnable. */
+export declare function recordConversationActivity(args: {
+    activityAtMs?: number;
+    channelName?: string;
+    conversationId: string;
+    destination?: Destination;
+    nowMs?: number;
+    requester?: StoredSlackRequester;
+    source?: Source;
+    state?: StateAdapter;
+    title?: string;
+}): Promise<void>;
 /** Record that a wake-up nudge was accepted for the conversation. */
 export declare function markConversationWorkEnqueued(args: {
     conversationId: string;
@@ -103,7 +146,7 @@ export declare function startConversationWork(args: {
     conversationId: string;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<ConversationLeaseStartResult>;
+}): Promise<StartConversationWorkResult>;
 /** Extend the durable execution lease when the worker checks in. */
 export declare function checkInConversationWork(args: {
     conversationId: string;
@@ -114,11 +157,11 @@ export declare function checkInConversationWork(args: {
 /** Drain pending mailbox entries after the caller has durably injected them. */
 export declare function drainConversationMailbox(args: {
     conversationId: string;
-    inject: (messages: InboundMessageRecord[]) => Promise<void>;
+    inject: (messages: InboundMessage[]) => Promise<void>;
     leaseToken: string;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<InboundMessageRecord[]>;
+}): Promise<InboundMessage[]>;
 /** Mark selected leased mailbox entries after their session-log injection succeeds. */
 export declare function markConversationMessagesInjected(args: {
     conversationId: string;
@@ -155,27 +198,19 @@ export declare function clearExpiredConversationLease(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
-export interface RecordConversationWorkFailureResult {
-    abandoned: boolean;
-    consecutiveFailureCount: number;
-    releasedLease: boolean;
-}
-/**
- * Increment the durable failure counter after a caught worker error so
- * deterministic poison work cannot churn the queue forever. When the counter
- * crosses {@link CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES}, the conversation
- * is marked terminally failed: the lease is cleared, pending mailbox messages
- * are dropped, and the conversation drops out of the recovery index so neither
- * the worker nor heartbeat will requeue it again. A later inbound message
- * resets the counter and gives the conversation a fresh attempt.
- */
-export declare function recordConversationWorkFailure(args: {
+/** Remove one conversation from the active index after it is missing or idle. */
+export declare function removeActiveConversation(args: {
     conversationId: string;
-    nowMs?: number;
     state?: StateAdapter;
-}): Promise<RecordConversationWorkFailureResult>;
-/** List bounded conversation ids that may need heartbeat recovery. */
-export declare function listConversationWorkIds(args?: {
+}): Promise<void>;
+/** List active conversation ids by oldest execution update first. */
+export declare function listActiveConversationIds(args?: {
     limit?: number;
+    staleBeforeMs?: number;
     state?: StateAdapter;
 }): Promise<string[]>;
+/** List retained conversations by newest visible activity first. */
+export declare function listConversationsByActivity(args?: {
+    limit?: number;
+    state?: StateAdapter;
+}): Promise<Conversation[]>;

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

@@ -1,14 +1,14 @@
 import type { StateAdapter } from "chat";
 import type { Destination } from "@sentry/junior-plugin-api";
 import { type ConversationQueueMessage, type ConversationWorkQueue } from "./queue";
-import { type InboundMessageRecord } from "./store";
+import { type InboundMessage } from "./store";
 export declare const CONVERSATION_WORK_DEFER_DELAY_MS = 15000;
 export declare const CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 240000;
 export interface ConversationWorkerContext {
     checkIn(): Promise<boolean>;
     conversationId: string;
     destination: Destination;
-    drainMailbox(inject: (messages: InboundMessageRecord[]) => Promise<void>): Promise<InboundMessageRecord[]>;
+    drainMailbox(inject: (messages: InboundMessage[]) => Promise<void>): Promise<InboundMessage[]>;
     leaseToken: string;
     shouldYield(): boolean;
 }
@@ -16,7 +16,7 @@ export interface ConversationWorkerResult {
     status: "completed" | "lost_lease" | "yielded";
 }
 export interface ConversationWorkProcessResult {
-    status: "abandoned" | "active" | "completed" | "lost_lease" | "no_work" | "pending_requeued" | "yielded";
+    status: "active" | "completed" | "lost_lease" | "no_work" | "pending_requeued" | "yielded";
 }
 export interface ProcessConversationWorkOptions {
     checkInIntervalMs?: number;

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

@@ -1,6 +1,7 @@
 import type { ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
 import type { Static, TSchema } from "@sinclair/typebox";
 import type { ToolExecutionMode } from "@earendil-works/pi-agent-core";
+import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 export interface ToolDefinition<TInputSchema extends TSchema = TSchema> {
     description: string;
     inputSchema: TInputSchema;
@@ -22,6 +23,8 @@ export interface ToolDefinition<TInputSchema extends TSchema = TSchema> {
     execute?: (input: Static<TInputSchema>, options: {
         experimental_context?: unknown;
         signal?: AbortSignal;
+        conversationPrivacy?: ConversationPrivacy;
+        toolCallId?: string;
     }) => Promise<unknown> | unknown;
 }
 /** Infer execute parameter types from the inputSchema via generic binding. */

package/dist/chat/tools/execution/tool-error-handler.d.ts

@@ -1,3 +1,4 @@
 import { type LogContext } from "@/chat/logging";
+import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 /** Handle tool execution errors: set span attributes, log, and rethrow. */
-export declare function handleToolExecutionError(error: unknown, toolName: string, toolCallId: string | undefined, shouldTrace: boolean, traceContext: LogContext): never;
+export declare function handleToolExecutionError(error: unknown, toolName: string, toolCallId: string | undefined, shouldTrace: boolean, traceContext: LogContext, conversationPrivacy?: ConversationPrivacy): never;

package/dist/chat/tools/slack/canvas-tools.d.ts

@@ -1,6 +1,7 @@
-import type { ToolRuntimeContext, ToolState } from "@/chat/tools/types";
+import type { SlackToolContext } from "@/chat/tools/slack/context";
+import type { ToolState } from "@/chat/tools/types";
 /** Create a tool that provisions a new Slack canvas in the active channel. */
-export declare function createSlackCanvasCreateTool(context: ToolRuntimeContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+export declare function createSlackCanvasCreateTool(context: SlackToolContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     title: import("@sinclair/typebox").TString;
     markdown: import("@sinclair/typebox").TString;
 }>>;

package/dist/chat/tools/slack/channel-list-messages.d.ts

@@ -1,5 +1,5 @@
-import type { ToolRuntimeContext } from "@/chat/tools/types";
-export declare function createSlackChannelListMessagesTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+import type { SlackToolContext } from "@/chat/tools/slack/context";
+export declare function createSlackChannelListMessagesTool(context: SlackToolContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
     cursor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     oldest: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;

package/dist/chat/tools/slack/channel-post-message.d.ts

@@ -1,4 +1,5 @@
-import type { ToolRuntimeContext, ToolState } from "@/chat/tools/types";
-export declare function createSlackChannelPostMessageTool(context: ToolRuntimeContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+import type { SlackToolContext } from "@/chat/tools/slack/context";
+import type { ToolState } from "@/chat/tools/types";
+export declare function createSlackChannelPostMessageTool(context: SlackToolContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     text: import("@sinclair/typebox").TString;
 }>>;

package/dist/chat/tools/slack/context.d.ts

@@ -1,3 +1,16 @@
 import type { ToolRuntimeContext } from "@/chat/tools/types";
-/** Resolve the Slack channel used by first-class delivery tools. */
-export declare function getSlackDeliveryChannelId(context: ToolRuntimeContext): string | undefined;
+import type { SlackDestination } from "@sentry/junior-plugin-api";
+import type { SlackSource } from "@sentry/junior-plugin-api";
+import type { SlackRequester } from "@/chat/requester";
+export interface SlackToolContext {
+    destination?: SlackDestination;
+    source: SlackSource;
+    requester?: SlackRequester;
+    destinationChannelId?: string;
+    messageTs?: string;
+    sourceChannelId: string;
+    teamId: string;
+    threadTs?: string;
+}
+/** Resolve Slack-specific tool context from the active source/destination/requester. */
+export declare function getSlackToolContext(context: ToolRuntimeContext): SlackToolContext | undefined;

package/dist/chat/tools/slack/message-add-reaction.d.ts

@@ -1,4 +1,5 @@
-import type { ToolRuntimeContext, ToolState } from "@/chat/tools/types";
-export declare function createSlackMessageAddReactionTool(context: ToolRuntimeContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+import type { SlackToolContext } from "@/chat/tools/slack/context";
+import type { ToolState } from "@/chat/tools/types";
+export declare function createSlackMessageAddReactionTool(context: SlackToolContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     emoji: import("@sinclair/typebox").TString;
 }>>;

package/dist/chat/tools/slack/thread-read.d.ts

@@ -1,6 +1,6 @@
-import type { ToolRuntimeContext } from "@/chat/tools/types";
+import type { SlackToolContext } from "@/chat/tools/slack/context";
 /** Create a tool that reads a Slack thread from a shared message URL or explicit coordinates. */
-export declare function createSlackThreadReadTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+export declare function createSlackThreadReadTool(context: SlackToolContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     url: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     channel_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     ts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;

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

@@ -1,11 +1,12 @@
 import type { FileUpload } from "chat";
-import type { Destination } from "@sentry/junior-plugin-api";
+import type { Destination, LocalDestination, LocalSource, SlackDestination, SlackSource, Source } from "@sentry/junior-plugin-api";
 import type { McpToolManager } from "@/chat/mcp/tool-manager";
 import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { Skill } from "@/chat/skills";
 import type { LoadSkillMetadata } from "@/chat/tools/skill/load-skill";
 import type { AdvisorToolRuntimeContext } from "@/chat/tools/advisor/tool";
+import type { LocalRequester, Requester, SlackRequester } from "@/chat/requester";
 export interface ImageGenerateToolDeps {
     fetch?: typeof fetch;
 }
@@ -33,20 +34,8 @@ export interface ToolHooks {
         webSearch?: WebSearchToolDeps;
     };
 }
-export interface ToolRuntimeContext {
+interface BaseToolRuntimeContext {
     advisor?: AdvisorToolRuntimeContext;
-    /**
-     * Raw Slack channel/conversation container for this turn: `C...`, `D...`,
-     * or `G...`. Never overridden by assistant context. Stable binding key for
-     * state scoped to a Slack conversation. Passed to plugin hooks as-is via
-     * `ToolRegistrationHookContext.channelId`.
-     */
-    channelId?: string;
-    /**
-     * Slack channel used by first-class delivery tools when assistant context
-     * points at a source channel different from the raw conversation channel.
-     */
-    deliveryChannelId?: string;
     /**
      * Opaque Junior conversation/session identity for this turn.
      * Interactive Slack turns use `slack:{channelId}:{threadTs}`.
@@ -54,22 +43,29 @@ export interface ToolRuntimeContext {
      * Do not parse as Slack unless the value starts with `slack:`.
      */
     conversationId?: string;
-    /** Runtime-owned destination for provider-neutral side effects. */
+    /** Runtime-owned default outbound destination, if this invocation has one. */
     destination?: Destination;
-    requester?: {
-        userId?: string;
-        userName?: string;
-        fullName?: string;
-    };
-    teamId?: string;
-    messageTs?: string;
-    threadTs?: string;
+    requester?: Requester;
+    /** Runtime-owned source where this invocation came from. */
+    source: Source;
     userText?: string;
     artifactState?: ThreadArtifactsState;
     configuration?: Record<string, unknown>;
     mcpToolManager?: McpToolManager;
     sandbox: SandboxWorkspace;
 }
+interface SlackToolRuntimeContext extends BaseToolRuntimeContext {
+    destination?: SlackDestination;
+    requester?: SlackRequester;
+    source: SlackSource;
+}
+interface LocalToolRuntimeContext extends BaseToolRuntimeContext {
+    destination?: LocalDestination;
+    requester?: LocalRequester;
+    source: LocalSource;
+    slack?: never;
+}
+export type ToolRuntimeContext = LocalToolRuntimeContext | SlackToolRuntimeContext;
 export interface ToolState {
     artifactState: ThreadArtifactsState;
     patchArtifactState: (patch: Partial<ThreadArtifactsState>) => void | Promise<void>;
@@ -77,3 +73,4 @@ export interface ToolState {
     getOperationResult: <T>(operationKey: string) => T | undefined;
     setOperationResult: (operationKey: string, result: unknown) => void;
 }
+export {};