@aexhq/sdk 0.62.1 → 0.64.0

package/dist/resources.js

@@ -1,442 +0,0 @@
-import { MAX_INLINE_FILE_BYTES, SessionChildren as BrainChildren, SessionSandbox as BrainSandbox, SessionStorage as BrainStorage, } from "@aexhq/brain";
-import { SessionError, abortError } from "./errors.js";
-import { randomIdempotencyKey } from "./json.js";
-export class SandboxFiles {
-    #inner;
-    #transport;
-    constructor(inner, transport) {
-        this.#inner = inner;
-        this.#transport = transport;
-    }
-    async list(path, options) {
-        const page = await this.#inner.list({
-            path,
-            generation: options.generation,
-            ...(options.cursor === undefined ? {} : { cursor: options.cursor }),
-            ...(options.limit === undefined ? {} : { limit: options.limit }),
-        }, request(options));
-        return filePage(page);
-    }
-    async stat(path, options) {
-        return file(await this.#inner.stat({ path, generation: options.generation }, request(options)));
-    }
-    async download(path, options) {
-        return collect(await this.downloadStream(path, options));
-    }
-    async downloadStream(path, options) {
-        const entry = await this.#inner.stat({ path, generation: options.generation }, request(options));
-        if (entry.bytes <= MAX_INLINE_FILE_BYTES) {
-            const result = await this.#inner.readInline({ path, generation: options.generation }, request(options));
-            return byteStream(decodeBase64(result.content_base64));
-        }
-        const ticket = await this.#inner.prepareDownload({ path, generation: options.generation }, request(options));
-        return this.#transport.downloadTransferStream(ticket, options.signal, entry.bytes);
-    }
-    async upload(path, source, options) {
-        const base = {
-            path,
-            generation: options.generation,
-            ...(options.overwrite === undefined ? {} : { overwrite: options.overwrite }),
-        };
-        let entry;
-        if (isStreamingSource(source)) {
-            assertStreamingSource(source);
-            entry = source.bytes <= MAX_INLINE_FILE_BYTES
-                ? await this.#inner.writeInline({ ...base, content_base64: encodeBase64(await collectDeclared(source, options.signal)) }, request(options))
-                : await this.#uploadStream(base, source, options);
-        }
-        else {
-            const content = await bytesOf(source);
-            entry = content.byteLength <= MAX_INLINE_FILE_BYTES
-                ? await this.#inner.writeInline({ ...base, content_base64: encodeBase64(content) }, request(options))
-                : await this.#upload(base, content, options);
-        }
-        return file(entry);
-    }
-    async #upload(input, content, options) {
-        const ticket = await this.#inner.prepareUpload({ ...input, bytes: content.byteLength, sha256: await sha256(content) }, request(options));
-        await this.#transport.uploadTransfer(ticket, content, content.byteLength, options.signal);
-        // Direct sandbox transfers are intentionally happy-path only. Do not automatically replay an
-        // ambiguous import: surface the error so the caller can inspect the generation/path and
-        // prepare a fresh transfer. Durable storage completion has separate retry-safe semantics.
-        return this.#inner.completeUpload(ticket.transfer_id, request(options));
-    }
-    async #uploadStream(input, source, options) {
-        const ticket = await this.#inner.prepareUpload({ ...input, bytes: source.bytes, sha256: source.sha256 }, request(options));
-        await this.#transport.uploadTransfer(ticket, () => source.stream(), source.bytes, options.signal);
-        return this.#inner.completeUpload(ticket.transfer_id, request(options));
-    }
-    async find(input, options) {
-        const page = await this.#inner.find({
-            ...input,
-            generation: options.generation,
-            ...(options.cursor === undefined ? {} : { cursor: options.cursor }),
-            ...(options.limit === undefined ? {} : { limit: options.limit }),
-        }, request(options));
-        return filePage(page);
-    }
-    async grep(input, options) {
-        const page = await this.#inner.grep({
-            ...input,
-            generation: options.generation,
-            ...(options.cursor === undefined ? {} : { cursor: options.cursor }),
-            ...(options.limit === undefined ? {} : { limit: options.limit }),
-        }, request(options));
-        return filePage(page);
-    }
-}
-export class SessionSandbox {
-    #inner;
-    files;
-    constructor(transport, sessionId, environment) {
-        this.#inner = new BrainSandbox(transport, sessionId, environment);
-        this.files = new SandboxFiles(this.#inner.files, transport);
-    }
-    /** The declared Environment name this sandbox addresses. */
-    get environment() {
-        return this.#inner.environment;
-    }
-    async status(options = {}) {
-        return sandboxStatus(await this.#inner.status(request(options)));
-    }
-    async create(options = {}) {
-        return sandboxStatus(await this.#inner.create(intrinsicRequest(options)));
-    }
-}
-export class SessionStorage {
-    #inner;
-    #transport;
-    constructor(transport, sessionId) {
-        this.#inner = new BrainStorage(transport, sessionId);
-        this.#transport = transport;
-    }
-    async list(options = {}) {
-        const page = await this.#inner.list({
-            ...(options.prefix === undefined ? {} : { prefix: options.prefix }),
-            ...(options.cursor === undefined ? {} : { cursor: options.cursor }),
-            ...(options.limit === undefined ? {} : { limit: options.limit }),
-        }, request(options));
-        return {
-            data: page.data.map(storageObject),
-            hasMore: page.has_more,
-            ...(page.next_cursor === undefined ? {} : { nextCursor: page.next_cursor }),
-        };
-    }
-    async stat(key, options = {}) {
-        return storageObject(await this.#inner.stat(key, request(options)));
-    }
-    async download(key, options = {}) {
-        return collect(await this.downloadStream(key, options));
-    }
-    async downloadStream(key, options = {}) {
-        const object = await this.#inner.stat(key, request(options));
-        if (object.bytes <= MAX_INLINE_FILE_BYTES) {
-            return byteStream(decodeBase64((await this.#inner.readInline(key, request(options))).content_base64));
-        }
-        const ticket = await this.#inner.prepareDownload(key, request(options));
-        return this.#transport.downloadTransferStream(ticket, options.signal, object.bytes);
-    }
-    async upload(key, source, options = {}) {
-        const base = {
-            key,
-            ...(options.contentType === undefined ? {} : { content_type: options.contentType }),
-            ...(options.overwrite === undefined ? {} : { overwrite: options.overwrite }),
-        };
-        if (isStreamingSource(source)) {
-            assertStreamingSource(source);
-            if (source.bytes <= MAX_INLINE_FILE_BYTES) {
-                return storageObject(await this.#inner.writeInline({ ...base, content_base64: encodeBase64(await collectDeclared(source, options.signal)) }, request(options)));
-            }
-            const ticket = await this.#inner.prepareUpload({ ...base, bytes: source.bytes, sha256: source.sha256 }, request(options));
-            await this.#transport.uploadTransfer(ticket, () => source.stream(), source.bytes, options.signal);
-            return storageObject(await this.#inner.completeUpload(ticket.transfer_id, intrinsicRequest(options)));
-        }
-        const content = await bytesOf(source);
-        if (content.byteLength <= MAX_INLINE_FILE_BYTES) {
-            return storageObject(await this.#inner.writeInline({ ...base, content_base64: encodeBase64(content) }, request(options)));
-        }
-        const ticket = await this.#inner.prepareUpload({ ...base, bytes: content.byteLength, sha256: await sha256(content) }, request(options));
-        await this.#transport.uploadTransfer(ticket, content, content.byteLength, options.signal);
-        return storageObject(await this.#inner.completeUpload(ticket.transfer_id, intrinsicRequest(options)));
-    }
-    delete(key, options = {}) {
-        return this.#inner.delete(key, request(options));
-    }
-    async copyFromSandbox(input, options = {}) {
-        return storageObject(await this.#inner.copyFromEnvironment(input.environment, {
-            key: input.key,
-            path: input.path,
-            environment_generation: input.sandboxGeneration,
-            ...(input.overwrite === undefined ? {} : { overwrite: input.overwrite }),
-        }, request(options)));
-    }
-    async copyToSandbox(input, options = {}) {
-        return file(await this.#inner.copyToEnvironment(input.environment, {
-            key: input.key,
-            path: input.path,
-            environment_generation: input.sandboxGeneration,
-            ...(input.overwrite === undefined ? {} : { overwrite: input.overwrite }),
-        }, request(options)));
-    }
-}
-export class SessionChild {
-    #inner;
-    constructor(inner) {
-        this.#inner = inner;
-    }
-    get id() {
-        return this.#inner.id;
-    }
-    async info(options = {}) {
-        return child(await this.#inner.get(request(options)));
-    }
-    async send(message, options = {}) {
-        await this.#inner.send(message, idempotentRequest(options));
-    }
-    async followUp(message, options = {}) {
-        return child(await this.#inner.followUp(message, idempotentRequest(options)));
-    }
-    async wait(options = {}) {
-        return child(await this.#inner.wait(options.timeoutMs === undefined ? {} : { timeout_ms: options.timeoutMs }, request(options)));
-    }
-    async interrupt(options = {}) {
-        return child(await this.#inner.interrupt(intrinsicRequest(options)));
-    }
-    async end(options = {}) {
-        return child(await this.#inner.end(intrinsicRequest(options)));
-    }
-    events(options = {}) {
-        return this.#inner.events(options);
-    }
-}
-export class SessionChildren {
-    #inner;
-    constructor(transport, sessionId) {
-        this.#inner = new BrainChildren(transport, sessionId);
-    }
-    async create(input, options = {}) {
-        const handle = await this.#inner.create({
-            prompt: input.prompt,
-            ...(input.name === undefined ? {} : { name: input.name }),
-            ...(input.forkTurns === undefined ? {} : { fork_turns: input.forkTurns }),
-        }, idempotentRequest(options));
-        return new SessionChild(handle);
-    }
-    async list(options = {}) {
-        const page = await this.#inner.list({
-            ...(options.cursor === undefined ? {} : { cursor: options.cursor }),
-            ...(options.limit === undefined ? {} : { limit: options.limit }),
-        }, request(options));
-        return {
-            data: page.data.map(child),
-            hasMore: page.has_more,
-            ...(page.next_cursor === undefined ? {} : { nextCursor: page.next_cursor }),
-        };
-    }
-    get(childId) {
-        return new SessionChild(this.#inner.get(childId));
-    }
-}
-function request(options) {
-    return options.signal === undefined ? {} : { signal: options.signal };
-}
-function intrinsicRequest(options) {
-    return {
-        ...(options.signal === undefined ? {} : { signal: options.signal }),
-        retry: true,
-    };
-}
-function idempotentRequest(options) {
-    return {
-        ...(options.signal === undefined ? {} : { signal: options.signal }),
-        headers: { "Idempotency-Key": options.idempotencyKey ?? randomIdempotencyKey() },
-        retry: true,
-    };
-}
-function sandboxStatus(value) {
-    return {
-        state: value.state,
-        ...(value.generation == null ? {} : { generation: value.generation }),
-        ...(value.reason == null ? {} : { reason: value.reason }),
-        ...(value.changed_at_ms == null ? {} : { changedAt: timestamp(value.changed_at_ms) }),
-        ...(value.expires_at_ms == null ? {} : { expiresAt: timestamp(value.expires_at_ms) }),
-    };
-}
-function file(value) {
-    return {
-        path: value.path,
-        kind: value.kind,
-        bytes: value.bytes,
-        ...(value.sha256 == null ? {} : { sha256: value.sha256 }),
-        modifiedAt: timestamp(value.modified_at_ms),
-    };
-}
-function filePage(value) {
-    return {
-        data: value.data.map(file),
-        hasMore: value.has_more,
-        ...(value.next_cursor === undefined ? {} : { nextCursor: value.next_cursor }),
-        generation: value.generation,
-    };
-}
-function storageObject(value) {
-    return {
-        key: value.key,
-        bytes: value.bytes,
-        sha256: value.sha256,
-        ...(value.content_type === undefined ? {} : { contentType: value.content_type }),
-        createdAt: value.created_at,
-        updatedAt: value.updated_at,
-    };
-}
-function child(value) {
-    if (value.parent_id === undefined) {
-        throw new SessionError(`Aex returned root session ${value.id} from a direct-child resource`);
-    }
-    return {
-        id: value.id,
-        parentId: value.parent_id,
-        rootId: value.root_id,
-        ...(value.name === undefined ? {} : { name: value.name }),
-        depth: value.depth,
-        state: value.state,
-        turnState: value.turn_state,
-        ...(value.turn_phase === undefined ? {} : { turnPhase: value.turn_phase }),
-        shape: value.shape,
-        createdAt: value.created_at,
-        updatedAt: value.updated_at,
-    };
-}
-function timestamp(value) {
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new SessionError("Aex returned an invalid sandbox timestamp");
-    }
-    try {
-        return new Date(value).toISOString();
-    }
-    catch (cause) {
-        throw new SessionError("Aex returned an invalid sandbox timestamp", { cause });
-    }
-}
-async function bytesOf(source) {
-    if (typeof source === "string")
-        return new TextEncoder().encode(source);
-    if (source instanceof ArrayBuffer)
-        return new Uint8Array(source);
-    if (typeof Blob !== "undefined" && source instanceof Blob) {
-        return new Uint8Array(await source.arrayBuffer());
-    }
-    if (ArrayBuffer.isView(source)) {
-        return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    }
-    throw new TypeError("Unsupported binary source");
-}
-function isStreamingSource(source) {
-    return typeof source === "object" && source !== null && "stream" in source &&
-        "bytes" in source && "sha256" in source && !(typeof Blob !== "undefined" && source instanceof Blob);
-}
-function assertStreamingSource(source) {
-    if (!Number.isSafeInteger(source.bytes) || source.bytes < 0) {
-        throw new TypeError("Streaming upload bytes must be a non-negative safe integer");
-    }
-    if (!/^[0-9a-f]{64}$/u.test(source.sha256)) {
-        throw new TypeError("Streaming upload sha256 must be 64 lowercase hexadecimal characters");
-    }
-    if (typeof source.stream !== "function") {
-        throw new TypeError("Streaming upload source must provide stream()");
-    }
-}
-function byteStream(bytes) {
-    return new ReadableStream({
-        start(controller) {
-            if (bytes.byteLength !== 0)
-                controller.enqueue(bytes);
-            controller.close();
-        },
-    });
-}
-async function collect(stream) {
-    const chunks = [];
-    let bytes = 0;
-    const reader = stream.getReader();
-    try {
-        while (true) {
-            const item = await reader.read();
-            if (item.done)
-                break;
-            chunks.push(item.value);
-            bytes += item.value.byteLength;
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    const result = new Uint8Array(bytes);
-    let offset = 0;
-    for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return result;
-}
-async function collectDeclared(source, signal) {
-    if (signal?.aborted === true)
-        throw abortError(signal.reason);
-    const reader = source.stream().getReader();
-    const result = new Uint8Array(source.bytes);
-    let offset = 0;
-    let aborted = false;
-    const abort = () => {
-        aborted = true;
-        void reader.cancel(signal?.reason).catch(() => undefined);
-    };
-    signal?.addEventListener("abort", abort, { once: true });
-    try {
-        while (true) {
-            const item = await reader.read();
-            if (aborted)
-                throw abortError(signal?.reason);
-            if (item.done)
-                break;
-            if (!(item.value instanceof Uint8Array) || offset + item.value.byteLength > result.byteLength) {
-                throw new TypeError("Streaming upload exceeded its declared byte length");
-            }
-            result.set(item.value, offset);
-            offset += item.value.byteLength;
-        }
-    }
-    finally {
-        signal?.removeEventListener("abort", abort);
-        reader.releaseLock();
-    }
-    if (offset !== result.byteLength) {
-        throw new TypeError(`Streaming upload produced ${offset} bytes; expected ${result.byteLength}`);
-    }
-    if (await sha256(result) !== source.sha256) {
-        throw new TypeError("Streaming upload content does not match its declared sha256");
-    }
-    return result;
-}
-export function encodeBase64(bytes) {
-    let binary = "";
-    for (let offset = 0; offset < bytes.byteLength; offset += 32_768) {
-        binary += String.fromCharCode(...bytes.subarray(offset, offset + 32_768));
-    }
-    return btoa(binary);
-}
-function decodeBase64(value) {
-    const binary = atob(value);
-    const bytes = new Uint8Array(binary.length);
-    for (let index = 0; index < binary.length; index += 1)
-        bytes[index] = binary.charCodeAt(index);
-    return bytes;
-}
-async function sha256(value) {
-    const input = value.buffer instanceof ArrayBuffer
-        ? value
-        : Uint8Array.from(value);
-    const digest = await crypto.subtle.digest("SHA-256", input);
-    return [...new Uint8Array(digest)]
-        .map((byte) => byte.toString(16).padStart(2, "0"))
-        .join("");
-}

package/dist/session.d.ts

@@ -1,137 +0,0 @@
-import type { Event, Session as BrainSessionData, SessionState } from "@aexhq/brain/session";
-import { type ComponentExtension, type SessionTool as ComponentSessionTool } from "@aexhq/brain";
-import type { NetworkPolicy, WebSocketFactory } from "@aexhq/brain";
-import * as z from "zod";
-import type { EventOptions } from "./transport.js";
-import { Transport } from "./transport.js";
-import { type Tool } from "./tools.js";
-import { SessionChildren, SessionSandbox, SessionStorage } from "./resources.js";
-type SessionData = BrainSessionData & {
-    retain_until: string;
-};
-export type SessionInput = string;
-export interface ModelOptions {
-    /** Imported Model component. */
-    component: ComponentExtension<"model">;
-    provider: string;
-    name: string;
-    apiKey: string;
-    baseUrl?: string;
-    maxOutputTokens?: number;
-}
-export interface CreateSessionOptions {
-    model: ModelOptions;
-    /** The imported agent loop that drives this session and every child unless spawn overrides it. */
-    agentloop: ComponentExtension<"agentloop">;
-    /** Omitted or empty grants no tools. A non-empty list is the exact grant. */
-    environments?: Readonly<Record<string, ComponentExtension<"environment">>>;
-    tools?: readonly (Tool | ComponentSessionTool)[];
-    /** Write-only values for components that explicitly consume session secrets. */
-    secrets?: Record<string, string>;
-    /** Maximum direct outbound network authority sealed for managed sandboxes. Omission is deny-all. */
-    network?: NetworkPolicy;
-    /** Replacement attempts after an unrecoverable provider outcome. Defaults to one. */
-    providerRecoveryRetries?: 0 | 1;
-    /** Optional ceilings for durable child sessions. Omitted fields use the hosted defaults. */
-    children?: {
-        maxDepth?: number;
-        maxDirectChildren?: number;
-        maxDescendants?: number;
-    };
-    metadata?: Record<string, string>;
-    /** Finite durable-history deadline. Omit to use the Brain deployment default. */
-    retainUntil?: Date | string;
-}
-export interface RequestOptions {
-    signal?: AbortSignal;
-    idempotencyKey?: string;
-    metadata?: Record<string, string>;
-}
-export interface OutputOptions<Schema extends z.ZodType = z.ZodType> extends RequestOptions {
-    output: Schema;
-    /** Extra attempts after the first invalid candidate. Defaults to 1; maximum 2. */
-    outputRetries?: 0 | 1 | 2;
-}
-export interface ListSessionsOptions {
-    limit?: number;
-    cursor?: string;
-    state?: SessionState;
-    signal?: AbortSignal;
-}
-export interface SessionList {
-    data: Session[];
-    hasMore: boolean;
-    nextCursor?: string;
-}
-export interface ModelSummary {
-    provider: string;
-    name: string;
-    baseUrl?: string;
-    contextWindowTokens: number;
-}
-export interface SessionSummary {
-    id: string;
-    parentId: string | undefined;
-    rootId: string;
-    depth: number;
-    state: SessionState;
-    turnState: SessionData["turn_state"];
-    model: ModelSummary;
-    createdAt: string;
-    updatedAt: string;
-    retainUntil: string;
-    metadata: Readonly<Record<string, string | undefined>>;
-}
-export declare class Sessions {
-    #private;
-    constructor(transport: Transport, webSocketFactory?: WebSocketFactory);
-    /** @internal Called by `Aex.close()`. */
-    close(): void;
-    create(options: CreateSessionOptions, request?: RequestOptions): Promise<Session>;
-    get(id: string, options?: Pick<RequestOptions, "signal">): Promise<Session>;
-    list(options?: ListSessionsOptions): Promise<SessionList>;
-}
-export declare class Session implements SessionSummary {
-    #private;
-    readonly storage: SessionStorage;
-    readonly children: SessionChildren;
-    constructor(transport: Transport, data: SessionData);
-    /** The Environment names this session sealed. Only these can be addressed. */
-    get environments(): readonly string[];
-    /** One sealed Environment addressed by the name the session declared it under. */
-    environment(name: string): SessionSandbox;
-    /** The session's default sandbox: the one Environment it declared. */
-    get sandbox(): SessionSandbox;
-    get id(): string;
-    get state(): SessionState;
-    get turnState(): SessionData["turn_state"];
-    get parentId(): string | undefined;
-    get rootId(): string;
-    get depth(): number;
-    get model(): ModelSummary;
-    get createdAt(): string;
-    get updatedAt(): string;
-    get retainUntil(): string;
-    get metadata(): Readonly<Record<string, string | undefined>>;
-    refresh(options?: Pick<RequestOptions, "signal">): Promise<this>;
-    send(input: SessionInput, options?: RequestOptions): Promise<string>;
-    send<Schema extends z.ZodType>(input: SessionInput, options: OutputOptions<Schema>): Promise<z.output<Schema>>;
-    /**
-     * Raw, attempt-aware event stream. Provisional frames have no durable cursor and may later be
-     * superseded; consumers rendering them must key by `attempt_id` and process
-     * `model.attempt_superseded`. Use `send()` when only the durable winning answer is needed.
-     */
-    events(options?: EventOptions): AsyncGenerator<Event>;
-    cancel(options?: Pick<RequestOptions, "signal">): Promise<this>;
-    suspend(options?: Pick<RequestOptions, "signal">): Promise<this>;
-    resume(options?: Pick<RequestOptions, "signal">): Promise<this>;
-    setRetention(value: Date | string, options?: Pick<RequestOptions, "signal"> & {
-        allowShorten?: boolean;
-    }): Promise<this>;
-    end(options?: Pick<RequestOptions, "signal">): Promise<this>;
-    delete(options?: Pick<RequestOptions, "signal"> & {
-        queue?: boolean;
-    }): Promise<void>;
-    private markIdle;
-}
-export {};