experimental-ash 0.26.0 → 0.28.0

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

@@ -1,158 +1,3 @@
-import { bufferToStream, streamToBuffer } from "./stream-utils.js";
-/**
- * Builds a public {@link SandboxSession} from backend-specific primitives.
- *
- * Encoding handling, line-range slicing, and the binary/text/stream
- * variants live here so each backend only has to implement byte-oriented
- * read/write primitives.
- */
-export function buildSandboxSession(primitives) {
-    return {
-        id: primitives.id,
-        resolvePath(path) {
-            return primitives.resolvePath(path);
-        },
-        async runCommand(options) {
-            return await primitives.runCommand(options);
-        },
-        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(options) {
-            validateReadTextFileOptions(options);
-            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 = decodeBytes(buf, options.encoding ?? "utf-8");
-            return applyLineRange(text, options);
-        },
-        async writeFile(options) {
-            await primitives.writeFile({
-                abortSignal: options.abortSignal,
-                content: options.content,
-                path: primitives.resolvePath(options.path),
-            });
-        },
-        async writeBinaryFile(options) {
-            await primitives.writeFile({
-                abortSignal: options.abortSignal,
-                content: bufferToStream(options.content),
-                path: primitives.resolvePath(options.path),
-            });
-        },
-        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),
-            });
-        },
-    };
-}
-/**
- * Validates the optional line-range options for
- * {@link SandboxSession.readTextFile}.
- *
- * Throws a descriptive error when values are non-integer, less than 1,
- * or when `startLine` exceeds `endLine`.
- */
-function validateReadTextFileOptions(options) {
-    const { startLine, endLine } = options;
-    if (startLine !== undefined && (!Number.isInteger(startLine) || startLine < 1)) {
-        throw new Error("startLine must be a positive integer (1-based).");
-    }
-    if (endLine !== undefined && (!Number.isInteger(endLine) || endLine < 1)) {
-        throw new Error("endLine must be a positive integer (1-based).");
-    }
-    if (startLine !== undefined && endLine !== undefined && startLine > endLine) {
-        throw new Error("startLine must not be greater than endLine.");
-    }
-}
-/**
- * Splits content into lines preserving original line endings.
- */
-function splitLinesPreservingEndings(content) {
-    const lines = [];
-    let start = 0;
-    for (let i = 0; i < content.length; i++) {
-        if (content[i] === "\r") {
-            if (i + 1 < content.length && content[i + 1] === "\n") {
-                lines.push(content.slice(start, i + 2));
-                start = i + 2;
-                i++;
-            }
-            else {
-                lines.push(content.slice(start, i + 1));
-                start = i + 1;
-            }
-        }
-        else if (content[i] === "\n") {
-            lines.push(content.slice(start, i + 1));
-            start = i + 1;
-        }
-    }
-    if (start < content.length) {
-        lines.push(content.slice(start));
-    }
-    return lines;
-}
-/**
- * Returns the line-range slice of `content`, preserving original line
- * endings.
- */
-function applyLineRange(content, options) {
-    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);
-    if (startLine > totalLines) {
-        return "";
-    }
-    return lines.slice(startLine - 1, endLine).join("");
-}
-/**
- * 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 decodeBytes(buf, encoding) {
-    if (encoding === "utf-8" || encoding === "utf8") {
-        return new TextDecoder("utf-8", { fatal: true }).decode(buf);
-    }
-    return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString(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 new TextEncoder().encode(str);
-    }
-    return Buffer.from(str, encoding);
-}
+import{bufferToStream,streamToBuffer}from"./stream-utils.js";function buildSandboxSession(n){return{id:n.id,resolvePath(e){return n.resolvePath(e)},async runCommand(e){return await n.runCommand(e)},async readFile(e){return await n.readFile({abortSignal:e.abortSignal,path:n.resolvePath(e.path)})},async readBinaryFile(e){let r=await n.readFile({abortSignal:e.abortSignal,path:n.resolvePath(e.path)});return r===null?null:await streamToBuffer(r)},async readTextFile(e){validateReadTextFileOptions(e);let r=await n.readFile({abortSignal:e.abortSignal,path:n.resolvePath(e.path)});return r===null?null:applyLineRange(decodeBytes(await streamToBuffer(r),e.encoding??`utf-8`),e)},async writeFile(e){await n.writeFile({abortSignal:e.abortSignal,content:e.content,path:n.resolvePath(e.path)})},async writeBinaryFile(t){await n.writeFile({abortSignal:t.abortSignal,content:bufferToStream(t.content),path:n.resolvePath(t.path)})},async writeTextFile(t){let r=encodeString(t.content,t.encoding??`utf-8`);await n.writeFile({abortSignal:t.abortSignal,content:bufferToStream(r),path:n.resolvePath(t.path)})}}}function validateReadTextFileOptions(e){let{startLine:t,endLine:n}=e;if(t!==void 0&&(!Number.isInteger(t)||t<1))throw Error(`startLine must be a positive integer (1-based).`);if(n!==void 0&&(!Number.isInteger(n)||n<1))throw Error(`endLine must be a positive integer (1-based).`);if(t!==void 0&&n!==void 0&&t>n)throw Error(`startLine must not be greater than endLine.`)}function splitLinesPreservingEndings(e){let t=[],n=0;for(let r=0;r<e.length;r++)e[r]===`\r`?r+1<e.length&&e[r+1]===`
+`?(t.push(e.slice(n,r+2)),n=r+2,r++):(t.push(e.slice(n,r+1)),n=r+1):e[r]===`
+`&&(t.push(e.slice(n,r+1)),n=r+1);return n<e.length&&t.push(e.slice(n)),t}function applyLineRange(e,t){if(t.startLine===void 0&&t.endLine===void 0)return e;let n=splitLinesPreservingEndings(e),r=n.length,i=t.startLine??1,a=Math.min(t.endLine??r,r);return i>r?``:n.slice(i-1,a).join(``)}function decodeBytes(e,t){return t===`utf-8`||t===`utf8`?new TextDecoder(`utf-8`,{fatal:!0}).decode(e):Buffer.from(e.buffer,e.byteOffset,e.byteLength).toString(t)}function encodeString(e,t){return t===`utf-8`||t===`utf8`?new TextEncoder().encode(e):Buffer.from(e,t)}export{buildSandboxSession};

package/dist/src/execution/sandbox/shell-quote.js

@@ -1,14 +1 @@
-/**
- * Wraps a value in POSIX single-quotes, escaping any embedded single-quotes.
- *
- * Used by the `glob` and `grep` execution cores to safely embed model-supplied
- * patterns, paths, and globs into shell commands run via `sandbox.runCommand`.
- *
- * The quoting strategy is the standard POSIX approach: wrap the value in
- * single-quotes and replace each embedded `'` with `'\''` (end the
- * single-quoted string, insert an escaped single-quote, re-open
- * single-quoting).
- */
-export function shellQuote(value) {
-    return `'${value.replace(/'/g, "'\\''")}'`;
-}
+function shellQuote(e){return`'${e.replace(/'/g,`'\\''`)}'`}export{shellQuote};

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

@@ -1,22 +1 @@
-/**
- * Collects all chunks of a `ReadableStream<Uint8Array>` into a single
- * Buffer.
- */
-export async function streamToBuffer(stream) {
-    const chunks = [];
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks);
-}
-/**
- * Wraps a byte buffer as a single-chunk `ReadableStream<Uint8Array>`.
- */
-export function bufferToStream(buf) {
-    return new ReadableStream({
-        start(controller) {
-            controller.enqueue(buf);
-            controller.close();
-        },
-    });
-}
+async function streamToBuffer(e){let t=[];for await(let n of e)t.push(n);return Buffer.concat(t)}function bufferToStream(e){return new ReadableStream({start(t){t.enqueue(e),t.close()}})}export{bufferToStream,streamToBuffer};

package/dist/src/execution/sandbox/truncate-output.js

@@ -1,110 +1,3 @@
-/**
- * Shared output truncation utilities for framework tool executors.
- *
- * Every framework tool that can return unbounded text output (bash,
- * grep, glob, read_file, web_fetch) uses these helpers to enforce
- * consistent size limits inside its executor before the result enters
- * conversation history. Authored tools are expected to do the same —
- * bounding at the source keeps the contract simple: whatever `execute`
- * returns is what the model sees.
- */
-/**
- * Maximum number of lines kept after truncation.
- */
-export const MAX_OUTPUT_LINES = 2000;
-/**
- * Maximum byte size of the truncated output.
- */
-export const MAX_OUTPUT_BYTES = 50 * 1024;
-/**
- * Maximum length of a single line before it is truncated.
- */
-export const MAX_LINE_LENGTH = 2000;
-/**
- * Suffix appended to lines exceeding {@link MAX_LINE_LENGTH}.
- */
-export const LINE_TRUNCATION_SUFFIX = " [truncated]";
-/**
- * Keeps the **first** lines of `text` that fit within the line and byte
- * budgets. This is the default shape of tool-result truncation — most
- * tool output (file contents, grep results, web fetches) is more
- * informative at the beginning.
- *
- * Each included line is individually capped at {@link MAX_LINE_LENGTH}
- * characters. Iteration starts from the beginning and stops when either
- * the line count reaches {@link MAX_OUTPUT_LINES} or cumulative byte
- * size would exceed {@link MAX_OUTPUT_BYTES}.
- */
-export function truncateHead(text) {
-    return truncateByDirection(text, "head");
-}
-/**
- * Keeps the **last** lines of `text` that fit within the line and byte
- * budgets. Useful for bash output where errors and results appear at
- * the end.
- *
- * Each included line is individually capped at {@link MAX_LINE_LENGTH}
- * characters. Iteration starts from the end and stops when either the
- * line count reaches {@link MAX_OUTPUT_LINES} or cumulative byte size
- * would exceed {@link MAX_OUTPUT_BYTES}.
- */
-export function truncateTail(text) {
-    return truncateByDirection(text, "tail");
-}
-/**
- * Shared truncation loop used by {@link truncateHead} and
- * {@link truncateTail}. The only difference between the two is the
- * iteration direction; all other budgeting logic is identical.
- */
-function truncateByDirection(text, direction) {
-    const rawLines = text.split("\n");
-    const totalLines = countLogicalLines(rawLines);
-    const fromStart = direction === "head";
-    const kept = [];
-    let bytes = 0;
-    const start = fromStart ? 0 : rawLines.length - 1;
-    const step = fromStart ? 1 : -1;
-    for (let i = start; i >= 0 && i < rawLines.length && kept.length < MAX_OUTPUT_LINES; i += step) {
-        const line = capLineLength(rawLines[i] ?? "");
-        const lineBytes = Buffer.byteLength(line, "utf8") + 1;
-        if (bytes + lineBytes > MAX_OUTPUT_BYTES && kept.length > 0) {
-            break;
-        }
-        kept.push(line);
-        bytes += lineBytes;
-    }
-    if (!fromStart) {
-        kept.reverse();
-    }
-    return {
-        output: kept.join("\n"),
-        outputLines: kept.length,
-        totalLines,
-        truncated: kept.length < totalLines,
-    };
-}
-/**
- * Caps a single line at {@link MAX_LINE_LENGTH} characters, appending
- * {@link LINE_TRUNCATION_SUFFIX} when truncated.
- *
- * Exported for tools that build their own output line-by-line (e.g.
- * `read_file` prepends line numbers, `grep` counts matches) so they
- * share the same per-line cap as {@link truncateHead} / {@link truncateTail}
- * without re-implementing the slice+suffix pattern.
- */
-export function capLineLength(line) {
-    if (line.length <= MAX_LINE_LENGTH) {
-        return line;
-    }
-    return line.slice(0, MAX_LINE_LENGTH) + LINE_TRUNCATION_SUFFIX;
-}
-/**
- * Counts logical lines, treating a trailing empty element from
- * `split("\n")` as not a separate line (consistent with read-file-tool).
- */
-function countLogicalLines(lines) {
-    if (lines.length > 0 && lines[lines.length - 1] === "") {
-        return lines.length - 1;
-    }
-    return lines.length;
-}
+var MAX_OUTPUT_LINES=2e3,MAX_OUTPUT_BYTES=50*1024,MAX_LINE_LENGTH=2e3,LINE_TRUNCATION_SUFFIX=` [truncated]`;function truncateHead(e){return truncateByDirection(e,`head`)}function truncateTail(e){return truncateByDirection(e,`tail`)}function truncateByDirection(e,t){let n=e.split(`
+`),r=countLogicalLines(n),i=t===`head`,a=[],o=0,s=i?0:n.length-1,c=i?1:-1;for(let e=s;e>=0&&e<n.length&&a.length<2e3;e+=c){let t=capLineLength(n[e]??``),r=Buffer.byteLength(t,`utf8`)+1;if(o+r>51200&&a.length>0)break;a.push(t),o+=r}return i||a.reverse(),{output:a.join(`
+`),outputLines:a.length,totalLines:r,truncated:a.length<r}}function capLineLength(e){return e.length<=2e3?e:e.slice(0,MAX_LINE_LENGTH)+LINE_TRUNCATION_SUFFIX}function countLogicalLines(e){return e.length>0&&e[e.length-1]===``?e.length-1:e.length}export{LINE_TRUNCATION_SUFFIX,MAX_LINE_LENGTH,MAX_OUTPUT_BYTES,MAX_OUTPUT_LINES,capLineLength,truncateHead,truncateTail};

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

@@ -1,62 +1 @@
-import { loadContext } from "#context/container.js";
-import { buildReadFileTargetKey, createReadFileStamp, normalizeModelPath, ReadFileStateKey, setReadFileStamp, } from "#runtime/framework-tools/file-state.js";
-import { requireSandboxSession, validateAbsoluteFilePath, } from "#execution/sandbox/require-sandbox.js";
-// ---------------------------------------------------------------------------
-// Executor
-// ---------------------------------------------------------------------------
-/**
- * Writes one text file to the sandbox with read-before-write
- * enforcement and stale-read detection for existing files.
- *
- * Used by the framework `write_file` tool and by author tools
- * constructed via `defineWriteFileTool`.
- */
-export async function executeWriteFileOnSandbox(args) {
-    const { filePath, content } = args;
-    validateAbsoluteFilePath(filePath);
-    const sandbox = await requireSandboxSession();
-    const ctx = loadContext();
-    const normalizedPath = normalizeModelPath(filePath);
-    const targetKey = buildReadFileTargetKey(normalizedPath);
-    // ── Read current file ───────────────────────────────────────────────
-    // The full read is required even for new-file detection because
-    // stale-write detection hashes the current content. This is a known
-    // 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({ path: filePath });
-    if (currentContent === null) {
-        // ── File does not exist — write immediately, no prior read needed ──
-        await sandbox.writeTextFile({ content, path: filePath });
-        const freshStamp = createReadFileStamp({
-            content,
-            filePath: normalizedPath,
-        });
-        setReadFileStamp(ctx, targetKey, freshStamp);
-        return { existed: false, path: normalizedPath };
-    }
-    // ── File exists — enforce read-before-write ─────────────────────────
-    const state = ctx.ensure(ReadFileStateKey, () => ({ byTarget: {} }));
-    const storedStamp = state.byTarget[targetKey];
-    if (storedStamp === undefined) {
-        throw new Error(`You must read file ${filePath} before overwriting it. Use the read_file tool first.`);
-    }
-    // ── Stale-read detection ────────────────────────────────────────────
-    const currentStamp = createReadFileStamp({
-        content: currentContent,
-        filePath: normalizedPath,
-    });
-    if (currentStamp.contentHash !== storedStamp.contentHash ||
-        currentStamp.byteLength !== storedStamp.byteLength) {
-        throw new Error(`File ${filePath} has been modified since it was last read. ` +
-            "Please read the file again before modifying it.");
-    }
-    // ── Write and refresh stamp ─────────────────────────────────────────
-    await sandbox.writeTextFile({ content, path: filePath });
-    const freshStamp = createReadFileStamp({
-        content,
-        filePath: normalizedPath,
-    });
-    setReadFileStamp(ctx, targetKey, freshStamp);
-    return { existed: true, path: normalizedPath };
-}
+import{loadContext}from"#context/container.js";import{requireSandboxSession,validateAbsoluteFilePath}from"#execution/sandbox/require-sandbox.js";import{ReadFileStateKey,buildReadFileTargetKey,createReadFileStamp,normalizeModelPath,setReadFileStamp}from"#runtime/framework-tools/file-state.js";async function executeWriteFileOnSandbox(e){let{filePath:t,content:n}=e;validateAbsoluteFilePath(t);let r=await requireSandboxSession(),i=loadContext(),a=normalizeModelPath(t),o=buildReadFileTargetKey(a),s=await r.readTextFile({path:t});if(s===null)return await r.writeTextFile({content:n,path:t}),setReadFileStamp(i,o,createReadFileStamp({content:n,filePath:a})),{existed:!1,path:a};let c=i.ensure(ReadFileStateKey,()=>({byTarget:{}})).byTarget[o];if(c===void 0)throw Error(`You must read file ${t} before overwriting it. Use the read_file tool first.`);let l=createReadFileStamp({content:s,filePath:a});if(l.contentHash!==c.contentHash||l.byteLength!==c.byteLength)throw Error(`File ${t} has been modified since it was last read. Please read the file again before modifying it.`);return await r.writeTextFile({content:n,path:t}),setReadFileStamp(i,o,createReadFileStamp({content:n,filePath:a})),{existed:!0,path:a}}export{executeWriteFileOnSandbox};

package/dist/src/execution/session-callback-step.js

@@ -1,72 +1 @@
-import { parseSessionCallback } from "#channel/session-callback.js";
-import { SessionCallbackKey } from "#context/keys.js";
-import { createLogger } from "#internal/logging.js";
-import { toErrorMessage } from "#shared/errors.js";
-const SESSION_CALLBACK_TIMEOUT_MS = 30_000;
-const log = createLogger("execution.session-callback");
-/**
- * Sends the configured session terminal callback.
- *
- * Absence is a no-op. Once callback metadata is present, delivery is part of
- * the remote delegation result path, so failures are logged and rethrown
- * instead of being reported as a successful terminal step. Throwing is
- * intentional: this function runs as a durable Workflow step, so rejection
- * hands retry/failure policy back to the Workflow orchestrator rather than
- * letting Ash falsely mark the callback delivery as complete.
- */
-export async function fireSessionCallbackStep(input) {
-    "use step";
-    const sessionId = input.serializedContext["ash.sessionId"] ?? "";
-    const value = input.serializedContext[SessionCallbackKey.name];
-    if (value === undefined) {
-        return;
-    }
-    try {
-        const callback = parseSerializedSessionCallback(value);
-        const body = input.status === "completed"
-            ? {
-                callId: callback.callId,
-                kind: "session.completed",
-                output: input.output ?? "",
-                sessionId,
-                subagentName: callback.subagentName,
-            }
-            : {
-                callId: callback.callId,
-                error: {
-                    code: "SESSION_FAILED",
-                    message: toErrorMessage(input.error),
-                },
-                kind: "session.failed",
-                sessionId,
-                subagentName: callback.subagentName,
-            };
-        const response = await fetch(callback.url, {
-            body: JSON.stringify(body),
-            headers: {
-                "content-type": "application/json",
-            },
-            method: "POST",
-            signal: AbortSignal.timeout(SESSION_CALLBACK_TIMEOUT_MS),
-        });
-        if (!response.ok) {
-            throw new Error(`Session callback failed with HTTP ${response.status}.`);
-        }
-    }
-    catch (error) {
-        log.error("failed to post session callback", {
-            error,
-            sessionId,
-        });
-        throw error;
-    }
-}
-function parseSerializedSessionCallback(value) {
-    const parsed = parseSessionCallback(value);
-    if (!parsed.ok) {
-        throw new Error("Serialized session callback is invalid.", {
-            cause: parsed.cause,
-        });
-    }
-    return parsed.callback;
-}
+import{createLogger}from"#internal/logging.js";import{toErrorMessage}from"#shared/errors.js";import{SessionCallbackKey}from"#context/keys.js";import{parseSessionCallback}from"#channel/session-callback.js";var SESSION_CALLBACK_TIMEOUT_MS=3e4,log=createLogger(`execution.session-callback`);async function fireSessionCallbackStep(e){"use step";let r=e.serializedContext[`ash.sessionId`]??``,a=e.serializedContext[SessionCallbackKey.name];if(a!==void 0)try{let n=parseSerializedSessionCallback(a),i=e.status===`completed`?{callId:n.callId,kind:`session.completed`,output:e.output??``,sessionId:r,subagentName:n.subagentName}:{callId:n.callId,error:{code:`SESSION_FAILED`,message:toErrorMessage(e.error)},kind:`session.failed`,sessionId:r,subagentName:n.subagentName},o=await fetch(n.url,{body:JSON.stringify(i),headers:{"content-type":`application/json`},method:`POST`,signal:AbortSignal.timeout(SESSION_CALLBACK_TIMEOUT_MS)});if(!o.ok)throw Error(`Session callback failed with HTTP ${o.status}.`)}catch(e){throw log.error(`failed to post session callback`,{error:e,sessionId:r}),e}}function parseSerializedSessionCallback(e){let t=parseSessionCallback(e);if(!t.ok)throw Error(`Serialized session callback is invalid.`,{cause:t.cause});return t.callback}export{fireSessionCallbackStep};

package/dist/src/execution/session.js

@@ -1,94 +1,3 @@
-const DEFAULT_COMPACTION_RECENT_WINDOW_SIZE = 10;
-const DEFAULT_COMPACTION_THRESHOLD_PERCENT = 0.9;
-const FALLBACK_COMPACTION_THRESHOLD = 100_000;
-/**
- * Creates the durable compaction configuration used by one harness session.
- */
-export function createCompactionConfig(input = {}) {
-    const thresholdPercent = input.thresholdPercent ?? DEFAULT_COMPACTION_THRESHOLD_PERCENT;
-    const threshold = input.contextWindowTokens === undefined
-        ? FALLBACK_COMPACTION_THRESHOLD
-        : Math.max(1, Math.floor(input.contextWindowTokens * thresholdPercent));
-    const config = {
-        recentWindowSize: DEFAULT_COMPACTION_RECENT_WINDOW_SIZE,
-        threshold,
-    };
-    if (input.lastKnownInputTokens !== undefined) {
-        return {
-            ...config,
-            lastKnownInputTokens: input.lastKnownInputTokens,
-            lastKnownPromptMessageCount: input.lastKnownPromptMessageCount,
-        };
-    }
-    return config;
-}
-/**
- * Creates a fresh serializable {@link HarnessSession} for a harness run.
- *
- * This is the only place that derives `session.agent.system` from a
- * `turnAgent`. The system prompt is a session-start snapshot: once
- * created here it is preserved unchanged for every subsequent turn.
- * Use {@link refreshSessionFromTurnAgent} to update model/tool metadata
- * on an existing session without touching the system prompt.
- */
-export function createSession(input) {
-    const { turnAgent } = input;
-    const tools = createSessionToolDefinitions(turnAgent);
-    return {
-        agent: {
-            compactionModelReference: turnAgent.compactionModel,
-            modelReference: turnAgent.model,
-            system: turnAgent.instructions.join("\n\n"),
-            tools,
-        },
-        compaction: createCompactionConfig({
-            contextWindowTokens: turnAgent.model.contextWindowTokens,
-            thresholdPercent: input.compactionOverrides?.thresholdPercent,
-        }),
-        continuationToken: input.continuationToken,
-        history: [],
-        sessionId: input.sessionId,
-    };
-}
-/**
- * Refreshes one existing session with the latest resolved turn-agent shape.
- *
- * Preserves durable history, state, and the system prompt while replacing
- * model/tool metadata and recalculating compaction thresholds from current
- * authored config. The system prompt is a session-start snapshot set by
- * {@link createSession} and is never rebuilt during refresh.
- */
-export function refreshSessionFromTurnAgent(input) {
-    return {
-        ...input.session,
-        agent: {
-            compactionModelReference: input.turnAgent.compactionModel,
-            modelReference: input.turnAgent.model,
-            system: input.session.agent.system,
-            tools: createSessionToolDefinitions(input.turnAgent),
-        },
-        compaction: createCompactionConfig({
-            contextWindowTokens: input.turnAgent.model.contextWindowTokens,
-            lastKnownInputTokens: input.session.compaction.lastKnownInputTokens,
-            lastKnownPromptMessageCount: input.session.compaction.lastKnownPromptMessageCount,
-            thresholdPercent: input.compactionOverrides?.thresholdPercent,
-        }),
-    };
-}
-/**
- * Mints a continuation token for a delegated subagent session.
- *
- * The `subagent:` prefix identifies the token as a child run handle. The
- * token is deterministic per parent call when `suffix` is provided so runtime
- * retries can address the same delegated child hook token.
- */
-export function mintSubagentContinuationToken(suffix) {
-    return `subagent:${suffix ?? crypto.randomUUID()}`;
-}
-function createSessionToolDefinitions(turnAgent) {
-    return turnAgent.tools.map((tool) => ({
-        description: tool.description ?? "",
-        inputSchema: tool.inputSchema,
-        name: tool.name,
-    }));
-}
+var DEFAULT_COMPACTION_RECENT_WINDOW_SIZE=10,DEFAULT_COMPACTION_THRESHOLD_PERCENT=.9,FALLBACK_COMPACTION_THRESHOLD=1e5;function createCompactionConfig(r={}){let i=r.thresholdPercent??DEFAULT_COMPACTION_THRESHOLD_PERCENT,a={recentWindowSize:DEFAULT_COMPACTION_RECENT_WINDOW_SIZE,threshold:r.contextWindowTokens===void 0?FALLBACK_COMPACTION_THRESHOLD:Math.max(1,Math.floor(r.contextWindowTokens*i))};return r.lastKnownInputTokens===void 0?a:{...a,lastKnownInputTokens:r.lastKnownInputTokens,lastKnownPromptMessageCount:r.lastKnownPromptMessageCount}}function createSession(e){let{turnAgent:t}=e,n=createSessionToolDefinitions(t);return{agent:{compactionModelReference:t.compactionModel,modelReference:t.model,system:t.instructions.join(`
+
+`),tools:n},compaction:createCompactionConfig({contextWindowTokens:t.model.contextWindowTokens,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:e.continuationToken,history:[],sessionId:e.sessionId}}function refreshSessionFromTurnAgent(e){return{...e.session,agent:{compactionModelReference:e.turnAgent.compactionModel,modelReference:e.turnAgent.model,system:e.session.agent.system,tools:createSessionToolDefinitions(e.turnAgent)},compaction:createCompactionConfig({contextWindowTokens:e.turnAgent.model.contextWindowTokens,lastKnownInputTokens:e.session.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.session.compaction.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent})}}function mintSubagentContinuationToken(e){return`subagent:${e??crypto.randomUUID()}`}function createSessionToolDefinitions(e){return e.tools.map(e=>({description:e.description??``,inputSchema:e.inputSchema,name:e.name}))}export{createCompactionConfig,createSession,mintSubagentContinuationToken,refreshSessionFromTurnAgent};

package/dist/src/execution/skills/instructions.js

@@ -1,30 +1,2 @@
-import { WORKSPACE_ROOT } from "#runtime/workspace/types.js";
-/**
- * Formats the "Available skills" system prompt section.
- *
- * All skills are always listed regardless of activation state. Active skill
- * instructions are never injected into the system prompt — the model already
- * has them from the `load_skill` tool result. This keeps the system
- * prompt identical across the entire session, preserving prompt caching.
- *
- * Authored skills call this at graph resolution time so the section is
- * part of the turn agent's static instructions. Hook-contributed skills
- * reuse the same formatter for durable history announcements.
- */
-export function formatAvailableSkillsSection(skills) {
-    if (skills.length === 0) {
-        return null;
-    }
-    const lines = [
-        "Available skills",
-        "Listed skills are available in this run. Do not claim a listed skill is inaccessible unless activation or workspace inspection actually fails.",
-        "If the user names a skill or the request clearly matches one of the descriptions below, call load_skill before proceeding.",
-        "If multiple skills match, activate the minimal set that covers the task. After activation, follow the returned instructions instead of improvising around them.",
-        "If activation fails, say so briefly and continue with the best fallback. Packaged sibling files under a skill path can be inspected with bash or read_file when needed.",
-        ...skills.map((skill) => formatAvailableSkillLine(skill)),
-    ];
-    return lines.join("\n");
-}
-function formatAvailableSkillLine(skill) {
-    return `- ${skill.name}: ${skill.description} (path: ${WORKSPACE_ROOT}/skills/${skill.name}/SKILL.md)`;
-}
+import{WORKSPACE_ROOT}from"#runtime/workspace/types.js";function formatAvailableSkillsSection(e){return e.length===0?null:[`Available skills`,`Listed skills are available in this run. Do not claim a listed skill is inaccessible unless activation or workspace inspection actually fails.`,`If the user names a skill or the request clearly matches one of the descriptions below, call load_skill before proceeding.`,`If multiple skills match, activate the minimal set that covers the task. After activation, follow the returned instructions instead of improvising around them.`,`If activation fails, say so briefly and continue with the best fallback. Packaged sibling files under a skill path can be inspected with bash or read_file when needed.`,...e.map(e=>formatAvailableSkillLine(e))].join(`
+`)}function formatAvailableSkillLine(t){return`- ${t.name}: ${t.description} (path: ${WORKSPACE_ROOT}/skills/${t.name}/SKILL.md)`}export{formatAvailableSkillsSection};

package/dist/src/execution/skills/types.js

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