@sentry/junior 0.91.0 → 0.92.1

package/dist/chat/state/turn-session.d.ts

@@ -1,6 +1,7 @@
 import { type Destination, type Source } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
-import { type Requester } from "@/chat/requester";
+import { type Actor } from "@/chat/actor";
+import { type PiMessageProvenance } from "./session-log";
 import type { AgentTurnUsage } from "@/chat/usage";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { ConversationStore } from "@/chat/conversations/store";
@@ -19,7 +20,17 @@ export interface AgentTurnSessionRecord {
     lastProgressAtMs: number;
     loadedSkillNames?: string[];
     piMessages: PiMessage[];
-    requester?: Requester;
+    /** Per-message provenance aligned one-to-one with `piMessages`. */
+    piMessageProvenance: PiMessageProvenance[];
+    /**
+     * All distinct actors annotated on this run's committed instruction-authority
+     * messages, in first-seen order. Derived from `piMessageProvenance` at
+     * materialization — never persisted separately, so it cannot drift from
+     * provenance. Attribution only; never an authority source.
+     */
+    actors: Actor[];
+    /** The single actor this run executes as (credential binding, auth flows). */
+    actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
     resumedFromSliceId?: number;
     sessionId: string;
@@ -31,7 +42,7 @@ export interface AgentTurnSessionRecord {
     turnStartMessageIndex?: number;
     updatedAtMs: number;
 }
-export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "piMessages" | "turnStartMessageIndex">;
+export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "actors" | "piMessages" | "piMessageProvenance" | "turnStartMessageIndex">;
 /** Read a materialized turn session record for resume and history loading. */
 export declare function getAgentTurnSessionRecord(conversationId: string, sessionId: string): Promise<AgentTurnSessionRecord | undefined>;
 /** Commit stable Pi session state and advance the turn session record. */
@@ -52,7 +63,9 @@ export declare function upsertAgentTurnSessionRecord(args: {
     state: AgentTurnSessionStatus;
     surface?: AgentTurnSurface;
     piMessages: PiMessage[];
-    requester?: Requester;
+    /** Provenance for trailing newly committed messages, such as steering. */
+    trailingMessageProvenance?: PiMessageProvenance[];
+    actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
     errorMessage?: string;
     resumedFromSliceId?: number;
@@ -77,7 +90,7 @@ export declare function recordAgentTurnSessionSummary(args: {
     lastProgressAtMs?: number;
     loadedSkillNames?: string[];
     conversationStore?: ConversationStore;
-    requester?: Requester;
+    actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
     sessionId: string;
     sliceId: number;

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

@@ -5,7 +5,7 @@ import type { ConversationStore } from "@/chat/conversations/store";
 import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
 import { type SlackInstallationContext } from "@/chat/slack/adapter-context";
-import { type SlackRequesterProfile } from "@/chat/requester";
+import { type SlackActorProfile } from "@/chat/actor";
 export type SlackConversationRoute = "mention" | "subscribed";
 export interface SlackConversationMessageMetadata {
     [key: string]: unknown;
@@ -44,7 +44,7 @@ interface SlackResourceEventInboundInput {
 }
 export interface CreateSlackConversationWorkerOptions {
     getSlackAdapter: () => SlackAdapter;
-    lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>;
+    lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackActorProfile | null | undefined>;
     resumeAwaitingContinuation: (conversationId: string) => Promise<boolean>;
     conversationStore?: ConversationStore;
     runtime: SlackInboxTurnRuntime;

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

@@ -1,6 +1,6 @@
 import type { StateAdapter } from "chat";
 import type { Destination } from "@sentry/junior-plugin-api";
-import { type StoredSlackRequester } from "@/chat/requester";
+import { type StoredSlackActor } from "@/chat/actor";
 declare class InvalidConversationRecordError extends Error {
     constructor(conversationId: string);
 }
@@ -55,7 +55,7 @@ export interface Conversation {
     destination?: Destination;
     execution: ConversationExecution;
     lastActivityAtMs: number;
-    requester?: StoredSlackRequester;
+    actor?: StoredSlackActor;
     schemaVersion: 1;
     source?: Source;
     title?: string;
@@ -131,7 +131,7 @@ export declare function recordConversationActivity(args: {
     conversationId: string;
     destination?: Destination;
     nowMs?: number;
-    requester?: StoredSlackRequester;
+    actor?: StoredSlackActor;
     source?: Source;
     state?: StateAdapter;
     title?: string;
@@ -150,7 +150,7 @@ export declare function recordConversationExecution(args: {
         updatedAtMs?: number;
     };
     lastActivityAtMs: number;
-    requester?: StoredSlackRequester;
+    actor?: StoredSlackActor;
     source?: Source;
     state?: StateAdapter;
     title?: string;

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

@@ -1,13 +1,13 @@
 import { z, type ZodType, type ZodTypeAny } from "zod";
 import { type JuniorToolResult } from "@/chat/tool-support/structured-result";
 import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
-import type { AnyToolDefinition, ToolExecuteOptions } from "@/chat/tools/definition";
+import type { AnyToolDefinition, JsonSchemaObject, ToolExecuteOptions } from "@/chat/tools/definition";
 type ZodToolDefinitionBase<TInputSchema extends ZodTypeAny> = Pick<AnyToolDefinition, "identity" | "description" | "exposure" | "annotations" | "promptSnippet" | "promptGuidelines" | "executionMode"> & {
     inputSchema: TInputSchema;
     prepareArguments?: (args: unknown) => z.input<TInputSchema>;
 };
 type StructuredToolExecuteResult<TOutputSchema extends ZodType<JuniorToolResult>> = z.input<TOutputSchema>;
-interface ContentOnlyToolResult {
+export interface ContentOnlyToolResult {
     content: Array<TextContent | ImageContent>;
     details?: never;
 }
@@ -19,9 +19,21 @@ type ContentZodToolDefinition<TInputSchema extends ZodTypeAny> = ZodToolDefiniti
     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"> & {
+    inputSchema: JsonSchemaObject;
+    outputSchema: JsonSchemaObject;
+    prepareArguments(args: unknown): z.output<TInputSchema>;
+    execute?: (input: unknown, options: ToolExecuteOptions) => Promise<z.output<TOutputSchema>> | z.output<TOutputSchema>;
+};
+type ContentZodTool<TInputSchema extends ZodTypeAny> = Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: JsonSchemaObject;
+    outputSchema?: undefined;
+    prepareArguments(args: unknown): z.output<TInputSchema>;
+    execute?: (input: unknown, options: ToolExecuteOptions) => Promise<ContentOnlyToolResult> | ContentOnlyToolResult;
+};
 /**
  * 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>): AnyToolDefinition;
-export declare function zodTool<TInputSchema extends ZodTypeAny>(definition: ContentZodToolDefinition<TInputSchema>): AnyToolDefinition;
+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>(definition: ContentZodToolDefinition<TInputSchema>): ContentZodTool<TInputSchema>;
 export {};

package/dist/chat/tools/advisor/tool.d.ts

@@ -24,4 +24,44 @@ export interface AdvisorToolRuntimeContext {
 /** Build the advisor's read-only tool definition subset. */
 export declare function createAdvisorToolDefinitions(definitions: Record<string, AnyToolDefinition>): Record<string, AnyToolDefinition>;
 /** Create the advisor tool backed by conversation-scoped message history. */
-export declare function createAdvisorTool(context: AdvisorToolRuntimeContext): AnyToolDefinition;
+export declare function createAdvisorTool(context: AdvisorToolRuntimeContext): Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("@/chat/tools/definition").JsonSchemaObject;
+    outputSchema: import("@/chat/tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        question: string;
+        context: string;
+    };
+    execute?: ((input: unknown, options: import("@/chat/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/tools/definition.d.ts

@@ -23,6 +23,11 @@ interface BaseToolDefinition<TInput, TInputSchema extends ToolInputSchema> {
         name: string;
         plugin: string;
     };
+    /** Stable model-facing catalog grouping for deferred tool discovery. */
+    source?: {
+        description: string;
+        id: string;
+    };
     description: string;
     exposure?: ToolExposure;
     inputSchema: TInputSchema;
@@ -56,6 +61,11 @@ export interface AnyToolDefinition {
         name: string;
         plugin: string;
     };
+    /** Stable model-facing catalog grouping for deferred tool discovery. */
+    source?: {
+        description: string;
+        id: string;
+    };
     description: string;
     exposure?: ToolExposure;
     inputSchema: ToolInputSchema;

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

@@ -1,3 +1,43 @@
 export declare const EXECUTE_TOOL_NAME = "executeTool";
 /** Create the model-visible dispatcher schema for catalog tools. */
-export declare function createExecuteToolTool(): import("./definition").AnyToolDefinition;
+export declare function createExecuteToolTool(): Omit<import("./definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("./definition").JsonSchemaObject;
+    outputSchema: import("./definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        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;
+};

package/dist/chat/tools/resource-events.d.ts

@@ -2,8 +2,129 @@ import type { ToolRuntimeContext } from "@/chat/tools/types";
 /** Return whether the current runtime can safely manage conversation subscriptions. */
 export declare function canUseResourceEventSubscriptionTools(context: ToolRuntimeContext): boolean;
 /** Create the tool that subscribes the current conversation to resource events. */
-export declare function createSubscribeToResourceEventsTool(context: ToolRuntimeContext): import("./definition").AnyToolDefinition;
+export declare function createSubscribeToResourceEventsTool(context: ToolRuntimeContext): Omit<import("./definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("./definition").JsonSchemaObject;
+    outputSchema: import("./definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        resourceRef: string;
+        provider: string;
+        resourceType: string;
+        label: string;
+        events: string[];
+        intent: string;
+        ttlMs?: 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;
+};
 /** Create the tool that lists active resource subscriptions for this conversation. */
-export declare function createListResourceEventSubscriptionsTool(context: ToolRuntimeContext): import("./definition").AnyToolDefinition;
+export declare function createListResourceEventSubscriptionsTool(context: ToolRuntimeContext): Omit<import("./definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("./definition").JsonSchemaObject;
+    outputSchema: import("./definition").JsonSchemaObject;
+    prepareArguments(args: unknown): Record<string, never>;
+    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;
+};
 /** Create the tool that cancels a current-conversation resource subscription. */
-export declare function createCancelResourceEventSubscriptionTool(context: ToolRuntimeContext): import("./definition").AnyToolDefinition;
+export declare function createCancelResourceEventSubscriptionTool(context: ToolRuntimeContext): Omit<import("./definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("./definition").JsonSchemaObject;
+    outputSchema: import("./definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        subscriptionId: string;
+    };
+    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;
+};

package/dist/chat/tools/runtime/report-progress.d.ts

@@ -1,2 +1,41 @@
 /** Create the internal tool the model uses for sparse progress updates. */
-export declare function createReportProgressTool(): import("../definition").AnyToolDefinition;
+export declare function createReportProgressTool(): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../definition").JsonSchemaObject;
+    outputSchema: import("../definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        message: string;
+    };
+    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;
+};

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

@@ -1,2 +1,42 @@
 /** Create the sandbox shell tool definition exposed to the agent. */
-export declare function createBashTool(): import("../definition").AnyToolDefinition;
+export declare function createBashTool(): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../definition").JsonSchemaObject;
+    outputSchema: import("../definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        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;
+};

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

@@ -51,5 +51,48 @@ export declare function editFile(params: {
     path: string;
 }): Promise<EditFileResult>;
 /** Create the sandbox edit tool definition exposed to the agent. */
-export declare function createEditFileTool(): import("../definition").AnyToolDefinition;
+export declare function createEditFileTool(): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../definition").JsonSchemaObject;
+    outputSchema: import("../definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        path: string;
+        edits: {
+            oldText: string;
+            newText: string;
+        }[];
+    };
+    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;
+};
 export {};

package/dist/chat/tools/sandbox/find-files.d.ts

@@ -21,5 +21,46 @@ export declare function findFiles(params: {
     pattern: string;
 }): Promise<FindFilesResult>;
 /** Create the sandbox file discovery tool definition exposed to the agent. */
-export declare function createFindFilesTool(): import("../definition").AnyToolDefinition;
+export declare function createFindFilesTool(): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../definition").JsonSchemaObject;
+    outputSchema: import("../definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        pattern: string;
+        path?: string | undefined;
+        limit?: 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;
+};
 export {};

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

@@ -35,5 +35,50 @@ export declare function grepFiles(params: {
     pattern: string;
 }): Promise<GrepResult>;
 /** Create the sandbox grep tool definition exposed to the agent. */
-export declare function createGrepTool(): import("../definition").AnyToolDefinition;
+export declare function createGrepTool(): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("../definition").JsonSchemaObject;
+    outputSchema: import("../definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        pattern: string;
+        path?: string | undefined;
+        glob?: string | undefined;
+        ignoreCase?: boolean | undefined;
+        literal?: boolean | undefined;
+        context?: number | undefined;
+        limit?: 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;
+};
 export {};