experimental-ash 0.18.0 → 0.18.2

package/dist/src/client/message-reducer.js

@@ -0,0 +1,462 @@
+/**
+ * Creates a UIMessage-compatible Ash reducer for chat and agent UIs.
+ *
+ * The returned projection keeps Ash-owned types while following the AI SDK
+ * `messages[].parts[]` rendering convention used by AI Elements. It projects
+ * text, reasoning, tool calls, tool results, tool approvals, and submitted
+ * HITL responses. Connection authorization stream events remain available to
+ * custom reducers through the reducer event contract until Ash has a dedicated
+ * message-part shape for authorization UI.
+ */
+export function defaultMessageReducer() {
+    return {
+        initial() {
+            return { messages: [] };
+        },
+        reduce(data, event) {
+            return reduceMessageData(data, event);
+        },
+    };
+}
+function reduceMessageData(data, event) {
+    switch (event.type) {
+        case "client.message.submitted":
+            return upsertMessage(data, {
+                id: optimisticUserMessageId(event.data.submissionId),
+                metadata: {
+                    optimistic: true,
+                    status: "submitted",
+                },
+                parts: [{ type: "text", text: event.data.message }],
+                role: "user",
+            });
+        case "client.message.failed":
+            return upsertMessage(data, {
+                id: optimisticUserMessageId(event.data.submissionId),
+                metadata: {
+                    optimistic: true,
+                    status: "failed",
+                },
+                parts: [{ type: "text", text: event.data.message }],
+                role: "user",
+            });
+        case "client.input.responded": {
+            let next = data;
+            for (const response of event.data.responses) {
+                next = respondToInputRequest(next, response);
+            }
+            return next;
+        }
+        case "message.received":
+            return upsertMessage(data, {
+                id: `${event.data.turnId}:user`,
+                metadata: {
+                    status: "complete",
+                    turnId: event.data.turnId,
+                },
+                parts: [{ type: "text", text: event.data.message, state: "done" }],
+                role: "user",
+            });
+        case "step.started":
+            return updateAssistantMessage(data, event.data.turnId, (message) => ensureStepStartPart(message, event.data.stepIndex));
+        case "reasoning.appended":
+            return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                state: "streaming",
+                stepIndex: event.data.stepIndex,
+                text: event.data.reasoningSoFar,
+                type: "reasoning",
+            }));
+        case "reasoning.completed":
+            return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                state: "done",
+                stepIndex: event.data.stepIndex,
+                text: event.data.reasoning,
+                type: "reasoning",
+            }));
+        case "actions.requested": {
+            let next = data;
+            for (const action of event.data.actions) {
+                const descriptor = normalizeActionRequest(action);
+                next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                    input: "input" in action ? action.input : undefined,
+                    state: "input-available",
+                    stepIndex: event.data.stepIndex,
+                    toolCallId: action.callId,
+                    toolMetadata: createToolMetadata(descriptor, event.data.stepIndex),
+                    toolName: descriptor.toolName,
+                    type: "dynamic-tool",
+                }));
+            }
+            return next;
+        }
+        case "input.requested": {
+            let next = data;
+            for (const request of event.data.requests) {
+                const descriptor = normalizeActionRequest(request.action);
+                next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                    approval: {
+                        id: request.requestId,
+                    },
+                    input: request.action.input,
+                    state: "approval-requested",
+                    stepIndex: event.data.stepIndex,
+                    toolCallId: request.action.callId,
+                    toolMetadata: createToolMetadata(descriptor, event.data.stepIndex, {
+                        inputRequest: toMessageInputRequest(request),
+                    }),
+                    toolName: descriptor.toolName,
+                    type: "dynamic-tool",
+                }));
+            }
+            return next;
+        }
+        case "action.result": {
+            const descriptor = normalizeActionResult(event.data.result);
+            const existing = findToolPart(data, event.data.result.callId);
+            const denied = event.data.error?.code === "TOOL_EXECUTION_DENIED";
+            const failed = event.data.status === "failed" && !denied;
+            const approvalId = existing?.approval?.id ?? event.data.result.callId;
+            const toolMetadata = mergeToolMetadata(existing?.toolMetadata, createToolMetadata(descriptor, event.data.stepIndex));
+            const resultPartBase = {
+                input: existing?.input,
+                stepIndex: event.data.stepIndex,
+                toolCallId: event.data.result.callId,
+                toolMetadata,
+                toolName: existing?.toolName ?? descriptor.toolName,
+                type: "dynamic-tool",
+            };
+            let nextPart;
+            if (denied) {
+                nextPart = {
+                    ...resultPartBase,
+                    approval: {
+                        approved: false,
+                        id: approvalId,
+                        reason: event.data.error?.message,
+                    },
+                    state: "output-denied",
+                };
+            }
+            else if (failed) {
+                nextPart = {
+                    ...resultPartBase,
+                    approval: approvedApproval(existing),
+                    errorText: event.data.error?.message ?? stringifyUnknown(event.data.result.output),
+                    state: "output-error",
+                };
+            }
+            else {
+                nextPart = {
+                    ...resultPartBase,
+                    approval: approvedApproval(existing),
+                    output: event.data.result.output,
+                    state: "output-available",
+                };
+            }
+            if (existing !== undefined) {
+                // Approved tool results can arrive on a later runtime turn; keep
+                // the UI lifecycle anchored to the original tool call.
+                return updateToolPart(data, event.data.result.callId, nextPart);
+            }
+            return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), nextPart));
+        }
+        case "message.appended":
+            return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                state: "streaming",
+                stepIndex: event.data.stepIndex,
+                text: event.data.messageSoFar,
+                type: "text",
+            }));
+        case "message.completed":
+            return updateAssistantMessage(data, event.data.turnId, (message) => {
+                if (event.data.message === null) {
+                    return completeExistingTextPart(message);
+                }
+                return upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                    state: "done",
+                    stepIndex: event.data.stepIndex,
+                    text: event.data.message,
+                    type: "text",
+                });
+            });
+        case "turn.completed":
+            return updateAssistantMetadata(data, event.data.turnId, { status: "complete" });
+        case "turn.failed":
+        case "session.failed":
+            return data;
+        default:
+            return data;
+    }
+}
+function respondToInputRequest(data, response) {
+    const existing = findToolPartByApprovalId(data, response.requestId);
+    if (!existing) {
+        return data;
+    }
+    const approval = {
+        id: response.requestId,
+    };
+    if (response.text !== undefined) {
+        approval.reason = response.text;
+    }
+    return updateToolPart(data, existing.toolCallId, {
+        approval,
+        input: existing.input,
+        state: "approval-responded",
+        stepIndex: existing.stepIndex,
+        toolCallId: existing.toolCallId,
+        toolMetadata: mergeToolMetadata(existing.toolMetadata, {
+            ash: {
+                inputResponse: response,
+                kind: existing.toolMetadata?.ash?.kind ?? "unknown",
+                name: existing.toolMetadata?.ash?.name ?? existing.toolName,
+            },
+        }),
+        toolName: existing.toolName,
+        type: "dynamic-tool",
+    });
+}
+function updateAssistantMessage(data, turnId, update) {
+    const existing = data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === turnId);
+    const message = existing ?? createAssistantMessage(turnId);
+    return upsertMessage(data, update(message));
+}
+function updateAssistantMetadata(data, turnId, metadata) {
+    return updateAssistantMessage(data, turnId, (message) => ({
+        ...message,
+        metadata: {
+            ...message.metadata,
+            ...metadata,
+        },
+    }));
+}
+function createAssistantMessage(turnId) {
+    return {
+        id: `${turnId}:assistant`,
+        metadata: {
+            status: "streaming",
+            turnId,
+        },
+        parts: [],
+        role: "assistant",
+    };
+}
+function ensureStepStartPart(message, stepIndex) {
+    const stepStartCount = message.parts.filter((part) => part.type === "step-start").length;
+    if (stepStartCount > stepIndex) {
+        return message;
+    }
+    const missingCount = stepIndex - stepStartCount + 1;
+    return {
+        ...message,
+        parts: [
+            ...message.parts,
+            ...Array.from({ length: missingCount }, () => ({ type: "step-start" })),
+        ],
+    };
+}
+function upsertPart(message, next) {
+    const index = message.parts.findIndex((part) => partKey(part) === partKey(next));
+    const parts = index === -1
+        ? [...message.parts, next]
+        : [...message.parts.slice(0, index), next, ...message.parts.slice(index + 1)];
+    return {
+        ...message,
+        metadata: {
+            ...message.metadata,
+            status: next.type === "text" && next.state === "done" ? "complete" : "streaming",
+        },
+        parts,
+    };
+}
+function completeExistingTextPart(message) {
+    const index = findLastIndex(message.parts, (part) => part.type === "text");
+    if (index === -1) {
+        return message;
+    }
+    const existing = message.parts[index];
+    if (existing?.type !== "text") {
+        return message;
+    }
+    return {
+        ...message,
+        metadata: {
+            ...message.metadata,
+            status: "complete",
+        },
+        parts: [
+            ...message.parts.slice(0, index),
+            { ...existing, state: "done" },
+            ...message.parts.slice(index + 1),
+        ],
+    };
+}
+function updateToolPart(data, toolCallId, next) {
+    const message = data.messages.find((candidate) => candidate.role === "assistant" &&
+        candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === toolCallId));
+    if (!message) {
+        return data;
+    }
+    return upsertMessage(data, upsertPart(message, next));
+}
+function findToolPart(data, toolCallId) {
+    for (const message of data.messages) {
+        for (const part of message.parts) {
+            if (part.type === "dynamic-tool" && part.toolCallId === toolCallId) {
+                return part;
+            }
+        }
+    }
+    return undefined;
+}
+function findToolPartByApprovalId(data, approvalId) {
+    for (const message of data.messages) {
+        for (const part of message.parts) {
+            if (part.type === "dynamic-tool" && part.approval?.id === approvalId) {
+                return part;
+            }
+        }
+    }
+    return undefined;
+}
+function partKey(part) {
+    switch (part.type) {
+        case "text":
+            return `text:${part.stepIndex ?? 0}`;
+        case "reasoning":
+            return `reasoning:${part.stepIndex ?? 0}`;
+        case "step-start":
+            return "step-start";
+        case "dynamic-tool":
+            return `dynamic-tool:${part.toolCallId}`;
+    }
+}
+function upsertMessage(data, next) {
+    const index = data.messages.findIndex((message) => message.id === next.id);
+    if (index === -1) {
+        return { messages: [...data.messages, next] };
+    }
+    return {
+        messages: [...data.messages.slice(0, index), next, ...data.messages.slice(index + 1)],
+    };
+}
+function toMessageInputRequest(request) {
+    return {
+        allowFreeform: request.allowFreeform,
+        display: request.display,
+        options: request.options,
+        prompt: request.prompt,
+        requestId: request.requestId,
+    };
+}
+function createToolMetadata(descriptor, _stepIndex, extra) {
+    return {
+        ash: {
+            inputRequest: extra?.inputRequest,
+            kind: descriptor.kind,
+            name: descriptor.name,
+        },
+    };
+}
+function mergeToolMetadata(current, next) {
+    const kind = next.ash?.kind ?? current?.ash?.kind ?? "unknown";
+    const name = next.ash?.name ?? current?.ash?.name ?? "unknown";
+    return {
+        ash: {
+            ...current?.ash,
+            ...next.ash,
+            inputRequest: next.ash?.inputRequest ?? current?.ash?.inputRequest,
+            inputResponse: next.ash?.inputResponse ?? current?.ash?.inputResponse,
+            kind,
+            name,
+        },
+    };
+}
+function approvedApproval(part) {
+    if (!part?.approval?.id) {
+        return undefined;
+    }
+    return {
+        approved: true,
+        id: part.approval.id,
+        isAutomatic: part.approval.isAutomatic,
+        reason: part.approval.reason,
+    };
+}
+function normalizeActionRequest(action) {
+    switch (action.kind) {
+        case "load-skill":
+            return {
+                kind: "load-skill",
+                name: action.name ?? "load_skill",
+                toolName: "ash:load-skill",
+            };
+        case "tool-call":
+            return {
+                kind: "tool-call",
+                name: action.toolName ?? "tool",
+                toolName: action.toolName ?? "tool",
+            };
+        case "subagent-call":
+            return {
+                kind: "subagent-call",
+                name: action.subagentName ?? action.name ?? "subagent",
+                toolName: `ash:subagent:${action.subagentName ?? action.name ?? "subagent"}`,
+            };
+        default:
+            return {
+                kind: "unknown",
+                name: action.toolName ?? action.subagentName ?? action.name ?? action.kind,
+                toolName: action.toolName ?? action.subagentName ?? action.name ?? action.kind,
+            };
+    }
+}
+function normalizeActionResult(result) {
+    switch (result.kind) {
+        case "load-skill-result":
+            return {
+                kind: "load-skill",
+                name: result.name ?? "load_skill",
+                toolName: "ash:load-skill",
+            };
+        case "tool-result":
+            return {
+                kind: "tool-call",
+                name: result.toolName ?? "tool",
+                toolName: result.toolName ?? "tool",
+            };
+        case "subagent-result":
+            return {
+                kind: "subagent-call",
+                name: result.subagentName ?? "subagent",
+                toolName: `ash:subagent:${result.subagentName ?? "subagent"}`,
+            };
+        default:
+            return {
+                kind: "unknown",
+                name: result.toolName ?? result.subagentName ?? result.name ?? result.kind,
+                toolName: result.toolName ?? result.subagentName ?? result.name ?? result.kind,
+            };
+    }
+}
+function optimisticUserMessageId(submissionId) {
+    return `optimistic:${submissionId}:user`;
+}
+function stringifyUnknown(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return "Action failed.";
+    }
+}
+function findLastIndex(items, predicate) {
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+        if (predicate(items[index])) {
+            return index;
+        }
+    }
+    return -1;
+}

package/dist/src/client/open-stream.js

@@ -1,6 +1,7 @@
 import { createAshMessageStreamRoutePath } from "#protocol/routes.js";
 import { ClientError } from "#client/client-error.js";
 import { isStreamDisconnectError, readNdjsonStream } from "#client/ndjson.js";
+import { createClientUrl } from "#client/url.js";
 /**
  * Opens a durable NDJSON event stream with automatic reconnection on socket
  * disconnection. Used by both {@link Client.openStream} and
@@ -10,10 +11,7 @@ export async function* openStreamIterable(input) {
     let startIndex = input.startIndex;
     let remainingReconnectAttempts = input.maxReconnectAttempts;
     while (true) {
-        const url = new URL(createAshMessageStreamRoutePath(input.sessionId), input.host);
-        if (startIndex > 0) {
-            url.searchParams.set("startIndex", String(startIndex));
-        }
+        const url = createClientUrl(input.host, createAshMessageStreamRoutePath(input.sessionId), startIndex > 0 ? { startIndex: String(startIndex) } : undefined);
         const headers = await input.resolveHeaders();
         const response = await fetch(url, {
             headers,

package/dist/src/client/reducer.d.ts

@@ -0,0 +1,63 @@
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { InputResponse } from "#runtime/input/types.js";
+/**
+ * Client-side reducer event emitted before Ash confirms a submitted user
+ * message with a `message.received` stream event.
+ */
+export interface ClientMessageSubmittedEvent {
+    readonly data: {
+        readonly createdAt: number;
+        readonly message: string;
+        readonly submissionId: string;
+    };
+    readonly type: "client.message.submitted";
+}
+/**
+ * Client-side reducer event emitted when a submitted user message fails before
+ * Ash confirms it with a `message.received` stream event.
+ */
+export interface ClientMessageFailedEvent {
+    readonly data: {
+        readonly createdAt: number;
+        readonly error: {
+            readonly message: string;
+        };
+        readonly message: string;
+        readonly submissionId: string;
+    };
+    readonly type: "client.message.failed";
+}
+/**
+ * Client-side reducer event emitted when the client submits HITL responses for
+ * pending input requests.
+ */
+export interface ClientInputRespondedEvent {
+    readonly data: {
+        readonly createdAt: number;
+        readonly responses: readonly InputResponse[];
+    };
+    readonly type: "client.input.responded";
+}
+/**
+ * Event consumed by Ash agent reducers.
+ *
+ * Server events are authoritative Ash stream events. They include text,
+ * reasoning, tool/action requests and results, HITL input requests, connection
+ * authorization events, subagent events, and session lifecycle events. Client
+ * events are projection-only events created by client state machines for local
+ * UI state such as optimistic user messages and submitted HITL responses.
+ */
+export type AshAgentReducerEvent = ClientInputRespondedEvent | ClientMessageFailedEvent | ClientMessageSubmittedEvent | HandleMessageStreamEvent;
+/**
+ * Projects Ash stream events into accumulated consumer data.
+ */
+export interface AshAgentReducer<TData> {
+    /**
+     * Creates the initial projection state.
+     */
+    initial(): TData;
+    /**
+     * Applies one server or client projection event to the current projection.
+     */
+    reduce(data: TData, event: AshAgentReducerEvent): TData;
+}

package/dist/src/client/reducer.js

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

package/dist/src/client/session.js

@@ -5,6 +5,7 @@ import { MessageResponse } from "#client/message-response.js";
 import { isStreamDisconnectError, readNdjsonStream } from "#client/ndjson.js";
 import { openStreamIterable } from "#client/open-stream.js";
 import { advanceSession } from "#client/session-utils.js";
+import { createClientUrl } from "#client/url.js";
 /**
  * One conversation with an Ash agent.
  *
@@ -84,7 +85,7 @@ export class ClientSession {
         const routePath = session.sessionId
             ? createAshContinueSessionRoutePath(session.sessionId)
             : ASH_CREATE_SESSION_ROUTE_PATH;
-        const url = new URL(routePath, this.#context.host);
+        const url = createClientUrl(this.#context.host, routePath);
         const headers = await this.#context.resolveHeaders(options?.headers);
         headers.set("content-type", "application/json");
         const body = createHandleMessageBody({
@@ -160,10 +161,7 @@ export class ClientSession {
         }
     }
     async #openStreamBody(sessionId, startIndex, signal) {
-        const url = new URL(createAshMessageStreamRoutePath(sessionId), this.#context.host);
-        if (startIndex > 0) {
-            url.searchParams.set("startIndex", String(startIndex));
-        }
+        const url = createClientUrl(this.#context.host, createAshMessageStreamRoutePath(sessionId), startIndex > 0 ? { startIndex: String(startIndex) } : undefined);
         const headers = await this.#context.resolveHeaders();
         const response = await fetch(url, {
             headers,

package/dist/src/client/url.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Builds a fetchable URL from a caller-provided host and an Ash route path.
+ *
+ * `host` may be an absolute origin (`https://agent.example.com`) or a
+ * same-origin prefix (`/api`). Prefixes are important for browser clients that
+ * talk to an app-owned proxy instead of the Ash deployment directly.
+ */
+export declare function createClientUrl(host: string, routePath: string, searchParams?: Readonly<Record<string, string>>): string;

package/dist/src/client/url.js

@@ -0,0 +1,34 @@
+/**
+ * Builds a fetchable URL from a caller-provided host and an Ash route path.
+ *
+ * `host` may be an absolute origin (`https://agent.example.com`) or a
+ * same-origin prefix (`/api`). Prefixes are important for browser clients that
+ * talk to an app-owned proxy instead of the Ash deployment directly.
+ */
+export function createClientUrl(host, routePath, searchParams) {
+    const normalizedRoute = routePath.startsWith("/") ? routePath : `/${routePath}`;
+    const search = formatSearch(searchParams);
+    if (isAbsoluteUrl(host)) {
+        const url = new URL(host);
+        const basePath = trimTrailingSlash(url.pathname);
+        url.pathname = `${basePath}${normalizedRoute}`;
+        url.search = search;
+        url.hash = "";
+        return url.toString();
+    }
+    return `${trimTrailingSlash(host)}${normalizedRoute}${search}`;
+}
+function isAbsoluteUrl(value) {
+    return /^[a-z][a-z\d+\-.]*:/i.test(value);
+}
+function trimTrailingSlash(value) {
+    if (value === "/")
+        return "";
+    return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function formatSearch(searchParams) {
+    if (!searchParams || Object.keys(searchParams).length === 0) {
+        return "";
+    }
+    return `?${new URLSearchParams(searchParams).toString()}`;
+}

package/dist/src/compiler/module-map.js

@@ -127,6 +127,18 @@ export function collectModuleRefsForManifest(manifest) {
             sourceId: hook.sourceId,
         });
     }
+    for (const schedule of manifest.schedules) {
+        // Only `run`-handler schedules need their source loaded at dispatch
+        // time. Markdown schedules execute from `manifest.markdown`.
+        if (schedule.sourceKind !== "module" || !schedule.hasRun) {
+            continue;
+        }
+        moduleSourceRefs.set(schedule.sourceId, {
+            sourceKind: "module",
+            logicalPath: schedule.logicalPath,
+            sourceId: schedule.sourceId,
+        });
+    }
     if (manifest.sandbox !== null) {
         moduleSourceRefs.set(manifest.sandbox.sourceId, {
             exportName: manifest.sandbox.exportName,

package/dist/src/evals/cli/eval.js

@@ -1 +1 @@
-import{n as e}from"../../chunks/paths-CvbqpwTh.js";import{loadDevelopmentEnvironmentFiles as t}from"../../cli/dev/environment.js";import{a as n,n as r,t as i}from"../../chunks/client-BeZ_W7vl.js";import{n as a}from"../../chunks/host-CIU0NATc.js";import{discoverAndImportSuites as o,discoverSuiteFiles as s,importSuiteFile as c}from"../runner/discover.js";import{executeSuite as l}from"../runner/execute-suite.js";import{ConsoleReporter as u}from"../runner/reporters/console.js";var d=n();function f(e,t){e.command(`eval`).description(`Run eval suites against an Ash agent.`).option(`--suite <id...>`,`Suite IDs to run (repeatable)`).option(`--all`,`Run all discovered suites`).option(`--url <url>`,`Remote agent URL (skip local host startup)`).option(`--timeout <ms>`,`Per-case timeout in milliseconds`).option(`--max-concurrency <n>`,`Max concurrent case executions per suite`).option(`--json`,`Output results as JSON`).option(`--list-suites`,`List discovered suites and exit`).option(`--skip-report`,`Skip suite-defined reporters (e.g. Braintrust)`).action(async e=>{await p(e,t)})}async function p(n,r){let i=e();if(t(i),n.listSuites){await y(i,r);return}let s=n.suite,c=await o(i,s);if(c.length===0){s&&s.length>0?r.error(`No suites found matching: ${s.join(`, `)}`):r.error(`No eval suites found. Create suite files under evals/ with the *.eval.ts extension.`),process.exitCode=1;return}let u,d;n.url?d={kind:`remote`,url:n.url}:(u=await a(i,{host:`127.0.0.1`,port:0}),d={kind:`local`,url:u.url});let f=m(d);try{let e=[];for(let t of c){let r=_(t,n),a=v(r,{json:n.json===!0,skipReport:n.skipReport===!0}),o=await l({suite:r,target:d,reporters:a,appRoot:i,client:f});e.push(o)}n.json&&r.log(JSON.stringify(e,null,2)),e.some(e=>e.errored>0)&&(process.exitCode=1)}finally{u&&await u.close()}process.exit(process.exitCode??0)}function m(e){if(e.kind===`local`)return new i({host:e.url});let t={},n=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return n&&(t[r]=n),new i({auth:h(),headers:Object.keys(t).length>0?t:void 0,host:e.url})}function h(){let e=process.env.ASH_EVAL_AUTH_TOKEN?.trim();return e?{bearer:e}:{bearer:g}}async function g(){try{let e=(await(0,d.getVercelOidcToken)()).trim();if(e.length>0)return e}catch{}return process.env.VERCEL_OIDC_TOKEN?.trim()??``}function _(e,t){let n=t.maxConcurrency?Number.parseInt(t.maxConcurrency,10):void 0,r=t.timeout?Number.parseInt(t.timeout,10):void 0;if(n===void 0&&r===void 0)return e;let i={...e};return n!==void 0&&(i.maxConcurrency=n),r!==void 0&&(i.timeoutMs=r),i}function v(e,t){let n=t.json?[]:[new u];return!t.skipReport&&e.reporters&&n.push(...e.reporters),n}async function y(e,t){let n=await s(e);if(n.length===0){t.log(`No eval suites found.`);return}t.log(`Found ${n.length} eval suite file(s):\n`);for(let r of n){let n=await c(e,r);t.log(`  ${n.id}${n.description?`  - ${n.description}`:``}`)}}export{f as registerEvalCommand,p as runEvalCommand};
+import{n as e}from"../../chunks/paths-Dwv0Eash.js";import{loadDevelopmentEnvironmentFiles as t}from"../../cli/dev/environment.js";import{a as n,n as r,t as i}from"../../chunks/client-CKsU8Li3.js";import{n as a}from"../../chunks/host-DkTSR6YJ.js";import{discoverAndImportSuites as o,discoverSuiteFiles as s,importSuiteFile as c}from"../runner/discover.js";import{executeSuite as l}from"../runner/execute-suite.js";import{ConsoleReporter as u}from"../runner/reporters/console.js";var d=n();function f(e,t){e.command(`eval`).description(`Run eval suites against an Ash agent.`).option(`--suite <id...>`,`Suite IDs to run (repeatable)`).option(`--all`,`Run all discovered suites`).option(`--url <url>`,`Remote agent URL (skip local host startup)`).option(`--timeout <ms>`,`Per-case timeout in milliseconds`).option(`--max-concurrency <n>`,`Max concurrent case executions per suite`).option(`--json`,`Output results as JSON`).option(`--list-suites`,`List discovered suites and exit`).option(`--skip-report`,`Skip suite-defined reporters (e.g. Braintrust)`).action(async e=>{await p(e,t)})}async function p(n,r){let i=e();if(t(i),n.listSuites){await y(i,r);return}let s=n.suite,c=await o(i,s);if(c.length===0){s&&s.length>0?r.error(`No suites found matching: ${s.join(`, `)}`):r.error(`No eval suites found. Create suite files under evals/ with the *.eval.ts extension.`),process.exitCode=1;return}let u,d;n.url?d={kind:`remote`,url:n.url}:(u=await a(i,{host:`127.0.0.1`,port:0}),d={kind:`local`,url:u.url});let f=m(d);try{let e=[];for(let t of c){let r=_(t,n),a=v(r,{json:n.json===!0,skipReport:n.skipReport===!0}),o=await l({suite:r,target:d,reporters:a,appRoot:i,client:f});e.push(o)}n.json&&r.log(JSON.stringify(e,null,2)),e.some(e=>e.errored>0)&&(process.exitCode=1)}finally{u&&await u.close()}process.exit(process.exitCode??0)}function m(e){if(e.kind===`local`)return new i({host:e.url});let t={},n=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return n&&(t[r]=n),new i({auth:h(),headers:Object.keys(t).length>0?t:void 0,host:e.url})}function h(){let e=process.env.ASH_EVAL_AUTH_TOKEN?.trim();return e?{bearer:e}:{bearer:g}}async function g(){try{let e=(await(0,d.getVercelOidcToken)()).trim();if(e.length>0)return e}catch{}return process.env.VERCEL_OIDC_TOKEN?.trim()??``}function _(e,t){let n=t.maxConcurrency?Number.parseInt(t.maxConcurrency,10):void 0,r=t.timeout?Number.parseInt(t.timeout,10):void 0;if(n===void 0&&r===void 0)return e;let i={...e};return n!==void 0&&(i.maxConcurrency=n),r!==void 0&&(i.timeoutMs=r),i}function v(e,t){let n=t.json?[]:[new u];return!t.skipReport&&e.reporters&&n.push(...e.reporters),n}async function y(e,t){let n=await s(e);if(n.length===0){t.log(`No eval suites found.`);return}t.log(`Found ${n.length} eval suite file(s):\n`);for(let r of n){let n=await c(e,r);t.log(`  ${n.id}${n.description?`  - ${n.description}`:``}`)}}export{f as registerEvalCommand,p as runEvalCommand};

package/dist/src/execution/sandbox/bindings/vercel.d.ts

@@ -1,7 +1,7 @@
 import type * as VercelSandboxSdk from "#compiled/@vercel/sandbox/index.js";
 import type { Sandbox as SdkSandbox } from "#compiled/@vercel/sandbox/index.js";
 import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
-import type { VercelSandbox, VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions } from "#public/sandbox/vercel-sandbox.js";
+import type { VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions } from "#public/sandbox/vercel-sandbox.js";
 type VercelSandboxModule = typeof VercelSandboxSdk;
 /**
  * User-controllable subset of `Sandbox.create` parameters.
@@ -18,5 +18,5 @@ export interface CreateVercelSandboxBackendInput {
 /**
  * Creates the Vercel-backed sandbox backend.
  */
-export declare function createVercelSandboxBackend(input?: CreateVercelSandboxBackendInput): SandboxBackend<VercelSandbox, VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions>;
+export declare function createVercelSandboxBackend(input?: CreateVercelSandboxBackendInput): SandboxBackend<VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions>;
 export {};