@abot-ai/runtime 1.0.0 → 1.2.0

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" });
+}

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

@@ -0,0 +1,17 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { LongTermMemoryOnboardingService } from "../../runtime/long-term-memory/onboarding/contracts.js";
+type JsonBody = Record<string, unknown> | null;
+export declare class LongTermMemoryOnboardingRoutes {
+    private readonly service;
+    constructor(service: LongTermMemoryOnboardingService);
+    handle(params: {
+        method: string;
+        route: string;
+        url: URL;
+        body: JsonBody;
+        request: IncomingMessage;
+        response: ServerResponse;
+    }): Promise<boolean>;
+    private handleKnownRoute;
+}
+export {};

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

@@ -0,0 +1,81 @@
+import { getString, sendJson } from "./http.js";
+import { withHttpRequestAbortSignal } from "./request-abort.js";
+export class LongTermMemoryOnboardingRoutes {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    async handle(params) {
+        try {
+            return await this.handleKnownRoute(params);
+        }
+        catch (error) {
+            sendJson(params.response, readErrorStatus(error), {
+                ok: false,
+                error: "long_term_memory_onboarding_failed",
+                message: error instanceof Error ? error.message : String(error),
+            });
+            return true;
+        }
+    }
+    async handleKnownRoute(params) {
+        if (params.method === "GET" && params.route === "runtime/memory") {
+            sendJson(params.response, 200, {
+                ok: true,
+                status: await this.service.status(),
+            });
+            return true;
+        }
+        if (params.method === "GET" &&
+            params.route === "runtime/memory/models") {
+            const providerId = params.url.searchParams.get("provider") ?? "";
+            sendJson(params.response, 200, {
+                ok: true,
+                catalog: await withHttpRequestAbortSignal({
+                    request: params.request,
+                    response: params.response,
+                    reason: "memory_onboarding_discovery_request_aborted",
+                    run: (abortSignal) => this.service.discover({ providerId, abortSignal }),
+                }),
+            });
+            return true;
+        }
+        if (params.method === "POST" &&
+            params.route === "runtime/memory/enable") {
+            const result = await withHttpRequestAbortSignal({
+                request: params.request,
+                response: params.response,
+                reason: "memory_onboarding_enable_request_aborted",
+                run: (abortSignal) => this.service.enable({
+                    providerId: getString(params.body?.providerId),
+                    model: getString(params.body?.model),
+                    ...(getString(params.body?.profileId)
+                        ? { profileId: getString(params.body?.profileId) }
+                        : {}),
+                    emitClientEvents: params.body?.emitClientEvents === true,
+                    abortSignal,
+                }),
+            });
+            sendJson(params.response, 200, { ok: true, ...result });
+            return true;
+        }
+        if (params.method === "POST" &&
+            params.route === "runtime/memory/disable") {
+            sendJson(params.response, 200, {
+                ok: true,
+                ...(await this.service.disable()),
+            });
+            return true;
+        }
+        return false;
+    }
+}
+function readErrorStatus(error) {
+    if (!error || typeof error !== "object" || !("statusCode" in error)) {
+        return 400;
+    }
+    const statusCode = Number(error.statusCode);
+    return Number.isInteger(statusCode) && statusCode >= 400 && statusCode <= 599
+        ? statusCode
+        : 400;
+}

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

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function withHttpRequestAbortSignal<T>(params: {
+    request: IncomingMessage;
+    response: ServerResponse;
+    reason: string;
+    run: (abortSignal: AbortSignal) => Promise<T>;
+}): Promise<T>;

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

@@ -0,0 +1,19 @@
+export async function withHttpRequestAbortSignal(params) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(new Error(params.reason));
+    const abortOnResponseClose = () => {
+        if (!params.response.writableEnded)
+            abort();
+    };
+    params.request.once("aborted", abort);
+    params.response.once("close", abortOnResponseClose);
+    if (params.request.aborted || params.response.destroyed)
+        abort();
+    try {
+        return await params.run(controller.signal);
+    }
+    finally {
+        params.request.removeListener("aborted", abort);
+        params.response.removeListener("close", abortOnResponseClose);
+    }
+}

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

@@ -1,3 +1,4 @@
+import { resolveProviderAdapters } from "../model-gateway/server/index.js";
 import { LocalRuntimeApiRouter } from "./local-runtime/api-router.js";
 import { LocalRuntimeControlRoutes } from "./local-runtime/control-routes.js";
 import { RuntimeEnvironmentRegistry } from "./local-runtime/environment-registry.js";
@@ -12,11 +13,17 @@ export class LocalRuntimeWebBackend {
     realtime;
     controls;
     constructor(options) {
-        this.environments = new RuntimeEnvironmentRegistry(options);
+        const resolvedOptions = {
+            ...options,
+            providerAdapters: resolveProviderAdapters({
+                providerAdapters: options.providerAdapters,
+            }),
+        };
+        this.environments = new RuntimeEnvironmentRegistry(resolvedOptions);
         const clients = new RealtimeClientHub();
         const requests = new LocalRequestExecution(clients);
-        this.api = new LocalRuntimeApiRouter(options, this.environments, requests);
-        this.realtime = new LocalRealtimeController(options, this.environments, requests, clients);
+        this.api = new LocalRuntimeApiRouter(resolvedOptions, this.environments, requests);
+        this.realtime = new LocalRealtimeController(resolvedOptions, this.environments, requests, clients);
         this.controls = new LocalRuntimeControlRoutes(requests);
     }
     async handleHttp(req, res, pathname) {

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

@@ -1,3 +1,4 @@
+import type { ModelProviderAdapterRegistry } from "../model-gateway/index.js";
 export type WebUiSetupCommandMode = "source" | "package";
 export type WebUiEnvironmentOption = {
     id: string;
@@ -20,6 +21,7 @@ type WebUiServerOptions = {
     rootDir?: string;
     configPath?: string;
     setupCommandMode?: WebUiSetupCommandMode;
+    providerAdapters?: ModelProviderAdapterRegistry;
 };
 type WebUiServerHandle = {
     close: () => Promise<void>;

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

@@ -201,6 +201,9 @@ export function startWebUiServer(overrides = {}) {
             rootDir: options.rootDir,
             configPath: options.configPath,
             defaultEnvironmentId: options.defaultEnvironmentId,
+            ...(options.providerAdapters
+                ? { providerAdapters: options.providerAdapters }
+                : {}),
         })
         : null;
     const externalBridgeBackend = options.backend === "bridge"