experimental-ash 0.26.0 → 0.27.0

package/dist/src/runtime/framework-tools/connection-search.js

@@ -1,224 +1 @@
-import { loadContext } from "#context/container.js";
-import { ContextKey } from "#context/key.js";
-import { createLogger } from "#internal/logging.js";
-import { isConnectionAuthorizationFailedError, isConnectionAuthorizationRequiredError, } from "#public/connections/errors.js";
-import { supportsInteractiveAuthorization, } from "#runtime/connections/types.js";
-import { qualifiedConnectionToolName } from "#runtime/framework-tools/connection-tools.js";
-import { appendPendingConnectionToolCalls, CONNECTION_AUTHORIZATION_PLACEHOLDER, PendingConnectionToolCallsKey, } from "#runtime/framework-tools/pending-connection-tool-calls.js";
-const logger = createLogger("framework.connection-search");
-/**
- * Context key for the per-session connection registry.
- *
- * Created as a derived key (no codec) because the registry holds live
- * client instances that cannot be serialized across step boundaries.
- * The `connectionProvider` reconstructs it each step.
- */
-export const ConnectionRegistryKey = new ContextKey("ash.connectionRegistry");
-/**
- * Durable context key for discovered connection tools.
- *
- * Written by `connection_search` after fetching tool metadata.
- * Read by `resolveDiscoveredConnectionTools` at the start of each
- * step to inject discovered tools into the ToolSet.
- */
-export const DiscoveredConnectionToolsKey = new ContextKey("ash.discoveredConnectionTools");
-/**
- * Framework-provided `connection_search` tool.
- */
-export const CONNECTION_SEARCH_TOOL_DEFINITION = {
-    description: "Search for tools across your connections. " +
-        "Discovered tools become directly callable by their qualified name " +
-        "(e.g. linear__list_issues) in your next response.",
-    execute: async (input, options) => {
-        const toolCallId = typeof options === "object" && options !== null && "toolCallId" in options
-            ? options.toolCallId
-            : undefined;
-        return executeConnectionSearch(input, {
-            toolCallId: typeof toolCallId === "string" ? toolCallId : undefined,
-        });
-    },
-    inputSchema: {
-        additionalProperties: false,
-        properties: {
-            connection: {
-                description: "Optional: limit search to a specific connection name.",
-                type: "string",
-            },
-            limit: {
-                description: "Max results to return. Default 10.",
-                type: "number",
-            },
-            keywords: {
-                description: "Search keywords and expanded aliases. Distill intent into keywords; avoid stop words like 'a', 'the', 'in'.",
-                type: "string",
-            },
-        },
-        required: ["keywords"],
-        type: "object",
-    },
-    logicalPath: "ash:framework/connection-search",
-    name: "connection_search",
-    onCompact({ ctx }) {
-        ctx.set(DiscoveredConnectionToolsKey, { byConnection: {} });
-        ctx.set(PendingConnectionToolCallsKey, []);
-        return {};
-    },
-    sourceId: "ash:connection-search-tool",
-    sourceKind: "module",
-};
-export async function executeConnectionSearch(input, meta) {
-    const ctx = loadContext();
-    const registry = ctx.get(ConnectionRegistryKey);
-    if (registry === undefined) {
-        return [];
-    }
-    const limit = input.limit ?? 10;
-    const queryTokens = tokenize(input.keywords);
-    const results = [];
-    const failedConnections = [];
-    const targetConnections = input.connection !== undefined && input.connection !== ""
-        ? registry.getConnections().filter((c) => c.connectionName === input.connection)
-        : registry.getConnections();
-    // Merge any previously discovered tools so we accumulate across
-    // multiple search calls rather than replacing.
-    const previouslyDiscovered = ctx.get(DiscoveredConnectionToolsKey);
-    const discoveredByConnection = {
-        ...previouslyDiscovered?.byConnection,
-    };
-    const authRequiredConnections = [];
-    for (const conn of targetConnections) {
-        let tools;
-        try {
-            const client = registry.getClient(conn.connectionName);
-            tools = await client.getToolMetadata();
-        }
-        catch (err) {
-            if (isConnectionAuthorizationRequiredError(err)) {
-                authRequiredConnections.push(conn.connectionName);
-                failedConnections.push({
-                    connection: conn.connectionName,
-                    description: conn.description,
-                    needsAuthorization: true,
-                });
-                continue;
-            }
-            if (isConnectionAuthorizationFailedError(err)) {
-                logger.warn("connection authorization failed", {
-                    connection: conn.connectionName,
-                    reason: err.reason,
-                    retryable: err.retryable,
-                    error: err,
-                });
-                failedConnections.push({
-                    connection: conn.connectionName,
-                    description: conn.description,
-                    error: `Authorization failed for ${conn.connectionName}: ${err.message}`,
-                });
-                continue;
-            }
-            // Anything that isn't `Required` or `Failed` is unclassified —
-            // most often a misconfiguration on the upstream provider (e.g. an
-            // OAuth bridge returning a 4xx for a project that hasn't been
-            // linked) rather than the connection's HTTP server being
-            // unreachable. Log so the developer running `ash dev` sees the
-            // underlying cause; the model only gets the truncated message.
-            const message = err instanceof Error ? err.message : "unknown error";
-            logger.warn("failed to load connection tools", {
-                connection: conn.connectionName,
-                error: err instanceof Error ? err : new Error(message),
-            });
-            failedConnections.push({
-                connection: conn.connectionName,
-                description: conn.description,
-                error: `Failed to load tools for "${conn.connectionName}": ${message}`,
-            });
-            continue;
-        }
-        // Record all tools from this connection as discovered.
-        discoveredByConnection[conn.connectionName] = tools;
-        for (const tool of tools) {
-            const score = scoreMatch(queryTokens, tool);
-            if (score > 0) {
-                results.push({
-                    item: {
-                        connection: conn.connectionName,
-                        description: tool.description,
-                        inputSchema: tool.inputSchema,
-                        qualifiedName: qualifiedConnectionToolName(conn.connectionName, tool.name),
-                        tool: tool.name,
-                    },
-                    score,
-                });
-            }
-        }
-    }
-    // Persist discovered tools so they materialize as first-class
-    // AI SDK tools on the next step.
-    ctx.set(DiscoveredConnectionToolsKey, { byConnection: discoveredByConnection });
-    const interactiveConnectionNames = authRequiredConnections.filter((name) => isInteractive(registry, name));
-    // Suspend the entire tool call when at least one auth-required
-    // connection has the full interactive-OAuth surface. The
-    // connection-discover retry re-runs this search after tokens land,
-    // and its result is spliced over the placeholder in history. See
-    // packages/ash/src/runtime/framework-tools/pending-connection-tool-calls.ts.
-    if (interactiveConnectionNames.length > 0 && meta?.toolCallId !== undefined) {
-        const existing = ctx.get(PendingConnectionToolCallsKey);
-        ctx.set(PendingConnectionToolCallsKey, appendPendingConnectionToolCalls(existing, [
-            {
-                args: input,
-                connectionNames: interactiveConnectionNames,
-                kind: "connection-discover",
-                toolCallId: meta.toolCallId,
-                toolName: "connection_search",
-            },
-        ]));
-        return CONNECTION_AUTHORIZATION_PLACEHOLDER;
-    }
-    results.sort((a, b) => b.score - a.score);
-    const matched = results.slice(0, limit).map((r) => r.item);
-    if (matched.length > 0) {
-        return [...matched, ...failedConnections];
-    }
-    // No keyword matches — return connection summaries so the model
-    // knows which connections exist even when the query is vague.
-    const summaries = targetConnections.map((c) => {
-        const failed = failedConnections.find((f) => f.connection === c.connectionName);
-        if (failed)
-            return failed;
-        return {
-            connection: c.connectionName,
-            description: c.description,
-        };
-    });
-    return summaries;
-}
-export function tokenize(text) {
-    return text
-        .toLowerCase()
-        .split(/[\s_\-./]+/)
-        .filter((t) => t.length > 1);
-}
-export function scoreMatch(queryTokens, tool) {
-    const nameTokens = tokenize(tool.name);
-    const descTokens = tokenize(tool.description);
-    let score = 0;
-    for (const qt of queryTokens) {
-        for (const nt of nameTokens) {
-            if (nt.includes(qt) || qt.includes(nt)) {
-                score += 3;
-            }
-        }
-        for (const dt of descTokens) {
-            if (dt.includes(qt) || qt.includes(dt)) {
-                score += 1;
-            }
-        }
-    }
-    return score;
-}
-function isInteractive(registry, connectionName) {
-    if (registry === undefined)
-        return false;
-    const def = registry.getConnections().find((c) => c.connectionName === connectionName);
-    return supportsInteractiveAuthorization(def?.authorization);
-}
+import{createLogger}from"#internal/logging.js";import{loadContext}from"#context/container.js";import{ContextKey}from"#context/key.js";import{CONNECTION_AUTHORIZATION_PLACEHOLDER,PendingConnectionToolCallsKey,appendPendingConnectionToolCalls}from"#runtime/framework-tools/pending-connection-tool-calls.js";import{isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#public/connections/errors.js";import{qualifiedConnectionToolName}from"#runtime/framework-tools/connection-tools.js";import{supportsInteractiveAuthorization}from"#runtime/connections/types.js";var logger=createLogger(`framework.connection-search`),ConnectionRegistryKey=new ContextKey(`ash.connectionRegistry`),DiscoveredConnectionToolsKey=new ContextKey(`ash.discoveredConnectionTools`),CONNECTION_SEARCH_TOOL_DEFINITION={description:`Search for tools across your connections. Discovered tools become directly callable by their qualified name (e.g. linear__list_issues) in your next response.`,execute:async(e,t)=>{let n=typeof t==`object`&&t&&`toolCallId`in t?t.toolCallId:void 0;return executeConnectionSearch(e,{toolCallId:typeof n==`string`?n:void 0})},inputSchema:{additionalProperties:!1,properties:{connection:{description:`Optional: limit search to a specific connection name.`,type:`string`},limit:{description:`Max results to return. Default 10.`,type:`number`},keywords:{description:`Search keywords and expanded aliases. Distill intent into keywords; avoid stop words like 'a', 'the', 'in'.`,type:`string`}},required:[`keywords`],type:`object`},logicalPath:`ash:framework/connection-search`,name:`connection_search`,onCompact({ctx:e}){return e.set(DiscoveredConnectionToolsKey,{byConnection:{}}),e.set(PendingConnectionToolCallsKey,[]),{}},sourceId:`ash:connection-search-tool`,sourceKind:`module`};async function executeConnectionSearch(e,n){let a=loadContext(),o=a.get(ConnectionRegistryKey);if(o===void 0)return[];let s=e.limit??10,c=tokenize(e.keywords),l=[],u=[],d=e.connection!==void 0&&e.connection!==``?o.getConnections().filter(t=>t.connectionName===e.connection):o.getConnections(),f={...a.get(DiscoveredConnectionToolsKey)?.byConnection},p=[];for(let e of d){let t;try{t=await o.getClient(e.connectionName).getToolMetadata()}catch(t){if(isConnectionAuthorizationRequiredError(t)){p.push(e.connectionName),u.push({connection:e.connectionName,description:e.description,needsAuthorization:!0});continue}if(isConnectionAuthorizationFailedError(t)){logger.warn(`connection authorization failed`,{connection:e.connectionName,reason:t.reason,retryable:t.retryable,error:t}),u.push({connection:e.connectionName,description:e.description,error:`Authorization failed for ${e.connectionName}: ${t.message}`});continue}let n=t instanceof Error?t.message:`unknown error`;logger.warn(`failed to load connection tools`,{connection:e.connectionName,error:t instanceof Error?t:Error(n)}),u.push({connection:e.connectionName,description:e.description,error:`Failed to load tools for "${e.connectionName}": ${n}`});continue}f[e.connectionName]=t;for(let n of t){let t=scoreMatch(c,n);t>0&&l.push({item:{connection:e.connectionName,description:n.description,inputSchema:n.inputSchema,qualifiedName:qualifiedConnectionToolName(e.connectionName,n.name),tool:n.name},score:t})}}a.set(DiscoveredConnectionToolsKey,{byConnection:f});let m=p.filter(e=>isInteractive(o,e));if(m.length>0&&n?.toolCallId!==void 0){let t=a.get(PendingConnectionToolCallsKey);return a.set(PendingConnectionToolCallsKey,appendPendingConnectionToolCalls(t,[{args:e,connectionNames:m,kind:`connection-discover`,toolCallId:n.toolCallId,toolName:`connection_search`}])),CONNECTION_AUTHORIZATION_PLACEHOLDER}l.sort((e,t)=>t.score-e.score);let h=l.slice(0,s).map(e=>e.item);return h.length>0?[...h,...u]:d.map(e=>u.find(t=>t.connection===e.connectionName)||{connection:e.connectionName,description:e.description})}function tokenize(e){return e.toLowerCase().split(/[\s_\-./]+/).filter(e=>e.length>1)}function scoreMatch(e,t){let n=tokenize(t.name),r=tokenize(t.description),i=0;for(let t of e){for(let e of n)(e.includes(t)||t.includes(e))&&(i+=3);for(let e of r)(e.includes(t)||t.includes(e))&&(i+=1)}return i}function isInteractive(e,t){return e===void 0?!1:supportsInteractiveAuthorization(e.getConnections().find(e=>e.connectionName===t)?.authorization)}export{CONNECTION_SEARCH_TOOL_DEFINITION,ConnectionRegistryKey,DiscoveredConnectionToolsKey,executeConnectionSearch,scoreMatch,tokenize};

package/dist/src/runtime/framework-tools/connection-tools.js

@@ -1,103 +1 @@
-import { loadContext } from "#context/container.js";
-import { isConnectionAuthorizationRequiredError } from "#public/connections/errors.js";
-import { isObject } from "#shared/guards.js";
-import { supportsInteractiveAuthorization, } from "#runtime/connections/types.js";
-import {} from "#runtime/framework-tools/connection-search.js";
-import { appendPendingConnectionToolCalls, CONNECTION_AUTHORIZATION_PLACEHOLDER, PendingConnectionToolCallsKey, } from "#runtime/framework-tools/pending-connection-tool-calls.js";
-/**
- * Builds the qualified tool name for a connection tool.
- *
- * Uses double-underscore as the separator because it is safe in
- * tool-name schemas and unlikely to appear in authored tool names.
- */
-export function qualifiedConnectionToolName(connectionName, toolName) {
-    return `${connectionName}__${toolName}`;
-}
-/**
- * Builds AI SDK tools for every connection tool that has been
- * discovered via a prior `connection_search` call.
- */
-export async function resolveConnectionToolsFromState(registry, discovered, input) {
-    const result = {};
-    for (const [connectionName, tools] of Object.entries(discovered.byConnection)) {
-        const client = registry.getClient(connectionName);
-        const sdkTools = await client.getTools();
-        const approval = registry.getConnectionApproval(connectionName);
-        for (const meta of tools) {
-            const qualifiedName = qualifiedConnectionToolName(connectionName, meta.name);
-            // Authored tools take precedence over connection tools.
-            if (input.existingToolNames?.has(qualifiedName))
-                continue;
-            const sdkTool = sdkTools[meta.name];
-            if (sdkTool === undefined)
-                continue;
-            const needsApproval = approval !== undefined
-                ? async (toolInput) => {
-                    return approval({
-                        approvedTools: input.approvedTools ?? new Set(),
-                        toolInput: isObject(toolInput) ? toolInput : undefined,
-                        toolName: qualifiedName,
-                    });
-                }
-                : undefined;
-            const connectionDef = registry
-                .getConnections()
-                .find((c) => c.connectionName === connectionName);
-            const wrappedExecute = wrapConnectionToolExecute({
-                connectionDefinition: connectionDef,
-                connectionName,
-                originalExecute: sdkTool.execute,
-                toolName: meta.name,
-            });
-            result[qualifiedName] = {
-                ...sdkTool,
-                execute: wrappedExecute,
-                needsApproval,
-            };
-        }
-    }
-    return result;
-}
-/**
- * Wraps one connection tool's `execute` to record a pending retry and
- * return a placeholder when interactive auth is required. Non-interactive
- * connections let the error propagate — the model sees the failure.
- */
-export function wrapConnectionToolExecute(params) {
-    const { connectionDefinition, connectionName, originalExecute, toolName } = params;
-    if (originalExecute === undefined)
-        return undefined;
-    return async (args, options) => {
-        try {
-            return await originalExecute(args, options);
-        }
-        catch (err) {
-            if (!isConnectionAuthorizationRequiredError(err)) {
-                throw err;
-            }
-            const toolCallId = readToolCallId(options);
-            const isInteractive = supportsInteractiveAuthorization(connectionDefinition?.authorization);
-            if (isInteractive && toolCallId !== undefined) {
-                const ctx = loadContext();
-                const existing = ctx.get(PendingConnectionToolCallsKey);
-                ctx.set(PendingConnectionToolCallsKey, appendPendingConnectionToolCalls(existing, [
-                    {
-                        args: (args ?? null),
-                        connectionName,
-                        kind: "connection-execute",
-                        toolCallId,
-                        toolName,
-                    },
-                ]));
-                return CONNECTION_AUTHORIZATION_PLACEHOLDER;
-            }
-            throw err;
-        }
-    };
-}
-function readToolCallId(options) {
-    if (typeof options !== "object" || options === null)
-        return undefined;
-    const id = options.toolCallId;
-    return typeof id === "string" ? id : undefined;
-}
+import{isObject}from"#shared/guards.js";import{loadContext}from"#context/container.js";import"#runtime/framework-tools/connection-search.js";import{CONNECTION_AUTHORIZATION_PLACEHOLDER,PendingConnectionToolCallsKey,appendPendingConnectionToolCalls}from"#runtime/framework-tools/pending-connection-tool-calls.js";import{isConnectionAuthorizationRequiredError}from"#public/connections/errors.js";import{supportsInteractiveAuthorization}from"#runtime/connections/types.js";function qualifiedConnectionToolName(e,t){return`${e}__${t}`}async function resolveConnectionToolsFromState(t,n,r){let i={};for(let[a,o]of Object.entries(n.byConnection)){let n=await t.getClient(a).getTools(),s=t.getConnectionApproval(a);for(let c of o){let o=qualifiedConnectionToolName(a,c.name);if(r.existingToolNames?.has(o))continue;let l=n[c.name];if(l===void 0)continue;let u=s===void 0?void 0:async t=>s({approvedTools:r.approvedTools??new Set,toolInput:isObject(t)?t:void 0,toolName:o}),d=wrapConnectionToolExecute({connectionDefinition:t.getConnections().find(e=>e.connectionName===a),connectionName:a,originalExecute:l.execute,toolName:c.name});i[o]={...l,execute:d,needsApproval:u}}}return i}function wrapConnectionToolExecute(e){let{connectionDefinition:s,connectionName:c,originalExecute:l,toolName:u}=e;if(l!==void 0)return async(e,d)=>{try{return await l(e,d)}catch(l){if(!isConnectionAuthorizationRequiredError(l))throw l;let f=readToolCallId(d);if(supportsInteractiveAuthorization(s?.authorization)&&f!==void 0){let a=loadContext(),o=a.get(PendingConnectionToolCallsKey);return a.set(PendingConnectionToolCallsKey,appendPendingConnectionToolCalls(o,[{args:e??null,connectionName:c,kind:`connection-execute`,toolCallId:f,toolName:u}])),CONNECTION_AUTHORIZATION_PLACEHOLDER}throw l}}}function readToolCallId(e){if(typeof e!=`object`||!e)return;let t=e.toolCallId;return typeof t==`string`?t:void 0}export{qualifiedConnectionToolName,resolveConnectionToolsFromState,wrapConnectionToolExecute};

package/dist/src/runtime/framework-tools/file-state.js

@@ -1,71 +1 @@
-import { createHash } from "node:crypto";
-import { posix } from "node:path";
-import { ContextKey } from "#context/key.js";
-/**
- * Durable context key for read-file stamps.
- */
-export const ReadFileStateKey = new ContextKey("ash.readFile");
-// ---------------------------------------------------------------------------
-// Path normalization
-// ---------------------------------------------------------------------------
-/**
- * Normalizes an absolute model-facing path by collapsing dot segments and
- * normalizing separators. The path must already be absolute — call
- * {@link normalizeModelPath} only after validating that the input starts
- * with `/`.
- *
- * Examples:
- * - `/workspace/./foo.ts`  → `/workspace/foo.ts`
- * - `/tmp/project/../project/foo.ts` → `/tmp/project/foo.ts`
- */
-export function normalizeModelPath(path) {
-    return posix.normalize(path);
-}
-/**
- * Builds the durable state key used to index a read-file stamp.
- *
- * Callers are expected to pass an already-normalized path from
- * {@link normalizeModelPath}. This function does not re-normalize.
- */
-export function buildReadFileTargetKey(normalizedPath) {
-    return normalizedPath;
-}
-// ---------------------------------------------------------------------------
-// Content fingerprinting
-// ---------------------------------------------------------------------------
-/**
- * Creates a read-file stamp from file content. The stamp records a SHA-256
- * hash and UTF-8 byte length so `write_file` can detect external
- * modifications without filesystem metadata.
- */
-export function createReadFileStamp(input) {
-    const hash = createHash("sha256").update(input.content, "utf8").digest("hex");
-    return {
-        byteLength: Buffer.byteLength(input.content, "utf8"),
-        contentHash: hash,
-        filePath: input.filePath,
-    };
-}
-/**
- * Persists one read-file stamp into the durable context state.
- *
- * Centralizes the context read-update-write so callers in `read-file-tool`
- * and `write-file-tool` do not duplicate the state mutation pattern.
- */
-export function setReadFileStamp(ctx, targetKey, stamp) {
-    const state = ctx.ensure(ReadFileStateKey, () => ({ byTarget: {} }));
-    ctx.set(ReadFileStateKey, {
-        byTarget: { ...state.byTarget, [targetKey]: stamp },
-    });
-}
-// ---------------------------------------------------------------------------
-// Compaction reset
-// ---------------------------------------------------------------------------
-/**
- * Clears all read-file stamps from the context. Used by the `read_file`
- * tool's `onCompact` hook and by authored `defineReadFileTool()` replacements
- * that keep the default compaction behavior.
- */
-export function clearReadFileState(ctx) {
-    ctx.set(ReadFileStateKey, { byTarget: {} });
-}
+import{posix}from"node:path";import{createHash}from"node:crypto";import{ContextKey}from"#context/key.js";var ReadFileStateKey=new ContextKey(`ash.readFile`);function normalizeModelPath(t){return posix.normalize(t)}function buildReadFileTargetKey(e){return e}function createReadFileStamp(e){let n=createHash(`sha256`).update(e.content,`utf8`).digest(`hex`);return{byteLength:Buffer.byteLength(e.content,`utf8`),contentHash:n,filePath:e.filePath}}function setReadFileStamp(e,t,n){let r=e.ensure(ReadFileStateKey,()=>({byTarget:{}}));e.set(ReadFileStateKey,{byTarget:{...r.byTarget,[t]:n}})}function clearReadFileState(e){e.set(ReadFileStateKey,{byTarget:{}})}export{ReadFileStateKey,buildReadFileTargetKey,clearReadFileState,createReadFileStamp,normalizeModelPath,setReadFileStamp};

package/dist/src/runtime/framework-tools/glob.js

@@ -1,56 +1,2 @@
-import { executeGlobOnSandbox } from "#execution/sandbox/glob-tool.js";
-/**
- * Shared input schema used by the framework `glob` tool and any author tool
- * constructed via {@link defineGlobTool}.
- *
- * Exported so the public `defineGlobTool` factory and the framework
- * `GLOB_TOOL_DEFINITION` use the exact same schema object — keeping model
- * input contracts in sync without duplication.
- */
-export const GLOB_INPUT_SCHEMA = {
-    additionalProperties: false,
-    properties: {
-        limit: {
-            description: "Maximum number of results to return. Defaults to 100.",
-            maximum: 1000,
-            minimum: 1,
-            type: "integer",
-        },
-        path: {
-            description: "The directory to search in. Defaults to /workspace. " +
-                "Must be an absolute path. Omit to use the default.",
-            type: "string",
-        },
-        pattern: {
-            description: 'The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.js").',
-            type: "string",
-        },
-    },
-    required: ["pattern"],
-    type: "object",
-};
-/**
- * Framework-owned executor that delegates to the default sandbox.
- */
-async function executeGlob(input) {
-    return executeGlobOnSandbox(input);
-}
-export const GLOB_TOOL_DEFINITION = {
-    description: [
-        "Fast file pattern matching tool that works with any codebase size.",
-        "",
-        "Usage:",
-        '- Supports glob patterns like "**/*.js" or "src/**/*.ts".',
-        "- Returns matching file paths.",
-        "- Use this tool when you need to find files by name patterns.",
-        "- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.",
-        "- Use the grep tool instead if you need to search file contents.",
-        "- Call this tool in parallel when you know there are multiple patterns to search for.",
-    ].join("\n"),
-    execute: executeGlob,
-    inputSchema: GLOB_INPUT_SCHEMA,
-    logicalPath: "ash:framework/glob",
-    name: "glob",
-    sourceId: "ash:glob-tool",
-    sourceKind: "module",
-};
+import{executeGlobOnSandbox}from"#execution/sandbox/glob-tool.js";var GLOB_INPUT_SCHEMA={additionalProperties:!1,properties:{limit:{description:`Maximum number of results to return. Defaults to 100.`,maximum:1e3,minimum:1,type:`integer`},path:{description:`The directory to search in. Defaults to /workspace. Must be an absolute path. Omit to use the default.`,type:`string`},pattern:{description:`The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.js").`,type:`string`}},required:[`pattern`],type:`object`};async function executeGlob(e){return executeGlobOnSandbox(e)}var GLOB_TOOL_DEFINITION={description:[`Fast file pattern matching tool that works with any codebase size.`,``,`Usage:`,`- Supports glob patterns like "**/*.js" or "src/**/*.ts".`,`- Returns matching file paths.`,`- Use this tool when you need to find files by name patterns.`,`- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.`,`- Use the grep tool instead if you need to search file contents.`,`- Call this tool in parallel when you know there are multiple patterns to search for.`].join(`
+`),execute:executeGlob,inputSchema:GLOB_INPUT_SCHEMA,logicalPath:`ash:framework/glob`,name:`glob`,sourceId:`ash:glob-tool`,sourceKind:`module`};export{GLOB_INPUT_SCHEMA,GLOB_TOOL_DEFINITION};

package/dist/src/runtime/framework-tools/grep.js

@@ -1,75 +1,2 @@
-import { executeGrepOnSandbox } from "#execution/sandbox/grep-tool.js";
-/**
- * Shared input schema used by the framework `grep` tool and any author tool
- * constructed via {@link defineGrepTool}.
- *
- * Exported so the public `defineGrepTool` factory and the framework
- * `GREP_TOOL_DEFINITION` use the exact same schema object — keeping model
- * input contracts in sync without duplication.
- */
-export const GREP_INPUT_SCHEMA = {
-    additionalProperties: false,
-    properties: {
-        context: {
-            description: "Number of surrounding context lines to include before and after each match. Defaults to 0.",
-            minimum: 0,
-            type: "integer",
-        },
-        glob: {
-            description: 'Filter files by glob pattern (e.g. "*.ts", "*.{ts,tsx}").',
-            type: "string",
-        },
-        ignoreCase: {
-            description: "Perform case-insensitive search. Defaults to false.",
-            type: "boolean",
-        },
-        limit: {
-            description: "Maximum number of matches to return per file. Defaults to 100.",
-            maximum: 1000,
-            minimum: 1,
-            type: "integer",
-        },
-        literal: {
-            description: "Treat the pattern as a literal string instead of a regular expression. Defaults to false.",
-            type: "boolean",
-        },
-        path: {
-            description: "The directory or file to search in. Defaults to /workspace. " +
-                "Must be an absolute path. Omit to use the default.",
-            type: "string",
-        },
-        pattern: {
-            description: 'The regex pattern to search for in file contents (e.g. "log.*Error", "function\\s+\\w+").',
-            type: "string",
-        },
-    },
-    required: ["pattern"],
-    type: "object",
-};
-/**
- * Framework-owned executor that delegates to the default sandbox.
- */
-async function executeGrep(input) {
-    return executeGrepOnSandbox(input);
-}
-export const GREP_TOOL_DEFINITION = {
-    description: [
-        "Fast content search tool that works with any codebase size.",
-        "",
-        "Usage:",
-        "- Searches file contents using regular expressions.",
-        '- Supports full regex syntax (e.g. "log.*Error", "function\\s+\\w+").',
-        '- Filter files by pattern with the glob parameter (e.g. "*.js", "*.{ts,tsx}").',
-        "- Returns matching lines with file paths and line numbers.",
-        "- Use this tool when you need to find files containing specific patterns.",
-        "- Use the glob tool instead if you only need to find files by name.",
-        "- Call this tool in parallel when you have multiple independent searches.",
-        "- Any line longer than 2000 characters is truncated.",
-    ].join("\n"),
-    execute: executeGrep,
-    inputSchema: GREP_INPUT_SCHEMA,
-    logicalPath: "ash:framework/grep",
-    name: "grep",
-    sourceId: "ash:grep-tool",
-    sourceKind: "module",
-};
+import{executeGrepOnSandbox}from"#execution/sandbox/grep-tool.js";var GREP_INPUT_SCHEMA={additionalProperties:!1,properties:{context:{description:`Number of surrounding context lines to include before and after each match. Defaults to 0.`,minimum:0,type:`integer`},glob:{description:`Filter files by glob pattern (e.g. "*.ts", "*.{ts,tsx}").`,type:`string`},ignoreCase:{description:`Perform case-insensitive search. Defaults to false.`,type:`boolean`},limit:{description:`Maximum number of matches to return per file. Defaults to 100.`,maximum:1e3,minimum:1,type:`integer`},literal:{description:`Treat the pattern as a literal string instead of a regular expression. Defaults to false.`,type:`boolean`},path:{description:`The directory or file to search in. Defaults to /workspace. Must be an absolute path. Omit to use the default.`,type:`string`},pattern:{description:`The regex pattern to search for in file contents (e.g. "log.*Error", "function\\s+\\w+").`,type:`string`}},required:[`pattern`],type:`object`};async function executeGrep(e){return executeGrepOnSandbox(e)}var GREP_TOOL_DEFINITION={description:[`Fast content search tool that works with any codebase size.`,``,`Usage:`,`- Searches file contents using regular expressions.`,`- Supports full regex syntax (e.g. "log.*Error", "function\\s+\\w+").`,`- Filter files by pattern with the glob parameter (e.g. "*.js", "*.{ts,tsx}").`,`- Returns matching lines with file paths and line numbers.`,`- Use this tool when you need to find files containing specific patterns.`,`- Use the glob tool instead if you only need to find files by name.`,`- Call this tool in parallel when you have multiple independent searches.`,`- Any line longer than 2000 characters is truncated.`].join(`
+`),execute:executeGrep,inputSchema:GREP_INPUT_SCHEMA,logicalPath:`ash:framework/grep`,name:`grep`,sourceId:`ash:grep-tool`,sourceKind:`module`};export{GREP_INPUT_SCHEMA,GREP_TOOL_DEFINITION};

package/dist/src/runtime/framework-tools/index.js

@@ -1,52 +1 @@
-import { ASK_QUESTION_TOOL_DEFINITION } from "#runtime/framework-tools/ask-question.js";
-import { BASH_TOOL_DEFINITION } from "#runtime/framework-tools/bash.js";
-import { CONNECTION_SEARCH_TOOL_DEFINITION } from "#runtime/framework-tools/connection-search.js";
-import { GLOB_TOOL_DEFINITION } from "#runtime/framework-tools/glob.js";
-import { GREP_TOOL_DEFINITION } from "#runtime/framework-tools/grep.js";
-import { READ_FILE_TOOL_DEFINITION } from "#runtime/framework-tools/read-file.js";
-import { SKILL_TOOL_DEFINITION } from "#runtime/framework-tools/skill.js";
-import { TODO_TOOL_DEFINITION } from "#runtime/framework-tools/todo.js";
-import { WEB_FETCH_TOOL_DEFINITION } from "#runtime/framework-tools/web-fetch.js";
-import { WEB_SEARCH_TOOL_DEFINITION } from "#runtime/framework-tools/web-search.js";
-import { WRITE_FILE_TOOL_DEFINITION } from "#runtime/framework-tools/write-file.js";
-export { ConnectionRegistryKey } from "#runtime/framework-tools/connection-search.js";
-export { ReadFileStateKey } from "#runtime/framework-tools/file-state.js";
-export { TodoStateKey } from "#runtime/framework-tools/todo.js";
-// Single source of truth — both getFrameworkToolDefinitions and
-// getAllFrameworkToolNames derive from this array.
-const ALL_FRAMEWORK_TOOLS = [
-    ASK_QUESTION_TOOL_DEFINITION,
-    BASH_TOOL_DEFINITION,
-    GLOB_TOOL_DEFINITION,
-    GREP_TOOL_DEFINITION,
-    READ_FILE_TOOL_DEFINITION,
-    WRITE_FILE_TOOL_DEFINITION,
-    TODO_TOOL_DEFINITION,
-    WEB_FETCH_TOOL_DEFINITION,
-    WEB_SEARCH_TOOL_DEFINITION,
-    SKILL_TOOL_DEFINITION,
-    CONNECTION_SEARCH_TOOL_DEFINITION,
-];
-const CONDITIONAL_TOOLS = new Map([[CONNECTION_SEARCH_TOOL_DEFINITION, (c) => c.hasConnections]]);
-/**
- * Returns framework-owned tool definitions registered in the tool registry
- * alongside authored tools during graph resolution.
- */
-export function getFrameworkToolDefinitions(config) {
-    return ALL_FRAMEWORK_TOOLS.filter((def) => {
-        const gate = CONDITIONAL_TOOLS.get(def);
-        return gate === undefined || gate(config);
-    });
-}
-/**
- * Returns the names of every framework-provided tool the framework knows
- * about, regardless of whether the current agent gates any of them on
- * runtime configuration.
- *
- * Used by the graph resolver to validate `disableTool(name)` arguments —
- * disabling a name that does not match any known framework tool is treated
- * as an authoring error rather than silently dropping the request.
- */
-export function getAllFrameworkToolNames() {
-    return new Set(ALL_FRAMEWORK_TOOLS.map((def) => def.name));
-}
+import{CONNECTION_SEARCH_TOOL_DEFINITION,ConnectionRegistryKey}from"#runtime/framework-tools/connection-search.js";import{ReadFileStateKey}from"#runtime/framework-tools/file-state.js";import{ASK_QUESTION_TOOL_DEFINITION}from"#runtime/framework-tools/ask-question.js";import{WEB_SEARCH_TOOL_DEFINITION}from"#runtime/framework-tools/web-search.js";import{BASH_TOOL_DEFINITION}from"#runtime/framework-tools/bash.js";import{GLOB_TOOL_DEFINITION}from"#runtime/framework-tools/glob.js";import{GREP_TOOL_DEFINITION}from"#runtime/framework-tools/grep.js";import{READ_FILE_TOOL_DEFINITION}from"#runtime/framework-tools/read-file.js";import{SKILL_TOOL_DEFINITION}from"#runtime/framework-tools/skill.js";import{TODO_TOOL_DEFINITION,TodoStateKey}from"#runtime/framework-tools/todo.js";import{WEB_FETCH_TOOL_DEFINITION}from"#runtime/framework-tools/web-fetch.js";import{WRITE_FILE_TOOL_DEFINITION}from"#runtime/framework-tools/write-file.js";var ALL_FRAMEWORK_TOOLS=[ASK_QUESTION_TOOL_DEFINITION,BASH_TOOL_DEFINITION,GLOB_TOOL_DEFINITION,GREP_TOOL_DEFINITION,READ_FILE_TOOL_DEFINITION,WRITE_FILE_TOOL_DEFINITION,TODO_TOOL_DEFINITION,WEB_FETCH_TOOL_DEFINITION,WEB_SEARCH_TOOL_DEFINITION,SKILL_TOOL_DEFINITION,CONNECTION_SEARCH_TOOL_DEFINITION],CONDITIONAL_TOOLS=new Map([[CONNECTION_SEARCH_TOOL_DEFINITION,e=>e.hasConnections]]);function getFrameworkToolDefinitions(e){return ALL_FRAMEWORK_TOOLS.filter(t=>{let n=CONDITIONAL_TOOLS.get(t);return n===void 0||n(e)})}function getAllFrameworkToolNames(){return new Set(ALL_FRAMEWORK_TOOLS.map(e=>e.name))}export{ConnectionRegistryKey,ReadFileStateKey,TodoStateKey,getAllFrameworkToolNames,getFrameworkToolDefinitions};