@slopus/rig 0.0.1

package/dist/tools/claude/WebFetch.d.ts

@@ -0,0 +1,29 @@
+import type { WebFetchResponse } from "./webFetch/types.js";
+export interface ClaudeWebFetchDependencies {
+    fetchPage?: (url: string, signal?: AbortSignal) => Promise<WebFetchResponse>;
+    applyPrompt?: (prompt: string, markdown: string, signal: AbortSignal | undefined, isPreapprovedDomain: boolean) => Promise<string>;
+    now?: () => number;
+}
+export declare function createClaudeWebFetchTool(dependencies?: ClaudeWebFetchDependencies): import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    url: import("@sinclair/typebox").TString;
+    prompt: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    bytes: import("@sinclair/typebox").TNumber;
+    code: import("@sinclair/typebox").TNumber;
+    codeText: import("@sinclair/typebox").TString;
+    result: import("@sinclair/typebox").TString;
+    durationMs: import("@sinclair/typebox").TNumber;
+    url: import("@sinclair/typebox").TString;
+}>>;
+export declare const claudeWebFetchTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    url: import("@sinclair/typebox").TString;
+    prompt: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    bytes: import("@sinclair/typebox").TNumber;
+    code: import("@sinclair/typebox").TNumber;
+    codeText: import("@sinclair/typebox").TString;
+    result: import("@sinclair/typebox").TString;
+    durationMs: import("@sinclair/typebox").TNumber;
+    url: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=WebFetch.d.ts.map

package/dist/tools/claude/WebFetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebFetch.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/WebFetch.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AA+B5D,MAAM,WAAW,0BAA0B;IACvC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC7E,WAAW,CAAC,EAAE,CACV,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,mBAAmB,EAAE,OAAO,KAC3B,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACtB;AAED,wBAAgB,wBAAwB,CAAC,YAAY,GAAE,0BAA+B;;;;;;;;;;IAqErF;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;GAA6B,CAAC"}

package/dist/tools/claude/WebFetch.js

@@ -0,0 +1,114 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { applyPromptToMarkdown, MAX_WEB_FETCH_MARKDOWN_LENGTH, } from "./webFetch/applyPromptToMarkdown.js";
+import { getUrlMarkdownContent } from "./webFetch/getUrlMarkdownContent.js";
+import { isPreapprovedWebFetchUrl } from "./webFetch/isPreapprovedWebFetchUrl.js";
+const CLAUDE_WEB_FETCH_DESCRIPTION = `IMPORTANT: WebFetch WILL FAIL for authenticated or private URLs. Before using this tool, check whether the URL points to an authenticated service such as Google Docs, Confluence, Jira, or GitHub. If so, look for a specialized MCP tool that provides authenticated access.
+
+- Fetches content from a specified URL and processes it using an AI model
+- Takes a URL and a prompt as input
+- Fetches the URL content and converts HTML to markdown
+- Processes the content with the prompt using a small, fast model
+- Returns the model's response about the content
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+  - IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead, as it may have fewer restrictions.
+  - The URL must be a fully formed valid URL
+  - HTTP URLs will be automatically upgraded to HTTPS
+  - The prompt should describe what information you want to extract from the page
+  - This tool is read-only and does not modify project files
+  - Results may be summarized if the content is very large
+  - Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL
+  - When a URL redirects to a different host, the tool will provide the redirect URL. Make a new WebFetch request with that URL to continue.
+  - For GitHub URLs, prefer using the gh CLI through Bash, such as gh pr view, gh issue view, or gh api.`;
+const claudeWebFetchReturnSchema = Type.Object({
+    bytes: Type.Number({ description: "Size of the fetched content in bytes" }),
+    code: Type.Number({ description: "HTTP response code" }),
+    codeText: Type.String({ description: "HTTP response status text" }),
+    result: Type.String({ description: "Processed result from the fetched content" }),
+    durationMs: Type.Number({ description: "Time taken to fetch and process the content" }),
+    url: Type.String({ description: "The URL that was fetched" }),
+});
+export function createClaudeWebFetchTool(dependencies = {}) {
+    const fetchPage = dependencies.fetchPage ?? getUrlMarkdownContent;
+    const applyPrompt = dependencies.applyPrompt ?? applyPromptToMarkdown;
+    const now = dependencies.now ?? Date.now;
+    return defineTool({
+        name: "WebFetch",
+        label: "WebFetch",
+        description: CLAUDE_WEB_FETCH_DESCRIPTION,
+        arguments: Type.Object({
+            url: Type.String({ description: "The URL to fetch content from" }),
+            prompt: Type.String({ description: "The prompt to run on the fetched content" }),
+        }),
+        returnType: claudeWebFetchReturnSchema,
+        execute: async ({ url, prompt }, _context, execution) => {
+            try {
+                new URL(url);
+            }
+            catch {
+                throw new Error(`Invalid URL: ${url}`);
+            }
+            const startedAt = now();
+            const response = await fetchPage(url, execution.signal);
+            if ("type" in response) {
+                const codeText = redirectStatusText(response.statusCode);
+                const result = `REDIRECT DETECTED: The URL redirects to a different host.
+
+Original URL: ${response.originalUrl}
+Redirect URL: ${response.redirectUrl}
+Status: ${response.statusCode} ${codeText}
+
+To complete your request, use WebFetch again with these parameters:
+- url: "${response.redirectUrl}"
+- prompt: "${prompt}"`;
+                return {
+                    bytes: Buffer.byteLength(result),
+                    code: response.statusCode,
+                    codeText,
+                    result,
+                    durationMs: now() - startedAt,
+                    url,
+                };
+            }
+            const isPreapproved = isPreapprovedWebFetchUrl(url);
+            let result = isPreapproved &&
+                response.contentType.includes("text/markdown") &&
+                response.content.length < MAX_WEB_FETCH_MARKDOWN_LENGTH
+                ? response.content
+                : await applyPrompt(prompt, response.content, execution.signal, isPreapproved);
+            if (response.persistedPath !== undefined) {
+                result += `\n\n[Binary content (${response.contentType}, ${formatFileSize(response.persistedSize ?? response.bytes)}) also saved to ${response.persistedPath}]`;
+            }
+            return {
+                bytes: response.bytes,
+                code: response.code,
+                codeText: response.codeText,
+                result,
+                durationMs: now() - startedAt,
+                url,
+            };
+        },
+        toLLM: (result) => [{ type: "text", text: result.result }],
+        toUI: (result) => `Received ${formatFileSize(result.bytes)} (${result.code} ${result.codeText})`,
+        locks: [],
+    });
+}
+export const claudeWebFetchTool = createClaudeWebFetchTool();
+function redirectStatusText(statusCode) {
+    if (statusCode === 301)
+        return "Moved Permanently";
+    if (statusCode === 307)
+        return "Temporary Redirect";
+    if (statusCode === 308)
+        return "Permanent Redirect";
+    return "Found";
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/dist/tools/claude/WebSearch.d.ts

@@ -0,0 +1,35 @@
+import type { WebSearchInput, WebSearchOutput } from "./webSearch/types.js";
+export interface ClaudeWebSearchDependencies {
+    search?: (input: WebSearchInput, signal?: AbortSignal) => Promise<WebSearchOutput>;
+}
+export declare function createClaudeWebSearchTool(dependencies?: ClaudeWebSearchDependencies): import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TString;
+    allowed_domains: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    blocked_domains: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+}>, import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TString;
+    results: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        tool_use_id: import("@sinclair/typebox").TString;
+        content: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            title: import("@sinclair/typebox").TString;
+            url: import("@sinclair/typebox").TString;
+        }>>;
+    }>, import("@sinclair/typebox").TString]>>;
+    durationSeconds: import("@sinclair/typebox").TNumber;
+}>>;
+export declare const claudeWebSearchTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TString;
+    allowed_domains: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    blocked_domains: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+}>, import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TString;
+    results: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        tool_use_id: import("@sinclair/typebox").TString;
+        content: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            title: import("@sinclair/typebox").TString;
+            url: import("@sinclair/typebox").TString;
+        }>>;
+    }>, import("@sinclair/typebox").TString]>>;
+    durationSeconds: import("@sinclair/typebox").TNumber;
+}>>;
+//# sourceMappingURL=WebSearch.d.ts.map

package/dist/tools/claude/WebSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSearch.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/WebSearch.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAqB5E,MAAM,WAAW,2BAA2B;IACxC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;CACtF;AAED,wBAAgB,yBAAyB,CAAC,YAAY,GAAE,2BAAgC;;;;;;;;;;;;;;IAmDvF;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;GAA8B,CAAC"}

package/dist/tools/claude/WebSearch.js

@@ -0,0 +1,83 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { formatWebSearchOutput } from "./webSearch/formatWebSearchOutput.js";
+import { performWebSearch } from "./webSearch/performWebSearch.js";
+const searchResultSchema = Type.Object({
+    tool_use_id: Type.String({ description: "ID of the web search tool use" }),
+    content: Type.Array(Type.Object({
+        title: Type.String({ description: "The title of the search result" }),
+        url: Type.String({ description: "The URL of the search result" }),
+    }), { description: "Search result links" }),
+});
+const claudeWebSearchReturnSchema = Type.Object({
+    query: Type.String({ description: "The search query that was executed" }),
+    results: Type.Array(Type.Union([searchResultSchema, Type.String()]), {
+        description: "Search results and text commentary from the model",
+    }),
+    durationSeconds: Type.Number({ description: "Time taken to complete the search" }),
+});
+export function createClaudeWebSearchTool(dependencies = {}) {
+    const search = dependencies.search ?? performWebSearch;
+    return defineTool({
+        name: "WebSearch",
+        label: "WebSearch",
+        description: createWebSearchDescription(),
+        arguments: Type.Object({
+            query: Type.String({ minLength: 2, description: "The search query to use" }),
+            allowed_domains: Type.Optional(Type.Array(Type.String(), {
+                description: "Only include search results from these domains",
+            })),
+            blocked_domains: Type.Optional(Type.Array(Type.String(), {
+                description: "Never include search results from these domains",
+            })),
+        }),
+        returnType: claudeWebSearchReturnSchema,
+        execute: async ({ query, allowed_domains, blocked_domains }, _context, execution) => {
+            if (query.trim().length < 2) {
+                throw new Error("Error: Web search query must contain at least two characters");
+            }
+            if (allowed_domains?.length && blocked_domains?.length) {
+                throw new Error("Error: Cannot specify both allowed_domains and blocked_domains in the same request");
+            }
+            return search({
+                query,
+                ...(allowed_domains !== undefined ? { allowed_domains } : {}),
+                ...(blocked_domains !== undefined ? { blocked_domains } : {}),
+            }, execution.signal);
+        },
+        toLLM: (result) => [{ type: "text", text: formatWebSearchOutput(result) }],
+        toUI: (result) => {
+            const searches = result.results.filter((item) => typeof item !== "string").length;
+            const duration = result.durationSeconds >= 1
+                ? `${Math.round(result.durationSeconds)}s`
+                : `${Math.round(result.durationSeconds * 1000)}ms`;
+            return `Completed ${searches} web ${searches === 1 ? "search" : "searches"} in ${duration}`;
+        },
+        locks: [],
+    });
+}
+export const claudeWebSearchTool = createClaudeWebSearchTool();
+function createWebSearchDescription() {
+    const currentMonthYear = new Intl.DateTimeFormat("en-US", {
+        month: "long",
+        year: "numeric",
+    }).format(new Date());
+    return `- Allows Claude to search the web and use the results to inform responses
+- Provides up-to-date information for current events and recent data
+- Returns search result information with links as markdown hyperlinks
+- Use this tool for information beyond Claude's knowledge cutoff
+- Searches are performed automatically within a single API call
+
+CRITICAL REQUIREMENT:
+  - After answering the user's question, include a "Sources:" section at the end of your response
+  - List all relevant URLs from the search results as markdown hyperlinks: [Title](URL)
+  - Never omit relevant sources from the response
+
+Usage notes:
+  - Domain filtering is supported to include or block specific websites
+  - Web search is only available in the US
+
+IMPORTANT - Use the correct year in search queries:
+  - The current month is ${currentMonthYear}. Use this year when searching for recent information, documentation, or current events.
+  - For example, if the user asks for the latest React docs, search for React documentation with the current year, not last year.`;
+}

package/dist/tools/claude/Write.d.ts

@@ -0,0 +1,7 @@
+export declare const claudeWriteTool: import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    file_path: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>;
+//# sourceMappingURL=Write.d.ts.map

package/dist/tools/claude/Write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Write.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/Write.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,eAAe;;;;;GAoB1B,CAAC"}

package/dist/tools/claude/Write.js

@@ -0,0 +1,32 @@
+import { Type } from "@sinclair/typebox";
+import { defineTool } from "../../agent/types.js";
+import { textOutputSchema, toTextBlocks, writeTextFile } from "../utils/index.js";
+const CLAUDE_WRITE_DESCRIPTION = `Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- Prefer the Edit tool for modifying existing files -- it only sends the diff. Only use this tool to create new files or for complete rewrites.
+- NEVER create documentation files (*.md) or README files unless explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.`;
+export const claudeWriteTool = defineTool({
+    name: "Write",
+    label: "Write",
+    description: CLAUDE_WRITE_DESCRIPTION,
+    arguments: Type.Object({
+        file_path: Type.String({
+            description: "The absolute path to the file to write (must be absolute, not relative)",
+        }),
+        content: Type.String({ description: "The content to write to the file" }),
+    }),
+    returnType: textOutputSchema,
+    execute: async ({ file_path, content }, context) => {
+        const result = await writeTextFile({ path: file_path, content }, context);
+        return {
+            text: `File ${result.created ? "created" : "updated"} successfully at: ${result.path}`,
+        };
+    },
+    toLLM: toTextBlocks,
+    toUI: (_result, args) => `Wrote ${args.file_path}`,
+    locks: [(args) => args.file_path],
+});

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

@@ -0,0 +1,107 @@
+export { claudeBashTool } from "./Bash.js";
+export { claudeEditTool } from "./Edit.js";
+export { claudeGlobTool } from "./Glob.js";
+export { claudeGrepTool } from "./Grep.js";
+export { claudeReadTool } from "./Read.js";
+export { claudeTodoWriteTool } from "./TodoWrite.js";
+export { claudeWebFetchTool } from "./WebFetch.js";
+export { claudeWebSearchTool } from "./WebSearch.js";
+export { claudeWriteTool } from "./Write.js";
+export declare const claudeCodeTools: readonly [import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    command: import("@sinclair/typebox").TString;
+    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    run_in_background: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, import("@sinclair/typebox").TObject<{
+    stdout: import("@sinclair/typebox").TString;
+    stderr: import("@sinclair/typebox").TString;
+    exitCode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TNull]>;
+    timedOut: import("@sinclair/typebox").TBoolean;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    file_path: import("@sinclair/typebox").TString;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TString;
+    startLine: import("@sinclair/typebox").TNumber;
+    totalLines: import("@sinclair/typebox").TNumber;
+    returnedLines: import("@sinclair/typebox").TNumber;
+    truncated: import("@sinclair/typebox").TBoolean;
+}>, import("@sinclair/typebox").TObject<{
+    image_url: import("@sinclair/typebox").TString;
+    mediaType: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>]>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    file_path: import("@sinclair/typebox").TString;
+    old_string: import("@sinclair/typebox").TString;
+    new_string: import("@sinclair/typebox").TString;
+    replace_all: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    replacements: import("@sinclair/typebox").TNumber;
+    fuzzy: import("@sinclair/typebox").TBoolean;
+    oldString: import("@sinclair/typebox").TString;
+    newString: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    file_path: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<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>;
+    output_mode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"content">, import("@sinclair/typebox").TLiteral<"files_with_matches">, import("@sinclair/typebox").TLiteral<"count">]>>;
+    "-B": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    "-A": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    "-C": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    "-n": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    "-i": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    head_limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    multiline: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    todos: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        content: import("@sinclair/typebox").TString;
+        activeForm: import("@sinclair/typebox").TString;
+        status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"in_progress">, import("@sinclair/typebox").TLiteral<"completed">]>;
+    }>>;
+}>, import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    url: import("@sinclair/typebox").TString;
+    prompt: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    bytes: import("@sinclair/typebox").TNumber;
+    code: import("@sinclair/typebox").TNumber;
+    codeText: import("@sinclair/typebox").TString;
+    result: import("@sinclair/typebox").TString;
+    durationMs: import("@sinclair/typebox").TNumber;
+    url: import("@sinclair/typebox").TString;
+}>>, import("../../agent/types.js").DefinedTool<import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TString;
+    allowed_domains: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    blocked_domains: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+}>, import("@sinclair/typebox").TObject<{
+    query: import("@sinclair/typebox").TString;
+    results: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        tool_use_id: import("@sinclair/typebox").TString;
+        content: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            title: import("@sinclair/typebox").TString;
+            url: import("@sinclair/typebox").TString;
+        }>>;
+    }>, import("@sinclair/typebox").TString]>>;
+    durationSeconds: import("@sinclair/typebox").TNumber;
+}>>];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/claude/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../sources/tools/claude/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAY7C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUlB,CAAC"}

package/dist/tools/claude/index.js

@@ -0,0 +1,29 @@
+export { claudeBashTool } from "./Bash.js";
+export { claudeEditTool } from "./Edit.js";
+export { claudeGlobTool } from "./Glob.js";
+export { claudeGrepTool } from "./Grep.js";
+export { claudeReadTool } from "./Read.js";
+export { claudeTodoWriteTool } from "./TodoWrite.js";
+export { claudeWebFetchTool } from "./WebFetch.js";
+export { claudeWebSearchTool } from "./WebSearch.js";
+export { claudeWriteTool } from "./Write.js";
+import { claudeBashTool } from "./Bash.js";
+import { claudeEditTool } from "./Edit.js";
+import { claudeGlobTool } from "./Glob.js";
+import { claudeGrepTool } from "./Grep.js";
+import { claudeReadTool } from "./Read.js";
+import { claudeTodoWriteTool } from "./TodoWrite.js";
+import { claudeWebFetchTool } from "./WebFetch.js";
+import { claudeWebSearchTool } from "./WebSearch.js";
+import { claudeWriteTool } from "./Write.js";
+export const claudeCodeTools = [
+    claudeBashTool,
+    claudeReadTool,
+    claudeEditTool,
+    claudeWriteTool,
+    claudeGlobTool,
+    claudeGrepTool,
+    claudeTodoWriteTool,
+    claudeWebFetchTool,
+    claudeWebSearchTool,
+];

package/dist/tools/claude/webFetch/applyPromptToMarkdown.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_WEB_FETCH_MARKDOWN_LENGTH = 100000;
+export declare function applyPromptToMarkdown(prompt: string, markdown: string, signal: AbortSignal | undefined, isPreapprovedDomain: boolean): Promise<string>;
+//# sourceMappingURL=applyPromptToMarkdown.d.ts.map

package/dist/tools/claude/webFetch/applyPromptToMarkdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyPromptToMarkdown.d.ts","sourceRoot":"","sources":["../../../../sources/tools/claude/webFetch/applyPromptToMarkdown.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,6BAA6B,SAAU,CAAC;AAErD,wBAAsB,qBAAqB,CACvC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,mBAAmB,EAAE,OAAO,GAC7B,OAAO,CAAC,MAAM,CAAC,CAsBjB"}

package/dist/tools/claude/webFetch/applyPromptToMarkdown.js

@@ -0,0 +1,21 @@
+import { requestAnthropicMessage } from "../../../providers/requestAnthropicMessage.js";
+import { makeWebFetchModelPrompt } from "./makeWebFetchModelPrompt.js";
+export const MAX_WEB_FETCH_MARKDOWN_LENGTH = 100_000;
+export async function applyPromptToMarkdown(prompt, markdown, signal, isPreapprovedDomain) {
+    const truncated = markdown.length > MAX_WEB_FETCH_MARKDOWN_LENGTH
+        ? `${markdown.slice(0, MAX_WEB_FETCH_MARKDOWN_LENGTH)}\n\n[Content truncated due to length...]`
+        : markdown;
+    const response = await requestAnthropicMessage({
+        max_tokens: 4096,
+        messages: [
+            {
+                role: "user",
+                content: makeWebFetchModelPrompt(truncated, prompt, isPreapprovedDomain),
+            },
+        ],
+        model: "claude-haiku-4-5-20251001",
+        thinking: { type: "disabled" },
+    }, signal);
+    const text = response.content.find((block) => block.type === "text");
+    return text?.text ?? "No response from model";
+}

package/dist/tools/claude/webFetch/cache.d.ts

@@ -0,0 +1,6 @@
+import { LRUCache } from "lru-cache";
+import type { WebFetchContent } from "./types.js";
+export declare const webFetchUrlCache: LRUCache<string, WebFetchContent, unknown>;
+export declare const webFetchDomainCache: LRUCache<string, true, unknown>;
+export declare function clearWebFetchCache(): void;
+//# sourceMappingURL=cache.d.ts.map

package/dist/tools/claude/webFetch/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../sources/tools/claude/webFetch/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAKlD,eAAO,MAAM,gBAAgB,4CAG3B,CAAC;AAEH,eAAO,MAAM,mBAAmB,iCAG9B,CAAC;AAEH,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC"}

package/dist/tools/claude/webFetch/cache.js

@@ -0,0 +1,15 @@
+import { LRUCache } from "lru-cache";
+const CACHE_TTL_MS = 15 * 60 * 1000;
+const MAX_CACHE_SIZE_BYTES = 50 * 1024 * 1024;
+export const webFetchUrlCache = new LRUCache({
+    maxSize: MAX_CACHE_SIZE_BYTES,
+    ttl: CACHE_TTL_MS,
+});
+export const webFetchDomainCache = new LRUCache({
+    max: 128,
+    ttl: 5 * 60 * 1000,
+});
+export function clearWebFetchCache() {
+    webFetchUrlCache.clear();
+    webFetchDomainCache.clear();
+}

package/dist/tools/claude/webFetch/checkWebFetchDomain.d.ts

@@ -0,0 +1,2 @@
+export declare function checkWebFetchDomain(domain: string, signal?: AbortSignal): Promise<void>;
+//# sourceMappingURL=checkWebFetchDomain.d.ts.map

package/dist/tools/claude/webFetch/checkWebFetchDomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkWebFetchDomain.d.ts","sourceRoot":"","sources":["../../../../sources/tools/claude/webFetch/checkWebFetchDomain.ts"],"names":[],"mappings":"AAKA,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA+B7F"}

package/dist/tools/claude/webFetch/checkWebFetchDomain.js

@@ -0,0 +1,29 @@
+import { webFetchDomainCache } from "./cache.js";
+import { createTimedSignal } from "./createTimedSignal.js";
+const DOMAIN_CHECK_TIMEOUT_MS = 10_000;
+export async function checkWebFetchDomain(domain, signal) {
+    if (webFetchDomainCache.has(domain)) {
+        return;
+    }
+    const timedSignal = createTimedSignal(signal, DOMAIN_CHECK_TIMEOUT_MS);
+    try {
+        const response = await fetch(`https://api.anthropic.com/api/web/domain_info?domain=${encodeURIComponent(domain)}`, { signal: timedSignal.signal });
+        if (!response.ok) {
+            throw new Error(`Domain check returned ${response.status} ${response.statusText}`);
+        }
+        const body = (await response.json());
+        if (body.can_fetch !== true) {
+            throw new Error(`Rig is unable to fetch from ${domain}`);
+        }
+        webFetchDomainCache.set(domain, true);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith("Rig is unable")) {
+            throw error;
+        }
+        throw new Error(`Unable to verify whether ${domain} is safe to fetch. The Anthropic domain check may be blocked by the network.`, { cause: error });
+    }
+    finally {
+        timedSignal.dispose();
+    }
+}

package/dist/tools/claude/webFetch/createTimedSignal.d.ts

@@ -0,0 +1,6 @@
+export interface TimedSignal {
+    signal: AbortSignal;
+    dispose(): void;
+}
+export declare function createTimedSignal(parent: AbortSignal | undefined, timeoutMs: number): TimedSignal;
+//# sourceMappingURL=createTimedSignal.d.ts.map

package/dist/tools/claude/webFetch/createTimedSignal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTimedSignal.d.ts","sourceRoot":"","sources":["../../../../sources/tools/claude/webFetch/createTimedSignal.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IACxB,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,IAAI,IAAI,CAAC;CACnB;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,CAiBjG"}

package/dist/tools/claude/webFetch/createTimedSignal.js

@@ -0,0 +1,18 @@
+export function createTimedSignal(parent, timeoutMs) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(parent?.reason);
+    if (parent?.aborted) {
+        onAbort();
+    }
+    else {
+        parent?.addEventListener("abort", onAbort, { once: true });
+    }
+    const timeout = setTimeout(() => controller.abort(new Error("Request timed out")), timeoutMs);
+    return {
+        signal: controller.signal,
+        dispose() {
+            clearTimeout(timeout);
+            parent?.removeEventListener("abort", onAbort);
+        },
+    };
+}

package/dist/tools/claude/webFetch/getTurndownService.d.ts

@@ -0,0 +1,3 @@
+import type TurndownService from "turndown";
+export declare function getTurndownService(): Promise<TurndownService>;
+//# sourceMappingURL=getTurndownService.d.ts.map

package/dist/tools/claude/webFetch/getTurndownService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTurndownService.d.ts","sourceRoot":"","sources":["../../../../sources/tools/claude/webFetch/getTurndownService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,UAAU,CAAC;AAI5C,wBAAgB,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC,CAG7D"}

package/dist/tools/claude/webFetch/getTurndownService.js

@@ -0,0 +1,5 @@
+let servicePromise;
+export function getTurndownService() {
+    servicePromise ??= import("turndown").then(({ default: Turndown }) => new Turndown());
+    return servicePromise;
+}

package/dist/tools/claude/webFetch/getUrlMarkdownContent.d.ts

@@ -0,0 +1,3 @@
+import type { WebFetchResponse } from "./types.js";
+export declare function getUrlMarkdownContent(url: string, signal?: AbortSignal): Promise<WebFetchResponse>;
+//# sourceMappingURL=getUrlMarkdownContent.d.ts.map

package/dist/tools/claude/webFetch/getUrlMarkdownContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getUrlMarkdownContent.d.ts","sourceRoot":"","sources":["../../../../sources/tools/claude/webFetch/getUrlMarkdownContent.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAsB,qBAAqB,CACvC,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,WAAW,GACrB,OAAO,CAAC,gBAAgB,CAAC,CA2C3B"}