@aexhq/sdk 0.62.1 → 0.63.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/tools.d.ts

@@ -1,48 +0,0 @@
-import type { ComponentExtension } from "@aexhq/brain";
-import type { ToolDefinition } from "@aexhq/brain/session";
-import * as z from "zod";
-export type JsonSchema = Record<string, unknown>;
-export interface ToolContext {
-    readonly signal: AbortSignal;
-    readonly operationId: string;
-    readonly sessionId: string;
-    readonly deadlineMs: number;
-}
-export type ToolHandler<Input extends z.ZodType, Output = unknown> = (input: z.output<Input>, context: ToolContext) => Output | Promise<Output>;
-export interface ToolContract {
-    readonly name: string;
-    readonly description?: string;
-    readonly inputSchema: JsonSchema;
-    readonly outputSchema?: JsonSchema;
-    readonly contractDigest: string;
-}
-export interface Tool<Input extends z.ZodType = z.ZodType, Output = unknown> {
-    readonly kind: "aex.tool";
-    readonly name?: string;
-    readonly description?: string;
-    readonly input: Input;
-    readonly output?: z.ZodType;
-    readonly handler: ToolHandler<Input, Output>;
-    describe(description: string): Tool<Input, Output>;
-    named(name: string): Tool<Input, Output>;
-    returns<Schema extends z.ZodType>(schema: Schema): Tool<Input, z.output<Schema>>;
-}
-declare const EMPTY_INPUT: z.ZodObject<{}, z.core.$strip>;
-export declare function tool<Output>(handler: ToolHandler<typeof EMPTY_INPUT, Output>): Tool<typeof EMPTY_INPUT, Output>;
-export declare function tool<Input extends z.ZodType, Output>(input: Input, handler: ToolHandler<Input, Output>): Tool<Input, Output>;
-export interface ClientRegistration {
-    readonly registration: string;
-    readonly name: string;
-    readonly contractDigest: string;
-    readonly input: z.ZodType;
-    readonly output?: z.ZodType;
-    readonly handler: ToolHandler<z.ZodType>;
-}
-export interface CompiledCallbacks {
-    readonly components: readonly ComponentExtension<"tool", Readonly<Record<string, unknown>> & {
-        readonly definition: ToolDefinition;
-    }>[];
-    readonly registrations: readonly ClientRegistration[];
-}
-export declare function compileCallbacks(selections: readonly Tool[]): Promise<CompiledCallbacks>;
-export {};

package/dist/tools.js

@@ -1,119 +0,0 @@
-import { callback as callbackComponent } from "@aexhq/env-app";
-import * as z from "zod";
-import { jcsSha256 } from "./json.js";
-const EMPTY_INPUT = z.object({});
-const TOOL_NAME = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/u;
-export function tool(inputOrHandler, maybeHandler) {
-    if (typeof inputOrHandler === "function") {
-        return makeTool({
-            ...(inputOrHandler.name === "" ? {} : { name: inputOrHandler.name }),
-            input: EMPTY_INPUT,
-            handler: inputOrHandler,
-        });
-    }
-    if (typeof maybeHandler !== "function")
-        throw new TypeError("tool(schema, handler) requires a function");
-    return makeTool({
-        ...(maybeHandler.name === "" ? {} : { name: maybeHandler.name }),
-        input: inputOrHandler,
-        handler: maybeHandler,
-    });
-}
-function makeTool(draft) {
-    return Object.freeze({
-        kind: "aex.tool",
-        ...(draft.name === undefined ? {} : { name: draft.name }),
-        ...(draft.description === undefined ? {} : { description: draft.description }),
-        input: draft.input,
-        ...(draft.output === undefined ? {} : { output: draft.output }),
-        handler: draft.handler,
-        describe(description) {
-            if (description.trim() === "" || description.length > 4096) {
-                throw new TypeError("Tool description must contain 1 through 4096 characters");
-            }
-            return makeTool({ ...draft, description });
-        },
-        named(name) {
-            assertToolName(name);
-            return makeTool({ ...draft, name });
-        },
-        returns(output) {
-            schemaOf(output, `${draft.name ?? "Tool"} output`);
-            return makeTool({ ...draft, output });
-        },
-    });
-}
-export async function compileCallbacks(selections) {
-    const components = [];
-    const registrations = [];
-    const names = new Set();
-    for (const value of selections) {
-        assertTool(value);
-        const contract = await compileContract(value);
-        if (names.has(contract.name)) {
-            throw new TypeError(`Tool ${JSON.stringify(contract.name)} was selected twice`);
-        }
-        names.add(contract.name);
-        const definition = {
-            name: contract.name,
-            ...(contract.description === undefined ? {} : { description: contract.description }),
-            input_schema: contract.inputSchema,
-            output_schema: contract.outputSchema ?? {},
-            contract_digest: contract.contractDigest,
-        };
-        const registration = `tool:${contract.contractDigest}`;
-        components.push(callbackComponent(definition, registration));
-        registrations.push(Object.freeze({
-            registration,
-            name: contract.name,
-            contractDigest: contract.contractDigest,
-            input: value.input,
-            ...(value.output === undefined ? {} : { output: value.output }),
-            handler: value.handler,
-        }));
-    }
-    return {
-        components: Object.freeze(components),
-        registrations: Object.freeze(registrations),
-    };
-}
-async function compileContract(value) {
-    const name = value.name;
-    if (name === undefined)
-        throw new TypeError("Tool functions must be named; use .named(name) when build tooling removes the name");
-    assertToolName(name);
-    const inputSchema = schemaOf(value.input, `${name} input`);
-    const outputSchema = value.output === undefined ? undefined : schemaOf(value.output, `${name} output`);
-    const canonical = {
-        name,
-        ...(value.description === undefined ? {} : { description: value.description }),
-        input_schema: inputSchema,
-        ...(outputSchema === undefined ? {} : { output_schema: outputSchema }),
-    };
-    return {
-        name,
-        ...(value.description === undefined ? {} : { description: value.description }),
-        inputSchema,
-        ...(outputSchema === undefined ? {} : { outputSchema }),
-        contractDigest: await jcsSha256(canonical),
-    };
-}
-function schemaOf(schema, label) {
-    try {
-        const value = z.toJSONSchema(schema, { target: "draft-2020-12", unrepresentable: "throw" });
-        if (Object.keys(value).length === 0)
-            throw new TypeError(`${label} schema is empty`);
-        return value;
-    }
-    catch (cause) {
-        throw new TypeError(`${label} cannot be represented as JSON Schema`, { cause });
-    }
-}
-function assertTool(value) {
-    if (value?.kind !== "aex.tool")
-        throw new TypeError("Tool selection is invalid");
-}
-function assertToolName(name) {
-    if (!TOOL_NAME.test(name))
-        throw new TypeError(`Invalid Tool name ${JSON.stringify(name)}`);
-}

package/dist/transport.d.ts

@@ -1,31 +0,0 @@
-import type { Event } from "@aexhq/brain/session";
-import type { JsonRequestOptions, TransferTicket } from "@aexhq/brain";
-export type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-export interface EventOptions {
-    after?: number;
-    follow?: boolean;
-    signal?: AbortSignal | undefined;
-}
-export declare class Transport {
-    #private;
-    readonly baseUrl: string;
-    constructor(apiKey: string, baseUrl: string, fetchImplementation: Fetch);
-    customerEnvironmentGrant(clientId: string, signal?: AbortSignal): Promise<{
-        url: string;
-        protocol: string;
-        expiresAt: string;
-        observationUrl: string;
-        observationToken: string;
-    }>;
-    customerEnvironmentObserve(url: string, token: string, observation: unknown): Promise<void>;
-    downloadTransfer(ticket: TransferTicket, signal?: AbortSignal, expectedBytes?: number): Promise<Uint8Array>;
-    downloadTransferStream(ticket: TransferTicket, signal?: AbortSignal, expectedBytes?: number): Promise<ReadableStream<Uint8Array>>;
-    uploadTransfer(ticket: TransferTicket, content: Uint8Array | (() => ReadableStream<Uint8Array>), bytes: number, signal?: AbortSignal): Promise<void>;
-    json<T>(method: "GET" | "POST" | "DELETE", path: string, options?: JsonRequestOptions): Promise<T>;
-    /** Accept one durable deletion job; strict callers poll its short status resource client-side. */
-    deleteSession(sessionId: string, waitForCompletion: boolean, signal?: AbortSignal): Promise<void>;
-    events(sessionId: string, options?: EventOptions): AsyncGenerator<Event>;
-    private responseError;
-}
-/** @internal Incremental, constant-space decoder for Brain's bounded public SSE events. */
-export declare function parseEventStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<Event>;