@sentry/junior 0.52.0 → 0.54.0

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[];

package/dist/chat/tools/skill/search-mcp-tools.d.ts

@@ -0,0 +1,8 @@
+import type { McpToolManager } from "@/chat/mcp/tool-manager";
+import type { Skill } from "@/chat/skills";
+/** Create the progressive MCP catalog search tool used before callMcpTool. */
+export declare function createSearchMcpToolsTool(mcpToolManager: McpToolManager, getActiveSkills: () => Skill[]): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    provider: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    max_results: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;

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

@@ -0,0 +1,29 @@
+import type { ToolRuntimeContext, ToolState } from "@/chat/tools/types";
+/** Create a tool that provisions a new Slack canvas in the active channel. */
+export declare function createSlackCanvasCreateTool(context: ToolRuntimeContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    title: import("@sinclair/typebox").TString;
+    markdown: import("@sinclair/typebox").TString;
+}>>;
+/**
+ * Create a tool that reads a Slack canvas the bot has access to. Accepts
+ * 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("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    canvas: import("@sinclair/typebox").TString;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;
+/** Create a tool that edits a Slack canvas like a markdown file. */
+export declare function createSlackCanvasEditTool(state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    canvas: import("@sinclair/typebox").TString;
+    edits: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        oldText: import("@sinclair/typebox").TString;
+        newText: import("@sinclair/typebox").TString;
+    }>>;
+}>>;
+/** Create a tool that deliberately replaces a Slack canvas body. */
+export declare function createSlackCanvasWriteTool(state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    canvas: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TString;
+}>>;

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

@@ -0,0 +1,45 @@
+export { extractCanvasId } from "@/chat/slack/canvas-references";
+export interface CanvasCreateInput {
+    title: string;
+    markdown: string;
+    channelId?: string;
+}
+export interface CanvasReadResult {
+    canvasId: string;
+    title?: string;
+    permalink?: string;
+    mimetype?: string;
+    filetype?: string;
+    content: string;
+    byteLength: number;
+}
+/** Clamp headings deeper than h3 to h3 (Slack canvas limitation). */
+export declare function normalizeCanvasMarkdown(markdown: string): {
+    markdown: string;
+    normalizedHeadingCount: number;
+};
+/**
+ * Create a standalone Slack canvas owned by the bot and best-effort grant write
+ * access to the active channel. Standalone canvases (`canvases.create`) are not
+ * subject to the one-per-channel limit of `conversations.canvases.create`, so
+ * the bot can produce multiple canvases in the same channel/thread.
+ */
+export declare function createCanvas(input: CanvasCreateInput): Promise<{
+    canvasId: string;
+    permalink?: string;
+}>;
+/** Replace an existing Slack canvas body with the provided markdown. */
+export declare function writeCanvasMarkdown(input: {
+    canvasId: string;
+    markdown: string;
+}): Promise<{
+    markdown: string;
+    normalizedHeadingCount: number;
+}>;
+/**
+ * Read a Slack canvas the bot has access to and return its raw downloadable
+ * content. Slack does not expose a structured canvas-read API, so we fetch
+ * file metadata via `files.info` and download the canvas body via the private
+ * file URL with the bot token.
+ */
+export declare function readCanvas(canvasIdOrUrl: string): Promise<CanvasReadResult>;

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

@@ -0,0 +1,9 @@
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+export declare function createSlackChannelListMessagesTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    cursor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    oldest: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    latest: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    inclusive: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    max_pages: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;

package/dist/chat/tools/slack/channel-post-message.d.ts

@@ -0,0 +1,4 @@
+import type { ToolRuntimeContext, ToolState } from "@/chat/tools/types";
+export declare function createSlackChannelPostMessageTool(context: ToolRuntimeContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;

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

@@ -0,0 +1,21 @@
+import type { ToolState } from "@/chat/tools/types";
+/** Create a tool that provisions a new Slack todo list. */
+export declare function createSlackListCreateTool(state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+}>>;
+/** Create a tool that appends items to the active Slack list. */
+export declare function createSlackListAddItemsTool(state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    items: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    assignee_user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    due_date: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>>;
+/** Create a tool that reads items from the active Slack list. */
+export declare function createSlackListGetItemsTool(state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;
+/** Create a tool that updates an item in the active Slack list. */
+export declare function createSlackListUpdateItemTool(state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    item_id: import("@sinclair/typebox").TString;
+    completed: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>>;

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

@@ -0,0 +1,42 @@
+import type { ListColumnMap } from "@/chat/state/artifacts";
+interface SlackListsSchemaColumnResponse {
+    id: string;
+    key: string;
+    name: string;
+    type: string;
+    is_primary_column?: boolean;
+}
+interface SlackListsItem {
+    id: string;
+    fields: unknown[];
+}
+/** Infer well-known column roles (title, completed, assignee, due date) from a list schema. */
+export declare function inferListColumnMap(schema?: SlackListsSchemaColumnResponse[]): ListColumnMap;
+/** Create a new Slack todo list with the default schema. */
+export declare function createTodoList(name: string): Promise<{
+    listId: string;
+    listColumnMap: ListColumnMap;
+    permalink?: string;
+}>;
+/** Add one or more items to an existing Slack list. */
+export declare function addListItems(input: {
+    listId: string;
+    titles: string[];
+    listColumnMap?: ListColumnMap;
+    assigneeUserId?: string;
+    dueDate?: string;
+}): Promise<{
+    createdItemIds: string[];
+    listColumnMap?: ListColumnMap;
+}>;
+/** Fetch items from a Slack list, paginating up to `limit`. */
+export declare function listItems(listId: string, limit?: number): Promise<SlackListsItem[]>;
+/** Update fields (title, completed) on an existing Slack list item. */
+export declare function updateListItem(input: {
+    listId: string;
+    itemId: string;
+    listColumnMap: ListColumnMap;
+    completed?: boolean;
+    title?: string;
+}): Promise<void>;
+export {};

package/dist/chat/tools/slack/message-add-reaction.d.ts

@@ -0,0 +1,4 @@
+import type { ToolRuntimeContext, ToolState } from "@/chat/tools/types";
+export declare function createSlackMessageAddReactionTool(context: ToolRuntimeContext, state: ToolState): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    emoji: import("@sinclair/typebox").TString;
+}>>;

package/dist/chat/tools/slack/slack-message-url.d.ts

@@ -0,0 +1,18 @@
+/** Parse Slack archive URLs into structured message references. */
+export interface SlackMessageReference {
+    channelId: string;
+    messageTs: string;
+    threadTs?: string;
+}
+type ParseResult = {
+    ok: true;
+    reference: SlackMessageReference;
+} | {
+    ok: false;
+    error: string;
+};
+/** Slack message timestamp format: 10 digits, dot, 6 digits. */
+export declare const SLACK_TS_PATTERN: RegExp;
+/** Parse a Slack archive URL (or mrkdwn-wrapped URL) into a message reference. */
+export declare function parseSlackMessageReference(input: string): ParseResult;
+export {};

package/dist/chat/tools/slack/thread-read.d.ts

@@ -0,0 +1,9 @@
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+/** Create a tool that reads a Slack thread from a shared message URL or explicit coordinates. */
+export declare function createSlackThreadReadTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    url: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    channel_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    max_pages: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;

package/dist/chat/tools/slack/user-lookup.d.ts

@@ -0,0 +1,8 @@
+export declare function createSlackUserLookupTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    email: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    max_pages: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    include_bots: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>>;

package/dist/chat/tools/system-time.d.ts

@@ -0,0 +1 @@
+export declare function createSystemTimeTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{}>>;

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

@@ -0,0 +1,55 @@
+import type { FileUpload } from "chat";
+import type { McpToolManager } from "@/chat/mcp/tool-manager";
+import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { Skill } from "@/chat/skills";
+import type { LoadSkillMetadata } from "@/chat/tools/skill/load-skill";
+import type { ChannelCapabilities } from "@/chat/tools/channel-capabilities";
+import type { AdvisorToolRuntimeContext } from "@/chat/tools/advisor/tool";
+export interface ImageGenerateToolDeps {
+    fetch?: typeof fetch;
+}
+export interface WebFetchToolDeps {
+    execute?: (input: {
+        url: string;
+        max_chars?: number;
+    }) => Promise<unknown> | unknown;
+}
+export interface WebSearchToolDeps {
+    execute?: (input: {
+        query: string;
+        max_results?: number;
+    }) => Promise<unknown> | unknown;
+}
+export interface ToolHooks {
+    getGeneratedFile?: (filename: string) => FileUpload | undefined;
+    onGeneratedArtifactFiles?: (files: FileUpload[]) => void;
+    onGeneratedFiles?: (files: FileUpload[]) => void;
+    onArtifactStatePatch?: (patch: Partial<ThreadArtifactsState>) => void | Promise<void>;
+    onSkillLoaded?: (skill: Skill) => void | LoadSkillMetadata | Promise<void | LoadSkillMetadata>;
+    toolOverrides?: {
+        imageGenerate?: ImageGenerateToolDeps;
+        webFetch?: WebFetchToolDeps;
+        webSearch?: WebSearchToolDeps;
+    };
+}
+export interface ToolRuntimeContext {
+    advisor?: AdvisorToolRuntimeContext;
+    channelId?: string;
+    channelCapabilities: ChannelCapabilities;
+    messageTs?: string;
+    threadTs?: string;
+    userText?: string;
+    artifactState?: ThreadArtifactsState;
+    configuration?: Record<string, unknown>;
+    getActiveSkills?: () => Skill[];
+    mcpToolManager?: McpToolManager;
+    sandbox: SandboxWorkspace;
+}
+export interface ToolState {
+    artifactState: ThreadArtifactsState;
+    patchArtifactState: (patch: Partial<ThreadArtifactsState>) => void | Promise<void>;
+    getCurrentListId: () => string | undefined;
+    getOperationResult: <T>(operationKey: string) => T | undefined;
+    setOperationResult: (operationKey: string, result: unknown) => void;
+}

package/dist/chat/tools/web/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const USER_AGENT = "junior-bot/0.1";
+export declare const FETCH_TIMEOUT_MS = 8000;
+export declare const MAX_REDIRECTS = 3;
+export declare const DEFAULT_MAX_CHARS = 6000;
+export declare const MAX_FETCH_CHARS = 12000;
+export declare const MAX_FETCH_BYTES = 1000000;

package/dist/chat/tools/web/fetch-content.d.ts

@@ -0,0 +1,23 @@
+import { MAX_FETCH_CHARS } from "@/chat/tools/web/constants";
+export { MAX_FETCH_CHARS };
+export interface WebFetchResponseContent {
+    content: string;
+    title?: string;
+    truncated: boolean;
+    extractedChars: number;
+}
+export interface WebFetchResponse {
+    url: string;
+    content: string;
+    title?: string;
+    content_type: string;
+    source_bytes: number;
+    extracted_chars: number;
+    truncated: boolean;
+}
+/** Extract readable content and metadata from a fetched response body. */
+export declare function extractContentDetails(body: string, contentType: string, maxChars: number): WebFetchResponseContent;
+/** Extract readable content from a fetched response body, converting HTML to markdown. */
+export declare function extractContent(body: string, contentType: string, maxChars: number): string;
+/** Extract text content from a web fetch response, validating content type and size. */
+export declare function extractWebFetchResponse(url: URL, response: Response, maxChars?: number): Promise<WebFetchResponse>;

package/dist/chat/tools/web/fetch-tool.d.ts

@@ -0,0 +1,5 @@
+import type { ToolHooks } from "@/chat/tools/types";
+export declare function createWebFetchTool(hooks: ToolHooks): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    url: import("@sinclair/typebox").TString;
+    max_chars: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;

package/dist/chat/tools/web/image-generate.d.ts

@@ -0,0 +1,4 @@
+import type { ImageGenerateToolDeps, ToolHooks } from "@/chat/tools/types";
+export declare function createImageGenerateTool(hooks: ToolHooks, deps?: ImageGenerateToolDeps): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    prompt: import("@sinclair/typebox").TString;
+}>>;

package/dist/chat/tools/web/network.d.ts

@@ -0,0 +1,6 @@
+export declare function assertPublicUrl(rawUrl: string): Promise<URL>;
+export declare function withTimeout<T>(task: Promise<T>, timeoutMs: number, label: string, options?: {
+    onTimeout?: () => void;
+}): Promise<T>;
+export declare function fetchTextWithRedirects(url: URL, redirectsLeft: number): Promise<Response>;
+export declare function readResponseBody(response: Response, maxBytes: number): Promise<string>;

package/dist/chat/tools/web/search.d.ts

@@ -0,0 +1,5 @@
+import type { WebSearchToolDeps } from "@/chat/tools/types";
+export declare function createWebSearchTool(override?: WebSearchToolDeps): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TString;
+    max_results: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+}>>;

package/dist/chat/turn-context-tag.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Canonical tag name for the runtime turn context block injected into Pi
+ * messages. Shared between prompt assembly and turn context stripping to keep
+ * both in sync without requiring the full prompt module.
+ */
+export declare const TURN_CONTEXT_TAG = "runtime-turn-context";

package/dist/chat/usage.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Structured token usage captured for a single agent turn.
+ *
+ * Mirrors the fields pi-ai emits on `AssistantMessage.usage` (see
+ * `@earendil-works/pi-ai` `Usage`) so diagnostics carry every counter the
+ * provider normalizes into the pi-ai shape as its own item. Renderers decide
+ * whether to display a breakdown or a single aggregate.
+ */
+export interface AgentTurnUsage {
+    /** Non-cached input tokens; OTel `gen_ai.usage.input_tokens` adds cache counters back in. */
+    inputTokens?: number;
+    /** Output tokens; pi-ai folds reasoning tokens into this for providers that report them. */
+    outputTokens?: number;
+    /** Cached input tokens read from the provider's prompt cache. */
+    cachedInputTokens?: number;
+    /** Input tokens written into the provider's prompt cache. */
+    cacheCreationTokens?: number;
+    /** Provider-reported total. May not equal the sum of individual counters across providers. */
+    totalTokens?: number;
+}
+/** Return whether any token counter is present on a usage record. */
+export declare function hasAgentTurnUsage(usage: AgentTurnUsage | undefined): usage is AgentTurnUsage;
+/** Aggregate token usage across slices without double-counting provider totals. */
+export declare function addAgentTurnUsage(...usages: Array<AgentTurnUsage | undefined>): AgentTurnUsage | undefined;