codex-chatgpt-control 0.1.0-alpha.1

package/dist/src/backend/client.d.ts

@@ -0,0 +1,129 @@
+import type { AskAndDownloadWorkflowArgs, AskInThreadWorkflowArgs, AskWithFilesWorkflowArgs, AskWorkflowArgs, NamedWorkflowInvocation, RunMessagesArgs, WorkflowThread } from "../client.js";
+import type { DoctorArgs, DoctorReport } from "../commands/doctor.js";
+import type { RunReportData, RunReportOptions } from "../commands/reports.js";
+import type { CommandDescriptor } from "../commands/registry.js";
+import type { ChatGPTResponsesCreateArgs } from "../runner/responses.js";
+import type { ChatGPTRunStream } from "../runner/stream.js";
+import type { ChatGPTAgent, ChatGPTAgentConfig, ChatGPTResponse, ChatGPTRunInput, ChatGPTRunResult } from "../runner/types.js";
+import type { ReportRedactionOptions } from "../safety/report-redaction.js";
+import type { BootstrapArgs, CommandResult, CopyResponseArgs, DownloadLatestArgs, NewThreadArgs, OpenThreadArgs, ReadLatestArgs, SearchThreadsArgs, SelectToolArgs, SequencePlan, SetModeArgs, WaitArgs } from "../types.js";
+import { type BackendEvent, type BackendRequest, type BackendResponse } from "./protocol.js";
+export type BackendTransport = {
+    request(request: BackendRequest): Promise<BackendResponse>;
+    stream(request: BackendRequest): AsyncIterable<BackendEvent>;
+    close?: () => Promise<void> | void;
+};
+export declare class BackendClientError extends Error {
+    readonly code: string;
+    readonly recoverable: boolean;
+    constructor(code: string, message: string, recoverable: boolean);
+}
+export type ChatGPTBackendRunner = {
+    run<TOutput = string>(agent: ChatGPTAgent<TOutput>, input: ChatGPTRunInput): Promise<ChatGPTRunResult<TOutput>>;
+    plan<TOutput = string>(agent: ChatGPTAgent<TOutput>, input: ChatGPTRunInput): Promise<SequencePlan>;
+    stream<TOutput = string>(agent: ChatGPTAgent<TOutput>, input: ChatGPTRunInput): ChatGPTRunStream<TOutput>;
+};
+export type ChatGPTBackendClient = {
+    agent<TOutput = string>(config: ChatGPTAgentConfig<TOutput>): ChatGPTAgent<TOutput>;
+    run<TOutput = string>(agent: ChatGPTAgent<TOutput>, input: ChatGPTRunInput): Promise<ChatGPTRunResult<TOutput>>;
+    runner: ChatGPTBackendRunner;
+    responses: {
+        create(args: ChatGPTResponsesCreateArgs | Record<string, unknown>): Promise<ChatGPTResponse>;
+    };
+    commands(filter?: {
+        layer?: CommandDescriptor["layer"];
+    }): Promise<CommandDescriptor[]>;
+    describe(name: string): Promise<CommandDescriptor | undefined>;
+    help(topic?: string): Promise<string>;
+    ask(args: AskWorkflowArgs): Promise<CommandResult<unknown>>;
+    askInThread(args: AskInThreadWorkflowArgs): Promise<CommandResult<unknown>>;
+    askWithFiles(args: AskWithFilesWorkflowArgs): Promise<CommandResult<unknown>>;
+    askAndDownload(args: AskAndDownloadWorkflowArgs): Promise<CommandResult<unknown>>;
+    runMessages(args: RunMessagesArgs): Promise<CommandResult<unknown>>;
+    openThread(thread: WorkflowThread): Promise<CommandResult<unknown>>;
+    readLatest(args?: ReadLatestArgs): Promise<CommandResult<unknown>>;
+    copyLatest(args?: CopyResponseArgs): Promise<CommandResult<unknown>>;
+    downloadLatest(args: DownloadLatestArgs): Promise<CommandResult<unknown>>;
+    runPlan(plan: SequencePlan | NamedWorkflowInvocation): Promise<CommandResult<unknown>>;
+    doctor(args?: DoctorArgs): Promise<CommandResult<DoctorReport>>;
+    createReport(result: CommandResult<unknown>, args?: RunReportOptions): Promise<CommandResult<RunReportData>>;
+    reports: {
+        create(result: CommandResult<unknown>, args?: RunReportOptions): Promise<CommandResult<RunReportData>>;
+        redact(value: unknown, args?: ReportRedactionOptions): Promise<CommandResult<unknown>>;
+        summarize(result: CommandResult<unknown>, args?: ReportRedactionOptions): Promise<CommandResult<unknown>>;
+    };
+    session: {
+        bootstrap(args?: BootstrapArgs): Promise<CommandResult<unknown>>;
+    };
+    threads: {
+        "new"(args?: NewThreadArgs): Promise<CommandResult<unknown>>;
+        search(args: SearchThreadsArgs): Promise<CommandResult<unknown>>;
+        open(args: OpenThreadArgs): Promise<CommandResult<unknown>>;
+    };
+    messages: {
+        compose(args: {
+            text: string;
+            mode?: "replace" | "append";
+            timeoutMs?: number;
+        }): Promise<CommandResult<unknown>>;
+        submit(args?: {
+            text?: string;
+            previousTurnCount?: number;
+            timeoutMs?: number;
+        }): Promise<CommandResult<unknown>>;
+        ask(args: {
+            text: string;
+            wait?: boolean | WaitArgs;
+            read?: boolean | ReadLatestArgs;
+            timeoutMs?: number;
+        }): Promise<CommandResult<unknown>>;
+        wait(args?: WaitArgs): Promise<CommandResult<unknown>>;
+        readLatest(args?: ReadLatestArgs): Promise<CommandResult<unknown>>;
+        waitAndRead(args?: WaitArgs & ReadLatestArgs): Promise<CommandResult<unknown>>;
+    };
+    files: {
+        attach(args: {
+            paths: string[];
+            timeoutMs?: number;
+        }): Promise<CommandResult<unknown>>;
+        downloadLatest(args: DownloadLatestArgs): Promise<CommandResult<unknown>>;
+    };
+    modes: {
+        set(args: SetModeArgs): Promise<CommandResult<unknown>>;
+    };
+    tools: {
+        select(args: SelectToolArgs): Promise<CommandResult<unknown>>;
+    };
+    response: {
+        copy(args?: CopyResponseArgs): Promise<CommandResult<unknown>>;
+    };
+    close(): Promise<void>;
+};
+export declare function createChatGPTBackendClient(transport: BackendTransport): ChatGPTBackendClient;
+export type StdioBackendTransportOptions = {
+    command: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+};
+export declare class StdioBackendTransport implements BackendTransport {
+    private readonly options;
+    private child;
+    private stdout;
+    private pendingResponses;
+    private pendingStreams;
+    private stderrText;
+    constructor(options: StdioBackendTransportOptions);
+    request(request: BackendRequest): Promise<BackendResponse>;
+    stream(request: BackendRequest): AsyncIterable<BackendEvent>;
+    close(): Promise<void>;
+    private start;
+    private write;
+    private handleLine;
+    private handleResponse;
+    private handleEvent;
+    private failAll;
+    private clearResponse;
+    private clearStream;
+    private createDeadline;
+}

package/dist/src/backend/client.js

@@ -0,0 +1,415 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { createChatGPTAgent } from "../runner/agent.js";
+import { BACKEND_REQUEST_SCHEMA_VERSION, BACKEND_RESPONSE_SCHEMA_VERSION, BACKEND_EVENT_SCHEMA_VERSION } from "./protocol.js";
+export class BackendClientError extends Error {
+    code;
+    recoverable;
+    constructor(code, message, recoverable) {
+        super(message);
+        this.code = code;
+        this.recoverable = recoverable;
+        this.name = "BackendClientError";
+    }
+}
+export function createChatGPTBackendClient(transport) {
+    let nextRequestId = 0;
+    const request = async (command, payload = {}) => {
+        const response = await transport.request({
+            schemaVersion: BACKEND_REQUEST_SCHEMA_VERSION,
+            requestId: `req_${++nextRequestId}`,
+            command,
+            payload
+        });
+        return unwrapResponse(response);
+    };
+    const runner = {
+        run: (agent, input) => request("runner.run", { agent, input }),
+        plan: (agent, input) => request("runner.plan", { agent, input }),
+        stream: (agent, input) => streamFromBackendEvents(transport.stream({
+            schemaVersion: BACKEND_REQUEST_SCHEMA_VERSION,
+            requestId: `req_${++nextRequestId}`,
+            command: "runner.stream",
+            payload: { agent, input }
+        }))
+    };
+    return {
+        agent: config => createChatGPTAgent(config),
+        run: runner.run,
+        runner,
+        responses: {
+            create: args => request("responses.create", args)
+        },
+        commands: filter => request("commands", filter === undefined ? {} : { filter }),
+        describe: name => request("describe", { name }),
+        help: topic => request("help", topic === undefined ? {} : { topic }),
+        ask: args => request("ask", args),
+        askInThread: args => request("askInThread", args),
+        askWithFiles: args => request("askWithFiles", args),
+        askAndDownload: args => request("askAndDownload", args),
+        runMessages: args => request("runMessages", args),
+        openThread: thread => request("openThread", thread),
+        readLatest: args => request("readLatest", args ?? {}),
+        copyLatest: args => request("copyLatest", args ?? {}),
+        downloadLatest: args => request("downloadLatest", args),
+        runPlan: plan => request("runPlan", plan),
+        doctor: args => request("doctor", args ?? {}),
+        createReport: (result, args) => request("createReport", args === undefined ? { result } : { result, args }),
+        reports: {
+            create: (result, args) => request("reports.create", args === undefined ? { result } : { result, args }),
+            redact: (value, args) => request("reports.redact", args === undefined ? { value } : { value, args }),
+            summarize: (result, args) => request("reports.summarize", args === undefined ? { result } : { result, args })
+        },
+        session: {
+            bootstrap: args => request("session.bootstrap", args ?? {})
+        },
+        threads: {
+            new: args => request("threads.new", args ?? {}),
+            search: args => request("threads.search", args),
+            open: args => request("threads.open", args)
+        },
+        messages: {
+            compose: args => request("messages.compose", args),
+            submit: args => request("messages.submit", args ?? {}),
+            ask: args => request("messages.ask", args),
+            wait: args => request("messages.wait", args ?? {}),
+            readLatest: args => request("messages.readLatest", args ?? {}),
+            waitAndRead: args => request("messages.waitAndRead", args)
+        },
+        files: {
+            attach: args => request("files.attach", args),
+            downloadLatest: args => request("files.downloadLatest", args)
+        },
+        modes: {
+            set: args => request("modes.set", args)
+        },
+        tools: {
+            select: args => request("tools.select", args)
+        },
+        response: {
+            copy: args => request("response.copy", args ?? {})
+        },
+        close: async () => {
+            await transport.close?.();
+        }
+    };
+}
+const DEFAULT_BACKEND_TIMEOUT_MS = 600_000;
+export class StdioBackendTransport {
+    options;
+    child;
+    stdout;
+    pendingResponses = new Map();
+    pendingStreams = new Map();
+    stderrText = "";
+    constructor(options) {
+        this.options = options;
+    }
+    async request(request) {
+        const requestId = requireRequestId(request);
+        this.start();
+        return new Promise((resolve, reject) => {
+            const timeout = this.createDeadline(requestId);
+            this.pendingResponses.set(requestId, { resolve, reject, timeout });
+            this.write(request, error => {
+                this.clearResponse(requestId);
+                reject(error);
+            });
+        });
+    }
+    stream(request) {
+        const requestId = requireRequestId(request);
+        this.start();
+        const queue = new AsyncQueue();
+        const timeout = this.createDeadline(requestId);
+        this.pendingStreams.set(requestId, { queue, timeout });
+        this.write(request, error => {
+            this.clearStream(requestId);
+            queue.fail(error);
+        });
+        return queue;
+    }
+    async close() {
+        const child = this.child;
+        if (child === undefined)
+            return;
+        this.child = undefined;
+        this.stdout?.close();
+        this.stdout = undefined;
+        child.removeAllListeners("error");
+        child.removeAllListeners("exit");
+        child.kill();
+        this.failAll(new BackendClientError("backend_closed", "Backend transport was closed.", true));
+    }
+    start() {
+        if (this.child !== undefined)
+            return;
+        const [command, ...args] = this.options.command;
+        if (command === undefined) {
+            throw new BackendClientError("invalid_backend_command", "Stdio backend command must not be empty.", false);
+        }
+        const child = spawn(command, args, {
+            cwd: this.options.cwd,
+            env: this.options.env,
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        this.child = child;
+        this.stdout = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        this.stdout.on("line", line => {
+            if (this.child !== child)
+                return;
+            this.handleLine(line);
+        });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", chunk => {
+            if (this.child !== child)
+                return;
+            this.stderrText = `${this.stderrText}${String(chunk)}`.slice(-4000);
+        });
+        child.on("error", error => {
+            if (this.child !== child)
+                return;
+            this.child = undefined;
+            this.stdout?.close();
+            this.stdout = undefined;
+            this.failAll(error);
+        });
+        child.on("exit", (code, signal) => {
+            if (this.child !== child)
+                return;
+            const suffix = this.stderrText.length > 0 ? ` stderr=${this.stderrText}` : "";
+            this.child = undefined;
+            this.stdout?.close();
+            this.stdout = undefined;
+            this.failAll(new BackendClientError("backend_exited", `Backend process exited with code ${String(code)} signal ${String(signal)}.${suffix}`, true));
+        });
+    }
+    write(request, reject) {
+        const child = this.child;
+        if (child === undefined) {
+            reject(new BackendClientError("backend_not_started", "Backend process is not running.", true));
+            return;
+        }
+        child.stdin.write(`${JSON.stringify(request)}\n`, error => {
+            if (error !== null && error !== undefined)
+                reject(error);
+        });
+    }
+    handleLine(line) {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch (error) {
+            this.failAll(new BackendClientError("invalid_backend_json", error instanceof Error ? error.message : String(error), true));
+            return;
+        }
+        if (!isRecord(value)) {
+            this.failAll(new BackendClientError("invalid_backend_message", "Backend protocol line must be a JSON object.", true));
+            return;
+        }
+        if (value.schemaVersion === BACKEND_RESPONSE_SCHEMA_VERSION) {
+            this.handleResponse(value);
+            return;
+        }
+        if (value.schemaVersion === BACKEND_EVENT_SCHEMA_VERSION) {
+            this.handleEvent(value);
+            return;
+        }
+        this.failAll(new BackendClientError("unsupported_backend_schema", `Unsupported backend protocol schemaVersion: ${String(value.schemaVersion)}`, true));
+    }
+    handleResponse(response) {
+        const requestId = response.requestId;
+        if (requestId === undefined) {
+            this.failAll(new BackendClientError("missing_backend_request_id", "Backend response is missing requestId.", true));
+            return;
+        }
+        const pending = this.pendingResponses.get(requestId);
+        if (pending === undefined) {
+            const stream = this.pendingStreams.get(requestId);
+            if (stream !== undefined) {
+                stream.queue.fail(new BackendClientError("unexpected_backend_response", `Backend sent a response for streaming requestId ${requestId}.`, true));
+                this.clearStream(requestId);
+                return;
+            }
+            this.failAll(new BackendClientError("unknown_backend_request_id", `Backend response used unknown requestId ${requestId}.`, true));
+            return;
+        }
+        if (typeof response.ok !== "boolean") {
+            this.clearResponse(requestId);
+            pending.reject(new BackendClientError("invalid_backend_response", `Backend response for requestId ${requestId} is missing boolean ok.`, true));
+            return;
+        }
+        this.clearResponse(requestId);
+        pending.resolve(response);
+    }
+    handleEvent(event) {
+        const requestId = event.requestId;
+        if (requestId === undefined) {
+            this.failAll(new BackendClientError("missing_backend_request_id", "Backend event is missing requestId.", true));
+            return;
+        }
+        const pending = this.pendingStreams.get(requestId);
+        if (pending === undefined) {
+            const response = this.pendingResponses.get(requestId);
+            if (response !== undefined) {
+                this.clearResponse(requestId);
+                response.reject(new BackendClientError("unexpected_backend_event", `Backend sent an event for non-streaming requestId ${requestId}.`, true));
+                return;
+            }
+            this.failAll(new BackendClientError("unknown_backend_request_id", `Backend event used unknown requestId ${requestId}.`, true));
+            return;
+        }
+        if (typeof event.type !== "string") {
+            pending.queue.fail(new BackendClientError("invalid_backend_event", `Backend event for requestId ${requestId} is missing type.`, true));
+            this.clearStream(requestId);
+            return;
+        }
+        pending.queue.push(event);
+        if (event.type === "completed") {
+            pending.queue.finish();
+            this.clearStream(requestId);
+        }
+        if (event.type === "error") {
+            pending.queue.fail(new BackendClientError(event.error.code, event.error.message, event.error.recoverable));
+            this.clearStream(requestId);
+        }
+    }
+    failAll(error) {
+        for (const pending of this.pendingResponses.values()) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+        }
+        this.pendingResponses.clear();
+        for (const pending of this.pendingStreams.values()) {
+            clearTimeout(pending.timeout);
+            pending.queue.fail(error);
+        }
+        this.pendingStreams.clear();
+    }
+    clearResponse(requestId) {
+        const pending = this.pendingResponses.get(requestId);
+        if (pending !== undefined) {
+            clearTimeout(pending.timeout);
+            this.pendingResponses.delete(requestId);
+        }
+    }
+    clearStream(requestId) {
+        const pending = this.pendingStreams.get(requestId);
+        if (pending !== undefined) {
+            clearTimeout(pending.timeout);
+            this.pendingStreams.delete(requestId);
+        }
+    }
+    createDeadline(requestId) {
+        const timeoutMs = this.options.timeoutMs ?? DEFAULT_BACKEND_TIMEOUT_MS;
+        return setTimeout(() => {
+            const error = new BackendClientError("backend_timeout", `Backend request ${requestId} timed out after ${timeoutMs}ms.`, true);
+            const child = this.child;
+            this.child = undefined;
+            this.stdout?.close();
+            this.stdout = undefined;
+            if (child !== undefined) {
+                child.removeAllListeners("error");
+                child.removeAllListeners("exit");
+                child.kill();
+            }
+            this.failAll(error);
+        }, timeoutMs);
+    }
+}
+function unwrapResponse(response) {
+    if (response.ok)
+        return response.result;
+    throw new BackendClientError(response.error.code, response.error.message, response.error.recoverable);
+}
+function streamFromBackendEvents(events) {
+    const queue = new AsyncQueue();
+    let resolveCompleted;
+    let rejectCompleted;
+    const completed = new Promise((resolve, reject) => {
+        resolveCompleted = resolve;
+        rejectCompleted = reject;
+    });
+    void (async () => {
+        try {
+            for await (const event of events) {
+                if (event.type === "run_item_stream_event") {
+                    queue.push({
+                        type: "run_item_stream_event",
+                        name: event.name,
+                        item: event.item
+                    });
+                    continue;
+                }
+                if (event.type === "completed") {
+                    resolveCompleted(event.result);
+                    queue.finish();
+                    return;
+                }
+                if (event.type === "error") {
+                    throw new BackendClientError(event.error.code, event.error.message, event.error.recoverable);
+                }
+            }
+            throw new BackendClientError("stream_incomplete", "Backend stream ended before a completed event.", true);
+        }
+        catch (error) {
+            queue.fail(error);
+            rejectCompleted(error);
+        }
+    })();
+    return {
+        completed,
+        [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator]()
+    };
+}
+function requireRequestId(request) {
+    if (request.requestId === undefined) {
+        throw new BackendClientError("missing_request_id", "Backend transport requests require requestId.", false);
+    }
+    return request.requestId;
+}
+class AsyncQueue {
+    values = [];
+    waiters = [];
+    done = false;
+    error;
+    push(value) {
+        if (this.done || this.error !== undefined)
+            return;
+        this.values.push(value);
+        this.wake();
+    }
+    finish() {
+        this.done = true;
+        this.wake();
+    }
+    fail(error) {
+        this.error = error;
+        this.wake();
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            const value = this.values.shift();
+            if (value !== undefined) {
+                yield value;
+                continue;
+            }
+            if (this.error !== undefined)
+                throw this.error;
+            if (this.done)
+                return;
+            await new Promise(resolve => {
+                this.waiters.push(resolve);
+            });
+        }
+    }
+    wake() {
+        const waiters = this.waiters.splice(0);
+        for (const waiter of waiters)
+            waiter();
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/backend/protocol.d.ts

@@ -0,0 +1,74 @@
+export declare const BACKEND_REQUEST_SCHEMA_VERSION: "chatgpt.browser_control.backend_request.v1";
+export declare const BACKEND_RESPONSE_SCHEMA_VERSION: "chatgpt.browser_control.backend_response.v1";
+export declare const BACKEND_EVENT_SCHEMA_VERSION: "chatgpt.browser_control.backend_event.v1";
+export declare const backendCommands: readonly ["backend.version", "backend.health", "backend.capabilities", "runner.run", "runner.plan", "runner.stream", "responses.create", "ask", "askInThread", "askWithFiles", "askAndDownload", "runMessages", "openThread", "readLatest", "copyLatest", "downloadLatest", "runPlan", "doctor", "createReport", "reports.create", "reports.redact", "reports.summarize", "commands", "describe", "help", "session.bootstrap", "threads.new", "threads.search", "threads.open", "messages.compose", "messages.submit", "messages.ask", "messages.wait", "messages.readLatest", "messages.waitAndRead", "files.attach", "files.downloadLatest", "modes.set", "tools.select", "response.copy"];
+export type BackendCommand = typeof backendCommands[number];
+export type BackendRequest = {
+    schemaVersion: typeof BACKEND_REQUEST_SCHEMA_VERSION;
+    requestId?: string;
+    command: BackendCommand;
+    payload: Record<string, unknown>;
+};
+export type BackendProtocolErrorCode = "invalid_request" | "unsupported_schema_version" | "unknown_command";
+export declare class ProtocolError extends Error {
+    readonly code: BackendProtocolErrorCode;
+    readonly recoverable: boolean;
+    constructor(code: BackendProtocolErrorCode, message: string, recoverable: boolean);
+}
+export type BackendResponseOk<TResult = unknown> = {
+    schemaVersion: typeof BACKEND_RESPONSE_SCHEMA_VERSION;
+    requestId?: string;
+    ok: true;
+    result: TResult;
+};
+export type BackendResponseError = {
+    schemaVersion: typeof BACKEND_RESPONSE_SCHEMA_VERSION;
+    requestId?: string;
+    ok: false;
+    error: {
+        code: BackendProtocolErrorCode | string;
+        message: string;
+        recoverable: boolean;
+    };
+};
+export type BackendResponse<TResult = unknown> = BackendResponseOk<TResult> | BackendResponseError;
+export type BackendCapabilities = {
+    protocolVersion: typeof BACKEND_REQUEST_SCHEMA_VERSION;
+    commands: BackendCommand[];
+    transports: Array<"stdio" | "http">;
+    streaming: {
+        modes: Array<"ndjson" | "sse">;
+        tokenDeltas: false;
+    };
+};
+export type BackendRunItemStreamEvent = {
+    type: "run_item_stream_event";
+    name: string;
+    item: Record<string, unknown>;
+};
+export type BackendAgentUpdatedStreamEvent = {
+    type: "agent_updated_stream_event";
+    agent: Record<string, unknown>;
+};
+export type BackendCompletedEvent = {
+    type: "completed";
+    result: unknown;
+};
+export type BackendErrorEvent = {
+    type: "error";
+    error: {
+        code: string;
+        message: string;
+        recoverable: boolean;
+    };
+};
+export type BackendEventPayload = BackendRunItemStreamEvent | BackendAgentUpdatedStreamEvent | BackendCompletedEvent | BackendErrorEvent;
+export type BackendEvent = BackendEventPayload & {
+    schemaVersion: typeof BACKEND_EVENT_SCHEMA_VERSION;
+    requestId?: string;
+};
+export declare function parseBackendRequest(raw: unknown): BackendRequest;
+export declare function backendResponseOk<TResult>(requestId: string | undefined, result: TResult): BackendResponseOk<TResult>;
+export declare function backendResponseError(requestId: string | undefined, error: ProtocolError | Error): BackendResponseError;
+export declare function backendEvent(requestId: string | undefined, payload: BackendEventPayload): BackendEvent;
+export declare function backendEventCompleted(requestId: string | undefined, result: unknown): BackendEvent;