@sentry/junior 0.53.0 → 0.55.0

package/dist/chat/scheduler/types.d.ts

@@ -0,0 +1,86 @@
+export type ScheduledTaskStatus = "active" | "paused" | "blocked" | "deleted";
+export type ScheduledRunStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "skipped";
+export interface ScheduledTaskPrincipal {
+    slackUserId: string;
+    fullName?: string;
+    userName?: string;
+}
+export interface ScheduledTaskExecutionActor {
+    type: "system";
+    id: string;
+}
+export declare const SCHEDULED_TASK_SYSTEM_ACTOR: Readonly<{
+    type: "system";
+    id: string;
+}>;
+export interface ScheduledTaskDestination {
+    platform: "slack";
+    teamId: string;
+    channelId: string;
+}
+export interface ScheduledTaskConversationAccess {
+    audience: "direct" | "group" | "channel";
+    visibility: "private" | "public" | "unknown";
+}
+export interface ScheduledTaskCredentialSubject {
+    type: "user";
+    userId: string;
+    allowedWhen: "private-direct-conversation";
+}
+export type ScheduledCalendarFrequency = "daily" | "weekly" | "monthly" | "yearly";
+export interface ScheduledLocalTime {
+    hour: number;
+    minute: number;
+}
+export interface ScheduledTaskRecurrence {
+    dayOfMonth?: number;
+    frequency: ScheduledCalendarFrequency;
+    interval: number;
+    month?: number;
+    startDate: string;
+    time: ScheduledLocalTime;
+    weekdays?: number[];
+}
+export interface ScheduledTaskSchedule {
+    description: string;
+    timezone: string;
+    kind: "one_off" | "recurring";
+    recurrence?: ScheduledTaskRecurrence;
+}
+export interface ScheduledTaskSpec {
+    text: string;
+}
+export interface ScheduledTask {
+    id: string;
+    createdAtMs: number;
+    createdBy: ScheduledTaskPrincipal;
+    conversationAccess?: ScheduledTaskConversationAccess;
+    credentialSubject?: ScheduledTaskCredentialSubject;
+    destination: ScheduledTaskDestination;
+    executionActor?: ScheduledTaskExecutionActor;
+    lastRunAtMs?: number;
+    nextRunAtMs?: number;
+    originalRequest?: string;
+    runNowAtMs?: number;
+    schedule: ScheduledTaskSchedule;
+    status: ScheduledTaskStatus;
+    statusReason?: string;
+    task: ScheduledTaskSpec;
+    updatedAtMs: number;
+    version: number;
+}
+export interface ScheduledRun {
+    id: string;
+    attempt: number;
+    claimedAtMs: number;
+    completedAtMs?: number;
+    dispatchId?: string;
+    errorMessage?: string;
+    idempotencyKey: string;
+    resultMessageTs?: string;
+    scheduledForMs: number;
+    startedAtMs?: number;
+    status: ScheduledRunStatus;
+    taskId: string;
+    taskVersion: number;
+}

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,19 @@
+export type AuthorizationPauseKind = "mcp" | "plugin";
+export type AuthorizationPauseDisposition = "link_already_sent" | "link_sent";
+export type AuthorizationFlowMode = "interactive" | "disabled";
+/**
+ * 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);
+}
+/** Error indicating this turn cannot start an external authorization flow. */
+export declare class AuthorizationFlowDisabledError extends Error {
+    readonly kind: AuthorizationPauseKind;
+    readonly provider: string;
+    constructor(kind: AuthorizationPauseKind, provider: string);
+}

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,30 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import { AuthorizationPauseError, type AuthorizationFlowMode } 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>;
+    authorizationFlowMode?: AuthorizationFlowMode;
+}
+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,37 @@
+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");
+}
+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>;
+    authorizationFlowMode?: AuthorizationFlowMode;
+    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>;

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

@@ -0,0 +1,74 @@
+import { type AgentTurnSessionCheckpoint } from "@/chat/state/turn-session-store";
+import type { PiMessage } from "@/chat/pi/messages";
+import { type AgentTurnUsage } from "@/chat/usage";
+export interface TurnCheckpointContext {
+    conversationId?: string;
+    sessionId?: string;
+}
+export interface TurnCheckpointState {
+    canUseTurnSession: boolean;
+    resumedFromCheckpoint: boolean;
+    currentSliceId: number;
+    existingCheckpoint?: AgentTurnSessionCheckpoint;
+}
+interface CheckpointLogContext {
+    threadId?: string;
+    requesterId?: string;
+    channelId?: string;
+    runId?: string;
+    assistantUserName?: string;
+    modelId: string;
+}
+/** Load turn checkpoint state for a conversation/session pair. */
+export declare function loadTurnCheckpoint(ctx: TurnCheckpointContext): Promise<TurnCheckpointState>;
+/** Persist the latest safe in-progress boundary without scheduling continuation. */
+export declare function persistRunningCheckpoint(args: {
+    conversationId: string;
+    sessionId: string;
+    sliceId: number;
+    messages: PiMessage[];
+    loadedSkillNames: string[];
+    logContext: CheckpointLogContext;
+}): Promise<void>;
+/** Persist a completed turn checkpoint. */
+export declare function persistCompletedCheckpoint(args: {
+    conversationId: string;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    sessionId: string;
+    sliceId: number;
+    allMessages: PiMessage[];
+    loadedSkillNames: string[];
+    logContext: CheckpointLogContext;
+}): Promise<void>;
+/**
+ * Persist an auth-pause checkpoint. Returns the durable checkpoint only when
+ * the caller can safely hand the user to an authorization resume flow.
+ */
+export declare function persistAuthPauseCheckpoint(args: {
+    conversationId: string;
+    sessionId: string;
+    currentSliceId: number;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    messages: PiMessage[];
+    loadedSkillNames: string[];
+    errorMessage: string;
+    logContext: CheckpointLogContext;
+}): Promise<AgentTurnSessionCheckpoint | undefined>;
+/**
+ * Persist a timeout checkpoint at the last safe boundary. Returns the durable
+ * checkpoint when persistence succeeds so callers can enqueue a continuation.
+ */
+export declare function persistTimeoutCheckpoint(args: {
+    conversationId: string;
+    sessionId: string;
+    currentSliceId: number;
+    currentDurationMs?: number;
+    currentUsage?: AgentTurnUsage;
+    messages: PiMessage[];
+    loadedSkillNames: string[];
+    errorMessage: string;
+    logContext: CheckpointLogContext;
+}): Promise<AgentTurnSessionCheckpoint | undefined>;
+export {};

package/dist/chat/services/turn-continuation-response.d.ts

@@ -0,0 +1,2 @@
+/** Build the user-facing response for a turn parked for continuation. */
+export declare function buildTurnContinuationResponse(): string;

package/dist/chat/services/turn-failure-response.d.ts

@@ -0,0 +1,15 @@
+import type { LogContext } from "@/chat/logging";
+import type { AssistantReply } from "@/chat/services/turn-result";
+type LogException = (error: unknown, eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string) => string | undefined;
+/** Require captured turn failures to carry a real Sentry event reference. */
+export declare function requireTurnFailureEventId(eventId: string | undefined, eventName: string): string;
+/** Keep failed-turn Sentry captures and completion spans on the same keys. */
+export declare function getAgentTurnDiagnosticsAttributes(reply: AssistantReply): Record<string, unknown>;
+/** Enforce one captured, event-ID-bearing failure response before delivery. */
+export declare function finalizeFailedTurnReply(args: {
+    reply: AssistantReply;
+    logException: LogException;
+    context: LogContext;
+    attributes?: Record<string, unknown>;
+}): AssistantReply;
+export {};

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

@@ -0,0 +1,55 @@
+import type { FileUpload } from "chat";
+import type { LogContext } from "@/chat/logging";
+import type { TurnThinkingSelection } from "@/chat/services/turn-thinking-level";
+import type { AgentTurnUsage } from "@/chat/usage";
+import { type ReplyDeliveryPlan } from "@/chat/services/reply-delivery-plan";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+export interface AgentTurnDiagnostics {
+    assistantMessageCount: number;
+    durationMs?: number;
+    errorMessage?: string;
+    providerError?: unknown;
+    modelId: string;
+    outcome: "success" | "execution_failure" | "provider_error";
+    thinkingLevel?: TurnThinkingSelection["thinkingLevel"];
+    stopReason?: string;
+    toolCalls: string[];
+    toolErrorCount: number;
+    toolResultCount: number;
+    usage?: AgentTurnUsage;
+    usedPrimaryText: boolean;
+}
+export interface AssistantReply {
+    text: string;
+    files?: FileUpload[];
+    artifactStatePatch?: Partial<ThreadArtifactsState>;
+    deliveryPlan?: ReplyDeliveryPlan;
+    deliveryMode?: "thread" | "channel_only";
+    sandboxId?: string;
+    sandboxDependencyProfileHash?: string;
+    diagnostics: AgentTurnDiagnostics;
+}
+export interface TurnResultInput {
+    newMessages: unknown[];
+    userInput: string;
+    replyFiles: FileUpload[];
+    artifactStatePatch: Partial<ThreadArtifactsState>;
+    toolCalls: string[];
+    sandboxId?: string;
+    sandboxDependencyProfileHash?: string;
+    durationMs?: number;
+    generatedFileCount: number;
+    shouldTrace: boolean;
+    spanContext: LogContext;
+    usage?: AgentTurnUsage;
+    thinkingSelection: TurnThinkingSelection;
+    correlation?: {
+        threadId?: string;
+        requesterId?: string;
+        channelId?: string;
+        runId?: string;
+    };
+    assistantUserName?: string;
+}
+/** Process raw agent messages into a structured AssistantReply. */
+export declare function buildTurnResult(input: TurnResultInput): AssistantReply;

package/dist/chat/services/turn-thinking-level.d.ts

@@ -0,0 +1,49 @@
+import type { ThinkingLevel as AgentThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { ThinkingLevel as ProviderThinkingLevel } from "@earendil-works/pi-ai";
+import { z } from "zod";
+declare const TURN_THINKING_LEVELS: readonly ["none", "low", "medium", "high", "xhigh"];
+declare const turnExecutionProfileSchema: z.ZodObject<{
+    thinking_level: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        none: "none";
+    }>;
+    confidence: z.ZodPreprocess<z.ZodNumber>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+type TurnThinkingLevel = (typeof TURN_THINKING_LEVELS)[number];
+export interface TurnThinkingSelection {
+    confidence?: number;
+    thinkingLevel: TurnThinkingLevel;
+    reason: string;
+}
+/** Choose the thinking level for the upcoming assistant turn. */
+export declare function selectTurnThinkingLevel(args: {
+    completeObject: (args: {
+        modelId: string;
+        schema: typeof turnExecutionProfileSchema;
+        maxTokens: number;
+        metadata: Record<string, string>;
+        prompt: string;
+        thinkingLevel?: ProviderThinkingLevel;
+        system: string;
+        temperature: number;
+    }) => Promise<{
+        object: unknown;
+    }>;
+    conversationContext?: string;
+    context?: {
+        channelId?: string;
+        requesterId?: string;
+        runId?: string;
+        threadId?: string;
+    };
+    currentTurnBlocks?: string[];
+    fastModelId: string;
+    messageText: string;
+}): Promise<TurnThinkingSelection>;
+/** Convert a routing bucket into the Pi Agent thinking level for a main turn. */
+export declare function toAgentThinkingLevel(level: TurnThinkingSelection["thinkingLevel"]): AgentThinkingLevel | "off";
+export {};

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

@@ -0,0 +1,61 @@
+import type { Attachment } from "chat";
+import type { completeText } from "@/chat/pi/client";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+export interface UserInputAttachment {
+    data?: Buffer;
+    mediaType: string;
+    filename?: string;
+    promptText?: string;
+}
+interface VisionThreadFile {
+    id?: string;
+    mimetype?: string;
+    name?: string;
+    size?: number;
+    url_private?: string;
+    url_private_download?: string;
+}
+interface VisionThreadReply {
+    ts?: string;
+    subtype?: string;
+    bot_id?: string;
+    files?: VisionThreadFile[];
+}
+export interface VisionContextDeps {
+    completeText: typeof completeText;
+    downloadFile: (url: string) => Promise<Buffer>;
+    listThreadReplies: (input: {
+        channelId: string;
+        threadTs: string;
+        limit?: number;
+        maxPages?: number;
+        targetMessageTs?: string[];
+    }) => Promise<VisionThreadReply[]>;
+}
+export interface VisionContextService {
+    hydrateConversationVisionContext: (conversation: ThreadConversationState, context: {
+        threadId?: string;
+        channelId?: string;
+        requesterId?: string;
+        runId?: string;
+        threadTs?: string;
+    }) => Promise<void>;
+    resolveUserAttachments: (attachments: Attachment[] | undefined, context: ResolveUserAttachmentsContext) => Promise<UserInputAttachment[]>;
+}
+interface ResolveUserAttachmentsContext {
+    threadId?: string;
+    requesterId?: string;
+    channelId?: string;
+    runId?: string;
+    conversation?: ThreadConversationState;
+    messageTs?: string;
+}
+/** Report whether the current Slack message carries an image that needs vision hydration. */
+export declare function hasPotentialImageAttachment(attachments: Attachment[] | undefined): boolean;
+/** Count image-bearing Slack attachments before vision filtering removes them. */
+export declare function countPotentialImageAttachments(attachments: Attachment[] | undefined): number;
+/** Report whether a dedicated vision model is configured for image analysis. */
+export declare function isVisionEnabled(): boolean;
+/** Build the vision service that owns thread image hydration and attachment preprocessing. */
+export declare function createVisionContextService(deps: VisionContextDeps): VisionContextService;
+export {};