experimental-ash 0.25.2 → 0.27.0

package/dist/src/runtime/resolve-connection.js

@@ -1,72 +1 @@
-import { expectObjectRecord } from "#internal/authored-module.js";
-import { registerDefinitionSource } from "#public/tool-result-narrowing.js";
-import { toErrorMessage } from "#shared/errors.js";
-import { normalizeAuthorizationSpec } from "#runtime/connections/validate-authorization.js";
-import { loadResolvedModuleExport, ResolveAgentError } from "#runtime/resolve-helpers.js";
-/**
- * Resolves one compiled connection entry into a runtime-owned definition
- * with the live `auth`, `headers`, and `tools` objects attached
- * from the authored module.
- *
- * The compiled manifest only stores serializable metadata (`url`,
- * `description`, `connectionName`). Live values (`auth`,
- * `headers`, `tools`) are resolved at runtime by re-importing the
- * authored module so they can reference ambient state (environment
- * variables, `AshContext`, etc.).
- */
-export async function resolveConnectionDefinition(definition, moduleMap, nodeId) {
-    try {
-        const resolvedExportValue = await loadResolvedModuleExport({
-            definition,
-            kindLabel: "connection",
-            moduleMap,
-            nodeId,
-        });
-        const resolvedRecord = expectObjectRecord(resolvedExportValue, `Expected the connection export "${definition.exportName ?? "default"}" from "${definition.logicalPath}" to return an object.`);
-        registerDefinitionSource(`connection:${resolvedRecord.url}`, {
-            kind: "connection",
-            name: definition.connectionName,
-        });
-        const hasAuth = resolvedRecord.auth !== undefined;
-        const hasHeaders = resolvedRecord.headers !== undefined;
-        const result = {
-            connectionName: definition.connectionName,
-            description: definition.description,
-            exportName: definition.exportName,
-            logicalPath: definition.logicalPath,
-            sourceId: definition.sourceId,
-            sourceKind: "module",
-            url: definition.url,
-        };
-        if (hasAuth) {
-            try {
-                result.authorization = normalizeAuthorizationSpec(resolvedRecord.auth, `Connection "${definition.connectionName}" at "${definition.logicalPath}":`);
-            }
-            catch (error) {
-                throw new ResolveAgentError(toErrorMessage(error), {
-                    logicalPath: definition.logicalPath,
-                    sourceId: definition.sourceId,
-                });
-            }
-        }
-        if (hasHeaders) {
-            result.headers = resolvedRecord.headers;
-        }
-        if (resolvedRecord.tools !== undefined) {
-            result.tools = resolvedRecord.tools;
-        }
-        if (typeof resolvedRecord.approval === "function") {
-            result.approval = resolvedRecord.approval;
-        }
-        return result;
-    }
-    catch (error) {
-        if (error instanceof ResolveAgentError) {
-            throw error;
-        }
-        throw new ResolveAgentError(`Failed to resolve connection "${definition.connectionName}" from "${definition.logicalPath}": ${toErrorMessage(error)}`, {
-            logicalPath: definition.logicalPath,
-            sourceId: definition.sourceId,
-        });
-    }
-}
+import{expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{registerDefinitionSource}from"#public/tool-result-narrowing.js";async function resolveConnectionDefinition(t,n,r){try{let i=expectObjectRecord(await loadResolvedModuleExport({definition:t,kindLabel:`connection`,moduleMap:n,nodeId:r}),`Expected the connection export "${t.exportName??`default`}" from "${t.logicalPath}" to return an object.`);registerDefinitionSource(`connection:${i.url}`,{kind:`connection`,name:t.connectionName});let a=i.auth!==void 0,o=i.headers!==void 0,s={connectionName:t.connectionName,description:t.description,exportName:t.exportName,logicalPath:t.logicalPath,sourceId:t.sourceId,sourceKind:`module`,url:t.url};if(a)try{s.authorization=normalizeAuthorizationSpec(i.auth,`Connection "${t.connectionName}" at "${t.logicalPath}":`)}catch(e){throw new ResolveAgentError(toErrorMessage(e),{logicalPath:t.logicalPath,sourceId:t.sourceId})}return o&&(s.headers=i.headers),i.tools!==void 0&&(s.tools=i.tools),typeof i.approval==`function`&&(s.approval=i.approval),s}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to resolve connection "${t.connectionName}" from "${t.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:t.logicalPath,sourceId:t.sourceId})}}export{resolveConnectionDefinition};

package/dist/src/runtime/resolve-helpers.js

@@ -1,58 +1 @@
-import { ROOT_COMPILED_AGENT_NODE_ID } from "#compiler/manifest.js";
-import { expectObjectRecord, getAuthoredModuleExport, materializeAuthoredModuleExport, } from "#internal/authored-module.js";
-/**
- * Error raised when compiled artifacts cannot be hydrated into a runtime-owned
- * authored agent model.
- */
-export class ResolveAgentError extends Error {
-    logicalPath;
-    sourceId;
-    constructor(message, input = {}) {
-        super(message);
-        this.name = "ResolveAgentError";
-        if (input.logicalPath !== undefined) {
-            this.logicalPath = input.logicalPath;
-        }
-        if (input.sourceId !== undefined) {
-            this.sourceId = input.sourceId;
-        }
-    }
-}
-/**
- * Builds the resolved source ref block shared by every per-primitive
- * resolver that targets a `module` source.
- */
-export function createResolvedModuleSourceRef(sourceRef) {
-    return {
-        exportName: sourceRef.exportName,
-        logicalPath: sourceRef.logicalPath,
-        sourceId: sourceRef.sourceId,
-        sourceKind: "module",
-    };
-}
-/**
- * Looks up a compiled module namespace for one resolved agent node and
- * returns the materialized exported value referenced by the given
- * compiled definition.
- *
- * Throws {@link ResolveAgentError} when the module map does not contain
- * the expected source — every per-primitive resolver shares this
- * lookup, so the helper centralizes the error message and avoids
- * duplicating ~25 lines of boilerplate per resolver.
- */
-export async function loadResolvedModuleExport(input) {
-    const resolvedNodeId = input.nodeId ?? ROOT_COMPILED_AGENT_NODE_ID;
-    const moduleNamespace = input.moduleMap.nodes[resolvedNodeId]?.modules[input.definition.sourceId];
-    if (moduleNamespace === undefined) {
-        throw new ResolveAgentError(`Missing compiled module namespace for ${input.kindLabel} source "${input.definition.sourceId}" in node "${resolvedNodeId}".`, {
-            logicalPath: input.definition.logicalPath,
-            sourceId: input.definition.sourceId,
-        });
-    }
-    const moduleRecord = expectObjectRecord(moduleNamespace, `Missing compiled module namespace for ${input.kindLabel} source "${input.definition.sourceId}" in node "${resolvedNodeId}".`);
-    const exportValue = getAuthoredModuleExport(moduleRecord, {
-        exportName: input.definition.exportName,
-        logicalPath: input.definition.logicalPath,
-    });
-    return await materializeAuthoredModuleExport(exportValue);
-}
+import{expectObjectRecord,getAuthoredModuleExport,materializeAuthoredModuleExport}from"#internal/authored-module.js";import{ROOT_COMPILED_AGENT_NODE_ID}from"#compiler/manifest.js";var ResolveAgentError=class extends Error{logicalPath;sourceId;constructor(e,t={}){super(e),this.name=`ResolveAgentError`,t.logicalPath!==void 0&&(this.logicalPath=t.logicalPath),t.sourceId!==void 0&&(this.sourceId=t.sourceId)}};function createResolvedModuleSourceRef(e){return{exportName:e.exportName,logicalPath:e.logicalPath,sourceId:e.sourceId,sourceKind:`module`}}async function loadResolvedModuleExport(n){let r=n.nodeId??ROOT_COMPILED_AGENT_NODE_ID,i=n.moduleMap.nodes[r]?.modules[n.definition.sourceId];if(i===void 0)throw new ResolveAgentError(`Missing compiled module namespace for ${n.kindLabel} source "${n.definition.sourceId}" in node "${r}".`,{logicalPath:n.definition.logicalPath,sourceId:n.definition.sourceId});return await materializeAuthoredModuleExport(getAuthoredModuleExport(expectObjectRecord(i,`Missing compiled module namespace for ${n.kindLabel} source "${n.definition.sourceId}" in node "${r}".`),{exportName:n.definition.exportName,logicalPath:n.definition.logicalPath}))}export{ResolveAgentError,createResolvedModuleSourceRef,loadResolvedModuleExport};

package/dist/src/runtime/resolve-hook.js

@@ -1,67 +1 @@
-import { expectFunction, expectObjectRecord } from "../internal/authored-module.js";
-import { toErrorMessage } from "../shared/errors.js";
-import { loadResolvedModuleExport, ResolveAgentError } from "./resolve-helpers.js";
-/**
- * Resolves one compiled authored hook into a runtime-owned definition
- * with live handlers reattached from the authored module.
- *
- * The authored shape is `{ lifecycle?: { session?, turn? }, events?: { ... } }`.
- * Each declared handler must be a function. Any other shape raises a
- * {@link ResolveAgentError} so typos surface at resolve time instead of
- * at first lifecycle call.
- */
-export async function resolveHookDefinition(definition, moduleMap, nodeId) {
-    try {
-        const resolvedExportValue = await loadResolvedModuleExport({
-            definition,
-            kindLabel: "hook",
-            moduleMap,
-            nodeId,
-        });
-        const resolvedRecord = expectObjectRecord(resolvedExportValue, describe(definition, "to return an object"));
-        const lifecycle = {};
-        const events = {};
-        const lifecycleRaw = resolvedRecord.lifecycle;
-        if (lifecycleRaw !== undefined) {
-            const lifecycleRecord = expectObjectRecord(lifecycleRaw, describe(definition, "to expose `lifecycle` as an object"));
-            for (const key of ["session", "turn"]) {
-                const value = lifecycleRecord[key];
-                if (value === undefined)
-                    continue;
-                const handler = expectFunction(value, describe(definition, `to provide a function for "lifecycle.${key}"`));
-                lifecycle[key] = handler;
-            }
-        }
-        const eventsRaw = resolvedRecord.events;
-        if (eventsRaw !== undefined) {
-            const eventsRecord = expectObjectRecord(eventsRaw, describe(definition, "to expose `events` as an object"));
-            for (const [key, value] of Object.entries(eventsRecord)) {
-                if (value === undefined)
-                    continue;
-                const handler = expectFunction(value, describe(definition, `to provide a function for "events.${key}"`));
-                events[key] = handler;
-            }
-        }
-        return {
-            events,
-            exportName: definition.exportName,
-            lifecycle: lifecycle,
-            logicalPath: definition.logicalPath,
-            slug: definition.slug,
-            sourceId: definition.sourceId,
-            sourceKind: "module",
-        };
-    }
-    catch (error) {
-        if (error instanceof ResolveAgentError) {
-            throw error;
-        }
-        throw new ResolveAgentError(`Failed to attach hook handlers from "${definition.logicalPath}": ${toErrorMessage(error)}`, {
-            logicalPath: definition.logicalPath,
-            sourceId: definition.sourceId,
-        });
-    }
-}
-function describe(definition, predicate) {
-    return `Expected the hook export "${definition.exportName ?? "default"}" from "${definition.logicalPath}" ${predicate}.`;
-}
+import{toErrorMessage}from"../shared/errors.js";import{expectFunction,expectObjectRecord}from"../internal/authored-module.js";import{ResolveAgentError,loadResolvedModuleExport}from"./resolve-helpers.js";async function resolveHookDefinition(a,o,s){try{let e=expectObjectRecord(await loadResolvedModuleExport({definition:a,kindLabel:`hook`,moduleMap:o,nodeId:s}),describe(a,`to return an object`)),r={},c={},l=e.lifecycle;if(l!==void 0){let e=expectObjectRecord(l,describe(a,"to expose `lifecycle` as an object"));for(let n of[`session`,`turn`]){let i=e[n];i!==void 0&&(r[n]=expectFunction(i,describe(a,`to provide a function for "lifecycle.${n}"`)))}}let u=e.events;if(u!==void 0){let e=expectObjectRecord(u,describe(a,"to expose `events` as an object"));for(let[n,r]of Object.entries(e))r!==void 0&&(c[n]=expectFunction(r,describe(a,`to provide a function for "events.${n}"`)))}return{events:c,exportName:a.exportName,lifecycle:r,logicalPath:a.logicalPath,slug:a.slug,sourceId:a.sourceId,sourceKind:`module`}}catch(t){throw t instanceof ResolveAgentError?t:new ResolveAgentError(`Failed to attach hook handlers from "${a.logicalPath}": ${toErrorMessage(t)}`,{logicalPath:a.logicalPath,sourceId:a.sourceId})}}function describe(e,t){return`Expected the hook export "${e.exportName??`default`}" from "${e.logicalPath}" ${t}.`}export{resolveHookDefinition};

package/dist/src/runtime/resolve-sandbox.js

@@ -1,65 +1 @@
-import { lazyBackend } from "#execution/sandbox/lazy-backend.js";
-import { expectObjectRecord } from "#internal/authored-module.js";
-import { defaultBackend } from "#public/sandbox/backends/default.js";
-import { toErrorMessage } from "#shared/errors.js";
-import { loadResolvedModuleExport, ResolveAgentError } from "#runtime/resolve-helpers.js";
-/**
- * Resolves one compiled sandbox entry into a runtime-owned definition
- * with live `backend`, `bootstrap`, and `onSession` lifecycle handlers
- * (when present) attached from the authored module.
- *
- * If the authored module omits `backend`, the resolver substitutes
- * {@link defaultBackend} so the rest of the runtime can rely on a
- * non-null backend value.
- */
-export async function resolveSandboxDefinition(definition, moduleMap, nodeId) {
-    try {
-        const resolvedExportValue = await loadResolvedModuleExport({
-            definition,
-            kindLabel: "sandbox",
-            moduleMap,
-            nodeId,
-        });
-        const resolvedRecord = expectObjectRecord(resolvedExportValue, `Expected the sandbox export "${definition.exportName ?? "default"}" from "${definition.logicalPath}" to return an object.`);
-        const sandboxDefinition = resolvedRecord;
-        const backend = resolveBackend(sandboxDefinition.backend, definition.logicalPath);
-        return {
-            backend,
-            bootstrap: sandboxDefinition.bootstrap,
-            description: definition.description,
-            exportName: definition.exportName,
-            logicalPath: definition.logicalPath,
-            onSession: sandboxDefinition.onSession,
-            sourceId: definition.sourceId,
-            sourceKind: "module",
-        };
-    }
-    catch (error) {
-        if (error instanceof ResolveAgentError) {
-            throw error;
-        }
-        throw new ResolveAgentError(`Failed to attach the sandbox lifecycle handlers from "${definition.logicalPath}": ${toErrorMessage(error)}`, {
-            logicalPath: definition.logicalPath,
-            sourceId: definition.sourceId,
-        });
-    }
-}
-function resolveBackend(value, logicalPath) {
-    if (value === undefined) {
-        return defaultBackend();
-    }
-    if (typeof value === "function") {
-        return lazyBackend(value);
-    }
-    if (typeof value !== "object" || value === null) {
-        throw new ResolveAgentError(`Sandbox "${logicalPath}" exposed a non-object "backend" field. Use vercelBackend(), localBackend(), another factory that returns a SandboxBackend value, or a zero-arg callback returning one.`, { logicalPath });
-    }
-    const record = value;
-    if (typeof record.name !== "string" || record.name.length === 0) {
-        throw new ResolveAgentError(`Sandbox "${logicalPath}" backend is missing a non-empty string "name" identifier.`, { logicalPath });
-    }
-    if (typeof record.create !== "function") {
-        throw new ResolveAgentError(`Sandbox "${logicalPath}" backend is missing a "create" function.`, { logicalPath });
-    }
-    return record;
-}
+import{expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{lazyBackend}from"#execution/sandbox/lazy-backend.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{defaultBackend}from"#public/sandbox/backends/default.js";async function resolveSandboxDefinition(n,i,a){try{let t=expectObjectRecord(await loadResolvedModuleExport({definition:n,kindLabel:`sandbox`,moduleMap:i,nodeId:a}),`Expected the sandbox export "${n.exportName??`default`}" from "${n.logicalPath}" to return an object.`);return{backend:resolveBackend(t.backend,n.logicalPath),bootstrap:t.bootstrap,description:n.description,exportName:n.exportName,logicalPath:n.logicalPath,onSession:t.onSession,sourceId:n.sourceId,sourceKind:`module`}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to attach the sandbox lifecycle handlers from "${n.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:n.logicalPath,sourceId:n.sourceId})}}function resolveBackend(e,t){if(e===void 0)return defaultBackend();if(typeof e==`function`)return lazyBackend(e);if(typeof e!=`object`||!e)throw new ResolveAgentError(`Sandbox "${t}" exposed a non-object "backend" field. Use vercelBackend(), localBackend(), another factory that returns a SandboxBackend value, or a zero-arg callback returning one.`,{logicalPath:t});let r=e;if(typeof r.name!=`string`||r.name.length===0)throw new ResolveAgentError(`Sandbox "${t}" backend is missing a non-empty string "name" identifier.`,{logicalPath:t});if(typeof r.create!=`function`)throw new ResolveAgentError(`Sandbox "${t}" backend is missing a "create" function.`,{logicalPath:t});return r}export{resolveSandboxDefinition};

package/dist/src/runtime/resolve-tool.js

@@ -1,110 +1 @@
-import { expectFunction, expectObjectRecord } from "#internal/authored-module.js";
-import { registerDefinitionSource } from "#public/tool-result-narrowing.js";
-import { toErrorMessage } from "#shared/errors.js";
-import { loadResolvedModuleExport, ResolveAgentError } from "#runtime/resolve-helpers.js";
-/**
- * Resolves one compiled authored tool into a runtime-owned definition
- * with live callbacks reattached from the authored module.
- *
- * Optional hooks (`onCompact`, `needsApproval`, `retentionPolicy`,
- * plus an optional Standard Schema `inputSchema`) are extracted when
- * declared and validated to have the expected shape; any type mismatch
- * raises a {@link ResolveAgentError} so typos surface at resolve time
- * instead of at first tool call.
- */
-export async function resolveToolDefinition(definition, moduleMap, nodeId) {
-    try {
-        const resolvedExportValue = await loadResolvedModuleExport({
-            definition,
-            kindLabel: "tool",
-            moduleMap,
-            nodeId,
-        });
-        const resolvedRecord = expectObjectRecord(resolvedExportValue, describe(definition, "to return an object"));
-        registerDefinitionSource(`tool:${resolvedRecord.description}`, {
-            kind: "tool",
-            name: definition.name,
-        });
-        const execute = expectFunction(resolvedRecord.execute, describe(definition, "to provide an execute function"));
-        return {
-            description: definition.description,
-            execute,
-            exportName: definition.exportName,
-            inputSchema: definition.inputSchema,
-            logicalPath: definition.logicalPath,
-            name: definition.name,
-            sourceId: definition.sourceId,
-            sourceKind: "module",
-            ...extractOptionalHooks(resolvedRecord, definition),
-        };
-    }
-    catch (error) {
-        if (error instanceof ResolveAgentError) {
-            throw error;
-        }
-        throw new ResolveAgentError(`Failed to attach the tool execute function from "${definition.logicalPath}": ${toErrorMessage(error)}`, {
-            logicalPath: definition.logicalPath,
-            sourceId: definition.sourceId,
-        });
-    }
-}
-/**
- * Validates and extracts every optional hook declared on the authored
- * tool module, returning them as an {@link OptionalResolvedFields}
- * builder.
- */
-function extractOptionalHooks(record, definition) {
-    const optional = {};
-    if (record.onCompact !== undefined) {
-        optional.onCompact = expectFunction(record.onCompact, describe(definition, "to provide an onCompact function"));
-    }
-    if (record.needsApproval !== undefined) {
-        optional.needsApproval = expectFunction(record.needsApproval, describe(definition, "to provide a needsApproval function"));
-    }
-    const retentionPolicy = extractRetentionPolicy(record, definition);
-    if (retentionPolicy !== undefined) {
-        optional.retentionPolicy = retentionPolicy;
-    }
-    if (record.toModelOutput !== undefined) {
-        optional.toModelOutput = expectFunction(record.toModelOutput, describe(definition, "to provide a toModelOutput function"));
-    }
-    if (record.inputSchema !== undefined && isFlexibleSchema(record.inputSchema)) {
-        optional.inputStandardSchema = record.inputSchema;
-    }
-    return optional;
-}
-/**
- * Validates and extracts `retentionPolicy` from the resolved authored
- * module record. Accepts the literal strings `"auto"` and `"keep"` or a
- * function that returns a {@link RetentionSummary}. Any other shape
- * raises a resolve error so typos surface early.
- */
-function extractRetentionPolicy(record, definition) {
-    const raw = record.retentionPolicy;
-    if (raw === undefined) {
-        return undefined;
-    }
-    if (raw === "auto" || raw === "keep") {
-        return raw;
-    }
-    if (typeof raw === "function") {
-        return raw;
-    }
-    throw new ResolveAgentError(describe(definition, 'to set retentionPolicy to "auto", "keep", or a function'), {
-        logicalPath: definition.logicalPath,
-        sourceId: definition.sourceId,
-    });
-}
-/**
- * Formats the "Expected the tool export ... {predicate}" message used
- * by every validation error in this file.
- */
-function describe(definition, predicate) {
-    return `Expected the tool export "${definition.exportName ?? "default"}" from "${definition.logicalPath}" ${predicate}.`;
-}
-function isFlexibleSchema(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "~standard" in value &&
-        typeof value["~standard"] === "object");
-}
+import{expectFunction,expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{registerDefinitionSource}from"#public/tool-result-narrowing.js";async function resolveToolDefinition(a,o,s){try{let n=expectObjectRecord(await loadResolvedModuleExport({definition:a,kindLabel:`tool`,moduleMap:o,nodeId:s}),describe(a,`to return an object`));registerDefinitionSource(`tool:${n.description}`,{kind:`tool`,name:a.name});let r=expectFunction(n.execute,describe(a,`to provide an execute function`));return{description:a.description,execute:r,exportName:a.exportName,inputSchema:a.inputSchema,logicalPath:a.logicalPath,name:a.name,sourceId:a.sourceId,sourceKind:`module`,...extractOptionalHooks(n,a)}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to attach the tool execute function from "${a.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:a.logicalPath,sourceId:a.sourceId})}}function extractOptionalHooks(t,n){let r={};t.onCompact!==void 0&&(r.onCompact=expectFunction(t.onCompact,describe(n,`to provide an onCompact function`))),t.needsApproval!==void 0&&(r.needsApproval=expectFunction(t.needsApproval,describe(n,`to provide a needsApproval function`)));let i=extractRetentionPolicy(t,n);return i!==void 0&&(r.retentionPolicy=i),t.toModelOutput!==void 0&&(r.toModelOutput=expectFunction(t.toModelOutput,describe(n,`to provide a toModelOutput function`))),t.inputSchema!==void 0&&isFlexibleSchema(t.inputSchema)&&(r.inputStandardSchema=t.inputSchema),r}function extractRetentionPolicy(e,t){let n=e.retentionPolicy;if(n!==void 0){if(n===`auto`||n===`keep`||typeof n==`function`)return n;throw new ResolveAgentError(describe(t,`to set retentionPolicy to "auto", "keep", or a function`),{logicalPath:t.logicalPath,sourceId:t.sourceId})}}function describe(e,t){return`Expected the tool export "${e.exportName??`default`}" from "${e.logicalPath}" ${t}.`}function isFlexibleSchema(e){return typeof e==`object`&&!!e&&`~standard`in e&&typeof e[`~standard`]==`object`}export{resolveToolDefinition};

package/dist/src/runtime/sandbox/keys.js

@@ -1,72 +1 @@
-import { createHash } from "node:crypto";
-import { realpath } from "node:fs/promises";
-import { resolveInstalledPackageInfo } from "#internal/application/package.js";
-import { getRuntimeCompiledArtifactsAppRoot, getRuntimeCompiledArtifactsCacheKey, } from "#runtime/compiled-artifacts-source.js";
-import { loadCompileMetadata } from "#runtime/loaders/compile-metadata.js";
-const RUNTIME_SANDBOX_CONTRACT_VERSION = 2;
-/**
- * Creates the stable runtime template and session keys for one sandbox
- * definition under the current artifact source and backend.
- */
-export async function createRuntimeSandboxKeys(input) {
-    return {
-        sessionKey: await createRuntimeSandboxSessionKey(input),
-        templateKey: await createRuntimeSandboxTemplateKey(input),
-    };
-}
-/**
- * Creates the stable reusable template key for one sandbox definition.
- *
- * The template key factors in the graph `nodeId` so that two
- * runtime agents (root and subagents) do not collide on the same
- * template when they each own a sandbox authored at the same logical
- * path.
- */
-export async function createRuntimeSandboxTemplateKey(input) {
-    const scope = await resolveRuntimeSandboxScope(input.backendName, input.compiledArtifactsSource);
-    const versionHash = await resolveRuntimeSandboxVersionHash({
-        compiledArtifactsSource: input.compiledArtifactsSource,
-        nodeId: input.nodeId,
-        sourceId: input.sourceId,
-    });
-    const templateHash = createStableHash(`${resolveInstalledPackageInfo().version}:${RUNTIME_SANDBOX_CONTRACT_VERSION}:${versionHash}`).slice(0, 20);
-    return sanitizeRuntimeSandboxKey(`ash-sbx-tpl-${input.backendName}-${scope}-${templateHash}`);
-}
-async function createRuntimeSandboxSessionKey(input) {
-    const scope = await resolveRuntimeSandboxScope(input.backendName, input.compiledArtifactsSource);
-    const nodeScope = sanitizeRuntimeSandboxKey(input.nodeId);
-    return sanitizeRuntimeSandboxKey(`ash-sbx-ses-${input.backendName}-${scope}-${input.sessionId}-${nodeScope}`);
-}
-/**
- * Resolves the partition key used in Vercel Sandbox template/session names.
- *
- * Uses deployment id for Vercel, realpath(appRoot) for local apps, and
- * the compiled-artifacts cache key as a bundled fallback.
- */
-async function resolveRuntimeSandboxScope(backendName, compiledArtifactsSource) {
-    if (backendName === "vercel") {
-        const deploymentId = process.env.VERCEL_DEPLOYMENT_ID?.trim();
-        if (deploymentId !== undefined && deploymentId.length > 0) {
-            return createStableHash(deploymentId).slice(0, 16);
-        }
-    }
-    const appRoot = getRuntimeCompiledArtifactsAppRoot(compiledArtifactsSource);
-    if (appRoot !== undefined) {
-        return createStableHash(await realpath(appRoot)).slice(0, 16);
-    }
-    return createStableHash(getRuntimeCompiledArtifactsCacheKey(compiledArtifactsSource)).slice(0, 16);
-}
-async function resolveRuntimeSandboxVersionHash(input) {
-    const metadata = await loadCompileMetadata({
-        compiledArtifactsSource: input.compiledArtifactsSource,
-    });
-    const sourceGraphHash = metadata?.discovery.sourceGraphHash ??
-        getRuntimeCompiledArtifactsCacheKey(input.compiledArtifactsSource);
-    return createStableHash(`${sourceGraphHash}:${input.nodeId}:${input.sourceId}`);
-}
-function createStableHash(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-function sanitizeRuntimeSandboxKey(value) {
-    return value.replaceAll(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 120);
-}
+import{realpath}from"node:fs/promises";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{createHash}from"node:crypto";import{getRuntimeCompiledArtifactsAppRoot,getRuntimeCompiledArtifactsCacheKey}from"#runtime/compiled-artifacts-source.js";import{loadCompileMetadata}from"#runtime/loaders/compile-metadata.js";var RUNTIME_SANDBOX_CONTRACT_VERSION=2;async function createRuntimeSandboxKeys(e){return{sessionKey:await createRuntimeSandboxSessionKey(e),templateKey:await createRuntimeSandboxTemplateKey(e)}}async function createRuntimeSandboxTemplateKey(e){let n=await resolveRuntimeSandboxScope(e.backendName,e.compiledArtifactsSource),r=await resolveRuntimeSandboxVersionHash({compiledArtifactsSource:e.compiledArtifactsSource,nodeId:e.nodeId,sourceId:e.sourceId}),i=createStableHash(`${resolveInstalledPackageInfo().version}:${RUNTIME_SANDBOX_CONTRACT_VERSION}:${r}`).slice(0,20);return sanitizeRuntimeSandboxKey(`ash-sbx-tpl-${e.backendName}-${n}-${i}`)}async function createRuntimeSandboxSessionKey(e){let t=await resolveRuntimeSandboxScope(e.backendName,e.compiledArtifactsSource),n=sanitizeRuntimeSandboxKey(e.nodeId);return sanitizeRuntimeSandboxKey(`ash-sbx-ses-${e.backendName}-${t}-${e.sessionId}-${n}`)}async function resolveRuntimeSandboxScope(t,n){if(t===`vercel`){let e=process.env.VERCEL_DEPLOYMENT_ID?.trim();if(e!==void 0&&e.length>0)return createStableHash(e).slice(0,16)}let a=getRuntimeCompiledArtifactsAppRoot(n);return a===void 0?createStableHash(getRuntimeCompiledArtifactsCacheKey(n)).slice(0,16):createStableHash(await realpath(a)).slice(0,16)}async function resolveRuntimeSandboxVersionHash(e){return createStableHash(`${(await loadCompileMetadata({compiledArtifactsSource:e.compiledArtifactsSource}))?.discovery.sourceGraphHash??getRuntimeCompiledArtifactsCacheKey(e.compiledArtifactsSource)}:${e.nodeId}:${e.sourceId}`)}function createStableHash(e){return createHash(`sha256`).update(e).digest(`hex`)}function sanitizeRuntimeSandboxKey(e){return e.replaceAll(/[^a-zA-Z0-9._-]+/g,`-`).slice(0,120)}export{createRuntimeSandboxKeys,createRuntimeSandboxTemplateKey};

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

@@ -1,42 +1 @@
-import { defaultBackend } from "#public/sandbox/backends/default.js";
-/**
- * Stable internal source id for the framework-owned default sandbox.
- *
- * Used by the runtime template/session key derivation and by prewarm
- * to distinguish the shared framework sandbox from per-node authored
- * overrides.
- */
-export const DEFAULT_SANDBOX_SOURCE_ID = "ash:default-sandbox";
-/**
- * Builds the runtime-owned registry for one resolved authored agent's
- * sandbox, preferring the authored override and falling back to the
- * framework default.
- */
-export function createRuntimeSandboxRegistry(input) {
-    const definition = input.authoredSandbox ?? createFrameworkSandboxDefinition();
-    return {
-        sandbox: {
-            definition,
-            workspaceResourceRoot: input.workspaceResourceRoot,
-        },
-    };
-}
-/**
- * Builds the framework default sandbox definition used when no agent
- * authored override is present.
- *
- * The `backend` is resolved through {@link defaultBackend} on each
- * call so the framework default picks up the same environment-aware
- * fallback as authored sandboxes that omit `backend` (`vercelBackend()`
- * on hosted Vercel, `localBackend()` everywhere else). Implemented as
- * a factory rather than a constant so the environment is read at
- * graph-resolution time rather than at module-load time.
- */
-export function createFrameworkSandboxDefinition() {
-    return {
-        backend: defaultBackend(),
-        logicalPath: "ash:framework/default-sandbox",
-        sourceId: DEFAULT_SANDBOX_SOURCE_ID,
-        sourceKind: "module",
-    };
-}
+import{defaultBackend}from"#public/sandbox/backends/default.js";var DEFAULT_SANDBOX_SOURCE_ID=`ash:default-sandbox`;function createRuntimeSandboxRegistry(e){return{sandbox:{definition:e.authoredSandbox??createFrameworkSandboxDefinition(),workspaceResourceRoot:e.workspaceResourceRoot}}}function createFrameworkSandboxDefinition(){return{backend:defaultBackend(),logicalPath:`ash:framework/default-sandbox`,sourceId:DEFAULT_SANDBOX_SOURCE_ID,sourceKind:`module`}}export{DEFAULT_SANDBOX_SOURCE_ID,createFrameworkSandboxDefinition,createRuntimeSandboxRegistry};

package/dist/src/runtime/schedules/register.js

@@ -1,62 +1 @@
-/**
- * Stable Nitro task-name prefix for framework-owned authored schedules.
- */
-export const ASH_SCHEDULE_TASK_NAME_PREFIX = "ash.schedule.";
-/**
- * Error raised when authored schedules cannot be converted into stable runtime
- * registrations.
- */
-export class ScheduleRegistrationError extends Error {
-    scheduleId;
-    sourceId;
-    taskName;
-    constructor(message, input = {}) {
-        super(message);
-        this.name = "ScheduleRegistrationError";
-        if (input.scheduleId !== undefined) {
-            this.scheduleId = input.scheduleId;
-        }
-        if (input.sourceId !== undefined) {
-            this.sourceId = input.sourceId;
-        }
-        if (input.taskName !== undefined) {
-            this.taskName = input.taskName;
-        }
-    }
-}
-/**
- * Creates stable registration inputs for Nitro's task and cron surfaces from
- * resolved authored schedules.
- */
-export function createScheduleRegistrations(schedules) {
-    const registrations = schedules
-        .map((schedule) => ({
-        cron: schedule.cron,
-        description: `Run Ash schedule "${schedule.name}" from "${schedule.logicalPath}".`,
-        logicalPath: schedule.logicalPath,
-        scheduleId: schedule.name,
-        sourceId: schedule.sourceId,
-        taskName: createScheduleTaskName(schedule.sourceId),
-    }))
-        .sort((left, right) => left.sourceId.localeCompare(right.sourceId));
-    assertUniqueScheduleIds(registrations);
-    return registrations;
-}
-function assertUniqueScheduleIds(registrations) {
-    const registrationByScheduleId = new Map();
-    for (const registration of registrations) {
-        const previousRegistration = registrationByScheduleId.get(registration.scheduleId);
-        if (previousRegistration === undefined) {
-            registrationByScheduleId.set(registration.scheduleId, registration);
-            continue;
-        }
-        throw new ScheduleRegistrationError(`Duplicate authored schedule id "${registration.scheduleId}" found in "${previousRegistration.logicalPath}" and "${registration.logicalPath}".`, {
-            scheduleId: registration.scheduleId,
-            sourceId: registration.sourceId,
-            taskName: registration.taskName,
-        });
-    }
-}
-function createScheduleTaskName(sourceId) {
-    return `${ASH_SCHEDULE_TASK_NAME_PREFIX}${Buffer.from(sourceId, "utf8").toString("base64url")}`;
-}
+var ASH_SCHEDULE_TASK_NAME_PREFIX=`ash.schedule.`,ScheduleRegistrationError=class extends Error{scheduleId;sourceId;taskName;constructor(e,t={}){super(e),this.name=`ScheduleRegistrationError`,t.scheduleId!==void 0&&(this.scheduleId=t.scheduleId),t.sourceId!==void 0&&(this.sourceId=t.sourceId),t.taskName!==void 0&&(this.taskName=t.taskName)}};function createScheduleRegistrations(e){let t=e.map(e=>({cron:e.cron,description:`Run Ash schedule "${e.name}" from "${e.logicalPath}".`,logicalPath:e.logicalPath,scheduleId:e.name,sourceId:e.sourceId,taskName:createScheduleTaskName(e.sourceId)})).sort((e,t)=>e.sourceId.localeCompare(t.sourceId));return assertUniqueScheduleIds(t),t}function assertUniqueScheduleIds(e){let t=new Map;for(let n of e){let e=t.get(n.scheduleId);if(e===void 0){t.set(n.scheduleId,n);continue}throw new ScheduleRegistrationError(`Duplicate authored schedule id "${n.scheduleId}" found in "${e.logicalPath}" and "${n.logicalPath}".`,{scheduleId:n.scheduleId,sourceId:n.sourceId,taskName:n.taskName})}}function createScheduleTaskName(t){return`${ASH_SCHEDULE_TASK_NAME_PREFIX}${Buffer.from(t,`utf8`).toString(`base64url`)}`}export{ASH_SCHEDULE_TASK_NAME_PREFIX,ScheduleRegistrationError,createScheduleRegistrations};

package/dist/src/runtime/schedules/resolve-schedule.js

@@ -1,66 +1 @@
-import { loadCompiledManifest } from "#runtime/loaders/manifest.js";
-import { createScheduleRegistrations } from "#runtime/schedules/register.js";
-/**
- * Error raised when compiled authored schedules cannot be hydrated into one
- * runtime-owned schedule model.
- */
-class ResolveScheduleError extends Error {
-    taskName;
-    constructor(message, input = {}) {
-        super(message);
-        this.name = "ResolveScheduleError";
-        if (input.taskName !== undefined) {
-            this.taskName = input.taskName;
-        }
-    }
-}
-/**
- * Resolves runtime-owned schedules from the compiled manifest.
- */
-export async function resolveSchedules(input) {
-    return [...input.manifest.schedules].map((schedule) => {
-        const base = {
-            cron: schedule.cron,
-            hasRun: schedule.hasRun,
-            logicalPath: schedule.logicalPath,
-            name: schedule.name,
-            sourceId: schedule.sourceId,
-            sourceKind: schedule.sourceKind,
-        };
-        if (schedule.markdown !== undefined) {
-            return { ...base, markdown: schedule.markdown };
-        }
-        return base;
-    });
-}
-/**
- * Loads the compiled manifest, then resolves authored schedules into
- * runtime-owned schedule models.
- */
-export async function loadResolvedCompiledSchedules(input) {
-    const manifest = await loadCompiledManifest({
-        compiledArtifactsSource: input.compiledArtifactsSource,
-    });
-    return await resolveSchedules({
-        manifest,
-    });
-}
-/**
- * Loads and resolves one compiled authored schedule from its registered Nitro
- * task name.
- */
-export async function loadResolvedCompiledScheduleByTaskName(taskName, input) {
-    const schedules = await loadResolvedCompiledSchedules(input);
-    const scheduleBySourceId = new Map(schedules.map((schedule) => [schedule.sourceId, schedule]));
-    for (const registration of createScheduleRegistrations(schedules)) {
-        if (registration.taskName === taskName) {
-            const schedule = scheduleBySourceId.get(registration.sourceId);
-            if (schedule !== undefined) {
-                return schedule;
-            }
-        }
-    }
-    throw new ResolveScheduleError(`No compiled authored schedule is registered for Nitro task "${taskName}".`, {
-        taskName,
-    });
-}
+import{loadCompiledManifest}from"#runtime/loaders/manifest.js";import{createScheduleRegistrations}from"#runtime/schedules/register.js";var ResolveScheduleError=class extends Error{taskName;constructor(e,t={}){super(e),this.name=`ResolveScheduleError`,t.taskName!==void 0&&(this.taskName=t.taskName)}};async function resolveSchedules(e){return[...e.manifest.schedules].map(e=>{let t={cron:e.cron,hasRun:e.hasRun,logicalPath:e.logicalPath,name:e.name,sourceId:e.sourceId,sourceKind:e.sourceKind};return e.markdown===void 0?t:{...t,markdown:e.markdown}})}async function loadResolvedCompiledSchedules(t){return await resolveSchedules({manifest:await loadCompiledManifest({compiledArtifactsSource:t.compiledArtifactsSource})})}async function loadResolvedCompiledScheduleByTaskName(e,n){let r=await loadResolvedCompiledSchedules(n),i=new Map(r.map(e=>[e.sourceId,e]));for(let n of createScheduleRegistrations(r))if(n.taskName===e){let e=i.get(n.sourceId);if(e!==void 0)return e}throw new ResolveScheduleError(`No compiled authored schedule is registered for Nitro task "${e}".`,{taskName:e})}export{loadResolvedCompiledScheduleByTaskName,loadResolvedCompiledSchedules,resolveSchedules};