experimental-ash 0.24.2 → 0.25.0

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

@@ -1,20 +0,0 @@
-import type { HarnessSession } from "#harness/types.js";
-import type { PendingConnectionAuthorization } from "#runtime/framework-tools/connection-search.js";
-import type { PendingConnectionToolCall } from "#runtime/framework-tools/pending-connection-tool-calls.js";
-export type { ChannelAdapter } from "#channel/adapter.js";
-export type { DeliverInput, EventEmitFn, RunHandle, RunInput, RunResult, Runtime, SessionParent, SessionTurn, } from "#channel/types.js";
-/**
- * Serializable projection of a step result for workflow persistence.
- */
-export type DurableStepResult = {
-    readonly action: "continue" | "park" | "done";
-    readonly output?: string;
-    readonly serializedContext: Record<string, unknown>;
-    readonly session: HarnessSession;
-} | {
-    readonly action: "await-authorization";
-    readonly pendingToolCalls: readonly PendingConnectionToolCall[];
-    readonly pendingAuths: readonly PendingConnectionAuthorization[];
-    readonly serializedContext: Record<string, unknown>;
-    readonly session: HarnessSession;
-};

package/dist/src/execution/types.js

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

package/dist/src/internal/logical-paths.d.ts

@@ -1,13 +0,0 @@
-/**
- * Removes one logical root prefix such as `context/` or `workspace/` when it
- * is present.
- */
-export declare function stripLogicalPathRoot(logicalPath: string, rootName: string): string;
-/**
- * Removes the authored `context/` logical root prefix when present.
- */
-export declare function stripContextRootLogicalPath(logicalPath: string): string;
-/**
- * Removes the authored `workspace/` logical root prefix when present.
- */
-export declare function stripWorkspaceRootLogicalPath(logicalPath: string): string;

package/dist/src/internal/logical-paths.js

@@ -1,25 +0,0 @@
-import { normalizeLogicalPath } from "#discover/filesystem.js";
-/**
- * Removes one logical root prefix such as `context/` or `workspace/` when it
- * is present.
- */
-export function stripLogicalPathRoot(logicalPath, rootName) {
-    const normalizedPath = normalizeLogicalPath(logicalPath);
-    const normalizedRootName = normalizeLogicalPath(rootName).replace(/\/+$/, "");
-    const prefixedRootName = `${normalizedRootName}/`;
-    return normalizedPath.startsWith(prefixedRootName)
-        ? normalizedPath.slice(prefixedRootName.length)
-        : normalizedPath;
-}
-/**
- * Removes the authored `context/` logical root prefix when present.
- */
-export function stripContextRootLogicalPath(logicalPath) {
-    return stripLogicalPathRoot(logicalPath, "context");
-}
-/**
- * Removes the authored `workspace/` logical root prefix when present.
- */
-export function stripWorkspaceRootLogicalPath(logicalPath) {
-    return stripLogicalPathRoot(logicalPath, "workspace");
-}

package/dist/src/runtime/sessions/messages.d.ts

@@ -1,140 +0,0 @@
-import { z } from "#compiled/zod/index.js";
-/**
- * Runtime-owned semantic tag applied to durable session messages.
- */
-export type RuntimeSessionMessageKind = "compaction" | "default";
-/**
- * Runtime-owned metadata preserved alongside one durable session message.
- */
-export type RuntimeSessionMessageMetadata = z.infer<typeof runtimeSessionMessageMetadataSchema>;
-export declare const runtimeSessionMessageMetadataSchema: z.ZodObject<{
-    kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"default">]>>;
-}, z.core.$strict>;
-/**
- * Serializable system message prepared for one runtime turn.
- */
-export type RuntimeSystemMessage = z.infer<typeof runtimeSystemMessageSchema>;
-/**
- * Zod schema for one runtime-owned system message.
- */
-export declare const runtimeSystemMessageSchema: z.ZodObject<{
-    content: z.ZodString;
-    metadata: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"default">]>>;
-    }, z.core.$strict>>;
-    role: z.ZodLiteral<"system">;
-}, z.core.$strict>;
-/**
- * Serializable user message prepared for one runtime turn.
- */
-export type RuntimeUserMessage = z.infer<typeof runtimeUserMessageSchema>;
-/**
- * Zod schema for one runtime-owned user message.
- */
-export declare const runtimeUserMessageSchema: z.ZodObject<{
-    content: z.ZodString;
-    metadata: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"default">]>>;
-    }, z.core.$strict>>;
-    role: z.ZodLiteral<"user">;
-}, z.core.$strict>;
-/**
- * Serializable assistant message prepared for one runtime turn.
- */
-export type RuntimeAssistantMessage = z.infer<typeof runtimeAssistantMessageSchema>;
-/**
- * Zod schema for one runtime-owned assistant message.
- */
-export declare const runtimeAssistantMessageSchema: z.ZodObject<{
-    content: z.ZodString;
-    metadata: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"default">]>>;
-    }, z.core.$strict>>;
-    role: z.ZodLiteral<"assistant">;
-}, z.core.$strict>;
-/**
- * Serializable model-visible message used to assemble one prepared runtime turn.
- */
-export type RuntimeSessionMessage = RuntimeAssistantMessage | RuntimeSystemMessage | RuntimeUserMessage;
-/**
- * Zod schema for one runtime-owned serializable session message.
- */
-export declare const runtimeSessionMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    content: z.ZodString;
-    metadata: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"default">]>>;
-    }, z.core.$strict>>;
-    role: z.ZodLiteral<"assistant">;
-}, z.core.$strict>, z.ZodObject<{
-    content: z.ZodString;
-    metadata: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"default">]>>;
-    }, z.core.$strict>>;
-    role: z.ZodLiteral<"system">;
-}, z.core.$strict>, z.ZodObject<{
-    content: z.ZodString;
-    metadata: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"compaction">, z.ZodLiteral<"default">]>>;
-    }, z.core.$strict>>;
-    role: z.ZodLiteral<"user">;
-}, z.core.$strict>], "role">;
-/**
- * Default inbound user message used when the message route receives only whitespace.
- */
-export declare const DEFAULT_RUNTIME_USER_MESSAGE = "Hello from Ash";
-/**
- * Normalizes one inbound user message into the runtime-owned session format.
- */
-export declare function normalizeRuntimeUserMessage(message: string): string;
-/**
- * Creates one runtime-owned system message.
- */
-export declare function createRuntimeSystemMessage(content: string): RuntimeSystemMessage;
-/**
- * Creates one runtime-owned user message.
- */
-export declare function createRuntimeUserMessage(content: string): RuntimeUserMessage;
-/**
- * Creates one runtime-owned assistant message.
- */
-export declare function createRuntimeAssistantMessage(content: string): RuntimeAssistantMessage;
-/**
- * Creates one runtime-owned compaction checkpoint message.
- */
-export declare function createRuntimeCompactionMessage(content: string): RuntimeSystemMessage;
-/**
- * Returns the canonical runtime-owned session history used to prepare the next turn.
- */
-export declare function getRuntimeSessionHistory(session: {
-    readonly history: unknown;
-}): readonly RuntimeSessionMessage[];
-/**
- * Returns the runtime-visible history slice that starts at the latest
- * compaction checkpoint when one exists.
- */
-export declare function getRuntimeSessionHistoryFromCompactionBoundary(session: {
-    readonly history: unknown;
-    readonly lastCompactionIndex: unknown;
-}): readonly RuntimeSessionMessage[];
-/**
- * Merges one visible harness-projected history back into the durable session
- * history while preserving any hidden pre-compaction prefix.
- */
-export declare function mergeRuntimeSessionHistoryFromProjection(input: {
-    readonly history: readonly RuntimeSessionMessage[];
-    readonly lastCompactionIndex: number | null;
-    readonly projectionHistory: readonly RuntimeSessionMessage[];
-}): readonly RuntimeSessionMessage[];
-/**
- * Returns the durable index of the latest compaction checkpoint message inside
- * one runtime history array.
- */
-export declare function findLastRuntimeCompactionIndex(history: readonly RuntimeSessionMessage[]): number | null;
-/**
- * Returns true when the durable message is a compaction checkpoint.
- */
-export declare function isRuntimeCompactionMessage(message: RuntimeSessionMessage): boolean;
-/**
- * Returns true when unknown JSON matches one runtime session message.
- */
-export declare function isRuntimeSessionMessage(value: unknown): value is RuntimeSessionMessage;

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

@@ -1,170 +0,0 @@
-import { z } from "#compiled/zod/index.js";
-export const runtimeSessionMessageMetadataSchema = z
-    .object({
-    kind: z.union([z.literal("compaction"), z.literal("default")]).optional(),
-})
-    .strict();
-/**
- * Zod schema for one runtime-owned system message.
- */
-export const runtimeSystemMessageSchema = z
-    .object({
-    content: z.string(),
-    metadata: runtimeSessionMessageMetadataSchema.optional(),
-    role: z.literal("system"),
-})
-    .strict();
-/**
- * Zod schema for one runtime-owned user message.
- */
-export const runtimeUserMessageSchema = z
-    .object({
-    content: z.string(),
-    metadata: runtimeSessionMessageMetadataSchema.optional(),
-    role: z.literal("user"),
-})
-    .strict();
-/**
- * Zod schema for one runtime-owned assistant message.
- */
-export const runtimeAssistantMessageSchema = z
-    .object({
-    content: z.string(),
-    metadata: runtimeSessionMessageMetadataSchema.optional(),
-    role: z.literal("assistant"),
-})
-    .strict();
-/**
- * Zod schema for one runtime-owned serializable session message.
- */
-export const runtimeSessionMessageSchema = z.discriminatedUnion("role", [
-    runtimeAssistantMessageSchema,
-    runtimeSystemMessageSchema,
-    runtimeUserMessageSchema,
-]);
-/**
- * Default inbound user message used when the message route receives only whitespace.
- */
-export const DEFAULT_RUNTIME_USER_MESSAGE = "Hello from Ash";
-/**
- * Normalizes one inbound user message into the runtime-owned session format.
- */
-export function normalizeRuntimeUserMessage(message) {
-    const normalized = message.trim();
-    return normalized.length > 0 ? normalized : DEFAULT_RUNTIME_USER_MESSAGE;
-}
-/**
- * Creates one runtime-owned system message.
- */
-export function createRuntimeSystemMessage(content) {
-    return {
-        content,
-        role: "system",
-    };
-}
-/**
- * Creates one runtime-owned user message.
- */
-export function createRuntimeUserMessage(content) {
-    return {
-        content,
-        role: "user",
-    };
-}
-/**
- * Creates one runtime-owned assistant message.
- */
-export function createRuntimeAssistantMessage(content) {
-    return {
-        content,
-        role: "assistant",
-    };
-}
-/**
- * Creates one runtime-owned compaction checkpoint message.
- */
-export function createRuntimeCompactionMessage(content) {
-    return {
-        content,
-        metadata: {
-            kind: "compaction",
-        },
-        role: "system",
-    };
-}
-/**
- * Returns the canonical runtime-owned session history used to prepare the next turn.
- */
-export function getRuntimeSessionHistory(session) {
-    if (!Array.isArray(session.history) ||
-        !session.history.every((message) => isRuntimeSessionMessage(message))) {
-        throw new Error("Expected runtime session history to be a serializable message array.");
-    }
-    return session.history;
-}
-/**
- * Returns the runtime-visible history slice that starts at the latest
- * compaction checkpoint when one exists.
- */
-export function getRuntimeSessionHistoryFromCompactionBoundary(session) {
-    const history = getRuntimeSessionHistory(session);
-    const lastCompactionIndex = assertLastCompactionIndex(session.lastCompactionIndex, history.length);
-    return lastCompactionIndex === null ? history : history.slice(lastCompactionIndex);
-}
-/**
- * Merges one visible harness-projected history back into the durable session
- * history while preserving any hidden pre-compaction prefix.
- */
-export function mergeRuntimeSessionHistoryFromProjection(input) {
-    const history = getRuntimeSessionHistory({
-        history: input.history,
-    });
-    const projectionHistory = getRuntimeSessionHistory({
-        history: input.projectionHistory,
-    });
-    const lastCompactionIndex = assertLastCompactionIndex(input.lastCompactionIndex, history.length);
-    if (lastCompactionIndex === null) {
-        return [...projectionHistory];
-    }
-    return [...history.slice(0, lastCompactionIndex), ...projectionHistory];
-}
-/**
- * Returns the durable index of the latest compaction checkpoint message inside
- * one runtime history array.
- */
-export function findLastRuntimeCompactionIndex(history) {
-    const normalizedHistory = getRuntimeSessionHistory({
-        history,
-    });
-    for (let index = normalizedHistory.length - 1; index >= 0; index -= 1) {
-        const message = normalizedHistory[index];
-        if (message !== undefined && isRuntimeCompactionMessage(message)) {
-            return index;
-        }
-    }
-    return null;
-}
-/**
- * Returns true when the durable message is a compaction checkpoint.
- */
-export function isRuntimeCompactionMessage(message) {
-    return message.metadata?.kind === "compaction";
-}
-/**
- * Returns true when unknown JSON matches one runtime session message.
- */
-export function isRuntimeSessionMessage(value) {
-    return runtimeSessionMessageSchema.safeParse(value).success;
-}
-function assertLastCompactionIndex(value, historyLength) {
-    if (value === null) {
-        return null;
-    }
-    if (typeof value !== "number" ||
-        !Number.isInteger(value) ||
-        value < 0 ||
-        value >= historyLength) {
-        throw new Error(`Expected lastCompactionIndex to point at a durable history entry, received ${String(value)}.`);
-    }
-    return value;
-}

package/dist/src/runtime/standard-schema.d.ts

@@ -1,27 +0,0 @@
-import type { StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
-/**
- * Runtime-owned validator signature extracted from a live Standard Schema.
- */
-export type StandardSchemaValidator = StandardSchemaV1["~standard"]["validate"];
-/**
- * Normalized result returned from one runtime Standard Schema validation.
- */
-export type StandardSchemaValidationResult = {
-    readonly issues: readonly StandardSchemaV1.Issue[];
-    readonly ok: false;
-} | {
-    readonly ok: true;
-    readonly value: unknown;
-};
-/**
- * Returns the live Standard Schema validator when the value exposes one.
- */
-export declare function getStandardSchemaValidator(value: unknown): StandardSchemaValidator | undefined;
-/**
- * Runs one Standard Schema validator and normalizes the success/error shape.
- */
-export declare function validateStandardSchemaValue(validator: StandardSchemaValidator, value: unknown): Promise<StandardSchemaValidationResult>;
-/**
- * Formats Standard Schema issues into a concise single-line message.
- */
-export declare function formatStandardSchemaIssues(issues: readonly StandardSchemaV1.Issue[]): string;

package/dist/src/runtime/standard-schema.js

@@ -1,64 +0,0 @@
-/**
- * Returns the live Standard Schema validator when the value exposes one.
- */
-export function getStandardSchemaValidator(value) {
-    if (typeof value !== "object" || value === null) {
-        return undefined;
-    }
-    const standard = value["~standard"];
-    if (typeof standard?.validate !== "function") {
-        return undefined;
-    }
-    return standard.validate;
-}
-/**
- * Runs one Standard Schema validator and normalizes the success/error shape.
- */
-export async function validateStandardSchemaValue(validator, value) {
-    const result = await validator(value);
-    if ("value" in result) {
-        return {
-            ok: true,
-            value: result.value,
-        };
-    }
-    if (result.issues.length > 0) {
-        return {
-            issues: result.issues,
-            ok: false,
-        };
-    }
-    return {
-        issues: result.issues,
-        ok: false,
-    };
-}
-/**
- * Formats Standard Schema issues into a concise single-line message.
- */
-export function formatStandardSchemaIssues(issues) {
-    return issues
-        .map((issue) => {
-        const path = formatIssuePath(issue.path);
-        return path.length === 0 ? issue.message : `${path}: ${issue.message}`;
-    })
-        .join("; ");
-}
-function formatIssuePath(path) {
-    if (path === undefined || path.length === 0) {
-        return "";
-    }
-    return path
-        .map((segment, index) => {
-        const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
-        if (typeof key === "number") {
-            return `[${key}]`;
-        }
-        const token = String(key);
-        if (index === 0) {
-            return token;
-        }
-        return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(token) ? `.${token}` : `[${JSON.stringify(token)}]`;
-    })
-        .join("");
-}

package/dist/src/services/dev-client/live-stream.d.ts

@@ -1,35 +0,0 @@
-import type { HandleMessageStreamEvent } from "#protocol/message.js";
-/**
- * One reusable service-owned connection to a durable message-run stream.
- */
-export interface DevelopmentMessageStream {
-    /**
-     * Absolute stream URL used to open this connection.
-     */
-    readonly resourceUrl: string;
-    /**
-     * Whether the underlying response body can no longer produce future events.
-     */
-    readonly closed: boolean;
-    /**
-     * Stops reading from the underlying response and releases any held reader.
-     */
-    close(): Promise<void>;
-    /**
-     * Reads one slice of newline-delimited events from the stream until the
-     * configured boundary predicate matches or the response closes.
-     */
-    readEvents(input: {
-        onEvent?(event: HandleMessageStreamEvent): void;
-        startAfterBoundaryCount?: number;
-        stopWhen?(event: HandleMessageStreamEvent): boolean;
-    }): Promise<HandleMessageStreamEvent[]>;
-}
-/**
- * Opens one reusable message-stream reader for the development client.
- */
-export declare function openDevelopmentMessageStream(input: {
-    boundaryCount?: number;
-    resourceUrl: string;
-    response: Response;
-}): DevelopmentMessageStream;

package/dist/src/services/dev-client/live-stream.js

@@ -1,157 +0,0 @@
-import { isCurrentTurnBoundaryEvent } from "#protocol/message.js";
-function isDevelopmentMessageStreamDisconnectError(error) {
-    if (error instanceof DOMException) {
-        return error.name === "AbortError";
-    }
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    const errorCode = "code" in error && typeof error.code === "string" ? error.code : undefined;
-    return (error.name === "AbortError" ||
-        error.message === "terminated" ||
-        errorCode === "UND_ERR_SOCKET" ||
-        /abort|cancel|disconnect|premature close|socket|terminated/i.test(error.message));
-}
-class BufferedDevelopmentMessageStream {
-    resourceUrl;
-    #boundaryCount = 0;
-    #buffer = "";
-    #closed = false;
-    #decoder = new TextDecoder();
-    #isReading = false;
-    #reader;
-    constructor(input) {
-        this.resourceUrl = input.resourceUrl;
-        this.#boundaryCount = input.boundaryCount ?? 0;
-        this.#reader = input.response.body?.getReader() ?? null;
-        this.#closed = this.#reader === null;
-        if (this.#reader) {
-            void this.#reader.closed
-                .catch(() => undefined)
-                .finally(() => {
-                this.#closed = true;
-            });
-        }
-    }
-    get closed() {
-        return this.#closed;
-    }
-    async close() {
-        const reader = this.#reader;
-        this.#closed = true;
-        this.#reader = null;
-        this.#buffer = "";
-        if (reader === null) {
-            return;
-        }
-        try {
-            await reader.cancel();
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
-    async readEvents(input) {
-        if (this.#closed) {
-            return [];
-        }
-        if (this.#isReading) {
-            throw new Error("Development message stream does not support concurrent reads.");
-        }
-        const reader = this.#reader;
-        if (reader === null) {
-            return [];
-        }
-        this.#isReading = true;
-        try {
-            const events = [];
-            const stopWhen = input.stopWhen ?? isCurrentTurnBoundaryEvent;
-            const startAfterBoundaryCount = input.startAfterBoundaryCount ?? 0;
-            let shouldCollect = startAfterBoundaryCount <= this.#boundaryCount;
-            const handleEvent = (event) => {
-                const isBoundaryEvent = isCurrentTurnBoundaryEvent(event);
-                if (shouldCollect) {
-                    events.push(event);
-                    input.onEvent?.(event);
-                }
-                if (!isBoundaryEvent) {
-                    return false;
-                }
-                this.#boundaryCount += 1;
-                if (!shouldCollect && this.#boundaryCount >= startAfterBoundaryCount) {
-                    shouldCollect = true;
-                    return false;
-                }
-                return shouldCollect && stopWhen(event);
-            };
-            while (true) {
-                while (true) {
-                    const newlineIndex = this.#buffer.indexOf("\n");
-                    if (newlineIndex === -1) {
-                        break;
-                    }
-                    const line = this.#buffer.slice(0, newlineIndex).trim();
-                    this.#buffer = this.#buffer.slice(newlineIndex + 1);
-                    if (line.length === 0) {
-                        continue;
-                    }
-                    const event = JSON.parse(line);
-                    if (handleEvent(event)) {
-                        return events;
-                    }
-                }
-                if (this.#closed) {
-                    break;
-                }
-                let done = false;
-                let value;
-                try {
-                    const readResult = await reader.read();
-                    done = readResult.done;
-                    value = readResult.value;
-                }
-                catch (error) {
-                    if (!isDevelopmentMessageStreamDisconnectError(error)) {
-                        throw error;
-                    }
-                    // Discard any incomplete trailing line and reconnect from the last
-                    // fully parsed event via the durable stream cursor.
-                    this.#buffer = "";
-                    this.#closed = true;
-                    break;
-                }
-                if (done) {
-                    this.#buffer += this.#decoder.decode();
-                    this.#closed = true;
-                    continue;
-                }
-                if (!value) {
-                    continue;
-                }
-                this.#buffer += this.#decoder.decode(value, {
-                    stream: true,
-                });
-            }
-            const trailingLine = this.#buffer.trim();
-            this.#buffer = "";
-            if (trailingLine.length > 0) {
-                const event = JSON.parse(trailingLine);
-                handleEvent(event);
-            }
-            return events;
-        }
-        finally {
-            this.#isReading = false;
-            if (this.#closed) {
-                reader.releaseLock();
-                this.#reader = null;
-            }
-        }
-    }
-}
-/**
- * Opens one reusable message-stream reader for the development client.
- */
-export function openDevelopmentMessageStream(input) {
-    return new BufferedDevelopmentMessageStream(input);
-}

package/dist/src/services/dev-client/send-message.d.ts

@@ -1,24 +0,0 @@
-import type { HandleMessageStreamEvent } from "#protocol/message.js";
-import { type DevelopmentRequestHeaders } from "#services/dev-client/request-headers.js";
-import { type DevelopmentSessionState } from "#services/dev-client/session.js";
-/**
- * Sends one message to the configured Ash server and collects its streamed
- * events, forwarding any caller-supplied Ash route headers across the message
- * and stream requests for the current turn.
- */
-export declare function sendDevelopmentMessage(input: {
-    headers?: DevelopmentRequestHeaders;
-    message: string;
-    onEvent?(event: HandleMessageStreamEvent): void;
-    onResponseStart?(response: {
-        sessionId?: string;
-    }): void;
-    signal?: AbortSignal;
-    session: DevelopmentSessionState;
-    serverUrl: string;
-}): Promise<{
-    completedMessage?: string;
-    events: HandleMessageStreamEvent[];
-    sessionId?: string;
-    session: DevelopmentSessionState;
-}>;