experimental-ash 0.25.2 → 0.27.0

package/dist/src/compiler/normalize-subagent.js

@@ -1,174 +1 @@
-import { createPathDerivedSourceId, } from "#discover/manifest.js";
-import { createCompiledSubagentNodeId, } from "#compiler/manifest.js";
-import { loadModuleBackedDefinition, } from "#compiler/normalize-helpers.js";
-import { expectObjectRecord, expectOnlyKnownKeys, expectString, } from "#internal/authored-module.js";
-import { ASH_CREATE_SESSION_ROUTE_PATH } from "#protocol/routes.js";
-/**
- * Compiles every local subagent reachable from one parent node into a
- * flat node list and the parent→child edges that connect them.
- *
- * Recursive: each subagent may itself declare further subagents, which
- * are compiled depth-first via the injected `compileAgentNodeManifest`
- * callback.
- */
-export async function compileSubagentGraph(input) {
-    const compiledNodes = [];
-    const compiledEdges = [];
-    const compiledRemoteAgents = [];
-    for (const subagentSource of input.subagents) {
-        const compiledSubagent = await compileSubagentDefinition({
-            appRoot: input.appRoot,
-            compileAgentNodeManifest: input.compileAgentNodeManifest,
-            context: input.context,
-            parentNodeId: input.parentNodeId,
-            source: subagentSource,
-        });
-        if (compiledSubagent.kind === "remote") {
-            compiledRemoteAgents.push(compiledSubagent.node);
-            continue;
-        }
-        compiledNodes.push(compiledSubagent.node, ...compiledSubagent.descendants.nodes);
-        compiledEdges.push({
-            childNodeId: compiledSubagent.node.nodeId,
-            parentNodeId: input.parentNodeId,
-        }, ...compiledSubagent.descendants.edges);
-    }
-    return {
-        edges: compiledEdges,
-        nodes: compiledNodes,
-        remoteAgents: compiledRemoteAgents,
-    };
-}
-async function compileSubagentDefinition(input) {
-    const configModule = input.source.manifest.configModule;
-    if (configModule === undefined) {
-        throw new Error(`Subagent "${input.source.logicalPath}" is missing an agent config module.`);
-    }
-    const definition = await loadModuleBackedDefinition({
-        agentRoot: input.source.manifest.agentRoot,
-        kind: "subagent config",
-        source: configModule,
-    });
-    if (readAgentDefinitionKind(definition) === "remote") {
-        return {
-            kind: "remote",
-            node: compileRemoteAgent({
-                source: input.source,
-                value: definition,
-            }),
-        };
-    }
-    return {
-        kind: "local",
-        ...(await compileLocalSubagent(input)),
-    };
-}
-async function compileSubagent(input) {
-    const nodeId = createCompiledSubagentNodeId(input.parentNodeId, input.source.sourceId);
-    const subagentName = input.source.subagentId;
-    const agent = await input.compileAgentNodeManifest({
-        ...input.source.manifest,
-        appRoot: input.appRoot,
-    }, input.context);
-    const description = agent.config.description;
-    if (!description) {
-        throw new Error(`Local subagent "${input.source.logicalPath}" is missing a "description" field on its agent config. Add \`description\` to \`defineAgent({ ... })\` so the parent agent can decide when to delegate to this subagent.`);
-    }
-    const descendants = await compileSubagentGraph({
-        appRoot: input.appRoot,
-        compileAgentNodeManifest: input.compileAgentNodeManifest,
-        context: input.context,
-        parentNodeId: nodeId,
-        subagents: input.source.manifest.subagents,
-    });
-    return {
-        descendants,
-        node: {
-            agent: {
-                ...agent,
-                remoteAgents: [...descendants.remoteAgents],
-            },
-            description,
-            entryPath: input.source.entryPath,
-            logicalPath: input.source.logicalPath,
-            name: subagentName,
-            nodeId,
-            rootPath: input.source.rootPath,
-            sourceId: input.source.sourceId,
-            sourceKind: "module",
-        },
-    };
-}
-const compileLocalSubagent = compileSubagent;
-function compileRemoteAgent(input) {
-    const configModule = input.source.manifest.configModule;
-    if (configModule === undefined) {
-        throw new Error(`Remote agent "${input.source.logicalPath}" is missing a config module.`);
-    }
-    assertRemoteAgentDefinitionHasNoLocalPackageEntries(input.source);
-    const definition = normalizeRemoteAgentDefinition(input.value, `Expected the remote agent config export "${configModule.exportName ?? "default"}" from "${configModule.logicalPath}" to match the public Ash shape.`);
-    const moduleSource = createRemoteAgentModuleSourceRef(input.source, configModule);
-    return {
-        ...moduleSource,
-        description: definition.description,
-        entryPath: input.source.entryPath,
-        name: input.source.subagentId,
-        nodeId: input.source.sourceId,
-        path: definition.path,
-        rootPath: input.source.rootPath,
-        url: definition.url,
-    };
-}
-function createRemoteAgentModuleSourceRef(source, configModule) {
-    const logicalPath = source.logicalPath === configModule.logicalPath
-        ? configModule.logicalPath
-        : `${source.logicalPath}/${configModule.logicalPath}`;
-    const moduleSource = {
-        logicalPath,
-        sourceId: createPathDerivedSourceId(logicalPath),
-        sourceKind: "module",
-    };
-    if (configModule.exportName !== undefined) {
-        moduleSource.exportName = configModule.exportName;
-    }
-    return moduleSource;
-}
-function readAgentDefinitionKind(value) {
-    if (value === null || typeof value !== "object") {
-        return "local";
-    }
-    return value.kind === "remote" ? "remote" : "local";
-}
-function normalizeRemoteAgentDefinition(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, ["auth", "description", "headers", "kind", "path", "url"], message);
-    if (record.kind !== "remote") {
-        throw new Error(`${message} Expected "kind" to be "remote".`);
-    }
-    return {
-        description: expectString(record.description, message),
-        path: record.path === undefined
-            ? ASH_CREATE_SESSION_ROUTE_PATH
-            : expectString(record.path, message),
-        url: expectString(record.url, message),
-    };
-}
-function assertRemoteAgentDefinitionHasNoLocalPackageEntries(source) {
-    const manifest = source.manifest;
-    const extraEntries = [
-        manifest.connections.length > 0 ? "connections/" : undefined,
-        manifest.hooks.length > 0 ? "hooks/" : undefined,
-        manifest.instructions !== undefined ? "instructions" : undefined,
-        manifest.lib.length > 0 ? "lib/" : undefined,
-        manifest.sandbox !== null ? "sandbox/" : undefined,
-        manifest.sandboxWorkspaces.length > 0 ? "sandbox/workspace/" : undefined,
-        manifest.schedules.length > 0 ? "schedules/" : undefined,
-        manifest.skills.length > 0 ? "skills/" : undefined,
-        manifest.subagents.length > 0 ? "subagents/" : undefined,
-        manifest.tools.length > 0 ? "tools/" : undefined,
-    ].filter((entry) => entry !== undefined);
-    if (extraEntries.length === 0) {
-        return;
-    }
-    throw new Error(`Remote subagent definition "${source.logicalPath}" cannot include local package entries. Remove unsupported entries: ${extraEntries.join(", ")}.`);
-}
+import{expectObjectRecord,expectOnlyKnownKeys,expectString}from"#internal/authored-module.js";import{ASH_CREATE_SESSION_ROUTE_PATH}from"#protocol/routes.js";import{createCompiledSubagentNodeId}from"#compiler/manifest.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{createPathDerivedSourceId}from"#discover/manifest.js";async function compileSubagentGraph(e){let t=[],n=[],r=[];for(let i of e.subagents){let a=await compileSubagentDefinition({appRoot:e.appRoot,compileAgentNodeManifest:e.compileAgentNodeManifest,context:e.context,parentNodeId:e.parentNodeId,source:i});if(a.kind===`remote`){r.push(a.node);continue}t.push(a.node,...a.descendants.nodes),n.push({childNodeId:a.node.nodeId,parentNodeId:e.parentNodeId},...a.descendants.edges)}return{edges:n,nodes:t,remoteAgents:r}}async function compileSubagentDefinition(e){let t=e.source.manifest.configModule;if(t===void 0)throw Error(`Subagent "${e.source.logicalPath}" is missing an agent config module.`);let n=await loadModuleBackedDefinition({agentRoot:e.source.manifest.agentRoot,kind:`subagent config`,source:t});return readAgentDefinitionKind(n)===`remote`?{kind:`remote`,node:compileRemoteAgent({source:e.source,value:n})}:{kind:`local`,...await compileLocalSubagent(e)}}async function compileSubagent(e){let t=createCompiledSubagentNodeId(e.parentNodeId,e.source.sourceId),n=e.source.subagentId,r=await e.compileAgentNodeManifest({...e.source.manifest,appRoot:e.appRoot},e.context),a=r.config.description;if(!a)throw Error(`Local subagent "${e.source.logicalPath}" is missing a "description" field on its agent config. Add \`description\` to \`defineAgent({ ... })\` so the parent agent can decide when to delegate to this subagent.`);let o=await compileSubagentGraph({appRoot:e.appRoot,compileAgentNodeManifest:e.compileAgentNodeManifest,context:e.context,parentNodeId:t,subagents:e.source.manifest.subagents});return{descendants:o,node:{agent:{...r,remoteAgents:[...o.remoteAgents]},description:a,entryPath:e.source.entryPath,logicalPath:e.source.logicalPath,name:n,nodeId:t,rootPath:e.source.rootPath,sourceId:e.source.sourceId,sourceKind:`module`}}}var compileLocalSubagent=compileSubagent;function compileRemoteAgent(e){let t=e.source.manifest.configModule;if(t===void 0)throw Error(`Remote agent "${e.source.logicalPath}" is missing a config module.`);assertRemoteAgentDefinitionHasNoLocalPackageEntries(e.source);let n=normalizeRemoteAgentDefinition(e.value,`Expected the remote agent config export "${t.exportName??`default`}" from "${t.logicalPath}" to match the public Ash shape.`);return{...createRemoteAgentModuleSourceRef(e.source,t),description:n.description,entryPath:e.source.entryPath,name:e.source.subagentId,nodeId:e.source.sourceId,path:n.path,rootPath:e.source.rootPath,url:n.url}}function createRemoteAgentModuleSourceRef(e,t){let n=e.logicalPath===t.logicalPath?t.logicalPath:`${e.logicalPath}/${t.logicalPath}`,r={logicalPath:n,sourceId:createPathDerivedSourceId(n),sourceKind:`module`};return t.exportName!==void 0&&(r.exportName=t.exportName),r}function readAgentDefinitionKind(e){return typeof e!=`object`||!e?`local`:e.kind===`remote`?`remote`:`local`}function normalizeRemoteAgentDefinition(i,a){let o=expectObjectRecord(i,a);if(expectOnlyKnownKeys(o,[`auth`,`description`,`headers`,`kind`,`path`,`url`],a),o.kind!==`remote`)throw Error(`${a} Expected "kind" to be "remote".`);return{description:expectString(o.description,a),path:o.path===void 0?ASH_CREATE_SESSION_ROUTE_PATH:expectString(o.path,a),url:expectString(o.url,a)}}function assertRemoteAgentDefinitionHasNoLocalPackageEntries(e){let t=e.manifest,n=[t.connections.length>0?`connections/`:void 0,t.hooks.length>0?`hooks/`:void 0,t.instructions===void 0?void 0:`instructions`,t.lib.length>0?`lib/`:void 0,t.sandbox===null?void 0:`sandbox/`,t.sandboxWorkspaces.length>0?`sandbox/workspace/`:void 0,t.schedules.length>0?`schedules/`:void 0,t.skills.length>0?`skills/`:void 0,t.subagents.length>0?`subagents/`:void 0,t.tools.length>0?`tools/`:void 0].filter(e=>e!==void 0);if(n.length!==0)throw Error(`Remote subagent definition "${e.logicalPath}" cannot include local package entries. Remove unsupported entries: ${n.join(`, `)}.`)}export{compileSubagentGraph};

package/dist/src/compiler/normalize-tool.js

@@ -1,40 +1 @@
-import { stripLogicalPathExtension } from "#discover/filesystem.js";
-import { normalizeToolDefinition } from "#internal/authored-definition/schema-backed.js";
-import { loadModuleBackedDefinition } from "#compiler/normalize-helpers.js";
-/**
- * Compiles one authored tool module into the normalized tool entry
- * stored on the compiled agent manifest.
- *
- * The tool name is derived from the file path under `tools/` with the
- * extension stripped and any path separators flattened to dashes
- * (e.g. `tools/billing/refund.ts` → `"billing-refund"`). Path separators
- * cannot reach the model — most providers reject `/` in tool names — so
- * tools are the one path-derived primitive that flattens nested
- * directories into a slug-safe single segment. Authored `name` fields
- * are rejected by the normalizer.
- */
-export async function compileToolEntry(agentRoot, source) {
-    const entry = normalizeToolDefinition(await loadModuleBackedDefinition({
-        agentRoot,
-        kind: "tool",
-        source,
-    }), `Expected the tool export "${source.exportName ?? "default"}" from "${source.logicalPath}" to match the public Ash shape.`);
-    const toolName = stripLogicalPathExtension(source.logicalPath)
-        .replace(/^tools\//, "")
-        .replaceAll("/", "-");
-    if (entry.kind === "disabled") {
-        return { kind: "disabled", name: toolName };
-    }
-    return {
-        kind: "tool",
-        definition: {
-            description: entry.definition.description,
-            exportName: source.exportName,
-            inputSchema: entry.definition.inputSchema ?? null,
-            logicalPath: source.logicalPath,
-            name: toolName,
-            sourceId: source.sourceId,
-            sourceKind: "module",
-        },
-    };
-}
+import{stripLogicalPathExtension}from"#discover/filesystem.js";import{loadModuleBackedDefinition}from"#compiler/normalize-helpers.js";import{normalizeToolDefinition}from"#internal/authored-definition/schema-backed.js";async function compileToolEntry(e,t){let n=normalizeToolDefinition(await loadModuleBackedDefinition({agentRoot:e,kind:`tool`,source:t}),`Expected the tool export "${t.exportName??`default`}" from "${t.logicalPath}" to match the public Ash shape.`),r=stripLogicalPathExtension(t.logicalPath).replace(/^tools\//,``).replaceAll(`/`,`-`);return n.kind===`disabled`?{kind:`disabled`,name:r}:{kind:`tool`,definition:{description:n.definition.description,exportName:t.exportName,inputSchema:n.definition.inputSchema??null,logicalPath:t.logicalPath,name:r,sourceId:t.sourceId,sourceKind:`module`}}}export{compileToolEntry};

package/dist/src/compiler/remote-agent-node.js

@@ -1,19 +1 @@
-import { z } from "#compiled/zod/index.js";
-/**
- * Zod schema for one compiled remote subagent entry.
- */
-export const compiledRemoteAgentNodeSchema = z
-    .object({
-    description: z.string(),
-    entryPath: z.string(),
-    exportName: z.string().optional(),
-    logicalPath: z.string(),
-    name: z.string(),
-    nodeId: z.string(),
-    path: z.string(),
-    rootPath: z.string(),
-    sourceId: z.string(),
-    sourceKind: z.literal("module"),
-    url: z.string(),
-})
-    .strict();
+import{z}from"#compiled/zod/index.js";var compiledRemoteAgentNodeSchema=z.object({description:z.string(),entryPath:z.string(),exportName:z.string().optional(),logicalPath:z.string(),name:z.string(),nodeId:z.string(),path:z.string(),rootPath:z.string(),sourceId:z.string(),sourceKind:z.literal(`module`),url:z.string()}).strict();export{compiledRemoteAgentNodeSchema};

package/dist/src/compiler/workspace-resources.js

@@ -1,85 +1 @@
-import { cp, mkdir, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { deriveResourceRootEntries, ROOT_COMPILED_AGENT_NODE_ID } from "#compiler/manifest.js";
-import { normalizeLogicalPath } from "#discover/filesystem.js";
-import { normalizeSkillPackage, writeSkillPackageDirectory } from "#shared/skill-package.js";
-const RESOURCES_DIRECTORY = "workspace-resources";
-/**
- * Materializes the per-node workspace resource trees under
- * `.ash/compile/workspace-resources/` and returns a manifest whose node
- * descriptors point at the freshly-written directories.
- *
- * Idempotent against an existing compile run: the resources directory
- * is removed before each invocation so a re-compile produces a clean
- * tree.
- */
-export async function materializeWorkspaceResources(input) {
-    const resourcesRoot = join(input.compileDirectoryPath, RESOURCES_DIRECTORY);
-    await rm(resourcesRoot, { force: true, recursive: true });
-    const rootAgent = await materializeNode({
-        nodeId: ROOT_COMPILED_AGENT_NODE_ID,
-        resourcesRoot,
-        manifest: input.manifest,
-    });
-    const subagents = await Promise.all(input.manifest.subagents.map(async (subagent) => ({
-        ...subagent,
-        agent: await materializeNode({
-            nodeId: subagent.nodeId,
-            resourcesRoot,
-            manifest: subagent.agent,
-        }),
-    })));
-    return {
-        ...rootAgent,
-        kind: input.manifest.kind,
-        subagentEdges: input.manifest.subagentEdges,
-        subagents,
-        version: input.manifest.version,
-    };
-}
-function createResourceRoot(manifest, nodeId) {
-    return {
-        logicalPath: normalizeLogicalPath(join(RESOURCES_DIRECTORY, nodeId)),
-        rootEntries: deriveResourceRootEntries({
-            sandboxWorkspaces: manifest.sandboxWorkspaces,
-            skills: manifest.skills,
-        }),
-    };
-}
-async function materializeNode(input) {
-    // Validate up-front so a `skills/`-shadowing workspace doesn't leave
-    // partial output behind from earlier workspaces in the same node.
-    for (const workspace of input.manifest.sandboxWorkspaces) {
-        if (workspace.rootEntries.some((entry) => entry === "skills/" || entry === "skills")) {
-            throw new Error(`Sandbox workspace "${workspace.logicalPath}" cannot define "skills" because Ash manages that workspace entry.`);
-        }
-    }
-    const nodeRoot = join(input.resourcesRoot, input.nodeId);
-    await mkdir(nodeRoot, { recursive: true });
-    for (const workspace of input.manifest.sandboxWorkspaces) {
-        await cp(workspace.sourcePath, nodeRoot, { recursive: true });
-    }
-    for (const skill of input.manifest.skills) {
-        await materializeSkill({ nodeRoot, skill });
-    }
-    return {
-        ...input.manifest,
-        skills: input.manifest.skills.map(stripSkillPackageFiles),
-        workspaceResourceRoot: createResourceRoot(input.manifest, input.nodeId),
-    };
-}
-async function materializeSkill(input) {
-    const skillRoot = join(input.nodeRoot, "skills", input.skill.name);
-    if (input.skill.sourceKind === "skill-package") {
-        await cp(input.skill.rootPath, skillRoot, { recursive: true });
-        return;
-    }
-    await writeSkillPackageDirectory({
-        rootPath: input.nodeRoot,
-        skill: normalizeSkillPackage(input.skill),
-    });
-}
-function stripSkillPackageFiles(skill) {
-    const { files: _files, ...manifestSkill } = skill;
-    return manifestSkill;
-}
+import{join}from"node:path";import{cp,mkdir,rm}from"node:fs/promises";import{normalizeLogicalPath}from"#discover/filesystem.js";import{ROOT_COMPILED_AGENT_NODE_ID,deriveResourceRootEntries}from"#compiler/manifest.js";import{normalizeSkillPackage,writeSkillPackageDirectory}from"#shared/skill-package.js";var RESOURCES_DIRECTORY=`workspace-resources`;async function materializeWorkspaceResources(t){let n=join(t.compileDirectoryPath,RESOURCES_DIRECTORY);await rm(n,{force:!0,recursive:!0});let i=await materializeNode({nodeId:ROOT_COMPILED_AGENT_NODE_ID,resourcesRoot:n,manifest:t.manifest}),a=await Promise.all(t.manifest.subagents.map(async e=>({...e,agent:await materializeNode({nodeId:e.nodeId,resourcesRoot:n,manifest:e.agent})})));return{...i,kind:t.manifest.kind,subagentEdges:t.manifest.subagentEdges,subagents:a,version:t.manifest.version}}function createResourceRoot(t,n){return{logicalPath:normalizeLogicalPath(join(RESOURCES_DIRECTORY,n)),rootEntries:deriveResourceRootEntries({sandboxWorkspaces:t.sandboxWorkspaces,skills:t.skills})}}async function materializeNode(r){for(let e of r.manifest.sandboxWorkspaces)if(e.rootEntries.some(e=>e===`skills/`||e===`skills`))throw Error(`Sandbox workspace "${e.logicalPath}" cannot define "skills" because Ash manages that workspace entry.`);let i=join(r.resourcesRoot,r.nodeId);await mkdir(i,{recursive:!0});for(let e of r.manifest.sandboxWorkspaces)await cp(e.sourcePath,i,{recursive:!0});for(let e of r.manifest.skills)await materializeSkill({nodeRoot:i,skill:e});return{...r.manifest,skills:r.manifest.skills.map(stripSkillPackageFiles),workspaceResourceRoot:createResourceRoot(r.manifest,r.nodeId)}}async function materializeSkill(n){let r=join(n.nodeRoot,`skills`,n.skill.name);if(n.skill.sourceKind===`skill-package`){await cp(n.skill.rootPath,r,{recursive:!0});return}await writeSkillPackageDirectory({rootPath:n.nodeRoot,skill:normalizeSkillPackage(n.skill)})}function stripSkillPackageFiles(e){let{files:t,...n}=e;return n}export{materializeWorkspaceResources};

package/dist/src/context/accessors.js

@@ -1,93 +1 @@
-import { createSandboxSkillHandle } from "#runtime/skills/sandbox-access.js";
-import { loadContext } from "#context/container.js";
-import { SandboxKey, SessionKey } from "#context/keys.js";
-/**
- * Returns the active session for the current authored async execution chain.
- *
- * @throws When called outside of a managed step execution.
- */
-export function getSession() {
-    return loadContext().require(SessionKey);
-}
-/**
- * Returns the active sandbox session for the current runtime execution.
- *
- * Each agent owns exactly one sandbox; callers do not pass a name.
- *
- * @throws When called outside of a managed step execution or when the
- *   sandbox is not available on the current context.
- */
-export async function getSandbox() {
-    const access = loadContext().get(SandboxKey);
-    if (access === undefined) {
-        throw new Error("Ash sandbox runtime access is unavailable in the current async context. " +
-            "Call getSandbox() only from authored runtime functions such as tools, steps, and model callbacks.");
-    }
-    const sandbox = await access.get();
-    if (sandbox === null) {
-        throw new Error("The sandbox is not available in the current authored runtime context.");
-    }
-    return sandbox;
-}
-/**
- * Returns the current value of a context key, or `undefined` when unset.
- *
- * @throws When called outside of a managed step execution.
- */
-export function getContext(key) {
-    return loadContext().get(key);
-}
-/**
- * Returns the current value of a context key, throwing when unset.
- *
- * @throws When the key is not set or when called outside of a managed
- *   step execution.
- */
-export function requireContext(key) {
-    return loadContext().require(key);
-}
-/**
- * Returns whether the key is currently set in the active context.
- *
- * @throws When called outside of a managed step execution.
- */
-export function hasContext(key) {
-    return loadContext().has(key);
-}
-/**
- * Sets the durable value of a context key in the active context.
- *
- * Accepts either a direct value or an updater function that receives the
- * current value (or `undefined` if unset) and returns the next value.
- *
- * The new durable value is serialized at the end of the step and survives
- * future workflow steps and turns.
- *
- * @throws When called outside of a managed step execution.
- */
-export function setContext(key, valueOrUpdater) {
-    return loadContext().set(key, valueOrUpdater);
-}
-/**
- * Returns the current value of a context key or initializes and stores a
- * durable value when the key is unset.
- *
- * @throws When called outside of a managed step execution.
- */
-export function ensureContext(key, create) {
-    return loadContext().ensure(key, create);
-}
-/**
- * Returns a handle for the named skill visible to the current agent.
- *
- * @throws When called outside of a managed step execution or when the
- *   requested skill is not found.
- */
-export function getSkill(identifier) {
-    const access = loadContext().get(SandboxKey);
-    if (access === undefined) {
-        throw new Error("Ash sandbox runtime access is unavailable in the current async context. " +
-            "Call getSkill() only from authored runtime functions such as tools, steps, and model callbacks.");
-    }
-    return createSandboxSkillHandle(access, identifier);
-}
+import{createSandboxSkillHandle}from"#runtime/skills/sandbox-access.js";import{loadContext}from"#context/container.js";import{SandboxKey,SessionKey}from"#context/keys.js";function getSession(){return loadContext().require(SessionKey)}async function getSandbox(){let e=loadContext().get(SandboxKey);if(e===void 0)throw Error(`Ash sandbox runtime access is unavailable in the current async context. Call getSandbox() only from authored runtime functions such as tools, steps, and model callbacks.`);let n=await e.get();if(n===null)throw Error(`The sandbox is not available in the current authored runtime context.`);return n}function getContext(e){return loadContext().get(e)}function requireContext(e){return loadContext().require(e)}function hasContext(e){return loadContext().has(e)}function setContext(e,t){return loadContext().set(e,t)}function ensureContext(e,t){return loadContext().ensure(e,t)}function getSkill(n){let r=loadContext().get(SandboxKey);if(r===void 0)throw Error(`Ash sandbox runtime access is unavailable in the current async context. Call getSkill() only from authored runtime functions such as tools, steps, and model callbacks.`);return createSandboxSkillHandle(r,n)}export{ensureContext,getContext,getSandbox,getSession,getSkill,hasContext,requireContext,setContext};

package/dist/src/context/container.js

@@ -1,89 +1 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { resolveKey } from "#context/key.js";
-const ASH_CONTEXT_STORAGE_KEY = Symbol.for("experimental-ash.context-storage");
-/**
- * Default mutable implementation of {@link AshContext}.
- */
-export class ContextContainer {
-    _durableValues = new Map();
-    _virtualValues = new Map();
-    get(key) {
-        if (this._virtualValues.has(key.name)) {
-            return this._virtualValues.get(key.name);
-        }
-        return this._durableValues.get(key.name);
-    }
-    require(key) {
-        if (!this.has(key)) {
-            throw new Error(`Context key "${key.name}" is not set.`);
-        }
-        return this.get(key);
-    }
-    has(key) {
-        return this._virtualValues.has(key.name) || this._durableValues.has(key.name);
-    }
-    set(key, valueOrUpdater) {
-        const value = typeof valueOrUpdater === "function"
-            ? valueOrUpdater(this.get(key))
-            : valueOrUpdater;
-        this._durableValues.set(key.name, value);
-        return value;
-    }
-    ensure(key, create) {
-        if (this.has(key)) {
-            return this.require(key);
-        }
-        return this.set(key, create());
-    }
-    /**
-     * Clears all step-local provider values from the context.
-     *
-     * The runtime calls this before rebuilding context providers for a new
-     * step.
-     */
-    clearVirtualContext() {
-        this._virtualValues.clear();
-    }
-    /**
-     * Stores a step-local provider value for one key.
-     *
-     * Virtual values shadow durable values for the lifetime of the current
-     * step and are excluded from serialization.
-     */
-    setVirtualContext(key, value) {
-        this._virtualValues.set(key.name, value);
-    }
-    *entries() {
-        for (const [name, value] of this._durableValues) {
-            const key = resolveKey(name);
-            if (key !== undefined) {
-                yield [key, value];
-            }
-        }
-    }
-}
-const globalContextStorage = globalThis;
-if (globalContextStorage[ASH_CONTEXT_STORAGE_KEY] === undefined) {
-    globalContextStorage[ASH_CONTEXT_STORAGE_KEY] = new AsyncLocalStorage();
-}
-/**
- * Process-wide AsyncLocalStorage used by every Ash module copy in the current
- * runtime.
- *
- * Nitro step bundles can inline parts of Ash while authored modules still
- * import `experimental-ash/*` from disk. Backing the storage with a global
- * symbol keeps those copies on the same ALS instance so authored tools,
- * model callbacks, and step code observe one unified Ash context.
- */
-export const contextStorage = globalContextStorage[ASH_CONTEXT_STORAGE_KEY];
-/**
- * Returns the active context, throwing when called outside a managed scope.
- */
-export function loadContext() {
-    const ctx = contextStorage.getStore();
-    if (ctx === undefined) {
-        throw new Error("No active Ash context. " +
-            "Call this function only from authored runtime code such as tools, steps, and model callbacks.");
-    }
-    return ctx;
-}
+import{AsyncLocalStorage}from"node:async_hooks";import{resolveKey}from"#context/key.js";var ASH_CONTEXT_STORAGE_KEY=Symbol.for(`experimental-ash.context-storage`),ContextContainer=class{_durableValues=new Map;_virtualValues=new Map;get(e){return this._virtualValues.has(e.name)?this._virtualValues.get(e.name):this._durableValues.get(e.name)}require(e){if(!this.has(e))throw Error(`Context key "${e.name}" is not set.`);return this.get(e)}has(e){return this._virtualValues.has(e.name)||this._durableValues.has(e.name)}set(e,t){let n=typeof t==`function`?t(this.get(e)):t;return this._durableValues.set(e.name,n),n}ensure(e,t){return this.has(e)?this.require(e):this.set(e,t())}clearVirtualContext(){this._virtualValues.clear()}setVirtualContext(e,t){this._virtualValues.set(e.name,t)}*entries(){for(let[e,n]of this._durableValues){let r=resolveKey(e);r!==void 0&&(yield[r,n])}}},globalContextStorage=globalThis;globalContextStorage[ASH_CONTEXT_STORAGE_KEY]===void 0&&(globalContextStorage[ASH_CONTEXT_STORAGE_KEY]=new AsyncLocalStorage);var contextStorage=globalContextStorage[ASH_CONTEXT_STORAGE_KEY];function loadContext(){let e=contextStorage.getStore();if(e===void 0)throw Error(`No active Ash context. Call this function only from authored runtime code such as tools, steps, and model callbacks.`);return e}export{ContextContainer,contextStorage,loadContext};