@slopus/rig 0.0.1

package/dist/app/runApp.js

@@ -0,0 +1,157 @@
+import { ProcessTerminal, TUI } from "@earendil-works/pi-tui";
+import { createNodeAgentContext } from "../agent/index.js";
+import { ensureLocalProtocolServer, RemoteAgent } from "../client/index.js";
+import { loadConfig, writeRuntimeConfig } from "../config/index.js";
+import { NativeProxessManager } from "../processes/index.js";
+import { CodingAssistantApp } from "./CodingAssistantApp.js";
+import {} from "./createCodingAssistantAgent.js";
+import { createStopOnceHandler } from "./createStopOnceHandler.js";
+import { ensureSessionCanResume } from "./ensureSessionCanResume.js";
+import { readPackageVersion } from "./readPackageVersion.js";
+import { StartupStatusApp } from "./StartupStatusApp.js";
+export async function runApp(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const loadedConfig = await loadConfig({ cwd });
+    const agentOptions = {
+        cwd,
+        modelId: loadedConfig.config.defaults.modelId,
+    };
+    if (loadedConfig.config.defaults.providerId !== undefined) {
+        agentOptions.providerId = loadedConfig.config.defaults.providerId;
+    }
+    if (loadedConfig.config.defaults.effort !== undefined) {
+        agentOptions.effort = loadedConfig.config.defaults.effort;
+    }
+    if (loadedConfig.config.defaults.instructions !== undefined) {
+        agentOptions.instructions = loadedConfig.config.defaults.instructions;
+    }
+    if (options.apiKey !== undefined)
+        agentOptions.apiKey = options.apiKey;
+    if (options.effort !== undefined)
+        agentOptions.effort = options.effort;
+    if (options.instructions !== undefined)
+        agentOptions.instructions = options.instructions;
+    if (options.modelId !== undefined)
+        agentOptions.modelId = options.modelId;
+    if (options.providerId !== undefined)
+        agentOptions.providerId = options.providerId;
+    let showReasoning = options.showReasoning ?? loadedConfig.config.settings.showReasoning;
+    // Keep the terminal in TUI mode while the daemon starts so startup work is visible.
+    const tui = new TUI(new ProcessTerminal(), false);
+    const startup = new StartupStatusApp({
+        cwd,
+        tui,
+        version: readPackageVersion(),
+    });
+    startup.start();
+    const { history, localServer, modelCatalog, session } = await (async () => {
+        try {
+            const connection = await ensureLocalProtocolServer({
+                onStatus: (message) => {
+                    startup.setStatus(message);
+                },
+            });
+            startup.setStatus("Opening session.");
+            const [openedSession, modelsResponse] = await Promise.all([
+                options.resumeSessionId === undefined
+                    ? connection.client.createSession(agentOptions)
+                    : connection.client.getSession(options.resumeSessionId),
+                connection.client.models(),
+            ]);
+            if (options.resumeSessionId !== undefined) {
+                ensureSessionCanResume(openedSession.session);
+            }
+            startup.setStatus("Loading transcript.");
+            const loadedHistory = options.resumeSessionId === undefined
+                ? { events: [] }
+                : await connection.client.getEvents(openedSession.session.id);
+            return {
+                history: loadedHistory,
+                localServer: connection,
+                modelCatalog: modelsResponse.catalog,
+                session: openedSession,
+            };
+        }
+        catch (error) {
+            startup.stop();
+            tui.stop();
+            throw error;
+        }
+    })();
+    const processManager = new NativeProxessManager();
+    const sessionCwd = session.session.cwd;
+    const context = createNodeAgentContext({ cwd: sessionCwd, processManager });
+    const agent = new RemoteAgent({
+        client: localServer.client,
+        context,
+        modelCatalog,
+        session: session.session,
+    });
+    const resumeCommand = `rig resume ${session.session.id}`;
+    const app = new CodingAssistantApp({
+        agent,
+        cwd: sessionCwd,
+        initialSessionEvents: history.events,
+        modelLocked: session.session.modelLocked,
+        onDefaultModelChange: (preference) => writeRuntimeConfig(loadedConfig.paths.runtime, {
+            defaults: {
+                modelId: preference.modelId,
+                providerId: preference.providerId,
+                effort: preference.effort,
+            },
+            settings: {
+                showReasoning,
+            },
+        }),
+        onSettingsChange: (settings) => {
+            showReasoning = settings.showReasoning;
+            return writeRuntimeConfig(loadedConfig.paths.runtime, {
+                defaults: {
+                    modelId: agent.model.id,
+                    providerId: agent.provider.id,
+                    effort: agent.snapshot().effort ?? agent.model.defaultThinkingLevel,
+                },
+                settings,
+            });
+        },
+        processManager,
+        sessionBacked: true,
+        showReasoning,
+        tui,
+        version: readPackageVersion(),
+    });
+    startup.stop();
+    const followController = new AbortController();
+    const lastHistoryEventId = history.events.at(-1)?.id ?? session.session.lastEventId;
+    void localServer.client.watchSessionEvents({
+        ...(lastHistoryEventId !== undefined ? { after: lastHistoryEventId } : {}),
+        onEvent: (event) => {
+            agent.applySessionEvent(event);
+            app.applySessionEvent(event);
+        },
+        sessionId: session.session.id,
+        signal: followController.signal,
+    });
+    const requestStop = createStopOnceHandler(() => app.stop(), (error) => {
+        console.error(error);
+        process.exitCode = 1;
+    });
+    const stop = () => {
+        void requestStop();
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    try {
+        app.start({ tuiAlreadyStarted: true });
+        await app.waitForExit();
+    }
+    finally {
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        followController.abort();
+        await processManager.killAll({ forceAfterMs: 500 });
+        console.error("");
+        console.error(`Session: ${session.session.id}`);
+        console.error(`Resume: ${resumeCommand}`);
+    }
+}

package/dist/app/runDaemonCommand.d.ts

@@ -0,0 +1,3 @@
+export type DaemonCommand = "start" | "stop" | "status";
+export declare function runDaemonCommand(command: DaemonCommand): Promise<void>;
+//# sourceMappingURL=runDaemonCommand.d.ts.map

package/dist/app/runDaemonCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runDaemonCommand.d.ts","sourceRoot":"","sources":["../../sources/app/runDaemonCommand.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAExD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}

package/dist/app/runDaemonCommand.js

@@ -0,0 +1,50 @@
+import { ensureLocalProtocolServer, ProtocolHttpClient, readTokenIfPresent, } from "../client/index.js";
+import { getLocalServerPaths } from "../server/index.js";
+export async function runDaemonCommand(command) {
+    if (command === "start") {
+        const connection = await ensureLocalProtocolServer();
+        console.log(`Daemon is running at ${connection.paths.socketPath}`);
+        return;
+    }
+    const connection = await connectToExistingDaemon();
+    if (command === "status") {
+        if (connection === undefined) {
+            console.log("Daemon is not running.");
+            return;
+        }
+        console.log(`Daemon is running at ${connection.client.socketPath}`);
+        return;
+    }
+    if (connection === undefined) {
+        console.log("Daemon is not running.");
+        return;
+    }
+    await connection.client.shutdown();
+    console.log("Daemon is stopping.");
+}
+async function connectToExistingDaemon() {
+    const paths = getEnvironmentLocalServerPaths();
+    const token = await readTokenIfPresent(paths.tokenPath);
+    if (token === undefined) {
+        return undefined;
+    }
+    const client = new ProtocolHttpClient({
+        socketPath: paths.socketPath,
+        token,
+    });
+    try {
+        const health = await client.health();
+        return health.healthy && health.ready ? { client } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getEnvironmentLocalServerPaths() {
+    const paths = getLocalServerPaths();
+    return {
+        ...paths,
+        socketPath: process.env.RIG_SERVER_SOCKET_PATH ?? paths.socketPath,
+        tokenPath: process.env.RIG_SERVER_TOKEN_PATH ?? paths.tokenPath,
+    };
+}

package/dist/app/runMonit.d.ts

@@ -0,0 +1,6 @@
+export interface RunMonitOptions {
+    columns?: number;
+    rows?: number;
+}
+export declare function runMonit(options?: RunMonitOptions): Promise<void>;
+//# sourceMappingURL=runMonit.d.ts.map

package/dist/app/runMonit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runMonit.d.ts","sourceRoot":"","sources":["../../sources/app/runMonit.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAU3E"}

package/dist/app/runMonit.js

@@ -0,0 +1,13 @@
+import { ensureLocalProtocolServer } from "../client/index.js";
+import { formatSessionSummaries } from "./formatSessionSummaries.js";
+export async function runMonit(options = {}) {
+    const rows = options.rows ?? process.stdout.rows ?? 24;
+    const columns = options.columns ?? process.stdout.columns ?? 100;
+    const limit = Math.max(0, rows - 1);
+    const localServer = await ensureLocalProtocolServer();
+    const response = await localServer.client.listSessions(limit);
+    const lines = formatSessionSummaries(response.sessions, { columns, rows });
+    for (const line of lines) {
+        console.log(line);
+    }
+}

package/dist/app/runWebCommand.d.ts

@@ -0,0 +1,2 @@
+export declare function runWebCommand(): Promise<void>;
+//# sourceMappingURL=runWebCommand.d.ts.map

package/dist/app/runWebCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runWebCommand.d.ts","sourceRoot":"","sources":["../../sources/app/runWebCommand.ts"],"names":[],"mappings":"AAMA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAmBnD"}

package/dist/app/runWebCommand.js

@@ -0,0 +1,52 @@
+import { spawn } from "node:child_process";
+import { ensureLocalProtocolServer } from "../client/index.js";
+import { resolvePortlessCliPath } from "./resolvePortlessCliPath.js";
+import { webPortlessAppName, webPortlessUrl } from "./web/webPortlessRoute.js";
+export async function runWebCommand() {
+    const localServer = await ensureLocalProtocolServer({
+        onStatus(message) {
+            console.log(message);
+        },
+    });
+    const entrypoint = process.argv[1];
+    if (entrypoint === undefined || entrypoint.length === 0) {
+        throw new Error("Cannot locate the current CLI entrypoint.");
+    }
+    const portlessCliPath = await resolvePortlessCliPath();
+    console.log(`Starting the web UI at ${webPortlessUrl}`);
+    await runPortlessWebProcess({
+        entrypoint,
+        portlessCliPath,
+        socketPath: localServer.paths.socketPath,
+        tokenPath: localServer.paths.tokenPath,
+    });
+}
+function runPortlessWebProcess(options) {
+    const child = spawn(process.execPath, [
+        options.portlessCliPath,
+        webPortlessAppName,
+        process.execPath,
+        ...process.execArgv,
+        options.entrypoint,
+        "--web-server",
+    ], {
+        env: {
+            ...process.env,
+            RIG_SERVER_SOCKET_PATH: options.socketPath,
+            RIG_SERVER_TOKEN_PATH: options.tokenPath,
+            PORTLESS_HTTPS: "1",
+            PORTLESS_TLD: "localhost",
+        },
+        stdio: "inherit",
+    });
+    return new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            if (code === 0 || signal === "SIGINT" || signal === "SIGTERM") {
+                resolve();
+                return;
+            }
+            reject(new Error(`The web UI stopped unexpectedly with exit code ${code ?? signal}.`));
+        });
+    });
+}

package/dist/app/web/createWebHttpServer.d.ts

@@ -0,0 +1,8 @@
+import { type Server } from "node:http";
+export interface WebHttpServerOptions {
+    assetRoot: string;
+    socketPath: string;
+    token: string;
+}
+export declare function createWebHttpServer(options: WebHttpServerOptions): Server;
+//# sourceMappingURL=createWebHttpServer.d.ts.map

package/dist/app/web/createWebHttpServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWebHttpServer.d.ts","sourceRoot":"","sources":["../../../sources/app/web/createWebHttpServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoD,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAK1F,MAAM,WAAW,oBAAoB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,CAYzE"}

package/dist/app/web/createWebHttpServer.js

@@ -0,0 +1,150 @@
+import { request as httpRequest } from "node:http";
+import { createServer } from "node:http";
+import { readFile, stat } from "node:fs/promises";
+import { extname, resolve, sep } from "node:path";
+export function createWebHttpServer(options) {
+    return createServer((request, response) => {
+        void handleWebRequest(request, response, options).catch((error) => {
+            sendText(response, 500, error instanceof Error
+                ? error.message
+                : "The web server could not handle the request.");
+        });
+    });
+}
+async function handleWebRequest(request, response, options) {
+    const url = new URL(request.url ?? "/", "http://web.rig.localhost");
+    if (url.pathname === "/api" || url.pathname.startsWith("/api/")) {
+        proxyDaemonRequest(request, response, options, url);
+        return;
+    }
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        sendText(response, 405, "This route only supports browser navigation requests.");
+        return;
+    }
+    const assetPath = resolveAssetPath(options.assetRoot, url.pathname);
+    if (assetPath === undefined) {
+        sendText(response, 400, "The requested path is not valid.");
+        return;
+    }
+    if (await isFile(assetPath)) {
+        await sendFile(response, request.method, assetPath);
+        return;
+    }
+    if (extname(url.pathname).length > 0) {
+        sendText(response, 404, "File not found.");
+        return;
+    }
+    await sendFile(response, request.method, resolve(options.assetRoot, "index.html"));
+}
+function proxyDaemonRequest(request, response, options, url) {
+    const daemonPath = `${url.pathname.slice("/api".length) || "/"}${url.search}`;
+    const upstream = httpRequest({
+        headers: createProxyHeaders(request.headers, options.token),
+        method: request.method,
+        path: daemonPath,
+        socketPath: options.socketPath,
+    }, (upstreamResponse) => {
+        response.writeHead(upstreamResponse.statusCode ?? 502, upstreamResponse.statusMessage, sanitizeProxyHeaders(upstreamResponse.headers));
+        upstreamResponse.pipe(response);
+    });
+    upstream.on("error", () => {
+        if (response.headersSent) {
+            response.destroy();
+            return;
+        }
+        sendText(response, 502, "The local daemon is not available.");
+    });
+    request.pipe(upstream);
+}
+function createProxyHeaders(headers, token) {
+    const proxyHeaders = { ...headers };
+    delete proxyHeaders.authorization;
+    delete proxyHeaders.connection;
+    delete proxyHeaders.host;
+    proxyHeaders.authorization = `Bearer ${token}`;
+    return proxyHeaders;
+}
+function sanitizeProxyHeaders(headers) {
+    const responseHeaders = { ...headers };
+    delete responseHeaders.connection;
+    delete responseHeaders["keep-alive"];
+    delete responseHeaders["proxy-authenticate"];
+    delete responseHeaders["proxy-authorization"];
+    delete responseHeaders.te;
+    delete responseHeaders.trailer;
+    delete responseHeaders["transfer-encoding"];
+    delete responseHeaders.upgrade;
+    return responseHeaders;
+}
+function resolveAssetPath(assetRoot, pathname) {
+    let decodedPathname;
+    try {
+        decodedPathname = decodeURIComponent(pathname);
+    }
+    catch {
+        return undefined;
+    }
+    const rootPath = resolve(assetRoot);
+    const relativePath = decodedPathname.replace(/^\/+/, "") || "index.html";
+    const assetPath = resolve(rootPath, relativePath);
+    if (assetPath !== rootPath && !assetPath.startsWith(`${rootPath}${sep}`)) {
+        return undefined;
+    }
+    return assetPath;
+}
+async function isFile(filePath) {
+    try {
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function sendFile(response, method, filePath) {
+    const body = await readFile(filePath);
+    response.writeHead(200, {
+        "cache-control": filePath.endsWith("index.html")
+            ? "no-store"
+            : "public, max-age=31536000, immutable",
+        "content-length": body.length,
+        "content-type": contentTypeForFile(filePath),
+    });
+    if (method !== "HEAD") {
+        response.end(body);
+        return;
+    }
+    response.end();
+}
+function sendText(response, statusCode, message) {
+    if (response.headersSent) {
+        return;
+    }
+    response.writeHead(statusCode, {
+        "cache-control": "no-store",
+        "content-type": "text/plain; charset=utf-8",
+    });
+    response.end(message);
+}
+function contentTypeForFile(filePath) {
+    switch (extname(filePath)) {
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".html":
+            return "text/html; charset=utf-8";
+        case ".ico":
+            return "image/x-icon";
+        case ".js":
+        case ".mjs":
+            return "text/javascript; charset=utf-8";
+        case ".json":
+            return "application/json; charset=utf-8";
+        case ".png":
+            return "image/png";
+        case ".svg":
+            return "image/svg+xml";
+        case ".webp":
+            return "image/webp";
+        default:
+            return "application/octet-stream";
+    }
+}

package/dist/app/web/runWebServer.d.ts

@@ -0,0 +1,2 @@
+export declare function runWebServer(env?: NodeJS.ProcessEnv): Promise<void>;
+//# sourceMappingURL=runWebServer.d.ts.map

package/dist/app/web/runWebServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runWebServer.d.ts","sourceRoot":"","sources":["../../../sources/app/web/runWebServer.ts"],"names":[],"mappings":"AAQA,wBAAsB,YAAY,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAYtF"}

package/dist/app/web/runWebServer.js

@@ -0,0 +1,63 @@
+import { access } from "node:fs/promises";
+import {} from "node:http";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getLocalServerPaths, readLocalServerToken } from "../../server/index.js";
+import { createWebHttpServer } from "./createWebHttpServer.js";
+export async function runWebServer(env = process.env) {
+    const paths = getLocalServerPaths();
+    const socketPath = env.RIG_SERVER_SOCKET_PATH ?? paths.socketPath;
+    const tokenPath = env.RIG_SERVER_TOKEN_PATH ?? paths.tokenPath;
+    const token = await readLocalServerToken(tokenPath);
+    const assetRoot = await resolveWebAssetRoot(env.RIG_WEB_ASSET_ROOT);
+    const server = createWebHttpServer({ assetRoot, socketPath, token });
+    const host = env.HOST ?? "127.0.0.1";
+    const port = parsePort(env.PORT);
+    await listen(server, port, host);
+    console.log(`Rig web server is listening on ${host}:${port}.`);
+}
+async function resolveWebAssetRoot(configuredPath) {
+    if (configuredPath !== undefined) {
+        if (await hasIndexHtml(configuredPath)) {
+            return configuredPath;
+        }
+        throw new Error(`Web assets were not found at ${configuredPath}.`);
+    }
+    const assetRoot = fileURLToPath(new URL("../../web/", import.meta.url));
+    if (await hasIndexHtml(assetRoot)) {
+        return assetRoot;
+    }
+    const cwdAssetRoot = resolve(process.cwd(), "dist/web");
+    if (await hasIndexHtml(cwdAssetRoot)) {
+        return cwdAssetRoot;
+    }
+    throw new Error(`Web assets were not found at ${assetRoot}. Run "pnpm build" first.`);
+}
+async function hasIndexHtml(assetRoot) {
+    try {
+        await access(resolve(assetRoot, "index.html"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parsePort(value) {
+    const port = Number.parseInt(value ?? "", 10);
+    if (!Number.isInteger(port) || port <= 0 || port > 65_535) {
+        throw new Error("Portless did not provide a valid port for the web server.");
+    }
+    return port;
+}
+function listen(server, port, host) {
+    return new Promise((resolveListen, rejectListen) => {
+        const onError = (error) => {
+            rejectListen(error);
+        };
+        server.once("error", onError);
+        server.listen(port, host, () => {
+            server.off("error", onError);
+            resolveListen();
+        });
+    });
+}

package/dist/app/web/webPortlessRoute.d.ts

@@ -0,0 +1,3 @@
+export declare const webPortlessAppName = "web.rig";
+export declare const webPortlessUrl = "https://web.rig.localhost";
+//# sourceMappingURL=webPortlessRoute.d.ts.map

package/dist/app/web/webPortlessRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webPortlessRoute.d.ts","sourceRoot":"","sources":["../../../sources/app/web/webPortlessRoute.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAY,CAAC;AAC5C,eAAO,MAAM,cAAc,8BAA8B,CAAC"}

package/dist/app/web/webPortlessRoute.js

@@ -0,0 +1,2 @@
+export const webPortlessAppName = "web.rig";
+export const webPortlessUrl = "https://web.rig.localhost";

package/dist/client/ProtocolHttpClient.d.ts

@@ -0,0 +1,42 @@
+import type { AbortRunResponse, ChangeEffortRequest, ChangeModelRequest, CreateSessionRequest, CreateSessionResponse, EventId, HealthResponse, ListModelsResponse, ListSessionsResponse, ListSubagentsResponse, ProtocolSession, SessionEvent, ShutdownServerResponse, SubmitMessageRequest, SubmitMessageResponse } from "../protocol/index.js";
+export interface ProtocolHttpClientOptions {
+    socketPath: string;
+    token: string;
+}
+export interface WatchSessionEventsOptions {
+    after?: EventId;
+    signal?: AbortSignal;
+    sessionId: string;
+    onEvent: (event: SessionEvent) => void | Promise<void>;
+}
+export declare class ProtocolHttpClient {
+    #private;
+    readonly socketPath: string;
+    readonly token: string;
+    constructor(options: ProtocolHttpClientOptions);
+    abort(sessionId: string): Promise<AbortRunResponse>;
+    changeModel(sessionId: string, request: ChangeModelRequest): Promise<{
+        session: ProtocolSession;
+    }>;
+    changeEffort(sessionId: string, request: ChangeEffortRequest): Promise<{
+        session: ProtocolSession;
+    }>;
+    createSession(request: CreateSessionRequest): Promise<CreateSessionResponse>;
+    health(): Promise<HealthResponse>;
+    models(): Promise<ListModelsResponse>;
+    listSessions(limit?: number): Promise<ListSessionsResponse>;
+    listSubagents(sessionId: string): Promise<ListSubagentsResponse>;
+    getSession(sessionId: string): Promise<{
+        session: ProtocolSession;
+    }>;
+    getEvents(sessionId: string, after?: EventId): Promise<{
+        events: SessionEvent[];
+    }>;
+    reset(sessionId: string): Promise<{
+        session: ProtocolSession;
+    }>;
+    shutdown(): Promise<ShutdownServerResponse>;
+    submitMessage(sessionId: string, request: SubmitMessageRequest): Promise<SubmitMessageResponse>;
+    watchSessionEvents(options: WatchSessionEventsOptions): Promise<void>;
+}
+//# sourceMappingURL=ProtocolHttpClient.d.ts.map

package/dist/client/ProtocolHttpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolHttpClient.d.ts","sourceRoot":"","sources":["../../sources/client/ProtocolHttpClient.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACR,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,OAAO,EACP,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,YAAY,EACZ,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACxB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,yBAAyB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB;IACtC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AAED,qBAAa,kBAAkB;;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,OAAO,EAAE,yBAAyB;IAK9C,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAInD,WAAW,CACP,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,kBAAkB,GAC5B,OAAO,CAAC;QAAE,OAAO,EAAE,eAAe,CAAA;KAAE,CAAC;IAQxC,YAAY,CACR,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,mBAAmB,GAC7B,OAAO,CAAC;QAAE,OAAO,EAAE,eAAe,CAAA;KAAE,CAAC;IAQxC,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAI5E,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC;IAIjC,MAAM,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAIrC,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAM3D,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIhE,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,eAAe,CAAA;KAAE,CAAC;IAIpE,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,YAAY,EAAE,CAAA;KAAE,CAAC;IAQlF,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,eAAe,CAAA;KAAE,CAAC;IAI/D,QAAQ,IAAI,OAAO,CAAC,sBAAsB,CAAC;IAI3C,aAAa,CACT,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,oBAAoB,GAC9B,OAAO,CAAC,qBAAqB,CAAC;IAQ3B,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CAsH9E"}