experimental-ash 0.26.0 → 0.28.0

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};

package/dist/src/runtime/framework-tools/pending-connection-tool-calls.js

@@ -1,63 +1 @@
-/**
- * Durable bookkeeping for connection tool calls that are pending
- * authorization.
- *
- * Pending calls are replaced with a placeholder result, then replayed
- * after webhook completion and spliced back into history before the next
- * model step sees them.
- */
-import { ContextKey } from "#context/key.js";
-/**
- * Opaque sentinel written to the session history as the tool-call
- * result while authorization is in flight. Always swapped for the
- * real result by `splicePendingToolResults` before the next model
- * fragment runs, so the model never sees it.
- */
-export const CONNECTION_AUTHORIZATION_PLACEHOLDER = Object.freeze({
-    __ashPlaceholder: "connection-authorization",
-});
-/**
- * Durable context key carrying pending tool calls across the workflow
- * pause/resume boundary.
- *
- * Entries are cleared per authorization cycle only for the connections
- * that resolved during that cycle; residual entries for connections
- * still awaiting auth (e.g. because the same turn observed a fresh
- * `Required` during retry) stay for the next cycle.
- */
-export const PendingConnectionToolCallsKey = new ContextKey("ash.pendingConnectionToolCalls");
-/**
- * Appends new pending tool calls to the context, deduplicated by
- * `toolCallId` so repeated retries in the same cycle don't grow the
- * list unboundedly. Existing order is preserved so the splice order
- * stays deterministic on replay.
- */
-export function appendPendingConnectionToolCalls(existing, additions) {
-    if (additions.length === 0) {
-        return existing ?? [];
-    }
-    const seen = new Set();
-    const base = existing ?? [];
-    for (const entry of base) {
-        seen.add(entry.toolCallId);
-    }
-    const next = [...base];
-    for (const addition of additions) {
-        if (seen.has(addition.toolCallId))
-            continue;
-        seen.add(addition.toolCallId);
-        next.push(addition);
-    }
-    return next;
-}
-/**
- * Narrow `value` to the placeholder sentinel. Used by the splice
- * helper and by tests to assert that a pre-splice tool-result is a
- * placeholder rather than a real value.
- */
-export function isConnectionAuthorizationPlaceholder(value) {
-    if (typeof value !== "object" || value === null)
-        return false;
-    const v = value;
-    return v.__ashPlaceholder === "connection-authorization";
-}
+import{ContextKey}from"#context/key.js";var CONNECTION_AUTHORIZATION_PLACEHOLDER=Object.freeze({__ashPlaceholder:`connection-authorization`}),PendingConnectionToolCallsKey=new ContextKey(`ash.pendingConnectionToolCalls`);function appendPendingConnectionToolCalls(e,t){if(t.length===0)return e??[];let n=new Set,r=e??[];for(let e of r)n.add(e.toolCallId);let i=[...r];for(let e of t)n.has(e.toolCallId)||(n.add(e.toolCallId),i.push(e));return i}function isConnectionAuthorizationPlaceholder(e){return typeof e!=`object`||!e?!1:e.__ashPlaceholder===`connection-authorization`}export{CONNECTION_AUTHORIZATION_PLACEHOLDER,PendingConnectionToolCallsKey,appendPendingConnectionToolCalls,isConnectionAuthorizationPlaceholder};

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

@@ -1,64 +1,2 @@
-import { executeReadFileOnSandbox } from "#execution/sandbox/read-file-tool.js";
-import { clearReadFileState } from "#runtime/framework-tools/file-state.js";
-/**
- * Shared input schema used by the framework `read_file` tool and any author
- * tool constructed via {@link defineReadFileTool}.
- *
- * Exported so the public `defineReadFileTool` factory and the framework
- * `READ_FILE_TOOL_DEFINITION` use the exact same schema object — keeping
- * model input contracts in sync without duplication.
- */
-export const READ_FILE_INPUT_SCHEMA = {
-    additionalProperties: false,
-    properties: {
-        filePath: {
-            description: "The absolute path to the file to read.",
-            type: "string",
-        },
-        limit: {
-            description: "Maximum number of lines to return. Defaults to 2000.",
-            minimum: 1,
-            type: "integer",
-        },
-        offset: {
-            description: "1-based line number to start from. Defaults to 1.",
-            minimum: 1,
-            type: "integer",
-        },
-    },
-    required: ["filePath"],
-    type: "object",
-};
-/**
- * Framework-owned executor that delegates to the default sandbox.
- */
-async function executeReadFile(input) {
-    return executeReadFileOnSandbox(input);
-}
-export const READ_FILE_TOOL_DEFINITION = {
-    description: [
-        "Read a file from the local filesystem. If the path does not exist, an error is returned.",
-        "",
-        "Usage:",
-        "- The filePath parameter should be an absolute path.",
-        "- By default, this tool returns up to 2000 lines from the start of the file.",
-        "- The offset parameter is the line number to start from (1-indexed).",
-        "- To read later sections, call this tool again with a larger offset.",
-        "- Use the grep tool to find specific content in large files or files with long lines.",
-        "- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.",
-        '- Contents are returned with each line prefixed by its line number as `<line>: <content>`. For example, if a file has contents "foo\\n", you will receive "1: foo\\n".',
-        "- Any line longer than 2000 characters is truncated.",
-        "- Call this tool in parallel when you know there are multiple files you want to read.",
-        "- Avoid tiny repeated slices (30 line chunks). If you need more context, read a larger window.",
-    ].join("\n"),
-    execute: executeReadFile,
-    inputSchema: READ_FILE_INPUT_SCHEMA,
-    logicalPath: "ash:framework/read-file",
-    name: "read_file",
-    onCompact({ ctx }) {
-        clearReadFileState(ctx);
-        return {};
-    },
-    sourceId: "ash:read-file-tool",
-    sourceKind: "module",
-};
+import{clearReadFileState}from"#runtime/framework-tools/file-state.js";import{executeReadFileOnSandbox}from"#execution/sandbox/read-file-tool.js";var READ_FILE_INPUT_SCHEMA={additionalProperties:!1,properties:{filePath:{description:`The absolute path to the file to read.`,type:`string`},limit:{description:`Maximum number of lines to return. Defaults to 2000.`,minimum:1,type:`integer`},offset:{description:`1-based line number to start from. Defaults to 1.`,minimum:1,type:`integer`}},required:[`filePath`],type:`object`};async function executeReadFile(e){return executeReadFileOnSandbox(e)}var READ_FILE_TOOL_DEFINITION={description:[`Read a file from the local filesystem. If the path does not exist, an error is returned.`,``,`Usage:`,`- The filePath parameter should be an absolute path.`,`- By default, this tool returns up to 2000 lines from the start of the file.`,`- The offset parameter is the line number to start from (1-indexed).`,`- To read later sections, call this tool again with a larger offset.`,`- Use the grep tool to find specific content in large files or files with long lines.`,`- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.`,'- Contents are returned with each line prefixed by its line number as `<line>: <content>`. For example, if a file has contents "foo\\n", you will receive "1: foo\\n".',`- Any line longer than 2000 characters is truncated.`,`- Call this tool in parallel when you know there are multiple files you want to read.`,`- Avoid tiny repeated slices (30 line chunks). If you need more context, read a larger window.`].join(`
+`),execute:executeReadFile,inputSchema:READ_FILE_INPUT_SCHEMA,logicalPath:`ash:framework/read-file`,name:`read_file`,onCompact({ctx:t}){return clearReadFileState(t),{}},sourceId:`ash:read-file-tool`,sourceKind:`module`};export{READ_FILE_INPUT_SCHEMA,READ_FILE_TOOL_DEFINITION};

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

@@ -1,47 +1 @@
-import { loadContext } from "#context/container.js";
-import { SandboxKey } from "#context/keys.js";
-import { loadSkillFromSandbox } from "#runtime/skills/sandbox-access.js";
-/**
- * Executes the `load_skill` tool.
- *
- * Reads the requested skill's `SKILL.md` from the active sandbox and
- * returns it as the tool result.
- */
-async function executeLoadSkillTool(args) {
-    const ctx = loadContext();
-    const sandbox = ctx.get(SandboxKey);
-    if (sandbox === undefined) {
-        throw new Error("The load_skill tool requires sandbox access on the runtime context. " +
-            "Ensure the step is running inside a managed runtime context with sandbox support.");
-    }
-    const { skill } = args;
-    return await loadSkillFromSandbox(sandbox, skill);
-}
-// ---------------------------------------------------------------------------
-// Tool definition
-// ---------------------------------------------------------------------------
-export const SKILL_TOOL_DEFINITION = {
-    description: [
-        "Load the full instructions for one available skill by name or id.",
-        "Use this tool when the request clearly matches a listed skill description or when the user explicitly asks for that skill.",
-        "Loading adds the skill instructions to the current turn.",
-        'Choose the "skill" value from the Available skills block.',
-    ].join(" "),
-    execute: (input) => executeLoadSkillTool(input),
-    inputSchema: {
-        additionalProperties: false,
-        properties: {
-            skill: {
-                description: "Available skill name or id.",
-                type: "string",
-            },
-        },
-        required: ["skill"],
-        type: "object",
-    },
-    logicalPath: "ash:framework/load-skill",
-    name: "load_skill",
-    retentionPolicy: "keep",
-    sourceId: "ash:load-skill-tool",
-    sourceKind: "module",
-};
+import{loadSkillFromSandbox}from"#runtime/skills/sandbox-access.js";import{loadContext}from"#context/container.js";import{SandboxKey}from"#context/keys.js";async function executeLoadSkillTool(t){let n=loadContext().get(SandboxKey);if(n===void 0)throw Error(`The load_skill tool requires sandbox access on the runtime context. Ensure the step is running inside a managed runtime context with sandbox support.`);let{skill:r}=t;return await loadSkillFromSandbox(n,r)}var SKILL_TOOL_DEFINITION={description:[`Load the full instructions for one available skill by name or id.`,`Use this tool when the request clearly matches a listed skill description or when the user explicitly asks for that skill.`,`Loading adds the skill instructions to the current turn.`,`Choose the "skill" value from the Available skills block.`].join(` `),execute:e=>executeLoadSkillTool(e),inputSchema:{additionalProperties:!1,properties:{skill:{description:`Available skill name or id.`,type:`string`}},required:[`skill`],type:`object`},logicalPath:`ash:framework/load-skill`,name:`load_skill`,retentionPolicy:`keep`,sourceId:`ash:load-skill-tool`,sourceKind:`module`};export{SKILL_TOOL_DEFINITION};