@abot-ai/runtime 1.0.0 → 1.1.0

package/dist/src/web-ui/app/styles/90-responsive.css

@@ -65,17 +65,31 @@
     padding: 20px 24px 48px;
   }
 
-  .config-dashboard-grid,
-  .config-loop-grid,
-  .config-steps-section .config-step-list,
-  .config-model-layout,
-  .config-field-grid,
-  .config-calibration-card .config-field-grid {
+  .config-category-panel {
+    padding: 22px;
+  }
+
+  .config-model-layout {
     grid-template-columns: 1fr;
+    gap: 20px;
   }
 
   .config-model-list {
-    max-height: 280px;
+    position: static;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    max-height: none;
+    border-right: 0;
+    border-bottom: 1px solid var(--config-line);
+  }
+
+  .config-model-list-title {
+    grid-column: 1 / -1;
+  }
+
+  .config-field-grid,
+  .config-field-grid.model-basics,
+  .config-calibration-card .config-field-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
   }
 }
 
@@ -366,33 +380,27 @@
     padding: 16px 14px 42px;
   }
 
-  .config-dashboard-header h3 {
-    font-size: 24px;
+  .config-summary {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
   }
 
-  .config-hero,
-  .config-field-grid,
-  .config-calibration-meta,
-  .config-add-row,
-  .config-add-row.compact {
-    grid-template-columns: 1fr;
+  .config-summary-item:nth-child(2n) {
+    border-right: 0;
   }
 
-  .config-section,
-  .config-model-editor,
-  .config-model-list,
-  .config-calibration-card,
-  .config-raw-panel {
-    border-radius: 12px;
+  .config-summary-item:nth-child(-n + 2) {
+    border-bottom: 1px solid var(--config-line);
   }
 
-  .config-section-header,
-  .config-subheader,
-  .config-calibration-title {
-    align-items: flex-start;
+  .config-category-panel {
+    padding: 20px;
+  }
+
+  .config-section-header p {
+    white-space: normal;
   }
 
-  .config-raw-toolbar {
+  .config-calibration-meta {
     grid-template-columns: 1fr;
   }
 
@@ -403,6 +411,130 @@
   }
 }
 
+@media (max-width: 620px) {
+  .config-workspace-body {
+    padding: 12px 10px 34px;
+  }
+
+  .config-dashboard {
+    border-radius: 8px;
+  }
+
+  .config-summary-item {
+    padding: 10px 12px;
+  }
+
+  .config-category-nav {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    padding-inline: 8px;
+  }
+
+  .config-category-tab:nth-child(-n + 2) {
+    border-bottom-color: var(--config-line);
+  }
+
+  .config-category-tab.active,
+  .config-category-tab[aria-selected="true"] {
+    border-bottom-color: var(--accent);
+  }
+
+  .config-category-panel {
+    padding: 16px 14px 20px;
+  }
+
+  .config-section-header,
+  .config-subheader,
+  .memory-setup-heading,
+  .memory-management-heading,
+  .memory-management-toolbar,
+  .memory-pagination {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .config-file-actions,
+  .config-section-actions {
+    justify-content: flex-start;
+  }
+
+  .config-step-header {
+    display: none;
+  }
+
+  .config-step-row,
+  .config-file-row,
+  .config-files-section .config-file-row,
+  .config-add-row,
+  .config-add-row.compact,
+  .config-field-grid,
+  .config-field-grid.model-basics,
+  .config-execution-route,
+  .config-calibration-card .config-field-grid,
+  .config-raw-toolbar,
+  .memory-setup-fields {
+    grid-template-columns: 1fr;
+  }
+
+  .config-step-row,
+  .config-file-row {
+    align-items: stretch;
+    gap: 7px;
+  }
+
+  .config-profile-select-cell small {
+    overflow: visible;
+    text-overflow: clip;
+    white-space: normal;
+  }
+
+  .config-add-row.compact {
+    width: 100%;
+  }
+
+  .config-model-list {
+    grid-template-columns: 1fr;
+  }
+
+  .config-calibration-title {
+    grid-template-columns: minmax(0, 1fr) auto;
+    align-items: center;
+  }
+
+  .config-calibration-title code {
+    max-width: 110px;
+  }
+
+  .config-raw-status {
+    grid-column: 1;
+  }
+
+  .memory-setup-actions,
+  .memory-management-primary-actions,
+  .memory-editor-actions,
+  .memory-pagination > div,
+  .memory-search,
+  .memory-search-shell {
+    width: 100%;
+  }
+
+  .memory-management-primary-actions {
+    flex-wrap: wrap;
+  }
+
+  .memory-setup-heading .memory-status,
+  .memory-management-heading .memory-status {
+    align-self: flex-start;
+  }
+
+  .memory-record {
+    padding-inline: 4px;
+  }
+
+  .memory-record-actions {
+    opacity: 1;
+  }
+}
+
 @media (max-width: 460px) {
   .runtime-summary {
     padding: 10px;
@@ -431,6 +563,35 @@
     height: 36px;
     min-height: 36px;
   }
+
+  .config-workspace-heading h2 {
+    font-size: 17px;
+  }
+
+  .config-workspace-heading > p:last-child {
+    display: none;
+  }
+
+  .config-workspace-back {
+    height: 32px;
+    min-height: 32px;
+    padding-inline: 8px;
+  }
+
+  .config-summary-item {
+    padding: 9px 10px;
+  }
+
+  .config-category-tab {
+    min-height: 38px;
+    padding-inline: 6px;
+    font-size: 11px;
+  }
+
+  .config-dashboard #configRawEditor,
+  .config-dashboard .config-view {
+    min-height: 300px;
+  }
 }
 
 @media (max-width: 360px) {

package/dist/src/web-ui/app/styles.css

@@ -3,4 +3,7 @@
 @import url("./styles/10-shell-sessions.css");
 @import url("./styles/20-chat-composer.css");
 @import url("./styles/30-inspector-config.css");
+@import url("./styles/40-config-workspace.css");
+@import url("./styles/35-memory-onboarding.css");
+@import url("./styles/36-memory-management.css");
 @import url("./styles/90-responsive.css");

package/dist/src/web-ui/config-dashboard-backend.js

@@ -2,8 +2,10 @@ import { existsSync } from "node:fs";
 import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { DEFAULT_RUNTIME_CONFIG_FILE } from "../runtime/config/constants.js";
-import { isRecord, resolveRuntimePath } from "../runtime/config/utils.js";
 import { REQUEST_INVOKED_STEP_IDS } from "../runtime/config/runner/contracts.js";
+import { assertSupportedRequestRunnerConfigVersion } from "../runtime/config/runner/schema-version.js";
+import { parseRequestRunnerConfig } from "../runtime/config/runner/versioned-config.js";
+import { isRecord, resolveRuntimePath } from "../runtime/config/utils.js";
 function resolveMainConfigPath(rootDir, configPath) {
     return configPath
         ? resolveRuntimePath(rootDir, configPath)
@@ -258,6 +260,12 @@ export async function saveConfigDashboardFile(params) {
         };
     }
     ensureInsideRoot(params.rootDir, filePath);
+    if (target.kind === "requestRunner") {
+        if (target.exists) {
+            assertSupportedRequestRunnerConfigVersion(target.config, filePath);
+        }
+        parseRequestRunnerConfig(params.config, filePath);
+    }
     const result = await writeJsonObject(filePath, params.config);
     const file = await readDescriptor({
         rootDir: params.rootDir,

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

@@ -1,5 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { LocalRuntimeBackendOptions } from "./contracts.js";
+import type { ResolvedLocalRuntimeBackendOptions } from "./contracts.js";
 import { RuntimeEnvironmentRegistry } from "./environment-registry.js";
 import { LocalRequestExecution } from "./request-execution.js";
 export declare class LocalRuntimeApiRouter {
@@ -7,7 +7,9 @@ export declare class LocalRuntimeApiRouter {
     private readonly environments;
     private readonly requests;
     private readonly attachments;
-    constructor(options: LocalRuntimeBackendOptions, environments: RuntimeEnvironmentRegistry, requests: LocalRequestExecution);
+    private readonly memoryManagement;
+    private readonly memoryOnboarding;
+    constructor(options: ResolvedLocalRuntimeBackendOptions, environments: RuntimeEnvironmentRegistry, requests: LocalRequestExecution);
     handle(req: IncomingMessage, res: ServerResponse): Promise<void>;
     private readState;
 }

package/dist/src/web-ui/local-runtime/api-router.js

@@ -2,7 +2,10 @@ import { getRuntimeConfig, getRuntimeConfigSchema, } from "../../runtime/admin/c
 import { getRuntimeStatus, tailRuntimeLog, } from "../../runtime/admin/system-control.js";
 import { getConfigDashboardSnapshot, saveConfigDashboardFile, } from "../config-dashboard-backend.js";
 import { deleteSessionAttachmentsIfSupported, LocalAttachmentRoutes, } from "./attachment-routes.js";
+import { createLocalLongTermMemoryOnboardingService } from "../../runtime/adapters/long-term-memory/onboarding-service.js";
 import { getString, pathSegments, readBody, readConfigFileKind, readJsonBody, requestEnvironmentId, sendJson, } from "./http.js";
+import { LongTermMemoryManagementRoutes } from "./memory-management-routes.js";
+import { LongTermMemoryOnboardingRoutes } from "./memory-onboarding-routes.js";
 function sendRuntimeSetupRequired(res, availability) {
     sendJson(res, 409, {
         ok: false,
@@ -16,10 +19,18 @@ export class LocalRuntimeApiRouter {
     environments;
     requests;
     attachments = new LocalAttachmentRoutes();
+    memoryManagement;
+    memoryOnboarding;
     constructor(options, environments, requests) {
         this.options = options;
         this.environments = environments;
         this.requests = requests;
+        this.memoryOnboarding = new LongTermMemoryOnboardingRoutes(createLocalLongTermMemoryOnboardingService({
+            rootDir: options.rootDir ?? process.cwd(),
+            providerAdapters: options.providerAdapters,
+            ...(options.configPath ? { configPath: options.configPath } : {}),
+        }));
+        this.memoryManagement = new LongTermMemoryManagementRoutes((environmentId) => this.environments.get(environmentId).services.longTermMemory);
     }
     async handle(req, res) {
         const url = new URL(req.url || "/", "http://localhost");
@@ -52,6 +63,28 @@ export class LocalRuntimeApiRouter {
             ? null
             : readJsonBody(await readBody(req));
         const environmentId = requestEnvironmentId(url, body, this.options.defaultEnvironmentId);
+        if (await this.memoryOnboarding.handle({
+            method,
+            route,
+            url,
+            body,
+            request: req,
+            response: res,
+        })) {
+            return;
+        }
+        if (await this.memoryManagement.handle({
+            method,
+            route,
+            segments,
+            url,
+            body,
+            environmentId,
+            request: req,
+            response: res,
+        })) {
+            return;
+        }
         if (method === "GET" && route === "runtime/config/dashboard") {
             sendJson(res, 200, {
                 ok: true,

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

@@ -1,10 +1,15 @@
 import type { RuntimeApplication } from "../../runtime/composition.js";
 import type { RequestSteeringInbox } from "../../runtime/request/request-steering.js";
+import type { ModelProviderAdapterRegistry } from "../../model-gateway/index.js";
 export type JsonObject = Record<string, unknown>;
 export type LocalRuntimeBackendOptions = {
     rootDir?: string;
     configPath?: string;
     defaultEnvironmentId: string;
+    providerAdapters?: ModelProviderAdapterRegistry;
+};
+export type ResolvedLocalRuntimeBackendOptions = Omit<LocalRuntimeBackendOptions, "providerAdapters"> & {
+    providerAdapters: ModelProviderAdapterRegistry;
 };
 export type RuntimeEnvironment = RuntimeApplication;
 export type RuntimeSetupRequirement = {

package/dist/src/web-ui/local-runtime/memory-management-input.d.ts

@@ -0,0 +1,12 @@
+import type { MemoryListInput } from "../../runtime/long-term-memory/contracts.js";
+import type { JsonObject } from "./contracts.js";
+export type WebMemoryCreateInput = Readonly<{
+    content: string;
+    tags: readonly string[];
+}>;
+export type WebMemoryUpdateInput = WebMemoryCreateInput & Readonly<{
+    expectedUpdatedAt: string;
+}>;
+export declare function readMemoryPage(url: URL): MemoryListInput;
+export declare function readMemoryCreateInput(body: JsonObject | null): WebMemoryCreateInput;
+export declare function readMemoryUpdateInput(body: JsonObject | null): WebMemoryUpdateInput;

package/dist/src/web-ui/local-runtime/memory-management-input.js

@@ -0,0 +1,68 @@
+import { LongTermMemoryManagementError } from "../../runtime/long-term-memory/index.js";
+const ENVIRONMENT_FIELDS = ["environment", "environmentId"];
+export function readMemoryPage(url) {
+    const limit = readOptionalInteger(url, "limit", false);
+    const offset = readOptionalInteger(url, "offset", true);
+    return Object.freeze({
+        ...(limit === undefined ? {} : { limit }),
+        ...(offset === undefined ? {} : { offset }),
+    });
+}
+export function readMemoryCreateInput(body) {
+    assertAllowedFields(body, ["content", "tags", ...ENVIRONMENT_FIELDS]);
+    return Object.freeze({
+        content: readString(body?.content),
+        tags: readTags(body?.tags),
+    });
+}
+export function readMemoryUpdateInput(body) {
+    assertAllowedFields(body, [
+        "content",
+        "tags",
+        "expectedUpdatedAt",
+        ...ENVIRONMENT_FIELDS,
+    ]);
+    return Object.freeze({
+        content: readString(body?.content),
+        tags: readTags(body?.tags),
+        expectedUpdatedAt: readString(body?.expectedUpdatedAt),
+    });
+}
+function assertAllowedFields(body, allowedFields) {
+    const fields = Object.keys(body ?? {});
+    if (fields.some((field) => !allowedFields.includes(field))) {
+        throw invalidManagementInput();
+    }
+}
+function readString(value) {
+    if (typeof value !== "string") {
+        throw invalidManagementInput();
+    }
+    return value;
+}
+function readTags(value) {
+    if (value === undefined)
+        return Object.freeze([]);
+    const validTags = Array.isArray(value) && value.every(isString);
+    if (!validTags) {
+        throw invalidManagementInput();
+    }
+    return Object.freeze([...value]);
+}
+function readOptionalInteger(url, name, allowZero) {
+    const raw = url.searchParams.get(name);
+    if (raw === null)
+        return undefined;
+    const value = Number(raw);
+    const validRange = allowZero ? value >= 0 : value > 0;
+    if (!Number.isSafeInteger(value) || !validRange || String(value) !== raw) {
+        throw invalidManagementInput();
+    }
+    return value;
+}
+function isString(value) {
+    return typeof value === "string";
+}
+function invalidManagementInput() {
+    return new LongTermMemoryManagementError("long_term_memory_management_input_invalid");
+}

package/dist/src/web-ui/local-runtime/memory-management-response.d.ts

@@ -0,0 +1,17 @@
+import type { ServerResponse } from "node:http";
+import type { LongTermMemoryRecord, LongTermMemoryStatus } from "../../runtime/long-term-memory/contracts.js";
+export type WebMemoryRecord = Readonly<{
+    id: string;
+    content: string;
+    tags: readonly string[];
+    origin: "passive_response" | "web_ui" | "management_api";
+    createdAt: string;
+    updatedAt: string;
+}>;
+export type WebMemoryStatus = Readonly<{
+    enabled: boolean;
+    available: boolean;
+}>;
+export declare function projectWebMemoryStatus(status: LongTermMemoryStatus): WebMemoryStatus;
+export declare function projectWebMemoryRecord(record: LongTermMemoryRecord): WebMemoryRecord;
+export declare function sendMemoryManagementError(response: ServerResponse, error: unknown): void;

package/dist/src/web-ui/local-runtime/memory-management-response.js

@@ -0,0 +1,47 @@
+import { isLongTermMemoryManagementError } from "../../runtime/long-term-memory/index.js";
+import { sendJson } from "./http.js";
+export function projectWebMemoryStatus(status) {
+    return Object.freeze({
+        enabled: status.enabled,
+        available: status.available,
+    });
+}
+export function projectWebMemoryRecord(record) {
+    return Object.freeze({
+        id: record.id,
+        content: record.content,
+        tags: Object.freeze([...record.tags]),
+        origin: record.provenance.kind === "passive_response"
+            ? "passive_response"
+            : record.provenance.source,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+    });
+}
+export function sendMemoryManagementError(response, error) {
+    if (!isLongTermMemoryManagementError(error)) {
+        sendJson(response, 500, {
+            ok: false,
+            error: "long_term_memory_management_failed",
+        });
+        return;
+    }
+    sendJson(response, statusForManagementError(error.code), {
+        ok: false,
+        error: error.code,
+        ...(error.memoryId ? { memoryId: error.memoryId } : {}),
+    });
+}
+function statusForManagementError(code) {
+    if (code === "long_term_memory_management_input_invalid" ||
+        code === "long_term_memory_management_sensitive_data") {
+        return 400;
+    }
+    if (code === "long_term_memory_management_not_found")
+        return 404;
+    if (code === "long_term_memory_management_conflict" ||
+        code === "long_term_memory_management_duplicate") {
+        return 409;
+    }
+    return 503;
+}

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

@@ -0,0 +1,24 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { LongTermMemoryManagementService } from "../../runtime/long-term-memory/contracts.js";
+import type { JsonObject } from "./contracts.js";
+type ResolveMemoryManagementService = (environmentId: string) => LongTermMemoryManagementService;
+type MemoryManagementRouteRequest = Readonly<{
+    method: string;
+    route: string;
+    segments: readonly string[];
+    url: URL;
+    body: JsonObject | null;
+    environmentId: string;
+    request: IncomingMessage;
+    response: ServerResponse;
+}>;
+export declare class LongTermMemoryManagementRoutes {
+    private readonly resolveService;
+    constructor(resolveService: ResolveMemoryManagementService);
+    handle(request: MemoryManagementRouteRequest): Promise<boolean>;
+    private handleKnownRoute;
+    private handleCollection;
+    private handleSearch;
+    private handleRecord;
+}
+export {};

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

@@ -0,0 +1,128 @@
+import { sendJson } from "./http.js";
+import { readMemoryCreateInput, readMemoryPage, readMemoryUpdateInput, } from "./memory-management-input.js";
+import { projectWebMemoryRecord, projectWebMemoryStatus, sendMemoryManagementError, } from "./memory-management-response.js";
+import { withHttpRequestAbortSignal } from "./request-abort.js";
+const RECORDS_ROUTE = "runtime/memory/records";
+const SEARCH_ROUTE = "runtime/memory/records/search";
+export class LongTermMemoryManagementRoutes {
+    resolveService;
+    constructor(resolveService) {
+        this.resolveService = resolveService;
+    }
+    async handle(request) {
+        if (!isMemoryManagementRoute(request))
+            return false;
+        try {
+            await this.handleKnownRoute(request, this.resolveService(request.environmentId));
+        }
+        catch (error) {
+            sendMemoryManagementError(request.response, error);
+        }
+        return true;
+    }
+    async handleKnownRoute(request, service) {
+        if (request.route === RECORDS_ROUTE) {
+            await this.handleCollection(request, service);
+            return;
+        }
+        if (request.route === SEARCH_ROUTE) {
+            await this.handleSearch(request, service);
+            return;
+        }
+        await this.handleRecord(request, service);
+    }
+    async handleCollection(request, service) {
+        if (request.method === "GET") {
+            const [status, result] = await Promise.all([
+                service.status(),
+                service.list(readMemoryPage(request.url)),
+            ]);
+            sendJson(request.response, 200, {
+                ok: true,
+                status: projectWebMemoryStatus(status),
+                items: result.items.map(projectWebMemoryRecord),
+                total: result.total,
+            });
+            return;
+        }
+        if (request.method === "POST") {
+            const input = readMemoryCreateInput(request.body);
+            const result = await withManagementContext(request, (context) => service.create({
+                ...input,
+                source: "web_ui",
+                context,
+            }));
+            sendJson(request.response, 201, {
+                ok: true,
+                record: projectWebMemoryRecord(result.record),
+            });
+            return;
+        }
+        sendMethodNotAllowed(request.response, "GET, POST");
+    }
+    async handleSearch(request, service) {
+        if (request.method !== "GET") {
+            sendMethodNotAllowed(request.response, "GET");
+            return;
+        }
+        const result = await withManagementContext(request, (context) => service.search({
+            query: request.url.searchParams.get("q") ?? "",
+            ...readMemoryPage(request.url),
+            context,
+        }));
+        sendJson(request.response, 200, {
+            ok: true,
+            items: result.items.map(projectWebMemoryRecord),
+            total: result.total,
+        });
+    }
+    async handleRecord(request, service) {
+        const id = request.segments[3] ?? "";
+        if (request.method === "PATCH") {
+            const input = readMemoryUpdateInput(request.body);
+            const result = await withManagementContext(request, (context) => service.update({ id, ...input, context }));
+            sendJson(request.response, 200, {
+                ok: true,
+                record: projectWebMemoryRecord(result.record),
+                updated: result.updated,
+            });
+            return;
+        }
+        if (request.method === "DELETE") {
+            const result = await service.delete({ id });
+            if (!result.deleted) {
+                sendJson(request.response, 404, {
+                    ok: false,
+                    error: "long_term_memory_management_not_found",
+                    memoryId: id,
+                });
+                return;
+            }
+            sendJson(request.response, 200, { ok: true, deleted: true });
+            return;
+        }
+        sendMethodNotAllowed(request.response, "PATCH, DELETE");
+    }
+}
+function isMemoryManagementRoute(request) {
+    if (request.route === RECORDS_ROUTE || request.route === SEARCH_ROUTE) {
+        return true;
+    }
+    return (request.segments.length === 4 &&
+        request.segments[0] === "runtime" &&
+        request.segments[1] === "memory" &&
+        request.segments[2] === "records" &&
+        Boolean(request.segments[3]));
+}
+function withManagementContext(request, run) {
+    return withHttpRequestAbortSignal({
+        request: request.request,
+        response: request.response,
+        reason: "memory_management_request_aborted",
+        run: (abortSignal) => run(Object.freeze({ abortSignal })),
+    });
+}
+function sendMethodNotAllowed(response, allow) {
+    response.setHeader("allow", allow);
+    sendJson(response, 405, { ok: false, error: "method_not_allowed" });
+}