@miao-ai/client 0.1.0

package/dist/client.js

@@ -0,0 +1,664 @@
+import { RUNTIME_PROTOCOL_VERSION, } from "@miao-ai/protocol";
+import { BoundedAsyncQueue } from "./async-queue.js";
+import { BackpressureError, HostCapabilityError, HostCapabilityTimeoutError, MiaoError, ProtocolError, ProtocolVersionError, RequestCancelledError, RequestTimeoutError, TransportError, UnsupportedOperationError, asTransportError, errorFromRuntime, } from "./errors.js";
+import { validateSchema, } from "./host-capability.js";
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_PENDING_REQUESTS = 256;
+const DEFAULT_EVENT_BUFFER_SIZE = 256;
+const DEFAULT_MAX_HOST_CALLS = 32;
+const DEFAULT_REMEMBERED_HOST_CALLS = 1_024;
+export class MiaoClient {
+    transport;
+    runtime;
+    apps;
+    agents;
+    runs;
+    approvals;
+    capabilities;
+    state;
+    memory;
+    artifacts;
+    scheduler;
+    skills;
+    mcp;
+    plugins;
+    bindings;
+    messages;
+    delegations;
+    #descriptor;
+    #state = "disconnected";
+    #generation = 0;
+    #requestCounter = 0;
+    #pending = new Map();
+    #subscriptions = new Map();
+    #orphanEvents = new Map();
+    #capabilities = new Map();
+    #hostResults = new Map();
+    #activeHostCalls = new Map();
+    #defaultTimeoutMs;
+    #maxPendingRequests;
+    #eventBufferSize;
+    #maxConcurrentHostCalls;
+    #maxRememberedHostCalls;
+    #restoreCapabilities;
+    #schemaValidator;
+    #autoDescribe;
+    constructor(options) {
+        this.transport = options.transport;
+        this.#defaultTimeoutMs = positive(options.defaultTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS, "defaultTimeoutMs");
+        this.#maxPendingRequests = positive(options.maxPendingRequests, DEFAULT_MAX_PENDING_REQUESTS, "maxPendingRequests");
+        this.#eventBufferSize = positive(options.eventBufferSize, DEFAULT_EVENT_BUFFER_SIZE, "eventBufferSize");
+        this.#maxConcurrentHostCalls = positive(options.maxConcurrentHostCalls, DEFAULT_MAX_HOST_CALLS, "maxConcurrentHostCalls");
+        this.#maxRememberedHostCalls = positive(options.maxRememberedHostCalls, DEFAULT_REMEMBERED_HOST_CALLS, "maxRememberedHostCalls");
+        this.#restoreCapabilities = options.restoreCapabilities ?? false;
+        this.#schemaValidator = options.schemaValidator;
+        this.#autoDescribe = options.autoDescribe ?? true;
+        this.runtime = { describe: (requestOptions) => this.describe(requestOptions) };
+        this.apps = {
+            register: (manifest, requestOptions) => this.request("apps.register", { manifest }, requestOptions),
+            list: (requestOptions) => this.request("apps.list", {}, requestOptions),
+        };
+        this.agents = {
+            list: (appId, requestOptions) => this.request("agents.list", { appId }, requestOptions),
+            launch: (input, requestOptions) => this.request("agents.launch", input, requestOptions),
+        };
+        this.runs = {
+            start: (input, requestOptions) => this.request("runs.start", input, requestOptions),
+            get: (runId, requestOptions) => this.request("runs.get", { runId }, requestOptions),
+            pause: (runId, requestOptions) => this.request("runs.pause", { runId }, requestOptions),
+            resume: (runId, requestOptions) => this.request("runs.resume", { runId }, requestOptions),
+            cancel: (runId, requestOptions) => this.request("runs.cancel", { runId }, requestOptions),
+            signal: (runId, name, payload = null, requestOptions) => this.request("runs.signal", { runId, name, payload }, requestOptions),
+            events: (runId, eventOptions) => this.#events(runId, eventOptions),
+            subscribe: (runId, listener, eventOptions) => this.#subscribe(runId, listener, eventOptions),
+        };
+        this.approvals = {
+            list: (requestOptions) => this.request("approvals.list", {}, requestOptions),
+            decide: (toolCallId, decision, reason, requestOptions) => this.request("approvals.decide", { toolCallId, decision, ...(reason === undefined ? {} : { reason }) }, requestOptions),
+            approve: (toolCallId, requestOptions) => this.request("approvals.decide", { toolCallId, decision: "approved" }, requestOptions),
+            deny: (toolCallId, input, requestOptions) => this.request("approvals.decide", { toolCallId, decision: "denied", ...input }, requestOptions),
+            cancel: (toolCallId, input, requestOptions) => this.request("approvals.decide", { toolCallId, decision: "cancelled", ...input }, requestOptions),
+        };
+        this.capabilities = {
+            register: (definition, requestOptions) => this.#registerCapability(definition, requestOptions),
+            renew: (address, leaseMs, requestOptions) => this.#renewCapability(address, leaseMs, requestOptions),
+            unregister: (address, requestOptions) => this.#unregisterCapability(address, requestOptions),
+        };
+        this.state = {
+            get: (appId, key, requestOptions) => this.request("state.get", { appId, key }, requestOptions),
+            put: (appId, key, value, expectedVersion, requestOptions) => this.request("state.put", { appId, key, value, ...(expectedVersion === undefined ? {} : { expectedVersion }) }, requestOptions),
+        };
+        this.memory = {
+            list: (appId, query, requestOptions) => this.request("memory.list", { appId, ...(query === undefined ? {} : { query }) }, requestOptions),
+            remember: (appId, memory, requestOptions) => this.request("memory.remember", { appId, memory }, requestOptions),
+            forget: (appId, memoryId, requestOptions) => this.request("memory.forget", { appId, memoryId }, requestOptions),
+        };
+        this.artifacts = {
+            list: (appId, runId, requestOptions) => this.request("artifacts.list", { appId, runId }, requestOptions),
+            get: (appId, artifactId, requestOptions) => this.request("artifacts.get", { appId, artifactId }, requestOptions),
+        };
+        this.scheduler = {
+            list: (status, requestOptions) => this.request("scheduler.list", status === undefined ? {} : { status }, requestOptions),
+            create: (input, requestOptions) => this.request("scheduler.create", input, requestOptions),
+            pause: (jobId, requestOptions) => this.request("scheduler.pause", { jobId }, requestOptions),
+            resume: (jobId, requestOptions) => this.request("scheduler.resume", { jobId }, requestOptions),
+            delete: (jobId, requestOptions) => this.request("scheduler.delete", { jobId }, requestOptions),
+            history: (jobId, requestOptions) => this.request("scheduler.history", jobId === undefined ? {} : { jobId }, requestOptions),
+        };
+        this.skills = {
+            list: (requestOptions) => this.request("skills.list", {}, requestOptions),
+            reload: (requestOptions) => this.request("skills.reload", {}, requestOptions),
+        };
+        this.mcp = {
+            list: (requestOptions) => this.request("mcp.list", {}, requestOptions),
+            reload: (requestOptions) => this.request("mcp.reload", {}, requestOptions),
+        };
+        this.plugins = {
+            list: (requestOptions) => this.request("plugins.list", {}, requestOptions),
+            install: (source, requestOptions) => this.request("plugins.install", { source }, requestOptions),
+            setEnabled: (pluginId, enabled, requestOptions) => this.request("plugins.set_enabled", { pluginId, enabled }, requestOptions),
+            enable: (pluginId, requestOptions) => this.request("plugins.set_enabled", { pluginId, enabled: true }, requestOptions),
+            disable: (pluginId, requestOptions) => this.request("plugins.set_enabled", { pluginId, enabled: false }, requestOptions),
+        };
+        this.bindings = {
+            list: (appId, requestOptions) => this.request("bindings.list", { appId }, requestOptions),
+            create: (input, requestOptions) => this.request("bindings.create", input, requestOptions),
+        };
+        this.messages = { deliver: (message, requestOptions) => this.request("messages.deliver", message, requestOptions) };
+        this.delegations = { create: (delegation, requestOptions) => this.request("delegations.create", delegation, requestOptions) };
+    }
+    get descriptor() {
+        return this.#descriptor;
+    }
+    get connected() {
+        return this.#state === "connected";
+    }
+    async connect() {
+        if (this.#state === "connected")
+            return this;
+        if (this.#state !== "disconnected")
+            throw new TransportError(`cannot connect while client is ${this.#state}`);
+        this.#state = "connecting";
+        const generation = ++this.#generation;
+        try {
+            await this.transport.connect();
+            this.#state = "connected";
+            void this.#consumeFrames(generation);
+            if (this.#autoDescribe)
+                await this.describe();
+            if (this.#restoreCapabilities)
+                await this.#restoreCapabilityRegistrations();
+            return this;
+        }
+        catch (error) {
+            const transportError = error instanceof MiaoError ? error : asTransportError(error, "failed to connect to Miao Runtime");
+            await this.#finishDisconnect(transportError, generation);
+            throw transportError;
+        }
+    }
+    async ready() {
+        if (this.#state !== "connected")
+            await this.connect();
+        return this;
+    }
+    async close() {
+        if (this.#state === "disconnected")
+            return;
+        this.#state = "closing";
+        const generation = this.#generation;
+        let closeError;
+        try {
+            await this.transport.close();
+        }
+        catch (error) {
+            closeError = error;
+        }
+        await this.#finishDisconnect(closeError === undefined
+            ? new TransportError("Miao Runtime transport closed", { code: "transport_closed", retryable: true })
+            : asTransportError(closeError, "failed to close Miao Runtime transport"), generation);
+        if (closeError !== undefined)
+            throw asTransportError(closeError, "failed to close Miao Runtime transport");
+    }
+    async describe(options) {
+        const descriptor = await this.request("runtime.describe", {}, options);
+        if (descriptor.protocolVersion !== RUNTIME_PROTOCOL_VERSION) {
+            throw new ProtocolVersionError(`Runtime uses ${descriptor.protocolVersion}; client requires ${RUNTIME_PROTOCOL_VERSION}`, { code: "protocol_version", details: { expected: RUNTIME_PROTOCOL_VERSION, actual: descriptor.protocolVersion } });
+        }
+        this.#descriptor = descriptor;
+        return descriptor;
+    }
+    supports(operation) {
+        return this.#descriptor?.operations.includes(operation) ?? false;
+    }
+    hasFeature(feature) {
+        return this.#descriptor?.features.some((candidate) => candidate === feature) ?? false;
+    }
+    require(requirements) {
+        if (this.#descriptor === undefined) {
+            throw new ProtocolError("Runtime capabilities have not been negotiated", { code: "descriptor_unavailable" });
+        }
+        const missingOperations = (requirements.operations ?? []).filter((operation) => !this.supports(operation));
+        const missingFeatures = (requirements.features ?? []).filter((feature) => !this.hasFeature(feature));
+        if (missingOperations.length > 0 || missingFeatures.length > 0) {
+            throw new UnsupportedOperationError("Runtime does not satisfy required capabilities", {
+                code: "unsupported_capability",
+                details: { missingOperations, missingFeatures },
+            });
+        }
+    }
+    async request(operation, payload = {}, options = {}) {
+        if (this.#state !== "connected") {
+            throw new TransportError("Miao Runtime transport is not connected", { code: "transport_disconnected", retryable: true });
+        }
+        if (this.#pending.size >= this.#maxPendingRequests) {
+            throw new BackpressureError(`client has reached ${this.#maxPendingRequests} pending requests`, {
+                code: "request_backpressure", retryable: true, details: { limit: this.#maxPendingRequests },
+            });
+        }
+        if (options.signal?.aborted === true) {
+            throw new RequestCancelledError("Miao Runtime request was cancelled before send", {
+                code: "request_cancelled", cause: options.signal.reason,
+            });
+        }
+        const requestId = this.#nextRequestId();
+        const timeoutMs = positive(options.timeoutMs, this.#defaultTimeoutMs, "timeoutMs");
+        let timer;
+        let abortListener;
+        const promise = new Promise((resolve, reject) => {
+            const cleanup = () => {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                if (abortListener !== undefined)
+                    options.signal?.removeEventListener("abort", abortListener);
+            };
+            this.#pending.set(requestId, {
+                resolve: (value) => resolve(value),
+                reject,
+                cleanup,
+            });
+            const fail = (error, reason) => {
+                const pending = this.#pending.get(requestId);
+                if (pending === undefined)
+                    return;
+                this.#pending.delete(requestId);
+                pending.cleanup();
+                pending.reject(error);
+                void this.#sendBestEffort({
+                    type: "cancel", protocol: RUNTIME_PROTOCOL_VERSION,
+                    target: { kind: "request", requestId }, reason,
+                });
+            };
+            timer = setTimeout(() => fail(new RequestTimeoutError(`Miao Runtime request ${requestId} timed out after ${timeoutMs}ms`, {
+                code: "request_timeout", retryable: true, requestId, details: { operation, timeoutMs },
+            }), "client request timeout"), timeoutMs);
+            abortListener = () => fail(new RequestCancelledError(`Miao Runtime request ${requestId} was cancelled`, {
+                code: "request_cancelled", requestId, cause: options.signal?.reason,
+            }), "client request cancelled");
+            options.signal?.addEventListener("abort", abortListener, { once: true });
+        });
+        const frame = {
+            type: "request", protocol: RUNTIME_PROTOCOL_VERSION, requestId, operation, payload,
+        };
+        try {
+            await this.transport.send(frame);
+        }
+        catch (error) {
+            const transportError = asTransportError(error, `failed to send ${operation}`);
+            await this.#finishDisconnect(transportError, this.#generation);
+        }
+        return promise;
+    }
+    #nextRequestId() {
+        this.#requestCounter += 1;
+        return `req-${this.#generation.toString(36)}-${this.#requestCounter.toString(36)}`;
+    }
+    async #consumeFrames(generation) {
+        let failure;
+        try {
+            for await (const frame of this.transport.frames()) {
+                if (generation !== this.#generation)
+                    return;
+                if (frame.protocol !== RUNTIME_PROTOCOL_VERSION) {
+                    throw new ProtocolVersionError(`received unsupported protocol ${frame.protocol}`, {
+                        code: "protocol_version", details: { expected: RUNTIME_PROTOCOL_VERSION, actual: frame.protocol },
+                    });
+                }
+                this.#dispatchFrame(frame);
+            }
+            failure = new TransportError("Miao Runtime transport disconnected", {
+                code: "transport_disconnected", retryable: true,
+            });
+        }
+        catch (error) {
+            failure = error instanceof MiaoError
+                ? error
+                : new TransportError("Miao Runtime frame stream failed", {
+                    code: "transport_error", retryable: true, cause: error,
+                });
+        }
+        finally {
+            await this.#finishDisconnect(failure, generation);
+        }
+    }
+    #dispatchFrame(frame) {
+        switch (frame.type) {
+            case "response": {
+                const pending = this.#pending.get(frame.requestId);
+                if (pending === undefined)
+                    return;
+                this.#pending.delete(frame.requestId);
+                pending.cleanup();
+                if (frame.status === "success")
+                    pending.resolve(frame.result);
+                else
+                    pending.reject(errorFromRuntime(frame.error, frame.requestId));
+                break;
+            }
+            case "event":
+                this.#dispatchEvent(frame);
+                break;
+            case "host_call":
+                void this.#routeHostCall(frame);
+                break;
+            case "cancel":
+                if (frame.target.kind === "host_call")
+                    this.#activeHostCalls.get(frame.target.callId)?.abort(frame.reason);
+                else if (frame.target.kind === "subscription")
+                    this.#subscriptions.get(frame.target.subscriptionId)?.close();
+                break;
+            case "ping":
+                void this.#sendBestEffort({ type: "pong", protocol: RUNTIME_PROTOCOL_VERSION, nonce: frame.nonce });
+                break;
+            case "request":
+            case "host_result":
+            case "pong":
+                break;
+        }
+    }
+    #dispatchEvent(frame) {
+        const queue = this.#subscriptions.get(frame.subscriptionId);
+        if (queue !== undefined) {
+            queue.push(frame.event);
+            return;
+        }
+        let events = this.#orphanEvents.get(frame.subscriptionId);
+        if (events === undefined) {
+            if (this.#orphanEvents.size >= this.#maxPendingRequests) {
+                const oldest = this.#orphanEvents.keys().next().value;
+                if (oldest !== undefined)
+                    this.#orphanEvents.delete(oldest);
+            }
+            events = [];
+            this.#orphanEvents.set(frame.subscriptionId, events);
+        }
+        if (events.length < this.#eventBufferSize)
+            events.push(frame);
+    }
+    async *#events(runId, options = {}) {
+        const result = await this.request("events.subscribe", { runId, fromSequence: options.fromSequence ?? 0 }, options);
+        const subscriptionId = result.subscriptionId;
+        if (typeof subscriptionId !== "string" || subscriptionId.length === 0) {
+            throw new ProtocolError("events.subscribe returned an invalid subscriptionId", { code: "invalid_response" });
+        }
+        const capacity = positive(options.bufferSize, this.#eventBufferSize, "bufferSize");
+        const queue = new BoundedAsyncQueue(capacity, () => {
+            void this.#unsubscribe(subscriptionId, "event consumer exceeded bounded buffer");
+        });
+        this.#subscriptions.set(subscriptionId, queue);
+        const orphans = this.#orphanEvents.get(subscriptionId) ?? [];
+        this.#orphanEvents.delete(subscriptionId);
+        for (const frame of orphans)
+            queue.push(frame.event);
+        const abort = () => queue.fail(new RequestCancelledError("event subscription was cancelled", {
+            code: "request_cancelled", cause: options.signal?.reason,
+        }));
+        if (options.signal?.aborted === true)
+            abort();
+        else
+            options.signal?.addEventListener("abort", abort, { once: true });
+        try {
+            yield* queue;
+        }
+        finally {
+            options.signal?.removeEventListener("abort", abort);
+            this.#subscriptions.delete(subscriptionId);
+            // Subscription teardown must not delay iterator completion on a slow or lost peer.
+            void this.#unsubscribe(subscriptionId, "event subscription closed");
+        }
+    }
+    #subscribe(runId, listener, options = {}) {
+        const controller = new AbortController();
+        let closed = false;
+        const forwardExternalAbort = () => controller.abort(options.signal?.reason);
+        options.signal?.addEventListener("abort", forwardExternalAbort, { once: true });
+        const done = (async () => {
+            try {
+                for await (const event of this.#events(runId, { ...options, signal: controller.signal })) {
+                    await listener(event);
+                }
+            }
+            catch (error) {
+                if (!controller.signal.aborted)
+                    options.onError?.(error);
+            }
+            finally {
+                closed = true;
+                options.signal?.removeEventListener("abort", forwardExternalAbort);
+            }
+        })();
+        return {
+            get closed() { return closed; },
+            done,
+            close() { controller.abort("callback subscription closed"); },
+        };
+    }
+    async #unsubscribe(subscriptionId, reason) {
+        if (this.#state !== "connected")
+            return;
+        try {
+            await this.request("events.unsubscribe", { subscriptionId }, { timeoutMs: Math.min(this.#defaultTimeoutMs, 5_000) });
+        }
+        catch {
+            await this.#sendBestEffort({
+                type: "cancel", protocol: RUNTIME_PROTOCOL_VERSION,
+                target: { kind: "subscription", subscriptionId }, reason,
+            });
+        }
+    }
+    async #registerCapability(definition, options) {
+        if (!/^service:\/\/\S+$/.test(definition.address)) {
+            throw new TypeError("Host Capability address must be a non-empty service:// URI");
+        }
+        if (definition.deadlineMs !== undefined)
+            positive(definition.deadlineMs, 1, "deadlineMs");
+        if (definition.leaseMs !== undefined)
+            positive(definition.leaseMs, 1, "leaseMs");
+        if (this.#capabilities.has(definition.address)) {
+            throw new HostCapabilityError(`Host Capability ${definition.address} is already registered`, {
+                code: "duplicate_host_capability",
+            });
+        }
+        const metadata = capabilityMetadata(definition);
+        const stored = {
+            definition, metadata, active: false,
+        };
+        this.#capabilities.set(definition.address, stored);
+        try {
+            await this.request("capabilities.register", metadata, options);
+            stored.active = true;
+        }
+        catch (error) {
+            this.#capabilities.delete(definition.address);
+            throw error;
+        }
+        return new ClientCapabilityRegistration(this, definition.address, metadata);
+    }
+    async #renewCapability(address, leaseMs, options) {
+        const stored = this.#capabilities.get(address);
+        await this.request("capabilities.renew", { address, ...(leaseMs === undefined ? {} : { leaseMs }) }, options);
+        if (stored !== undefined) {
+            stored.active = true;
+            if (leaseMs !== undefined)
+                stored.metadata = { ...stored.metadata, leaseMs };
+        }
+    }
+    async #unregisterCapability(address, options) {
+        const stored = this.#capabilities.get(address);
+        if (this.#state !== "connected") {
+            this.#capabilities.delete(address);
+            if (stored !== undefined)
+                stored.active = false;
+            return;
+        }
+        if (stored !== undefined && !stored.active) {
+            this.#capabilities.delete(address);
+            return;
+        }
+        await this.request("capabilities.unregister", { address }, options);
+        this.#capabilities.delete(address);
+        if (stored !== undefined)
+            stored.active = false;
+    }
+    #capabilityIsActive(address) {
+        return this.#capabilities.get(address)?.active ?? false;
+    }
+    async #restoreCapabilityRegistrations() {
+        for (const stored of this.#capabilities.values()) {
+            await this.request("capabilities.register", stored.metadata);
+            stored.active = true;
+        }
+    }
+    async #routeHostCall(frame) {
+        let result = this.#hostResults.get(frame.callId);
+        if (result === undefined) {
+            result = this.#executeHostCall(frame);
+            this.#hostResults.set(frame.callId, result);
+            this.#trimHostResults();
+        }
+        const response = await result;
+        this.#trimHostResults();
+        if (this.#state === "connected")
+            await this.#sendBestEffort(response);
+    }
+    #trimHostResults() {
+        while (this.#hostResults.size > this.#maxRememberedHostCalls) {
+            const removable = [...this.#hostResults.keys()].find((callId) => !this.#activeHostCalls.has(callId));
+            if (removable === undefined)
+                return;
+            this.#hostResults.delete(removable);
+        }
+    }
+    async #executeHostCall(frame) {
+        const stored = this.#capabilities.get(frame.capability);
+        if (stored === undefined || !stored.active) {
+            return hostError(frame.callId, "host_capability_unavailable", `Host Capability ${frame.capability} is unavailable`, true);
+        }
+        if (this.#activeHostCalls.size >= this.#maxConcurrentHostCalls) {
+            return hostError(frame.callId, "backpressure", "Host Capability concurrency limit reached", true);
+        }
+        const controller = new AbortController();
+        this.#activeHostCalls.set(frame.callId, controller);
+        const deadline = Date.now() + frame.deadlineMs;
+        const timer = setTimeout(() => controller.abort(new HostCapabilityTimeoutError(`Host Capability ${frame.capability} exceeded its ${frame.deadlineMs}ms deadline`, { code: "host_capability_timeout", retryable: true })), frame.deadlineMs);
+        const schemaContext = { capability: frame.capability, callId: frame.callId };
+        try {
+            await validateSchema(this.#schemaValidator, stored.definition.inputSchema, frame.input, {
+                ...schemaContext, direction: "input",
+            });
+            const context = hostContext(frame, deadline, controller.signal);
+            const output = await raceAbort(Promise.resolve(stored.definition.handler(frame.input, context)), controller.signal);
+            await validateSchema(this.#schemaValidator, stored.definition.outputSchema, output, {
+                ...schemaContext, direction: "output",
+            });
+            return { type: "host_result", protocol: RUNTIME_PROTOCOL_VERSION, callId: frame.callId, status: "success", output };
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                const reason = controller.signal.reason;
+                if (reason instanceof HostCapabilityTimeoutError) {
+                    return hostError(frame.callId, reason.code, reason.message, true, reason.details);
+                }
+                return {
+                    type: "host_result", protocol: RUNTIME_PROTOCOL_VERSION, callId: frame.callId,
+                    status: "cancelled", reason: reason instanceof Error ? reason.message : String(reason ?? "Host Call cancelled"),
+                };
+            }
+            const hostErrorValue = error instanceof MiaoError ? error : new HostCapabilityError(error instanceof Error ? error.message : "Host Capability handler failed", { code: "host_capability_error", cause: error });
+            return hostError(frame.callId, hostErrorValue.code, hostErrorValue.message, hostErrorValue.retryable, hostErrorValue.details);
+        }
+        finally {
+            clearTimeout(timer);
+            this.#activeHostCalls.delete(frame.callId);
+        }
+    }
+    async #sendBestEffort(frame) {
+        try {
+            await this.transport.send(frame);
+        }
+        catch (error) {
+            await this.#finishDisconnect(asTransportError(error), this.#generation);
+        }
+    }
+    async #finishDisconnect(error, generation) {
+        if (generation !== this.#generation || this.#state === "disconnected")
+            return;
+        const disconnectError = error instanceof MiaoError ? error : asTransportError(error);
+        this.#state = "disconnected";
+        this.#descriptor = undefined;
+        for (const pending of this.#pending.values()) {
+            pending.cleanup();
+            pending.reject(disconnectError);
+        }
+        this.#pending.clear();
+        for (const queue of this.#subscriptions.values())
+            queue.fail(disconnectError);
+        this.#subscriptions.clear();
+        this.#orphanEvents.clear();
+        for (const controller of this.#activeHostCalls.values())
+            controller.abort(disconnectError);
+        this.#activeHostCalls.clear();
+        this.#hostResults.clear();
+        for (const capability of this.#capabilities.values())
+            capability.active = false;
+        try {
+            await this.transport.close();
+        }
+        catch {
+            // The first transport failure is the useful terminal cause.
+        }
+    }
+    /** @internal Used by HostCapabilityRegistration. */
+    _registrationActive(address) { return this.#capabilityIsActive(address); }
+    /** @internal Used by HostCapabilityRegistration. */
+    _renewRegistration(address, leaseMs) { return this.#renewCapability(address, leaseMs); }
+    /** @internal Used by HostCapabilityRegistration. */
+    _unregisterRegistration(address) { return this.#unregisterCapability(address); }
+}
+class ClientCapabilityRegistration {
+    restoreMetadata;
+    #client;
+    address;
+    constructor(client, address, metadata) {
+        this.#client = client;
+        this.address = address;
+        this.restoreMetadata = metadata;
+    }
+    get active() { return this.#client._registrationActive(this.address); }
+    get description() { return this.restoreMetadata.description; }
+    get effects() { return this.restoreMetadata.effects; }
+    get approval() { return this.restoreMetadata.approval; }
+    get inputSchema() { return this.restoreMetadata.inputSchema; }
+    get outputSchema() { return this.restoreMetadata.outputSchema; }
+    get deadlineMs() { return this.restoreMetadata.deadlineMs; }
+    get leaseMs() { return this.restoreMetadata.leaseMs; }
+    get metadata() { return this.restoreMetadata.metadata; }
+    renew(leaseMs) { return this.#client._renewRegistration(this.address, leaseMs); }
+    unregister() { return this.#client._unregisterRegistration(this.address); }
+}
+function capabilityMetadata(definition) {
+    return {
+        address: definition.address,
+        ...(definition.description === undefined ? {} : { description: definition.description }),
+        ...(definition.effects === undefined ? {} : { effects: definition.effects }),
+        ...(definition.approval === undefined ? {} : { approval: definition.approval }),
+        ...(definition.inputSchema === undefined ? {} : { inputSchema: definition.inputSchema }),
+        ...(definition.outputSchema === undefined ? {} : { outputSchema: definition.outputSchema }),
+        ...(definition.deadlineMs === undefined ? {} : { deadlineMs: definition.deadlineMs }),
+        ...(definition.leaseMs === undefined ? {} : { leaseMs: definition.leaseMs }),
+        ...(definition.metadata === undefined ? {} : { metadata: definition.metadata }),
+    };
+}
+function hostContext(frame, deadline, signal) {
+    const context = frame.context;
+    return {
+        callId: frame.callId,
+        runId: context.runId,
+        principal: context.principal,
+        namespace: context.namespace,
+        deadline,
+        signal,
+        ...(context.traceId === undefined ? {} : { traceId: context.traceId }),
+    };
+}
+function hostError(callId, code, message, retryable, details) {
+    return {
+        type: "host_result", protocol: RUNTIME_PROTOCOL_VERSION, callId, status: "error",
+        error: { code, message, retryable, ...(details === undefined ? {} : { details }) },
+    };
+}
+function raceAbort(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+        promise.then((value) => { signal.removeEventListener("abort", abort); resolve(value); }, (error) => { signal.removeEventListener("abort", abort); reject(error); });
+    });
+}
+function positive(value, fallback, name) {
+    const result = value ?? fallback;
+    if (!Number.isSafeInteger(result) || result <= 0)
+        throw new RangeError(`${name} must be a positive integer`);
+    return result;
+}
+//# sourceMappingURL=client.js.map