experimental-ash 0.25.2 → 0.27.0

package/dist/src/public/channels/upload-policy.js

@@ -1,170 +1 @@
-/**
- * Upload-policy authoring helpers for channel routes.
- */
-import { getKnownByteLength } from "#internal/attachments/data.js";
-/**
- * Framework default: 25 MB cap, unrestricted media types. Channels
- * override this per-route; authors override per-channel /
- * channel factory call via the `uploadPolicy` option.
- */
-export const DEFAULT_UPLOAD_POLICY = Object.freeze({
-    allowedMediaTypes: "*",
-    maxBytes: 25 * 1024 * 1024,
-});
-/**
- * Produces a final {@link UploadPolicy} by merging an optional partial
- * override on top of `base` (default: {@link DEFAULT_UPLOAD_POLICY}).
- * Returns `"disabled"` unchanged when passed as the override.
- */
-export function mergeUploadPolicy(override, base = DEFAULT_UPLOAD_POLICY) {
-    if (override === "disabled")
-        return "disabled";
-    if (override === undefined)
-        return base;
-    const maxBytes = override.maxBytes ?? base.maxBytes;
-    const allowedMediaTypes = override.allowedMediaTypes ?? base.allowedMediaTypes;
-    if (maxBytes < 0 || !Number.isFinite(maxBytes)) {
-        throw new RangeError(`UploadPolicy.maxBytes must be a non-negative finite number. Received: ${String(maxBytes)}.`);
-    }
-    return { allowedMediaTypes, maxBytes };
-}
-/**
- * Returns `true` when `policy` rejects every attachment — the explicit
- * `"disabled"` literal, `maxBytes: 0`, or an empty `allowedMediaTypes`
- * array. Channels use this to skip attachment-discovery work.
- */
-export function isUploadsDisabled(policy) {
-    if (policy === "disabled")
-        return true;
-    if (policy.maxBytes === 0)
-        return true;
-    if (Array.isArray(policy.allowedMediaTypes) && policy.allowedMediaTypes.length === 0)
-        return true;
-    return false;
-}
-/**
- * Returns `true` if `mediaType` is accepted under `policy`.
- */
-export function isMediaTypeAllowed(mediaType, policy) {
-    if (policy === "disabled")
-        return false;
-    if (policy.allowedMediaTypes === "*") {
-        return true;
-    }
-    const normalized = mediaType.toLowerCase();
-    for (const pattern of policy.allowedMediaTypes) {
-        const normalizedPattern = pattern.toLowerCase();
-        if (normalizedPattern === normalized) {
-            return true;
-        }
-        if (normalizedPattern.endsWith("/*")) {
-            const prefix = normalizedPattern.slice(0, -1);
-            if (normalized.startsWith(prefix)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Evaluates a single `FilePart` against a {@link UploadPolicy}. Returns
- * a {@link UploadPolicyViolation} on rejection, or `null` when the
- * part is either accepted or has a non-local payload (remote URL) whose
- * size cannot be determined without fetching.
- *
- * Order of checks is stable: media-type first (cheap), size second.
- * This keeps channel error responses consistent — a 25 MB disallowed
- * CSV surfaces a 415 instead of a 413 — and mirrors how most HTTP
- * proxies enforce policy.
- */
-export function evaluateFilePart(part, policy) {
-    if (policy === "disabled" || !isMediaTypeAllowed(part.mediaType, policy)) {
-        const allowedMediaTypes = policy === "disabled" || policy.allowedMediaTypes === "*"
-            ? []
-            : [...policy.allowedMediaTypes];
-        const violation = {
-            allowedMediaTypes,
-            kind: "disallowed-media-type",
-            mediaType: part.mediaType,
-        };
-        if (part.filename !== undefined) {
-            return { ...violation, filename: part.filename };
-        }
-        return violation;
-    }
-    const byteLength = getKnownByteLength(part.data);
-    if (byteLength !== null && byteLength > policy.maxBytes) {
-        const violation = {
-            byteLength,
-            kind: "too-large",
-            limit: policy.maxBytes,
-            mediaType: part.mediaType,
-        };
-        if (part.filename !== undefined) {
-            return { ...violation, filename: part.filename };
-        }
-        return violation;
-    }
-    return null;
-}
-/**
- * Walks a `UserContent` array and returns every policy violation, in
- * iteration order. Non-file parts (text, image) are skipped.
- *
- * Returns an empty array when the message is a plain string or when
- * every file part passes. Channels use this to decide between
- * rejecting an inbound request (HTTP) and dropping individual attachments
- * (Slack).
- */
-export function collectUploadPolicyViolations(content, policy) {
-    if (typeof content === "string") {
-        return [];
-    }
-    const violations = [];
-    for (const part of content) {
-        if (part.type !== "file") {
-            continue;
-        }
-        const violation = evaluateFilePart(part, policy);
-        if (violation !== null) {
-            violations.push(violation);
-        }
-    }
-    return violations;
-}
-/**
- * Returns a copy of `content` with every {@link FilePart} that violates
- * `policy` removed.
- *
- * Callers that want a hard-fail contract (HTTP) should use
- * {@link collectUploadPolicyViolations} and return a 4xx response
- * instead. Callers that want best-effort delivery (Slack: drop the bad
- * upload, keep the turn going) use this helper and log the dropped
- * attachments.
- */
-export function stripDisallowedFileParts(content, policy) {
-    if (typeof content === "string") {
-        return content;
-    }
-    const filtered = content.filter((part) => {
-        if (part.type !== "file") {
-            return true;
-        }
-        return evaluateFilePart(part, policy) === null;
-    });
-    return filtered;
-}
-/**
- * Renders a {@link UploadPolicyViolation} as a short human-readable
- * string. Used by channel error responses and warning logs.
- */
-export function formatUploadPolicyViolation(violation) {
-    const fileLabel = violation.filename ?? violation.mediaType;
-    if (violation.kind === "too-large") {
-        return `${fileLabel} (${violation.byteLength} bytes) exceeds the ${violation.limit}-byte upload limit.`;
-    }
-    const allowed = violation.allowedMediaTypes.length > 0
-        ? ` Allowed: ${violation.allowedMediaTypes.join(", ")}.`
-        : "";
-    return `${fileLabel} has media type "${violation.mediaType}" which is not allowed by this route.${allowed}`;
-}
+import{getKnownByteLength}from"#internal/attachments/data.js";var DEFAULT_UPLOAD_POLICY=Object.freeze({allowedMediaTypes:`*`,maxBytes:25*1024*1024});function mergeUploadPolicy(e,n=DEFAULT_UPLOAD_POLICY){if(e===`disabled`)return`disabled`;if(e===void 0)return n;let r=e.maxBytes??n.maxBytes,i=e.allowedMediaTypes??n.allowedMediaTypes;if(r<0||!Number.isFinite(r))throw RangeError(`UploadPolicy.maxBytes must be a non-negative finite number. Received: ${String(r)}.`);return{allowedMediaTypes:i,maxBytes:r}}function isUploadsDisabled(e){return!!(e===`disabled`||e.maxBytes===0||Array.isArray(e.allowedMediaTypes)&&e.allowedMediaTypes.length===0)}function isMediaTypeAllowed(e,t){if(t===`disabled`)return!1;if(t.allowedMediaTypes===`*`)return!0;let n=e.toLowerCase();for(let e of t.allowedMediaTypes){let t=e.toLowerCase();if(t===n)return!0;if(t.endsWith(`/*`)){let e=t.slice(0,-1);if(n.startsWith(e))return!0}}return!1}function evaluateFilePart(t,n){if(n===`disabled`||!isMediaTypeAllowed(t.mediaType,n)){let e={allowedMediaTypes:n===`disabled`||n.allowedMediaTypes===`*`?[]:[...n.allowedMediaTypes],kind:`disallowed-media-type`,mediaType:t.mediaType};return t.filename===void 0?e:{...e,filename:t.filename}}let r=getKnownByteLength(t.data);if(r!==null&&r>n.maxBytes){let e={byteLength:r,kind:`too-large`,limit:n.maxBytes,mediaType:t.mediaType};return t.filename===void 0?e:{...e,filename:t.filename}}return null}function collectUploadPolicyViolations(e,t){if(typeof e==`string`)return[];let n=[];for(let r of e){if(r.type!==`file`)continue;let e=evaluateFilePart(r,t);e!==null&&n.push(e)}return n}function stripDisallowedFileParts(e,t){return typeof e==`string`?e:e.filter(e=>e.type===`file`?evaluateFilePart(e,t)===null:!0)}function formatUploadPolicyViolation(e){let t=e.filename??e.mediaType;if(e.kind===`too-large`)return`${t} (${e.byteLength} bytes) exceeds the ${e.limit}-byte upload limit.`;let n=e.allowedMediaTypes.length>0?` Allowed: ${e.allowedMediaTypes.join(`, `)}.`:``;return`${t} has media type "${e.mediaType}" which is not allowed by this route.${n}`}export{DEFAULT_UPLOAD_POLICY,collectUploadPolicyViolations,evaluateFilePart,formatUploadPolicyViolation,isMediaTypeAllowed,isUploadsDisabled,mergeUploadPolicy,stripDisallowedFileParts};

package/dist/src/public/connections/errors.js

@@ -1,53 +1 @@
-/**
- * Typed error classes for the connection authorization lifecycle.
- */
-/**
- * Thrown when a connection's authorization token is missing because
- * the user has not completed the required OAuth flow.
- */
-export class ConnectionAuthorizationRequiredError extends Error {
-    connectionName;
-    constructor(connectionName, options) {
-        super(options?.message ?? `Connection "${connectionName}" requires authorization.`);
-        this.name = "ConnectionAuthorizationRequiredError";
-        this.connectionName = connectionName;
-    }
-}
-/**
- * Thrown when a connection's authorization fails.
- *
- * Retryable by default; pass `retryable: false` for terminal failures
- * where starting a fresh authorization flow would be wrong.
- */
-export class ConnectionAuthorizationFailedError extends Error {
-    connectionName;
-    reason;
-    retryable;
-    constructor(connectionName, options) {
-        super(options?.message ?? `Connection "${connectionName}" authorization failed.`);
-        this.name = "ConnectionAuthorizationFailedError";
-        this.connectionName = connectionName;
-        this.reason = options?.reason;
-        this.retryable = options?.retryable ?? true;
-    }
-}
-/**
- * Type guard for {@link ConnectionAuthorizationRequiredError}.
- *
- * Uses `err.name` rather than `instanceof` because user code and
- * framework internals can end up with different class identities
- * after bundling (dual-instance hazard in Nitro output).
- */
-export function isConnectionAuthorizationRequiredError(err) {
-    return err instanceof Error && err.name === "ConnectionAuthorizationRequiredError";
-}
-/**
- * Type guard for {@link ConnectionAuthorizationFailedError}.
- *
- * Uses `err.name` rather than `instanceof` because user code and
- * framework internals can end up with different class identities
- * after bundling (dual-instance hazard in Nitro output).
- */
-export function isConnectionAuthorizationFailedError(err) {
-    return err instanceof Error && err.name === "ConnectionAuthorizationFailedError";
-}
+var ConnectionAuthorizationRequiredError=class extends Error{connectionName;constructor(e,t){super(t?.message??`Connection "${e}" requires authorization.`),this.name=`ConnectionAuthorizationRequiredError`,this.connectionName=e}},ConnectionAuthorizationFailedError=class extends Error{connectionName;reason;retryable;constructor(e,t){super(t?.message??`Connection "${e}" authorization failed.`),this.name=`ConnectionAuthorizationFailedError`,this.connectionName=e,this.reason=t?.reason,this.retryable=t?.retryable??!0}};function isConnectionAuthorizationRequiredError(e){return e instanceof Error&&e.name===`ConnectionAuthorizationRequiredError`}function isConnectionAuthorizationFailedError(e){return e instanceof Error&&e.name===`ConnectionAuthorizationFailedError`}export{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError};

package/dist/src/public/connections/index.js

@@ -1,6 +1 @@
-/**
- * Connection authoring helpers for `agent/connections/*.ts` files.
- */
-export { defineInteractiveAuthorization } from "#runtime/connections/types.js";
-export { defineMcpClientConnection, } from "#public/definitions/connections/mcp.js";
-export { ConnectionAuthorizationFailedError, ConnectionAuthorizationRequiredError, isConnectionAuthorizationFailedError, isConnectionAuthorizationRequiredError, } from "#public/connections/errors.js";
+import{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#public/connections/errors.js";import{defineInteractiveAuthorization}from"#runtime/connections/types.js";import{defineMcpClientConnection}from"#public/definitions/connections/mcp.js";export{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,defineInteractiveAuthorization,defineMcpClientConnection,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError};

package/dist/src/public/context/index.js

@@ -1,13 +1 @@
-/**
- * Runtime context helpers for authored code.
- *
- * These APIs work only inside active authored runtime execution such as
- * tools and other Ash-invoked callbacks.
- *
- * @example
- * ```ts
- * import { defineState, getSession } from "experimental-ash/context";
- * ```
- */
-export { getSession, } from "#context/accessors.js";
-export { defineState } from "#public/definitions/state.js";
+import{getSession}from"#context/accessors.js";import{defineState}from"#public/definitions/state.js";export{defineState,getSession};

package/dist/src/public/definitions/agent.js

@@ -1,6 +1 @@
-/**
- * Defines additive agent configuration.
- */
-export function defineAgent(definition) {
-    return definition;
-}
+function defineAgent(e){return e}export{defineAgent};

package/dist/src/public/definitions/channel.js

@@ -1,24 +1 @@
-/**
- * Marker discriminator written into every {@link DisabledRouteSentinel}.
- */
-const DISABLED_ROUTE_SENTINEL_KIND = "ash:disabled-channel";
-/**
- * Returns a sentinel that disables the framework route whose logical name
- * matches the containing file's slug path.
- *
- * Export it as the default export of a file in `agent/channels/`.
- */
-export function disableRoute() {
-    return {
-        kind: DISABLED_ROUTE_SENTINEL_KIND,
-    };
-}
-/**
- * Type guard: returns whether `value` is a {@link DisabledRouteSentinel}
- * produced by {@link disableRoute}.
- */
-export function isDisabledRouteSentinel(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        value.kind === DISABLED_ROUTE_SENTINEL_KIND);
-}
+var DISABLED_ROUTE_SENTINEL_KIND=`ash:disabled-channel`;function disableRoute(){return{kind:DISABLED_ROUTE_SENTINEL_KIND}}function isDisabledRouteSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_ROUTE_SENTINEL_KIND}export{disableRoute,isDisabledRouteSentinel};

package/dist/src/public/definitions/connections/mcp.js

@@ -1,20 +1 @@
-import { normalizeAuthorizationSpec } from "#runtime/connections/validate-authorization.js";
-import { stampDefinitionKey } from "#public/tool-result-narrowing.js";
-/**
- * Defines an MCP client connection.
- *
- * Validates the {@link McpClientAuthDefinition} shape at
- * definition time, in particular the "both-or-neither" constraint
- * for {@link McpClientAuthDefinition.startAuthorization} and
- * {@link McpClientAuthDefinition.completeAuthorization}: providing
- * exactly one is a definition error. `getToken` alone is valid and
- * selects the non-interactive flow; providing both opts into
- * await-authorization-and-splice interactive OAuth.
- */
-export function defineMcpClientConnection(definition) {
-    if (definition.auth !== undefined) {
-        definition.auth = normalizeAuthorizationSpec(definition.auth, "defineMcpClientConnection:");
-    }
-    stampDefinitionKey(definition, `connection:${definition.url}`);
-    return definition;
-}
+import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";import{stampDefinitionKey}from"#public/tool-result-narrowing.js";function defineMcpClientConnection(e){return e.auth!==void 0&&(e.auth=normalizeAuthorizationSpec(e.auth,`defineMcpClientConnection:`)),stampDefinitionKey(e,`connection:${e.url}`),e}export{defineMcpClientConnection};

package/dist/src/public/definitions/defineChannel.js

@@ -1,74 +1 @@
-import { CHANNEL_SENTINEL } from "#channel/compiled-channel.js";
-import { defaultDeliverResult } from "#channel/adapter.js";
-import { HTTP_ADAPTER_KIND } from "#channel/http.js";
-export { GET, POST, PUT, PATCH, DELETE } from "#channel/routes.js";
-export function defineChannel(config) {
-    const adapter = buildAdapter(config);
-    const compiled = {
-        __kind: CHANNEL_SENTINEL,
-        routes: config.routes,
-        adapter,
-        receive: config.receive,
-    };
-    return compiled;
-}
-function buildAdapter(config) {
-    const hasState = config.state != null;
-    const hasContext = config.context != null;
-    const hasFetchFile = config.fetchFile !== undefined;
-    const hasBehavior = hasState || hasContext;
-    const eventHandlers = {};
-    let hasEventHandlers = false;
-    const eventTypes = [
-        "turn.started",
-        "actions.requested",
-        "action.result",
-        "message.completed",
-        "message.appended",
-        "input.requested",
-        "turn.failed",
-        "turn.completed",
-        "session.failed",
-        "session.completed",
-        "session.waiting",
-        "connection.authorization_required",
-        "connection.authorization_pending",
-        "connection.authorization_completed",
-    ];
-    const events = config.events;
-    for (const eventType of eventTypes) {
-        const userHandler = events?.[eventType];
-        if (userHandler) {
-            hasEventHandlers = true;
-            eventHandlers[eventType] = (data, ctx) => {
-                return userHandler(data, ctx);
-            };
-        }
-    }
-    if (!hasBehavior && !hasEventHandlers && !hasFetchFile) {
-        return { kind: config.kindHint ?? HTTP_ADAPTER_KIND };
-    }
-    const adapter = {
-        kind: config.kindHint ?? "defineChannel",
-        state: hasState ? { ...config.state } : {},
-        fetchFile: config.fetchFile,
-        createAdapterContext(base) {
-            const state = base.state;
-            const session = base.session;
-            const channelCtx = hasContext
-                ? config.context(state, session)
-                : {};
-            return {
-                ...channelCtx,
-                state,
-                ctx: base.ctx,
-                session,
-            };
-        },
-        deliver(payload) {
-            return defaultDeliverResult(payload);
-        },
-        ...eventHandlers,
-    };
-    return adapter;
-}
+import{CHANNEL_SENTINEL}from"#channel/compiled-channel.js";import{defaultDeliverResult}from"#channel/adapter.js";import{HTTP_ADAPTER_KIND}from"#channel/http.js";import{DELETE,GET,PATCH,POST,PUT}from"#channel/routes.js";function defineChannel(t){let n=buildAdapter(t);return{__kind:CHANNEL_SENTINEL,routes:t.routes,adapter:n,receive:t.receive}}function buildAdapter(e){let r=e.state!=null,i=e.context!=null,a=e.fetchFile!==void 0,o=r||i,s={},c=!1,l=[`turn.started`,`actions.requested`,`action.result`,`message.completed`,`message.appended`,`input.requested`,`turn.failed`,`turn.completed`,`session.failed`,`session.completed`,`session.waiting`,`connection.authorization_required`,`connection.authorization_pending`,`connection.authorization_completed`],u=e.events;for(let e of l){let t=u?.[e];t&&(c=!0,s[e]=(e,n)=>t(e,n))}return!o&&!c&&!a?{kind:e.kindHint??HTTP_ADAPTER_KIND}:{kind:e.kindHint??`defineChannel`,state:r?{...e.state}:{},fetchFile:e.fetchFile,createAdapterContext(t){let n=t.state,r=t.session;return{...i?e.context(n,r):{},state:n,ctx:t.ctx,session:r}},deliver(e){return defaultDeliverResult(e)},...s}}export{DELETE,GET,PATCH,POST,PUT,defineChannel};

package/dist/src/public/definitions/hook.js

@@ -1,11 +1 @@
-/**
- * Identity-with-types helper. Authors export
- * `defineHook({ lifecycle: { session, turn }, events: { "session.started": … } })`
- * and receive a typed {@link HookDefinition}.
- *
- * `defineHook` runs no side effects — it exists purely so authors get
- * type checking and editor inference on the lifecycle and event keys.
- */
-export function defineHook(definition) {
-    return definition;
-}
+function defineHook(e){return e}export{defineHook};

package/dist/src/public/definitions/instructions.js

@@ -1,7 +1 @@
-/**
- * Defines an instructions prompt in TypeScript using the same shape
- * discovery produces from markdown.
- */
-export function defineInstructions(definition) {
-    return definition;
-}
+function defineInstructions(e){return e}export{defineInstructions};

package/dist/src/public/definitions/instrumentation.js

@@ -1,13 +1 @@
-/**
- * Defines instrumentation settings for the agent application.
- *
- * Export the result as the default export of `agent/instrumentation.ts`.
- * Ash picks up these settings at server startup and applies them to every
- * AI SDK model call.
- *
- * The `setup` callback is invoked later by the framework with the resolved
- * agent name — it is not called during `defineInstrumentation` itself.
- */
-export function defineInstrumentation(definition) {
-    return definition;
-}
+function defineInstrumentation(e){return e}export{defineInstrumentation};

package/dist/src/public/definitions/remote-agent.js

@@ -1,11 +1 @@
-import { ASH_CREATE_SESSION_ROUTE_PATH } from "#protocol/routes.js";
-/**
- * Defines a remote Ash agent that the parent can call as a subagent tool.
- */
-export function defineRemoteAgent(input) {
-    return {
-        ...input,
-        kind: "remote",
-        path: input.path ?? ASH_CREATE_SESSION_ROUTE_PATH,
-    };
-}
+import{ASH_CREATE_SESSION_ROUTE_PATH}from"#protocol/routes.js";function defineRemoteAgent(e){return{...e,kind:`remote`,path:e.path??ASH_CREATE_SESSION_ROUTE_PATH}}export{defineRemoteAgent};

package/dist/src/public/definitions/sandbox-backend.js

@@ -1,13 +1 @@
-export class SandboxTemplateNotProvisionedError extends Error {
-    backendName;
-    templateKey;
-    constructor(input) {
-        super(`Sandbox template "${input.templateKey}" is not provisioned for backend "${input.backendName}". Run \`ash build\` or invoke \`prewarmAppSandboxes()\` before serving traffic.`);
-        this.name = "SandboxTemplateNotProvisionedError";
-        this.backendName = input.backendName;
-        this.templateKey = input.templateKey;
-    }
-    static is(error) {
-        return error instanceof SandboxTemplateNotProvisionedError;
-    }
-}
+var SandboxTemplateNotProvisionedError=class SandboxTemplateNotProvisionedError extends Error{backendName;templateKey;constructor(e){super(`Sandbox template "${e.templateKey}" is not provisioned for backend "${e.backendName}". Run \`ash build\` or invoke \`prewarmAppSandboxes()\` before serving traffic.`),this.name=`SandboxTemplateNotProvisionedError`,this.backendName=e.backendName,this.templateKey=e.templateKey}static is(e){return e instanceof SandboxTemplateNotProvisionedError}};export{SandboxTemplateNotProvisionedError};

package/dist/src/public/definitions/sandbox.js

@@ -1,6 +1 @@
-/**
- * Defines a sandbox configuration.
- */
-export function defineSandbox(definition) {
-    return definition;
-}
+function defineSandbox(e){return e}export{defineSandbox};

package/dist/src/public/definitions/schedule.js

@@ -1,32 +1 @@
-/**
- * Defines a schedule in TypeScript. Export as the default from
- * `agent/schedules/<name>.ts`.
- *
- * @example Hand off to Slack:
- * ```ts
- * import { defineSchedule } from "experimental-ash/schedules";
- * import slack from "../channels/slack.js";
- *
- * export default defineSchedule({
- *   cron: "0 9 * * 1-5",
- *   async run({ receive, waitUntil, appAuth }) {
- *     waitUntil(receive(slack, {
- *       message: "Post the daily standup summary.",
- *       args: { channelId: "C0123ABC" },
- *       auth: appAuth,
- *     }));
- *   },
- * });
- * ```
- *
- * @example Fire-and-forget:
- * ```ts
- * export default defineSchedule({
- *   cron: "* / 5 * * * *",
- *   markdown: "Sync open Linear issues to the metrics dashboard.",
- * });
- * ```
- */
-export function defineSchedule(definition) {
-    return definition;
-}
+function defineSchedule(e){return e}export{defineSchedule};

package/dist/src/public/definitions/skill.js

@@ -1,7 +1 @@
-/**
- * Defines a skill in TypeScript using the same shape discovery produces from
- * markdown, with optional package-relative sibling files.
- */
-export function defineSkill(definition) {
-    return definition;
-}
+function defineSkill(e){return e}export{defineSkill};

package/dist/src/public/definitions/source.js

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

package/dist/src/public/definitions/state.js

@@ -1,34 +1 @@
-import { ContextKey } from "#context/key.js";
-import { loadContext } from "#context/container.js";
-/**
- * Creates a typed, named state slot backed by a durable `ContextKey`.
- *
- * All operations require an active Ash context — calling `get()` or
- * `update()` outside of tools, hooks, or other framework-managed
- * code throws.
- *
- * State is durable: values survive across workflow step boundaries.
- * To reset per-turn, use `update(() => freshValue)` in a lifecycle
- * hook.
- *
- * ```ts
- * const budget = defineState("my-agent.budget", () => ({ count: 0, cap: 25 }));
- *
- * // In a tool or hook:
- * budget.update((s) => ({ ...s, count: s.count + 1 }));
- * const current = budget.get();
- * ```
- */
-export function defineState(name, initial) {
-    const key = new ContextKey(name);
-    return {
-        get() {
-            return loadContext().ensure(key, initial);
-        },
-        update(fn) {
-            const ctx = loadContext();
-            const current = ctx.ensure(key, initial);
-            ctx.set(key, fn(current));
-        },
-    };
-}
+import{loadContext}from"#context/container.js";import{ContextKey}from"#context/key.js";function defineState(t,n){let r=new ContextKey(t);return{get(){return loadContext().ensure(r,n)},update(e){let t=loadContext(),i=t.ensure(r,n);t.set(r,e(i))}}}export{defineState};

package/dist/src/public/definitions/tool.js

@@ -1,27 +1 @@
-import { stampDefinitionKey } from "#public/tool-result-narrowing.js";
-export function defineTool(definition) {
-    stampDefinitionKey(definition, `tool:${definition.description}`);
-    return definition;
-}
-/**
- * Marker discriminator written into every {@link DisabledToolSentinel}.
- */
-const DISABLED_TOOL_SENTINEL_KIND = "ash:disabled-tool";
-/**
- * Returns a sentinel that disables the framework tool whose name matches the
- * containing file's slug.
- */
-export function disableTool() {
-    return {
-        kind: DISABLED_TOOL_SENTINEL_KIND,
-    };
-}
-/**
- * Type guard: returns whether `value` is a {@link DisabledToolSentinel}
- * produced by {@link disableTool}.
- */
-export function isDisabledToolSentinel(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        value.kind === DISABLED_TOOL_SENTINEL_KIND);
-}
+import{stampDefinitionKey}from"#public/tool-result-narrowing.js";function defineTool(t){return stampDefinitionKey(t,`tool:${t.description}`),t}var DISABLED_TOOL_SENTINEL_KIND=`ash:disabled-tool`;function disableTool(){return{kind:DISABLED_TOOL_SENTINEL_KIND}}function isDisabledToolSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_TOOL_SENTINEL_KIND}export{defineTool,disableTool,isDisabledToolSentinel};

package/dist/src/public/hooks/index.js

@@ -1,9 +1 @@
-/**
- * Hook authoring helpers for `agent/hooks/*.ts` files.
- *
- * Hooks subscribe to lifecycle moments (under `lifecycle:`) and runtime
- * stream events (under `events:`). See {@link defineHook} for the
- * authoring shape and {@link HookContext} for the runtime context every
- * handler receives.
- */
-export { defineHook, } from "../definitions/hook.js";
+import{defineHook}from"../definitions/hook.js";export{defineHook};

package/dist/src/public/index.js

@@ -1,5 +1 @@
-/**
- * Core agent authoring helpers for `agent/agent.ts`.
- */
-export { defineAgent, } from "#public/definitions/agent.js";
-export { defineRemoteAgent, } from "#public/definitions/remote-agent.js";
+import{defineAgent}from"#public/definitions/agent.js";import{defineRemoteAgent}from"#public/definitions/remote-agent.js";export{defineAgent,defineRemoteAgent};

package/dist/src/public/instructions/index.js

@@ -1,4 +1 @@
-/**
- * Instructions prompt authoring helpers for `agent/instructions.ts` files.
- */
-export { defineInstructions, } from "#public/definitions/instructions.js";
+import{defineInstructions}from"#public/definitions/instructions.js";export{defineInstructions};

package/dist/src/public/instrumentation/index.js

@@ -1,4 +1 @@
-/**
- * Instrumentation authoring helpers for `agent/instrumentation.ts`.
- */
-export { defineInstrumentation, } from "#public/definitions/instrumentation.js";
+import{defineInstrumentation}from"#public/definitions/instrumentation.js";export{defineInstrumentation};