experimental-ash 0.26.0 → 0.28.0

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

package/dist/src/runtime/session-callback-route.js

@@ -1,87 +1 @@
-import { resumeHook } from "#compiled/@workflow/core/runtime.js";
-import { ASH_CALLBACK_ROUTE_PATTERN } from "#protocol/routes.js";
-export const HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX = "ash/v1/callback";
-const HANDLED_METHODS = ["POST"];
-export function getSessionCallbackChannelDefinitions() {
-    return HANDLED_METHODS.map((method) => buildCallbackChannelDefinition(method));
-}
-export function getSessionCallbackChannelNames() {
-    return new Set(HANDLED_METHODS.map(channelNameForMethod));
-}
-function buildCallbackChannelDefinition(method) {
-    const name = channelNameForMethod(method);
-    return {
-        name,
-        method,
-        urlPath: ASH_CALLBACK_ROUTE_PATTERN,
-        fetch: handleSessionCallbackRequest,
-        logicalPath: `framework://channels/${name}`,
-        sourceId: `ash:framework:session-callback-${method.toLowerCase()}`,
-        sourceKind: "module",
-    };
-}
-function channelNameForMethod(method) {
-    return `${HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX}/${method.toLowerCase()}`;
-}
-export async function handleSessionCallbackRequest(request, ctx) {
-    const token = ctx.params.token;
-    if (typeof token !== "string" || token.length === 0) {
-        return Response.json({ error: "Missing callback token.", ok: false }, { status: 400 });
-    }
-    let body;
-    try {
-        body = await request.json();
-    }
-    catch {
-        return Response.json({ error: "Invalid JSON body.", ok: false }, { status: 400 });
-    }
-    const result = projectSessionCallbackResult(body);
-    if (result instanceof Response) {
-        return result;
-    }
-    try {
-        await resumeHook(token, {
-            kind: "runtime-action-result",
-            results: [result],
-        });
-    }
-    catch {
-        return Response.json({ error: "Session callback not pending.", ok: false }, { status: 404 });
-    }
-    return Response.json({ ok: true }, { status: 202 });
-}
-function projectSessionCallbackResult(value) {
-    if (value === null || typeof value !== "object") {
-        return Response.json({ error: "Expected a JSON object.", ok: false }, { status: 400 });
-    }
-    const payload = value;
-    if (typeof payload.callId !== "string" || payload.callId.length === 0) {
-        return Response.json({ error: "Missing callback callId.", ok: false }, { status: 400 });
-    }
-    if (typeof payload.subagentName !== "string" || payload.subagentName.length === 0) {
-        return Response.json({ error: "Missing callback subagentName.", ok: false }, { status: 400 });
-    }
-    if (payload.kind === "session.completed") {
-        return {
-            callId: payload.callId,
-            kind: "subagent-result",
-            output: typeof payload.output === "string" ? payload.output : "",
-            subagentName: payload.subagentName,
-        };
-    }
-    if (payload.kind === "session.failed") {
-        return {
-            callId: payload.callId,
-            isError: true,
-            kind: "subagent-result",
-            output: payload.error === undefined
-                ? {
-                    code: "REMOTE_AGENT_FAILED",
-                    message: "Remote agent failed.",
-                }
-                : payload.error,
-            subagentName: payload.subagentName,
-        };
-    }
-    return Response.json({ error: "Unsupported callback kind.", ok: false }, { status: 400 });
-}
+import{ASH_CALLBACK_ROUTE_PATTERN}from"#protocol/routes.js";import{resumeHook}from"#compiled/@workflow/core/runtime.js";var HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX=`ash/v1/callback`,HANDLED_METHODS=[`POST`];function getSessionCallbackChannelDefinitions(){return HANDLED_METHODS.map(e=>buildCallbackChannelDefinition(e))}function getSessionCallbackChannelNames(){return new Set(HANDLED_METHODS.map(channelNameForMethod))}function buildCallbackChannelDefinition(t){let n=channelNameForMethod(t);return{name:n,method:t,urlPath:ASH_CALLBACK_ROUTE_PATTERN,fetch:handleSessionCallbackRequest,logicalPath:`framework://channels/${n}`,sourceId:`ash:framework:session-callback-${t.toLowerCase()}`,sourceKind:`module`}}function channelNameForMethod(e){return`${HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX}/${e.toLowerCase()}`}async function handleSessionCallbackRequest(e,n){let r=n.params.token;if(typeof r!=`string`||r.length===0)return Response.json({error:`Missing callback token.`,ok:!1},{status:400});let i;try{i=await e.json()}catch{return Response.json({error:`Invalid JSON body.`,ok:!1},{status:400})}let a=projectSessionCallbackResult(i);if(a instanceof Response)return a;try{await resumeHook(r,{kind:`runtime-action-result`,results:[a]})}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}function projectSessionCallbackResult(e){if(typeof e!=`object`||!e)return Response.json({error:`Expected a JSON object.`,ok:!1},{status:400});let t=e;return typeof t.callId!=`string`||t.callId.length===0?Response.json({error:`Missing callback callId.`,ok:!1},{status:400}):typeof t.subagentName!=`string`||t.subagentName.length===0?Response.json({error:`Missing callback subagentName.`,ok:!1},{status:400}):t.kind===`session.completed`?{callId:t.callId,kind:`subagent-result`,output:typeof t.output==`string`?t.output:``,subagentName:t.subagentName}:t.kind===`session.failed`?{callId:t.callId,isError:!0,kind:`subagent-result`,output:t.error===void 0?{code:`REMOTE_AGENT_FAILED`,message:`Remote agent failed.`}:t.error,subagentName:t.subagentName}:Response.json({error:`Unsupported callback kind.`,ok:!1},{status:400})}export{HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX,getSessionCallbackChannelDefinitions,getSessionCallbackChannelNames,handleSessionCallbackRequest};

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

@@ -1,18 +1 @@
-import { z } from "#compiled/zod/index.js";
-const runtimeSessionAuthAttributeValueSchema = z.union([
-    z.string(),
-    z.array(z.string()).readonly(),
-]);
-/**
- * Zod schema for one serializable runtime session auth context.
- */
-const runtimeSessionAuthContextSchema = z
-    .object({
-    attributes: z.record(z.string(), runtimeSessionAuthAttributeValueSchema).readonly(),
-    authenticator: z.enum(["http-basic", "jwt-hmac", "jwt-ecdsa", "oidc"]),
-    issuer: z.string().optional(),
-    principalId: z.string(),
-    principalType: z.enum(["service", "user", "runtime", "unknown"]),
-    subject: z.string().optional(),
-})
-    .strict();
+import{z}from"#compiled/zod/index.js";var runtimeSessionAuthAttributeValueSchema=z.union([z.string(),z.array(z.string()).readonly()]);z.object({attributes:z.record(z.string(),runtimeSessionAuthAttributeValueSchema).readonly(),authenticator:z.enum([`http-basic`,`jwt-hmac`,`jwt-ecdsa`,`oidc`]),issuer:z.string().optional(),principalId:z.string(),principalType:z.enum([`service`,`user`,`runtime`,`unknown`]),subject:z.string().optional()}).strict();export{};