@abot-ai/runtime 1.2.0 → 1.3.1

package/dist/src/web-ui/local-runtime/environment-registry.js

@@ -1,13 +1,17 @@
-import { createRuntimeApplication } from "../../runtime/composition.js";
+import { createLocalRuntimeApplication, } from "../../runtime/local-application.js";
 import { loadRuntimeConfig } from "../../runtime/config.js";
 import { inspectRuntimeConfigFileWithMeta } from "../../runtime/config/loader.js";
 import { loadRuntimeModelCatalog } from "../../runtime/model/model-catalog.js";
 import { inspectRuntimeSetupRequirement } from "./runtime-availability.js";
 export class RuntimeEnvironmentRegistry {
     options;
+    schedulerBindings;
     environments = new Map();
-    constructor(options) {
+    stopped = false;
+    stopping;
+    constructor(options, schedulerBindings = {}) {
         this.options = options;
+        this.schedulerBindings = schedulerBindings;
     }
     modelCatalog(environmentId) {
         const source = inspectRuntimeConfigFileWithMeta(this.options.rootDir ?? process.cwd(), this.options.configPath ?? process.env.LLM_RUNTIME_CONFIG_FILE);
@@ -26,15 +30,46 @@ export class RuntimeEnvironmentRegistry {
         return availability.status === "setup_required" ? availability : null;
     }
     get(environmentId) {
+        this.requireEnvironmentIntakeOpen();
         const normalized = environmentId || this.options.defaultEnvironmentId;
         const existing = this.environments.get(normalized);
         if (existing)
             return existing;
         const config = this.loadConfig(normalized);
-        const environment = createRuntimeApplication(config);
+        const environment = createLocalRuntimeApplication(config, {
+            scheduledRequestOptions: this.schedulerBindings.requestOptions,
+        });
+        if (this.schedulerBindings.publish) {
+            environment.subscribeScheduledEvents(this.schedulerBindings.publish);
+        }
         this.environments.set(normalized, environment);
         return environment;
     }
+    async start(environmentIds) {
+        this.requireEnvironmentIntakeOpen();
+        await Promise.all(environmentIds.map((id) => this.startEnvironment(id)));
+    }
+    async startEnvironment(id) {
+        try {
+            if (this.setupRequirement(id))
+                return;
+            await this.get(id).start();
+        }
+        catch (error) {
+            console.error(`Scheduler unavailable for environment ${id}:`, error);
+        }
+    }
+    stop() {
+        if (this.stopping)
+            return this.stopping;
+        this.stopped = true;
+        this.stopping = Promise.all([...this.environments.values()].map(async (environment) => environment.stop())).then(() => undefined);
+        return this.stopping;
+    }
+    requireEnvironmentIntakeOpen() {
+        if (this.stopped)
+            throw new Error("web_runtime_stopped");
+    }
     profileEnv(environmentId) {
         return {
             ...process.env,

package/dist/src/web-ui/local-runtime/realtime-controller.js

@@ -32,7 +32,7 @@ export class LocalRealtimeController {
             return;
         }
         if (message.type === "steer_request") {
-            this.clients.send(client, this.requests.handleSteer(message));
+            this.clients.send(client, await this.requests.handleSteer(message, (id) => this.environments.get(id)));
             return;
         }
         if (message.type !== "resume_request")
@@ -53,6 +53,7 @@ export class LocalRealtimeController {
             this.clients.send(client, {
                 type: "completed",
                 requestId,
+                sessionId: replay.sessionId,
                 environment: environmentId,
                 output: replay.finalState.output,
             });
@@ -61,6 +62,7 @@ export class LocalRealtimeController {
             this.clients.send(client, {
                 type: "failed",
                 requestId,
+                sessionId: replay.sessionId,
                 environment: environmentId,
                 error: replay.finalState.error,
             });

package/dist/src/web-ui/local-runtime/request-execution.d.ts

@@ -1,4 +1,6 @@
 import type { ServerResponse } from "node:http";
+import type { SchedulerRun } from "../../runtime/scheduler/contracts.js";
+import type { RuntimeRequestOptions } from "../../runtime/composition.js";
 import type { JsonObject, RuntimeEnvironment } from "./contracts.js";
 import { RealtimeClientHub } from "./realtime-hub.js";
 export declare class LocalRequestExecution {
@@ -6,10 +8,12 @@ export declare class LocalRequestExecution {
     private readonly activeRequests;
     private readonly pendingToolApprovals;
     constructor(realtime: RealtimeClientHub);
+    scheduledRequestOptions(run: SchedulerRun): RuntimeRequestOptions;
+    publishScheduled(payload: JsonObject): void;
     start(res: ServerResponse, body: JsonObject, environmentId: string, environment: RuntimeEnvironment): Promise<void>;
     activeReplay(requestId: string, afterSeq: number): JsonObject | undefined;
     healthDetails(): JsonObject[];
-    handleSteer(message: JsonObject): JsonObject;
+    handleSteer(message: JsonObject, resolveEnvironment: (id: string) => RuntimeEnvironment): Promise<JsonObject>;
     resolveToolApproval(message: JsonObject): void;
     private run;
     private createToolApprovalController;

package/dist/src/web-ui/local-runtime/request-execution.js

@@ -11,6 +11,37 @@ export class LocalRequestExecution {
     constructor(realtime) {
         this.realtime = realtime;
     }
+    scheduledRequestOptions(run) {
+        const requestSteering = createRequestSteeringInbox({
+            requestId: run.requestId,
+        });
+        this.activeRequests.set(run.requestId, {
+            requestId: run.requestId,
+            sessionId: run.sessionId,
+            environmentId: run.environmentId,
+            startedAt: Date.now(),
+            lastEventAt: Date.now(),
+            lastEventName: "request.started",
+            events: [],
+            finalState: null,
+            requestSteering,
+        });
+        return {
+            toolApprovalController: this.createToolApprovalController(),
+            requestSteering,
+        };
+    }
+    publishScheduled(payload) {
+        const isTerminal = payload.type === "completed" || payload.type === "failed";
+        const outbound = isTerminal
+            ? { ...payload, requestOrigin: "schedule" }
+            : payload;
+        if (payload.sessionDeleted !== true)
+            this.publish(outbound);
+        if (isTerminal) {
+            this.activeRequests.delete(getString(payload.requestId));
+        }
+    }
     async start(res, body, environmentId, environment) {
         const text = getString(body.text).trim();
         const sessionId = getString(body.sessionId).trim();
@@ -79,12 +110,17 @@ export class LocalRequestExecution {
             idleMs: Date.now() - request.lastEventAt,
         }));
     }
-    handleSteer(message) {
+    async handleSteer(message, resolveEnvironment) {
         const requestId = getString(message.requestId).trim();
         const steerId = getString(message.steerId).trim();
         const text = getString(message.text).trim();
         const active = requestId ? this.activeRequests.get(requestId) : undefined;
-        const result = active?.requestSteering.append({ steerId, text }) ??
+        const steer = active
+            ? resolveEnvironment(active.environmentId).requests.steer
+            : undefined;
+        const result = (steer
+            ? await steer(requestId, { steerId, text })
+            : active?.requestSteering.append({ steerId, text })) ??
             { ok: false, reason: "request_not_active" };
         return result.ok
             ? {

package/dist/src/web-ui/local-runtime/schedule-job-creation.d.ts

@@ -0,0 +1,7 @@
+import type { SessionStore } from "../../runtime/ports.js";
+import type { SchedulerService } from "../../runtime/scheduler/contracts.js";
+import type { JsonObject } from "./contracts.js";
+export type ScheduleConversationStore = Pick<SessionStore, "getOrCreateSession" | "getSessionById" | "updateSessionTitle" | "deleteSession">;
+type ScheduleCreationService = Pick<SchedulerService, "create" | "list">;
+export declare function createWebScheduleJob(service: ScheduleCreationService, sessions: ScheduleConversationStore | undefined, body: JsonObject | null): Promise<import("../../runtime/scheduler/contracts.js").SchedulerJob>;
+export {};

package/dist/src/web-ui/local-runtime/schedule-job-creation.js

@@ -0,0 +1,62 @@
+import { randomUUID } from "node:crypto";
+import { validateSchedulerJobInput } from "../../runtime/scheduler/schedule-validation.js";
+function requestsDedicatedConversation(body) {
+    if (body?.newConversation === undefined)
+        return false;
+    if (body.newConversation === false)
+        return false;
+    if (body.newConversation !== true)
+        throw new Error("scheduler_invalid_job: newConversation must be a boolean.");
+    if (body.sessionId !== undefined)
+        throw new Error("scheduler_invalid_job: Choose a new or existing conversation.");
+    return true;
+}
+function isEmptyScheduleConversation(session) {
+    if (session.messageCount !== 0)
+        return false;
+    if (session.messages.length > 0)
+        return false;
+    if (session.requests?.length)
+        return false;
+    return true;
+}
+async function removeUnlinkedScheduleConversation(service, sessions, sessionId) {
+    try {
+        const jobs = await service.list({ sessionId });
+        if (jobs.length > 0)
+            return false;
+        const session = await sessions.getSessionById(sessionId);
+        if (!session)
+            return true;
+        if (!isEmptyScheduleConversation(session))
+            return false;
+        return await sessions.deleteSession(sessionId);
+    }
+    catch {
+        // A failed lookup cannot prove that the save failed or the session is unused.
+        return false;
+    }
+}
+export async function createWebScheduleJob(service, sessions, body) {
+    if (!requestsDedicatedConversation(body))
+        return service.create(body);
+    if (!sessions)
+        throw new Error("scheduler_unavailable: Conversation storage is unavailable.");
+    const { newConversation: _newConversation, sessionId: _sessionId, ...fields } = body;
+    const sessionId = `job-${randomUUID()}`;
+    const input = { ...fields, sessionId };
+    validateSchedulerJobInput(input);
+    try {
+        await sessions.getOrCreateSession(sessionId);
+        const session = await sessions.updateSessionTitle(sessionId, input.title);
+        if (!session)
+            throw new Error("scheduler_session_not_found");
+        return await service.create(input);
+    }
+    catch (error) {
+        if (await removeUnlinkedScheduleConversation(service, sessions, sessionId))
+            throw error;
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not confirm the Job save: ${detail}. The conversation was kept; check Jobs before saving again.`, { cause: error });
+    }
+}

package/dist/src/web-ui/local-runtime/schedule-management-routes.d.ts

@@ -0,0 +1,30 @@
+import type { ServerResponse } from "node:http";
+import type { RuntimeConfig } from "../../runtime/ports.js";
+import type { SchedulerService } from "../../runtime/scheduler/contracts.js";
+import type { JsonObject } from "./contracts.js";
+import { type ScheduleConversationStore } from "./schedule-job-creation.js";
+type ScheduleRouteRequest = {
+    method: string;
+    segments: readonly string[];
+    url: URL;
+    body: JsonObject | null;
+    environmentId: string;
+    response: ServerResponse;
+};
+type ScheduleEnvironment = {
+    start(): Promise<void>;
+    services: {
+        config: RuntimeConfig;
+        scheduler?: Omit<SchedulerService, "start" | "stop">;
+        sessions?: ScheduleConversationStore;
+    };
+};
+export declare class ScheduleManagementRoutes {
+    private readonly resolveEnvironment;
+    constructor(resolveEnvironment: (id: string) => ScheduleEnvironment);
+    handle(request: ScheduleRouteRequest): Promise<boolean>;
+    private handleScheduleRoute;
+    private handleRunCollection;
+    private handleCollection;
+}
+export {};

package/dist/src/web-ui/local-runtime/schedule-management-routes.js

@@ -0,0 +1,134 @@
+import { requireAvailableScheduleModel } from "../../runtime/capabilities/scheduling/model-validation.js";
+import { sendJson } from "./http.js";
+import { readScheduleRunPage } from "./schedule-run-page.js";
+import { createWebScheduleJob, } from "./schedule-job-creation.js";
+function isScheduleRunCollection(segments) {
+    if (segments.length !== 2)
+        return false;
+    return segments[1] === "runs";
+}
+function sendScheduleError(response, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof Error && "code" in error ? String(error.code) : message;
+    const isMissingRecord = code.includes("not_found");
+    const isUnavailable = code === "scheduler_store_in_use" || code === "scheduler_stopped";
+    if (isMissingRecord) {
+        sendJson(response, 404, { ok: false, error: code, message });
+        return;
+    }
+    if (isUnavailable) {
+        sendJson(response, 409, { ok: false, error: code, message });
+        return;
+    }
+    sendJson(response, 400, { ok: false, error: code, message });
+}
+export class ScheduleManagementRoutes {
+    resolveEnvironment;
+    constructor(resolveEnvironment) {
+        this.resolveEnvironment = resolveEnvironment;
+    }
+    async handle(request) {
+        if (request.segments[0] !== "schedules")
+            return false;
+        try {
+            const environment = this.resolveEnvironment(request.environmentId);
+            await environment.start();
+            const service = environment.services.scheduler;
+            if (!service)
+                throw new Error("scheduler_unavailable");
+            await this.handleScheduleRoute(request, environment, service);
+        }
+        catch (error) {
+            sendScheduleError(request.response, error);
+        }
+        return true;
+    }
+    async handleScheduleRoute(request, environment, service) {
+        const [, id, action] = request.segments;
+        const { response, method, body } = request;
+        if (!id) {
+            await this.handleCollection(request, environment, service);
+            return;
+        }
+        if (request.segments.length > 3) {
+            sendJson(response, 404, { ok: false, error: "not_found" });
+            return;
+        }
+        if (isScheduleRunCollection(request.segments)) {
+            await this.handleRunCollection(request, service);
+            return;
+        }
+        const job = await service.get(id);
+        if (!job)
+            throw new Error("scheduler_job_not_found");
+        if (method === "GET" && !action) {
+            sendJson(response, 200, { ok: true, job });
+            return;
+        }
+        if (method === "GET" && action === "runs") {
+            const page = await readScheduleRunPage(service, id, request.url.searchParams);
+            sendJson(response, 200, { ok: true, ...page });
+            return;
+        }
+        if (method === "PATCH" && !action) {
+            if (body?.modelProfileId !== undefined)
+                requireAvailableScheduleModel(environment.services.config, body.modelProfileId);
+            sendJson(response, 200, {
+                ok: true,
+                job: await service.update(id, (body ?? {})),
+            });
+            return;
+        }
+        if (method === "POST" && action === "run-now") {
+            sendJson(response, 200, { ok: true, run: await service.runNow(id) });
+            return;
+        }
+        if (method === "POST" && action === "pause") {
+            sendJson(response, 200, { ok: true, job: await service.pause(id) });
+            return;
+        }
+        if (method === "POST" && action === "resume") {
+            sendJson(response, 200, { ok: true, job: await service.resume(id) });
+            return;
+        }
+        if (method === "POST" && action === "cancel") {
+            sendJson(response, 200, { ok: true, job: await service.cancel(id) });
+            return;
+        }
+        response.setHeader("allow", action ? "GET, POST" : "GET, PATCH");
+        sendJson(response, 405, { ok: false, error: "method_not_allowed" });
+    }
+    async handleRunCollection(request, service) {
+        if (request.method !== "GET") {
+            request.response.setHeader("allow", "GET");
+            sendJson(request.response, 405, {
+                ok: false,
+                error: "method_not_allowed",
+            });
+            return;
+        }
+        const page = await readScheduleRunPage(service, undefined, request.url.searchParams);
+        sendJson(request.response, 200, { ok: true, ...page });
+    }
+    async handleCollection(request, environment, service) {
+        if (request.method === "GET") {
+            const sessionId = request.url.searchParams.get("sessionId") || undefined;
+            const search = request.url.searchParams.get("search") || undefined;
+            const state = request.url.searchParams.get("state");
+            const jobs = await service.list({ sessionId, search });
+            sendJson(request.response, 200, {
+                ok: true,
+                jobs: state ? jobs.filter((job) => job.state === state) : jobs,
+            });
+            return;
+        }
+        if (request.method === "POST") {
+            requireAvailableScheduleModel(environment.services.config, request.body?.modelProfileId);
+            const job = await createWebScheduleJob(service, environment.services.sessions, request.body);
+            sendJson(request.response, 201, { ok: true, job });
+            return;
+        }
+        request.response.setHeader("allow", "GET, POST");
+        sendJson(request.response, 405, { ok: false, error: "method_not_allowed" });
+    }
+}

package/dist/src/web-ui/local-runtime/schedule-run-page.d.ts

@@ -0,0 +1,5 @@
+import type { SchedulerService } from "../../runtime/scheduler/contracts.js";
+export declare function readScheduleRunPage(service: Pick<SchedulerService, "listRuns">, jobId: string | undefined, params: URLSearchParams): Promise<{
+    runs: import("../../runtime/scheduler/contracts.js").SchedulerRun[];
+    nextCursor: string | null;
+}>;

package/dist/src/web-ui/local-runtime/schedule-run-page.js

@@ -0,0 +1,23 @@
+export async function readScheduleRunPage(service, jobId, params) {
+    const limit = requireWebRunPageLimit(params.get("limit"));
+    const cursor = params.get("cursor") ?? undefined;
+    // Bound the owner response before it crosses the shared Runtime transport.
+    const page = await service.listRuns(jobId, { cursor, limit: limit + 1 });
+    const runs = page.slice(0, limit);
+    return {
+        runs,
+        nextCursor: page.length > limit ? runs.at(-1).id : null,
+    };
+}
+function requireWebRunPageLimit(value) {
+    if (value === null)
+        return 50;
+    const limit = Number(value);
+    if (!Number.isSafeInteger(limit))
+        throw new Error("scheduler_run_page_limit_invalid");
+    if (limit < 1)
+        throw new Error("scheduler_run_page_limit_invalid");
+    if (limit > 100)
+        throw new Error("scheduler_run_page_limit_invalid");
+    return limit;
+}

package/dist/src/web-ui/local-runtime/session-routes.d.ts

@@ -0,0 +1,17 @@
+import type { ServerResponse } from "node:http";
+import type { RuntimeEnvironment, JsonObject } from "./contracts.js";
+import { WebSessionReadStates } from "../session-read-state/service.js";
+type SessionRouteRequest = {
+    method: string;
+    segments: string[];
+    body: JsonObject | null;
+    environmentId: string;
+    environment: RuntimeEnvironment;
+    response: ServerResponse;
+};
+export declare class WebSessionRoutes {
+    private readonly readStates;
+    constructor(readStates: WebSessionReadStates);
+    handle(request: SessionRouteRequest): Promise<boolean>;
+}
+export {};

package/dist/src/web-ui/local-runtime/session-routes.js

@@ -0,0 +1,74 @@
+import { deleteSessionWithAttachments } from "../../runtime/session/session-attachment-deletion.js";
+import { deleteSessionAttachmentsIfSupported } from "./attachment-routes.js";
+import { sendJson } from "./http.js";
+export class WebSessionRoutes {
+    readStates;
+    constructor(readStates) {
+        this.readStates = readStates;
+    }
+    async handle(request) {
+        const { method, segments, body, environmentId, environment, response } = request;
+        if (segments[0] !== "chat" || segments[1] !== "sessions")
+            return false;
+        const [, , sessionId, action] = segments;
+        if (segments.length > 4)
+            return false;
+        if (method === "GET" && segments.length === 2) {
+            sendJson(response, 200, {
+                ok: true,
+                ...(await this.readStates.list(environmentId)),
+            });
+            return true;
+        }
+        if (!sessionId)
+            return false;
+        const sessions = environment.services.sessions;
+        if (method === "GET" && action === "messages") {
+            const snapshot = await sessions.getSessionSnapshot(sessionId, {
+                includeRequests: true,
+            });
+            if (!snapshot) {
+                sendJson(response, 404, {
+                    ok: false,
+                    error: "session_not_found",
+                    messages: [],
+                    requests: [],
+                });
+                return true;
+            }
+            sendJson(response, 200, {
+                ok: true,
+                ...snapshot,
+                readState: await this.readStates.project(environmentId, snapshot),
+            });
+            return true;
+        }
+        if (method === "POST" && action === "read") {
+            const readState = await this.readStates.mark(environmentId, sessionId, body ?? {});
+            if (!readState) {
+                sendJson(response, 404, { ok: false, error: "session_not_found" });
+                return true;
+            }
+            sendJson(response, 200, { ok: true, readState });
+            return true;
+        }
+        if (method === "DELETE" && action === "messages") {
+            const result = await sessions.clearSessionMessages(sessionId);
+            if (!result) {
+                sendJson(response, 404, { ok: false, error: "session_not_found" });
+                return true;
+            }
+            await this.readStates.reset(environmentId, sessionId);
+            await deleteSessionAttachmentsIfSupported(environment, sessionId);
+            sendJson(response, 200, { ok: true, ...result });
+            return true;
+        }
+        if (method === "DELETE" && !action) {
+            const result = await deleteSessionWithAttachments(sessions, environment.services.attachments, sessionId);
+            await this.readStates.forget(environmentId, sessionId);
+            sendJson(response, 200, { ok: true, ...result });
+            return true;
+        }
+        return false;
+    }
+}

package/dist/src/web-ui/local-runtime-backend.d.ts

@@ -11,4 +11,6 @@ export declare class LocalRuntimeWebBackend {
     constructor(options: LocalRuntimeBackendOptions);
     handleHttp(req: IncomingMessage, res: ServerResponse, pathname: string): Promise<boolean>;
     handleRealtimeConnection(client: WebSocket): void;
+    start(environmentIds: readonly string[]): Promise<void>;
+    stop(): Promise<void>;
 }

package/dist/src/web-ui/local-runtime-backend.js

@@ -19,9 +19,12 @@ export class LocalRuntimeWebBackend {
                 providerAdapters: options.providerAdapters,
             }),
         };
-        this.environments = new RuntimeEnvironmentRegistry(resolvedOptions);
         const clients = new RealtimeClientHub();
         const requests = new LocalRequestExecution(clients);
+        this.environments = new RuntimeEnvironmentRegistry(resolvedOptions, {
+            requestOptions: (run) => requests.scheduledRequestOptions(run),
+            publish: (event) => requests.publishScheduled(event),
+        });
         this.api = new LocalRuntimeApiRouter(resolvedOptions, this.environments, requests);
         this.realtime = new LocalRealtimeController(resolvedOptions, this.environments, requests, clients);
         this.controls = new LocalRuntimeControlRoutes(requests);
@@ -64,4 +67,11 @@ export class LocalRuntimeWebBackend {
     handleRealtimeConnection(client) {
         this.realtime.connect(client);
     }
+    async start(environmentIds) {
+        await this.api.initializeSessionReadState(environmentIds);
+        await this.environments.start(environmentIds);
+    }
+    stop() {
+        return this.environments.stop();
+    }
 }

package/dist/src/web-ui/schedule-creation-contract.d.ts

@@ -0,0 +1,7 @@
+import type { CreateSchedulerJobInput } from "../runtime/scheduler/contracts.js";
+export type CreateWebScheduleJobInput = (CreateSchedulerJobInput & {
+    newConversation?: false;
+}) | (Omit<CreateSchedulerJobInput, "sessionId"> & {
+    newConversation: true;
+    sessionId?: never;
+});

package/dist/src/web-ui/schedule-creation-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/src/web-ui/server-shutdown.d.ts

@@ -0,0 +1,4 @@
+import type { Server } from "node:http";
+import type { WebSocketServer } from "ws";
+/** Fence transport and environment intake before waiting for startup or stop. */
+export declare function createWebUiShutdown(server: Server, webSockets: WebSocketServer, startup: Promise<void> | undefined, stopBackend: () => Promise<void> | undefined, listenAbort: AbortController): () => Promise<void>;

package/dist/src/web-ui/server-shutdown.js

@@ -0,0 +1,32 @@
+import { closeHttpServerImmediately } from "../shared/http-server-shutdown.js";
+/** Fence transport and environment intake before waiting for startup or stop. */
+export function createWebUiShutdown(server, webSockets, startup, stopBackend, listenAbort) {
+    let closing;
+    return () => {
+        if (closing)
+            return closing;
+        const wasListening = server.listening;
+        const transport = closeHttpServerImmediately(server, webSockets).catch((error) => {
+            if (isPendingListenAlreadyClosed(error, wasListening))
+                return;
+            throw error;
+        });
+        listenAbort.abort();
+        const backend = (async () => {
+            await stopBackend();
+        })();
+        closing = Promise.allSettled([transport, startup, backend]).then((results) => {
+            // Preserve transport-close error precedence, then original startup error.
+            for (const result of results) {
+                if (result.status === "rejected")
+                    throw result.reason;
+            }
+        });
+        return closing;
+    };
+}
+function isPendingListenAlreadyClosed(error, wasListening) {
+    if (wasListening)
+        return false;
+    return error.code === "ERR_SERVER_NOT_RUNNING";
+}