@sentry/junior 0.110.0 → 0.111.0

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

@@ -3,6 +3,7 @@ import type { PiMessage } from "@/chat/pi/messages";
 import type { TurnRoute } from "@/chat/services/turn-router";
 import type { AgentTurnUsage } from "@/chat/usage";
 import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { SandboxRef } from "@/chat/sandbox/ref";
 import { extractAssistantText } from "@/chat/pi/transcript";
 export interface AgentTurnDiagnostics {
     assistantMessageCount: number;
@@ -23,8 +24,7 @@ export interface AgentRunResult {
     /** Sanitized terminal text for diagnostics and failure fallback, not success delivery. */
     text: string;
     artifactStatePatch?: Partial<ThreadArtifactsState>;
-    sandboxId?: string;
-    sandboxDependencyProfileHash?: string;
+    sandboxRef?: SandboxRef;
     piMessages?: PiMessage[];
     diagnostics: AgentTurnDiagnostics;
 }
@@ -33,8 +33,7 @@ export interface TurnResultInput {
     userInput: string;
     artifactStatePatch: Partial<ThreadArtifactsState>;
     toolCalls: string[];
-    sandboxId?: string;
-    sandboxDependencyProfileHash?: string;
+    sandboxRef?: SandboxRef;
     piMessages?: PiMessage[];
     durationMs?: number;
     generatedFileCount: number;

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

@@ -272,7 +272,9 @@ interface SlackResourceEventInboundInput {
 export interface CreateSlackConversationWorkerOptions {
     getSlackAdapter: () => SlackAdapter;
     lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackActorProfile | null | undefined>;
-    resumeAwaitingContinuation: (conversationId: string) => Promise<boolean>;
+    resumeAwaitingContinuation: (conversationId: string, options: {
+        shouldYield: () => boolean;
+    }) => Promise<boolean>;
     conversationStore?: ConversationStore;
     runtime: SlackInboxTurnRuntime;
     state?: StateAdapter;

package/dist/chat/task-execution/state.d.ts

@@ -1,5 +1,6 @@
 import type { StateAdapter } from "chat";
-import type { Destination } from "@sentry/junior-plugin-api";
+import { type Destination } from "@sentry/junior-plugin-api";
+import { z } from "zod";
 import { type StoredSlackActor } from "@/chat/actor";
 declare class InvalidConversationRecordError extends Error {
     constructor(conversationId: string);
@@ -12,25 +13,67 @@ export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
 export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
 export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
 export declare const CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS = 5;
-export type Source = "api" | "internal" | "local" | "plugin" | "resource_event" | "scheduler" | "slack";
+declare const inboundMessageSourceSchema: z.ZodEnum<{
+    slack: "slack";
+    plugin: "plugin";
+    api: "api";
+    local: "local";
+    internal: "internal";
+    resource_event: "resource_event";
+    scheduler: "scheduler";
+}>;
+export type Source = z.output<typeof inboundMessageSourceSchema>;
 export type ExecutionStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
-export interface AgentInput {
-    attachments?: unknown[];
-    authorId?: string;
-    metadata?: Record<string, unknown>;
-    text: string;
-}
-export interface InboundMessage {
-    attemptCount?: number;
-    conversationId: string;
-    createdAtMs: number;
-    destination: Destination;
-    inboundMessageId: string;
-    injectedAtMs?: number;
-    input: AgentInput;
-    receivedAtMs: number;
-    source: Source;
-}
+declare const agentInputSchema: z.ZodObject<{
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    authorId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    text: z.ZodString;
+}, z.core.$strict>;
+export type AgentInput = z.output<typeof agentInputSchema>;
+/** Durable delivery modes for pending inbound mailbox work. */
+export declare const inboundMessageDeliverySchema: z.ZodEnum<{
+    defer: "defer";
+    interrupt: "interrupt";
+}>;
+export type InboundMessageDelivery = z.output<typeof inboundMessageDeliverySchema>;
+/** Canonical durable mailbox entry owned by task execution. */
+export declare const inboundMessageSchema: z.ZodObject<{
+    attemptCount: z.ZodOptional<z.ZodNumber>;
+    conversationId: z.ZodString;
+    createdAtMs: z.ZodNumber;
+    delivery: z.ZodEnum<{
+        defer: "defer";
+        interrupt: "interrupt";
+    }>;
+    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    inboundMessageId: z.ZodString;
+    injectedAtMs: z.ZodOptional<z.ZodNumber>;
+    input: z.ZodObject<{
+        attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        authorId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        text: z.ZodString;
+    }, z.core.$strict>;
+    receivedAtMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        slack: "slack";
+        plugin: "plugin";
+        api: "api";
+        local: "local";
+        internal: "internal";
+        resource_event: "resource_event";
+        scheduler: "scheduler";
+    }>;
+}, z.core.$strict>;
+export type InboundMessage = z.output<typeof inboundMessageSchema>;
 export interface Lease {
     acquiredAtMs: number;
     expiresAtMs: number;
@@ -56,7 +99,7 @@ export interface Conversation {
     execution: ConversationExecution;
     lastActivityAtMs: number;
     actor?: StoredSlackActor;
-    schemaVersion: 1;
+    schemaVersion: 2;
     source?: Source;
     title?: string;
     updatedAtMs: number;
@@ -182,7 +225,7 @@ export declare function checkInConversationWork(args: {
     state?: StateAdapter;
 }): Promise<boolean>;
 /**
- * Drain pending mailbox entries after the caller acknowledges durable handling.
+ * Resolve pending mailbox entries after the caller accepts responsibility.
  *
  * Returning ids acknowledges only that subset; returning nothing acknowledges
  * every pending entry passed to the handler.
@@ -193,7 +236,10 @@ export declare function drainConversationMailbox(args: {
     leaseToken: string;
     nowMs?: number;
     state?: StateAdapter;
-}): Promise<InboundMessage[]>;
+}): Promise<{
+    changed: boolean;
+    messages: InboundMessage[];
+}>;
 /** Acknowledge leased mailbox entries after the handler accepts responsibility. */
 export declare function ackMessages(args: {
     conversationId: string;
@@ -210,6 +256,13 @@ export declare function requestConversationContinuation(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
+/** Begin a requested turn resume under the worker's existing lease. */
+export declare function beginConversationResume(args: {
+    conversationId: string;
+    leaseToken: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
 /** Release the durable execution lease without changing completion state. */
 export declare function releaseConversationWork(args: {
     conversationId: string;

package/dist/chat/task-execution/store.d.ts

@@ -2,13 +2,13 @@ import type { StateAdapter } from "chat";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { ConversationWorkQueue } from "./queue";
 import * as workState from "./state";
-export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS, CONVERSATION_WORK_STALE_ENQUEUE_MS, isFinalAttempt, isInvalidConversationRecordError, type AgentInput, type AttemptFailure, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
+export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS, CONVERSATION_WORK_STALE_ENQUEUE_MS, isFinalAttempt, isInvalidConversationRecordError, type AgentInput, type AttemptFailure, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type InboundMessageDelivery, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
 import type { AppendAndEnqueueInboundMessageResult, Conversation, InboundMessage } from "@/chat/task-execution/state";
 export type EnsureConversationWakeResult = {
     queueMessageId?: string;
     status: "enqueued";
 } | {
-    status: "already_enqueued" | "no_work";
+    status: "already_enqueued" | "lease_active" | "no_work";
 };
 /** Return a persisted conversation record, if one exists. */
 export declare function getConversation(args: {
@@ -94,7 +94,30 @@ export declare function checkInConversationWork(args: {
 export declare function drainConversationMailbox(args: Parameters<typeof workState.drainConversationMailbox>[0] & {
     conversationStore?: ConversationStore;
     state?: StateAdapter;
-}): Promise<workState.InboundMessage[]>;
+}): Promise<{
+    conversationId: string;
+    createdAtMs: number;
+    delivery: "defer" | "interrupt";
+    destination: {
+        platform: "slack";
+        teamId: string;
+        channelId: string;
+    } | {
+        platform: "local";
+        conversationId: string;
+    };
+    inboundMessageId: string;
+    input: {
+        text: string;
+        attachments?: unknown[] | undefined;
+        authorId?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    receivedAtMs: number;
+    source: "slack" | "plugin" | "api" | "local" | "internal" | "resource_event" | "scheduler";
+    attemptCount?: number | undefined;
+    injectedAtMs?: number | undefined;
+}[]>;
 /** Acknowledge leased mailbox entries after the handler accepts responsibility. */
 export declare function ackMessages(args: {
     conversationId: string;
@@ -113,6 +136,14 @@ export declare function requestConversationContinuation(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<boolean>;
+/** Begin a requested turn resume without releasing the current lease. */
+export declare function beginConversationResume(args: {
+    conversationId: string;
+    leaseToken: string;
+    conversationStore?: ConversationStore;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
 /** Release the durable execution lease without changing completion state. */
 export declare function releaseConversationWork(args: {
     conversationId: string;

package/dist/chat/task-execution/worker.d.ts

@@ -4,7 +4,6 @@ import type { ConversationStore } from "@/chat/conversations/store";
 import { type ConversationQueueMessage, type ConversationWorkQueue } from "./queue";
 import { type InboundMessage } from "./store";
 export declare const CONVERSATION_WORK_DEFER_DELAY_MS = 15000;
-export declare const CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 240000;
 export interface ConversationWorkerContext {
     attempt: InboxAttempt;
     checkIn(): Promise<boolean>;

package/dist/chat/tool-support/normalize-result.d.ts

@@ -1,6 +1,6 @@
 import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
-/** Unwrap sandbox envelope and detect structured results. */
-export declare function normalizeToolResult(result: unknown, isSandboxResult: boolean, options?: {
+/** Normalize raw tool output into Pi content and structured details. */
+export declare function normalizeToolResult(result: unknown, options?: {
     requireStructuredResult?: boolean;
     toolName?: string;
 }): {

package/dist/chat/tool-support/pi-tool-adapter.d.ts

@@ -3,10 +3,10 @@ import { type ConversationPrivacy } from "@/chat/conversation-privacy";
 import { type LogContext } from "@/chat/logging";
 import type { PluginAuthOrchestration } from "@/chat/services/plugin-auth-orchestration";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
-import type { SandboxExecutor } from "@/chat/sandbox/sandbox";
+import type { SandboxTools } from "@/chat/sandbox/sandbox";
 import type { SkillSandbox } from "@/chat/sandbox/skill-sandbox";
 import type { AnyToolDefinition } from "@/chat/tools/definition";
 import type { ToolExecutionReport } from "@/chat/tool-support/tool-execution-report";
 import type { PluginHookRunner } from "@/chat/plugins/agent-hooks";
 /** Wrap tool definitions into Pi Agent tool objects with logging, validation, and sandbox execution. */
-export declare function createPiAgentTools(tools: Record<string, AnyToolDefinition>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxExecutor?: SandboxExecutor, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolCallId: string, toolName: string, params: Record<string, unknown>) => void | Promise<void>, agentHooks?: PluginHookRunner, conversationPrivacy?: ConversationPrivacy, onToolResult?: (report: ToolExecutionReport) => void | Promise<void>): AgentTool[];
+export declare function createPiAgentTools(tools: Record<string, AnyToolDefinition>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxTools?: SandboxTools, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolCallId: string, toolName: string, params: Record<string, unknown>) => void | Promise<void>, agentHooks?: PluginHookRunner, conversationPrivacy?: ConversationPrivacy, onToolResult?: (report: ToolExecutionReport) => void | Promise<void>): AgentTool[];

package/dist/chat/tool-support/structured-result.d.ts

@@ -61,7 +61,7 @@ export interface JuniorToolResultEnvelope<TDetails extends JuniorToolResult = Ju
 }
 /** Bind continuation metadata to the exposed runtime tool name. */
 export declare function injectContinuationToolName(details: JuniorToolResult, toolName: string): JuniorToolResult | JuniorToolResultWithBoundContinuation;
-interface JuniorTextToolResultEnvelope<TDetails extends JuniorToolResult = JuniorToolResult> {
+export interface JuniorTextToolResultEnvelope<TDetails extends JuniorToolResult = JuniorToolResult> {
     content: [TextContent];
     details: TDetails;
 }
@@ -70,4 +70,3 @@ export declare function makeStructuredToolResult<TDetails extends JuniorToolResu
 export declare function makeStructuredToolResult<TDetails extends JuniorToolResult>(details: TDetails, options: {
     content: Array<TextContent | ImageContent>;
 }): JuniorToolResultEnvelope<TDetails>;
-export {};

package/dist/chat/tools/sandbox/file-uploads.d.ts

@@ -48,5 +48,5 @@ export declare function sandboxArtifactPath(filename: string): string;
 /** Infer upload MIME type from an explicit value or filename extension. */
 export declare function inferMimeType(filename: string, explicitMimeType?: string): string;
 /** Read and validate one sandbox file for Slack/file reply upload. */
-export declare function readSandboxFileUpload(sandbox: SandboxWorkspace, input: SandboxFileMaterializationInput): Promise<SandboxFileUpload>;
+export declare function readSandboxFileUpload(workspace: SandboxWorkspace, input: SandboxFileMaterializationInput): Promise<SandboxFileUpload>;
 export {};

package/dist/chat/{runtime → tools/sandbox}/generated-artifacts.d.ts

@@ -1,8 +1,8 @@
 import type { FileUpload } from "chat";
 import { type GeneratedArtifactFileRef } from "@/chat/tools/sandbox/file-uploads";
 import type { SandboxCommandResult } from "@/chat/sandbox/workspace";
-/** Sandbox operations needed to make generated artifacts visible to later tools. */
-export interface GeneratedArtifactSandbox {
+/** Workspace operations needed to make generated artifacts visible to later tools. */
+export interface GeneratedArtifactWorkspace {
     runCommand(input: {
         args?: string[];
         cmd: string;
@@ -13,4 +13,4 @@ export interface GeneratedArtifactSandbox {
     }>): Promise<void>;
 }
 /** Persist generated artifacts into the sandbox before returning model-visible handles. */
-export declare function writeSandboxGeneratedArtifacts(sandbox: GeneratedArtifactSandbox, files: FileUpload[]): Promise<GeneratedArtifactFileRef[]>;
+export declare function writeSandboxGeneratedArtifacts(workspace: GeneratedArtifactWorkspace, files: FileUpload[]): Promise<GeneratedArtifactFileRef[]>;

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

@@ -69,7 +69,7 @@ interface BaseToolRuntimeContext {
     configuration?: Record<string, unknown>;
     egress: PluginEgress;
     mcpToolManager?: McpToolManager;
-    sandbox: SandboxWorkspace;
+    workspace: SandboxWorkspace;
 }
 interface SlackToolRuntimeContext extends BaseToolRuntimeContext {
     destination: SlackDestination;

package/dist/chat/tools/web/fetch-content.d.ts

@@ -17,6 +17,11 @@ export type WebFetchResponse = {
     extracted_chars: number;
     truncated: boolean;
 } & Record<string, unknown>;
+/** Apply the web-fetch character limit to already extracted text content. */
+export declare function truncateWebFetchContent(content: string, maxChars: number): {
+    content: string;
+    truncated: boolean;
+};
 /** Extract readable content and metadata from a fetched response body. */
 export declare function extractContentDetails(body: string, contentType: string, maxChars: number): WebFetchResponseContent;
 /** Extract readable content from a fetched response body, converting HTML to markdown. */

package/dist/chat/tools/web/image-generate.d.ts

@@ -1,6 +1,7 @@
 import type { ImageGenerateToolDeps, ToolHooks } from "@/chat/tools/types";
 /** Create the image tool with sandbox artifact guidance matched to file-send capability. */
-export declare function createImageGenerateTool(hooks: Required<Pick<ToolHooks, "writeGeneratedArtifacts">>, options?: {
+export declare function createImageGenerateTool(hooks: Required<Pick<ToolHooks, "writeGeneratedArtifacts">>, options: {
+    modelId: string;
     canSendFilesToActiveConversation?: boolean;
 }, deps?: ImageGenerateToolDeps): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("../definition").JsonSchemaObject;

package/dist/chat/tools/web/search.d.ts

@@ -1,5 +1,5 @@
 import type { WebSearchToolDeps } from "@/chat/tools/types";
-export declare function createWebSearchTool(override?: WebSearchToolDeps): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+export declare function createWebSearchTool(modelId: string, override?: WebSearchToolDeps): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("../definition").JsonSchemaObject;
     outputSchema: import("../definition").JsonSchemaObject;
     prepareArguments(args: unknown): {