@sentry/junior 0.89.0 → 0.91.0

package/dist/{catalog-runtime-MW7XERSU.js → catalog-runtime-DXE6NXHT.js}

@@ -1,11 +1,11 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-KBFQXJL4.js";
-import "./chunk-KQKIA4CU.js";
-import "./chunk-6APU57E6.js";
-import "./chunk-VMBZFPZM.js";
-import "./chunk-FTMXFBDC.js";
+} from "./chunk-XP7F4LYB.js";
+import "./chunk-ZUK7BL63.js";
+import "./chunk-OB42YVAE.js";
 import "./chunk-3DA7X2U3.js";
+import "./chunk-6APU57E6.js";
+import "./chunk-LFLTJQVR.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

package/dist/chat/agent/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentRunOutcome } from "@/chat/runtime/agent-run-outcome";
+import { type AgentRunRequest } from "@/chat/agent/request";
+/** Run a full agent turn: discover skills, execute tools, and return the assistant reply. */
+export declare function executeAgentRun(request: AgentRunRequest): Promise<AgentRunOutcome>;

package/dist/chat/agent/prompt.d.ts

@@ -0,0 +1,78 @@
+import type { PiMessage } from "@/chat/pi/messages";
+import { type LogContext } from "@/chat/logging";
+import { type ConversationPrivacy } from "@/chat/conversation-privacy";
+import type { SkillInvocation, SkillMetadata } from "@/chat/skills";
+import type { ActiveMcpCatalogSummary } from "@/chat/tool-support/skill/mcp-tool-summary";
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+import type { AnyToolDefinition } from "@/chat/tools/definition";
+import type { Requester } from "@/chat/requester";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { AgentRunInput, AgentRunInstructionActor, AgentRunRouting, AgentRunSteeringMessage } from "@/chat/agent/request";
+export type UserContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+};
+/** User-turn content parts plus the plain-text blocks used for routing decisions. */
+export interface PromptInput {
+    routerBlocks: string[];
+    userContentParts: UserContentPart[];
+}
+/** Fully assembled prompt state for one run slice. */
+export interface PromptAssembly {
+    baseInstructions: string;
+    inputMessages: Array<{
+        role: string;
+        content: Record<string, unknown>[];
+    }>;
+    inputMessagesAttribute: string | undefined;
+    promptContentParts: UserContentPart[];
+    promptHistoryMessages: PiMessage[];
+    shouldPromptAgent: boolean;
+}
+/**
+ * Keep thread text separate from the canonical active task boundary.
+ */
+export declare function buildUserTurnText(userInput: string, conversationContext?: string, actor?: AgentRunInstructionActor): string;
+/** Encode a non-image attachment as base64 XML for the prompt. */
+export declare function encodeNonImageAttachmentForPrompt(attachment: {
+    data: Buffer;
+    mediaType: string;
+    filename?: string;
+}): string;
+/** Redact image data from prompt content parts for observability. */
+export declare function toObservablePromptPart(part: UserContentPart): Record<string, unknown>;
+/** Build the prompt-facing user input, keeping router text aligned with Pi content. */
+export declare function buildPromptInput(input: AgentRunInput): PromptInput;
+/**
+ * Convert a mid-run user message into the Pi user message shape used for
+ * steering injection and parked-conversation session-log appends, so both
+ * paths store identical durable history.
+ */
+export declare function buildSteeringPiMessage(message: AgentRunSteeringMessage): PiMessage;
+/** Assemble prompt history, instructions, and telemetry input for one slice. */
+export declare function assemblePrompt(args: {
+    activeMcpCatalogs: ActiveMcpCatalogSummary[];
+    actorRequester?: Requester;
+    artifactState?: ThreadArtifactsState;
+    availableSkills: SkillMetadata[];
+    configurationValues: Record<string, unknown>;
+    conversationPrivacy?: ConversationPrivacy;
+    existingSessionPiMessages?: PiMessage[];
+    existingTurnStartMessageIndex?: number;
+    invocation: SkillInvocation | null;
+    priorPiMessages?: PiMessage[];
+    resumedFromSessionRecord: boolean;
+    routing: AgentRunRouting;
+    spanContext: LogContext;
+    toolGuidance: Array<{
+        name: string;
+        promptGuidelines: AnyToolDefinition["promptGuidelines"];
+        promptSnippet: AnyToolDefinition["promptSnippet"];
+    }>;
+    toolRuntimeContext: ToolRuntimeContext;
+    userContentParts: UserContentPart[];
+}): Promise<PromptAssembly>;

package/dist/chat/{respond.d.ts → agent/request.d.ts}

@@ -1,22 +1,59 @@
+/**
+ * Agent run request contract.
+ *
+ * Groups the per-slice run request by the runtime role each field serves and
+ * owns interpretation of the routing group: requester derivation, surface
+ * inference, destination consistency checks, and session identifiers. Run
+ * phases consume these groups directly; callers build them at runtime
+ * boundaries.
+ */
 import type { Destination, Source } from "@sentry/junior-plugin-api";
 import type { ChannelConfigurationService } from "@/chat/configuration/types";
-import type { ThreadArtifactsState } from "@/chat/state/artifacts";
-import type { ConversationPendingAuthState } from "@/chat/state/conversation";
-import type { ImageGenerateToolDeps, WebFetchToolDeps, WebSearchToolDeps } from "@/chat/tools/types";
+import type { CredentialContext } from "@/chat/credentials/context";
 import type { PiMessage } from "@/chat/pi/messages";
-import { type SandboxAcquiredState } from "@/chat/sandbox/sandbox";
+import { type Requester } from "@/chat/requester";
+import type { SandboxAcquiredState } from "@/chat/sandbox/sandbox";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
+import type { AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SlackConversationContext } from "@/chat/slack/conversation-context";
-import { type ToolExecutionReport } from "@/chat/tools/agent-tools";
-import { type AssistantReply, type AgentTurnDiagnostics } from "@/chat/services/turn-result";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { ConversationPendingAuthState } from "@/chat/state/conversation";
 import type { AgentTurnSurface } from "@/chat/state/turn-session";
-import type { CredentialContext } from "@/chat/credentials/context";
-import { type Requester } from "@/chat/requester";
-import { type AuthorizationFlowMode } from "@/chat/services/auth-pause";
-export type { AssistantReply, AgentTurnDiagnostics };
-export interface ReplyRequestContext {
-    skillDirs?: string[];
+import type { ToolExecutionReport } from "@/chat/tool-support/tool-execution-report";
+import type { ImageGenerateToolDeps, WebFetchToolDeps, WebSearchToolDeps } from "@/chat/tools/types";
+export interface AgentRunAttachment {
+    data?: Buffer;
+    mediaType: string;
+    filename?: string;
+    promptText?: string;
+}
+export interface AgentRunInstructionActor {
+    authorId?: string;
+    authorName?: string;
+    slackTs?: string;
+}
+export interface AgentRunSteeringMessage {
+    actor?: AgentRunInstructionActor;
+    omittedImageAttachmentCount?: number;
+    text: string;
+    timestampMs?: number;
+    userAttachments?: AgentRunAttachment[];
+}
+/** Carries the user-visible content and prior transcript for one agent-run slice. */
+export interface AgentRunInput {
+    actor?: AgentRunInstructionActor;
+    includeConversationContextWithPiMessages?: boolean;
+    messageText: string;
+    userAttachments?: AgentRunAttachment[];
+    inboundAttachmentCount?: number;
+    omittedImageAttachmentCount?: number;
+    /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
+    piMessages?: PiMessage[];
+    conversationContext?: string;
+}
+/** Carries identity and addressing needed to route tools, auth, and delivery. */
+export interface AgentRunRouting {
     credentialContext?: CredentialContext;
     requester?: Requester;
     source: Source;
@@ -44,38 +81,38 @@ export interface ReplyRequestContext {
         requesterId?: string;
     };
     toolChannelId?: string;
-    conversationContext?: string;
-    artifactState?: ThreadArtifactsState;
-    pendingAuth?: ConversationPendingAuthState;
-    authorizationFlowMode?: AuthorizationFlowMode;
-    configuration?: Record<string, unknown>;
-    /** Durable Pi transcript for this conversation, excluding ephemeral turn context. */
-    piMessages?: PiMessage[];
+}
+/** Carries execution limits and dependency overrides for one run slice. */
+export interface AgentRunPolicy {
     /** Absolute wall-clock deadline for this host request, in milliseconds. */
     turnDeadlineAtMs?: number;
+    authorizationFlowMode?: AuthorizationFlowMode;
+    configuration?: Record<string, unknown>;
     channelConfiguration?: ChannelConfigurationService;
-    userAttachments?: ReplyRequestAttachment[];
-    inboundAttachmentCount?: number;
-    omittedImageAttachmentCount?: number;
-    sandbox?: {
-        sandboxId?: string;
-        sandboxDependencyProfileHash?: string;
-        /** Per-turn override for app-owned sandbox egress trace propagation. */
-        tracePropagation?: SandboxEgressTracePropagationConfig;
-    };
-    onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
-    onArtifactStateUpdated?: (artifactState: ThreadArtifactsState) => void | Promise<void>;
-    onInputCommitted?: () => void | Promise<void>;
+    skillDirs?: string[];
+    /** Per-slice override for app-owned sandbox egress trace propagation. */
+    sandboxTracePropagation?: SandboxEgressTracePropagationConfig;
     toolOverrides?: {
         imageGenerate?: ImageGenerateToolDeps;
         webFetch?: WebFetchToolDeps;
         webSearch?: WebSearchToolDeps;
     };
-    onStatus?: (status: AssistantStatusSpec) => void | Promise<void>;
-    drainSteeringMessages?: (accept: (messages: ReplySteeringMessage[]) => Promise<void>) => Promise<ReplySteeringMessage[]>;
-    /** Return true when the durable worker should pause at the next Pi boundary. */
-    shouldYield?: () => boolean;
-    recordPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+}
+/** Carries durable state snapshots already loaded by the caller. */
+export interface AgentRunState {
+    artifactState?: ThreadArtifactsState;
+    pendingAuth?: ConversationPendingAuthState;
+    /** Persisted sandbox reuse state from prior slices of this conversation. */
+    sandbox?: {
+        sandboxId?: string;
+        sandboxDependencyProfileHash?: string;
+    };
+}
+/**
+ * Carries notification-only callbacks for streaming UI and status surfaces;
+ * their failures never affect the run.
+ */
+export interface AgentRunObservers {
     onTextDelta?: (deltaText: string) => void | Promise<void>;
     onAssistantMessageStart?: () => void | Promise<void>;
     onToolInvocation?: (invocation: {
@@ -83,25 +120,39 @@ export interface ReplyRequestContext {
         params: Record<string, unknown>;
     }) => void | Promise<void>;
     onToolResult?: (result: ToolExecutionReport) => void | Promise<void>;
+    onStatus?: (status: AssistantStatusSpec) => void | Promise<void>;
 }
-export type AssistantReplyRequestContext = ReplyRequestContext;
-export interface ReplyRequestAttachment {
-    data?: Buffer;
-    mediaType: string;
-    filename?: string;
-    promptText?: string;
+/** Carries durable-worker ports that commit or update resumable run state. */
+export interface AgentRunDurability {
+    onInputCommitted?: () => void | Promise<void>;
+    /** Return true when the durable worker should pause at the next Pi boundary. */
+    shouldYield?: () => boolean;
+    drainSteeringMessages?: (accept: (messages: AgentRunSteeringMessage[]) => Promise<void>) => Promise<AgentRunSteeringMessage[]>;
+    recordPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
+    onArtifactStateUpdated?: (artifactState: ThreadArtifactsState) => void | Promise<void>;
 }
-export interface ReplySteeringMessage {
-    omittedImageAttachmentCount?: number;
-    text: string;
-    timestampMs?: number;
-    userAttachments?: ReplyRequestAttachment[];
+/** Groups the per-slice run request by the runtime role each field serves. */
+export interface AgentRunRequest {
+    input: AgentRunInput;
+    routing: AgentRunRouting;
+    policy?: AgentRunPolicy;
+    state?: AgentRunState;
+    observers?: AgentRunObservers;
+    durability?: AgentRunDurability;
 }
-/**
- * Convert a mid-run user message into the Pi user message shape used for
- * steering injection and parked-conversation session-log appends, so both
- * paths store identical durable history.
- */
-export declare function buildSteeringPiMessage(message: ReplySteeringMessage): PiMessage;
-/** Run a full agent turn: discover skills, execute tools, and return the assistant reply. */
-export declare function generateAssistantReply(messageText: string, context: AssistantReplyRequestContext): Promise<AssistantReply>;
+/** Extract conversation and session identifiers from correlation context. */
+export declare function getSessionIdentifiers(routing: AgentRunRouting): {
+    conversationId?: string;
+    sessionId?: string;
+};
+/** Derive the acting requester, filling platform and team from the destination. */
+export declare function requesterFromRouting(routing: AgentRunRouting): Requester | undefined;
+/** Reject requester identities that do not belong to the active destination. */
+export declare function assertRequesterDestinationMatch(routing: AgentRunRouting): void;
+/** Reject legacy Slack correlation fields that conflict with the destination. */
+export declare function assertCorrelationDestinationMatch(routing: AgentRunRouting): void;
+/** Route tool side effects to the tool channel when one overrides the destination. */
+export declare function toolInvocationDestination(routing: AgentRunRouting): Destination;
+/** Infer the run surface when the caller did not state one. */
+export declare function surfaceFromRouting(routing: AgentRunRouting): AgentTurnSurface | undefined;

package/dist/chat/agent/resume.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Run resumability.
+ *
+ * Owns the durable state that lets a run slice stop without losing work:
+ * safe-boundary checkpoints, the durable input commit, resume snapshots, and
+ * persistence of the expected endings (cooperative yield, continuable
+ * timeout, auth pause) translated into `AgentRunOutcome` values so the
+ * executor's catch block stays a thin translation over genuine errors.
+ */
+import type { Destination, Source } from "@sentry/junior-plugin-api";
+import type { PiMessage } from "@/chat/pi/messages";
+import { CooperativeTurnYieldError } from "@/chat/runtime/turn";
+import type { AgentRunOutcome } from "@/chat/runtime/agent-run-outcome";
+import type { AgentTurnSurface } from "@/chat/state/turn-session";
+import type { Requester } from "@/chat/requester";
+import { loadTurnSessionRecord, persistRunningSessionRecord } from "@/chat/services/turn-session-record";
+import { type AgentTurnUsage } from "@/chat/usage";
+import type { AgentRunDurability } from "@/chat/agent/request";
+type LoadedSessionRecordState = Awaited<ReturnType<typeof loadTurnSessionRecord>>;
+type SessionRecordLogContext = NonNullable<Parameters<typeof persistRunningSessionRecord>[0]["logContext"]>;
+interface ResumeStateArgs {
+    channelName?: string;
+    destination: Destination;
+    durability: AgentRunDurability;
+    getLoadedSkillNames: () => string[];
+    logContext: SessionRecordLogContext;
+    recordActiveMcpProviders: () => Promise<void>;
+    requester?: Requester;
+    runSource: Source;
+    sessionConversationId?: string;
+    sessionId?: string;
+    sessionRecordState: LoadedSessionRecordState;
+    startedAtMs: number;
+    surface?: AgentTurnSurface;
+}
+interface ExpectedEndingTranslation {
+    outcome?: AgentRunOutcome;
+}
+/** Create the run's resume state: checkpoints, snapshots, and ending translation. */
+export declare function createResumeState(args: ResumeStateArgs): {
+    readonly inputCommitted: boolean;
+    readonly beforeMessageCount: number;
+    readonly timedOut: boolean;
+    readonly cooperativeYieldError: CooperativeTurnYieldError | undefined;
+    setTurnStartMessageIndex(index: number | undefined): void;
+    setBeforeMessageCount(count: number): void;
+    captureResumeSnapshot(messages: PiMessage[]): void;
+    getResumeSnapshot(currentMessages: PiMessage[]): PiMessage[];
+    markTimedOut(): void;
+    commitInput(): Promise<void>;
+    persistSafeBoundary(messages: PiMessage[]): Promise<boolean>;
+    requireDurableInputCheckpoint(messages: PiMessage[]): Promise<boolean>;
+    yieldAtSafeBoundaryIfDue(currentMessages: PiMessage[]): void;
+    /**
+     * Persist the continuation for an expected run ending and translate it
+     * into an outcome; returns no outcome for genuine errors so the caller's
+     * error guards run.
+     */
+    translateExpectedEnding(args2: {
+        currentUsage?: AgentTurnUsage;
+        error: unknown;
+    }): Promise<ExpectedEndingTranslation>;
+};
+export type ResumeState = ReturnType<typeof createResumeState>;
+export {};

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

@@ -0,0 +1,15 @@
+/**
+ * Run-scoped sandbox workspace.
+ *
+ * Exposes a stable workspace port to tools while deferring the actual
+ * sandbox boot until a tool first touches the filesystem or runs a command,
+ * and rebinding when the executor's sandbox identity changes mid-run.
+ */
+import { type LogContext } from "@/chat/logging";
+import type { SandboxExecutor } from "@/chat/sandbox/sandbox";
+import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
+/** Create a lazy-boot workspace port bound to the run's sandbox executor. */
+export declare function createLazySandboxWorkspace(args: {
+    executor: SandboxExecutor;
+    spanContext: LogContext;
+}): SandboxWorkspace;

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

@@ -0,0 +1,20 @@
+/**
+ * Run session restore.
+ *
+ * Loads the persisted turn session projection for one run slice before the
+ * tool and prompt phases need it, resolving the durable conversation and
+ * session identifiers from routing.
+ */
+import { loadTurnSessionRecord } from "@/chat/services/turn-session-record";
+import { type AgentRunRouting } from "@/chat/agent/request";
+type LoadedSessionRecordState = Awaited<ReturnType<typeof loadTurnSessionRecord>>;
+/** Restore the persisted session projection for one run slice. */
+export declare function restoreSessionRecord(routing: AgentRunRouting): Promise<{
+    existingSessionRecord: LoadedSessionRecordState["existingSessionRecord"];
+    currentSliceId: number;
+    resumedFromSessionRecord: boolean;
+    sessionConversationId?: string;
+    sessionId?: string;
+    sessionRecordState: LoadedSessionRecordState;
+}>;
+export {};

package/dist/chat/agent/skills.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Run-scoped skill discovery and restore.
+ *
+ * Discovers the skills available to one run slice and rehydrates active skill
+ * handles from durable Pi history and explicit invocation, so resumed slices
+ * keep the skill state the conversation already established.
+ */
+import { type LogContext } from "@/chat/logging";
+import { type Skill, type SkillMetadata } from "@/chat/skills";
+import { SkillSandbox } from "@/chat/sandbox/skill-sandbox";
+import type { PiMessage } from "@/chat/pi/messages";
+/** Upsert a skill into the active skills list by name. */
+export declare function upsertActiveSkill(activeSkills: Skill[], next: Skill): void;
+/** Discover skills for one slice; emits the startup discovery summary once per process. */
+export declare function discoverRunSkills(args: {
+    skillDirs?: string[];
+    spanContext: LogContext;
+}): Promise<SkillMetadata[]>;
+/** Rehydrate active skill handles from durable Pi history and explicit invocation. */
+export declare function restoreSkillRuntime(args: {
+    activeSkills: Skill[];
+    invokedSkill: SkillMetadata | null;
+    priorPiMessages: PiMessage[] | undefined;
+    skillSandbox: SkillSandbox;
+    syncLoadedSkillNamesForResume: () => void;
+}): Promise<void>;

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

@@ -0,0 +1,78 @@
+/**
+ * Run tool wiring.
+ *
+ * Builds everything the agent can act through for one run slice: the sandbox
+ * executor and lazy workspace, MCP and plugin auth orchestration, MCP
+ * provider restoration from durable history, and the Pi-facing tool surfaces
+ * (agent tools plus the advisor's tool view). Auth pauses raised while
+ * restoring providers are thrown here so the run parks before prompting.
+ */
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import type { FileUpload } from "chat";
+import { SkillSandbox } from "@/chat/sandbox/skill-sandbox";
+import type { Skill, SkillMetadata } from "@/chat/skills";
+import { type PluginHookRunner } from "@/chat/plugins/agent-hooks";
+import { McpToolManager } from "@/chat/mcp/tool-manager";
+import type { AnyToolDefinition } from "@/chat/tools/definition";
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+import { type ActiveMcpCatalogSummary } from "@/chat/tool-support/skill/mcp-tool-summary";
+import { type SandboxExecutor } from "@/chat/sandbox/sandbox";
+import type { PiMessage } from "@/chat/pi/messages";
+import type { LogContext } from "@/chat/logging";
+import type { ConversationPrivacy } from "@/chat/conversation-privacy";
+import type { Requester } from "@/chat/requester";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { AuthorizationPauseError } from "@/chat/services/auth-pause";
+import type { AgentTurnSurface } from "@/chat/state/turn-session";
+import { type AgentRunDurability, type AgentRunObservers, type AgentRunPolicy, type AgentRunRouting, type AgentRunState } from "@/chat/agent/request";
+import type { ResumeState } from "@/chat/agent/resume";
+interface ToolWiringArgs {
+    abortAgent: () => void;
+    activeSkills: Skill[];
+    actorRequester?: Requester;
+    artifactStatePatch: Partial<ThreadArtifactsState>;
+    availableSkills: SkillMetadata[];
+    configurationValues: Record<string, unknown>;
+    connectedMcpProviders: Set<string>;
+    conversationPrivacy?: ConversationPrivacy;
+    durability: AgentRunDurability;
+    generatedFiles: FileUpload[];
+    invokedSkill: SkillMetadata | null;
+    observers: AgentRunObservers;
+    onSandboxMetadataChanged: (sandbox: {
+        sandboxId?: string;
+        sandboxDependencyProfileHash?: string;
+    }) => void;
+    policy: AgentRunPolicy;
+    preAgentPromptMessages: () => PiMessage[];
+    priorPiMessages: PiMessage[] | undefined;
+    recordConnectedMcpProvider: (provider: string) => Promise<void>;
+    resume: ResumeState;
+    routing: AgentRunRouting;
+    sessionConversationId?: string;
+    sessionId?: string;
+    skillSandbox: SkillSandbox;
+    spanContext: LogContext;
+    state: AgentRunState;
+    surface?: AgentTurnSurface;
+    syncLoadedSkillNamesForResume: () => void;
+    toolCalls: string[];
+    userInput: string;
+}
+export interface ToolWiring {
+    activeMcpCatalogs: ActiveMcpCatalogSummary[];
+    agentTools: AgentTool[];
+    getPendingAuthPause: () => AuthorizationPauseError | undefined;
+    mcpToolManager: McpToolManager;
+    pluginHooks: PluginHookRunner;
+    sandboxExecutor: SandboxExecutor;
+    toolGuidance: Array<{
+        name: string;
+        promptGuidelines: AnyToolDefinition["promptGuidelines"];
+        promptSnippet: AnyToolDefinition["promptSnippet"];
+    }>;
+    toolRuntimeContext: ToolRuntimeContext;
+}
+/** Wire sandbox, auth orchestration, MCP restoration, and Pi tool surfaces for one slice. */
+export declare function wireAgentTools(args: ToolWiringArgs): Promise<ToolWiring>;
+export {};

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

@@ -1,13 +1,11 @@
-import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
-import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
+import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import { scheduleSessionCompletedPluginTasks } from "@/chat/plugins/task-runner";
 import { scheduleDispatchCallback } from "./signing";
 import type { DispatchCallback } from "./types";
 export interface AgentDispatchRunnerDeps {
-    generateAssistantReply?: typeof generateAssistantReplyImpl;
+    agentRunner: AgentRunner;
     scheduleCallback?: typeof scheduleDispatchCallback;
     scheduleSessionCompletedPluginTasks?: typeof scheduleSessionCompletedPluginTasks;
-    tracePropagation?: SandboxEgressTracePropagationConfig;
 }
 /** Run one serverless slice for a core-owned agent dispatch. */
-export declare function runAgentDispatchSlice(callback: DispatchCallback, deps?: AgentDispatchRunnerDeps): Promise<void>;
+export declare function runAgentDispatchSlice(callback: DispatchCallback, deps: AgentDispatchRunnerDeps): Promise<void>;

package/dist/chat/app/production.d.ts

@@ -1,5 +1,6 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
 import { createSlackRuntime } from "@/chat/app/factory";
+import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import type { SlackWebhookServices } from "@/chat/ingress/slack-webhook";
 import type { VercelConversationWorkCallbackOptions } from "@/chat/task-execution/vercel-callback";
 import type { JuniorRuntimeServiceOverrides } from "@/chat/app/services";
@@ -17,6 +18,7 @@ export declare function createProductionSlackWebhookServices(options?: {
 /** Return production services for Slack webhook ingress. */
 export declare function getProductionSlackWebhookServices(): SlackWebhookServices;
 /** Return the production queue callback options for conversation work. */
-export declare function createProductionConversationWorkOptions(options?: {
+export declare function createProductionConversationWorkOptions(options: {
+    agentRunner: AgentRunner;
     services?: JuniorRuntimeServiceOverrides;
 }): VercelConversationWorkCallbackOptions;

package/dist/chat/app/services.d.ts

@@ -1,10 +1,9 @@
-import { generateAssistantReply as generateAssistantReplyImpl } from "@/chat/respond";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import { type ConversationMemoryDeps, type ConversationMemoryService } from "@/chat/services/conversation-memory";
 import { type ContextCompactor, type ContextCompactorDeps } from "@/chat/services/context-compaction";
 import { type SubscribedReplyPolicy, type SubscribedReplyPolicyDeps } from "@/chat/services/subscribed-reply-policy";
 import type { ReplyExecutorServices } from "@/chat/runtime/reply-executor";
-import { type VisionContextDeps, type VisionContextService } from "@/chat/services/vision-context";
+import { type VisionContextDeps, type VisionContextService } from "@/chat/slack/vision-context";
 export interface JuniorRuntimeServices {
     conversationMemory: ConversationMemoryService;
     contextCompactor: ContextCompactor;
@@ -22,6 +21,4 @@ export interface JuniorRuntimeServiceOverrides {
     };
     visionContext?: Partial<VisionContextDeps>;
 }
-/** Apply app-owned sandbox egress trace config unless a turn overrides it. */
-export declare function withSandboxTracePropagation(generateReply: typeof generateAssistantReplyImpl, tracePropagation?: SandboxEgressTracePropagationConfig): typeof generateAssistantReplyImpl;
 export declare function createJuniorRuntimeServices(overrides?: JuniorRuntimeServiceOverrides): JuniorRuntimeServices;

package/dist/chat/current-instruction.d.ts

@@ -1,6 +1,8 @@
 /** Render the active user task in a stable prompt boundary. */
-export declare function renderCurrentInstruction(instruction: string): string;
-/** Read the exact body from a standalone current-task prompt boundary. */
-export declare function extractCurrentInstructionBody(text: string): string | undefined;
+export declare function renderCurrentInstruction(instruction: string, attrs?: {
+    authorId?: string;
+    authorName?: string;
+    slackTs?: string;
+}): string;
 /** Recover display text from the internal current-task prompt boundary. */
 export declare function unwrapCurrentInstruction(text: string): string | undefined;

package/dist/chat/logging.d.ts

@@ -39,6 +39,8 @@ interface SentryUserIdentity {
 }
 /** Normalize runtime finish reasons to the telemetry spelling we emit. */
 export declare function normalizeGenAiFinishReason(reason: string): string;
+/** Truncate message text for log attributes. */
+export declare function summarizeMessageText(text: 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

@@ -11,7 +11,7 @@ import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.
 import { type ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { SkillMetadata } from "@/chat/skills";
 import type { PluginDefinition } from "@/chat/plugins/types";
-import { McpAuthorizationRequiredError, type PluginMcpToolCallResult } from "./client";
+import { McpAuthorizationRequiredError } from "./client";
 export interface McpToolManagerOptions {
     authProviderFactory?: (plugin: PluginDefinition) => OAuthClientProvider | undefined | Promise<OAuthClientProvider | undefined>;
     fetch?: typeof fetch;
@@ -19,11 +19,6 @@ export interface McpToolManagerOptions {
 }
 export interface ManagedMcpToolResult {
     content: Array<TextContent | ImageContent>;
-    details: {
-        provider: string;
-        tool: string;
-        rawResult: PluginMcpToolCallResult;
-    };
 }
 export interface ManagedMcpToolDescriptor {
     name: string;

package/dist/chat/oauth-authorization-message.d.ts

@@ -0,0 +1,6 @@
+/** Format the private OAuth authorization prompt for Slack delivery. */
+export declare function formatOAuthAuthorizationMessage(args: {
+    authorizationUrl: string;
+    label: string;
+    completionText: string;
+}): string;

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

@@ -1,3 +1,19 @@
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { z } from "zod";
+/** Permissive schema for durable Pi SDK messages whose content shape may evolve. */
+export declare const piMessageSchema: z.ZodPipe<z.ZodObject<{
+    role: z.ZodString;
+}, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+    [x: string]: unknown;
+    role: string;
+}>>;
 /** Durable Pi transcript message stored across turns. */
-export type PiMessage = AgentMessage;
+export type PiMessage = z.output<typeof piMessageSchema>;
+/** Reporting transcript entries only render messages with structured content parts. */
+export declare const piContentMessageSchema: z.ZodPipe<z.ZodObject<{
+    content: z.ZodArray<z.ZodUnknown>;
+    role: z.ZodString;
+}, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+    [x: string]: unknown;
+    content: unknown[];
+    role: string;
+}>>;