@sentry/junior 0.71.3 → 0.73.0

package/dist/chat/sandbox/egress-tracing.d.ts

@@ -0,0 +1,7 @@
+export interface SandboxEgressTracePropagationConfig {
+    domains?: string[];
+}
+/** Normalize exact and leading-wildcard sandbox egress trace domains. */
+export declare function normalizeSandboxEgressTracePropagationDomains(domains: string[] | undefined): string[];
+/** Return whether a host may carry sandbox egress trace propagation headers. */
+export declare function shouldPropagateSandboxEgressTrace(host: string, config?: SandboxEgressTracePropagationConfig): boolean;

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

@@ -1,5 +1,6 @@
 import { type LogContext } from "@/chat/logging";
 import { type SandboxEgressAuthRequiredSignal, type SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress-session";
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress-tracing";
 import type { CredentialContext } from "@/chat/credentials/context";
 import type { AgentPluginHookRunner } from "@/chat/plugins/agent-hooks";
 import type { SandboxInstance } from "@/chat/sandbox/workspace";
@@ -46,6 +47,7 @@ export declare function createSandboxExecutor(options?: {
     sandboxDependencyProfileHash?: string;
     timeoutMs?: number;
     traceContext?: LogContext;
+    tracePropagation?: SandboxEgressTracePropagationConfig;
     credentialEgress?: CredentialContext;
     agentHooks?: AgentPluginHookRunner;
     onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;

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

@@ -1,5 +1,5 @@
 import { type NetworkPolicy } from "@vercel/sandbox";
-import { type LogContext } from "@/chat/logging";
+import { type LogContext, type TracePropagationHeaders } from "@/chat/logging";
 import { type SandboxFileSystem, type SandboxInstance } from "@/chat/sandbox/workspace";
 import type { SkillMetadata } from "@/chat/skills";
 interface SandboxToolExecutors {
@@ -38,6 +38,7 @@ interface SandboxSessionManager {
     getDependencyProfileHash(): string | undefined;
     createSandbox(): Promise<SandboxInstance>;
     ensureToolExecutors(): Promise<SandboxToolExecutors>;
+    refreshNetworkPolicy(traceHeaders?: TracePropagationHeaders): Promise<void>;
     dispose(): Promise<void>;
 }
 /** Manage sandbox lifecycle, sync, keepalive, and tool executor caching for one executor instance. */
@@ -47,7 +48,7 @@ export declare function createSandboxSessionManager(options?: {
     timeoutMs?: number;
     traceContext?: LogContext;
     commandEnv?: () => Promise<Record<string, string>>;
-    createNetworkPolicy?: (egressId: string) => NetworkPolicy | undefined;
+    createNetworkPolicy?: (egressId: string, traceHeaders?: TracePropagationHeaders) => NetworkPolicy | undefined;
     onSandboxPrepare?: (sandbox: SandboxInstance) => void | Promise<void>;
     onSandboxAcquired?: (sandbox: {
         sandboxId: string;

package/dist/chat/services/agent-continue.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Durable agent continuation scheduling.
+ *
+ * This module owns the queue handoff used when an agent run pauses at a safe
+ * Pi continuation boundary and needs another execution slice.
+ */
+import type { StateAdapter } from "chat";
+import type { Destination } from "@sentry/junior-plugin-api";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+export interface AgentContinueRequest {
+    conversationId: string;
+    destination: Destination;
+    expectedVersion: number;
+    sessionId: string;
+}
+export interface ScheduleAgentContinueOptions {
+    nowMs?: number;
+    queue?: ConversationWorkQueue;
+    state?: StateAdapter;
+}
+/** Build the queue request for an awaiting automatic agent continuation. */
+export declare function getAwaitingAgentContinueRequest(args: {
+    conversationId: string;
+    sessionId: string;
+}): Promise<AgentContinueRequest | undefined>;
+/** Schedule durable conversation work to continue a paused agent run. */
+export declare function scheduleAgentContinue(request: AgentContinueRequest, options?: ScheduleAgentContinueOptions): Promise<void>;

package/dist/chat/services/auth-pause-response.d.ts

@@ -1,2 +1,2 @@
 /** Build the visible Slack thread note for an auth-paused turn. */
-export declare function buildAuthPauseResponse(): string;
+export declare function buildAuthPauseResponse(slackUserId: string | undefined, providerDisplayName: string): string;

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

@@ -9,7 +9,8 @@ export declare class AuthorizationPauseError extends Error {
     readonly disposition: AuthorizationPauseDisposition;
     readonly kind: AuthorizationPauseKind;
     readonly provider: string;
-    constructor(kind: AuthorizationPauseKind, provider: string, disposition: AuthorizationPauseDisposition);
+    readonly providerDisplayName: string;
+    constructor(kind: AuthorizationPauseKind, provider: string, providerDisplayName: string, disposition: AuthorizationPauseDisposition);
 }
 /** Error indicating this turn cannot start an external authorization flow. */
 export declare class AuthorizationFlowDisabledError extends Error {

package/dist/chat/services/mcp-auth-orchestration.d.ts

@@ -5,7 +5,7 @@ import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { PluginDefinition } from "@/chat/plugins/types";
 export declare class McpAuthorizationPauseError extends AuthorizationPauseError {
-    constructor(provider: string, disposition: "link_already_sent" | "link_sent");
+    constructor(provider: string, providerDisplayName: string, disposition: "link_already_sent" | "link_sent");
 }
 export interface McpAuthOrchestrationDeps {
     conversationId?: string;

package/dist/chat/services/message-actor-identity.d.ts

@@ -1,8 +1,16 @@
 import type { Message } from "chat";
-import { type ActorIdentityInput, type SlackActorProfile } from "@/chat/services/requester-identity";
+import { type Requester, type SlackRequester, type SlackRequesterProfile } from "@/chat/requester";
+interface MessageAuthorIdentity {
+    email?: string;
+    fullName?: string;
+    userId: string;
+    userName?: string;
+}
+type MessageActorIdentity = Requester | MessageAuthorIdentity;
 /** Preserve runtime-owned identity on Chat SDK messages before persistence. */
-export declare function bindMessageActorIdentity(message: Message, identity: ActorIdentityInput): ActorIdentityInput;
+export declare function bindMessageActorIdentity(message: Message, requester: Requester): Requester;
 /** Read message identity without promoting adapter display fallbacks. */
-export declare function getMessageActorIdentity(message: Message): ActorIdentityInput | undefined;
+export declare function getMessageActorIdentity(message: Message): MessageActorIdentity | undefined;
 /** Attach Slack display fields only after the author id is exact. */
-export declare function ensureSlackMessageActorIdentity(message: Message, lookupSlackUser: (userId: string) => Promise<SlackActorProfile | null | undefined>): Promise<ActorIdentityInput>;
+export declare function ensureSlackMessageActorIdentity(message: Message, teamId: string, lookupSlackUser: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>): Promise<SlackRequester>;
+export {};

package/dist/chat/services/plugin-auth-orchestration.d.ts

@@ -3,9 +3,8 @@ import type { ChannelConfigurationService } from "@/chat/configuration/types";
 import type { UserTokenStore } from "@/chat/credentials/user-token-store";
 import { AuthorizationPauseError, type AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { ConversationPendingAuthState } from "@/chat/state/conversation";
-import type { Skill } from "@/chat/skills";
 export declare class PluginAuthorizationPauseError extends AuthorizationPauseError {
-    constructor(provider: string, disposition: "link_already_sent" | "link_sent");
+    constructor(provider: string, providerDisplayName: string, disposition: "link_already_sent" | "link_sent");
 }
 export declare class PluginCredentialFailureError extends Error {
     readonly provider: string;
@@ -26,14 +25,16 @@ export interface PluginAuthOrchestrationDeps {
     userTokenStore?: UserTokenStore;
 }
 export interface PluginAuthOrchestration {
-    handleCommandFailure: (input: {
-        activeSkill: Skill | null;
-        command: string;
-        details: unknown;
-    }) => Promise<void>;
+    /**
+     * Inspect a sandbox tool result for an `auth_required` signal from the
+     * egress proxy. If one is present and an OAuth flow is available, parks the
+     * current turn and sends the user an authorization link. No-ops when the
+     * result carries no auth signal.
+     */
+    maybeHandleAuthSignal: (details: unknown) => Promise<void>;
     getPendingPause: () => PluginAuthorizationPauseError | undefined;
 }
 /**
- * Start plugin OAuth from an authenticated bash command and park the turn.
+ * Start plugin OAuth from a sandbox egress auth signal and park the turn.
  */
 export declare function createPluginAuthOrchestration(deps: PluginAuthOrchestrationDeps, abortAgent: () => void): PluginAuthOrchestration;

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

@@ -1,5 +1,6 @@
 import type { FileUpload } from "chat";
 import type { LogContext } from "@/chat/logging";
+import type { PiMessage } from "@/chat/pi/messages";
 import type { TurnThinkingSelection } from "@/chat/services/turn-thinking-level";
 import type { AgentTurnUsage } from "@/chat/usage";
 import { type ReplyDeliveryPlan } from "@/chat/services/reply-delivery-plan";
@@ -27,6 +28,7 @@ export interface AssistantReply {
     deliveryMode?: "thread" | "channel_only";
     sandboxId?: string;
     sandboxDependencyProfileHash?: string;
+    piMessages?: PiMessage[];
     diagnostics: AgentTurnDiagnostics;
 }
 export interface TurnResultInput {
@@ -37,6 +39,7 @@ export interface TurnResultInput {
     toolCalls: string[];
     sandboxId?: string;
     sandboxDependencyProfileHash?: string;
+    piMessages?: PiMessage[];
     durationMs?: number;
     generatedFileCount: number;
     shouldTrace: boolean;

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

@@ -1,8 +1,9 @@
-import { type AgentTurnSessionRecord, type AgentTurnRequester, type AgentTurnSurface } from "@/chat/state/turn-session";
+import { type AgentTurnSessionRecord, type AgentTurnSurface } from "@/chat/state/turn-session";
+import type { StoredSlackRequester } from "@/chat/requester";
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
 import { type AgentTurnUsage } from "@/chat/usage";
-export declare const AGENT_TURN_TIMEOUT_RESUME_MAX_SLICES = 48;
+export declare const AGENT_CONTINUE_MAX_SLICES = 48;
 export interface TurnSessionContext {
     conversationId?: string;
     sessionId?: string;
@@ -33,8 +34,9 @@ export declare function persistRunningSessionRecord(args: {
     messages: PiMessage[];
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
+    turnStartMessageIndex?: number;
 }): Promise<boolean>;
 /** Persist a completed turn session record. */
 export declare function persistCompletedSessionRecord(args: {
@@ -48,8 +50,9 @@ export declare function persistCompletedSessionRecord(args: {
     allMessages: PiMessage[];
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
+    turnStartMessageIndex?: number;
 }): Promise<void>;
 /**
  * Persist an auth-pause session record. Returns the durable record only when
@@ -67,7 +70,7 @@ export declare function persistAuthPauseSessionRecord(args: {
     loadedSkillNames?: string[];
     errorMessage: string;
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
@@ -86,7 +89,7 @@ export declare function persistTimeoutSessionRecord(args: {
     loadedSkillNames?: string[];
     errorMessage: string;
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
@@ -104,7 +107,7 @@ export declare function persistYieldSessionRecord(args: {
     loadedSkillNames?: string[];
     errorMessage: string;
     logContext: SessionRecordLogContext;
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 export {};

package/dist/chat/slack/user.d.ts

@@ -1,11 +1,11 @@
-import { type ActorIdentityInput } from "@/chat/services/requester-identity";
+import { type SlackRequester } from "@/chat/requester";
 interface SlackUserLookupResult {
     userName?: string;
     fullName?: string;
     email?: string;
 }
 /** Fetch Slack user profile info with in-memory TTL cache to avoid repeated API calls. */
-export declare function lookupSlackUser(userId?: string): Promise<SlackUserLookupResult | null>;
-/** Resolve the canonical Slack actor identity from Slack profile data. */
-export declare function lookupSlackActorIdentity(userId: string): Promise<ActorIdentityInput>;
+export declare function lookupSlackUser(teamId: string, userId?: string): Promise<SlackUserLookupResult | null>;
+/** Resolve the canonical Slack requester from Slack profile data. */
+export declare function lookupSlackRequester(teamId: string, userId: string): Promise<SlackRequester>;
 export {};

package/dist/chat/state/adapter.d.ts

@@ -5,5 +5,7 @@ export declare function getConnectedStateContext(): Promise<{
     redisStateAdapter?: RedisStateAdapter;
     stateAdapter: StateAdapter;
 }>;
+/** Return the Redis adapter only when the caller is using the default state adapter. */
+export declare function getDefaultRedisStateAdapterFor(adapter: StateAdapter): Promise<RedisStateAdapter | undefined>;
 export declare function getStateAdapter(): StateAdapter;
 export declare function disconnectStateAdapter(): Promise<void>;

package/dist/chat/state/conversation-details.d.ts

@@ -1,4 +1,5 @@
-import type { AgentTurnRequester, AgentTurnSurface } from "./turn-session";
+import { type StoredSlackRequester } from "@/chat/requester";
+import type { AgentTurnSurface } from "./turn-session";
 export interface ConversationDetailsRecord {
     conversationId: string;
     /** Generated display title from the LLM. Absent until title has been produced. */
@@ -10,7 +11,7 @@ export interface ConversationDetailsRecord {
     /** Surface on which the conversation was started. */
     originSurface?: AgentTurnSurface;
     /** Requester who initiated the conversation (first turn). */
-    originRequester?: AgentTurnRequester;
+    originRequester?: StoredSlackRequester;
     /** Timestamp of the first turn in the conversation. */
     startedAtMs?: number;
 }
@@ -21,7 +22,7 @@ export interface ConversationDetailsRecord {
 export declare function initConversationContext(conversationId: string, context: {
     channelName?: string;
     originSurface?: AgentTurnSurface;
-    originRequester?: AgentTurnRequester;
+    originRequester?: StoredSlackRequester;
     startedAtMs: number;
 }): Promise<void>;
 /**

package/dist/chat/state/session-log.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { PiMessage } from "@/chat/pi/messages";
+import { type StoredSlackRequester } from "@/chat/requester";
 declare const authorizationKindSchema: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
 declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
@@ -11,6 +12,14 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         [x: string]: unknown;
         role: string;
     }>>;
+    requester: z.ZodOptional<z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodLiteral<"slack">>;
+        slackUserId: z.ZodOptional<z.ZodString>;
+        slackUserName: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
 }, z.core.$strip>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     type: z.ZodLiteral<"projection_reset">;
@@ -21,6 +30,26 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         [x: string]: unknown;
         role: string;
     }>>>;
+    requester: z.ZodOptional<z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodLiteral<"slack">>;
+        slackUserId: z.ZodOptional<z.ZodString>;
+        slackUserName: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"requester_recorded">;
+    sessionId: z.ZodDefault<z.ZodString>;
+    requester: z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodLiteral<"slack">>;
+        slackUserId: z.ZodOptional<z.ZodString>;
+        slackUserName: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
 }, z.core.$strip>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     type: z.ZodLiteral<"mcp_provider_connected">;
@@ -46,6 +75,7 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     requesterId: z.ZodString;
     authorizationId: z.ZodString;
 }, z.core.$strip>], "type">;
+/** Requester identity stored with turn-start messages for durable continuation. */
 export type SessionLogEntry = z.infer<typeof sessionLogEntrySchema>;
 export type AuthorizationKind = z.infer<typeof authorizationKindSchema>;
 interface Scope {
@@ -60,6 +90,10 @@ export interface SessionLogStore {
     append(args: AppendArgs): Promise<void>;
     read(scope: Scope): Promise<SessionLogEntry[]>;
 }
+export interface SessionProjection {
+    messages: PiMessage[];
+    requester?: StoredSlackRequester;
+}
 /** Load the committed Pi-message projection for a conversation. */
 export declare function loadMessages(args: Scope & {
     store?: SessionLogStore;
@@ -71,6 +105,14 @@ export declare function loadProjection(args: Scope & {
     store?: SessionLogStore;
     sessionId?: string;
 }): Promise<PiMessage[]>;
+/**
+ * Load the Pi-message projection and derived requester identity in one read.
+ * Used at continuation boundaries to avoid a second log scan.
+ */
+export declare function loadProjectionWithRequester(args: Scope & {
+    store?: SessionLogStore;
+    sessionId?: string;
+}): Promise<SessionProjection>;
 /** Load MCP providers that were durably connected in this conversation. */
 export declare function loadConnectedMcpProviders(args: Scope & {
     store?: SessionLogStore;
@@ -111,6 +153,7 @@ export declare function commitMessages(args: Scope & {
     store?: SessionLogStore;
     messages: PiMessage[];
     ttlMs: number;
+    requester?: StoredSlackRequester;
 }): Promise<{
     sessionId: string;
 }>;

package/dist/chat/state/turn-session.d.ts

@@ -1,15 +1,10 @@
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
+import { type StoredSlackRequester } from "@/chat/requester";
 import type { AgentTurnUsage } from "@/chat/usage";
 export type AgentTurnSessionStatus = "running" | "awaiting_resume" | "completed" | "failed" | "abandoned";
 export type AgentTurnSurface = "slack" | "api" | "scheduler" | "internal";
 export type AgentTurnResumeReason = "timeout" | "auth" | "yield";
-export interface AgentTurnRequester {
-    email?: string;
-    fullName?: string;
-    slackUserId?: string;
-    slackUserName?: string;
-}
 export interface AgentTurnSessionRecord {
     channelName?: string;
     version: number;
@@ -21,7 +16,7 @@ export interface AgentTurnSessionRecord {
     lastProgressAtMs: number;
     loadedSkillNames?: string[];
     piMessages: PiMessage[];
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     resumeReason?: AgentTurnResumeReason;
     resumedFromSliceId?: number;
     sessionId: string;
@@ -30,9 +25,10 @@ export interface AgentTurnSessionRecord {
     state: AgentTurnSessionStatus;
     surface?: AgentTurnSurface;
     traceId?: string;
+    turnStartMessageIndex?: number;
     updatedAtMs: number;
 }
-export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "piMessages">;
+export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "piMessages" | "turnStartMessageIndex">;
 /** Read a materialized turn session record for resume and history loading. */
 export declare function getAgentTurnSessionRecord(conversationId: string, sessionId: string): Promise<AgentTurnSessionRecord | undefined>;
 /** Commit stable Pi session state and advance the turn session record. */
@@ -49,11 +45,12 @@ export declare function upsertAgentTurnSessionRecord(args: {
     state: AgentTurnSessionStatus;
     surface?: AgentTurnSurface;
     piMessages: PiMessage[];
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     resumeReason?: AgentTurnResumeReason;
     errorMessage?: string;
     resumedFromSliceId?: number;
     traceId?: string;
+    turnStartMessageIndex?: number;
     ttlMs?: number;
 }): Promise<AgentTurnSessionRecord>;
 /** Record turn-session metadata without storing conversation messages. */
@@ -65,7 +62,7 @@ export declare function recordAgentTurnSessionSummary(args: {
     destination?: Destination;
     lastProgressAtMs?: number;
     loadedSkillNames?: string[];
-    requester?: AgentTurnRequester;
+    requester?: StoredSlackRequester;
     resumeReason?: AgentTurnResumeReason;
     sessionId: string;
     sliceId: number;

package/dist/chat/task-execution/slack-work.d.ts

@@ -1,10 +1,10 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { Message, ThreadImpl, type SerializedMessage, type SerializedThread, type StateAdapter } from "chat";
 import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
-import type { InboundMessageRecord } from "@/chat/task-execution/store";
+import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
 import { type SlackInstallationContext } from "@/chat/slack/adapter-context";
-import { type SlackActorProfile } from "@/chat/services/requester-identity";
+import { type SlackRequesterProfile } from "@/chat/requester";
 export type SlackConversationRoute = "mention" | "subscribed";
 export interface SlackConversationMessageMetadata {
     [key: string]: unknown;
@@ -16,8 +16,8 @@ export interface SlackConversationMessageMetadata {
 }
 export interface CreateSlackConversationWorkerOptions {
     getSlackAdapter: () => SlackAdapter;
-    lookupSlackUser?: (userId: string) => Promise<SlackActorProfile | null | undefined>;
-    resumeAwaitingContinuation?: (conversationId: string) => Promise<boolean>;
+    lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>;
+    resumeAwaitingContinuation: (conversationId: string) => Promise<boolean>;
     runtime: Pick<SlackTurnRuntime<unknown>, "handleNewMention" | "handleSubscribedMessage">;
     state?: StateAdapter;
 }
@@ -31,4 +31,4 @@ export declare function buildSlackInboundMessage(args: {
     receivedAtMs: number;
     route: SlackConversationRoute;
     thread: ThreadImpl;
-}): InboundMessageRecord;
+}): InboundMessage;