@sentry/junior 0.71.3 → 0.72.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" | "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/types.d.ts

@@ -6,6 +6,7 @@ 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 { Requester } from "@/chat/requester";
 export interface ImageGenerateToolDeps {
     fetch?: typeof fetch;
 }
@@ -56,11 +57,7 @@ export interface ToolRuntimeContext {
     conversationId?: string;
     /** Runtime-owned destination for provider-neutral side effects. */
     destination?: Destination;
-    requester?: {
-        userId?: string;
-        userName?: string;
-        fullName?: string;
-    };
+    requester?: Requester;
     teamId?: string;
     messageTs?: string;
     threadTs?: string;

package/dist/{chunk-R62YWUNO.js → chunk-3FYPXHPL.js}

@@ -1,6 +1,6 @@
 import {
   getChatConfig
-} from "./chunk-JS4HURDT.js";
+} from "./chunk-ZJQPA67D.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";
@@ -212,6 +212,13 @@ async function getConnectedStateContext() {
     stateAdapter: adapter
   };
 }
+async function getDefaultRedisStateAdapterFor(adapter) {
+  if (adapter !== stateAdapter) {
+    return void 0;
+  }
+  const context = await getConnectedStateContext();
+  return context.stateAdapter === adapter ? context.redisStateAdapter : void 0;
+}
 function getStateAdapter() {
   if (!stateAdapter) {
     stateAdapter = createStateAdapter();
@@ -230,35 +237,10 @@ async function disconnectStateAdapter() {
   }
 }
 
-// src/chat/sandbox/paths.ts
-function normalizeWorkspaceRoot(input) {
-  const candidate = (input ?? "").trim();
-  if (!candidate) {
-    return "/vercel/sandbox";
-  }
-  const normalized = candidate.replace(/\/+$/, "");
-  return normalized.startsWith("/") ? normalized : `/${normalized}`;
-}
-var SANDBOX_WORKSPACE_ROOT = normalizeWorkspaceRoot(
-  process.env.VERCEL_SANDBOX_WORKSPACE_DIR
-);
-var SANDBOX_SKILLS_ROOT = `${SANDBOX_WORKSPACE_ROOT}/skills`;
-var SANDBOX_DATA_ROOT = `${SANDBOX_WORKSPACE_ROOT}/data`;
-function sandboxSkillDir(skillName) {
-  return `${SANDBOX_SKILLS_ROOT}/${skillName}`;
-}
-function sandboxSkillFile(skillName) {
-  return `${sandboxSkillDir(skillName)}/SKILL.md`;
-}
-
 export {
   ACTIVE_LOCK_TTL_MS,
   getConnectedStateContext,
+  getDefaultRedisStateAdapterFor,
   getStateAdapter,
-  disconnectStateAdapter,
-  SANDBOX_WORKSPACE_ROOT,
-  SANDBOX_SKILLS_ROOT,
-  SANDBOX_DATA_ROOT,
-  sandboxSkillDir,
-  sandboxSkillFile
+  disconnectStateAdapter
 };

package/dist/chunk-4JXCSGSA.js

@@ -0,0 +1,212 @@
+import {
+  isRecord,
+  toOptionalNumber,
+  toOptionalString
+} from "./chunk-6GEYPE6T.js";
+
+// src/chat/state/conversation.ts
+function coerceRole(value) {
+  return value === "assistant" || value === "system" || value === "user" ? value : "user";
+}
+function coerceAuthor(value) {
+  if (!isRecord(value)) return void 0;
+  const author = {
+    fullName: toOptionalString(value.fullName),
+    userId: toOptionalString(value.userId),
+    userName: toOptionalString(value.userName)
+  };
+  if (typeof value.isBot === "boolean") {
+    author.isBot = value.isBot;
+  }
+  if (!author.fullName && !author.userId && !author.userName && author.isBot === void 0) {
+    return void 0;
+  }
+  return author;
+}
+function coerceMessageMeta(value) {
+  if (!isRecord(value)) return void 0;
+  const meta = {};
+  const attachmentCount = toOptionalNumber(value.attachmentCount);
+  if (typeof attachmentCount === "number" && attachmentCount > 0) {
+    meta.attachmentCount = attachmentCount;
+  }
+  if (typeof value.explicitMention === "boolean") {
+    meta.explicitMention = value.explicitMention;
+  }
+  const imageAttachmentCount = toOptionalNumber(value.imageAttachmentCount);
+  if (typeof imageAttachmentCount === "number" && imageAttachmentCount > 0) {
+    meta.imageAttachmentCount = imageAttachmentCount;
+  }
+  if (typeof value.replied === "boolean") {
+    meta.replied = value.replied;
+  }
+  if (typeof value.skippedReason === "string" && value.skippedReason.trim().length > 0) {
+    meta.skippedReason = value.skippedReason;
+  }
+  if (typeof value.slackTs === "string" && value.slackTs.trim().length > 0) {
+    meta.slackTs = value.slackTs;
+  }
+  if (Array.isArray(value.imageFileIds)) {
+    const imageFileIds = value.imageFileIds.filter(
+      (entry) => typeof entry === "string" && entry.trim().length > 0
+    );
+    if (imageFileIds.length > 0) {
+      meta.imageFileIds = imageFileIds;
+    }
+  }
+  if (typeof value.imagesHydrated === "boolean") {
+    meta.imagesHydrated = value.imagesHydrated;
+  }
+  if (meta.attachmentCount === void 0 && meta.explicitMention === void 0 && meta.imageAttachmentCount === void 0 && meta.replied === void 0 && meta.skippedReason === void 0 && meta.slackTs === void 0 && meta.imageFileIds === void 0 && meta.imagesHydrated === void 0) {
+    return void 0;
+  }
+  return meta;
+}
+function defaultConversationState() {
+  const nowMs = Date.now();
+  return {
+    schemaVersion: 1,
+    messages: [],
+    piMessages: [],
+    compactions: [],
+    backfill: {},
+    processing: {},
+    stats: {
+      estimatedContextTokens: 0,
+      totalMessageCount: 0,
+      compactedMessageCount: 0,
+      updatedAtMs: nowMs
+    },
+    vision: {
+      byFileId: {}
+    }
+  };
+}
+function coercePendingAuthState(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const kind = value.kind;
+  const provider = toOptionalString(value.provider);
+  const requesterId = toOptionalString(value.requesterId);
+  const scope = toOptionalString(value.scope);
+  const sessionId = toOptionalString(value.sessionId);
+  const linkSentAtMs = toOptionalNumber(value.linkSentAtMs);
+  if (kind !== "mcp" && kind !== "plugin" || !provider || !requesterId || !sessionId || typeof linkSentAtMs !== "number") {
+    return void 0;
+  }
+  return {
+    kind,
+    provider,
+    requesterId,
+    ...scope ? { scope } : {},
+    sessionId,
+    linkSentAtMs
+  };
+}
+function coerceThreadConversationState(value) {
+  if (!isRecord(value)) {
+    return defaultConversationState();
+  }
+  const root = value;
+  const rawConversation = isRecord(root.conversation) ? root.conversation : {};
+  const base = defaultConversationState();
+  const rawMessages = Array.isArray(rawConversation.messages) ? rawConversation.messages : [];
+  const messages = [];
+  for (const item of rawMessages) {
+    if (!isRecord(item)) continue;
+    const id = toOptionalString(item.id);
+    const text = toOptionalString(item.text);
+    const createdAtMs = toOptionalNumber(item.createdAtMs);
+    if (!id || !text || !createdAtMs) continue;
+    messages.push({
+      id,
+      role: coerceRole(item.role),
+      text,
+      createdAtMs,
+      author: coerceAuthor(item.author),
+      meta: coerceMessageMeta(item.meta)
+    });
+  }
+  const rawCompactions = Array.isArray(rawConversation.compactions) ? rawConversation.compactions : [];
+  const compactions = [];
+  for (const item of rawCompactions) {
+    if (!isRecord(item)) continue;
+    const id = toOptionalString(item.id);
+    const summary = toOptionalString(item.summary);
+    const createdAtMs = toOptionalNumber(item.createdAtMs);
+    if (!id || !summary || !createdAtMs) continue;
+    const coveredMessageIds = Array.isArray(item.coveredMessageIds) ? item.coveredMessageIds.filter(
+      (entry) => typeof entry === "string" && entry.length > 0
+    ) : [];
+    compactions.push({
+      id,
+      summary,
+      createdAtMs,
+      coveredMessageIds
+    });
+  }
+  const rawBackfill = isRecord(rawConversation.backfill) ? rawConversation.backfill : {};
+  const backfill = {
+    completedAtMs: toOptionalNumber(rawBackfill.completedAtMs),
+    source: rawBackfill.source === "recent_messages" || rawBackfill.source === "thread_fetch" ? rawBackfill.source : void 0
+  };
+  const rawProcessing = isRecord(rawConversation.processing) ? rawConversation.processing : {};
+  const processing = {
+    activeTurnId: toOptionalString(rawProcessing.activeTurnId),
+    lastCompletedAtMs: toOptionalNumber(rawProcessing.lastCompletedAtMs),
+    pendingAuth: coercePendingAuthState(rawProcessing.pendingAuth)
+  };
+  const rawStats = isRecord(rawConversation.stats) ? rawConversation.stats : {};
+  const stats = {
+    estimatedContextTokens: toOptionalNumber(rawStats.estimatedContextTokens) ?? base.stats.estimatedContextTokens,
+    totalMessageCount: toOptionalNumber(rawStats.totalMessageCount) ?? messages.length,
+    compactedMessageCount: toOptionalNumber(rawStats.compactedMessageCount) ?? 0,
+    updatedAtMs: toOptionalNumber(rawStats.updatedAtMs) ?? base.stats.updatedAtMs
+  };
+  const rawVision = isRecord(rawConversation.vision) ? rawConversation.vision : {};
+  const rawVisionByFileId = isRecord(rawVision.byFileId) ? rawVision.byFileId : {};
+  const byFileId = {};
+  for (const [fileId, value2] of Object.entries(rawVisionByFileId)) {
+    if (typeof fileId !== "string" || fileId.trim().length === 0) continue;
+    if (!isRecord(value2)) continue;
+    const summary = toOptionalString(value2.summary);
+    const analyzedAtMs = toOptionalNumber(value2.analyzedAtMs);
+    if (!summary || !analyzedAtMs) continue;
+    byFileId[fileId] = {
+      summary,
+      analyzedAtMs
+    };
+  }
+  return {
+    schemaVersion: 1,
+    messages,
+    piMessages: Array.isArray(rawConversation.piMessages) ? rawConversation.piMessages : [],
+    compactions,
+    backfill,
+    processing,
+    stats,
+    vision: {
+      backfillCompletedAtMs: toOptionalNumber(rawVision.backfillCompletedAtMs),
+      byFileId
+    }
+  };
+}
+function buildConversationStatePatch(conversation) {
+  return {
+    conversation: {
+      ...conversation,
+      schemaVersion: 1,
+      stats: {
+        ...conversation.stats,
+        totalMessageCount: conversation.messages.length,
+        updatedAtMs: Date.now()
+      }
+    }
+  };
+}
+
+export {
+  coerceThreadConversationState,
+  buildConversationStatePatch
+};

package/dist/{chunk-GT67ZWZQ.js → chunk-55XEZFGD.js}

@@ -1,11 +1,13 @@
 import {
   getPluginForSkillPath,
   getPluginSkillRoots
-} from "./chunk-UXG6TU2U.js";
+} from "./chunk-GB3AL54K.js";
 import {
-  logWarn,
   skillRoots
-} from "./chunk-BBXYXOJW.js";
+} from "./chunk-KVZL5NZS.js";
+import {
+  logWarn
+} from "./chunk-6GEYPE6T.js";
 
 // src/chat/skills.ts
 import fs from "fs/promises";