@tarkahq/sdk 0.0.0-stage → 0.3.0

package/dist/cjs/rpc-types.d.ts

@@ -0,0 +1,36 @@
+import type { ChannelsServiceDefinition } from "./generated/tarka/channels/v1/channels.js";
+import type { AccessServiceDefinition } from "./generated/tarka/access/v1/access.js";
+import type { GatewayServiceDefinition } from "./generated/tarka/gateway/v1/gateway.js";
+import type { IAMServiceDefinition } from "./generated/tarka/iam/v1/iam.js";
+import type { Channel } from "@grpc/grpc-js";
+import type { InferenceServiceDefinition } from "./generated/tarka/inference/v1/inference.js";
+import type { ProvisioningServiceDefinition } from "./generated/tarka/provisioning/v1/provisioning.js";
+import type { SandboxServiceDefinition } from "./generated/tarka/provisioning/v1/sandbox.js";
+import type { ServiceClient, ServiceDefinition } from "./transport.js";
+/** Native inference methods with generated messages and gRPC errors. Access through client.grpc.inference. */
+export type InferenceRpc = ServiceClient<typeof InferenceServiceDefinition>;
+/** Native control plane methods. Access through client.grpc.provisioning. */
+export type ProvisioningRpc = ServiceClient<typeof ProvisioningServiceDefinition>;
+/** Native sandbox methods with explicit organization IDs. Access through client.grpc.sandboxes. */
+export type SandboxRpc = ServiceClient<typeof SandboxServiceDefinition>;
+/** Low-level escape hatch. Resource methods on the client are preferred for normal application use. */
+export type IAMRpc = ServiceClient<typeof IAMServiceDefinition>;
+export type GatewayRpc = ServiceClient<typeof GatewayServiceDefinition>;
+export type AccessRpc = ServiceClient<typeof AccessServiceDefinition>;
+export type ChannelsRpc = ServiceClient<typeof ChannelsServiceDefinition>;
+export interface GrpcClient {
+    /** Shared native channel. Client.close() closes it only when the SDK owns it. */
+    readonly iam: IAMRpc;
+    readonly gateway: GatewayRpc;
+    readonly access: AccessRpc;
+    readonly channels: ChannelsRpc;
+    readonly channel: Channel;
+    /** Inference RPCs with generated request/response shapes and numeric status codes. */
+    readonly inference: InferenceRpc;
+    /** Control plane RPCs with explicit request envelopes and organization IDs. */
+    readonly provisioning: ProvisioningRpc;
+    /** Sandbox RPCs with raw enum values and explicit idempotency-key handling. */
+    readonly sandboxes: SandboxRpc;
+}
+/** Keep native errors on client.grpc, and normalize errors only in the SDK layer. */
+export declare function sdkService<D extends ServiceDefinition>(definition: D, client: ServiceClient<D>): ServiceClient<D>;

package/dist/cjs/rpc-types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdkService = sdkService;
+const errors_js_1 = require("./errors.js");
+/** Keep native errors on client.grpc, and normalize errors only in the SDK layer. */
+function sdkService(definition, client) {
+    const result = {};
+    for (const [key, method] of Object.entries(definition.methods)) {
+        const invoke = client[key];
+        result[key] = method.responseStream
+            ? async function* (...args) {
+                try {
+                    yield* invoke(...args);
+                }
+                catch (error) {
+                    throw error instanceof TypeError ? error : (0, errors_js_1.normalizeError)(error);
+                }
+            }
+            : async (...args) => {
+                try {
+                    return await invoke(...args);
+                }
+                catch (error) {
+                    throw error instanceof TypeError ? error : (0, errors_js_1.normalizeError)(error);
+                }
+            };
+    }
+    return Object.freeze(result);
+}

package/dist/cjs/runtime.d.ts

@@ -0,0 +1,99 @@
+import { inspect } from "node:util";
+export interface RuntimePermission {
+    readonly resource: string;
+    readonly action: "invoke" | "read" | "get";
+}
+export interface RuntimeStart {
+    readonly gateway_id: string;
+    readonly transport: "api" | "mcp";
+    readonly permissions: readonly RuntimePermission[];
+    readonly max_seconds?: number;
+}
+export interface RuntimeMetadata {
+    readonly id: string;
+    readonly realm_id: string;
+    readonly subject_id: string;
+    readonly actor_id: string;
+    readonly grant_id: string;
+    readonly version: string;
+    readonly status: string;
+    readonly gateway_id: string;
+    readonly transport: "api" | "mcp";
+    readonly permissions: readonly RuntimePermission[];
+    readonly expires_at: string;
+}
+export interface RuntimeClientOptions {
+    /** Canonical HTTPS gateway origin, from trusted application configuration. */
+    readonly origin: string;
+    readonly realmId: string;
+    /** Obtain a fresh OAuth token for runtime.execute and the exact runtime audience. */
+    readonly tokenProvider: () => string | Promise<string>;
+    readonly timeoutMs?: number;
+    /** Trusted transport hook, primarily for controlled fixtures. No automatic retries. */
+    readonly fetch?: typeof globalThis.fetch;
+}
+/** Errors contain status and a safe local code, never a token or server response body. */
+export declare class RuntimeError extends Error {
+    readonly code: string;
+    readonly status?: number | undefined;
+    constructor(code: string, status?: number | undefined);
+}
+type Lease = {
+    run: RuntimeMetadata;
+    credential: string;
+    expires_at: string;
+    audience: string;
+};
+/** Keep this client and its token provider outside the model/tool execution context. */
+export declare class RuntimeClient {
+    #private;
+    readonly audience: string;
+    constructor(options: RuntimeClientOptions);
+    toJSON(): {
+        audience: string;
+    };
+    [inspect.custom](): string;
+    start(request: RuntimeStart): Promise<RuntimeRun>;
+    /** Claim one verified message with autonomous worker authority. Never retries. */
+    claimMessage(channelId: string, signal?: AbortSignal): Promise<RuntimeMessage | null>;
+    /** Only successfully empty polls repeat. Uncertain claims/replies propagate. */
+    messages(channelId: string, options?: {
+        signal?: AbortSignal;
+        pollIntervalMs?: number;
+    }): AsyncGenerator<RuntimeMessage>;
+    /** Finishes on success, cancels on callback failure. Cleanup failure never hides the callback error. */
+    withRun<T>(input: RuntimeStart, callback: (run: RuntimeRun) => Promise<T>): Promise<T>;
+}
+type Operations = {
+    renew: (run: RuntimeMetadata) => Promise<Lease>;
+    finish: (run: RuntimeMetadata, token: string, state: string) => Promise<void>;
+    send: (url: string, token: string, init: RequestInit) => Promise<Response>;
+    reply?: (run: RuntimeMetadata, token: string, text: string) => Promise<void>;
+};
+/** A trusted harness handle, not a model tool argument. No parent or upstream secrets are exposed. */
+export declare class RuntimeRun {
+    #private;
+    readonly audience: string;
+    constructor(lease: Lease, operations: Operations);
+    get metadata(): RuntimeMetadata;
+    toJSON(): {
+        run: RuntimeMetadata;
+        audience: string;
+    };
+    [inspect.custom](): string;
+    renew(): Promise<void>;
+    finish(state?: "completed" | "failed" | "cancelled"): Promise<void>;
+    /** Reply once to a claimed message and finish; no caller-selected destination. */
+    reply(text: string): Promise<void>;
+    /** Invoke only a relative API route within this run's gateway. Never retries an operation. */
+    api(path: string, init?: RequestInit): Promise<Response>;
+    /** Fetch adapter for an MCP Streamable HTTP transport, bound to this exact MCP URL. */
+    readonly mcpFetch: typeof globalThis.fetch;
+}
+/** Only prompt is model input. Keep this handle and its transports in the harness. */
+export declare class RuntimeMessage extends RuntimeRun {
+    #private;
+    constructor(lease: Lease, operations: Operations, prompt: string);
+    get prompt(): string;
+}
+export {};

package/dist/cjs/runtime.js

@@ -0,0 +1,473 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeMessage = exports.RuntimeRun = exports.RuntimeClient = exports.RuntimeError = void 0;
+const node_util_1 = require("node:util");
+const promises_1 = require("node:timers/promises");
+/** Errors contain status and a safe local code, never a token or server response body. */
+class RuntimeError extends Error {
+    code;
+    status;
+    constructor(code, status) {
+        super(code);
+        this.code = code;
+        this.status = status;
+        this.name = "RuntimeError";
+    }
+}
+exports.RuntimeError = RuntimeError;
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const id = (value) => typeof value === "string" &&
+    uuid.test(value) &&
+    !/^0{8}-0{4}-0{4}-0{4}-0{12}$/.test(value);
+const credential = /^tr_run_[A-Za-z0-9_-]{43}$/;
+const secret = (value) => typeof value === "string" &&
+    value.length >= 16 &&
+    value.length <= 8192 &&
+    !/\s/.test(value);
+function validateStart(input) {
+    if (!id(input.gateway_id) ||
+        !["api", "mcp"].includes(input.transport) ||
+        !Array.isArray(input.permissions) ||
+        input.permissions.length < 1 ||
+        input.permissions.length > 64 ||
+        input.permissions.some((p) => !id(p.resource) || !["invoke", "read", "get"].includes(p.action)) ||
+        new Set(input.permissions.map((p) => `${p.resource}/${p.action}`)).size !==
+            input.permissions.length ||
+        !Number.isInteger(input.max_seconds ?? 900) ||
+        (input.max_seconds ?? 900) < 1 ||
+        (input.max_seconds ?? 900) > 3600)
+        throw new RuntimeError("invalid_runtime_request");
+    return Object.freeze({
+        gateway_id: input.gateway_id,
+        transport: input.transport,
+        permissions: Object.freeze(input.permissions.map((p) => Object.freeze({ resource: p.resource, action: p.action }))),
+        max_seconds: input.max_seconds ?? 900,
+    });
+}
+async function readJSON(response, limit = 32768) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new RuntimeError("invalid_runtime_response");
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            size += next.value.length;
+            if (size > limit)
+                throw new RuntimeError("invalid_runtime_response");
+            chunks.push(next.value);
+        }
+    }
+    catch {
+        throw new RuntimeError("invalid_runtime_response");
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        throw new RuntimeError("invalid_runtime_response");
+    }
+}
+async function readLease(response, realm, audience, input, previous) {
+    try {
+        const lease = (await readJSON(response));
+        const run = lease.run;
+        if (lease.audience !== audience ||
+            !credential.test(lease.credential) ||
+            !id(run.id) ||
+            run.realm_id !== realm ||
+            run.gateway_id !== input.gateway_id ||
+            run.transport !== input.transport ||
+            run.status !== "running" ||
+            !id(run.subject_id) ||
+            (run.actor_id !== "" && !id(run.actor_id)) ||
+            (run.grant_id !== "" && !id(run.grant_id)) ||
+            typeof run.version !== "string" ||
+            !/^[1-9][0-9]*$/.test(run.version) ||
+            !Number.isFinite(Date.parse(run.expires_at)) ||
+            !Number.isFinite(Date.parse(lease.expires_at)) ||
+            Date.parse(lease.expires_at) <= Date.now() ||
+            Date.parse(lease.expires_at) > Date.parse(run.expires_at) ||
+            !Array.isArray(run.permissions) ||
+            run.permissions.length !== input.permissions.length ||
+            run.permissions.some((p, i) => p.resource !== input.permissions[i]?.resource ||
+                p.action !== input.permissions[i]?.action) ||
+            (previous &&
+                (run.id !== previous.id ||
+                    run.subject_id !== previous.subject_id ||
+                    run.actor_id !== previous.actor_id ||
+                    run.grant_id !== previous.grant_id ||
+                    BigInt(run.version) !== BigInt(previous.version) + 1n))) {
+            throw new Error();
+        }
+        lease.run = Object.freeze({
+            id: run.id,
+            realm_id: run.realm_id,
+            subject_id: run.subject_id,
+            actor_id: run.actor_id,
+            grant_id: run.grant_id,
+            version: run.version,
+            status: run.status,
+            gateway_id: run.gateway_id,
+            transport: run.transport,
+            expires_at: run.expires_at,
+            permissions: input.permissions,
+        });
+        return lease;
+    }
+    catch {
+        throw new RuntimeError("invalid_runtime_response");
+    }
+}
+/** Keep this client and its token provider outside the model/tool execution context. */
+class RuntimeClient {
+    audience;
+    #realm;
+    #origin;
+    #provider;
+    #fetch;
+    #timeout;
+    constructor(options) {
+        let url;
+        try {
+            url = new URL(options.origin);
+        }
+        catch {
+            throw new RuntimeError("invalid_runtime_origin");
+        }
+        if (url.protocol !== "https:" ||
+            url.origin !== options.origin ||
+            !id(options.realmId) ||
+            !Number.isFinite(options.timeoutMs ?? 30000) ||
+            (options.timeoutMs ?? 30000) <= 0) {
+            throw new RuntimeError("invalid_runtime_configuration");
+        }
+        this.#origin = options.origin;
+        this.#realm = options.realmId;
+        this.audience = `${options.origin}/v1/realms/${options.realmId}/runtime`;
+        this.#provider = options.tokenProvider;
+        this.#fetch = options.fetch ?? globalThis.fetch;
+        this.#timeout = options.timeoutMs ?? 30000;
+    }
+    toJSON() {
+        return { audience: this.audience };
+    }
+    [node_util_1.inspect.custom]() {
+        return `RuntimeClient(${this.audience})`;
+    }
+    async #parent() {
+        let token;
+        try {
+            token = await this.#provider();
+        }
+        catch {
+            throw new RuntimeError("runtime_identity_unavailable");
+        }
+        if (!secret(token) || token.startsWith("tr_run_"))
+            throw new RuntimeError("invalid_runtime_identity");
+        return token;
+    }
+    async #send(url, token, init) {
+        const headers = new Headers(init.headers);
+        for (const h of [...headers.keys()]) {
+            if (/^(authorization|cookie|proxy-authorization|origin|referer|host|forwarded)$/i.test(h) ||
+                /^x-(tarka|forwarded)-/i.test(h))
+                headers.delete(h);
+        }
+        headers.set("Authorization", `Bearer ${token}`);
+        const timeout = AbortSignal.timeout(this.#timeout);
+        const signal = init.signal
+            ? AbortSignal.any([init.signal, timeout])
+            : timeout;
+        let response;
+        try {
+            response = await this.#fetch(url, {
+                ...init,
+                headers,
+                redirect: "error",
+                credentials: "omit",
+                referrerPolicy: "no-referrer",
+                signal,
+            });
+        }
+        catch {
+            throw new RuntimeError("runtime_transport_uncertain");
+        }
+        if (response.status >= 300 && response.status < 400) {
+            await response.body?.cancel().catch(() => { });
+            throw new RuntimeError("runtime_redirect_rejected", response.status);
+        }
+        return response;
+    }
+    async #control(path, token, body) {
+        const response = await this.#send(`${this.audience}/runs${path}`, token, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            await response.body?.cancel().catch(() => { });
+            throw new RuntimeError("runtime_request_rejected", response.status);
+        }
+        return response;
+    }
+    async start(request) {
+        const input = validateStart(request);
+        const audience = `${this.#origin}/v1/realms/${this.#realm}/gateways/${input.gateway_id}${input.transport === "mcp" ? "/mcp" : ""}`;
+        const response = await this.#control("", await this.#parent(), input);
+        const lease = await readLease(response, this.#realm, audience, input);
+        return new RuntimeRun(lease, this.#operations(audience, input));
+    }
+    #operations(audience, input, channel) {
+        return {
+            renew: async (run) => readLease(await this.#control(`/${run.id}/renew`, await this.#parent(), {
+                expected_version: run.version,
+            }), this.#realm, audience, input, run),
+            finish: async (run, token, state) => {
+                const response = await this.#control(`/${run.id}/finish`, token, {
+                    state,
+                });
+                await response.body?.cancel();
+            },
+            send: (url, token, init) => this.#send(url, token, init),
+            ...(channel
+                ? {
+                    reply: async (run, token, text) => {
+                        const response = await this.#send(`${this.#origin}/v1/realms/${this.#realm}/channels/${channel}/runs/${run.id}/reply`, token, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: JSON.stringify({ text }),
+                        });
+                        await response.body?.cancel().catch(() => { });
+                        if (response.status !== 204)
+                            throw new RuntimeError("messaging_request_rejected", response.status);
+                    },
+                }
+                : {}),
+        };
+    }
+    /** Claim one verified message with autonomous worker authority. Never retries. */
+    async claimMessage(channelId, signal) {
+        if (!id(channelId))
+            throw new RuntimeError("invalid_messaging_channel");
+        const response = await this.#send(`${this.#origin}/v1/realms/${this.#realm}/channels/${channelId}/claim`, await this.#parent(), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: "{}",
+            signal,
+        });
+        if (response.status === 204) {
+            await response.body?.cancel().catch(() => { });
+            return null;
+        }
+        if (response.status !== 200) {
+            await response.body?.cancel().catch(() => { });
+            throw new RuntimeError("messaging_request_rejected", response.status);
+        }
+        let value, input;
+        try {
+            value = (await readJSON(response, 65536));
+            if (typeof value.prompt !== "string" ||
+                !value.prompt.trim() ||
+                /[\u0000\uD800-\uDFFF]/u.test(value.prompt) ||
+                Buffer.byteLength(value.prompt, "utf8") > 16000 ||
+                !id(value.run.actor_id) ||
+                !id(value.run.grant_id))
+                throw new Error();
+            input = validateStart({
+                gateway_id: value.run.gateway_id,
+                transport: value.run.transport,
+                permissions: value.run.permissions,
+                max_seconds: 3600,
+            });
+        }
+        catch {
+            throw new RuntimeError("invalid_messaging_response");
+        }
+        const audience = `${this.#origin}/v1/realms/${this.#realm}/gateways/${input.gateway_id}${input.transport === "mcp" ? "/mcp" : ""}`;
+        // Reuse the same strict identity, scope, expiry and origin validation as runs.
+        const { prompt, ...raw } = value;
+        const lease = await readLease(Response.json(raw), this.#realm, audience, input);
+        return new RuntimeMessage(lease, this.#operations(audience, input, channelId), prompt);
+    }
+    /** Only successfully empty polls repeat. Uncertain claims/replies propagate. */
+    async *messages(channelId, options = {}) {
+        const interval = options.pollIntervalMs ?? 5000;
+        if (!Number.isFinite(interval) || interval < 5000)
+            throw new RuntimeError("invalid_messaging_poll_interval");
+        while (!options.signal?.aborted) {
+            const message = await this.claimMessage(channelId, options.signal);
+            if (!message) {
+                await (0, promises_1.setTimeout)(interval, undefined, { signal: options.signal });
+                continue;
+            }
+            try {
+                if (!options.signal?.aborted)
+                    yield message;
+            }
+            finally {
+                await message.finish("cancelled").catch(() => { });
+            }
+        }
+    }
+    /** Finishes on success, cancels on callback failure. Cleanup failure never hides the callback error. */
+    async withRun(input, callback) {
+        const run = await this.start(input);
+        let result;
+        try {
+            result = await callback(run);
+        }
+        catch (error) {
+            await run.finish("cancelled").catch(() => { });
+            throw error;
+        }
+        await run.finish("completed");
+        return result;
+    }
+}
+exports.RuntimeClient = RuntimeClient;
+/** A trusted harness handle, not a model tool argument. No parent or upstream secrets are exposed. */
+class RuntimeRun {
+    audience;
+    #lease;
+    #ops;
+    #queue = Promise.resolve();
+    #unusable = false;
+    #finished = false;
+    constructor(lease, operations) {
+        this.#lease = lease;
+        this.audience = lease.audience;
+        this.#ops = operations;
+    }
+    get metadata() {
+        return this.#lease.run;
+    }
+    toJSON() {
+        return { run: this.metadata, audience: this.audience };
+    }
+    [node_util_1.inspect.custom]() {
+        return `RuntimeRun(${this.metadata.id})`;
+    }
+    async #exclusive(fn) {
+        const previous = this.#queue;
+        let release;
+        this.#queue = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+    async #renew() {
+        if (this.#unusable || this.#finished)
+            throw new RuntimeError("runtime_run_unusable");
+        try {
+            this.#lease = await this.#ops.renew(this.metadata);
+        }
+        catch (error) {
+            this.#unusable = true;
+            throw error;
+        }
+    }
+    async renew() {
+        return this.#exclusive(() => this.#renew());
+    }
+    async finish(state = "completed") {
+        return this.#exclusive(async () => {
+            if (this.#finished)
+                return;
+            if (!["completed", "failed", "cancelled"].includes(state))
+                throw new RuntimeError("invalid_runtime_state");
+            this.#unusable = true;
+            await this.#ops.finish(this.metadata, this.#lease.credential, state);
+            this.#finished = true;
+            this.#lease = { ...this.#lease, credential: "" };
+        });
+    }
+    /** Reply once to a claimed message and finish; no caller-selected destination. */
+    async reply(text) {
+        if (typeof text !== "string" ||
+            !text.trim() ||
+            /[\u0000\uD800-\uDFFF]/u.test(text) ||
+            [...text].length > 2000)
+            throw new RuntimeError("invalid_messaging_reply");
+        return this.#exclusive(async () => {
+            if (this.#unusable || this.#finished)
+                throw new RuntimeError("runtime_run_unusable");
+            if (!this.#ops.reply)
+                throw new RuntimeError("not_a_messaging_run");
+            if (Date.parse(this.#lease.expires_at) - Date.now() < 60000)
+                await this.#renew();
+            this.#unusable = true;
+            await this.#ops.reply(this.metadata, this.#lease.credential, text);
+            this.#finished = true;
+            this.#lease = { ...this.#lease, credential: "" };
+        });
+    }
+    async #request(url, init) {
+        // Serialize through receipt of response headers so a concurrent renewal does
+        // not rotate a credential while another request is awaiting admission.
+        return this.#exclusive(async () => {
+            if (this.#unusable || this.#finished)
+                throw new RuntimeError("runtime_run_unusable");
+            if (Date.parse(this.#lease.expires_at) - Date.now() < 60000)
+                await this.#renew();
+            const response = await this.#ops.send(url, this.#lease.credential, init);
+            if (response.status === 401 || response.status === 403)
+                this.#unusable = true;
+            return response;
+        });
+    }
+    /** Invoke only a relative API route within this run's gateway. Never retries an operation. */
+    async api(path, init = {}) {
+        if (this.metadata.transport !== "api" ||
+            !path.startsWith("/") ||
+            path.startsWith("//") ||
+            /[\\#]/.test(path))
+            throw new RuntimeError("invalid_runtime_destination");
+        const base = `${this.audience}/api/`;
+        const url = new URL(`${this.audience}/api${path}`);
+        if (!url.href.startsWith(base))
+            throw new RuntimeError("invalid_runtime_destination");
+        return this.#request(url.href, init);
+    }
+    /** Fetch adapter for an MCP Streamable HTTP transport, bound to this exact MCP URL. */
+    mcpFetch = async (input, init) => {
+        const request = new Request(input, init);
+        if (this.metadata.transport !== "mcp" ||
+            request.url !== this.audience ||
+            !["POST", "GET", "DELETE"].includes(request.method))
+            throw new RuntimeError("invalid_runtime_destination");
+        const body = request.body ? await request.arrayBuffer() : undefined;
+        return this.#request(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body,
+            signal: request.signal,
+        });
+    };
+}
+exports.RuntimeRun = RuntimeRun;
+/** Only prompt is model input. Keep this handle and its transports in the harness. */
+class RuntimeMessage extends RuntimeRun {
+    #prompt;
+    constructor(lease, operations, prompt) {
+        super(lease, operations);
+        this.#prompt = prompt;
+    }
+    get prompt() {
+        return this.#prompt;
+    }
+}
+exports.RuntimeMessage = RuntimeMessage;