@masons/runtime-broker 0.1.0

package/dist/connector-client.js

@@ -0,0 +1,364 @@
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import createDebug from "debug";
+import WebSocket from "ws";
+import { setEnvironmentContext } from "./environment-context.js";
+import { CURRENT_PROTOCOL_VERSION, isAddressedMessage, isDeliveryPending, isDeliveryStatus, isRegisterAck, isSendAck, isStructuredError, REGISTER_ACK_TIMEOUT_MS, SEND_ACK_TIMEOUT_MS, } from "./types.js";
+import { PLUGIN_VERSION } from "./version.js";
+const dbg = createDebug("agent-network:connector");
+const dbgMsg = createDebug("agent-network:connector:msg");
+const BACKOFF_INITIAL_MS = 1_000;
+const BACKOFF_MAX_MS = 30_000;
+const ALREADY_CONNECTED_RETRY_MS = 2_000;
+const ALREADY_CONNECTED_MAX_RETRIES = 30;
+const REPLACED_BY_NEW_RUNTIME_REASON = "Replaced by new Runtime";
+const REPLACED_BY_NEW_RUNTIME_CODE = 4001;
+export class ConnectorError extends Error {
+    code;
+    to;
+    constructor(message, code, to) {
+        super(message);
+        this.name = "ConnectorError";
+        this.code = code;
+        this.to = to;
+    }
+}
+export class ConnectorClient extends EventEmitter {
+    url;
+    token;
+    ws = null;
+    intentionalClose = false;
+    backoffMs = BACKOFF_INITIAL_MS;
+    alreadyConnectedRetries = 0;
+    reconnectTimer = null;
+    registerResolve = null;
+    registerReject = null;
+    registerTimer = null;
+    lastKnownSeq;
+    pendingSends = new Map();
+    constructor(url, token) {
+        super();
+        this.url = url;
+        this.token = token;
+    }
+    connect() {
+        if (this.ws) {
+            return Promise.reject(new Error("Already connecting or connected"));
+        }
+        dbg("connecting to %s", this.url);
+        this.intentionalClose = false;
+        return this.doConnect();
+    }
+    disconnect() {
+        dbg("intentional disconnect");
+        this.intentionalClose = true;
+        this.clearReconnectTimer();
+        const wsToClose = this.ws;
+        this.cleanupConnection();
+        if (wsToClose &&
+            (wsToClose.readyState === WebSocket.OPEN ||
+                wsToClose.readyState === WebSocket.CONNECTING)) {
+            wsToClose.close(1000, "Client disconnect");
+        }
+    }
+    send(to, content, contentType = "text", metadata) {
+        const messageId = randomUUID();
+        const event = {
+            event: "SEND_MESSAGE",
+            messageId,
+            to,
+            content,
+            contentType,
+            metadata,
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingSends.delete(messageId);
+                reject(new Error("SEND_ACK timeout"));
+            }, SEND_ACK_TIMEOUT_MS);
+            this.pendingSends.set(messageId, { resolve, reject, timer });
+            const sent = this.sendEvent(event);
+            if (!sent) {
+                clearTimeout(timer);
+                this.pendingSends.delete(messageId);
+                reject(new Error("WebSocket not connected"));
+            }
+        });
+    }
+    sendTyping(to, isTyping) {
+        const event = { event: "TYPING", to, isTyping };
+        const sent = this.sendEvent(event);
+        dbg("sendTyping to=%s isTyping=%s sent=%s", to, isTyping, sent);
+        return sent;
+    }
+    ackDelivery(upTo) {
+        const event = { event: "DELIVERY_ACK", upTo };
+        const sent = this.sendEvent(event);
+        dbg("ackDelivery upTo=%s sent=%s", upTo, sent);
+        return sent;
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    doConnect() {
+        return new Promise((resolve, reject) => {
+            this.registerResolve = resolve;
+            this.registerReject = reject;
+            const ws = new WebSocket(this.url, { handshakeTimeout: 10_000 });
+            this.ws = ws;
+            ws.on("open", () => {
+                this.sendRegister();
+                this.startRegisterTimeout();
+            });
+            ws.on("message", this.handleMessage);
+            ws.on("close", this.handleClose);
+            ws.on("error", this.handleError);
+        });
+    }
+    sendRegister() {
+        const event = {
+            event: "REGISTER",
+            token: this.token,
+            protocolVersion: CURRENT_PROTOCOL_VERSION,
+            clientVersion: PLUGIN_VERSION,
+            ...(this.lastKnownSeq !== undefined
+                ? { lastKnownSeq: this.lastKnownSeq }
+                : {}),
+        };
+        dbg("REGISTER lastKnownSeq=%s", this.lastKnownSeq ?? "none");
+        this.sendEvent(event);
+    }
+    startRegisterTimeout() {
+        this.registerTimer = setTimeout(() => {
+            this.rejectRegister(new Error("REGISTER_ACK timeout"));
+            this.ws?.close(4000, "Register timeout");
+        }, REGISTER_ACK_TIMEOUT_MS);
+    }
+    resolveRegister() {
+        if (this.registerTimer) {
+            clearTimeout(this.registerTimer);
+            this.registerTimer = null;
+        }
+        if (this.registerResolve) {
+            this.registerResolve();
+            this.registerResolve = null;
+            this.registerReject = null;
+        }
+    }
+    rejectRegister(err) {
+        if (this.registerTimer) {
+            clearTimeout(this.registerTimer);
+            this.registerTimer = null;
+        }
+        if (this.registerReject) {
+            this.registerReject(err);
+            this.registerResolve = null;
+            this.registerReject = null;
+        }
+    }
+    handleMessage = (data) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(data.toString());
+        }
+        catch {
+            this.emit("error", new Error("Received non-JSON message from Connector"));
+            return;
+        }
+        if (isRegisterAck(parsed)) {
+            this.handleRegisterAck(parsed);
+            return;
+        }
+        this.dispatchAddressed(parsed);
+    };
+    dispatchAddressed(parsed) {
+        if (isSendAck(parsed)) {
+            dbg("SEND_ACK messageId=%s status=%s", parsed.messageId, parsed.status);
+            this.handleSendAck(parsed);
+            return;
+        }
+        if (isAddressedMessage(parsed)) {
+            dbgMsg("MESSAGE_RECEIVED from=%s contentLength=%d seq=%s", parsed.from, parsed.content.length, parsed.seq ?? "none");
+            if (typeof parsed.seq === "number" &&
+                (this.lastKnownSeq === undefined || parsed.seq > this.lastKnownSeq)) {
+                this.lastKnownSeq = parsed.seq;
+            }
+            this.emit("message_received", parsed);
+            return;
+        }
+        if (isDeliveryPending(parsed)) {
+            dbg("DELIVERY_PENDING count=%d upTo=%s", parsed.count, parsed.upTo);
+            this.emit("delivery_pending", parsed);
+            return;
+        }
+        if (isDeliveryStatus(parsed)) {
+            dbg("DELIVERY_STATUS messageId=%s status=%s", parsed.messageId, parsed.status);
+            this.emit("delivery_status", parsed);
+            return;
+        }
+        if (isStructuredError(parsed)) {
+            dbg("ERROR code=%s message=%s", parsed.code, parsed.message);
+            this.handleStructuredError(parsed);
+            return;
+        }
+    }
+    handleRegisterAck(ack) {
+        dbg("REGISTER_ACK status=%s protocolVersion=%d", ack.status, ack.protocolVersion);
+        if (ack.status === "ok") {
+            if (ack.protocolVersion !== CURRENT_PROTOCOL_VERSION) {
+                dbg("WARN: server negotiated protocolVersion=%d, expected=%d", ack.protocolVersion, CURRENT_PROTOCOL_VERSION);
+            }
+            setEnvironmentContext(ack.agent, ack.owner);
+            if (typeof ack.deliverySeq === "number" &&
+                this.lastKnownSeq === undefined) {
+                this.lastKnownSeq = ack.deliverySeq;
+                dbg("delivery cursor initialized: %d", ack.deliverySeq);
+            }
+            this.backoffMs = BACKOFF_INITIAL_MS;
+            this.alreadyConnectedRetries = 0;
+            this.resolveRegister();
+            this.emit("connected");
+        }
+        else {
+            const reason = ack.reason ?? "Unknown registration error";
+            if (reason === "Unsupported protocol version") {
+                this.intentionalClose = true;
+                this.rejectRegister(new Error(reason));
+                this.emit("error", new Error(reason));
+                this.ws?.close(4001, reason);
+                return;
+            }
+            if (reason === "Already connected") {
+                this.alreadyConnectedRetries++;
+            }
+            this.rejectRegister(new Error(reason));
+            this.ws?.close(4001, reason);
+        }
+    }
+    handleSendAck(ack) {
+        this.emit("send_ack", ack);
+        const pending = this.pendingSends.get(ack.messageId);
+        if (pending) {
+            clearTimeout(pending.timer);
+            this.pendingSends.delete(ack.messageId);
+            pending.resolve(ack);
+        }
+    }
+    handleStructuredError(event) {
+        this.emit("structured_error", event);
+        if (event.messageId) {
+            const pending = this.pendingSends.get(event.messageId);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingSends.delete(event.messageId);
+                pending.reject(new ConnectorError(event.message, event.code, event.to));
+                return;
+            }
+        }
+        this.emit("error", new Error(`[${event.code}] ${event.message}`));
+    }
+    handleClose = (code, reason) => {
+        const reasonStr = reason
+            ? typeof reason === "string"
+                ? reason
+                : reason.toString()
+            : "";
+        dbg("connection closed code=%s reason=%s intentional=%s", code ?? "?", reasonStr, this.intentionalClose);
+        const wasRegistering = this.registerReject !== null;
+        this.cleanupConnection();
+        const replacedByNewRuntime = code === REPLACED_BY_NEW_RUNTIME_CODE &&
+            reasonStr === REPLACED_BY_NEW_RUNTIME_REASON;
+        if (replacedByNewRuntime) {
+            this.intentionalClose = true;
+            const msg = "This agent was claimed by another Runtime " +
+                "(this Runtime disconnected). " +
+                "Re-run `openclaw channels login --channel agent-network` " +
+                "to drive this agent from here again.";
+            this.emit("error", new Error(msg));
+            if (wasRegistering) {
+                this.rejectRegister(new Error(msg));
+            }
+            this.emit("disconnected");
+            return;
+        }
+        if (wasRegistering) {
+            if (this.registerReject) {
+                this.rejectRegister(new Error("Connection closed during registration"));
+            }
+        }
+        this.emit("disconnected");
+        if (!this.intentionalClose) {
+            this.scheduleReconnect();
+        }
+    };
+    handleError = (err) => {
+        dbg("websocket error: %s", err.message);
+        this.emit("error", err);
+    };
+    scheduleReconnect() {
+        this.clearReconnectTimer();
+        const delay = this.calculateBackoff();
+        dbg("reconnecting in %dms", Math.round(delay));
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.doConnect().catch(() => {
+            });
+        }, delay);
+    }
+    calculateBackoff() {
+        if (this.alreadyConnectedRetries > 0) {
+            if (this.alreadyConnectedRetries >= ALREADY_CONNECTED_MAX_RETRIES) {
+                this.alreadyConnectedRetries = 0;
+                return this.nextExponentialBackoff();
+            }
+            return ALREADY_CONNECTED_RETRY_MS;
+        }
+        return this.nextExponentialBackoff();
+    }
+    nextExponentialBackoff() {
+        const jitter = 1 + Math.random() * 0.3;
+        const delay = Math.min(this.backoffMs * jitter, BACKOFF_MAX_MS);
+        this.backoffMs = Math.min(this.backoffMs * 2, BACKOFF_MAX_MS);
+        return delay;
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    cleanupConnection() {
+        if (this.ws) {
+            this.ws.off("message", this.handleMessage);
+            this.ws.off("close", this.handleClose);
+            this.ws.off("error", this.handleError);
+            this.ws = null;
+        }
+        if (this.registerTimer) {
+            clearTimeout(this.registerTimer);
+            this.registerTimer = null;
+        }
+        for (const [, pending] of this.pendingSends) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Connection closed"));
+        }
+        this.pendingSends.clear();
+    }
+    sendEvent(event) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(event));
+            return true;
+        }
+        dbg("send failed: ws not open event=%s", event.event);
+        return false;
+    }
+}

package/dist/environment-context.d.ts

@@ -0,0 +1,21 @@
+export interface AgentIdentity {
+    handle: string;
+    name?: string;
+}
+export interface OwnerIdentity {
+    handle: string;
+    displayName?: string;
+}
+export declare function setEnvironmentContext(agent?: {
+    handle: string;
+    name?: string;
+}, owner?: {
+    handle: string;
+    displayName?: string;
+}): void;
+export declare function getAgentIdentity(): AgentIdentity | null;
+export declare function getOwnerIdentity(): OwnerIdentity | null;
+export declare function getOwnerHandle(): string | null;
+export declare function clearEnvironmentContext(): void;
+export declare function _resetForTesting(): void;
+//# sourceMappingURL=environment-context.d.ts.map

package/dist/environment-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment-context.d.ts","sourceRoot":"","sources":["../src/environment-context.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAmBD,wBAAgB,qBAAqB,CACnC,KAAK,CAAC,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EACzC,KAAK,CAAC,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/C,IAAI,CAkBN;AAMD,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,IAAI,CAEvD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,IAAI,CAEvD;AAGD,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAE9C;AAOD,wBAAgB,uBAAuB,IAAI,IAAI,CAG9C;AAOD,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC"}

package/dist/environment-context.js

@@ -0,0 +1,39 @@
+let agentIdentity = null;
+let ownerIdentity = null;
+export function setEnvironmentContext(agent, owner) {
+    if (agent && typeof agent.handle === "string") {
+        const identity = { handle: agent.handle };
+        if (agent.name)
+            identity.name = agent.name;
+        agentIdentity = identity;
+    }
+    else {
+        agentIdentity = null;
+    }
+    if (owner && typeof owner.handle === "string") {
+        const identity = { handle: owner.handle };
+        if (owner.displayName)
+            identity.displayName = owner.displayName;
+        ownerIdentity = identity;
+    }
+    else {
+        ownerIdentity = null;
+    }
+}
+export function getAgentIdentity() {
+    return agentIdentity;
+}
+export function getOwnerIdentity() {
+    return ownerIdentity;
+}
+export function getOwnerHandle() {
+    return ownerIdentity?.handle ?? null;
+}
+export function clearEnvironmentContext() {
+    agentIdentity = null;
+    ownerIdentity = null;
+}
+export function _resetForTesting() {
+    agentIdentity = null;
+    ownerIdentity = null;
+}

package/dist/platform-client.d.ts

@@ -0,0 +1,84 @@
+export declare const DEFAULT_API_HOST = "preview-api.masons.ai";
+export declare const DEFAULT_CONNECTOR_URL = "wss://preview-connectorapi.masons.ai/gateway";
+export interface PlatformClientConfig {
+    apiHost: string;
+}
+export declare class PlatformApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export interface RequestConnectionResponse {
+    requestIds: string[];
+    status: string;
+}
+export interface ConnectionNodeRef {
+    kind: string;
+    mstpAddress: string;
+    handle?: string;
+    displayName?: string;
+    avatarUrl?: string;
+}
+export interface ListRequestsItem {
+    id: string;
+    direction: "incoming" | "outgoing";
+    fromNode?: ConnectionNodeRef | null;
+    toNode?: ConnectionNodeRef | null;
+    variant: string;
+    status: string;
+    matchmaking: {
+        title: string | null;
+        benefit: string | null;
+        scenario: string | null;
+    };
+    createdAt: string;
+}
+export interface ListRequestsResponse {
+    total: number;
+    items: ListRequestsItem[];
+}
+export interface AcceptRequestResponse {
+    status: "accepted";
+    counterparty: ConnectionNodeRef | null;
+}
+export interface DeclineRequestResponse {
+    status: "declined";
+}
+export interface UpdateProfileParams {
+    name?: string;
+    scope?: string;
+    about?: string;
+    audience?: string;
+}
+export interface UpdateProfileResponse {
+    status: "updated";
+    profile?: {
+        name: string;
+        scope: string;
+        about: string;
+        audience: string;
+    };
+}
+export interface ListConnectionsResponse {
+    total: number;
+    connections: Array<{
+        counterparty: ConnectionNodeRef;
+        access: "mutual" | "outbound" | "inbound" | string;
+        createdAt: string | null;
+    }>;
+}
+export declare function requestConnection(cfg: PlatformClientConfig, runtimeKey: string, params: {
+    targetHandle: string;
+    variants: ("distribute" | "receive")[];
+}): Promise<RequestConnectionResponse>;
+export declare function listRequests(cfg: PlatformClientConfig, runtimeKey: string, params?: {
+    status?: string;
+    direction?: string;
+    page?: number;
+    limit?: number;
+}): Promise<ListRequestsResponse>;
+export declare function acceptRequest(cfg: PlatformClientConfig, runtimeKey: string, requestId: string): Promise<AcceptRequestResponse>;
+export declare function declineRequest(cfg: PlatformClientConfig, runtimeKey: string, requestId: string): Promise<DeclineRequestResponse>;
+export declare function updateProfile(cfg: PlatformClientConfig, runtimeKey: string, params: UpdateProfileParams): Promise<UpdateProfileResponse>;
+export declare function listConnections(cfg: PlatformClientConfig, runtimeKey: string): Promise<ListConnectionsResponse>;
+//# sourceMappingURL=platform-client.d.ts.map

package/dist/platform-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-client.d.ts","sourceRoot":"","sources":["../src/platform-client.ts"],"names":[],"mappings":"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"}

package/dist/platform-client.js

@@ -0,0 +1,94 @@
+export const DEFAULT_API_HOST = "preview-api.masons.ai";
+export const DEFAULT_CONNECTOR_URL = "wss://preview-connectorapi.masons.ai/gateway";
+export class PlatformApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "PlatformApiError";
+    }
+}
+function baseUrl(cfg) {
+    const trimmed = cfg.apiHost.replace(/\/+$/, "");
+    const origin = /^https?:\/\//.test(trimmed) ? trimmed : `https://${trimmed}`;
+    return `${origin}/v1`;
+}
+async function handleError(res) {
+    const body = (await res.json().catch(() => ({})));
+    const code = typeof body.error === "string" ? body.error : "unknown";
+    const message = typeof body.message === "string" ? body.message : res.statusText;
+    throw new PlatformApiError(res.status, code, message);
+}
+export async function requestConnection(cfg, runtimeKey, params) {
+    const res = await fetch(`${baseUrl(cfg)}/me/connections/requests`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${runtimeKey}`,
+        },
+        body: JSON.stringify(params),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return (await res.json());
+}
+export async function listRequests(cfg, runtimeKey, params) {
+    const query = new URLSearchParams();
+    if (params?.status != null)
+        query.set("status", params.status);
+    if (params?.direction != null)
+        query.set("direction", params.direction);
+    if (params?.page != null)
+        query.set("page", String(params.page));
+    if (params?.limit != null)
+        query.set("limit", String(params.limit));
+    const qs = query.toString();
+    const url = `${baseUrl(cfg)}/me/connections/requests${qs ? `?${qs}` : ""}`;
+    const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${runtimeKey}` },
+    });
+    if (!res.ok)
+        return handleError(res);
+    return (await res.json());
+}
+export async function acceptRequest(cfg, runtimeKey, requestId) {
+    const res = await fetch(`${baseUrl(cfg)}/me/connections/requests/${encodeURIComponent(requestId)}/accept`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${runtimeKey}` },
+    });
+    if (!res.ok)
+        return handleError(res);
+    return (await res.json());
+}
+export async function declineRequest(cfg, runtimeKey, requestId) {
+    const res = await fetch(`${baseUrl(cfg)}/me/connections/requests/${encodeURIComponent(requestId)}/decline`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${runtimeKey}` },
+    });
+    if (!res.ok)
+        return handleError(res);
+    return (await res.json());
+}
+export async function updateProfile(cfg, runtimeKey, params) {
+    const res = await fetch(`${baseUrl(cfg)}/me/profile`, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${runtimeKey}`,
+        },
+        body: JSON.stringify(params),
+    });
+    if (!res.ok)
+        return handleError(res);
+    return (await res.json());
+}
+export async function listConnections(cfg, runtimeKey) {
+    const res = await fetch(`${baseUrl(cfg)}/me/connections`, {
+        headers: { Authorization: `Bearer ${runtimeKey}` },
+    });
+    if (!res.ok)
+        return handleError(res);
+    return (await res.json());
+}

package/dist/runtime-endpoint-client.d.ts

@@ -0,0 +1,74 @@
+import { PlatformApiError, type PlatformClientConfig } from "./platform-client.js";
+export { PlatformApiError, type PlatformClientConfig };
+export type RuntimeKind = "claude-code" | "openclaw" | "codex" | "passport" | "custom" | (string & {});
+export interface WorkspaceMetadata {
+    root: string;
+    cwd: string;
+    remote?: string;
+    branch?: string;
+}
+export type ShareWithPeerField = "workspace" | "tracking_ref" | "runtime_session_id" | "fingerprint" | (string & {});
+export interface RegisterRuntimeEndpointParams {
+    as?: string;
+    runtime_kind: RuntimeKind;
+    runtime_session_id?: string;
+    endpoint_nonce: string;
+    display_label: string;
+    workspace?: WorkspaceMetadata;
+    tracking_ref?: string;
+    share_with_peer?: ShareWithPeerField[];
+}
+export interface RegisterRuntimeEndpointResponse {
+    endpoint_id: string;
+    node_id: string;
+    display_label: string;
+    heartbeat_after_seconds: number;
+    lease_ttl_seconds: number;
+    soft_retention_seconds: number;
+    registered_at: string;
+}
+export interface OwnedRuntimeEndpointView {
+    endpoint_id: string;
+    node_id: string;
+    node_handle?: string;
+    runtime_kind: RuntimeKind;
+    runtime_session_id?: string;
+    display_label: string;
+    workspace?: WorkspaceMetadata;
+    tracking_ref?: string;
+    fingerprint?: {
+        workspace_hash_per_peer?: Record<string, string>;
+    };
+    registered_at: string;
+    retired_at?: string;
+    is_self: boolean;
+}
+export interface ListOwnedRuntimeEndpointsResponse {
+    total: number;
+    items: OwnedRuntimeEndpointView[];
+}
+export type HeartbeatRuntimeEndpointResponse = Record<string, unknown>;
+export type UnregisterRuntimeEndpointResponse = Record<string, unknown>;
+export interface TransitionRuntimeEndpointStateParams {
+    state: "active" | "reconnecting" | "closed";
+    reason: string;
+    ts: string;
+}
+export type TransitionRuntimeEndpointStateResponse = Record<string, unknown>;
+export declare function registerRuntimeEndpoint(cfg: PlatformClientConfig, runtimeKey: string, params: RegisterRuntimeEndpointParams): Promise<RegisterRuntimeEndpointResponse>;
+export declare function heartbeatRuntimeEndpoint(cfg: PlatformClientConfig, runtimeKey: string, endpointId: string): Promise<HeartbeatRuntimeEndpointResponse>;
+export declare function transitionRuntimeEndpointState(cfg: PlatformClientConfig, runtimeKey: string, endpointId: string, params: TransitionRuntimeEndpointStateParams): Promise<TransitionRuntimeEndpointStateResponse>;
+export declare function unregisterRuntimeEndpoint(cfg: PlatformClientConfig, runtimeKey: string, endpointId: string, asNodeId?: string): Promise<UnregisterRuntimeEndpointResponse>;
+export declare function listOwnedRuntimeEndpoints(cfg: PlatformClientConfig, runtimeKey: string, asNodeId: string): Promise<ListOwnedRuntimeEndpointsResponse>;
+export declare function getOwnedRuntimeEndpoint(cfg: PlatformClientConfig, runtimeKey: string, endpointId: string, asNodeId: string): Promise<OwnedRuntimeEndpointView>;
+export declare function emitRuntimeUndispatchedChanged(cfg: PlatformClientConfig, runtimeKey: string, event: Readonly<Record<string, unknown>>): Promise<EmitUndispatchedChangedOutcome>;
+export type EmitUndispatchedChangedOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    terminal: boolean;
+    status?: number;
+    detail?: string;
+};
+export declare function emitRuntimeNetworkPresenceChanged(cfg: PlatformClientConfig, runtimeKey: string, event: Readonly<Record<string, unknown>>): Promise<EmitUndispatchedChangedOutcome>;
+//# sourceMappingURL=runtime-endpoint-client.d.ts.map