@sentry/junior 0.121.0 → 0.122.1

package/dist/{catalog-runtime-AD3YNTTM.js → catalog-runtime-VNNMSKCB.js}

@@ -1,17 +1,17 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-WUP7NWMP.js";
-import "./chunk-ET2SDCNV.js";
+} from "./chunk-73TQBD5S.js";
+import "./chunk-4ZV2GNHX.js";
 import "./chunk-W3U3YQYI.js";
 import "./chunk-HZF5P5UN.js";
-import "./chunk-JZ47AFSH.js";
+import "./chunk-4JPJTFUH.js";
 import "./chunk-OB42YVAE.js";
 import "./chunk-F3B2YJ76.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-IK4QSS5H.js";
-import "./chunk-D2EMOH3N.js";
+import "./chunk-PYS4QZAF.js";
+import "./chunk-LZ4XXS76.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

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

@@ -1,4 +1,21 @@
+/**
+ * Agent executor.
+ *
+ * Composition root and execution loop for one agent run slice after
+ * runtime/ingress code has parsed and routed the request. Wires the phase
+ * modules (session restore, skills, tools, prompt, resume), runs the Pi agent
+ * with inline retry handling, and translates expected run endings into
+ * `AgentRunOutcome` values. It emits every completed, tool-free visible
+ * assistant message through the delivery port; the result carries diagnostics,
+ * artifacts, and transcript state for destination-owned completion.
+ */
+import { type StreamFn } from "@earendil-works/pi-agent-core";
 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>;
+/**
+ * Run a full agent turn, optionally using a caller-provided model stream.
+ *
+ * The stream changes model output only; prompt assembly, persistence, tools,
+ * delivery, and completion still use the normal agent runtime.
+ */
+export declare function executeAgentRun(request: AgentRunRequest, streamFn?: StreamFn): Promise<AgentRunOutcome>;

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

@@ -28,6 +28,7 @@ import type { ToolExecutionReport } from "@/chat/tool-support/tool-execution-rep
 import type { SlackActionToken } from "@/chat/slack/action-token";
 import type { TurnReasoningLevel } from "@/chat/reasoning-level";
 import type { ImageGenerateToolDeps, ViewImageToolDeps, WebFetchToolDeps, WebSearchToolDeps } from "@/chat/tools/types";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
 export interface AgentRunAttachment {
     data?: Buffer;
     mediaType: string;
@@ -126,14 +127,13 @@ export interface AgentRunObservers {
     onToolResult?: (result: ToolExecutionReport) => void | Promise<void>;
     onStatus?: (status: AssistantStatusSpec) => void | Promise<void>;
 }
-/** One completed tool-free assistant message ready for destination delivery. */
-export interface AgentAssistantMessage {
-    text: string;
-}
-/** Delivers completed tool-free assistant messages in model order. */
-export interface AgentRunDelivery {
-    onAssistantMessage: (message: AgentAssistantMessage) => void | Promise<void>;
-}
+/**
+ * Delivers completed tool-free assistant messages in model order.
+ *
+ * The runner must commit the preceding agent boundary before invoking this
+ * port; the accepted reply transaction appends only this message.
+ */
+export type AgentRunDelivery = (message: AssistantMessage) => void | Promise<void>;
 /** Resume the agent turn after a transient or ambiguous delivery failure. */
 export declare class RetryableDeliveryError extends Error {
     constructor(cause: unknown);

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

@@ -14,13 +14,12 @@ 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 { Actor } from "@/chat/actor";
-import { loadTurnSessionRecord, persistRunningSessionRecord } from "@/chat/services/turn-session-record";
+import { loadTurnSessionRecord } from "@/chat/services/turn-session-record";
 import { type AuthorizationPauseError } from "@/chat/services/auth-pause";
 import { type AgentTurnUsage } from "@/chat/usage";
 import { type AgentRunDurability } from "@/chat/agent/request";
 import type { PluginTurnContext } from "@/chat/plugins/prompt";
 type LoadedSessionRecordState = Awaited<ReturnType<typeof loadTurnSessionRecord>>;
-type SessionRecordLogContext = NonNullable<Parameters<typeof persistRunningSessionRecord>[0]["logContext"]>;
 interface ResumeStateArgs {
     channelName?: string;
     destination: Destination;
@@ -28,7 +27,6 @@ interface ResumeStateArgs {
     durability: AgentRunDurability;
     getLoadedSkillNames: () => string[];
     getModelId: () => string;
-    logContext: SessionRecordLogContext;
     getReasoningLevel: () => string | undefined;
     recordActiveMcpProviders: () => Promise<void>;
     actor?: Actor;

package/dist/chat/agent/retry-usage.d.ts

@@ -0,0 +1,8 @@
+import type { PiMessage } from "@/chat/pi/messages";
+import { type AgentTurnUsage } from "@/chat/usage";
+/**
+ * Return usage discarded when a retry keeps an exact prefix of agent history.
+ *
+ * Retained messages stay in the next phase and must not be counted again here.
+ */
+export declare function getDiscardedRetryUsage(messages: PiMessage[], retryMessages: PiMessage[]): AgentTurnUsage | undefined;

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

@@ -1,11 +1,3 @@
-/**
- * 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";
@@ -14,7 +6,6 @@ export declare function upsertActiveSkill(activeSkills: Skill[], next: Skill): v
 /** 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: {

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

@@ -1,4 +1,5 @@
 import type { ConversationMessage, ThreadConversationState } from "@/chat/state/conversation";
+import type { ConversationEventStore } from "./history";
 /** Author role of a visible conversation message. */
 export type ConversationMessageRole = "user" | "assistant" | "system";
 /** A source message to record; identity is `(conversationId, messageId)`. */
@@ -23,3 +24,9 @@ export declare function persistConversationMessages(args: {
     conversationId: string | undefined;
     repliedAtMs?: number;
 }): Promise<void>;
+/** Append visible message facts through a caller-owned event-store transaction. */
+export declare function appendConversationMessages(eventStore: ConversationEventStore, args: {
+    conversation: ThreadConversationState;
+    conversationId: string;
+    repliedAtMs?: number;
+}): Promise<void>;

package/dist/chat/conversations/projection.d.ts

@@ -6,6 +6,8 @@ import { type PiConversationEventProjection, type PiConversationProjection } fro
 import type { ModelProfile } from "@/chat/model-profile";
 import type { TurnReasoningLevel } from "@/chat/reasoning-level";
 import type { PluginTurnContext } from "@/chat/plugins/prompt";
+import type { ThreadConversationState } from "@/chat/state/conversation";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
 interface ScopedConversation {
     conversationId: string;
 }
@@ -63,6 +65,20 @@ export declare function commitMessages(args: {
     messages: PiMessage[];
     provenance: ConversationMessageProvenance[];
 }>;
+/**
+ * Commit an accepted agent reply and its visible message in causal order.
+ *
+ * The destination has already accepted the reply. One transaction prevents
+ * reporting from observing the visible reply before the agent message that
+ * produced it.
+ */
+export declare function commitAcceptedReply(args: {
+    agentMessage: AssistantMessage;
+    conversation: ThreadConversationState;
+    conversationMessageId: string;
+    conversationId: string;
+    repliedAtMs?: number;
+}): Promise<void>;
 /** Record a successful MCP provider connection without duplicating the fact. */
 export declare function recordMcpProviderConnected(args: {
     conversationId: string;

package/dist/chat/logging.d.ts

@@ -20,22 +20,33 @@ interface SentryUserIdentity {
 export declare function normalizeGenAiFinishReason(reason: string): string;
 /** Truncate message text for log attributes. */
 export declare function summarizeMessageText(text: string): string;
+/**
+ * Low-level adapter logger.
+ *
+ * Application runtime code should use the severity helpers below. This surface
+ * exists for adapters that must preserve an external free-form body.
+ */
 export declare const log: {
     debug(eventName: string, attrs?: Record<string, unknown>, body?: string): void;
     info(eventName: string, attrs?: Record<string, unknown>, body?: string): void;
     warn(eventName: string, attrs?: Record<string, unknown>, body?: string): void;
     error(eventName: string, attrs?: Record<string, unknown>, body?: string): void;
-    exception(eventName: string, error: unknown, attrs?: Record<string, unknown>, body?: string, context?: LogContext): string | undefined;
+    exception(eventName: string, error: unknown, attrs?: Record<string, unknown>, body?: string): string | undefined;
 };
 /** Create a Chat SDK logger that routes records through Junior's logging backend. */
 export declare function createChatSdkLogger(): ChatSdkLogger;
-export declare function withLogContext<T>(context: LogContext, callback: () => Promise<T>): Promise<T>;
+/**
+ * Run one operation with inherited correlation context.
+ *
+ * Call this at execution boundaries after reconstructing authoritative
+ * context. Nested application logs should not receive the same context again.
+ */
+export declare function withLogContext<T>(context: LogContext, callback: () => T): T;
 export declare function getLogContextAttributes(): LogAttributes;
 /** Return inherited log context filtered to attributes valid for the span operation. */
 export declare function getLogContextAttributesForSpan(op: string): LogAttributes;
 export declare function registerLogRecordSink(sink: (record: EmittedLogRecord) => void): () => void;
 export declare function createLogContextFromRequest(request: Request, context?: Partial<LogContext>): LogContext;
-export declare function toSpanAttributes(context: LogContext): Record<string, string>;
 /** Attach filterable non-user context tags to Sentry. */
 export declare function setSentryTagsFromContext(context: LogContext): void;
 /** Bind actor identity to Sentry's native user fields. */
@@ -43,16 +54,38 @@ export declare function setSentryUser(identity: SentryUserIdentity | undefined):
 /** Attach scoped Sentry context for isolated exception capture. */
 export declare function setSentryScopeContext(scope: Sentry.Scope, context: LogContext): void;
 export type SetSpanAttributes = (attributes: Record<string, unknown>) => void;
-/** Capture an error to Sentry and emit an error log record. */
-export declare function captureException(error: unknown, context?: LogContext): void;
-/** Log an info-level structured event. */
-export declare function logInfo(eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): void;
-/** Log a warning-level structured event. */
-export declare function logWarn(eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): void;
-/** Log an error-level structured event. */
-export declare function logError(eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): void;
-/** Log an error with exception capture; returns the Sentry event ID if available. */
-export declare function logException(error: unknown, eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): string | undefined;
+/**
+ * Capture an error using context already bound to the current operation.
+ */
+export declare function captureException(error: unknown): void;
+/**
+ * Emit an informational event with occurrence-specific attributes.
+ *
+ * Bind correlation context at the owning operation boundary instead of
+ * passing it here.
+ */
+export declare function logInfo(eventName: string, attributes?: Record<string, unknown>): void;
+/**
+ * Emit a warning event with occurrence-specific attributes.
+ *
+ * Bind correlation context at the owning operation boundary instead of
+ * passing it here.
+ */
+export declare function logWarn(eventName: string, attributes?: Record<string, unknown>): void;
+/**
+ * Emit an error event without capturing an exception.
+ *
+ * Use `logException` when an actual exception instance owns the failure.
+ */
+export declare function logError(eventName: string, attributes?: Record<string, unknown>): void;
+/**
+ * Emit an exception event and capture the exception with bound context.
+ *
+ * Exception event names should end in `.exception` when they describe a
+ * generic operation exception. Existing domain failure events may retain a
+ * `.failed` outcome when the event also covers non-exception failures.
+ */
+export declare function logException(error: unknown, eventName: string, attributes?: Record<string, unknown>): string | undefined;
 /** Add context to the current operation and Sentry scope. */
 export declare function setTags(context?: LogContext): void;
 /** Create a LogContext from an incoming HTTP request. */

package/dist/chat/mcp/tool-manager.d.ts

@@ -13,10 +13,21 @@ import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { SkillMetadata } from "@/chat/skills";
 import type { PluginDefinition } from "@/chat/plugins/types";
 import { McpAuthorizationRequiredError } from "./client";
+export interface McpToolSuccessHookInput {
+    arguments: Record<string, unknown>;
+    provider: string;
+    structuredContent?: unknown;
+    toolName: string;
+}
 export interface McpToolManagerOptions {
     authProviderFactory?: (plugin: PluginDefinition) => OAuthClientProvider | undefined | Promise<OAuthClientProvider | undefined>;
     fetch?: typeof fetch;
     onAuthorizationRequired?: (provider: string, error: McpAuthorizationRequiredError) => Promise<boolean | void> | boolean | void;
+    /**
+     * Optional post-success processor for model-facing MCP tool calls.
+     * Failures are logged by the host caller and must not fail the tool result.
+     */
+    onToolSuccess?: (input: McpToolSuccessHookInput) => Promise<void> | void;
 }
 export interface ManagedMcpToolResult {
     /**

package/dist/chat/plugins/agent-hooks.d.ts

@@ -23,7 +23,15 @@ export interface PluginApiRouteRegistration {
     app: PluginRouteApp;
     pluginName: string;
 }
+export interface AfterMcpToolHookInput {
+    arguments: Record<string, unknown>;
+    conversationId?: string;
+    provider: string;
+    structuredContent?: unknown;
+    toolName: string;
+}
 export interface PluginHookRunner {
+    afterMcpTool(input: AfterMcpToolHookInput): Promise<void>;
     beforeToolExecute(input: ToolHookInput): Promise<ToolHookResult>;
     prepareSandbox(workspace: SandboxWorkspace): Promise<void>;
 }

package/dist/chat/runtime/processing-reaction.d.ts

@@ -11,8 +11,7 @@ export interface ProcessingReactionSession {
 export declare function shouldKeepProcessingReactionForToolInvocation(input: TurnToolInvocation): boolean;
 /** Start Junior's automatic Slack processing reaction for one inbound message. */
 export declare function startSlackProcessingReaction(args: {
-    logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;
-    logContext: Record<string, unknown>;
+    logException: (error: unknown, eventName: string, attributes?: Record<string, unknown>) => string | undefined;
     message: Message;
     thread: Thread;
 }): Promise<ProcessingReactionSession>;
@@ -20,6 +19,5 @@ export declare function startSlackProcessingReaction(args: {
 export declare function startSlackProcessingReactionForMessage(args: {
     channelId: string;
     timestamp: SlackMessageTs;
-    logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;
-    logContext: Record<string, unknown>;
+    logException: (error: unknown, eventName: string, attributes?: Record<string, unknown>) => string | undefined;
 }): Promise<ProcessingReactionSession>;

package/dist/chat/runtime/slack-runtime.d.ts

@@ -62,8 +62,8 @@ export interface SlackTurnRuntimeDependencies<TPreparedState> {
         threadId: string;
         threadTs: string;
     }) => Promise<void>;
-    logException: (error: unknown, eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => string | undefined;
-    logWarn: (eventName: string, context?: Record<string, unknown>, attributes?: Record<string, unknown>, body?: string) => void;
+    logException: (error: unknown, eventName: string, attributes?: Record<string, unknown>) => string | undefined;
+    logWarn: (eventName: string, attributes?: Record<string, unknown>) => void;
     modelId: string;
     now: () => number;
     recordSkippedSteeringMessage: (args: {

package/dist/chat/services/assistant-reply.d.ts

@@ -0,0 +1,16 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+type ReplyDecision = {
+    kind: "deliver";
+    text: string;
+} | {
+    kind: "empty";
+} | {
+    kind: "suppress";
+};
+/** Remove provider reasoning wrappers while preserving fenced code examples. */
+export declare function sanitizeAssistantText(text: string): string;
+/** Decide whether one completed assistant message becomes a reply. */
+export declare function decideReply(message: AssistantMessage): ReplyDecision;
+/** Return destination-visible reply text when the message is deliverable. */
+export declare function getAssistantReplyText(message: AssistantMessage): string | undefined;
+export {};

package/dist/chat/services/empty-output-continuation.d.ts

@@ -0,0 +1,20 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { PiMessage } from "@/chat/pi/messages";
+type EmptyOutputContinuation = {
+    kind: "none";
+} | {
+    kind: "retry";
+    messages: PiMessage[];
+} | {
+    kind: "exhausted";
+};
+/**
+ * Decide whether empty assistant output gets one continuation after a
+ * history replacement.
+ */
+export declare function nextEmptyOutputContinuation(args: {
+    attempt: number;
+    lastAssistant?: AssistantMessage;
+    messages: PiMessage[];
+}): EmptyOutputContinuation;
+export {};

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

@@ -1,6 +1,5 @@
-import type { LogContext } from "@/chat/logging";
 import type { AgentRunResult } from "@/chat/services/turn-result";
-type LogException = (error: unknown, eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string) => string | undefined;
+type LogException = (error: unknown, eventName: string, attributes?: Record<string, unknown>) => 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. */
@@ -14,7 +13,6 @@ export interface FinalizedTurnFailure {
 export declare function finalizeFailedTurnReplyWithEvent(args: {
     reply: AgentRunResult;
     logException: LogException;
-    context: LogContext;
     attributes?: Record<string, unknown>;
 }): FinalizedTurnFailure;
 /** Enforce one captured, event-ID-bearing failure response before delivery. */

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

@@ -1,10 +1,8 @@
-import type { LogContext } from "@/chat/logging";
 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;
     durationMs?: number;
@@ -38,13 +36,10 @@ export interface TurnResultInput {
     durationMs?: number;
     generatedFileCount: number;
     shouldTrace: boolean;
-    spanContext: LogContext;
     usage?: AgentTurnUsage;
     executionProfile: TurnRoute;
     assistantUserName?: string;
     modelId: string;
 }
-/** Return destination-visible text from one completed tool-free assistant message. */
-export declare function getAssistantMessageText(message: Parameters<typeof extractAssistantText>[0]): string | undefined;
 /** Process raw agent messages into a structured AgentRunResult. */
 export declare function buildTurnResult(input: TurnResultInput): AgentRunResult;

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

@@ -14,13 +14,6 @@ export interface TurnSessionState {
     currentSliceId: number;
     existingSessionRecord?: AgentTurnSessionRecord;
 }
-interface SessionRecordLogContext {
-    threadId?: string;
-    actorId?: string;
-    channelId?: string;
-    runId?: string;
-    assistantUserName?: string;
-}
 /** Load turn session record state for a conversation/session pair. */
 export declare function loadTurnSessionRecord(ctx: TurnSessionContext): Promise<TurnSessionState>;
 /** Persist the latest safe in-progress boundary without scheduling continuation. */
@@ -36,7 +29,6 @@ export declare function persistRunningSessionRecord(args: {
     /** Provenance for trailing newly committed messages, such as steering. */
     trailingMessageProvenance?: ConversationMessageProvenance[];
     loadedSkillNames?: string[];
-    logContext: SessionRecordLogContext;
     modelId: string;
     actor?: Actor;
     reasoningLevel?: string;
@@ -119,7 +111,6 @@ export declare function persistAuthPauseSessionRecord(args: {
     loadedSkillNames?: string[];
     modelId: string;
     errorMessage: string;
-    logContext: SessionRecordLogContext;
     actor?: Actor;
     reasoningLevel?: string;
     surface?: AgentTurnSurface;
@@ -138,7 +129,6 @@ interface ContinuationRecordInput {
     loadedSkillNames?: string[];
     modelId: string;
     errorMessage: string;
-    logContext: SessionRecordLogContext;
     actor?: Actor;
     reasoningLevel?: string;
     surface?: AgentTurnSurface;
@@ -164,7 +154,6 @@ export declare function persistYieldSessionRecord(args: {
     loadedSkillNames?: string[];
     modelId: string;
     errorMessage: string;
-    logContext: SessionRecordLogContext;
     actor?: Actor;
     reasoningLevel?: string;
     surface?: AgentTurnSurface;

package/dist/chat/tool-support/zod-tool.d.ts

@@ -7,25 +7,30 @@ type ZodToolDefinitionBase<TInputSchema extends ZodTypeAny> = Pick<AnyToolDefini
     inputSchema: TInputSchema;
     prepareArguments?: (args: unknown) => z.input<TInputSchema>;
 };
-type StructuredToolExecuteResult<TOutputSchema extends ZodType<JuniorToolResult>> = z.input<TOutputSchema>;
+type StructuredToolExecuteResult<TOutputSchema extends ZodType<JuniorToolResult>> = z.input<TOutputSchema> | StructuredToolResultEnvelope<z.input<TOutputSchema>>;
+interface StructuredToolResultEnvelope<TDetails> {
+    content: Array<TextContent | ImageContent>;
+    details: TDetails;
+}
 export interface ContentOnlyToolResult {
     content: Array<TextContent | ImageContent>;
     details?: never;
 }
-type StructuredZodToolDefinition<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>> = ZodToolDefinitionBase<TInputSchema> & {
+type StructuredZodToolDefinition<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>, TExecuteResult extends StructuredToolExecuteResult<TOutputSchema>> = ZodToolDefinitionBase<TInputSchema> & {
     outputSchema: TOutputSchema;
     privateTraceResult?(result: z.output<TOutputSchema>): unknown;
-    execute?: (input: z.output<TInputSchema>, options: ToolExecuteOptions) => Promise<StructuredToolExecuteResult<TOutputSchema>> | StructuredToolExecuteResult<TOutputSchema>;
+    execute?: (input: z.output<TInputSchema>, options: ToolExecuteOptions) => Promise<TExecuteResult> | TExecuteResult;
 };
 type ContentZodToolDefinition<TInputSchema extends ZodTypeAny> = ZodToolDefinitionBase<TInputSchema> & {
     outputSchema?: undefined;
     execute?: (input: z.output<TInputSchema>, options: ToolExecuteOptions) => Promise<ContentOnlyToolResult> | ContentOnlyToolResult;
 };
-type StructuredZodTool<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>> = Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+type ParsedStructuredToolExecuteResult<TOutputSchema extends ZodType<JuniorToolResult>, TExecuteResult> = TExecuteResult extends StructuredToolResultEnvelope<unknown> ? StructuredToolResultEnvelope<z.output<TOutputSchema>> : z.output<TOutputSchema>;
+type StructuredZodTool<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>, TExecuteResult> = Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: JsonSchemaObject;
     outputSchema: JsonSchemaObject;
     prepareArguments(args: unknown): z.output<TInputSchema>;
-    execute?: (input: unknown, options: ToolExecuteOptions) => Promise<z.output<TOutputSchema>> | z.output<TOutputSchema>;
+    execute?: (input: unknown, options: ToolExecuteOptions) => Promise<ParsedStructuredToolExecuteResult<TOutputSchema, TExecuteResult>> | ParsedStructuredToolExecuteResult<TOutputSchema, TExecuteResult>;
 };
 type ContentZodTool<TInputSchema extends ZodTypeAny> = Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: JsonSchemaObject;
@@ -36,6 +41,6 @@ type ContentZodTool<TInputSchema extends ZodTypeAny> = Omit<AnyToolDefinition, "
 /**
  * Define a Junior-owned tool with Zod input parsing and JSON Schema parameters.
  */
-export declare function zodTool<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>>(definition: StructuredZodToolDefinition<TInputSchema, TOutputSchema>): StructuredZodTool<TInputSchema, TOutputSchema>;
+export declare function zodTool<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>, TExecuteResult extends StructuredToolExecuteResult<TOutputSchema>>(definition: StructuredZodToolDefinition<TInputSchema, TOutputSchema, TExecuteResult>): StructuredZodTool<TInputSchema, TOutputSchema, TExecuteResult>;
 export declare function zodTool<TInputSchema extends ZodTypeAny>(definition: ContentZodToolDefinition<TInputSchema>): ContentZodTool<TInputSchema>;
 export {};

package/dist/chat/tools/execute-tool.d.ts

@@ -7,37 +7,5 @@ export declare function createExecuteToolTool(): Omit<import("./definition").Any
         tool_name: string;
         arguments?: Record<string, unknown> | undefined;
     };
-    execute?: ((input: unknown, options: import("./definition").ToolExecuteOptions) => {
-        [x: string]: unknown;
-        ok: boolean;
-        status: "error" | "success";
-        target?: string | undefined;
-        data?: unknown;
-        truncated?: boolean | undefined;
-        continuation?: {
-            arguments: Record<string, unknown>;
-            reason?: string | undefined;
-        } | undefined;
-        error?: string | {
-            kind: string;
-            message: string;
-            retryable?: boolean | undefined;
-        } | undefined;
-    } | Promise<{
-        [x: string]: unknown;
-        ok: boolean;
-        status: "error" | "success";
-        target?: string | undefined;
-        data?: unknown;
-        truncated?: boolean | undefined;
-        continuation?: {
-            arguments: Record<string, unknown>;
-            reason?: string | undefined;
-        } | undefined;
-        error?: string | {
-            kind: string;
-            message: string;
-            retryable?: boolean | undefined;
-        } | undefined;
-    }>) | undefined;
+    execute?: ((input: unknown, options: import("./definition").ToolExecuteOptions) => Promise<never>) | undefined;
 };

package/dist/chat/tools/execution/tool-error-handler.d.ts

@@ -1,4 +1,4 @@
-import { type LogContext, type SetSpanAttributes } from "@/chat/logging";
+import { type SetSpanAttributes } from "@/chat/logging";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 /** Handle tool execution errors: set span attributes, log, and rethrow. */
-export declare function handleToolExecutionError(error: unknown, toolName: string, toolCallId: string | undefined, shouldTrace: boolean, traceContext: LogContext, conversationPrivacy?: ConversationPrivacy, setExecutionSpanAttributes?: SetSpanAttributes): never;
+export declare function handleToolExecutionError(error: unknown, toolName: string, toolCallId: string | undefined, shouldTrace: boolean, conversationPrivacy?: ConversationPrivacy, setExecutionSpanAttributes?: SetSpanAttributes): never;

package/dist/chat/tools/query-conversation-events.d.ts

@@ -1,6 +1,6 @@
 import { type KnownConversationEventType } from "@/chat/conversations/history";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
-/** Create a deferred tool that returns a bounded raw conversation event page. */
+/** Create a deferred tool that returns a bounded conversation event page. */
 export declare function createQueryConversationEventsTool(context: ToolRuntimeContext): Omit<import("./definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("./definition").JsonSchemaObject;
     outputSchema: import("./definition").JsonSchemaObject;
@@ -37,6 +37,7 @@ export declare function createQueryConversationEventsTool(context: ToolRuntimeCo
             message: string;
             retryable?: boolean | undefined;
         } | undefined;
+        omitted_event_count?: number | undefined;
     } | Promise<{
         [x: string]: unknown;
         ok: boolean;
@@ -63,6 +64,7 @@ export declare function createQueryConversationEventsTool(context: ToolRuntimeCo
             message: string;
             retryable?: boolean | undefined;
         } | undefined;
+        omitted_event_count?: number | undefined;
     }>) | undefined;
 };
 export type { KnownConversationEventType };

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

@@ -6,37 +6,5 @@ export declare function createBashTool(): Omit<import("../definition").AnyToolDe
         command: string;
         timeoutMs?: number | undefined;
     };
-    execute?: ((input: unknown, options: import("../definition").ToolExecuteOptions) => {
-        [x: string]: unknown;
-        ok: boolean;
-        status: "error" | "success";
-        target?: string | undefined;
-        data?: unknown;
-        truncated?: boolean | undefined;
-        continuation?: {
-            arguments: Record<string, unknown>;
-            reason?: string | undefined;
-        } | undefined;
-        error?: string | {
-            kind: string;
-            message: string;
-            retryable?: boolean | undefined;
-        } | undefined;
-    } | Promise<{
-        [x: string]: unknown;
-        ok: boolean;
-        status: "error" | "success";
-        target?: string | undefined;
-        data?: unknown;
-        truncated?: boolean | undefined;
-        continuation?: {
-            arguments: Record<string, unknown>;
-            reason?: string | undefined;
-        } | undefined;
-        error?: string | {
-            kind: string;
-            message: string;
-            retryable?: boolean | undefined;
-        } | undefined;
-    }>) | undefined;
+    execute?: ((input: unknown, options: import("../definition").ToolExecuteOptions) => Promise<never>) | undefined;
 };