@sentry/junior 0.90.0 → 0.92.0

package/dist/chat/runtime/reply-executor.d.ts

@@ -27,7 +27,7 @@ interface ReplyExecutorDeps {
     getSlackAdapter: () => SlackAdapter;
     resolveUserAttachments: (attachments: Message["attachments"] | undefined, context: {
         threadId?: string;
-        requesterId?: string;
+        actorId?: string;
         channelId?: string;
         runId?: string;
         conversation?: PreparedTurnState["conversation"];

package/dist/chat/runtime/turn-input.d.ts

@@ -1,7 +1,7 @@
 import type { Message, Thread } from "chat";
 export interface TurnContext {
     channelId?: string;
-    requesterId?: string;
+    actorId?: string;
     threadId?: string;
     runId?: string;
 }

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

@@ -13,8 +13,8 @@ export declare const sandboxEgressCredentialContextSchema: z.ZodObject<{
         }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
         actor: z.ZodObject<{
-            type: z.ZodLiteral<"system">;
-            id: z.ZodString;
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
         }, z.core.$strict>;
         subject: z.ZodOptional<z.ZodObject<{
             type: z.ZodLiteral<"user">;

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

@@ -5,7 +5,7 @@ export type { SandboxEgressAuthRequiredSignal, SandboxEgressCredentialContext, S
 /**
  * Create the signed Junior credential context embedded in the proxy URL.
  *
- * The token binds requester credentials to a specific sandbox egress id and a
+ * The token binds actor credentials to a specific sandbox egress id and a
  * short expiry. Vercel OIDC proves which VM sent a request; this token proves
  * which Junior actor and credential context that VM is allowed to use.
  */

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

@@ -16,7 +16,7 @@ export interface CompactContextArgs {
     piMessages: PiMessage[];
     metadata?: {
         channelId?: string;
-        requesterId?: string;
+        actorId?: string;
         runId?: string;
         threadId?: string;
     };

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

@@ -8,7 +8,7 @@ export interface ConversationMemoryService {
     compactConversationIfNeeded: (conversation: ThreadConversationState, context: {
         threadId?: string;
         channelId?: string;
-        requesterId?: string;
+        actorId?: string;
         runId?: string;
     }) => Promise<void>;
     generateThreadTitle: (sourceText: string) => Promise<string>;

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

@@ -11,7 +11,7 @@ export interface McpAuthOrchestrationInput {
     abortAgent: () => void;
     conversationId?: string;
     sessionId?: string;
-    requesterId?: string;
+    actorId?: string;
     channelId?: string;
     destination?: Destination;
     source?: Source;

package/dist/chat/services/message-actor-identity.d.ts

@@ -1,16 +1,16 @@
 import type { Message } from "chat";
-import { type Requester, type SlackRequester, type SlackRequesterProfile } from "@/chat/requester";
+import { type SlackActor, type SlackActorProfile, type UserActor } from "@/chat/actor";
 interface MessageAuthorIdentity {
     email?: string;
     fullName?: string;
     userId: string;
     userName?: string;
 }
-type MessageActorIdentity = Requester | MessageAuthorIdentity;
+type MessageActorIdentity = UserActor | MessageAuthorIdentity;
 /** Preserve runtime-owned identity on Chat SDK messages before persistence. */
-export declare function bindMessageActorIdentity(message: Message, requester: Requester): Requester;
+export declare function bindMessageActorIdentity(message: Message, actor: UserActor): UserActor;
 /** Read message identity without promoting adapter display fallbacks. */
 export declare function getMessageActorIdentity(message: Message): MessageActorIdentity | undefined;
 /** Attach Slack display fields only after the author id is exact. */
-export declare function ensureSlackMessageActorIdentity(message: Message, teamId: string, lookupSlackUser: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>): Promise<SlackRequester>;
+export declare function ensureSlackMessageActorIdentity(message: Message, teamId: string, lookupSlackUser: (teamId: string, userId: string) => Promise<SlackActorProfile | null | undefined>): Promise<SlackActor>;
 export {};

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

@@ -6,7 +6,7 @@ export declare function canReusePendingAuthLink(args: {
     nowMs?: number;
     pendingAuth?: ConversationPendingAuthState;
     provider: string;
-    requesterId: string;
+    actorId: string;
     scope?: string;
     sessionId: string;
 }): boolean;
@@ -14,7 +14,7 @@ export declare function getConversationPendingAuth(args: {
     conversation: ThreadConversationState;
     kind: AuthorizationPauseKind;
     provider: string;
-    requesterId: string;
+    actorId: string;
     scope?: string;
 }): ConversationPendingAuthState | undefined;
 export declare function clearPendingAuth(conversation: ThreadConversationState, sessionId?: string): void;

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

@@ -14,7 +14,7 @@ export interface PluginAuthOrchestrationInput {
     abortAgent: () => void;
     conversationId?: string;
     sessionId?: string;
-    requesterId?: string;
+    actorId?: string;
     channelId?: string;
     destination?: Destination;
     source?: Source;

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

@@ -2,7 +2,7 @@ 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;
+    actorId?: string;
     text: string;
 }): Promise<{
     text: string;

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

@@ -18,7 +18,7 @@ export interface SubscribedDecisionInput {
     isExplicitMention?: boolean;
     context: {
         threadId?: string;
-        requesterId?: string;
+        actorId?: string;
         channelId?: string;
         runId?: string;
     };

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

@@ -45,7 +45,7 @@ export interface TurnResultInput {
     thinkingSelection: TurnThinkingSelection;
     correlation?: {
         threadId?: string;
-        requesterId?: string;
+        actorId?: string;
         channelId?: string;
         runId?: string;
     };

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

@@ -1,7 +1,8 @@
 import { type AgentTurnSessionRecord, type AgentTurnSurface } from "@/chat/state/turn-session";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-import type { Destination, Requester, Source } from "@sentry/junior-plugin-api";
+import type { Destination, Actor, Source } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
+import type { PiMessageProvenance } from "@/chat/state/session-log";
 import { type AgentTurnUsage } from "@/chat/usage";
 export declare const AGENT_CONTINUE_MAX_SLICES = 48;
 export interface TurnSessionContext {
@@ -16,7 +17,7 @@ export interface TurnSessionState {
 }
 interface SessionRecordLogContext {
     threadId?: string;
-    requesterId?: string;
+    actorId?: string;
     channelId?: string;
     runId?: string;
     assistantUserName?: string;
@@ -33,9 +34,11 @@ export declare function persistRunningSessionRecord(args: {
     sessionId: string;
     sliceId: number;
     messages: PiMessage[];
+    /** Provenance for trailing newly committed messages, such as steering. */
+    trailingMessageProvenance?: PiMessageProvenance[];
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
-    requester?: Requester;
+    actor?: Actor;
     surface?: AgentTurnSurface;
     turnStartMessageIndex?: number;
 }): Promise<boolean>;
@@ -62,7 +65,7 @@ export declare function persistCompletedSessionRecord(args: {
     allMessages: PiMessage[];
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
-    requester?: Requester;
+    actor?: Actor;
     surface?: AgentTurnSurface;
     turnStartMessageIndex?: number;
 }): Promise<void>;
@@ -76,7 +79,7 @@ export declare function completeDeliveredTurn(args: {
     loadedSkillNames?: string[];
     logContext: SessionRecordLogContext;
     messages: PiMessage[];
-    requester?: Requester;
+    actor?: Actor;
     sessionId: string;
     sliceId: number;
     source: Source;
@@ -101,7 +104,7 @@ export declare function persistAuthPauseSessionRecord(args: {
     loadedSkillNames?: string[];
     errorMessage: string;
     logContext: SessionRecordLogContext;
-    requester?: Requester;
+    actor?: Actor;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
@@ -121,7 +124,7 @@ export declare function persistTimeoutSessionRecord(args: {
     loadedSkillNames?: string[];
     errorMessage: string;
     logContext: SessionRecordLogContext;
-    requester?: Requester;
+    actor?: Actor;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 /**
@@ -140,7 +143,7 @@ export declare function persistYieldSessionRecord(args: {
     loadedSkillNames?: string[];
     errorMessage: string;
     logContext: SessionRecordLogContext;
-    requester?: Requester;
+    actor?: Actor;
     surface?: AgentTurnSurface;
 }): Promise<AgentTurnSessionRecord | undefined>;
 export {};

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

@@ -36,7 +36,7 @@ export declare function selectTurnThinkingLevel(args: {
     conversationContext?: string;
     context?: {
         channelId?: string;
-        requesterId?: string;
+        actorId?: string;
         runId?: string;
         threadId?: string;
     };

package/dist/chat/slack/assistant-thread/title.d.ts

@@ -27,7 +27,7 @@ export declare function maybeUpdateAssistantTitle(args: {
     generateThreadTitle: ConversationMemoryService["generateThreadTitle"];
     getSlackAdapter: () => Pick<SlackAdapter, "setAssistantTitle">;
     modelId: string;
-    requesterId?: string;
+    actorId?: string;
     runId?: string;
     threadId?: string;
 }): Promise<{

package/dist/chat/slack/mrkdwn.d.ts

@@ -1,3 +1,9 @@
+/** Escape dynamic text for Slack mrkdwn without changing intended formatting. */
+export declare function escapeSlackMrkdwnText(text: string): string;
+/** Escape a URL for Slack explicit link syntax while preserving query semantics. */
+export declare function escapeSlackLinkUrl(url: string): string;
+/** Build a Slack explicit link from dynamic URL and label values. */
+export declare function formatSlackLink(url: string, label: string): string;
 /** Insert blank lines between content blocks so Slack renders them with visual separation. */
 export declare function ensureBlockSpacing(text: string): string;
 /**

package/dist/chat/slack/tools/canvas/create.d.ts

@@ -1,4 +1,44 @@
 import type { SlackToolContext } from "@/chat/slack/tools/context";
 import type { ToolState } from "@/chat/tools/types";
 /** Create a tool that provisions a new Slack canvas in the active channel. */
-export declare function createSlackCanvasCreateTool(context: SlackToolContext, state: ToolState): import("../../../tools/definition").AnyToolDefinition;
+export declare function createSlackCanvasCreateTool(context: SlackToolContext, state: ToolState): Omit<import("../../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        title: string;
+        markdown: string;
+    };
+    execute?: ((input: unknown, options: import("../../../tools/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;
+};

package/dist/chat/slack/tools/canvas/edit.d.ts

@@ -1,3 +1,62 @@
 import type { ToolState } from "@/chat/tools/types";
 /** Create a tool that edits a Slack canvas like a markdown file. */
-export declare function createSlackCanvasEditTool(state: ToolState): import("../../../tools/definition").AnyToolDefinition;
+export declare function createSlackCanvasEditTool(state: ToolState): Omit<import("../../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        canvas: string;
+        edits: {
+            oldText: string;
+            newText: string;
+        }[];
+    };
+    execute?: ((input: unknown, options: import("../../../tools/definition").ToolExecuteOptions) => {
+        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;
+        canvas_id?: string | undefined;
+        title?: string | undefined;
+        permalink?: string | undefined;
+        diff?: string | undefined;
+        first_changed_line?: number | undefined;
+        replacements?: number | undefined;
+        normalized_heading_count?: number | undefined;
+        summary?: string | undefined;
+        deduplicated?: boolean | undefined;
+    } | Promise<{
+        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;
+        canvas_id?: string | undefined;
+        title?: string | undefined;
+        permalink?: string | undefined;
+        diff?: string | undefined;
+        first_changed_line?: number | undefined;
+        replacements?: number | undefined;
+        normalized_heading_count?: number | undefined;
+        summary?: string | undefined;
+        deduplicated?: boolean | undefined;
+    }>) | undefined;
+};

package/dist/chat/slack/tools/canvas/read.d.ts

@@ -3,4 +3,63 @@
  * either a canvas/file ID (`F...`) or a Slack canvas/docs URL and returns the
  * canvas body downloaded via the bot's file access.
  */
-export declare function createSlackCanvasReadTool(): import("../../../tools/definition").AnyToolDefinition;
+export declare function createSlackCanvasReadTool(): Omit<import("../../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        canvas: string;
+        offset?: number | undefined;
+        limit?: number | undefined;
+    };
+    execute?: ((input: unknown, options: import("../../../tools/definition").ToolExecuteOptions) => {
+        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;
+        canvas_id?: string | undefined;
+        title?: string | undefined;
+        permalink?: string | undefined;
+        mimetype?: string | undefined;
+        filetype?: string | undefined;
+        original_byte_length?: number | undefined;
+        content?: string | undefined;
+        start_line?: number | undefined;
+        end_line?: number | undefined;
+        total_lines?: number | undefined;
+    } | Promise<{
+        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;
+        canvas_id?: string | undefined;
+        title?: string | undefined;
+        permalink?: string | undefined;
+        mimetype?: string | undefined;
+        filetype?: string | undefined;
+        original_byte_length?: number | undefined;
+        content?: string | undefined;
+        start_line?: number | undefined;
+        end_line?: number | undefined;
+        total_lines?: number | undefined;
+    }>) | undefined;
+};

package/dist/chat/slack/tools/canvas/write.d.ts

@@ -1,3 +1,43 @@
 import type { ToolState } from "@/chat/tools/types";
 /** Create a tool that deliberately replaces a Slack canvas body. */
-export declare function createSlackCanvasWriteTool(state: ToolState): import("../../../tools/definition").AnyToolDefinition;
+export declare function createSlackCanvasWriteTool(state: ToolState): Omit<import("../../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        canvas: string;
+        content: string;
+    };
+    execute?: ((input: unknown, options: import("../../../tools/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;
+};

package/dist/chat/slack/tools/channel-list-messages.d.ts

@@ -1,3 +1,47 @@
 import type { SlackToolContext } from "@/chat/slack/tools/context";
 /** Create the active-channel history tool with preflight timestamp normalization. */
-export declare function createSlackChannelListMessagesTool(context: SlackToolContext): import("../../tools/definition").AnyToolDefinition;
+export declare function createSlackChannelListMessagesTool(context: SlackToolContext): Omit<import("../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        limit?: number | undefined;
+        cursor?: string | undefined;
+        oldest?: string | undefined;
+        latest?: string | undefined;
+        inclusive?: boolean | undefined;
+        max_pages?: number | undefined;
+    };
+    execute?: ((input: unknown, options: import("../../tools/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;
+};

package/dist/chat/slack/tools/context.d.ts

@@ -1,18 +1,18 @@
 import type { ToolRuntimeContext } from "@/chat/tools/types";
 import type { SlackDestination } from "@sentry/junior-plugin-api";
 import type { SlackSource } from "@sentry/junior-plugin-api";
-import type { SlackRequester } from "@/chat/requester";
+import type { SlackActor } from "@/chat/actor";
 import { type SlackChannelId, type SlackTeamId } from "@/chat/slack/ids";
 import { type SlackMessageTs } from "@/chat/slack/timestamp";
 export interface SlackToolContext {
     destination: SlackDestination;
     source: SlackSource;
-    requester?: SlackRequester;
+    actor?: SlackActor;
     destinationChannelId: SlackChannelId;
     messageTs?: SlackMessageTs;
     sourceChannelId: SlackChannelId;
     teamId: SlackTeamId;
     threadTs?: SlackMessageTs;
 }
-/** Resolve Slack-specific tool context from the active source/destination/requester. */
+/** Resolve Slack-specific tool context from the active source/destination/actor. */
 export declare function getSlackToolContext(context: ToolRuntimeContext): SlackToolContext | undefined;

package/dist/chat/slack/tools/list/add-items.d.ts

@@ -1,3 +1,44 @@
 import type { ToolState } from "@/chat/tools/types";
 /** Create a tool that appends items to the active Slack list. */
-export declare function createSlackListAddItemsTool(state: ToolState): import("../../../tools/definition").AnyToolDefinition;
+export declare function createSlackListAddItemsTool(state: ToolState): Omit<import("../../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        items: string[];
+        assignee_user_id?: string | undefined;
+        due_date?: string | undefined;
+    };
+    execute?: ((input: unknown, options: import("../../../tools/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;
+};

package/dist/chat/slack/tools/list/create.d.ts

@@ -1,3 +1,42 @@
 import type { ToolState } from "@/chat/tools/types";
 /** Create a tool that provisions a new Slack todo list. */
-export declare function createSlackListCreateTool(state: ToolState): import("../../../tools/definition").AnyToolDefinition;
+export declare function createSlackListCreateTool(state: ToolState): Omit<import("../../../tools/definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../../../tools/definition").JsonSchemaObject;
+    outputSchema: import("../../../tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        name: string;
+    };
+    execute?: ((input: unknown, options: import("../../../tools/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;
+};