@sentry/junior 0.57.0 → 0.59.0

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

@@ -2,8 +2,10 @@ import type { StateAdapter } from "chat";
 import type { DispatchCreateResult, DispatchOptions, DispatchProjection, DispatchRecord, DispatchStatus } from "./types";
 /** Keep dispatch persistence keys consistent across callback and recovery paths. */
 export declare function getDispatchStorageKey(id: string): string;
-/** Map a dispatch destination to the conversation lock and memory key it owns. */
-export declare function getDispatchConversationId(destination: DispatchRecord["destination"]): string;
+/** Map a dispatch destination to the lock key that serializes Slack delivery. */
+export declare function getDispatchDestinationLockId(destination: DispatchRecord["destination"]): string;
+/** Return the isolated persisted conversation key for one dispatch run. */
+export declare function getDispatchConversationId(dispatch: Pick<DispatchRecord, "id">): string;
 /** Give dispatch slices stable turn ids for resumability and trace correlation. */
 export declare function getDispatchTurnId(dispatchId: string): string;
 /** Gate recovery to dispatches that can still make progress. */

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

@@ -36,7 +36,6 @@ export interface DispatchRecord {
     metadata?: Record<string, string>;
     plugin: string;
     resultMessageTs?: string;
-    resumeCheckpointVersion?: number;
     status: DispatchStatus;
     updatedAtMs: number;
     version: number;

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

@@ -0,0 +1,23 @@
+export type ConversationPrivacy = "public" | "private";
+type TraceAttributeValue = string | number | boolean | string[];
+/** Resolve whether a conversation may expose raw payloads based on known Slack identity. */
+export declare function resolveConversationPrivacy(input: {
+    channelId?: string;
+    conversationId?: string;
+}): ConversationPrivacy | undefined;
+/** Gate raw transcript/tool payload exposure to conversations known to be public. */
+export declare function canExposeConversationPayload(input: {
+    channelId?: string;
+    conversationId?: string;
+}): boolean;
+/** Convert a GenAI message into safe metadata for private trace contexts. */
+export declare function toGenAiMessageMetadata(message: unknown): Record<string, unknown>;
+/** Convert raw text into size-only metadata for private trace contexts. */
+export declare function toGenAiTextMetadata(text: string): Record<string, unknown>;
+/** Convert an arbitrary payload into safe structured metadata for trace data fields. */
+export declare function toGenAiPayloadMetadata(payload: unknown): Record<string, unknown>;
+/** Convert an arbitrary payload into safe flattened trace attributes. */
+export declare function toGenAiPayloadTraceAttributes(prefix: string, payload: unknown): Record<string, TraceAttributeValue>;
+/** Summarize a message list without exposing raw message content. */
+export declare function toGenAiMessagesTraceAttributes(prefix: string, messages: unknown[]): Record<string, TraceAttributeValue>;
+export {};

package/dist/chat/logging.d.ts

@@ -30,6 +30,8 @@ export interface LogContext {
     urlFull?: string;
     userAgent?: string;
 }
+/** Normalize runtime finish reasons to the telemetry spelling we emit. */
+export declare function normalizeGenAiFinishReason(reason: string): string;
 export declare const log: {
     debug(eventName: string, attrs?: Record<string, unknown>, body?: string): void;
     info(eventName: string, attrs?: Record<string, unknown>, body?: string): void;

package/dist/chat/mcp/tool-manager.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Turn-local MCP tool manager.
+ *
+ * This manager activates plugin MCP providers for one agent turn, exposes
+ * discovered tools through provider-prefixed names, and converts MCP results
+ * into Pi tool content. MCP clients, auth challenges, and provider session
+ * details stay inside this layer.
+ */
 import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import type { SkillMetadata } from "@/chat/skills";
@@ -26,7 +34,6 @@ export interface ManagedMcpToolDescriptor {
     annotations?: Record<string, unknown>;
     provider: string;
 }
-type ActiveMcpSkillScope = Pick<SkillMetadata, "pluginProvider">;
 type ActiveMcpSkill = Pick<SkillMetadata, "name" | "pluginProvider">;
 export interface ManagedMcpTool extends ManagedMcpToolDescriptor {
     execute: (args: Record<string, unknown>) => Promise<ManagedMcpToolResult>;
@@ -40,21 +47,27 @@ export declare class McpToolManager {
     private readonly toolsByProvider;
     constructor(plugins: PluginDefinition[], options?: McpToolManagerOptions);
     getActiveProviders(): string[];
+    /** List configured MCP providers for discovery without connecting to them. */
+    getAvailableProviderCatalog(): Array<{
+        provider: string;
+        description: string;
+        active: boolean;
+    }>;
     activateForSkill(skill: ActiveMcpSkill): Promise<boolean>;
     activateProvider(provider: string): Promise<boolean>;
     close(): Promise<void>;
-    getActiveToolCatalog(skills: ActiveMcpSkillScope[], options?: {
+    /** Return descriptors for all active MCP provider tools, optionally filtered by provider. */
+    getActiveToolCatalog(options?: {
         provider?: string;
     }): ManagedMcpToolDescriptor[];
     private filterListedTools;
     private getClient;
     private toManagedTool;
     private handleAuthorizationRequired;
-    /** Return all active ManagedMcpTool objects for the given skill scope. */
-    getResolvedActiveTools(skills: ActiveMcpSkillScope[], options?: {
+    /** Return all active ManagedMcpTool objects, optionally filtered by provider. */
+    getResolvedActiveTools(options?: {
         provider?: string;
     }): ManagedMcpTool[];
-    private resolveProviderTools;
     private toToolDescriptor;
 }
 export {};

package/dist/chat/mcp/tool-name.d.ts

@@ -0,0 +1,2 @@
+/** Extract the provider from canonical `mcp__<provider>__<tool>` names. */
+export declare function parseMcpProviderFromToolName(toolName: string): string | undefined;

package/dist/chat/pi/client.d.ts

@@ -1,6 +1,8 @@
 import { type Message, type Model, type ThinkingLevel } from "@earendil-works/pi-ai";
 import type { ZodTypeAny, z } from "zod";
 export declare const GEN_AI_PROVIDER_NAME: "vercel-ai-gateway";
+export declare const GEN_AI_SERVER_ADDRESS = "ai-gateway.vercel.sh";
+export declare const GEN_AI_SERVER_PORT = 443;
 export declare const MISSING_GATEWAY_CREDENTIALS_ERROR = "Missing AI gateway credentials (AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN)";
 /**
  * Resolve the documented AI Gateway env credentials for the paths that need

package/dist/chat/pi/derived-state.d.ts

@@ -0,0 +1,5 @@
+import type { PiMessage } from "@/chat/pi/messages";
+/** Infer MCP providers previously used in durable Pi history. */
+export declare function inferActiveMcpProvidersFromPiMessages(messages: PiMessage[] | undefined): string[];
+/** Infer successfully loaded skills from durable Pi history. */
+export declare function inferLoadedSkillNamesFromPiMessages(messages: PiMessage[] | undefined): string[];

package/dist/chat/pi/traced-stream.d.ts

@@ -1,4 +1,5 @@
 import type { StreamFn } from "@earendil-works/pi-agent-core";
+import { type ConversationPrivacy } from "@/chat/conversation-privacy";
 /**
  * Wraps pi-ai's `streamSimple` so each LLM call inside a pi-agent-core agent
  * loop produces its own `gen_ai.chat` Sentry span. The returned function is
@@ -6,4 +7,7 @@ import type { StreamFn } from "@earendil-works/pi-agent-core";
  *
  * The base argument exists so tests can inject a stub stream function.
  */
-export declare function createTracedStreamFn(base?: StreamFn): StreamFn;
+export declare function createTracedStreamFn(baseOrOptions?: StreamFn | {
+    conversationPrivacy?: ConversationPrivacy;
+    base?: StreamFn;
+}): StreamFn;

package/dist/chat/prompt.d.ts

@@ -1,5 +1,5 @@
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
-import type { Skill, SkillMetadata, SkillInvocation } from "@/chat/skills";
+import type { SkillMetadata, SkillInvocation } from "@/chat/skills";
 import type { ActiveMcpCatalogSummary } from "@/chat/tools/skill/mcp-tool-summary";
 export declare const JUNIOR_PERSONALITY: string;
 export declare const JUNIOR_WORLD: string | null;
@@ -10,8 +10,8 @@ interface ToolPromptContext {
 }
 type TurnContextPromptInput = {
     availableSkills: SkillMetadata[];
-    activeSkills: Skill[];
     activeMcpCatalogs?: ActiveMcpCatalogSummary[];
+    includeSessionContext?: boolean;
     toolGuidance?: ToolPromptContext[];
     runtime?: {
         conversationId?: string;
@@ -25,15 +25,9 @@ type TurnContextPromptInput = {
     };
     artifactState?: ThreadArtifactsState;
     configuration?: Record<string, unknown>;
-    /**
-     * Whether this turn is a fresh prompt or a resume from a prior checkpoint
-     * (OAuth pause or timeout-resume). Surfaced in <context> so the model knows
-     * it is continuing rather than starting fresh.
-     */
-    turnState?: "fresh" | "resumed";
 };
 /** Return byte-stable platform instructions shared by every conversation and turn. */
 export declare function buildSystemPrompt(): string;
 /** Build volatile runtime context that belongs in the user turn, not the system prompt. */
-export declare function buildTurnContextPrompt(params: TurnContextPromptInput): string;
+export declare function buildTurnContextPrompt(params: TurnContextPromptInput): string | null;
 export {};

package/dist/chat/respond-helpers.d.ts

@@ -63,9 +63,11 @@ export declare function isToolResultError(result: unknown): boolean;
 export declare function isAssistantMessage(value: unknown): value is AssistantMessage;
 /** Extract role string from a raw Pi message. */
 export declare function getPiMessageRole(value: unknown): string | undefined;
-/** Refresh volatile runtime context in a checkpoint before continuing Pi. */
+/** Refresh volatile runtime context in session history before continuing Pi. */
 export declare function refreshRuntimeTurnContext(messages: PiMessage[], turnContextPrompt: string): PiMessage[];
-/** Remove volatile runtime context before using checkpoint messages as history. */
+/** Return whether Pi history already carries session bootstrap context. */
+export declare function hasRuntimeTurnContext(messages: PiMessage[]): boolean;
+/** Remove volatile runtime context before reusing messages as history. */
 export declare function stripRuntimeTurnContext(messages: PiMessage[]): PiMessage[];
 /** Concatenate text content parts from an assistant message. */
 export declare function extractAssistantText(message: AssistantMessage): string;
@@ -73,5 +75,5 @@ export declare function extractAssistantText(message: AssistantMessage): string;
 export declare function getTerminalAssistantMessages(messages: readonly unknown[]): AssistantMessage[];
 /** Upsert a skill into the active skills list by name. */
 export declare function upsertActiveSkill(activeSkills: Skill[], next: Skill): void;
-/** Remove trailing assistant messages before checkpointing. */
+/** Remove trailing assistant messages before committing a resumable boundary. */
 export declare function trimTrailingAssistantMessages(messages: PiMessage[]): PiMessage[];

package/dist/chat/respond.d.ts

@@ -27,6 +27,7 @@ export interface ReplyRequestContext {
         turnId?: string;
         runId?: string;
         channelId?: string;
+        channelName?: string;
         teamId?: string;
         messageTs?: string;
         threadTs?: string;

package/dist/chat/runtime/conversation-message.d.ts

@@ -0,0 +1,10 @@
+import type { Message } from "chat";
+import type { ConversationMessage } from "@/chat/state/conversation";
+interface ConversationMessageInput {
+    entry: Message;
+    explicitMention?: boolean;
+    text: string;
+}
+/** Preserve an SDK message and its Slack metadata in durable conversation memory. */
+export declare function toConversationMessage(args: ConversationMessageInput): ConversationMessage;
+export {};

package/dist/chat/runtime/processing-reaction.d.ts

@@ -1,14 +1,12 @@
 import type { Message, Thread } from "chat";
+import type { TurnToolInvocation } from "@/chat/runtime/turn-input";
 /** Controls the automatic Slack processing reaction lifecycle for one message. */
 export interface ProcessingReactionSession {
     keep: () => void;
     stop: () => Promise<void>;
 }
 /** Return true when a Slack reaction tool call should leave the processing reaction in place. */
-export declare function shouldKeepProcessingReactionForToolInvocation(input: {
-    params: Record<string, unknown>;
-    toolName: string;
-}): boolean;
+export declare function shouldKeepProcessingReactionForToolInvocation(input: TurnToolInvocation): boolean;
 /** Start Junior's automatic Slack processing reaction for one inbound message. */
 export declare function startSlackProcessingReaction(args: {
     logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;

package/dist/chat/runtime/reply-executor.d.ts

@@ -1,7 +1,16 @@
+/**
+ * Slack reply execution boundary.
+ *
+ * This module bridges prepared Slack thread state into `generateAssistantReply`
+ * and commits the resulting Slack-visible delivery/state updates. It is where
+ * queued messages, compaction, status updates, and Slack posting meet; agent
+ * internals stay behind the reply generator.
+ */
 import type { Message, Thread } from "chat";
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
 import type { PreparedTurnState } from "@/chat/runtime/turn-preparation";
+import { type PrepareTurnStateInput, type QueuedTurnMessage, type TurnToolInvocation } from "@/chat/runtime/turn-input";
 import { type ConversationMemoryService } from "@/chat/services/conversation-memory";
 import type { ContextCompactor } from "@/chat/services/context-compaction";
 import { lookupSlackUser } from "@/chat/slack/user";
@@ -32,27 +41,15 @@ interface ReplyExecutorDeps {
         filename?: string;
         promptText?: string;
     }>>;
-    prepareTurnState: (args: {
-        explicitMention: boolean;
-        message: Message;
-        thread: Thread;
-        userText: string;
-        context: {
-            threadId?: string;
-            requesterId?: string;
-            channelId?: string;
-            runId?: string;
-        };
-    }) => Promise<PreparedTurnState>;
+    prepareTurnState: (args: PrepareTurnStateInput) => Promise<PreparedTurnState>;
     services: ReplyExecutorServices;
 }
+/** Build the Slack reply handler that prepares state, runs Pi, and delivers replies. */
 export declare function createReplyToThread(deps: ReplyExecutorDeps): (thread: Thread, message: Message, options?: {
     beforeFirstResponsePost?: () => Promise<void>;
     explicitMention?: boolean;
-    onToolInvocation?: (invocation: {
-        params: Record<string, unknown>;
-        toolName: string;
-    }) => void;
+    onToolInvocation?: (invocation: TurnToolInvocation) => void;
     preparedState?: PreparedTurnState;
+    queuedMessages?: QueuedTurnMessage[];
 }) => Promise<void>;
 export {};

package/dist/chat/runtime/slack-runtime.d.ts

@@ -1,5 +1,14 @@
-import type { Message, Thread } from "chat";
-import type { SubscribedReplyDecision } from "@/chat/services/subscribed-reply-policy";
+/**
+ * Slack event runtime.
+ *
+ * This module owns inbound Slack routing decisions for mentions, subscribed
+ * messages, assistant lifecycle events, and retryable turn pauses. It should
+ * normalize text/queued context and decide reply vs silence while keeping
+ * Pi/MCP internals and durable session storage behind injected services.
+ */
+import type { Message, MessageContext, Thread } from "chat";
+import type { SubscribedReplyDecision, SubscribedReplyPolicy } from "@/chat/services/subscribed-reply-policy";
+import { type PrepareTurnStateInput, type QueuedTurnMessage, type TurnMessageText, type TurnToolInvocation } from "@/chat/runtime/turn-input";
 export interface AssistantLifecycleEvent {
     channelId: string;
     context?: {
@@ -9,18 +18,10 @@ export interface AssistantLifecycleEvent {
     threadTs: string;
     userId?: string;
 }
-export interface ThreadContext {
-    channelId?: string;
-    requesterId?: string;
-    threadId?: string;
-    runId?: string;
-}
 export interface ReplyHooks {
     beforeFirstResponsePost?: () => Promise<void>;
-    onToolInvocation?: (invocation: {
-        params: Record<string, unknown>;
-        toolName: string;
-    }) => void;
+    messageContext?: MessageContext;
+    onToolInvocation?: (invocation: TurnToolInvocation) => void;
 }
 export interface SlackTurnRuntimeDependencies<TPreparedState> {
     assistantUserName: string;
@@ -48,8 +49,8 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
         completedAtMs: number;
         decision: SubscribedReplyDecision;
         message: Message;
+        text: TurnMessageText;
         thread: Thread;
-        userText: string;
     }) => Promise<void>;
     onSubscribedMessageSkipped: (args: {
         completedAtMs: number;
@@ -62,30 +63,15 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
         preparedState: TPreparedState;
         thread: Thread;
     }) => Promise<void>;
-    prepareTurnState: (args: {
-        context: ThreadContext;
-        explicitMention: boolean;
-        message: Message;
-        thread: Thread;
-        userText: string;
-    }) => Promise<TPreparedState>;
+    prepareTurnState: (args: PrepareTurnStateInput) => Promise<TPreparedState>;
     replyToThread: (thread: Thread, message: Message, options?: {
         beforeFirstResponsePost?: () => Promise<void>;
         explicitMention?: boolean;
-        onToolInvocation?: (invocation: {
-            params: Record<string, unknown>;
-            toolName: string;
-        }) => void;
+        onToolInvocation?: (invocation: TurnToolInvocation) => void;
         preparedState?: TPreparedState;
+        queuedMessages?: QueuedTurnMessage[];
     }) => Promise<void>;
-    decideSubscribedReply: (args: {
-        context: ThreadContext;
-        conversationContext?: string;
-        hasAttachments?: boolean;
-        isExplicitMention?: boolean;
-        rawText: string;
-        text: string;
-    }) => Promise<SubscribedReplyDecision>;
+    decideSubscribedReply: SubscribedReplyPolicy;
     stripLeadingBotMention: (text: string, options: {
         stripLeadingSlackMentionToken?: boolean;
     }) => string;
@@ -97,4 +83,5 @@ export interface SlackTurnRuntime<_TPreparedState, TAssistantEvent extends Assis
     handleNewMention: (thread: Thread, message: Message, hooks?: ReplyHooks) => Promise<void>;
     handleSubscribedMessage: (thread: Thread, message: Message, hooks?: ReplyHooks) => Promise<void>;
 }
+/** Build the Slack event runtime that routes mentions and subscribed messages. */
 export declare function createSlackTurnRuntime<TPreparedState, TAssistantEvent extends AssistantLifecycleEvent = AssistantLifecycleEvent>(deps: SlackTurnRuntimeDependencies<TPreparedState>): SlackTurnRuntime<TPreparedState, TAssistantEvent>;

package/dist/chat/runtime/thread-state.d.ts

@@ -1,4 +1,4 @@
-import { type Thread } from "chat";
+import type { Thread } from "chat";
 import type { ChannelConfigurationService } from "@/chat/configuration/types";
 import type { ThreadConversationState } from "@/chat/state/conversation";
 import { type ThreadArtifactsState } from "@/chat/state/artifacts";

package/dist/chat/runtime/turn-input.d.ts

@@ -0,0 +1,29 @@
+import type { Message, Thread } from "chat";
+export interface TurnContext {
+    channelId?: string;
+    requesterId?: string;
+    threadId?: string;
+    runId?: string;
+}
+export interface TurnMessageText {
+    rawText: string;
+    userText: string;
+}
+export interface TurnToolInvocation {
+    params: Record<string, unknown>;
+    toolName: string;
+}
+export interface QueuedTurnMessage extends TurnMessageText {
+    explicitMention: boolean;
+    message: Message;
+}
+export interface PrepareTurnStateInput {
+    context: TurnContext;
+    explicitMention: boolean;
+    message: Message;
+    queuedMessages?: QueuedTurnMessage[];
+    text: TurnMessageText;
+    thread: Thread;
+}
+/** Preserve skipped Slack messages as turn input without duplicating stored state. */
+export declare function combineTurnText(queuedMessages: readonly TurnMessageText[], latestText: TurnMessageText): TurnMessageText;

package/dist/chat/runtime/turn-preparation.d.ts

@@ -1,7 +1,7 @@
-import type { Message, Thread } from "chat";
 import type { ThreadConversationState } from "@/chat/state/conversation";
 import { type ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ChannelConfigurationService } from "@/chat/configuration/types";
+import type { PrepareTurnStateInput, TurnContext } from "@/chat/runtime/turn-input";
 export interface PreparedTurnState {
     artifacts: ThreadArtifactsState;
     configuration?: Record<string, unknown>;
@@ -14,30 +14,10 @@ export interface PreparedTurnState {
     userMessageId?: string;
 }
 export interface PrepareTurnStateDeps {
-    compactConversationIfNeeded: (conversation: ThreadConversationState, context: {
-        threadId?: string;
-        channelId?: string;
-        requesterId?: string;
-        runId?: string;
-    }) => Promise<void>;
-    hydrateConversationVisionContext: (conversation: ThreadConversationState, context: {
-        threadId?: string;
-        channelId?: string;
-        requesterId?: string;
-        runId?: string;
+    compactConversationIfNeeded: (conversation: ThreadConversationState, context: TurnContext) => Promise<void>;
+    hydrateConversationVisionContext: (conversation: ThreadConversationState, context: TurnContext & {
         threadTs?: string;
     }) => Promise<void>;
 }
 /** Build the turn-state preparer from injected conversation services. */
-export declare function createPrepareTurnState(deps: PrepareTurnStateDeps): (args: {
-    explicitMention: boolean;
-    message: Message;
-    thread: Thread;
-    userText: string;
-    context: {
-        threadId?: string;
-        requesterId?: string;
-        channelId?: string;
-        runId?: string;
-    };
-}) => Promise<PreparedTurnState>;
+export declare function createPrepareTurnState(deps: PrepareTurnStateDeps): (args: PrepareTurnStateInput) => Promise<PreparedTurnState>;

package/dist/chat/runtime/turn.d.ts

@@ -11,7 +11,7 @@ export interface RetryableTurnMetadata {
     authProvider?: string;
     authThinkingLevel?: TurnThinkingSelection["thinkingLevel"];
     authUsage?: AgentTurnUsage;
-    checkpointVersion?: number;
+    version?: number;
     conversationId?: string;
     sessionId?: string;
     sliceId?: number;
@@ -42,8 +42,7 @@ export declare function markTurnClosed(args: {
     updateConversationStats: (conversation: ThreadConversationState) => void;
 }): void;
 /**
- * Mark a turn as completed after final reply delivery succeeds and make its Pi
- * session the reusable history source for the next turn.
+ * Mark a turn as completed after final reply delivery succeeds.
  */
 export declare function markTurnCompleted(args: {
     conversation: ThreadConversationState;

package/dist/chat/sentry-links.d.ts

@@ -0,0 +1,4 @@
+/** Build a Sentry conversation URL only when the runtime has enough Sentry config. */
+export declare function buildSentryConversationUrl(conversationId: string): string | undefined;
+/** Build a Sentry trace URL only when the runtime has enough Sentry config. */
+export declare function buildSentryTraceUrl(traceId: string): string | undefined;

package/dist/chat/services/context-compaction.d.ts

@@ -13,7 +13,7 @@ export interface CompactContextArgs {
     conversationContext?: string;
     conversationId: string;
     onCompactionStart?: () => void;
-    previousSessionId: string;
+    piMessages: PiMessage[];
     metadata?: {
         channelId?: string;
         requesterId?: string;
@@ -24,10 +24,9 @@ export interface CompactContextArgs {
 export interface CompactContextResult {
     compacted: boolean;
     piMessages?: PiMessage[];
-    reason?: "below_threshold" | "missing_context" | "not_completed" | "summary_failed";
-    sessionId?: string;
+    reason?: "below_threshold" | "missing_context" | "summary_failed";
 }
 /** Build retained user messages for a compacted Pi replacement history. */
 export declare function selectRetainedUserMessages(messages: PiMessage[], maxTokens?: number): PiMessage[];
-/** Build the service that owns local context compaction and checkpoint forks. */
+/** Build the service that owns local context compaction. */
 export declare function createContextCompactor(deps: ContextCompactorDeps): ContextCompactor;

package/dist/chat/services/pending-auth.d.ts

@@ -16,7 +16,7 @@ export declare function getConversationPendingAuth(args: {
 export declare function clearPendingAuth(conversation: ThreadConversationState, sessionId?: string): void;
 /**
  * Apply a new pending-auth record to the conversation and, when replacing a
- * different session's pending-auth, mark the prior checkpoint as superseded.
+ * different session's pending-auth, mark the prior session record as abandoned.
  * Callers are responsible for persisting the mutated conversation afterwards.
  */
 export declare function applyPendingAuthUpdate(args: {

package/dist/chat/services/subscribed-reply-policy.d.ts

@@ -1,3 +1,4 @@
+import { type SubscribedDecisionInput } from "@/chat/services/subscribed-decision";
 import type { completeObject } from "@/chat/pi/client";
 export interface SubscribedReplyPolicyDeps {
     completeObject: typeof completeObject;
@@ -7,17 +8,5 @@ export interface SubscribedReplyDecision {
     shouldReply: boolean;
     shouldUnsubscribe?: boolean;
 }
-export type SubscribedReplyPolicy = (args: {
-    rawText: string;
-    text: string;
-    conversationContext?: string;
-    hasAttachments?: boolean;
-    isExplicitMention?: boolean;
-    context: {
-        threadId?: string;
-        requesterId?: string;
-        channelId?: string;
-        runId?: string;
-    };
-}) => Promise<SubscribedReplyDecision>;
+export type SubscribedReplyPolicy = (args: SubscribedDecisionInput) => Promise<SubscribedReplyDecision>;
 export declare function createSubscribedReplyPolicy(deps: SubscribedReplyPolicyDeps): SubscribedReplyPolicy;

package/dist/chat/services/timeout-resume.d.ts

@@ -1,9 +1,8 @@
 export interface TurnContinuationRequest {
     conversationId: string;
-    expectedCheckpointVersion: number;
+    expectedVersion: number;
     sessionId: string;
 }
-export type TurnTimeoutResumeRequest = TurnContinuationRequest;
 /** Bound automatic timeout continuation so one bad turn cannot loop forever. */
 export declare function canScheduleTurnTimeoutResume(nextSliceId: number | undefined): boolean;
 /** Build the callback request for an awaiting automatic turn continuation. */

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

@@ -0,0 +1,82 @@
+import { type AgentTurnSessionRecord, type AgentTurnRequester } from "@/chat/state/turn-session";
+import type { PiMessage } from "@/chat/pi/messages";
+import { type AgentTurnUsage } from "@/chat/usage";
+export interface TurnSessionContext {
+    conversationId?: string;
+    sessionId?: string;
+}
+export interface TurnSessionState {
+    canUseTurnSession: boolean;
+    resumedFromSessionRecord: boolean;
+    currentSliceId: number;
+    existingSessionRecord?: AgentTurnSessionRecord;
+}
+interface SessionRecordLogContext {
+    threadId?: string;
+    requesterId?: string;
+    channelId?: string;
+    runId?: string;
+    assistantUserName?: string;
+    modelId: string;
+}
+/** Load turn session record state for a conversation/session pair. */
+export declare function loadTurnSessionRecord(ctx: TurnSessionContext): Promise<TurnSessionState>;
+/** Persist the latest safe in-progress boundary without scheduling continuation. */
+export declare function persistRunningSessionRecord(args: {
+    channelName?: string;
+    conversationId: string;
+    sessionId: string;
+    sliceId: number;
+    messages: PiMessage[];
+    loadedSkillNames?: string[];
+    logContext: SessionRecordLogContext;
+    requester?: AgentTurnRequester;
+}): Promise<void>;
+/** Persist a completed turn session record. */
+export declare function persistCompletedSessionRecord(args: {
+    channelName?: string;
+    conversationId: string;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    sessionId: string;
+    sliceId: number;
+    allMessages: PiMessage[];
+    loadedSkillNames?: string[];
+    logContext: SessionRecordLogContext;
+    requester?: AgentTurnRequester;
+}): Promise<void>;
+/**
+ * Persist an auth-pause session record. Returns the durable record only when
+ * the caller can safely hand the user to an authorization resume flow.
+ */
+export declare function persistAuthPauseSessionRecord(args: {
+    channelName?: string;
+    conversationId: string;
+    sessionId: string;
+    currentSliceId: number;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    messages: PiMessage[];
+    loadedSkillNames?: string[];
+    errorMessage: string;
+    logContext: SessionRecordLogContext;
+    requester?: AgentTurnRequester;
+}): Promise<AgentTurnSessionRecord | undefined>;
+/**
+ * Persist a timeout session record at the last safe boundary. Returns the durable
+ * record when persistence succeeds so callers can enqueue a continuation.
+ */
+export declare function persistTimeoutSessionRecord(args: {
+    channelName?: string;
+    conversationId: string;
+    sessionId: string;
+    currentSliceId: number;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    messages: PiMessage[];
+    loadedSkillNames?: string[];
+    errorMessage: string;
+    logContext: SessionRecordLogContext;
+    requester?: AgentTurnRequester;
+}): Promise<AgentTurnSessionRecord | undefined>;
+export {};

package/dist/chat/slack/assistant-thread/title.d.ts

@@ -25,4 +25,7 @@ export declare function maybeUpdateAssistantTitle(args: {
     requesterId?: string;
     runId?: string;
     threadId?: string;
-}): Promise<string | undefined>;
+}): Promise<{
+    sourceMessageId: string;
+    title?: string;
+} | undefined>;