@sentry/junior 0.52.0 → 0.54.0

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

@@ -0,0 +1,42 @@
+import type { TurnThinkingSelection } from "@/chat/services/turn-thinking-level";
+import type { AgentTurnUsage } from "@/chat/usage";
+interface SlackMrkdwnTextObject {
+    text: string;
+    type: "mrkdwn";
+}
+/** Slack-flavored Markdown block — accepts a standard Markdown subset and Slack renders it natively. */
+interface SlackMarkdownBlock {
+    text: string;
+    type: "markdown";
+}
+interface SlackSectionBlock {
+    text: SlackMrkdwnTextObject;
+    type: "section";
+}
+interface SlackContextBlock {
+    elements: SlackMrkdwnTextObject[];
+    type: "context";
+}
+export type SlackMessageBlock = SlackMarkdownBlock | SlackSectionBlock | SlackContextBlock;
+interface SlackReplyFooterItem {
+    label: string;
+    url?: string;
+    value: string;
+}
+export interface SlackReplyFooter {
+    items: SlackReplyFooterItem[];
+}
+/**
+ * Build a compact footer for the finalized Slack reply.
+ *
+ * This is reply metadata, not part of the in-flight assistant loading state.
+ */
+export declare function buildSlackReplyFooter(args: {
+    conversationId?: string;
+    durationMs?: number;
+    thinkingLevel?: TurnThinkingSelection["thinkingLevel"];
+    usage?: AgentTurnUsage;
+}): SlackReplyFooter | undefined;
+/** Build Slack blocks for a reply chunk using the Slack-flavored markdown block for the body. */
+export declare function buildSlackReplyBlocks(text: string, footer: SlackReplyFooter | undefined): SlackMessageBlock[] | undefined;
+export {};

package/dist/chat/slack/legacy-attachments.d.ts

@@ -0,0 +1,4 @@
+/** Render legacy Slack attachment fields so attachment-only messages still carry context. */
+export declare function renderSlackLegacyAttachmentText(input: unknown): string;
+/** Append legacy Slack attachment text to the message text used by routing and replies. */
+export declare function appendSlackLegacyAttachmentText(baseText: string | undefined, rawMessageOrAttachments: unknown): string;

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

@@ -0,0 +1,6 @@
+import type { Message } from "chat";
+/**
+ * Preserve the native Slack message timestamp when a synthetic message ID is
+ * used for routing or deduplication.
+ */
+export declare function getSlackMessageTs(message: Pick<Message, "id" | "raw">): string;

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

@@ -0,0 +1,12 @@
+/** Insert blank lines between content blocks so Slack renders them with visual separation. */
+export declare function ensureBlockSpacing(text: string): string;
+/**
+ * Render model-authored markdown into Slack-friendly `mrkdwn`.
+ *
+ * Slack reply delivery owns chunking and continuation markers separately.
+ * This helper only normalizes text into the repository's canonical Slack
+ * rendering form.
+ */
+export declare function renderSlackMrkdwn(text: string): string;
+/** Normalize assistant status text before handing it to Slack. */
+export declare function normalizeSlackStatusText(text: string): string;

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

@@ -0,0 +1,57 @@
+import type { SlackMessageBlock } from "@/chat/slack/footer";
+/** Post Slack `mrkdwn` text to a conversation or thread via the shared outbound boundary. */
+export declare function postSlackMessage(input: {
+    blocks?: SlackMessageBlock[];
+    channelId: string;
+    text: string;
+    threadTs?: string;
+    includePermalink?: boolean;
+}): Promise<{
+    ts: string;
+    permalink?: string;
+}>;
+/** Delete a previously posted Slack message through the shared outbound boundary. */
+export declare function deleteSlackMessage(input: {
+    channelId: string;
+    timestamp: string;
+}): Promise<void>;
+/**
+ * Post an ephemeral Slack message. Delivery is best-effort on Slack's side, but
+ * request validation and Web API behavior are centralized here.
+ */
+export declare function postSlackEphemeralMessage(input: {
+    channelId: string;
+    userId: string;
+    text: string;
+    threadTs?: string;
+}): Promise<{
+    messageTs?: string;
+}>;
+/** Upload files into a Slack thread via the shared outbound file boundary. */
+export declare function uploadFilesToThread(input: {
+    channelId: string;
+    threadTs: string;
+    files: Array<{
+        data: Buffer;
+        filename: string;
+    }>;
+}): Promise<void>;
+/** Add a reaction to a Slack message, treating `already_reacted` as idempotent success. */
+export declare function addReactionToMessage(input: {
+    channelId: string;
+    timestamp: string;
+    emoji: string;
+}): Promise<{
+    ok: true;
+}>;
+/** Remove a reaction from a Slack message, treating `no_reaction` as idempotent success. */
+export declare function removeReactionFromMessage(input: {
+    channelId: string;
+    timestamp: string;
+    emoji: string;
+}): Promise<{
+    ok: true;
+}>;
+export declare const slackOutboundPolicy: {
+    maxMessageTextChars: number;
+};

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

@@ -0,0 +1,54 @@
+import type { FileUpload, PostableMessage } from "chat";
+/** Return the first continuation-safe chunk plus any remaining text. */
+export declare function takeSlackContinuationPrefix(text: string, options?: {
+    forceSplit?: boolean;
+    maxChars?: number;
+    maxLines?: number;
+}): {
+    prefix: string;
+    renderedPrefix: string;
+    rest: string;
+};
+/**
+ * Take the largest Slack-safe inline prefix from `text` under the configured
+ * character and line budgets. Returns the consumed prefix plus remaining text.
+ */
+export declare function takeSlackInlinePrefix(text: string, options?: {
+    maxChars?: number;
+    maxLines?: number;
+}): {
+    prefix: string;
+    rest: string;
+};
+/**
+ * Split a normalized Slack reply into multiple inline-safe thread messages.
+ *
+ * Replies split across more than two messages receive explicit continuation
+ * markers on non-final chunks. When
+ * `interrupted` is true, the final chunk receives an interruption marker.
+ */
+export declare function splitSlackReplyText(text: string, options?: {
+    interrupted?: boolean;
+}): string[];
+/** Return the marker added to non-final overflow chunks. */
+export declare function getSlackContinuationMarker(): string;
+/** Return the marker added when a visible reply ended mid-execution. */
+export declare function getSlackInterruptionMarker(): string;
+/**
+ * Return true when `text` already fits the repository's inline Slack reply
+ * budget without needing continuation messages.
+ */
+export declare function fitsSlackInlineBudget(text: string): boolean;
+/**
+ * Reserve enough inline budget for a continuation suffix on the current chunk.
+ */
+export declare function getSlackContinuationBudget(): {
+    maxChars: number;
+    maxLines: number;
+};
+/** Normalize text for Slack and wrap it as a PostableMessage with optional file attachments. */
+export declare function buildSlackOutputMessage(text: string, files?: FileUpload[]): PostableMessage;
+export declare const slackOutputPolicy: {
+    maxInlineChars: number;
+    maxInlineLines: number;
+};

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

@@ -0,0 +1,33 @@
+import type { FileUpload } from "chat";
+import type { AssistantReply } from "@/chat/respond";
+import { type SlackReplyFooter } from "@/chat/slack/footer";
+export type PlannedSlackReplyStage = "thread_reply" | "thread_reply_continuation" | "thread_reply_files_followup";
+export interface PlannedSlackReplyPost {
+    files?: FileUpload[];
+    stage: PlannedSlackReplyStage;
+    text: string;
+}
+/**
+ * Plan the Slack thread posts needed to realize a completed assistant reply,
+ * including chunking, interruption markers, and file delivery.
+ */
+export declare function planSlackReplyPosts(args: {
+    reply: AssistantReply;
+}): PlannedSlackReplyPost[];
+/**
+ * Deliver planned Slack reply posts over raw Slack Web API calls for resume and
+ * callback handlers that do not have a Chat SDK thread object.
+ */
+export declare function postSlackApiReplyPosts(args: {
+    beforePost?: () => Promise<void>;
+    footer?: SlackReplyFooter;
+    channelId: string;
+    fileUploadFailureMode?: "best_effort" | "strict";
+    onPostError?: (context: {
+        error: unknown;
+        messageTs?: string;
+        stage: PlannedSlackReplyStage;
+    }) => Promise<void> | void;
+    threadTs: string;
+    posts: PlannedSlackReplyPost[];
+}): Promise<string | undefined>;

package/dist/chat/slack/status-format.d.ts

@@ -0,0 +1,2 @@
+/** Truncate a status string to fit Slack's 50-char assistant status limit. */
+export declare function truncateStatusText(text: string): string;

package/dist/chat/slack/turn-continuation-notice.d.ts

@@ -0,0 +1,8 @@
+import { type SlackMessageBlock } from "@/chat/slack/footer";
+/** Build the Slack timeout-continuation acknowledgement with correlation-only metadata. */
+export declare function buildSlackTurnContinuationNotice(args: {
+    conversationId?: string;
+}): {
+    blocks?: SlackMessageBlock[];
+    text: string;
+};

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

@@ -0,0 +1,7 @@
+interface SlackUserLookupResult {
+    userName?: string;
+    fullName?: string;
+}
+/** Fetch Slack user profile info with in-memory TTL cache to avoid repeated API calls. */
+export declare function lookupSlackUser(userId?: string): Promise<SlackUserLookupResult | null>;
+export {};

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

@@ -0,0 +1,39 @@
+/** Normalized Slack user profile with custom fields from the Slack workspace. */
+export interface SlackUserProfile {
+    id: string;
+    team_id?: string;
+    name?: string;
+    real_name?: string;
+    display_name?: string;
+    title?: string;
+    email?: string;
+    status_text?: string;
+    status_emoji?: string;
+    is_bot: boolean;
+    is_deleted: boolean;
+    timezone?: string;
+    profile_fields?: Array<{
+        id: string;
+        label?: string;
+        value?: string;
+        alt?: string;
+    }>;
+}
+/** Look up a Slack user by ID, returning the full profile including custom fields. */
+export declare function lookupSlackUserProfile(userId: string): Promise<SlackUserProfile>;
+/** Look up a Slack user by email. Returns null when no user matches. */
+export declare function lookupSlackUserByEmail(email: string): Promise<SlackUserProfile | null>;
+export interface SlackUserSearchResult {
+    users: SlackUserProfile[];
+    searched_pages: number;
+    searched_user_count: number;
+    truncated: boolean;
+}
+/** Search workspace users by name with bounded pagination through `users.list`. */
+export declare function searchSlackUsers(options: {
+    query: string;
+    limit?: number;
+    maxPages?: number;
+    includeDeleted?: boolean;
+    includeBots?: boolean;
+}): Promise<SlackUserSearchResult>;

package/dist/chat/state/adapter.d.ts

@@ -0,0 +1,9 @@
+import type { RedisStateAdapter } from "@chat-adapter/state-redis";
+import type { StateAdapter } from "chat";
+export declare const ACTIVE_LOCK_TTL_MS = 90000;
+export declare function getConnectedStateContext(): Promise<{
+    redisStateAdapter?: RedisStateAdapter;
+    stateAdapter: StateAdapter;
+}>;
+export declare function getStateAdapter(): StateAdapter;
+export declare function disconnectStateAdapter(): Promise<void>;

package/dist/chat/state/artifacts.d.ts

@@ -0,0 +1,29 @@
+export interface ListColumnMap {
+    titleColumnId?: string;
+    completedColumnId?: string;
+    assigneeColumnId?: string;
+    dueDateColumnId?: string;
+}
+export interface CanvasArtifactSummary {
+    id: string;
+    title?: string;
+    url?: string;
+    createdAt?: string;
+}
+export interface ThreadArtifactsState {
+    assistantContextChannelId?: string;
+    assistantTitleSourceMessageId?: string;
+    lastCanvasId?: string;
+    lastCanvasUrl?: string;
+    recentCanvases?: CanvasArtifactSummary[];
+    lastListId?: string;
+    lastListUrl?: string;
+    listColumnMap?: ListColumnMap;
+    updatedAt?: string;
+}
+/** Safely coerce an unknown value into a ThreadArtifactsState, discarding invalid fields. */
+export declare function coerceThreadArtifactsState(value: unknown): ThreadArtifactsState;
+/** Wrap a partial artifact update into the storage envelope with an updatedAt timestamp. */
+export declare function buildArtifactStatePatch(patch: Partial<ThreadArtifactsState>): {
+    artifacts: ThreadArtifactsState;
+};

package/dist/chat/state/conversation.d.ts

@@ -0,0 +1,81 @@
+import type { PiMessage } from "@/chat/pi/messages";
+import type { AuthorizationPauseKind } from "@/chat/services/auth-pause";
+type ConversationRole = "assistant" | "system" | "user";
+export interface ConversationAuthor {
+    fullName?: string;
+    isBot?: boolean;
+    userId?: string;
+    userName?: string;
+}
+export interface ConversationMessageMeta {
+    attachmentCount?: number;
+    explicitMention?: boolean;
+    imageAttachmentCount?: number;
+    imageFileIds?: string[];
+    imagesHydrated?: boolean;
+    replied?: boolean;
+    slackTs?: string;
+    skippedReason?: string;
+}
+export interface ConversationMessage {
+    author?: ConversationAuthor;
+    createdAtMs: number;
+    id: string;
+    meta?: ConversationMessageMeta;
+    role: ConversationRole;
+    text: string;
+}
+export interface ConversationCompaction {
+    coveredMessageIds: string[];
+    createdAtMs: number;
+    id: string;
+    summary: string;
+}
+export interface ConversationBackfillState {
+    completedAtMs?: number;
+    source?: "recent_messages" | "thread_fetch";
+}
+export interface ConversationProcessingState {
+    activeTurnId?: string;
+    lastCompletedAtMs?: number;
+    lastSessionId?: string;
+    pendingAuth?: ConversationPendingAuthState;
+}
+export interface ConversationPendingAuthState {
+    kind: AuthorizationPauseKind;
+    linkSentAtMs: number;
+    provider: string;
+    requesterId: string;
+    sessionId: string;
+}
+export interface ConversationStats {
+    compactedMessageCount: number;
+    estimatedContextTokens: number;
+    totalMessageCount: number;
+    updatedAtMs: number;
+}
+export interface ConversationVisionSummary {
+    analyzedAtMs: number;
+    summary: string;
+}
+export interface ConversationVisionState {
+    backfillCompletedAtMs?: number;
+    byFileId: Record<string, ConversationVisionSummary>;
+}
+export interface ThreadConversationState {
+    backfill: ConversationBackfillState;
+    compactions: ConversationCompaction[];
+    messages: ConversationMessage[];
+    piMessages: PiMessage[];
+    processing: ConversationProcessingState;
+    schemaVersion: 1;
+    stats: ConversationStats;
+    vision: ConversationVisionState;
+}
+/** Safely coerce an unknown persisted value into a ThreadConversationState. */
+export declare function coerceThreadConversationState(value: unknown): ThreadConversationState;
+/** Wrap a conversation state into the storage envelope for persistence. */
+export declare function buildConversationStatePatch(conversation: ThreadConversationState): {
+    conversation: ThreadConversationState;
+};
+export {};

package/dist/chat/state/pi-session-message-store.d.ts

@@ -0,0 +1,15 @@
+import type { PiMessage } from "@/chat/pi/messages";
+interface PiSessionScope {
+    conversationId: string;
+    sessionId: string;
+}
+/** Load the exact stable Pi message prefix for a session. */
+export declare function loadPiSessionMessages(args: PiSessionScope & {
+    messageCount: number;
+}): Promise<PiMessage[] | undefined>;
+/** Commit new stable Pi messages before the caller advances its cursor. */
+export declare function commitPiSessionMessages(args: PiSessionScope & {
+    messages: PiMessage[];
+    ttlMs: number;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,2 @@
+/** Build a stable turn identifier from a message ID. */
+export declare function buildDeterministicTurnId(messageId: string): string;

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

@@ -0,0 +1,49 @@
+import type { PiMessage } from "@/chat/pi/messages";
+import type { AgentTurnUsage } from "@/chat/usage";
+export type AgentTurnSessionStatus = "running" | "awaiting_resume" | "completed" | "failed" | "superseded";
+export type AgentTurnResumeReason = "timeout" | "auth";
+export interface AgentTurnSessionCheckpoint {
+    checkpointVersion: number;
+    conversationId: string;
+    cumulativeDurationMs?: number;
+    cumulativeUsage?: AgentTurnUsage;
+    errorMessage?: string;
+    loadedSkillNames?: string[];
+    piMessages: PiMessage[];
+    resumeReason?: AgentTurnResumeReason;
+    resumedFromSliceId?: number;
+    sessionId: string;
+    sliceId: number;
+    state: AgentTurnSessionStatus;
+    updatedAtMs: number;
+}
+/** Read a materialized turn-session checkpoint for resume and history loading. */
+export declare function getAgentTurnSessionCheckpoint(conversationId: string, sessionId: string): Promise<AgentTurnSessionCheckpoint | undefined>;
+/** Commit stable Pi session state and advance the turn-session checkpoint cursor. */
+export declare function upsertAgentTurnSessionCheckpoint(args: {
+    conversationId: string;
+    cumulativeDurationMs?: number;
+    cumulativeUsage?: AgentTurnUsage;
+    sessionId: string;
+    sliceId: number;
+    state: AgentTurnSessionStatus;
+    piMessages: PiMessage[];
+    loadedSkillNames?: string[];
+    resumeReason?: AgentTurnResumeReason;
+    errorMessage?: string;
+    resumedFromSliceId?: number;
+    ttlMs?: number;
+}): Promise<AgentTurnSessionCheckpoint>;
+/** Mark an unfinished turn-session checkpoint as superseded when a newer turn wins. */
+export declare function supersedeAgentTurnSessionCheckpoint(args: {
+    conversationId: string;
+    sessionId: string;
+    errorMessage?: string;
+}): Promise<AgentTurnSessionCheckpoint | undefined>;
+/** Mark an unfinished turn-session checkpoint as failed so it cannot resume. */
+export declare function failAgentTurnSessionCheckpoint(args: {
+    conversationId: string;
+    expectedCheckpointVersion?: number;
+    sessionId: string;
+    errorMessage?: string;
+}): Promise<AgentTurnSessionCheckpoint | undefined>;

package/dist/chat/tools/advisor/session-store.d.ts

@@ -0,0 +1,9 @@
+import type { PiMessage } from "@/chat/pi/messages";
+export interface AdvisorSessionStore {
+    load: (conversationId: string) => Promise<PiMessage[]>;
+    save: (conversationId: string, messages: PiMessage[]) => Promise<void>;
+}
+/** Return the durable advisor session key for an opaque parent conversation id. */
+export declare function getAdvisorSessionKey(conversationId: string): string;
+/** Create the production advisor message store backed by the chat state adapter. */
+export declare function createStateAdvisorSessionStore(): AdvisorSessionStore;

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

@@ -0,0 +1,33 @@
+import { type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
+import type { AdvisorConfig } from "@/chat/config";
+import { type LogContext } from "@/chat/logging";
+import { type AdvisorSessionStore } from "@/chat/tools/advisor/session-store";
+import { type ToolDefinition } from "@/chat/tools/definition";
+export type AdvisorErrorCode = "invalid_context" | "invalid_question" | "missing_conversation_id" | "session_unavailable" | "unavailable";
+export interface AdvisorToolResult {
+    content: [{
+        type: "text";
+        text: string;
+    }];
+    details: {
+        ok: true;
+    } | {
+        error_code: AdvisorErrorCode;
+        ok: false;
+    };
+}
+export interface AdvisorToolRuntimeContext {
+    config: AdvisorConfig;
+    conversationId?: string;
+    getTools: () => AgentTool[];
+    logContext?: LogContext;
+    store?: AdvisorSessionStore;
+    streamFn?: StreamFn;
+}
+/** Build the advisor's read-only tool definition subset. */
+export declare function createAdvisorToolDefinitions(definitions: Record<string, ToolDefinition<any>>): Record<string, ToolDefinition<any>>;
+/** Create the advisor tool backed by conversation-scoped message history. */
+export declare function createAdvisorTool(context: AdvisorToolRuntimeContext): ToolDefinition<import("@sinclair/typebox").TObject<{
+    question: import("@sinclair/typebox").TString;
+    context: import("@sinclair/typebox").TString;
+}>>;

package/dist/chat/tools/agent-tools.d.ts

@@ -0,0 +1,9 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+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 { SkillSandbox } from "@/chat/sandbox/skill-sandbox";
+import type { ToolDefinition } from "@/chat/tools/definition";
+/** Wrap tool definitions into Pi Agent tool objects with logging, validation, and sandbox execution. */
+export declare function createAgentTools(tools: Record<string, ToolDefinition<any>>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxExecutor?: SandboxExecutor, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolName: string, params: Record<string, unknown>) => void): AgentTool[];

package/dist/chat/tools/channel-capabilities.d.ts

@@ -0,0 +1,11 @@
+/** Declared capabilities of the current channel context. */
+export interface ChannelCapabilities {
+    /** Can create canvases in this channel (C/G/D channels). */
+    canCreateCanvas: boolean;
+    /** Can post standalone messages to this channel (C/G channels only). */
+    canPostToChannel: boolean;
+    /** Can add reactions to messages (C/G/D channels). */
+    canAddReactions: boolean;
+}
+/** Resolve channel capabilities from a Slack channel ID. */
+export declare function resolveChannelCapabilities(channelId: string | undefined): ChannelCapabilities;

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

@@ -0,0 +1,17 @@
+import type { ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+import type { Static, TSchema } from "@sinclair/typebox";
+import type { ToolExecutionMode } from "@earendil-works/pi-agent-core";
+export interface ToolDefinition<TInputSchema extends TSchema = TSchema> {
+    description: string;
+    inputSchema: TInputSchema;
+    annotations?: ToolAnnotations;
+    promptSnippet?: string;
+    promptGuidelines?: string[];
+    prepareArguments?: (args: unknown) => Static<TInputSchema>;
+    executionMode?: ToolExecutionMode;
+    execute?: (input: Static<TInputSchema>, options: {
+        experimental_context?: unknown;
+    }) => Promise<unknown> | unknown;
+}
+/** Infer execute parameter types from the inputSchema via generic binding. */
+export declare function tool<TInputSchema extends TSchema>(definition: ToolDefinition<TInputSchema>): ToolDefinition<TInputSchema>;

package/dist/chat/tools/execution/build-sandbox-input.d.ts

@@ -0,0 +1,2 @@
+/** Normalize LLM tool params into the shape expected by the sandbox executor. */
+export declare function buildSandboxInput(toolName: string, params: Record<string, unknown>): Record<string, unknown>;

package/dist/chat/tools/execution/normalize-result.d.ts

@@ -0,0 +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): {
+    content: Array<TextContent | ImageContent>;
+    details: unknown;
+};

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

@@ -0,0 +1,3 @@
+import { type LogContext } from "@/chat/logging";
+/** 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): never;

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

@@ -0,0 +1,6 @@
+/** Thrown when a tool fails due to invalid model/user input, not a system error. */
+export declare class ToolInputError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}

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

@@ -0,0 +1 @@
+export declare function createOperationKey(toolName: string, input: Record<string, unknown>): string;

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

@@ -0,0 +1,5 @@
+import type { SkillMetadata } from "@/chat/skills";
+import type { ToolDefinition } from "@/chat/tools/definition";
+import type { ToolHooks, ToolRuntimeContext } from "@/chat/tools/types";
+export type { ToolHooks, ToolRuntimeContext };
+export declare function createTools(availableSkills: SkillMetadata[], hooks: ToolHooks | undefined, context: ToolRuntimeContext): Record<string, ToolDefinition<any>>;

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

@@ -0,0 +1,4 @@
+/** Create the internal tool the model uses for sparse progress updates. */
+export declare function createReportProgressTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    message: import("@sinclair/typebox").TString;
+}>>;

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

@@ -0,0 +1,7 @@
+import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
+import type { ToolHooks } from "@/chat/tools/types";
+export declare function createAttachFileTool(sandbox: SandboxWorkspace, hooks?: ToolHooks): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    filename: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    mimeType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>>;

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

@@ -0,0 +1,5 @@
+/** Create the sandbox shell tool definition exposed to the agent. */
+export declare function createBashTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    command: import("@sinclair/typebox").TString;
+    timeoutMs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;

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

@@ -0,0 +1,37 @@
+import { type SandboxFileSystem } from "@/chat/tools/sandbox/file-utils";
+import { type TextReplacement } from "@/chat/tools/sandbox/text-edits";
+type EditReplacement = TextReplacement;
+interface EditFileResult {
+    content: [{
+        type: "text";
+        text: string;
+    }];
+    details: {
+        diff: string;
+        first_changed_line?: number;
+        ok: true;
+        path: string;
+        replacements: number;
+    };
+}
+interface EditFileInput {
+    path: string;
+    edits: EditReplacement[];
+}
+/** Accept common edit argument variants before Pi validates the canonical schema. */
+export declare function prepareEditFileArguments(input: unknown): EditFileInput;
+/** Apply exact, ordered file replacements through the sandbox filesystem API. */
+export declare function editFile(params: {
+    edits: EditReplacement[];
+    fs: SandboxFileSystem;
+    path: string;
+}): Promise<EditFileResult>;
+/** Create the sandbox edit tool definition exposed to the agent. */
+export declare function createEditFileTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    edits: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        oldText: import("@sinclair/typebox").TString;
+        newText: import("@sinclair/typebox").TString;
+    }>>;
+}>>;
+export {};