experimental-ash 0.18.3 → 0.20.0

package/dist/src/execution/sandbox/bindings/vercel.js

@@ -4,11 +4,17 @@ import { buildSandboxSession } from "#execution/sandbox/session.js";
 import { streamToBuffer } from "#execution/sandbox/stream-utils.js";
 /**
  * Creates the Vercel-backed sandbox backend.
+ *
+ * Any author-supplied `createOptions` are forwarded to the Vercel SDK
+ * `Sandbox.create(...)` for every fresh sandbox the framework creates
+ * (template at prewarm time, session at first-time session-create). On
+ * resume (`Sandbox.get`) no create happens, so they are not re-applied.
  */
 export function createVercelSandboxBackend(input = {}) {
     const loadSandboxModule = input.loadSandboxModule ?? (async () => await import("#compiled/@vercel/sandbox/index.js"));
     const createOptions = {
         timeout: DEFAULT_SANDBOX_TIMEOUT_MS,
+        ...input.createOptions,
     };
     const prewarmedTemplates = new Map();
     return {
@@ -130,10 +136,10 @@ async function ensureTemplate(input) {
     }
     for (const file of input.seedFiles) {
         if (typeof file.content === "string") {
-            await templateSession.writeTextFile(file.path, file.content);
+            await templateSession.writeTextFile({ content: file.content, path: file.path });
         }
         else {
-            await templateSession.writeBinaryFile(file.path, file.content);
+            await templateSession.writeBinaryFile({ content: file.content, path: file.path });
         }
     }
     const snapshot = await sandbox.snapshot();
@@ -150,8 +156,13 @@ async function ensureSession(input) {
         await ensureVercelSandboxTags(existing, input.tags);
         return existing;
     }
+    // The Vercel SDK rejects `runtime` when `source` is a snapshot — the
+    // runtime is already baked into the snapshot's filesystem. Strip it
+    // from the consumer-supplied create options for the session path
+    // only; template prewarm still honors `runtime`.
+    const { runtime: _runtime, ...sessionCreateOptions } = input.createOptions;
     const createParams = {
-        ...input.createOptions,
+        ...sessionCreateOptions,
         name: sandboxName,
         persistent: true,
         source: { snapshotId: input.snapshotId, type: "snapshot" },
@@ -183,24 +194,24 @@ function createHandle(sandbox, sessionKey) {
 function createVercelInternalSandboxSession(sandbox, id) {
     return {
         id,
-        async readFile(resolvedPath) {
-            const stream = await sandbox.readFile({ path: resolvedPath });
-            return stream ?? null;
-        },
         resolvePath: resolveVercelSandboxPath,
-        async runCommand(command, options) {
+        async runCommand(options) {
             const result = await sandbox.runCommand({
-                args: ["-lc", command],
+                args: ["-lc", options.command],
                 cmd: "bash",
-                cwd: options?.workingDirectory ?? WORKSPACE_ROOT,
-                signal: options?.abortSignal,
+                cwd: options.workingDirectory ?? WORKSPACE_ROOT,
+                signal: options.abortSignal,
             });
             const [stdout, stderr] = await Promise.all([result.stdout(), result.stderr()]);
             return { exitCode: result.exitCode, stderr, stdout };
         },
-        async writeFile(resolvedPath, content) {
-            const bytes = await streamToBuffer(content);
-            await sandbox.writeFiles([{ content: bytes, path: resolvedPath }]);
+        async readFile(options) {
+            const stream = await sandbox.readFile({ path: options.path });
+            return stream ?? null;
+        },
+        async writeFile(options) {
+            const bytes = await streamToBuffer(options.content);
+            await sandbox.writeFiles([{ content: bytes, path: options.path }]);
         },
     };
 }

package/dist/src/execution/sandbox/glob-tool.js

@@ -24,7 +24,7 @@ export async function executeGlobOnSandbox(args) {
     const command = (await ripgrepIsAvailable(sandbox))
         ? buildRipgrepCommand({ normalizedPath, pattern: args.pattern })
         : buildPosixFindCommand({ normalizedPath, pattern: args.pattern });
-    const result = await sandbox.runCommand(command);
+    const result = await sandbox.runCommand({ command });
     // Both ripgrep and POSIX find use conventional exit code semantics:
     //   0 — operation succeeded (results may be empty for find)
     //   1 — ripgrep-specific: no matches found (legitimate empty result)

package/dist/src/execution/sandbox/grep-tool.js

@@ -41,7 +41,7 @@ export async function executeGrepOnSandbox(args) {
             normalizedPath,
             pattern: args.pattern,
         });
-    const result = await sandbox.runCommand(command);
+    const result = await sandbox.runCommand({ command });
     // Both ripgrep and POSIX grep use the same conventional exit codes:
     //   0 — one or more matches were found
     //   1 — no matches found (legitimate empty result)

package/dist/src/execution/sandbox/lazy-backend.d.ts

@@ -0,0 +1,15 @@
+import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
+/**
+ * Wraps a backend-producing function in a `SandboxBackend` proxy that
+ * invokes the function exactly once, on first access to any of `.name`,
+ * `.create`, or `.prewarm`. Subsequent accesses return the same cached
+ * underlying backend.
+ *
+ * Used by `defaultBackend()` for env-conditional selection, and by the
+ * authored-definition normalizer when an author passes a callback to
+ * `SandboxDefinition.backend` (e.g. `backend: () => vercelBackend({...})`)
+ * so the factory runs at first use rather than at module load — while
+ * still preserving backend-internal state (such as the Vercel backend's
+ * prewarmed-templates map) across every framework call.
+ */
+export declare function lazyBackend<BO, SO>(factory: () => SandboxBackend<BO, SO>): SandboxBackend<BO, SO>;

package/dist/src/execution/sandbox/lazy-backend.js

@@ -0,0 +1,33 @@
+/**
+ * Wraps a backend-producing function in a `SandboxBackend` proxy that
+ * invokes the function exactly once, on first access to any of `.name`,
+ * `.create`, or `.prewarm`. Subsequent accesses return the same cached
+ * underlying backend.
+ *
+ * Used by `defaultBackend()` for env-conditional selection, and by the
+ * authored-definition normalizer when an author passes a callback to
+ * `SandboxDefinition.backend` (e.g. `backend: () => vercelBackend({...})`)
+ * so the factory runs at first use rather than at module load — while
+ * still preserving backend-internal state (such as the Vercel backend's
+ * prewarmed-templates map) across every framework call.
+ */
+export function lazyBackend(factory) {
+    let resolved;
+    function resolve() {
+        if (resolved === undefined) {
+            resolved = factory();
+        }
+        return resolved;
+    }
+    return {
+        get name() {
+            return resolve().name;
+        },
+        create(input) {
+            return resolve().create(input);
+        },
+        async prewarm(input) {
+            await resolve().prewarm(input);
+        },
+    };
+}

package/dist/src/execution/sandbox/read-file-tool.js

@@ -30,7 +30,7 @@ export async function executeReadFileOnSandbox(args) {
         throw new Error(`offset must be >= 1. Received: ${effectiveOffset}.`);
     }
     // ── Read full file for fingerprinting ───────────────────────────────
-    const rawContent = await sandbox.readTextFile(filePath);
+    const rawContent = await sandbox.readTextFile({ path: filePath });
     if (rawContent === null) {
         throw new Error(`File not found: ${filePath}. Verify the path exists and is accessible in the sandbox.`);
     }

package/dist/src/execution/sandbox/ripgrep-probe.js

@@ -31,6 +31,6 @@ export async function ripgrepIsAvailable(session) {
     }
 }
 async function runProbe(session) {
-    const result = await session.runCommand("command -v rg >/dev/null 2>&1");
+    const result = await session.runCommand({ command: "command -v rg >/dev/null 2>&1" });
     return result.exitCode === 0;
 }

package/dist/src/execution/sandbox/session.js

@@ -9,41 +9,62 @@ import { bufferToStream, streamToBuffer } from "./stream-utils.js";
 export function buildSandboxSession(primitives) {
     return {
         id: primitives.id,
-        async readFile(path) {
-            return await primitives.readFile(primitives.resolvePath(path));
+        resolvePath(path) {
+            return primitives.resolvePath(path);
+        },
+        async runCommand(options) {
+            return await primitives.runCommand(options);
         },
-        async readBinaryFile(path) {
-            const stream = await primitives.readFile(primitives.resolvePath(path));
+        async readFile(options) {
+            return await primitives.readFile({
+                abortSignal: options.abortSignal,
+                path: primitives.resolvePath(options.path),
+            });
+        },
+        async readBinaryFile(options) {
+            const stream = await primitives.readFile({
+                abortSignal: options.abortSignal,
+                path: primitives.resolvePath(options.path),
+            });
             if (stream === null) {
                 return null;
             }
             return await streamToBuffer(stream);
         },
-        async readTextFile(path, options) {
+        async readTextFile(options) {
             validateReadTextFileOptions(options);
-            const stream = await primitives.readFile(primitives.resolvePath(path));
+            const stream = await primitives.readFile({
+                abortSignal: options.abortSignal,
+                path: primitives.resolvePath(options.path),
+            });
             if (stream === null) {
                 return null;
             }
             const buf = await streamToBuffer(stream);
-            const text = decodeBuffer(buf, options?.encoding ?? "utf-8");
+            const text = decodeBytes(buf, options.encoding ?? "utf-8");
             return applyLineRange(text, options);
         },
-        resolvePath(path) {
-            return primitives.resolvePath(path);
-        },
-        async runCommand(command, options) {
-            return await primitives.runCommand(command, options);
+        async writeFile(options) {
+            await primitives.writeFile({
+                abortSignal: options.abortSignal,
+                content: options.content,
+                path: primitives.resolvePath(options.path),
+            });
         },
-        async writeFile(path, content) {
-            await primitives.writeFile(primitives.resolvePath(path), content);
+        async writeBinaryFile(options) {
+            await primitives.writeFile({
+                abortSignal: options.abortSignal,
+                content: bufferToStream(options.content),
+                path: primitives.resolvePath(options.path),
+            });
         },
-        async writeBinaryFile(path, content) {
-            await primitives.writeFile(primitives.resolvePath(path), bufferToStream(content));
-        },
-        async writeTextFile(path, content, options) {
-            const buf = encodeString(content, options?.encoding ?? "utf-8");
-            await primitives.writeFile(primitives.resolvePath(path), bufferToStream(buf));
+        async writeTextFile(options) {
+            const buf = encodeString(options.content, options.encoding ?? "utf-8");
+            await primitives.writeFile({
+                abortSignal: options.abortSignal,
+                content: bufferToStream(buf),
+                path: primitives.resolvePath(options.path),
+            });
         },
     };
 }
@@ -55,9 +76,6 @@ export function buildSandboxSession(primitives) {
  * or when `startLine` exceeds `endLine`.
  */
 function validateReadTextFileOptions(options) {
-    if (options === undefined) {
-        return;
-    }
     const { startLine, endLine } = options;
     if (startLine !== undefined && (!Number.isInteger(startLine) || startLine < 1)) {
         throw new Error("startLine must be a positive integer (1-based).");
@@ -102,39 +120,39 @@ function splitLinesPreservingEndings(content) {
  * endings.
  */
 function applyLineRange(content, options) {
-    if (options?.startLine === undefined && options?.endLine === undefined) {
+    if (options.startLine === undefined && options.endLine === undefined) {
         return content;
     }
     const lines = splitLinesPreservingEndings(content);
     const totalLines = lines.length;
-    const startLine = options?.startLine ?? 1;
-    const endLine = Math.min(options?.endLine ?? totalLines, totalLines);
+    const startLine = options.startLine ?? 1;
+    const endLine = Math.min(options.endLine ?? totalLines, totalLines);
     if (startLine > totalLines) {
         return "";
     }
     return lines.slice(startLine - 1, endLine).join("");
 }
 /**
- * Decodes a Buffer to a string using the given encoding.
+ * Decodes raw bytes to a string using the given encoding.
  *
  * `"utf-8"` uses `TextDecoder` in fatal mode so malformed sequences
  * throw. Other encodings fall back to Node's `Buffer.toString`.
  */
-function decodeBuffer(buf, encoding) {
+function decodeBytes(buf, encoding) {
     if (encoding === "utf-8" || encoding === "utf8") {
         return new TextDecoder("utf-8", { fatal: true }).decode(buf);
     }
-    return buf.toString(encoding);
+    return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding);
 }
 /**
- * Encodes a string to a Buffer using the given encoding.
+ * Encodes a string to raw bytes using the given encoding.
  *
  * `"utf-8"` uses `TextEncoder`; other encodings fall back to
  * `Buffer.from(str, encoding)`.
  */
 function encodeString(str, encoding) {
     if (encoding === "utf-8" || encoding === "utf8") {
-        return Buffer.from(new TextEncoder().encode(str));
+        return new TextEncoder().encode(str);
     }
     return Buffer.from(str, encoding);
 }

package/dist/src/execution/sandbox/stream-utils.d.ts

@@ -4,6 +4,6 @@
  */
 export declare function streamToBuffer(stream: ReadableStream<Uint8Array>): Promise<Buffer>;
 /**
- * Wraps a Buffer as a single-chunk `ReadableStream<Uint8Array>`.
+ * Wraps a byte buffer as a single-chunk `ReadableStream<Uint8Array>`.
  */
-export declare function bufferToStream(buf: Buffer): ReadableStream<Uint8Array>;
+export declare function bufferToStream(buf: Uint8Array): ReadableStream<Uint8Array>;

package/dist/src/execution/sandbox/stream-utils.js

@@ -10,7 +10,7 @@ export async function streamToBuffer(stream) {
     return Buffer.concat(chunks);
 }
 /**
- * Wraps a Buffer as a single-chunk `ReadableStream<Uint8Array>`.
+ * Wraps a byte buffer as a single-chunk `ReadableStream<Uint8Array>`.
  */
 export function bufferToStream(buf) {
     return new ReadableStream({

package/dist/src/execution/sandbox/write-file-tool.js

@@ -24,10 +24,10 @@ export async function executeWriteFileOnSandbox(args) {
     // cost: the entire file is read and hashed before every write. A
     // separate `exists()` primitive would avoid this for new files but
     // would require a sandbox session API change.
-    const currentContent = await sandbox.readTextFile(filePath);
+    const currentContent = await sandbox.readTextFile({ path: filePath });
     if (currentContent === null) {
         // ── File does not exist — write immediately, no prior read needed ──
-        await sandbox.writeTextFile(filePath, content);
+        await sandbox.writeTextFile({ content, path: filePath });
         const freshStamp = createReadFileStamp({
             content,
             filePath: normalizedPath,
@@ -52,7 +52,7 @@ export async function executeWriteFileOnSandbox(args) {
             "Please read the file again before modifying it.");
     }
     // ── Write and refresh stamp ─────────────────────────────────────────
-    await sandbox.writeTextFile(filePath, content);
+    await sandbox.writeTextFile({ content, path: filePath });
     const freshStamp = createReadFileStamp({
         content,
         filePath: normalizedPath,

package/dist/src/execution/skills/types.d.ts

@@ -3,7 +3,7 @@
  */
 export interface SkillFile {
     /** Reads the file content as bytes. */
-    bytes(): Promise<Buffer>;
+    bytes(): Promise<Uint8Array>;
     /** Reads the file content as UTF-8 text. */
     text(): Promise<string>;
 }

package/dist/src/execution/workflow-entry.d.ts

@@ -1,4 +1,4 @@
-import type { UserContent } from "ai";
+import type { RunInput } from "#channel/types.js";
 /**
  * Serializable input for the workflow entrypoint.
  *
@@ -9,9 +9,7 @@ import type { UserContent } from "ai";
  * the serialized record.
  */
 export interface WorkflowEntryInput {
-    readonly input: {
-        readonly message: string | UserContent;
-    };
+    readonly input: RunInput["input"];
     readonly serializedContext: Record<string, unknown>;
 }
 /**

package/dist/src/execution/workflow-entry.js

@@ -41,7 +41,7 @@ export async function workflowEntry(input) {
             capabilities,
             initialInput: {
                 kind: "deliver",
-                payloads: [{ message: input.input.message }],
+                payloads: [{ message: input.input.message, modelContext: input.input.modelContext }],
             },
             mode,
             serializedContext: input.serializedContext,

package/dist/src/harness/attachment-staging.js

@@ -171,7 +171,7 @@ async function hydrateMessageContent(content, sandbox) {
         if (!shouldInlineSandboxRefAsBytes(ref)) {
             return renderSandboxRefAsTextPart(ref);
         }
-        const bytes = await sandbox.readBinaryFile(ref.path);
+        const bytes = await sandbox.readBinaryFile({ path: ref.path });
         if (bytes === null) {
             throw new Error(`Sandbox-ref FilePart references missing file: "${ref.path}". ` +
                 "The staging pipeline invariant (every ash-sandbox: ref has bytes on disk) was violated.");
@@ -230,21 +230,20 @@ async function stageFilePart(part, sandbox, adapterCtx) {
     }
     return stageResolvedBytes(part, { bytes }, sandbox);
 }
-function stageResolvedBytes(part, resolved, sandbox) {
+async function stageResolvedBytes(part, resolved, sandbox) {
     const bytes = resolved.bytes;
     const sha = sha256Prefix(bytes);
     const mediaType = resolved.mediaType ?? part.mediaType ?? DEFAULT_MEDIA_TYPE;
     const name = safeFilename(resolved.filename ?? part.filename, sha);
     const authored = `${ATTACHMENTS_ROOT}/${sha}/${name}`;
-    return sandbox.writeBinaryFile(authored, bytes).then(() => {
-        const resolvedPath = sandbox.resolvePath(authored);
-        return {
-            ...part,
-            data: encodeSandboxRef({ mediaType, path: resolvedPath, size: bytes.byteLength }),
-            filename: resolvedPath,
-            mediaType,
-        };
-    });
+    await sandbox.writeBinaryFile({ content: bytes, path: authored });
+    const resolvedPath = sandbox.resolvePath(authored);
+    return {
+        ...part,
+        data: encodeSandboxRef({ mediaType, path: resolvedPath, size: bytes.byteLength }),
+        filename: resolvedPath,
+        mediaType,
+    };
 }
 async function tryFetchFile(url, adapterCtx) {
     const adapter = adapterCtx.ctx.get(ChannelKey);

package/dist/src/harness/execute-tool.d.ts

@@ -22,4 +22,5 @@ export interface HarnessToolDefinition {
     readonly name: string;
     readonly needsApproval?: (ctx: NeedsApprovalContext) => boolean;
     readonly runtimeAction?: HarnessRuntimeActionDefinition;
+    readonly toModelOutput?: (output: unknown) => unknown;
 }

package/dist/src/harness/messages.js

@@ -14,6 +14,10 @@ export function coalesceTurnInputs(a, b) {
         a: a.message,
         b: b.message,
     });
+    const modelContext = coalesceModelContext({
+        a: a.modelContext,
+        b: b.modelContext,
+    });
     const result = {};
     if (inputResponses !== undefined) {
         result.inputResponses = inputResponses;
@@ -21,6 +25,9 @@ export function coalesceTurnInputs(a, b) {
     if (message !== undefined) {
         result.message = message;
     }
+    if (modelContext !== undefined) {
+        result.modelContext = modelContext;
+    }
     return result;
 }
 /**
@@ -73,6 +80,14 @@ function coalesceInputResponses(input) {
     }
     return [...a, ...b];
 }
+function coalesceModelContext(input) {
+    const a = input.a ?? [];
+    const b = input.b ?? [];
+    if (a.length === 0 && b.length === 0) {
+        return undefined;
+    }
+    return [...a, ...b];
+}
 /**
  * Merges two optional turn messages into one.
  *

package/dist/src/harness/tools.js

@@ -26,6 +26,11 @@ export function buildToolSet(input) {
             execute: definition.execute,
             inputSchema: definition.inputSchema,
             needsApproval: buildNeedsApprovalFn(definition, input),
+            ...(definition.toModelOutput !== undefined
+                ? {
+                    toModelOutput: ({ output }) => definition.toModelOutput(output),
+                }
+                : {}),
         });
     }
     return tools;

package/dist/src/harness/types.d.ts

@@ -79,13 +79,12 @@ export interface StepInput {
     readonly inputResponses?: readonly InputResponse[];
     readonly message?: string | UserContent;
     /**
-     * Ephemeral messages contributed by lifecycle hooks (via the
-     * `modelContext` field on a {@link LifecycleHookResult}), appended to
-     * the next model call's message list and never persisted to durable
-     * session history.
-     *
-     * Internal to the execution/harness boundary; never produced by
-     * channels.
+     * Ephemeral messages appended to the next model call and never
+     * persisted to durable session history. Populated by channels via
+     * `SendPayload.modelContext` and by lifecycle hooks via the
+     * `modelContext` field on a `LifecycleHookResult`. Channel-provided
+     * messages appear first, then session-hook messages, then turn-hook
+     * messages.
      */
     readonly modelContext?: readonly ModelMessage[];
     /**

package/dist/src/internal/application/package.js

@@ -6,7 +6,7 @@ import { ASH_PACKAGE_NAME } from "#package-name.js";
 let cachedPackageInfo;
 // The package build stamps the published version into `dist` so bundled
 // deployments can still report package metadata without resolving package.json.
-const BUNDLED_FALLBACK_PACKAGE_VERSION = "0.18.3";
+const BUNDLED_FALLBACK_PACKAGE_VERSION = "0.20.0";
 const BUNDLED_FALLBACK_PACKAGE_VERSION_PLACEHOLDER = "__ASH_PACKAGE_VERSION_PLACEHOLDER__";
 const WORKFLOW_MODULE_ALIASES = {
     "workflow/api": "src/compiled/@workflow/core/runtime.js",

package/dist/src/internal/authored-definition/sandbox.d.ts

@@ -1,9 +1,15 @@
+import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
 import type { SandboxDefinition } from "#public/definitions/sandbox.js";
-export type NormalizedSandboxDefinition = Readonly<SandboxDefinition> & {
+export type NormalizedSandboxDefinition = Readonly<Omit<SandboxDefinition, "backend">> & {
+    readonly backend?: SandboxBackend;
     readonly description?: string;
 };
 /**
  * Normalizes one authored sandbox definition into the canonical internal
- * shape.
+ * shape. If the author supplied a `backend` callback (e.g.
+ * `backend: () => vercelBackend({...})`), it is wrapped via
+ * {@link lazyBackend} so downstream consumers always see a plain
+ * `SandboxBackend` value — the callback fires exactly once on first
+ * access and the resulting backend is memoized.
  */
 export declare function normalizeSandboxDefinition(value: unknown, message: string): NormalizedSandboxDefinition;

package/dist/src/internal/authored-definition/sandbox.js

@@ -1,7 +1,12 @@
 import { expectFunction, expectObjectRecord, expectOnlyKnownKeys, } from "#internal/authored-module.js";
+import { lazyBackend } from "#execution/sandbox/lazy-backend.js";
 /**
  * Normalizes one authored sandbox definition into the canonical internal
- * shape.
+ * shape. If the author supplied a `backend` callback (e.g.
+ * `backend: () => vercelBackend({...})`), it is wrapped via
+ * {@link lazyBackend} so downstream consumers always see a plain
+ * `SandboxBackend` value — the callback fires exactly once on first
+ * access and the resulting backend is memoized.
  */
 export function normalizeSandboxDefinition(value, message) {
     const record = expectObjectRecord(value, message);
@@ -25,7 +30,10 @@ export function normalizeSandboxDefinition(value, message) {
     return definition;
 }
 function expectSandboxBackend(value, message) {
-    const record = expectObjectRecord(value, `${message} The "backend" field must be a SandboxBackend value (use vercelBackend(), localBackend(), or your own factory).`);
+    if (typeof value === "function") {
+        return lazyBackend(value);
+    }
+    const record = expectObjectRecord(value, `${message} The "backend" field must be a SandboxBackend value (use vercelBackend(), localBackend(), or your own factory) or a zero-arg function returning one.`);
     if (typeof record.name !== "string" || record.name.length === 0) {
         throw new Error(`${message} The "backend" value must expose a non-empty string "name" identifier.`);
     }

package/dist/src/internal/authored-definition/schema-backed.js

@@ -12,7 +12,15 @@ export function normalizeToolDefinition(value, message) {
         return { kind: "disabled" };
     }
     const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, ["description", "execute", "inputSchema", "needsApproval", "onCompact", "retentionPolicy"], message);
+    expectOnlyKnownKeys(record, [
+        "description",
+        "execute",
+        "inputSchema",
+        "needsApproval",
+        "onCompact",
+        "retentionPolicy",
+        "toModelOutput",
+    ], message);
     const inputSchema = record.inputSchema === undefined ? null : normalizeJsonSchemaDefinition(record.inputSchema);
     const definition = {
         description: expectString(record.description, message),
@@ -38,6 +46,9 @@ export function normalizeToolDefinition(value, message) {
             throw new Error(`${message} Expected \`retentionPolicy\` to be "auto", "keep", or a function.`);
         }
     }
+    if (record.toModelOutput !== undefined) {
+        expectFunction(record.toModelOutput, message);
+    }
     return {
         kind: "tool",
         definition,

package/dist/src/internal/nitro/host/configure-nitro-routes.js

@@ -107,7 +107,7 @@ function buildWorkflowFileHandlerSource(input) {
             }
             lines.push(`import { POST as ${handler.binding} } from ${JSON.stringify(handler.importSpecifier)};`);
         }
-        lines.push(`import { getWorld as __ashGetWorkflowWorld } from ${JSON.stringify(input.runtimeImportSpecifier)};`, "", "try {", "  const __ashWorkflowWorld = __ashGetWorkflowWorld();", '  if (typeof __ashWorkflowWorld?.registerHandler === "function") {');
+        lines.push(`import { getWorld as __ashGetWorkflowWorld } from ${JSON.stringify(input.runtimeImportSpecifier)};`, "", "try {", "  const __ashWorkflowWorld = await __ashGetWorkflowWorld();", '  if (typeof __ashWorkflowWorld?.registerHandler === "function") {');
         for (const handler of handlerBindings) {
             lines.push(`    __ashWorkflowWorld.registerHandler(${JSON.stringify(handler.queuePrefix)}, ${handler.binding});`);
         }

package/dist/src/internal/workflow-bundle/builder-support.d.ts

@@ -67,4 +67,5 @@ export declare function bundleFinalWorkflowOutput(input: {
 export declare function convertStepsManifest(steps: WorkflowManifest["steps"]): Record<string, unknown>;
 export declare function convertWorkflowsManifest(workflows: WorkflowManifest["workflows"]): Record<string, unknown>;
 export declare function convertClassesManifest(classes: WorkflowManifest["classes"]): Record<string, unknown>;
+export declare function atomicWriteFile(targetPath: string, contents: string | Buffer | Uint8Array): Promise<void>;
 export {};

package/dist/src/internal/workflow-bundle/builder-support.js

@@ -360,3 +360,17 @@ function createManifestRelativeFilepath(workingDir, absolutePath) {
 function isJavaScriptLikePath(path) {
     return /\.(?:[cm]?[jt]sx?)$/.test(path);
 }
+/*
+ * Some generated workflow artifacts (notably `workflows.mjs`) are read by
+ * Nitro's Rolldown bundler concurrently with rebuilds during `ash dev`. A
+ * plain `writeFile` truncates the target first and streams bytes, so a
+ * reader can observe an empty or partial module mid-write and report
+ * spurious "missing export" errors. Writing to a sibling temp file and
+ * renaming relies on POSIX `rename` atomicity so readers always see
+ * either the old or the new contents.
+ */
+export async function atomicWriteFile(targetPath, contents) {
+    const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now().toString(36)}`;
+    await writeFile(tmpPath, contents);
+    await rename(tmpPath, targetPath);
+}