@maiaos/sdk 0.1.0-canary.2

package/dist/interaction/interaction.d.ts

@@ -0,0 +1,12 @@
+import type { InteractionCancelParameters, InteractionCancelResult, InteractionCreateParameters, InteractionCreateResult, InteractionListParameters, InteractionListResult, InteractionRespondParameters, InteractionRespondResult, InteractionShowParameters, InteractionShowResult } from "@maiaos/protocol";
+import type { LocalNodeRequester, LocalNodeRequestOptions } from "../request/index.js";
+export type InteractionClient = {
+    readonly cancelInteraction: (parameters: InteractionCancelParameters, options: LocalNodeRequestOptions) => Promise<InteractionCancelResult>;
+    readonly createInteraction: (parameters: InteractionCreateParameters, options: LocalNodeRequestOptions) => Promise<InteractionCreateResult>;
+    readonly listInteractions: (parameters: InteractionListParameters, options: LocalNodeRequestOptions) => Promise<InteractionListResult>;
+    readonly respondToInteraction: (parameters: InteractionRespondParameters, options: LocalNodeRequestOptions) => Promise<InteractionRespondResult>;
+    readonly showInteraction: (parameters: InteractionShowParameters, options: LocalNodeRequestOptions) => Promise<InteractionShowResult>;
+};
+export declare const makeInteractionClient: (request: LocalNodeRequester) => InteractionClient;
+export { type Interaction, INTERACTION_EXPIRED_ERROR_CODE, type InteractionAnswer, interactionAnswerSchema, type InteractionCancelParameters, interactionCancelParametersSchema, type InteractionCancelResult, interactionCancelResultSchema, type InteractionCreateParameters, interactionCreateParametersSchema, type InteractionCreateResult, interactionCreateResultSchema, type InteractionDetail, interactionDetailSchema, type InteractionListParameters, interactionListParametersSchema, type InteractionListResult, interactionListResultSchema, type InteractionRespondParameters, interactionRespondParametersSchema, type InteractionRespondResult, interactionRespondResultSchema, interactionSchema, type InteractionShowParameters, interactionShowParametersSchema, type InteractionShowResult, interactionShowResultSchema, MAX_INTERACTION_RESULT_BYTES, } from "@maiaos/protocol";
+//# sourceMappingURL=interaction.d.ts.map

package/dist/interaction/interaction.js

@@ -0,0 +1,5 @@
+import { fromPromiseRequester, toPromiseClient } from "../request/effect.js";
+import { makeInteractionOperations } from "./effect.js";
+export const makeInteractionClient = (request) => toPromiseClient(makeInteractionOperations(fromPromiseRequester(request)));
+export { INTERACTION_EXPIRED_ERROR_CODE, interactionAnswerSchema, interactionCancelParametersSchema, interactionCancelResultSchema, interactionCreateParametersSchema, interactionCreateResultSchema, interactionDetailSchema, interactionListParametersSchema, interactionListResultSchema, interactionRespondParametersSchema, interactionRespondResultSchema, interactionSchema, interactionShowParametersSchema, interactionShowResultSchema, MAX_INTERACTION_RESULT_BYTES, } from "@maiaos/protocol";
+//# sourceMappingURL=interaction.js.map

package/dist/node/attach.d.ts

@@ -0,0 +1,11 @@
+import { type SessionAttachFrame } from "@maiaos/protocol";
+import type * as Crypto from "effect/Crypto";
+import * as Stream from "effect/Stream";
+import type { MaiaClientError } from "../request/index.js";
+import { type NodeApiEffectDiscoveryOptions } from "./discovery.js";
+import { type SessionAttachRequest } from "./transport.js";
+export type SessionAttachEffectOptions = NodeApiEffectDiscoveryOptions & {
+    readonly messageId?: string;
+};
+export declare const attachSessionEffect: (parameters: SessionAttachRequest["parameters"], options?: SessionAttachEffectOptions) => Stream.Stream<SessionAttachFrame, MaiaClientError, Crypto.Crypto>;
+//# sourceMappingURL=attach.d.ts.map

package/dist/node/attach.js

@@ -0,0 +1,33 @@
+import { MAIA_PROTOCOL_VERSION, NODE_API_SCHEMA_VERSION, } from "@maiaos/protocol";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { connectDiscoveredNodeApi, discoveryFailure, newMessageId, } from "./discovery.js";
+import { createNodeApiEffectClient } from "./http.js";
+import { makeSessionAttachStream, } from "./transport.js";
+const discoverAttachment = (options) => connectDiscoveredNodeApi(options, (descriptor, token) => {
+    const client = createNodeApiEffectClient({
+        credential: token,
+        endpoint: descriptor.endpoint,
+    });
+    return {
+        client: { token },
+        status: (messageId) => client.status({ messageId }),
+    };
+}).pipe(Effect.mapError(discoveryFailure));
+export const attachSessionEffect = (parameters, options = {}) => Stream.unwrap(Effect.gen(function* () {
+    const connection = yield* discoverAttachment(options);
+    const messageId = options.messageId ?? (yield* newMessageId("attach"));
+    return makeSessionAttachStream({
+        credential: connection.client.token,
+        endpoint: connection.descriptor.endpoint,
+        request: {
+            kind: "subscribe",
+            messageId,
+            operationId: "session.attach",
+            parameters,
+            protocolVersion: MAIA_PROTOCOL_VERSION,
+            schemaVersion: NODE_API_SCHEMA_VERSION,
+        },
+    });
+}));
+//# sourceMappingURL=attach.js.map

package/dist/node/bridge-frame.d.ts

@@ -0,0 +1,18 @@
+import { type BridgeRequestFrame, type BridgeServerFrame, type ProtocolError } from "@maiaos/protocol";
+import * as Stream from "effect/Stream";
+export declare const decodeRequestFrame: (line: string) => BridgeRequestFrame | undefined;
+export declare const decodeServerFrame: (line: string) => BridgeServerFrame | undefined;
+export declare const failureRemoteError: (frame: Extract<BridgeServerFrame, {
+    readonly type: "failure";
+}>) => ProtocolError | undefined;
+export declare const encodeFrame: (frame: BridgeRequestFrame | BridgeServerFrame) => string;
+export type FrameLine = {
+    readonly _tag: "Invalid";
+} | {
+    readonly _tag: "Line";
+    readonly text: string;
+} | {
+    readonly _tag: "Overflow";
+};
+export declare const splitFrameLines: (maximumBytes: number) => <TError, TContext>(stream: Stream.Stream<Uint8Array, TError, TContext>) => Stream.Stream<readonly FrameLine[], TError, TContext>;
+//# sourceMappingURL=bridge-frame.d.ts.map

package/dist/node/bridge-frame.js

@@ -0,0 +1,67 @@
+import { Buffer } from "node:buffer";
+import { bridgeRequestFrameSchema, bridgeServerFrameSchema, protocolErrorSchema, } from "@maiaos/protocol";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+const parseJson = (line) => Option.getOrUndefined(decodeJson(line));
+export const decodeRequestFrame = (line) => {
+    const parsed = bridgeRequestFrameSchema.safeParse(parseJson(line));
+    return parsed.success ? parsed.data : undefined;
+};
+export const decodeServerFrame = (line) => {
+    const parsed = bridgeServerFrameSchema.safeParse(parseJson(line));
+    return parsed.success ? parsed.data : undefined;
+};
+export const failureRemoteError = (frame) => {
+    const parsed = protocolErrorSchema.safeParse(frame.remoteError);
+    return parsed.success ? parsed.data : undefined;
+};
+export const encodeFrame = (frame) => `${JSON.stringify(frame)}\n`;
+const NEWLINE = 10;
+const STOPPED = { bytes: 0, chunks: [], stopped: true };
+const EMPTY = { bytes: 0, chunks: [], stopped: false };
+const utf8 = new TextDecoder("utf-8", { fatal: true });
+const decodeLine = (chunks) => {
+    try {
+        return { _tag: "Line", text: utf8.decode(Buffer.concat(chunks)) };
+    }
+    catch {
+        return { _tag: "Invalid" };
+    }
+};
+const piecesOf = (chunk, state) => Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+    .toString("latin1")
+    .split(String.fromCodePoint(NEWLINE))
+    .map((segment, index) => ({
+    bytes: Buffer.from(segment, "latin1"),
+    prefix: index === 0 ? state : EMPTY,
+}));
+const tooLong = (piece, maximumBytes) => piece.prefix.bytes + piece.bytes.byteLength > maximumBytes;
+const pending = (piece) => ({
+    bytes: piece.prefix.bytes + piece.bytes.byteLength,
+    chunks: piece.bytes.byteLength === 0
+        ? piece.prefix.chunks
+        : [...piece.prefix.chunks, piece.bytes],
+    stopped: false,
+});
+const splitChunk = (state, chunk, maximumBytes) => {
+    const pieces = piecesOf(chunk, state);
+    const overflow = pieces.findIndex((piece) => tooLong(piece, maximumBytes));
+    const complete = pieces.slice(0, -1);
+    const lines = complete
+        .slice(0, overflow < 0 ? complete.length : overflow)
+        .map((piece) => decodeLine([...piece.prefix.chunks, piece.bytes]));
+    if (overflow >= 0)
+        return [STOPPED, [...lines, { _tag: "Overflow" }]];
+    const remainder = pieces.at(-1) ?? { bytes: new Uint8Array(), prefix: state };
+    return [pending(remainder), lines];
+};
+const batch = (state, chunk, maximumBytes) => {
+    if (state.stopped)
+        return [state, []];
+    const [next, lines] = splitChunk(state, chunk, maximumBytes);
+    return [next, lines.length === 0 ? [] : [lines]];
+};
+export const splitFrameLines = (maximumBytes) => (stream) => stream.pipe(Stream.mapAccum(() => EMPTY, (state, chunk) => batch(state, chunk, maximumBytes)));
+//# sourceMappingURL=bridge-frame.js.map

package/dist/node/bridge.d.ts

@@ -0,0 +1,31 @@
+import { type LocalNodeStatusResult } from "@maiaos/protocol";
+import type * as Cause from "effect/Cause";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import type { ChildProcessHandle } from "effect/process/ChildProcessSpawner";
+import type * as Scope from "effect/Scope";
+import { type LocalNodeEffectClient } from "../client/effect.js";
+import { type MaiaTransport } from "../request/index.js";
+declare const BridgeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "BridgeError";
+} & Readonly<A>;
+export declare class BridgeError extends BridgeError_base<{
+    readonly message: string;
+    readonly reason: "closed" | "deadline_exceeded" | "node_unavailable" | "protocol_invalid";
+}> {
+}
+export type BridgeHello = {
+    readonly status: LocalNodeStatusResult;
+    readonly version: string;
+};
+export type NodeBridge = {
+    readonly client: LocalNodeEffectClient;
+    readonly closed: Effect.Effect<boolean>;
+    readonly hello: BridgeHello;
+    readonly transport: MaiaTransport;
+};
+export declare const openNodeBridge: (handle: ChildProcessHandle, options?: {
+    readonly helloDeadline?: Duration.Input;
+}) => Effect.Effect<NodeBridge, BridgeError, Scope.Scope>;
+export {};
+//# sourceMappingURL=bridge.d.ts.map

package/dist/node/bridge.js

@@ -0,0 +1,148 @@
+import { localNodeOperationErrorCodeSchema, localNodeStatusResultSchema, MAX_BRIDGE_FRAME_BYTES, MAX_BRIDGE_IN_FLIGHT, } from "@maiaos/protocol";
+import * as Data from "effect/Data";
+import * as Deferred from "effect/Deferred";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Stream from "effect/Stream";
+import { makeLocalNodeEffectClient, } from "../client/effect.js";
+import { makeLocalNodeEffectRequester, } from "../request/effect.js";
+import { MaiaClientError, } from "../request/index.js";
+import { decodeServerFrame, encodeFrame, failureRemoteError, splitFrameLines, } from "./bridge-frame.js";
+const DEFAULT_HELLO_DEADLINE = Duration.seconds(20);
+const REQUEST_DEADLINE = Duration.seconds(15);
+export class BridgeError extends Data.TaggedError("BridgeError") {
+}
+const BASE_CLIENT_CODES = new Set([
+    "cancelled",
+    "correlation_mismatch",
+    "invalid_request",
+    "invalid_response",
+    "remote_error",
+    "transport_failure",
+]);
+const isClientCode = (code) => BASE_CLIENT_CODES.has(code) ||
+    localNodeOperationErrorCodeSchema.safeParse(code).success;
+const clientError = (frame) => {
+    const remote = failureRemoteError(frame);
+    return new MaiaClientError(isClientCode(frame.code) ? frame.code : "transport_failure", frame.message, remote === undefined ? undefined : { remoteError: remote });
+};
+const outcomeUnknown = () => new MaiaClientError("outcome_unknown", "The bridged request outcome is unknown.");
+const protocolInvalid = (message) => new BridgeError({ message, reason: "protocol_invalid" });
+const acceptHello = (state, frame) => {
+    if (frame.type === "unavailable") {
+        return Deferred.fail(state.hello, new BridgeError({ message: frame.message, reason: "node_unavailable" }));
+    }
+    const status = frame.type === "ready"
+        ? localNodeStatusResultSchema.safeParse(frame.status)
+        : undefined;
+    return status?.success === true && frame.type === "ready"
+        ? Deferred.succeed(state.hello, {
+            status: status.data,
+            version: frame.version,
+        })
+        : Deferred.fail(state.hello, protocolInvalid("The bridge greeted without a valid node.status."));
+};
+const settle = (state, frame) => {
+    if (frame.type === "response") {
+        const deferred = state.pending.get(String(frame.envelope.correlationId));
+        return deferred === undefined
+            ? Effect.void
+            : Deferred.succeed(deferred, frame.envelope);
+    }
+    if (frame.type === "failure") {
+        const deferred = state.pending.get(frame.messageId);
+        return deferred === undefined
+            ? Effect.void
+            : Deferred.fail(deferred, clientError(frame));
+    }
+    return Effect.fail(protocolInvalid("The bridge greeted twice."));
+};
+const onLine = (state) => (line) => {
+    const frame = line._tag === "Line" ? decodeServerFrame(line.text) : undefined;
+    if (frame === undefined) {
+        return Effect.fail(protocolInvalid("The bridge sent an invalid frame."));
+    }
+    return Deferred.isDone(state.hello).pipe(Effect.flatMap((greeted) => greeted ? settle(state, frame) : acceptHello(state, frame)));
+};
+const close = (state) => Effect.suspend(() => {
+    state.closed = true;
+    const waiting = [...state.pending.values()];
+    state.pending.clear();
+    return Effect.all([
+        Deferred.fail(state.hello, new BridgeError({
+            message: "The bridge closed before it greeted.",
+            reason: "closed",
+        })),
+        ...waiting.map((deferred) => Deferred.fail(deferred, outcomeUnknown())),
+    ], { discard: true });
+});
+const readFrames = (state, handle) => handle.stdout.pipe(splitFrameLines(MAX_BRIDGE_FRAME_BYTES), Stream.runForEach((lines) => Effect.forEach(lines, onLine(state), { discard: true })), Effect.ignore, Effect.ensuring(close(state)));
+const admissionFailure = (state, messageId) => {
+    if (state.closed) {
+        return new MaiaClientError("transport_failure", "The Maia Node bridge is closed.");
+    }
+    if (state.pending.has(messageId)) {
+        return new MaiaClientError("invalid_request", "A bridged request with this message ID is already in flight.");
+    }
+    return state.pending.size >= MAX_BRIDGE_IN_FLIGHT
+        ? new MaiaClientError("saturated", "The Maia Node bridge reached its concurrency limit.")
+        : undefined;
+};
+const notSent = () => new MaiaClientError("transport_failure", "The Maia Node bridge closed before the request was sent.");
+const dispatch = (state, envelope) => Effect.gen(function* () {
+    const deferred = yield* Deferred.make();
+    state.pending.set(envelope.messageId, deferred);
+    const sent = yield* Queue.offer(state.outgoing, encodeFrame({ envelope: { ...envelope }, type: "request" }));
+    return sent
+        ? yield* Deferred.await(deferred)
+        : yield* Effect.fail(notSent());
+}).pipe(Effect.timeoutOrElse({
+    duration: REQUEST_DEADLINE,
+    orElse: () => Effect.fail(outcomeUnknown()),
+}), Effect.ensuring(Effect.sync(() => state.pending.delete(envelope.messageId))));
+const request = (state, envelope) => Effect.suspend(() => {
+    const refused = admissionFailure(state, envelope.messageId);
+    return refused === undefined
+        ? dispatch(state, envelope)
+        : Effect.fail(refused);
+});
+const startStreams = (state, handle) => Effect.all([
+    Effect.addFinalizer(() => Queue.end(state.outgoing)),
+    Stream.fromQueue(state.outgoing).pipe(Stream.encodeText, Stream.run(handle.stdin), Effect.ignore, Effect.ensuring(Queue.shutdown(state.outgoing)), Effect.forkScoped),
+    Effect.forkScoped(readFrames(state, handle)),
+], { discard: true });
+const awaitHello = (state, deadline) => Deferred.await(state.hello).pipe(Effect.timeoutOrElse({
+    duration: deadline,
+    orElse: () => Effect.fail(new BridgeError({
+        message: "The bridge did not greet in time.",
+        reason: "deadline_exceeded",
+    })),
+}));
+const transportFor = (state) => ({
+    request: (envelope, requestOptions) => Effect.runPromise(request(state, envelope), {
+        ...(requestOptions?.signal === undefined
+            ? {}
+            : { signal: requestOptions.signal }),
+    }),
+});
+export const openNodeBridge = (handle, options = {}) => Effect.gen(function* () {
+    const state = {
+        closed: false,
+        hello: yield* Deferred.make(),
+        outgoing: yield* Queue.bounded(MAX_BRIDGE_IN_FLIGHT * 2),
+        pending: new Map(),
+    };
+    yield* startStreams(state, handle);
+    const hello = yield* awaitHello(state, options.helloDeadline ?? DEFAULT_HELLO_DEADLINE);
+    const effectTransport = {
+        request: (envelope) => request(state, envelope),
+    };
+    return {
+        client: makeLocalNodeEffectClient(makeLocalNodeEffectRequester(effectTransport)),
+        closed: Effect.sync(() => state.closed),
+        hello,
+        transport: transportFor(state),
+    };
+});
+//# sourceMappingURL=bridge.js.map

package/dist/node/discovery.d.ts

@@ -0,0 +1,187 @@
+import { type InvocationContextShowResult, type LocalNodeStatusResult, type NodeApiConnectionDescriptor, type SessionInboxAckParameters, type SessionInboxAckResult, type SessionInboxCheckParameters, type SessionInboxCheckResult, type SessionMessageSendParameters, type SessionMessageSendResult } from "@maiaos/protocol";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type { LocalNodeEffectClient } from "../client/effect.js";
+import { MaiaClientError } from "../request/index.js";
+import type { NodeApiDiscoveryOptions } from "./local-node.js";
+type LocalNodeTransportErrorReason = "credential_invalid" | "deadline_exceeded" | "discovery_invalid" | "endpoint_invalid" | "outcome_unknown" | "saturated" | "transport_failed";
+declare const LocalNodeTransportError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LocalNodeTransportError";
+} & Readonly<A>;
+declare class LocalNodeTransportError extends LocalNodeTransportError_base<{
+    readonly message: string;
+    readonly reason: LocalNodeTransportErrorReason;
+}> {
+}
+export type DiscoveredNodeApiClient<TClient> = {
+    readonly client: TClient;
+    readonly status: (messageId: string) => Effect.Effect<LocalNodeStatusResult, unknown>;
+};
+export declare const newMessageId: (prefix: string) => Effect.Effect<string, never, Crypto.Crypto>;
+export declare const connectDiscoveredNodeApi: <TClient>(options: NodeApiDiscoveryOptions, open: (descriptor: NodeApiConnectionDescriptor, token: string) => DiscoveredNodeApiClient<TClient>) => Effect.Effect<{
+    client: TClient;
+    descriptor: {
+        readonly instanceId: string;
+        readonly pid: number;
+        readonly profile: string;
+        readonly startedAt: string;
+        readonly credentialPath: string;
+        readonly descriptorVersion: 1;
+        readonly endpoint: {
+            readonly observationPath: "/api/v1/observations";
+            readonly operationPath: "/api/v1/operations";
+            readonly origin: string;
+            readonly transport: "http-websocket";
+        };
+        readonly kind: "maia.node-api.connection";
+        readonly lifecycle: "ready";
+        readonly lifecycleOwner: "desktop";
+        readonly protocolVersion: "maia.protocol/v1alpha1";
+        readonly schemaVersion: "maia.node-api/v1";
+    };
+    status: {
+        readonly instanceId: string;
+        readonly lifecycle: "draining" | "failed" | "ready" | "starting" | "stopped";
+        readonly pid: number;
+        readonly profile: string;
+        readonly startedAt: string;
+        readonly method: "node.status";
+        readonly processResources: {
+            readonly activeTrees: number;
+            readonly admission: {
+                readonly availableTrees: number;
+                readonly capacity: number;
+                readonly queuedSpawns: 0;
+                readonly state: "available" | "degraded" | "pressured" | "saturated" | "unavailable";
+                readonly usedTrees: number;
+            };
+            readonly capability: {
+                readonly hardLimitEnforcement: "enforced";
+                readonly metricSampling: "host_sampled";
+                readonly mode: "hard_containment";
+                readonly observedPressureTermination: "disabled";
+                readonly releaseQualified: false;
+                readonly sourceCandidate: true;
+            } | {
+                readonly hardLimitEnforcement: "unavailable";
+                readonly metricSampling: "host_sampled";
+                readonly mode: "macos_cooperative";
+                readonly observedPressureTermination: "disabled";
+                readonly releaseQualified: false;
+                readonly sourceCandidate: true;
+            } | {
+                readonly hardLimitEnforcement: "unavailable";
+                readonly metricSampling: "unavailable";
+                readonly mode: "unavailable";
+                readonly observedPressureTermination: "disabled";
+                readonly releaseQualified: false;
+                readonly sourceCandidate: false;
+            };
+            readonly cleanupUnknownTrees: number;
+            readonly fencedTrees: number;
+            readonly nextStep: "close_idle_terminal" | "inspect_cleanup_unknown" | "inspect_observed_pressure" | "none" | "verify_native_host";
+            readonly observations: {
+                readonly cpuTimeMilliseconds: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly fileDescriptorCount: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly ioReadBytes: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly ioWriteBytes: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly observedPeakRssBytes: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly processCount: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly rssBytes: {
+                    readonly availableTrees: number;
+                    readonly budget: "declared_per_tree_limit" | "unavailable_not_declared";
+                    readonly maximumValue?: number | undefined;
+                    readonly state: "available" | "partial" | "unavailable";
+                    readonly unavailableTrees: number;
+                    readonly warningTrees: number;
+                };
+                readonly treeCount: number;
+            };
+            readonly pressure: "admission_degraded" | "cleanup_unknown" | "healthy" | "observed_pressure" | "warning";
+            readonly supervision: {
+                readonly trackedTrees: number;
+                readonly watcherFibers: number;
+            };
+        };
+        readonly storage: {
+            readonly integrity: "ok";
+            readonly journalMode: "wal";
+            readonly schemaTag: string;
+            readonly schemaVersion: number;
+        };
+    };
+}, LocalNodeTransportError, Crypto.Crypto>;
+export declare const discoveryFailure: (error: unknown) => MaiaClientError;
+export type DiscoveredNodeApiEffectConnection = {
+    readonly client: LocalNodeEffectClient;
+    readonly descriptor: NodeApiConnectionDescriptor;
+    readonly status: LocalNodeStatusResult;
+};
+export type NodeApiEffectDiscoveryOptions = Omit<NodeApiDiscoveryOptions, "signal">;
+export declare const connectNodeApiEffect: (options?: NodeApiEffectDiscoveryOptions) => Effect.Effect<DiscoveredNodeApiEffectConnection, MaiaClientError, Crypto.Crypto>;
+export declare const acquireAttachedCredential: () => Effect.Effect<Uint8Array, unknown>;
+export declare const attachedTransportOptions: <TCredential>(descriptor: NodeApiConnectionDescriptor, credential: Uint8Array, readToken: (read: Effect.Effect<string, unknown>) => TCredential) => {
+    credential: TCredential;
+    endpoint: {
+        readonly observationPath: "/api/v1/observations";
+        readonly operationPath: "/api/v1/operations";
+        readonly origin: string;
+        readonly transport: "http-websocket";
+    };
+    invocationAuthentication: {
+        credential: string;
+        scheme: "maia.invocation-attachment/v1";
+    };
+};
+export declare const requireAttachmentPlatform: () => Effect.Effect<void, MaiaClientError>;
+export type AttachedLocalNodeEffectOptions = NodeApiEffectDiscoveryOptions & {
+    readonly messageId?: string;
+};
+export declare const showAttachedCurrentContextEffect: (options?: AttachedLocalNodeEffectOptions) => Effect.Effect<InvocationContextShowResult, MaiaClientError, Crypto.Crypto>;
+export declare const sendAttachedSessionMessageEffect: (parameters: SessionMessageSendParameters, options?: AttachedLocalNodeEffectOptions) => Effect.Effect<SessionMessageSendResult, MaiaClientError, Crypto.Crypto>;
+export declare const checkAttachedSessionInboxEffect: (parameters: SessionInboxCheckParameters, options?: AttachedLocalNodeEffectOptions) => Effect.Effect<SessionInboxCheckResult, MaiaClientError, Crypto.Crypto>;
+export declare const acknowledgeAttachedSessionDeliveryEffect: (parameters: SessionInboxAckParameters, options?: AttachedLocalNodeEffectOptions) => Effect.Effect<SessionInboxAckResult, MaiaClientError, Crypto.Crypto>;
+export {};
+//# sourceMappingURL=discovery.d.ts.map