experimental-ash 0.26.0 → 0.28.0

package/dist/src/runtime/sessions/compiled-agent-cache.js

@@ -1,125 +1 @@
-import { pathToFileURL } from "node:url";
-import { resolveRuntimeCompiledArtifactsVersionedCacheKey } from "#runtime/cache-key.js";
-import { createRuntimeAdapterRegistry } from "#runtime/channels/registry.js";
-import { getRuntimeCompiledArtifactsCacheKey, } from "#runtime/compiled-artifacts-source.js";
-import { getResolvedRuntimeAgentNode } from "#runtime/graph.js";
-import { loadCompiledManifest } from "#runtime/loaders/manifest.js";
-import { loadCompiledModuleMap } from "#runtime/loaders/module-map.js";
-import { resolveRuntimeAgentGraph } from "#runtime/resolve-agent-graph.js";
-import { getActiveRuntimeSession } from "#runtime/sessions/runtime-session.js";
-const isCacheDisabled = process.env.ASH_DISABLE_AGENT_CACHE === "1";
-async function loadFullBundle(compiledArtifactsSource) {
-    const [manifest, moduleMap] = await Promise.all([
-        loadCompiledManifest({ compiledArtifactsSource }),
-        loadRuntimeCompiledModuleMap(compiledArtifactsSource),
-    ]);
-    const graph = await resolveRuntimeAgentGraph({ manifest, moduleMap });
-    const rootNode = graph.root;
-    return {
-        adapterRegistry: createRuntimeAdapterRegistry({
-            channels: collectResolvedChannels(graph),
-        }),
-        compiledArtifactsSource,
-        graph,
-        hookRegistry: rootNode.hookRegistry,
-        moduleMap,
-        resolvedAgent: rootNode.agent,
-        subagentRegistry: rootNode.subagentRegistry,
-        toolRegistry: rootNode.toolRegistry,
-        turnAgent: rootNode.turnAgent,
-    };
-}
-async function loadRuntimeCompiledModuleMap(compiledArtifactsSource) {
-    if (compiledArtifactsSource.kind === "disk" &&
-        compiledArtifactsSource.moduleMapLoaderPath !== undefined) {
-        return await loadAuthoredSourceCompiledModuleMap(compiledArtifactsSource);
-    }
-    return await loadCompiledModuleMap({ compiledArtifactsSource });
-}
-async function loadAuthoredSourceCompiledModuleMap(compiledArtifactsSource) {
-    if (compiledArtifactsSource.moduleMapLoaderPath === undefined) {
-        throw new Error('Authored-source module map loading requires "moduleMapLoaderPath" in the compiled artifacts source.');
-    }
-    const loader = (await import(pathToFileURL(compiledArtifactsSource.moduleMapLoaderPath).href));
-    return await loader.loadCompiledModuleMapFromAuthoredSource({
-        compiledArtifactsSource,
-    });
-}
-async function getOrLoadFullBundle(compiledArtifactsSource) {
-    if (isCacheDisabled) {
-        return loadFullBundle(compiledArtifactsSource);
-    }
-    const session = getActiveRuntimeSession();
-    const sourceKey = getRuntimeCompiledArtifactsCacheKey(compiledArtifactsSource);
-    const cacheKey = await resolveRuntimeCompiledArtifactsVersionedCacheKey(compiledArtifactsSource);
-    const previousKey = session.bundleCacheKeyBySourceKey.get(sourceKey);
-    if (previousKey !== undefined && previousKey !== cacheKey) {
-        session.bundleCache.delete(previousKey);
-    }
-    session.bundleCacheKeyBySourceKey.set(sourceKey, cacheKey);
-    const cached = session.bundleCache.get(cacheKey);
-    if (cached !== undefined) {
-        return cached;
-    }
-    const bundlePromise = loadFullBundle(compiledArtifactsSource).catch((error) => {
-        session.bundleCache.delete(cacheKey);
-        if (session.bundleCacheKeyBySourceKey.get(sourceKey) === cacheKey) {
-            session.bundleCacheKeyBySourceKey.delete(sourceKey);
-        }
-        throw error;
-    });
-    session.bundleCache.set(cacheKey, bundlePromise);
-    return bundlePromise;
-}
-/**
- * Returns a compiled runtime agent bundle for the given source and optional
- * node id.
- *
- * The full graph is loaded and cached once per `compiledArtifactsSource`.
- * When `nodeId` is provided, a cheap per-node bundle is derived from
- * the cached graph with the node-level fields (turn agent, registries, etc.)
- * pointing at the target node. When omitted the root bundle is returned.
- */
-export async function getCompiledRuntimeAgentBundle(input) {
-    const fullBundle = await getOrLoadFullBundle(input.compiledArtifactsSource);
-    if (input.nodeId === undefined) {
-        return fullBundle;
-    }
-    const node = getResolvedRuntimeAgentNode(fullBundle.graph, input.nodeId);
-    return {
-        adapterRegistry: fullBundle.adapterRegistry,
-        compiledArtifactsSource: fullBundle.compiledArtifactsSource,
-        graph: {
-            nodesByNodeId: fullBundle.graph.nodesByNodeId,
-            root: node,
-        },
-        hookRegistry: node.hookRegistry,
-        moduleMap: fullBundle.moduleMap,
-        nodeId: input.nodeId,
-        resolvedAgent: node.agent,
-        subagentRegistry: node.subagentRegistry,
-        toolRegistry: node.toolRegistry,
-        turnAgent: node.turnAgent,
-    };
-}
-/**
- * Clears all cached compiled runtime agent bundles on the active runtime
- * session. The dev-server file watcher uses this to invalidate cached
- * bundles when authored source changes; tests rely on per-session isolation
- * so the process default cache is untouched when called inside a scoped
- * session.
- */
-export function clearCompiledRuntimeAgentBundleCache() {
-    const session = getActiveRuntimeSession();
-    session.bundleCache.clear();
-    session.bundleCacheKeyBySourceKey.clear();
-}
-function collectResolvedChannels(bundle) {
-    const channels = new Map();
-    for (const node of bundle.nodesByNodeId.values()) {
-        for (const channel of node.channels) {
-            channels.set(`${channel.sourceId}:${channel.name}`, channel);
-        }
-    }
-    return [...channels.values()];
-}
+import{createRuntimeAdapterRegistry}from"#runtime/channels/registry.js";import{getRuntimeCompiledArtifactsCacheKey}from"#runtime/compiled-artifacts-source.js";import{getResolvedRuntimeAgentNode}from"#runtime/graph.js";import{loadCompiledManifest}from"#runtime/loaders/manifest.js";import{resolveRuntimeAgentGraph}from"#runtime/resolve-agent-graph.js";import{pathToFileURL}from"node:url";import{loadCompiledModuleMap}from"#runtime/loaders/module-map.js";import{getActiveRuntimeSession}from"#runtime/sessions/runtime-session.js";import{resolveRuntimeCompiledArtifactsVersionedCacheKey}from"#runtime/cache-key.js";var isCacheDisabled=process.env.ASH_DISABLE_AGENT_CACHE===`1`;async function loadFullBundle(t){let[n,a]=await Promise.all([loadCompiledManifest({compiledArtifactsSource:t}),loadRuntimeCompiledModuleMap(t)]),o=await resolveRuntimeAgentGraph({manifest:n,moduleMap:a}),s=o.root;return{adapterRegistry:createRuntimeAdapterRegistry({channels:collectResolvedChannels(o)}),compiledArtifactsSource:t,graph:o,hookRegistry:s.hookRegistry,moduleMap:a,resolvedAgent:s.agent,subagentRegistry:s.subagentRegistry,toolRegistry:s.toolRegistry,turnAgent:s.turnAgent}}async function loadRuntimeCompiledModuleMap(e){return e.kind===`disk`&&e.moduleMapLoaderPath!==void 0?await loadAuthoredSourceCompiledModuleMap(e):await loadCompiledModuleMap({compiledArtifactsSource:e})}async function loadAuthoredSourceCompiledModuleMap(e){if(e.moduleMapLoaderPath===void 0)throw Error(`Authored-source module map loading requires "moduleMapLoaderPath" in the compiled artifacts source.`);return await(await import(pathToFileURL(e.moduleMapLoaderPath).href)).loadCompiledModuleMapFromAuthoredSource({compiledArtifactsSource:e})}async function getOrLoadFullBundle(e){if(isCacheDisabled)return loadFullBundle(e);let n=getActiveRuntimeSession(),r=getRuntimeCompiledArtifactsCacheKey(e),i=await resolveRuntimeCompiledArtifactsVersionedCacheKey(e),a=n.bundleCacheKeyBySourceKey.get(r);a!==void 0&&a!==i&&n.bundleCache.delete(a),n.bundleCacheKeyBySourceKey.set(r,i);let o=n.bundleCache.get(i);if(o!==void 0)return o;let c=loadFullBundle(e).catch(e=>{throw n.bundleCache.delete(i),n.bundleCacheKeyBySourceKey.get(r)===i&&n.bundleCacheKeyBySourceKey.delete(r),e});return n.bundleCache.set(i,c),c}async function getCompiledRuntimeAgentBundle(e){let t=await getOrLoadFullBundle(e.compiledArtifactsSource);if(e.nodeId===void 0)return t;let r=getResolvedRuntimeAgentNode(t.graph,e.nodeId);return{adapterRegistry:t.adapterRegistry,compiledArtifactsSource:t.compiledArtifactsSource,graph:{nodesByNodeId:t.graph.nodesByNodeId,root:r},hookRegistry:r.hookRegistry,moduleMap:t.moduleMap,nodeId:e.nodeId,resolvedAgent:r.agent,subagentRegistry:r.subagentRegistry,toolRegistry:r.toolRegistry,turnAgent:r.turnAgent}}function clearCompiledRuntimeAgentBundleCache(){let e=getActiveRuntimeSession();e.bundleCache.clear(),e.bundleCacheKeyBySourceKey.clear()}function collectResolvedChannels(e){let t=new Map;for(let n of e.nodesByNodeId.values())for(let e of n.channels)t.set(`${e.sourceId}:${e.name}`,e);return[...t.values()]}export{clearCompiledRuntimeAgentBundleCache,getCompiledRuntimeAgentBundle};

package/dist/src/runtime/sessions/runtime-session.js

@@ -1,50 +1 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-/**
- * Creates a fresh, empty runtime session.
- */
-export function createRuntimeSession(id = "test-session") {
-    return {
-        bundleCache: new Map(),
-        bundleCacheKeyBySourceKey: new Map(),
-        compiledArtifacts: null,
-        id,
-    };
-}
-/**
- * Process-global storage for the current `RuntimeSession`.
- *
- * Rooted on `globalThis` so Nitro-inlined Ash and disk-imported Ash share
- * the same process default while tests still get async-scoped overrides.
- */
-const RUNTIME_SESSION_STORAGE_GLOBAL_KEY = Symbol.for("experimental-ash.runtime-session-storage");
-const RUNTIME_SESSION_DEFAULT_GLOBAL_KEY = Symbol.for("experimental-ash.runtime-session-default");
-const globalContainer = globalThis;
-if (globalContainer[RUNTIME_SESSION_STORAGE_GLOBAL_KEY] === undefined) {
-    globalContainer[RUNTIME_SESSION_STORAGE_GLOBAL_KEY] = new AsyncLocalStorage();
-}
-const runtimeSessionStorage = globalContainer[RUNTIME_SESSION_STORAGE_GLOBAL_KEY];
-function resolveProcessDefaultSession() {
-    if (globalContainer[RUNTIME_SESSION_DEFAULT_GLOBAL_KEY] === undefined) {
-        globalContainer[RUNTIME_SESSION_DEFAULT_GLOBAL_KEY] = createRuntimeSession("process-default");
-    }
-    return globalContainer[RUNTIME_SESSION_DEFAULT_GLOBAL_KEY];
-}
-/**
- * Returns the runtime session that should be consulted for the current call.
- *
- * Returns the scoped session when {@link withRuntimeSession} is active in
- * the current async context, otherwise the process-default session
- * (lazily created on first access).
- */
-export function getActiveRuntimeSession() {
-    return runtimeSessionStorage.getStore() ?? resolveProcessDefaultSession();
-}
-/**
- * Executes `fn` with `session` installed as the active runtime session for
- * the duration of the callback, including across every `await` boundary
- * inside it. Concurrent callers each observe their own session. The
- * process-default session is untouched.
- */
-export async function withRuntimeSession(session, fn) {
-    return await runtimeSessionStorage.run(session, async () => await fn());
-}
+import{AsyncLocalStorage}from"node:async_hooks";function createRuntimeSession(e=`test-session`){return{bundleCache:new Map,bundleCacheKeyBySourceKey:new Map,compiledArtifacts:null,id:e}}var RUNTIME_SESSION_STORAGE_GLOBAL_KEY=Symbol.for(`experimental-ash.runtime-session-storage`),RUNTIME_SESSION_DEFAULT_GLOBAL_KEY=Symbol.for(`experimental-ash.runtime-session-default`),globalContainer=globalThis;globalContainer[RUNTIME_SESSION_STORAGE_GLOBAL_KEY]===void 0&&(globalContainer[RUNTIME_SESSION_STORAGE_GLOBAL_KEY]=new AsyncLocalStorage);var runtimeSessionStorage=globalContainer[RUNTIME_SESSION_STORAGE_GLOBAL_KEY];function resolveProcessDefaultSession(){return globalContainer[RUNTIME_SESSION_DEFAULT_GLOBAL_KEY]===void 0&&(globalContainer[RUNTIME_SESSION_DEFAULT_GLOBAL_KEY]=createRuntimeSession(`process-default`)),globalContainer[RUNTIME_SESSION_DEFAULT_GLOBAL_KEY]}function getActiveRuntimeSession(){return runtimeSessionStorage.getStore()??resolveProcessDefaultSession()}async function withRuntimeSession(e,t){return await runtimeSessionStorage.run(e,async()=>await t())}export{createRuntimeSession,getActiveRuntimeSession,withRuntimeSession};

package/dist/src/runtime/sessions/turn.js

@@ -1 +1 @@
-export {};
+export{};

package/dist/src/runtime/skills/fragment-context.js

@@ -1,4 +1 @@
-/**
- * Framework-owned tool name used to load one available compiled skill.
- */
-export const LOAD_SKILL_TOOL_NAME = "load_skill";
+var LOAD_SKILL_TOOL_NAME=`load_skill`;export{LOAD_SKILL_TOOL_NAME};

package/dist/src/runtime/skills/sandbox-access.js

@@ -1,85 +1 @@
-import { WORKSPACE_ROOT } from "#runtime/workspace/types.js";
-const FRONTMATTER_PATTERN = /^---\r?\n[\s\S]*?\r?\n---\r?\n?/;
-/**
- * Validates a skill id before it is used as one path segment under
- * `/workspace/skills`.
- */
-export function assertSafeSkillId(id) {
-    if (id.length === 0 ||
-        id.trim() !== id ||
-        id.startsWith(".") ||
-        id.includes("/") ||
-        id.includes("\\") ||
-        id.includes("..") ||
-        /^[A-Za-z]:/.test(id)) {
-        throw new Error('Expected skill id to be a non-empty safe path segment without whitespace, separators, "." prefix, or "..".');
-    }
-}
-/**
- * Reads one skill's instruction markdown from the current sandbox.
- *
- * Returns the SKILL.md body with any YAML frontmatter stripped, so the
- * model receives plain markdown as the tool result. Throws when the id
- * is unsafe or the file does not exist; the AI SDK forwards the error
- * to the model as a tool-error result.
- */
-export async function loadSkillFromSandbox(access, id) {
-    assertSafeSkillId(id);
-    const sandbox = await requireSandboxSession(access);
-    const path = skillFilePath(id, "SKILL.md");
-    const instructions = await sandbox.readTextFile({ path });
-    if (instructions === null) {
-        throw new Error(`No skill named "${id}" at ${path}.`);
-    }
-    return instructions.replace(FRONTMATTER_PATTERN, "");
-}
-/**
- * Creates the public runtime skill handle. Existence is checked lazily by
- * each file read against the sandbox.
- */
-export function createSandboxSkillHandle(access, id) {
-    assertSafeSkillId(id);
-    return {
-        name: id,
-        file(relativePath) {
-            assertSafeSkillRelativePath(relativePath);
-            const path = skillFilePath(id, relativePath);
-            return {
-                async bytes() {
-                    const sandbox = await requireSandboxSession(access);
-                    const content = await sandbox.readBinaryFile({ path });
-                    if (content === null)
-                        throw new Error(`Skill file not found: ${path}`);
-                    return content;
-                },
-                async text() {
-                    const sandbox = await requireSandboxSession(access);
-                    const content = await sandbox.readTextFile({ path });
-                    if (content === null)
-                        throw new Error(`Skill file not found: ${path}`);
-                    return content;
-                },
-            };
-        },
-    };
-}
-function assertSafeSkillRelativePath(relativePath) {
-    if (relativePath.length === 0 ||
-        relativePath.startsWith("/") ||
-        relativePath.includes("\\") ||
-        relativePath
-            .split("/")
-            .some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-        throw new Error("Expected skill file path to be a relative path inside the skill directory.");
-    }
-}
-async function requireSandboxSession(access) {
-    const sandbox = await access.get();
-    if (sandbox === null) {
-        throw new Error("The sandbox is not available in the current authored runtime context.");
-    }
-    return sandbox;
-}
-function skillFilePath(id, relativePath) {
-    return `${WORKSPACE_ROOT}/skills/${id}/${relativePath}`;
-}
+import{WORKSPACE_ROOT}from"#runtime/workspace/types.js";var FRONTMATTER_PATTERN=/^---\r?\n[\s\S]*?\r?\n---\r?\n?/;function assertSafeSkillId(e){if(e.length===0||e.trim()!==e||e.startsWith(`.`)||e.includes(`/`)||e.includes(`\\`)||e.includes(`..`)||/^[A-Za-z]:/.test(e))throw Error(`Expected skill id to be a non-empty safe path segment without whitespace, separators, "." prefix, or "..".`)}async function loadSkillFromSandbox(e,n){assertSafeSkillId(n);let r=await requireSandboxSession(e),i=skillFilePath(n,`SKILL.md`),a=await r.readTextFile({path:i});if(a===null)throw Error(`No skill named "${n}" at ${i}.`);return a.replace(FRONTMATTER_PATTERN,``)}function createSandboxSkillHandle(e,t){return assertSafeSkillId(t),{name:t,file(n){assertSafeSkillRelativePath(n);let r=skillFilePath(t,n);return{async bytes(){let t=await(await requireSandboxSession(e)).readBinaryFile({path:r});if(t===null)throw Error(`Skill file not found: ${r}`);return t},async text(){let t=await(await requireSandboxSession(e)).readTextFile({path:r});if(t===null)throw Error(`Skill file not found: ${r}`);return t}}}}}function assertSafeSkillRelativePath(e){if(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||e.split(`/`).some(e=>e.length===0||e===`.`||e===`..`))throw Error(`Expected skill file path to be a relative path inside the skill directory.`)}async function requireSandboxSession(e){let t=await e.get();if(t===null)throw Error(`The sandbox is not available in the current authored runtime context.`);return t}function skillFilePath(t,n){return`${WORKSPACE_ROOT}/skills/${t}/${n}`}export{assertSafeSkillId,createSandboxSkillHandle,loadSkillFromSandbox};

package/dist/src/runtime/subagents/registry.js

@@ -1,62 +1 @@
-import { RuntimeRegistry, RuntimeRegistryError } from "#internal/runtime-registry.js";
-/**
- * Stable JSON Schema lowered onto every subagent tool. Subagents always
- * accept one free-form `message` string from the parent agent.
- */
-const SUBAGENT_TOOL_INPUT_SCHEMA = Object.freeze({
-    type: "object",
-    properties: Object.freeze({
-        message: Object.freeze({
-            type: "string",
-            description: "The message to send to the subagent. Provide all context the subagent needs to complete the task; the subagent does not see the parent's history.",
-        }),
-    }),
-    required: Object.freeze(["message"]),
-    additionalProperties: false,
-});
-/**
- * Builds the runtime-owned registry for the resolved subagents visible from one
- * runtime agent node.
- */
-export function createRuntimeSubagentRegistry(input) {
-    const preparedTools = [];
-    const registry = new RuntimeRegistry("subagent", input.reservedToolNames ?? []);
-    const subagentsByNodeId = new Map();
-    for (const subagentDefinition of input.subagents) {
-        const location = {
-            logicalPath: subagentDefinition.logicalPath,
-            sourceId: subagentDefinition.sourceId,
-        };
-        if (subagentsByNodeId.has(subagentDefinition.nodeId)) {
-            throw new RuntimeRegistryError("subagent", `Found multiple runtime subagents mapped to node id "${subagentDefinition.nodeId}".`, { ...location, entryName: subagentDefinition.name });
-        }
-        const prepared = createPreparedRuntimeSubagentTool(subagentDefinition);
-        const registeredSubagent = {
-            definition: subagentDefinition,
-            prepared,
-        };
-        registry.register(subagentDefinition.name, registeredSubagent, {
-            location,
-            duplicateMessage: `Found multiple subagents named "${subagentDefinition.name}". Subagent names must be unique at runtime.`,
-            reservedMessage: `Subagent "${subagentDefinition.name}" collides with another runtime-visible tool name.`,
-        });
-        preparedTools.push(prepared);
-        subagentsByNodeId.set(subagentDefinition.nodeId, registeredSubagent);
-    }
-    return {
-        preparedTools,
-        subagentsByName: registry.asMap(),
-        subagentsByNodeId,
-    };
-}
-function createPreparedRuntimeSubagentTool(definition) {
-    return {
-        description: definition.description,
-        inputSchema: SUBAGENT_TOOL_INPUT_SCHEMA,
-        kind: definition.kind,
-        logicalPath: definition.logicalPath,
-        name: definition.name,
-        nodeId: definition.nodeId,
-        sourceId: definition.sourceId,
-    };
-}
+import{RuntimeRegistry,RuntimeRegistryError}from"#internal/runtime-registry.js";var SUBAGENT_TOOL_INPUT_SCHEMA=Object.freeze({type:`object`,properties:Object.freeze({message:Object.freeze({type:`string`,description:`The message to send to the subagent. Provide all context the subagent needs to complete the task; the subagent does not see the parent's history.`})}),required:Object.freeze([`message`]),additionalProperties:!1});function createRuntimeSubagentRegistry(t){let n=[],r=new RuntimeRegistry(`subagent`,t.reservedToolNames??[]),i=new Map;for(let e of t.subagents){let t={logicalPath:e.logicalPath,sourceId:e.sourceId};if(i.has(e.nodeId))throw new RuntimeRegistryError(`subagent`,`Found multiple runtime subagents mapped to node id "${e.nodeId}".`,{...t,entryName:e.name});let a=createPreparedRuntimeSubagentTool(e),o={definition:e,prepared:a};r.register(e.name,o,{location:t,duplicateMessage:`Found multiple subagents named "${e.name}". Subagent names must be unique at runtime.`,reservedMessage:`Subagent "${e.name}" collides with another runtime-visible tool name.`}),n.push(a),i.set(e.nodeId,o)}return{preparedTools:n,subagentsByName:r.asMap(),subagentsByNodeId:i}}function createPreparedRuntimeSubagentTool(e){return{description:e.description,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,kind:e.kind,logicalPath:e.logicalPath,name:e.name,nodeId:e.nodeId,sourceId:e.sourceId}}export{createRuntimeSubagentRegistry};

package/dist/src/runtime/tools/registry.js

@@ -1,40 +1 @@
-import { RuntimeRegistry } from "#internal/runtime-registry.js";
-/**
- * Builds the runtime-owned registry for one resolved authored agent.
- */
-export async function createRuntimeToolRegistry(definitions, input = {}) {
-    const preparedTools = [];
-    const registry = new RuntimeRegistry("tool", input.reservedToolNames ?? []);
-    for (const toolDefinition of definitions.tools) {
-        const prepared = await createPreparedRuntimeTool(toolDefinition);
-        registry.register(toolDefinition.name, { definition: toolDefinition, prepared }, {
-            location: {
-                logicalPath: toolDefinition.logicalPath,
-                sourceId: toolDefinition.sourceId,
-            },
-            duplicateMessage: `Found multiple authored tools named "${toolDefinition.name}". Tool names must be unique at runtime.`,
-            reservedMessage: `Tool "${toolDefinition.name}" collides with another runtime-visible tool name.`,
-        });
-        preparedTools.push(prepared);
-    }
-    return {
-        preparedTools,
-        toolsByName: registry.asMap(),
-    };
-}
-/**
- * Looks up one authored tool by name from the runtime-owned registry.
- */
-export function findRegisteredRuntimeTool(registry, toolName) {
-    return registry.toolsByName.get(toolName) ?? null;
-}
-async function createPreparedRuntimeTool(definition) {
-    return {
-        description: definition.description,
-        inputSchema: definition.inputSchema,
-        kind: "authored-tool",
-        logicalPath: definition.logicalPath,
-        name: definition.name,
-        sourceId: definition.sourceId,
-    };
-}
+import{RuntimeRegistry}from"#internal/runtime-registry.js";async function createRuntimeToolRegistry(t,n={}){let r=[],i=new RuntimeRegistry(`tool`,n.reservedToolNames??[]);for(let e of t.tools){let t=await createPreparedRuntimeTool(e);i.register(e.name,{definition:e,prepared:t},{location:{logicalPath:e.logicalPath,sourceId:e.sourceId},duplicateMessage:`Found multiple authored tools named "${e.name}". Tool names must be unique at runtime.`,reservedMessage:`Tool "${e.name}" collides with another runtime-visible tool name.`}),r.push(t)}return{preparedTools:r,toolsByName:i.asMap()}}function findRegisteredRuntimeTool(e,t){return e.toolsByName.get(t)??null}async function createPreparedRuntimeTool(e){return{description:e.description,inputSchema:e.inputSchema,kind:`authored-tool`,logicalPath:e.logicalPath,name:e.name,sourceId:e.sourceId}}export{createRuntimeToolRegistry,findRegisteredRuntimeTool};

package/dist/src/runtime/types.js

@@ -1 +1 @@
-export {};
+export{};

package/dist/src/runtime/validation.js

@@ -1,7 +1 @@
-import { fromError } from "#compiled/zod-validation-error/index.js";
-/**
- * Formats one zod validation error into a concise single-message string.
- */
-export function formatValidationError(error) {
-    return fromError(error, { prefix: undefined }).message;
-}
+import{fromError}from"#compiled/zod-validation-error/index.js";function formatValidationError(e){return fromError(e,{prefix:void 0}).message}export{formatValidationError};

package/dist/src/runtime/workspace/seed-files.js

@@ -1,42 +1 @@
-import { readdir, readFile } from "node:fs/promises";
-import { join, posix as pathPosix } from "node:path";
-import { WORKSPACE_ROOT } from "#runtime/workspace/types.js";
-/**
- * Walks a directory tree on disk and returns one entry per file rooted at
- * `/workspace/...`, sorted by path. The directory is treated as the
- * `/workspace` root for the resulting seed file paths.
- */
-export async function materializeWorkspaceDirectory(sourceDirectoryPath) {
-    const files = [];
-    await addMaterializedDirectoryFiles({
-        files,
-        logicalDirectoryPath: ".",
-        sourceDirectoryPath,
-    });
-    files.sort((left, right) => left.path.localeCompare(right.path));
-    return files;
-}
-async function addMaterializedDirectoryFiles(input) {
-    const entries = await readdir(input.sourceDirectoryPath, {
-        withFileTypes: true,
-    });
-    for (const entry of entries) {
-        if (!entry.isDirectory() && !entry.isFile()) {
-            continue;
-        }
-        const sourcePath = join(input.sourceDirectoryPath, entry.name);
-        const logicalPath = pathPosix.join(input.logicalDirectoryPath, entry.name);
-        if (entry.isDirectory()) {
-            await addMaterializedDirectoryFiles({
-                files: input.files,
-                logicalDirectoryPath: logicalPath,
-                sourceDirectoryPath: sourcePath,
-            });
-            continue;
-        }
-        input.files.push({
-            content: await readFile(sourcePath),
-            path: pathPosix.join(WORKSPACE_ROOT, logicalPath),
-        });
-    }
-}
+import{join,posix}from"node:path";import{readFile,readdir}from"node:fs/promises";import{WORKSPACE_ROOT}from"#runtime/workspace/types.js";async function materializeWorkspaceDirectory(e){let t=[];return await addMaterializedDirectoryFiles({files:t,logicalDirectoryPath:`.`,sourceDirectoryPath:e}),t.sort((e,t)=>e.path.localeCompare(t.path)),t}async function addMaterializedDirectoryFiles(r){let i=await readdir(r.sourceDirectoryPath,{withFileTypes:!0});for(let n of i){if(!n.isDirectory()&&!n.isFile())continue;let i=join(r.sourceDirectoryPath,n.name),a=posix.join(r.logicalDirectoryPath,n.name);if(n.isDirectory()){await addMaterializedDirectoryFiles({files:r.files,logicalDirectoryPath:a,sourceDirectoryPath:i});continue}r.files.push({content:await readFile(i),path:posix.join(WORKSPACE_ROOT,a)})}}export{materializeWorkspaceDirectory};

package/dist/src/runtime/workspace/spec.js

@@ -1,22 +1,2 @@
-import { WORKSPACE_ROOT } from "#runtime/workspace/types.js";
-/**
- * Creates the authored-workspace prompt section that advertises the authored
- * paths visible at the workspace root.
- */
-export function createWorkspacePromptSection(spec) {
-    if (spec.rootEntries.length === 0) {
-        return undefined;
-    }
-    const lines = [
-        "Workspace",
-        "- You have access to authored files mounted at the workspace root for this run.",
-        `- The live workspace root visible to \`bash\` in this run is \`${WORKSPACE_ROOT}\`.`,
-        `- Root entries under ${WORKSPACE_ROOT}/:`,
-        ...spec.rootEntries.map((entry) => `  - ${entry}`),
-        `- Treat \`${WORKSPACE_ROOT}\` as the workspace root for this run unless a \`bash\` call shows otherwise.`,
-        "- For questions about workspace paths or file availability, verify with `bash` first using commands like `pwd`, `ls`, and `find`.",
-        "- Use the `bash` tool with `ls`, `find`, and `rg` to inspect deeper contents when needed.",
-        "- Do not claim these files are unavailable unless a workspace or tool call actually fails.",
-    ];
-    return lines.join("\n");
-}
+import{WORKSPACE_ROOT}from"#runtime/workspace/types.js";function createWorkspacePromptSection(t){return t.rootEntries.length===0?void 0:[`Workspace`,`- You have access to authored files mounted at the workspace root for this run.`,`- The live workspace root visible to \`bash\` in this run is \`${WORKSPACE_ROOT}\`.`,`- Root entries under ${WORKSPACE_ROOT}/:`,...t.rootEntries.map(e=>`  - ${e}`),`- Treat \`${WORKSPACE_ROOT}\` as the workspace root for this run unless a \`bash\` call shows otherwise.`,"- For questions about workspace paths or file availability, verify with `bash` first using commands like `pwd`, `ls`, and `find`.","- Use the `bash` tool with `ls`, `find`, and `rg` to inspect deeper contents when needed.",`- Do not claim these files are unavailable unless a workspace or tool call actually fails.`].join(`
+`)}export{createWorkspacePromptSection};

package/dist/src/runtime/workspace/types.js

@@ -1,9 +1 @@
-/**
- * Stable root directory for every workspace Ash exposes to agents and
- * sandbox backends.
- *
- * This is both the model-facing logical path and the live `bash` cwd
- * for every backend. Backends must initialize their filesystems so
- * commands run at this path; there is no per-backend translation.
- */
-export const WORKSPACE_ROOT = "/workspace";
+var WORKSPACE_ROOT=`/workspace`;export{WORKSPACE_ROOT};

package/dist/src/sandbox/state.js

@@ -1 +1 @@
-export {};
+export{};