@sentry/junior 0.52.0 → 0.54.0

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

@@ -0,0 +1,27 @@
+import type { CredentialHeaderTransform } from "@/chat/credentials/broker";
+export declare const SANDBOX_EGRESS_PROXY_PATH = "/api/internal/sandbox-egress";
+export interface SandboxEgressRequesterContext {
+    requesterId: string;
+    egressId: string;
+    expiresAtMs: number;
+    contextId: string;
+}
+export interface SandboxEgressCredentialLease {
+    provider: string;
+    expiresAt: string;
+    headerTransforms: CredentialHeaderTransform[];
+}
+/** Create a signed requester/sandbox context token for lazy sandbox egress auth. */
+export declare function createSandboxEgressRequesterToken(input: {
+    requesterId: string;
+    egressId: string;
+    ttlMs?: number;
+}): string;
+/** Verify a signed requester/sandbox context token from the proxy URL. */
+export declare function parseSandboxEgressRequesterToken(token: string | undefined): SandboxEgressRequesterContext | undefined;
+/** Cache a short-lived credential lease for repeated forwarded requests for one requester/sandbox context. */
+export declare function setSandboxEgressCredentialLease(context: SandboxEgressRequesterContext, lease: SandboxEgressCredentialLease): Promise<void>;
+/** Load a cached egress credential lease for a requester/sandbox context/provider pair. */
+export declare function getSandboxEgressCredentialLease(provider: string, context: SandboxEgressRequesterContext): Promise<SandboxEgressCredentialLease | undefined>;
+/** Clear a cached egress credential lease after the provider rejects its headers. */
+export declare function clearSandboxEgressCredentialLease(provider: string, context: SandboxEgressRequesterContext): Promise<void>;

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

@@ -0,0 +1,12 @@
+/** Detect sandbox filesystem operations that can safely ignore existing directories. */
+export declare function isAlreadyExistsError(error: unknown): boolean;
+/** Detect when a cached sandbox can no longer be reused and must be recreated. */
+export declare function isSandboxUnavailableError(error: unknown): boolean;
+/** Detect transient snapshot boot races so sandbox creation can retry. */
+export declare function isSnapshottingError(error: unknown): boolean;
+/** Detect interrupted command streams where no reliable exit status is available. */
+export declare function isSandboxCommandStreamInterruptedError(error: unknown): boolean;
+/** Wrap raw sandbox setup failures into one stable user-facing error contract. */
+export declare function wrapSandboxSetupError(error: unknown): Error;
+/** Record span data and throw one stable sandbox operation error. */
+export declare function throwSandboxOperationError(action: string, error: unknown, includeMissingPath?: boolean): never;

package/dist/chat/sandbox/eval-gh-stub.d.ts

@@ -0,0 +1,2 @@
+/** Build the eval-only GitHub CLI shim copied into sandbox test environments. */
+export declare function buildEvalGitHubCliStub(): string;

package/dist/chat/sandbox/eval-oauth-stub.d.ts

@@ -0,0 +1,2 @@
+/** Build the eval-only generic OAuth CLI shim copied into sandbox eval environments. */
+export declare function buildEvalOauthCliStub(): string;

package/dist/chat/sandbox/eval-sentry-stub.d.ts

@@ -0,0 +1,2 @@
+/** Build the eval-only Sentry CLI shim copied into sandbox test environments. */
+export declare function buildEvalSentryCliStub(): string;

package/dist/chat/sandbox/fault-injection.d.ts

@@ -0,0 +1,2 @@
+/** Consume one eval-only sandbox bash stream interruption fault. */
+export declare function consumeSandboxBashStreamInterruptFault(): Error | undefined;

package/dist/chat/sandbox/http-error-details.d.ts

@@ -0,0 +1,18 @@
+interface ExtraFieldOption {
+    sourceKey: string;
+    attributeKey: string;
+    summaryKey?: string;
+}
+export interface ExtractHttpErrorDetailsOptions {
+    attributePrefix?: string;
+    previewLimit?: number;
+    extraFields?: ExtraFieldOption[];
+}
+export interface ExtractedHttpErrorDetails {
+    attributes: Record<string, string | number | boolean | string[]>;
+    summary: string;
+    searchableText: string;
+}
+/** Extract structured HTTP error metadata (status, headers, body preview) for logging. */
+export declare function extractHttpErrorDetails(error: unknown, options?: ExtractHttpErrorDetailsOptions): ExtractedHttpErrorDetails;
+export {};

package/dist/chat/sandbox/noninteractive-command.d.ts

@@ -0,0 +1,17 @@
+import type { SandboxCommandResult, SandboxWorkspace } from "@/chat/sandbox/workspace";
+interface NonInteractiveShellOptions {
+    env?: Record<string, string>;
+    pathPrefix?: string;
+}
+interface NonInteractiveCommandInput extends NonInteractiveShellOptions {
+    args?: string[];
+    cmd: string;
+    cwd?: string;
+    login?: boolean;
+    sudo?: boolean;
+}
+/** Build one shell entrypoint that never waits on terminal input. */
+export declare function buildNonInteractiveShellScript(script: string, options?: NonInteractiveShellOptions): string;
+/** Run a subprocess through one enforced non-interactive entrypoint. */
+export declare function runNonInteractiveCommand(sandbox: Pick<SandboxWorkspace, "runCommand">, input: NonInteractiveCommandInput): Promise<SandboxCommandResult>;
+export {};

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

@@ -0,0 +1,5 @@
+export declare const SANDBOX_WORKSPACE_ROOT: string;
+export declare const SANDBOX_SKILLS_ROOT: string;
+export declare const SANDBOX_DATA_ROOT: string;
+export declare function sandboxSkillDir(skillName: string): string;
+export declare function sandboxSkillFile(skillName: string): string;

package/dist/chat/sandbox/runtime-dependency-snapshots.d.ts

@@ -0,0 +1,20 @@
+export type SnapshotResolveOutcome = "no_profile" | "cache_hit" | "cache_hit_after_lock_wait" | "rebuilt" | "forced_rebuild";
+export type SnapshotRebuildReason = "cache_miss" | "floating_stale" | "force_rebuild" | "snapshot_missing";
+export interface RuntimeDependencySnapshot {
+    snapshotId?: string;
+    profileHash?: string;
+    dependencyCount: number;
+    cacheHit: boolean;
+    resolveOutcome: SnapshotResolveOutcome;
+    rebuildReason?: SnapshotRebuildReason;
+}
+export type RuntimeDependencySnapshotProgressPhase = "resolve_start" | "cache_hit" | "waiting_for_lock" | "building_snapshot" | "build_complete";
+export declare function getRuntimeDependencyProfileHash(runtime: string): string | undefined;
+export declare function resolveRuntimeDependencySnapshot(params: {
+    runtime: string;
+    timeoutMs: number;
+    forceRebuild?: boolean;
+    staleSnapshotId?: string;
+    onProgress?: (phase: RuntimeDependencySnapshotProgressPhase) => void | Promise<void>;
+}): Promise<RuntimeDependencySnapshot>;
+export declare function isSnapshotMissingError(error: unknown): boolean;

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

@@ -0,0 +1,52 @@
+import { type LogContext } from "@/chat/logging";
+import type { SandboxInstance } from "@/chat/sandbox/workspace";
+import type { SkillMetadata } from "@/chat/skills";
+interface SandboxExecutionInput {
+    toolName: string;
+    input: unknown;
+}
+export interface SandboxExecutionEnvelope<T = unknown> {
+    result: T;
+}
+export interface BashCustomCommandResult {
+    ok: boolean;
+    command: string;
+    cwd: string;
+    exit_code: number;
+    signal: null;
+    timed_out: boolean;
+    stdout: string;
+    stderr: string;
+    stdout_truncated: boolean;
+    stderr_truncated: boolean;
+}
+export interface SandboxAcquiredState {
+    sandboxId: string;
+    sandboxDependencyProfileHash?: string;
+}
+export interface SandboxExecutor {
+    configureSkills(skills: SkillMetadata[]): void;
+    configureReferenceFiles(files: string[]): void;
+    getSandboxId(): string | undefined;
+    getDependencyProfileHash(): string | undefined;
+    canExecute(toolName: string): boolean;
+    createSandbox(): Promise<SandboxInstance>;
+    execute<T>(params: SandboxExecutionInput): Promise<SandboxExecutionEnvelope<T>>;
+    dispose(): Promise<void>;
+}
+/** Create one sandbox-backed tool executor facade for the current turn. */
+export declare function createSandboxExecutor(options?: {
+    sandboxId?: string;
+    sandboxDependencyProfileHash?: string;
+    timeoutMs?: number;
+    traceContext?: LogContext;
+    credentialEgress?: {
+        requesterId: string;
+    };
+    onSandboxAcquired?: (sandbox: SandboxAcquiredState) => void | Promise<void>;
+    runBashCustomCommand?: (command: string) => Promise<{
+        handled: boolean;
+        result?: BashCustomCommandResult;
+    }>;
+}): SandboxExecutor;
+export {};

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

@@ -0,0 +1,53 @@
+import { type NetworkPolicy } from "@vercel/sandbox";
+import { type LogContext } from "@/chat/logging";
+import { type SandboxFileSystem, type SandboxInstance } from "@/chat/sandbox/workspace";
+import type { SkillMetadata } from "@/chat/skills";
+interface SandboxToolExecutors {
+    bash: (input: {
+        command: string;
+        env?: Record<string, string>;
+        timeoutMs?: number;
+    }) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        stdoutTruncated: boolean;
+        stderrTruncated: boolean;
+        timedOut?: boolean;
+    }>;
+    readFile: (input: {
+        path: string;
+    }) => Promise<{
+        content: string;
+    }>;
+    writeFile: (input: {
+        path: string;
+        content: string;
+    }) => Promise<{
+        success: boolean;
+    }>;
+    fs: SandboxFileSystem;
+}
+interface SandboxSessionManager {
+    configureSkills(skills: SkillMetadata[]): void;
+    configureReferenceFiles(files: string[]): void;
+    getSandboxId(): string | undefined;
+    getDependencyProfileHash(): string | undefined;
+    createSandbox(): Promise<SandboxInstance>;
+    ensureToolExecutors(): Promise<SandboxToolExecutors>;
+    dispose(): Promise<void>;
+}
+/** Manage sandbox lifecycle, sync, keepalive, and tool executor caching for one executor instance. */
+export declare function createSandboxSessionManager(options?: {
+    sandboxId?: string;
+    sandboxDependencyProfileHash?: string;
+    timeoutMs?: number;
+    traceContext?: LogContext;
+    commandEnv?: () => Promise<Record<string, string>>;
+    createNetworkPolicy?: (egressId: string) => NetworkPolicy | undefined;
+    onSandboxAcquired?: (sandbox: {
+        sandboxId: string;
+        sandboxDependencyProfileHash?: string;
+    }) => void | Promise<void>;
+}): SandboxSessionManager;
+export {};

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

@@ -0,0 +1,42 @@
+import { type Skill, type SkillMetadata } from "@/chat/skills";
+export interface SkillSandboxFileEntry {
+    path: string;
+    type: "file" | "directory";
+}
+export interface SkillSandboxListFilesResult {
+    skillName: string;
+    directory: string;
+    entries: SkillSandboxFileEntry[];
+    truncated: boolean;
+}
+export interface SkillSandboxReadFileResult {
+    skillName: string;
+    path: string;
+    content: string;
+    truncated: boolean;
+}
+/** Sandboxed file access scoped to the active skill's directory — prevents path traversal. */
+export declare class SkillSandbox {
+    private readonly availableSkills;
+    private readonly availableByName;
+    private readonly loadedSkills;
+    private activeSkillName;
+    constructor(availableSkills: SkillMetadata[], preloadedSkills?: Skill[]);
+    getAvailableSkills(): SkillMetadata[];
+    getLoadedSkillNames(): string[];
+    getActiveSkill(): Skill | null;
+    loadSkill(skillName: string): Promise<Skill | null>;
+    filterToolNames(toolNames: string[]): string[] | null;
+    listFiles(params: {
+        skillName?: string;
+        directory?: string;
+        recursive?: boolean;
+        maxEntries?: number;
+    }): Promise<SkillSandboxListFilesResult>;
+    readFile(params: {
+        skillName?: string;
+        filePath: string;
+        maxChars?: number;
+    }): Promise<SkillSandboxReadFileResult>;
+    private requireSkill;
+}

package/dist/chat/sandbox/skill-sync.d.ts

@@ -0,0 +1,17 @@
+import type { SandboxInstance } from "@/chat/sandbox/workspace";
+import type { SkillMetadata } from "@/chat/skills";
+/** Resolve a virtual sandbox skill path back to the host filesystem when no sandbox exists yet. */
+export declare function resolveHostSkillPath(availableSkills: SkillMetadata[], sandboxPath: string): string | null;
+/** Resolve a virtual sandbox data path back to the host filesystem when no sandbox exists yet. */
+export declare function resolveHostDataPath(referenceFiles: string[], sandboxPath: string): string | null;
+/** Detect missing host-backed skill files so reads can fall back to the sandbox copy. */
+export declare function isHostFileMissingError(error: unknown): boolean;
+/** Copy the current skill set and reference files into a sandbox and mark runtime shims executable. */
+export declare function syncSkillsToSandbox(params: {
+    sandbox: SandboxInstance;
+    skills: SkillMetadata[];
+    referenceFiles?: string[];
+    withSpan: <T>(name: string, op: string, attributes: Record<string, unknown>, callback: () => Promise<T>) => Promise<T>;
+    runtimeBinDir: string;
+    workspaceRoot?: string;
+}): Promise<void>;

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

@@ -0,0 +1,55 @@
+import type { NetworkPolicy, Sandbox as VercelSandbox } from "@vercel/sandbox";
+export interface SandboxCommandResult {
+    exitCode: number;
+    stderr(): Promise<string>;
+    stdout(): Promise<string>;
+}
+export interface SandboxCommandInput {
+    args?: string[];
+    cmd: string;
+    cwd?: string;
+    env?: Record<string, string>;
+    signal?: AbortSignal;
+    sudo?: boolean;
+}
+export interface SandboxFileStat {
+    isDirectory(): boolean;
+}
+export interface SandboxFileSystem {
+    readFile(filePath: string, options: {
+        encoding: BufferEncoding;
+    }): Promise<string>;
+    writeFile(filePath: string, content: string, options?: {
+        encoding?: BufferEncoding;
+    }): Promise<void>;
+    readdir(filePath: string): Promise<string[]>;
+    stat(filePath: string): Promise<SandboxFileStat>;
+}
+export interface SandboxWorkspace {
+    readFileToBuffer(input: {
+        cwd?: string;
+        path: string;
+    }): Promise<Buffer | null | undefined>;
+    runCommand(input: SandboxCommandInput): Promise<SandboxCommandResult>;
+}
+export interface SandboxInstance extends SandboxWorkspace {
+    readonly sandboxId: string;
+    readonly sandboxEgressId: string;
+    readonly fs: SandboxFileSystem;
+    extendTimeout(duration: number): Promise<void>;
+    mkDir(path: string): Promise<void>;
+    snapshot(): Promise<{
+        snapshotId: string;
+    }>;
+    stop(): Promise<unknown>;
+    update(params: {
+        networkPolicy?: NetworkPolicy;
+    }): Promise<void>;
+    writeFiles(files: Array<{
+        content: string | Uint8Array;
+        mode?: number;
+        path: string;
+    }>): Promise<void>;
+}
+/** Adapt the Vercel SDK object once so the rest of Junior sees one sandbox contract. */
+export declare function createSandboxInstance(sandbox: VercelSandbox): SandboxInstance;

package/dist/chat/sentry.d.ts

@@ -0,0 +1,2 @@
+/** Sentry SDK re-export. Isolates the concrete package to a single file. */
+export * from "@sentry/node";

package/dist/chat/services/attachment-claims.d.ts

@@ -0,0 +1,2 @@
+/** Append a correction when the assistant claims it attached a file but none was actually delivered. */
+export declare function enforceAttachmentClaimTruth(text: string, hasAttachedFiles: boolean): string;

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

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

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

@@ -0,0 +1,12 @@
+export type AuthorizationPauseKind = "mcp" | "plugin";
+export type AuthorizationPauseDisposition = "link_already_sent" | "link_sent";
+/**
+ * Runtime-owned signal that the current turn must park until the user
+ * completes an external authorization step.
+ */
+export declare class AuthorizationPauseError extends Error {
+    readonly disposition: AuthorizationPauseDisposition;
+    readonly kind: AuthorizationPauseKind;
+    readonly provider: string;
+    constructor(kind: AuthorizationPauseKind, provider: string, disposition: AuthorizationPauseDisposition);
+}

package/dist/chat/services/channel-intent.d.ts

@@ -0,0 +1,2 @@
+/** Detect whether the user explicitly asked the assistant to post a message in the channel (not the thread). */
+export declare function isExplicitChannelPostIntent(text: string): boolean;

package/dist/chat/services/conversation-memory.d.ts

@@ -0,0 +1,33 @@
+import type { completeText } from "@/chat/pi/client";
+import type { ConversationMessage, ThreadConversationState } from "@/chat/state/conversation";
+export interface ConversationMemoryDeps {
+    completeText: typeof completeText;
+}
+export interface ConversationMemoryService {
+    compactConversationIfNeeded: (conversation: ThreadConversationState, context: {
+        threadId?: string;
+        channelId?: string;
+        requesterId?: string;
+        runId?: string;
+    }) => Promise<void>;
+    generateThreadTitle: (sourceText: string) => Promise<string>;
+}
+export declare function generateConversationId(prefix: "assistant" | "backfill" | "compaction" | "turn"): string;
+export declare function normalizeConversationText(text: string): string;
+export declare function updateConversationStats(conversation: ThreadConversationState): void;
+export declare function upsertConversationMessage(conversation: ThreadConversationState, message: ConversationMessage): string;
+export declare function markConversationMessage(conversation: ThreadConversationState, messageId: string | undefined, patch: Partial<NonNullable<ConversationMessage["meta"]>>): void;
+/**
+ * Render thread history as structured XML. Each compaction and message is
+ * wrapped with index/ts metadata so the model can reference prior items
+ * individually instead of treating the whole block as one flat narrative.
+ */
+export declare function buildConversationContext(conversation: ThreadConversationState, options?: {
+    excludeMessageId?: string;
+}): string | undefined;
+/** Return the earliest human-authored message known for a thread. */
+export declare function getThreadTitleSourceMessage(conversation: ThreadConversationState): ConversationMessage | undefined;
+/** Build the service that owns durable conversation memory compaction and titles. */
+export declare function createConversationMemoryService(deps: ConversationMemoryDeps): ConversationMemoryService;
+export declare function isHumanConversationMessage(message: ConversationMessage): boolean;
+export declare function getConversationMessageSlackTs(message: ConversationMessage): string | undefined;

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

@@ -0,0 +1,29 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import { AuthorizationPauseError } from "@/chat/services/auth-pause";
+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");
+}
+export interface McpAuthOrchestrationDeps {
+    conversationId?: string;
+    sessionId?: string;
+    requesterId?: string;
+    channelId?: string;
+    threadTs?: string;
+    toolChannelId?: string;
+    userMessage: string;
+    currentPendingAuth?: ConversationPendingAuthState;
+    getConfiguration: () => Record<string, unknown>;
+    getArtifactState: () => ThreadArtifactsState | undefined;
+    getMergedArtifactState: () => ThreadArtifactsState;
+    onPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+}
+export interface McpAuthOrchestration {
+    authProviderFactory: (plugin: PluginDefinition) => Promise<OAuthClientProvider | undefined>;
+    onAuthorizationRequired: (provider: string) => Promise<boolean>;
+    getPendingPause: () => McpAuthorizationPauseError | undefined;
+}
+/** Create MCP authorization orchestration for a single turn. */
+export declare function createMcpAuthOrchestration(deps: McpAuthOrchestrationDeps, abortAgent: () => void): McpAuthOrchestration;

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

@@ -0,0 +1,27 @@
+import type { AuthorizationPauseKind } from "@/chat/services/auth-pause";
+import type { ConversationPendingAuthState, ThreadConversationState } from "@/chat/state/conversation";
+export declare function canReusePendingAuthLink(args: {
+    kind: AuthorizationPauseKind;
+    nowMs?: number;
+    pendingAuth?: ConversationPendingAuthState;
+    provider: string;
+    requesterId: string;
+}): boolean;
+export declare function getConversationPendingAuth(args: {
+    conversation: ThreadConversationState;
+    kind: AuthorizationPauseKind;
+    provider: string;
+    requesterId: string;
+}): ConversationPendingAuthState | undefined;
+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.
+ * Callers are responsible for persisting the mutated conversation afterwards.
+ */
+export declare function applyPendingAuthUpdate(args: {
+    conversation: ThreadConversationState;
+    conversationId: string | undefined;
+    nextPendingAuth: ConversationPendingAuthState;
+}): Promise<void>;
+export declare function isPendingAuthLatestRequest(conversation: ThreadConversationState, pendingAuth: ConversationPendingAuthState): boolean;

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

@@ -0,0 +1,36 @@
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+import { AuthorizationPauseError } 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");
+}
+export declare class PluginCredentialFailureError extends Error {
+    readonly provider: string;
+    constructor(provider: string, message: string);
+}
+export interface PluginAuthOrchestrationDeps {
+    conversationId?: string;
+    sessionId?: string;
+    requesterId?: string;
+    channelId?: string;
+    threadTs?: string;
+    userMessage: string;
+    channelConfiguration?: ChannelConfigurationService;
+    currentPendingAuth?: ConversationPendingAuthState;
+    onPendingAuth?: (pendingAuth: ConversationPendingAuthState) => void | Promise<void>;
+    userTokenStore?: UserTokenStore;
+}
+export interface PluginAuthOrchestration {
+    handleCommandFailure: (input: {
+        activeSkill: Skill | null;
+        command: string;
+        details: unknown;
+    }) => Promise<void>;
+    getPendingPause: () => PluginAuthorizationPauseError | undefined;
+}
+/**
+ * Start plugin OAuth from an authenticated bash command and park the turn.
+ */
+export declare function createPluginAuthOrchestration(deps: PluginAuthOrchestrationDeps, abortAgent: () => void): PluginAuthOrchestration;

package/dist/chat/services/provider-default-config.d.ts

@@ -0,0 +1,9 @@
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
+/** Apply explicit provider-default config requests that do not need agent reasoning. */
+export declare function maybeApplyProviderDefaultConfigRequest(args: {
+    channelConfiguration?: ChannelConfigurationService;
+    requesterId?: string;
+    text: string;
+}): Promise<{
+    text: string;
+} | null>;

package/dist/chat/services/provider-retry.d.ts

@@ -0,0 +1,6 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { PiMessage } from "@/chat/pi/messages";
+/** Detect transient provider failures that are safe to retry from a Pi boundary. */
+export declare function isRetryableProviderError(message: Pick<AssistantMessage, "stopReason" | "errorMessage"> | undefined): boolean;
+/** Remove a failed assistant tail only when the remaining Pi history can continue. */
+export declare function trimRetryableProviderErrorTail(messages: PiMessage[]): PiMessage[] | undefined;

package/dist/chat/services/reply-delivery-plan.d.ts

@@ -0,0 +1,17 @@
+export type ReplyDeliveryMode = "thread" | "channel_only";
+export type ReplyFileDelivery = "none" | "inline" | "followup";
+export interface ReplyDeliveryPlan {
+    mode: ReplyDeliveryMode;
+    postThreadText: boolean;
+    attachFiles: ReplyFileDelivery;
+}
+/** Check if text is a short acknowledgment (emoji, "ok", etc.) that a reaction already covers. */
+export declare function isRedundantReactionAckText(text: string): boolean;
+/** Check if the user asked for a reaction without also asking for text. */
+export declare function isReactionOnlyIntent(text: string): boolean;
+/** Determine how a reply should be delivered (thread vs channel, file handling). */
+export declare function buildReplyDeliveryPlan(args: {
+    explicitChannelPostIntent: boolean;
+    channelPostPerformed: boolean;
+    hasFiles: boolean;
+}): ReplyDeliveryPlan;

package/dist/chat/services/subscribed-decision.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+export declare enum SubscribedReplyReason {
+    ThreadOptOut = "thread_opt_out",
+    ExplicitMention = "explicit_mention",
+    DirectedFollowUp = "directed_follow_up",
+    DirectedToOtherParty = "directed_to_other_party",
+    EmptyMessage = "empty_message",
+    Classifier = "llm_classifier",
+    SideConversation = "side_conversation",
+    LowConfidence = "low_confidence",
+    ClassifierError = "classifier_error"
+}
+export interface SubscribedDecisionInput {
+    rawText: string;
+    text: string;
+    conversationContext?: string;
+    hasAttachments?: boolean;
+    isExplicitMention?: boolean;
+    context: {
+        threadId?: string;
+        requesterId?: string;
+        channelId?: string;
+        runId?: string;
+    };
+}
+export interface SubscribedDecisionResult {
+    shouldReply: boolean;
+    shouldUnsubscribe?: boolean;
+    reason: SubscribedReplyReason;
+    reasonDetail?: string;
+}
+declare const replyDecisionSchema: z.ZodObject<{
+    should_reply: z.ZodBoolean;
+    should_unsubscribe: z.ZodOptional<z.ZodBoolean>;
+    confidence: z.ZodNumber;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Fast heuristic check before the LLM classifier — skips messages directed at another party. */
+export declare function getSubscribedReplyPreflightDecision(args: {
+    botUserName: string;
+    rawText: string;
+    text: string;
+    isExplicitMention?: boolean;
+}): SubscribedDecisionResult | undefined;
+/** Decide whether to reply to a message in a subscribed thread using an LLM classifier. */
+export declare function decideSubscribedThreadReply(args: {
+    botUserName: string;
+    modelId: string;
+    input: SubscribedDecisionInput;
+    completeObject: (args: {
+        modelId: string;
+        schema: typeof replyDecisionSchema;
+        maxTokens: number;
+        temperature: number;
+        system: string;
+        prompt: string;
+        metadata: Record<string, string>;
+    }) => Promise<{
+        object: unknown;
+    }>;
+    logClassifierFailure: (error: unknown, input: SubscribedDecisionInput) => void;
+}): Promise<SubscribedDecisionResult>;
+export {};

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

@@ -0,0 +1,23 @@
+import type { completeObject } from "@/chat/pi/client";
+export interface SubscribedReplyPolicyDeps {
+    completeObject: typeof completeObject;
+}
+export interface SubscribedReplyDecision {
+    reason: string;
+    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 declare function createSubscribedReplyPolicy(deps: SubscribedReplyPolicyDeps): SubscribedReplyPolicy;

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

@@ -0,0 +1,17 @@
+export interface TurnContinuationRequest {
+    conversationId: string;
+    expectedCheckpointVersion: 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. */
+export declare function getAwaitingTurnContinuationRequest(args: {
+    conversationId: string;
+    sessionId: string;
+}): Promise<TurnContinuationRequest | undefined>;
+/** Schedule an authenticated internal callback to resume a timed-out turn. */
+export declare function scheduleTurnTimeoutResume(request: TurnContinuationRequest): Promise<void>;
+/** Verify and parse an authenticated timeout resume callback request. */
+export declare function verifyTurnTimeoutResumeRequest(request: Request): Promise<TurnContinuationRequest | undefined>;