@sentry/junior 0.53.0 → 0.55.0

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,10 @@
+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";
+import type { AgentPluginHookRunner } from "@/chat/plugins/agent-hooks";
+/** 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, agentHooks?: AgentPluginHookRunner): 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 {};

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

@@ -0,0 +1,52 @@
+import type { SandboxFileSystem } from "@/chat/sandbox/workspace";
+export type { SandboxFileSystem };
+export declare const MAX_TEXT_CHARS = 60000;
+export type TextSearchResultDetails = {
+    ok: true;
+    path: string;
+    truncated: boolean;
+} | {
+    ok: false;
+    error: "not_found";
+    path: string;
+    missing_path?: string;
+    truncated: false;
+};
+export interface TextSearchToolResult {
+    content: [{
+        type: "text";
+        text: string;
+    }];
+    details: TextSearchResultDetails;
+}
+/** Normalize model-supplied numeric knobs before they reach filesystem tools. */
+export declare function positiveInteger(value: unknown): number | undefined;
+/** Compare and slice text in one line-ending space while preserving callers' output rules. */
+export declare function normalizeToLf(value: string): string;
+/** Keep tool output inside the model-facing budget with an explicit notice. */
+export declare function truncateText(value: string, maxChars?: number): {
+    content: string;
+    truncated: boolean;
+};
+/** Detect model-facing missing paths without swallowing sandbox lifecycle/API failures. */
+export declare function isMissingPathError(error: unknown): boolean;
+/** Build the shared model-visible result for expected missing search/list paths. */
+export declare function missingPathSearchResult(params: {
+    path: string;
+    displayPath?: string;
+    missingPath?: string;
+}): TextSearchToolResult;
+/** Keep sandbox filesystem tools scoped to the mounted workspace root. */
+export declare function resolveWorkspacePath(input: string | undefined, fallback?: string): string;
+/** Share bounded workspace traversal across search tools so their skip rules stay aligned. */
+export declare function collectFiles(params: {
+    fs: SandboxFileSystem;
+    root: string;
+    limit?: number;
+    pattern?: string;
+}): Promise<{
+    files: string[];
+    limitReached: boolean;
+    missingPath?: string;
+    missingRoot: boolean;
+}>;

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

@@ -0,0 +1,24 @@
+import { type SandboxFileSystem, type TextSearchResultDetails } from "@/chat/tools/sandbox/file-utils";
+interface FindFilesResult {
+    content: [{
+        type: "text";
+        text: string;
+    }];
+    details: TextSearchResultDetails & {
+        result_limit_reached?: number;
+    };
+}
+/** Find workspace files with structured limits instead of ad hoc shell output. */
+export declare function findFiles(params: {
+    fs: SandboxFileSystem;
+    limit?: unknown;
+    path?: string;
+    pattern: string;
+}): Promise<FindFilesResult>;
+/** Create the sandbox file discovery tool definition exposed to the agent. */
+export declare function createFindFilesTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;
+export {};

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

@@ -0,0 +1,33 @@
+import { type SandboxFileSystem, type TextSearchResultDetails } from "@/chat/tools/sandbox/file-utils";
+interface GrepResult {
+    content: [{
+        type: "text";
+        text: string;
+    }];
+    details: TextSearchResultDetails & {
+        line_truncated?: boolean;
+        match_limit_reached?: number;
+    };
+}
+/** Search workspace file contents with bounded, line-numbered output. */
+export declare function grepFiles(params: {
+    context?: unknown;
+    fs: SandboxFileSystem;
+    glob?: string;
+    ignoreCase?: boolean;
+    limit?: unknown;
+    literal?: boolean;
+    path?: string;
+    pattern: string;
+}): Promise<GrepResult>;
+/** Create the sandbox grep tool definition exposed to the agent. */
+export declare function createGrepTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;
+export {};

package/dist/chat/tools/sandbox/list-dir.d.ts

@@ -0,0 +1,22 @@
+import { type SandboxFileSystem, type TextSearchResultDetails } from "@/chat/tools/sandbox/file-utils";
+interface ListDirResult {
+    content: [{
+        type: "text";
+        text: string;
+    }];
+    details: TextSearchResultDetails & {
+        entry_limit_reached?: number;
+    };
+}
+/** List workspace directories without forcing the model through shell output. */
+export declare function listDir(params: {
+    fs: SandboxFileSystem;
+    limit?: unknown;
+    path?: string;
+}): Promise<ListDirResult>;
+/** Create the sandbox directory listing tool definition exposed to the agent. */
+export declare function createListDirTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;
+export {};

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

@@ -0,0 +1,32 @@
+interface TextRangeResult {
+    content: string;
+    end_line?: number;
+    path: string;
+    start_line: number;
+    success: true;
+    total_lines: number;
+    truncated: boolean;
+    continuation?: string;
+}
+interface TextRangeMissingPathResult {
+    content: "";
+    error: "not_found";
+    path: string;
+    success: false;
+}
+/** Return a bounded line window so large files can be read incrementally. */
+export declare function sliceFileContent(params: {
+    content: string;
+    limit?: unknown;
+    offset?: unknown;
+    path: string;
+}): TextRangeResult;
+/** Return a model-visible result for expected missing read targets. */
+export declare function missingFileResult(path: string): TextRangeMissingPathResult;
+/** Create the sandbox read tool definition exposed to the agent. */
+export declare function createReadFileTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;
+export {};

package/dist/chat/tools/sandbox/text-edits.d.ts

@@ -0,0 +1,28 @@
+export interface TextReplacement {
+    oldText: string;
+    newText: string;
+}
+export interface TextReplacementInput {
+    edits: TextReplacement[];
+}
+/** Preserve a text artifact's dominant line-ending style across rewrites. */
+export declare function detectLineEnding(value: string): "\r\n" | "\n";
+/** Restore normalized LF content to the caller's original line-ending style. */
+export declare function restoreLineEndings(value: string, lineEnding: "\r\n" | "\n"): string;
+/** Keep UTF-8 BOM handling out of exact edit matching. */
+export declare function stripBom(value: string): {
+    bom: string;
+    text: string;
+};
+/** Accept common exact-edit argument variants before schema validation. */
+export declare function prepareTextReplacementArguments<T extends TextReplacementInput>(input: unknown): T;
+/** Build a small line-oriented diff that gives agents enough context to review edits. */
+export declare function buildCompactDiff(oldContent: string, newContent: string): {
+    diff: string;
+    firstChangedLine?: number;
+};
+/** Apply exact replacements to normalized text after validating uniqueness and overlap. */
+export declare function validateAndApplyTextEdits(content: string, edits: TextReplacement[], targetName: string): {
+    baseContent: string;
+    newContent: string;
+};

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

@@ -0,0 +1,5 @@
+/** Create the sandbox full-file write tool definition exposed to the agent. */
+export declare function createWriteFileTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TString;
+}>>;

package/dist/chat/tools/skill/call-mcp-tool.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolManager } from "@/chat/mcp/tool-manager";
+import type { Skill } from "@/chat/skills";
+/** Create the stable dispatcher for active MCP provider tools. */
+export declare function createCallMcpToolTool(mcpToolManager: McpToolManager, getActiveSkills: () => Skill[]): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    tool_name: import("@sinclair/typebox").TString;
+    arguments: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
+}>>;

package/dist/chat/tools/skill/load-skill.d.ts

@@ -0,0 +1,22 @@
+import { type Skill, type SkillMetadata } from "@/chat/skills";
+export type LoadSkillResult = {
+    ok?: boolean;
+    error?: string;
+    available_skills?: string[];
+    skill_name?: string;
+    description?: string;
+    skill_dir?: string;
+    working_directory?: string;
+    location?: string;
+    path_resolution?: string;
+    instructions?: string;
+    mcp_provider?: string;
+    available_tool_count?: number;
+};
+export type LoadSkillMetadata = Pick<LoadSkillResult, "mcp_provider" | "available_tool_count">;
+/** Create the skill-loading tool that injects skill instructions and activates provider catalogs. */
+export declare function createLoadSkillTool(availableSkills: SkillMetadata[], options?: {
+    onSkillLoaded?: (skill: Skill) => void | LoadSkillMetadata | Promise<void | LoadSkillMetadata>;
+}): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    skill_name: import("@sinclair/typebox").TString;
+}>>;

package/dist/chat/tools/skill/mcp-tool-summary.d.ts

@@ -0,0 +1,31 @@
+import type { ManagedMcpToolDescriptor } from "@/chat/mcp/tool-manager";
+export interface ExposedToolSummary {
+    tool_name: string;
+    mcp_tool_name: string;
+    provider: string;
+    title?: string;
+    description: string;
+    signature: string;
+    call: {
+        tool_name: string;
+        arguments: Record<string, string>;
+    };
+    input_schema: Record<string, unknown>;
+    input_schema_summary: string;
+    output_schema?: Record<string, unknown>;
+    annotations?: Record<string, unknown>;
+}
+export interface ActiveMcpCatalogSummary {
+    provider: string;
+    available_tool_count: number;
+}
+/** Build a stable model-readable MCP tool signature. */
+export declare function formatMcpToolSignature(toolName: string, schema: Record<string, unknown>): string;
+/** Build the exact callMcpTool argument shape agents should use. */
+export declare function formatMcpToolCallExample(toolName: string, schema: Record<string, unknown>): ExposedToolSummary["call"];
+/** Summarize an MCP input schema for quick catalog scanning. */
+export declare function summarizeInputSchema(schema: Record<string, unknown>): string;
+/** Convert a managed MCP tool descriptor into agent-visible search output. */
+export declare function toExposedToolSummary(toolDef: ManagedMcpToolDescriptor): ExposedToolSummary;
+/** Group discovered MCP tools into provider catalogs for prompt disclosure. */
+export declare function toActiveMcpCatalogSummaries(toolDefs: ManagedMcpToolDescriptor[]): ActiveMcpCatalogSummary[];