@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/web-ui/local-runtime/model-setup-profile-file.js

@@ -0,0 +1,121 @@
+import { lstat, rm } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { canonicalConfigFilePath, readConfigFileSnapshot, withConfigFileTransaction, } from "../../runtime/adapters/config-file-transaction.js";
+import { ModelSetupError } from "./model-setup-input.js";
+function declaredModelSetupProfilePath(options, profileId) {
+    return resolve(dirname(options.configPath), `./models/${profileId}.config.json`);
+}
+export async function modelSetupProfilePath(options, profileId) {
+    return canonicalConfigFilePath(declaredModelSetupProfilePath(options, profileId));
+}
+export async function isDiscoveredModelSetupProfileAtTarget(options, profileId, discoveredPath) {
+    return ((await canonicalConfigFilePath(discoveredPath)) ===
+        (await modelSetupProfilePath(options, profileId)));
+}
+function matchesRequestedModelSetupProfile(snapshot, profile) {
+    if (snapshot.invalidJson)
+        return false;
+    return isDeepStrictEqual(snapshot.config, profile);
+}
+function requireProfileInsideWorkspace(rootDir, path) {
+    const target = relative(rootDir, path);
+    if (!target.startsWith("..") && !isAbsolute(target))
+        return;
+    throw new ModelSetupError("model_config_outside_workspace", "The model configuration must be inside the workspace.", 409);
+}
+function rejectExistingModelFile() {
+    throw new ModelSetupError("model_profile_exists", "A model file already uses this profile ID. Choose another ID.", 409);
+}
+async function requireAbsentModelProfileEntry(path) {
+    try {
+        // A dangling symlink is an existing user-owned entry, not a new file.
+        await lstat(path);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    rejectExistingModelFile();
+}
+async function requireUnchangedProfileTarget(declaredPath, expectedPath) {
+    if ((await canonicalConfigFilePath(declaredPath)) === expectedPath)
+        return;
+    throw new ModelSetupError("config_changed", "The model file reference changed while being checked. Reload Configuration before retrying.", 409);
+}
+async function discardUncommittedProfile(root, rootRevision, path, profileRevision) {
+    // A changed root or child may belong to an external editor; preserve it.
+    try {
+        if ((await readConfigFileSnapshot(root.path)).revision !== rootRevision)
+            return;
+        if ((await readConfigFileSnapshot(path)).revision !== profileRevision)
+            return;
+        await rm(path);
+    }
+    catch {
+        // Cleanup must never hide the original save failure or erase uncertain data.
+    }
+}
+/** The caller holds the Runtime lock; a new or exact existing profile is locked until commit. */
+export async function withModelSetupProfile(options, root, profileId, profile, commit) {
+    const configRef = `./models/${profileId}.config.json`;
+    const declaredPath = declaredModelSetupProfilePath(options, profileId);
+    const path = await modelSetupProfilePath(options, profileId);
+    requireProfileInsideWorkspace(options.rootDir, path);
+    if (path === root.path)
+        rejectExistingModelFile();
+    return withConfigFileTransaction(path, async (target) => {
+        await requireUnchangedProfileTarget(declaredPath, path);
+        const createdByThisAddition = !target.snapshot.exists;
+        if (!createdByThisAddition &&
+            !matchesRequestedModelSetupProfile(target.snapshot, profile))
+            rejectExistingModelFile();
+        const rootRevision = root.snapshot.revision;
+        if (createdByThisAddition) {
+            await requireAbsentModelProfileEntry(declaredPath);
+            await target.write(profile);
+        }
+        const profileRevision = target.snapshot.revision;
+        const assertProfileUnchanged = async () => {
+            await requireUnchangedProfileTarget(declaredPath, path);
+            if ((await readConfigFileSnapshot(path, { allowMalformedJson: true }))
+                .revision !== profileRevision)
+                throw new ModelSetupError("config_changed", "The model file changed while saving. Reload Configuration to check the saved model.", 409);
+        };
+        try {
+            await assertProfileUnchanged();
+            // The confirmed Runtime commit is the save boundary. Later external
+            // profile edits must not report the committed declaration as rejected.
+            return await commit({ configRef }, assertProfileUnchanged);
+        }
+        catch (error) {
+            if (createdByThisAddition)
+                await discardUncommittedProfile(root, rootRevision, path, profileRevision);
+            throw error;
+        }
+    }, { allowMalformedJson: true });
+}
+/** Preserve exact retry identity for both legacy inline and linked declarations. */
+export async function readSavedModelSetupProfile(options, declaration) {
+    if (!Object.hasOwn(declaration, "configRef"))
+        return { profile: declaration, assertUnchanged: async () => { } };
+    if (typeof declaration.configRef !== "string")
+        rejectExistingModelFile();
+    if (Object.keys(declaration).length !== 1)
+        rejectExistingModelFile();
+    const declaredPath = resolve(dirname(options.configPath), declaration.configRef);
+    const path = await canonicalConfigFilePath(declaredPath);
+    requireProfileInsideWorkspace(options.rootDir, path);
+    const snapshot = await readConfigFileSnapshot(path);
+    if (!snapshot.exists)
+        rejectExistingModelFile();
+    return {
+        profile: snapshot.config,
+        async assertUnchanged() {
+            await requireUnchangedProfileTarget(declaredPath, path);
+            if ((await readConfigFileSnapshot(path)).revision !== snapshot.revision)
+                throw new ModelSetupError("config_changed", "The saved model file changed while being checked. Reload Configuration before retrying.", 409);
+        },
+    };
+}

package/dist/src/web-ui/local-runtime/model-setup-retry.d.ts

@@ -1,6 +1,6 @@
 import { type ModelSetupOptions } from "./model-setup-catalog.js";
 import { type ModelSetupInput } from "./model-setup-input.js";
-/** A repeated POST may acknowledge only the exact inline addition already committed. */
+/** A repeated POST may acknowledge only the exact addition already committed. */
 export declare function recoverCommittedModelAddition(options: ModelSetupOptions & {
     configPath: string;
 }, models: Record<string, unknown>, input: ModelSetupInput, expectedRevision: string): Promise<{

package/dist/src/web-ui/local-runtime/model-setup-retry.js

@@ -4,6 +4,7 @@ import { isRecord } from "../../runtime/config/utils.js";
 import { modelConfigMap, } from "./model-setup-catalog.js";
 import { buildModelSetupProfile, modelSetupResult, } from "./model-setup-identity.js";
 import { ModelSetupError } from "./model-setup-input.js";
+import { readSavedModelSetupProfile } from "./model-setup-profile-file.js";
 import { buildNewModelProvider, planModelProvider, prepareModelCredential, } from "./model-setup-provider.js";
 function rejectModelProfileCollision() {
     throw new ModelSetupError("model_profile_exists", "That model profile ID already exists with different settings. Choose another ID.", 409);
@@ -19,13 +20,13 @@ async function requireUnchangedRetryConfiguration(options, expectedRevision) {
         return;
     throw new ModelSetupError("config_changed", "Configuration changed while the saved model was being checked. Refresh before retrying.", 409);
 }
-/** A repeated POST may acknowledge only the exact inline addition already committed. */
+/** A repeated POST may acknowledge only the exact addition already committed. */
 export async function recoverCommittedModelAddition(options, models, input, expectedRevision) {
     const profiles = modelConfigMap(models.profiles);
-    const profile = profiles[input.profileId];
-    const savedProfileIsInline = isRecord(profile);
-    if (!savedProfileIsInline)
+    const declaration = profiles[input.profileId];
+    if (!isRecord(declaration))
         rejectModelProfileCollision();
+    const saved = await readSavedModelSetupProfile(options, declaration);
     const providers = modelConfigMap(models.providers);
     const providerId = input.providerId ?? input.newProvider.id;
     const hasSavedProviderConnection = isRecord(providers[providerId]);
@@ -36,12 +37,13 @@ export async function recoverCommittedModelAddition(options, models, input, expe
     if (!savedProviderMatchesRequest)
         rejectModelProfileCollision();
     const expectedProfile = await buildModelSetupProfile(provider, input);
-    const savedProfileMatchesRequest = isDeepStrictEqual(profile, expectedProfile);
+    const savedProfileMatchesRequest = isDeepStrictEqual(saved.profile, expectedProfile);
     if (!savedProfileMatchesRequest)
         rejectModelProfileCollision();
     const credential = await prepareModelCredential(options, provider.config, input.apiKey);
     if (credential?.apiKey)
-        throw new ModelSetupError("model_credential_required", "The saved model's credential is missing. Restore its connection in Configuration before retrying.", 409);
+        throw new ModelSetupError("model_credential_required", "The saved model's credential is missing. Restore its connection in Models before retrying.", 409);
     await requireUnchangedRetryConfiguration(options, expectedRevision);
+    await saved.assertUnchanged();
     return modelSetupResult(provider, input);
 }

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

@@ -19,12 +19,14 @@ export class ModelSetupRoutes {
                 });
             }
             else if (params.route === "runtime/config/models" &&
-                params.method === "POST") {
+                ["POST", "DELETE"].includes(params.method)) {
                 assertConfigMutationRequest(params.request);
                 const body = readJsonBody(await readBody(params.request, { maxBytes: 16_384 }));
                 sendJson(params.response, 200, {
                     ok: true,
-                    ...(await this.service.add(body)),
+                    ...(params.method === "DELETE"
+                        ? await this.service.remove(body)
+                        : await this.service.add(body)),
                 });
             }
             else

package/dist/src/web-ui/local-runtime/model-setup-service.d.ts

@@ -17,6 +17,10 @@ export declare class ModelSetupService {
         profileIds: string[];
     }>;
     private canonicalOptions;
+    remove(body: Record<string, unknown>): Promise<{
+        profileId: string;
+        restartRequired: boolean;
+    }>;
     add(body: Record<string, unknown>): Promise<{
         model: {
             profileId: string;
@@ -27,4 +31,5 @@ export declare class ModelSetupService {
         restartRequired: true;
     }>;
     private save;
+    private commit;
 }

package/dist/src/web-ui/local-runtime/model-setup-service.js

@@ -1,8 +1,9 @@
 import { isDeepStrictEqual } from "node:util";
 import { realpath } from "node:fs/promises";
-import { isAbsolute, relative } from "node:path";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { mergeRuntimeModelAddition } from "../../../scripts/runtime-model-addition.js";
-import { ConfigFileConflictError, withConfigFileTransaction, } from "../../runtime/adapters/config-file-transaction.js";
+import { ConfigFileConflictError, canonicalConfigFilePath, readConfigFileSnapshot, withConfigFileTransaction, } from "../../runtime/adapters/config-file-transaction.js";
+import { validateRuntimeConfigFile } from "../../runtime/config/validation.js";
 import { getConfigDashboardSnapshot, saveConfigDashboardFile, } from "../config-dashboard-backend.js";
 import { getModelSetupCatalog, modelConfigMap, readModelSetupSource, } from "./model-setup-catalog.js";
 import { ModelSetupError, parseModelSetupInput, } from "./model-setup-input.js";
@@ -10,9 +11,21 @@ import { planModelProvider, prepareModelCredential, saveModelCredential, } from
 import { validateModelAddition } from "./model-setup-validation.js";
 import { buildModelSetupProfile, modelSetupResult, } from "./model-setup-identity.js";
 import { recoverCommittedModelAddition } from "./model-setup-retry.js";
-function hasCommittedModelAddition(options, candidate) {
+import { removeRuntimeModelDeclaration } from "./model-removal.js";
+import { isDiscoveredModelSetupProfileAtTarget, withModelSetupProfile, } from "./model-setup-profile-file.js";
+function isModelConfigLocationInsideWorkspace(rootDir, path) {
+    const location = relative(rootDir, path);
+    return !location.startsWith("..") && !isAbsolute(location);
+}
+function requireModelConfigLocationInsideWorkspace(rootDir, path) {
+    if (isModelConfigLocationInsideWorkspace(rootDir, path))
+        return;
+    throw new ModelSetupError("model_config_outside_workspace", "The selected configuration must be inside the workspace.", 409);
+}
+async function hasCommittedModelAddition(transaction, candidate) {
     try {
-        return isDeepStrictEqual(readModelSetupSource(options).config, candidate);
+        const current = await readConfigFileSnapshot(transaction.path);
+        return isDeepStrictEqual(current.config, candidate);
     }
     catch {
         return false;
@@ -34,41 +47,70 @@ export class ModelSetupService {
     }
     async canonicalOptions() {
         const source = readModelSetupSource(this.sourceOptions());
-        const options = {
-            rootDir: await realpath(this.options.rootDir),
-            configPath: await realpath(source.path),
-        };
-        const target = relative(options.rootDir, options.configPath);
-        if (target.startsWith("..") || isAbsolute(target))
-            throw new ModelSetupError("model_config_outside_workspace", "The selected configuration must be inside the workspace.", 409);
-        return options;
+        const rootDir = await realpath(this.options.rootDir);
+        // Rebase only the workspace prefix. Resolving inner parent links would
+        // change the Runtime's lexical resolution of references such as ../models.
+        const configPath = isModelConfigLocationInsideWorkspace(this.options.rootDir, source.path)
+            ? resolve(rootDir, relative(this.options.rootDir, source.path))
+            : source.path;
+        const canonicalConfigPath = await realpath(source.path);
+        requireModelConfigLocationInsideWorkspace(rootDir, configPath);
+        requireModelConfigLocationInsideWorkspace(rootDir, canonicalConfigPath);
+        requireModelConfigLocationInsideWorkspace(rootDir, await realpath(dirname(source.path)));
+        return { rootDir, configPath, canonicalConfigPath };
+    }
+    async remove(body) {
+        const options = await this.canonicalOptions();
+        return withConfigFileTransaction(options.canonicalConfigPath, (transaction) => removeRuntimeModelDeclaration(options, transaction, body));
     }
     async add(body) {
         const input = parseModelSetupInput(body);
         const options = await this.canonicalOptions();
-        return withConfigFileTransaction(options.configPath, (transaction) => this.save(options, input, transaction));
+        return withConfigFileTransaction(options.canonicalConfigPath, (transaction) => this.save(options, input, transaction));
     }
     async save(options, input, transaction) {
-        const source = readModelSetupSource(options);
-        const models = modelConfigMap(source.config.models);
-        const dashboard = await getConfigDashboardSnapshot(options);
-        const profileExists = dashboard.files.models.some((profile) => profile.id === input.profileId);
-        if (profileExists)
+        const selectedPath = await canonicalConfigFilePath(options.configPath);
+        const hasLockedSelectedConfig = transaction.snapshot.exists && transaction.path === selectedPath;
+        if (!hasLockedSelectedConfig)
+            throw new ModelSetupError("config_changed", "The selected configuration changed while being opened. Reload Configuration before retrying.", 409);
+        const source = transaction.snapshot.config;
+        validateRuntimeConfigFile(source, transaction.path);
+        const models = modelConfigMap(source.models);
+        const dashboard = await getConfigDashboardSnapshot(options, transaction.snapshot);
+        const savedProfiles = modelConfigMap(models.profiles);
+        if (Object.hasOwn(savedProfiles, input.profileId))
             return recoverCommittedModelAddition(options, models, input, transaction.snapshot.revision);
+        const discovered = dashboard.files.models.find((entry) => entry.id === input.profileId);
+        if (discovered &&
+            !(await isDiscoveredModelSetupProfileAtTarget(options, input.profileId, resolve(options.rootDir, discovered.path))))
+            throw new ModelSetupError("model_profile_exists", "Another model file already uses this profile ID. Choose another ID.", 409);
         const provider = planModelProvider(modelConfigMap(models.providers), input);
         const profile = await buildModelSetupProfile(provider, input);
-        const candidate = mergeRuntimeModelAddition(source.config, {
+        const addition = {
             profileId: input.profileId,
             providerId: provider.id,
             provider: provider.config,
             profile,
-        }).config;
-        await validateModelAddition(candidate, options);
+        };
+        await validateModelAddition(mergeRuntimeModelAddition(source, addition).config, options);
         const credential = await prepareModelCredential(options, provider.config, input.apiKey);
+        return withModelSetupProfile(options, transaction, input.profileId, profile, async (declaration, assertProfileUnchanged) => {
+            const candidate = mergeRuntimeModelAddition(source, {
+                ...addition,
+                profile: declaration,
+            }).config;
+            await validateModelAddition(candidate, options);
+            await assertProfileUnchanged();
+            await this.commit(options, candidate, transaction, credential, assertProfileUnchanged);
+            return modelSetupResult(provider, input);
+        });
+    }
+    async commit(options, candidate, transaction, credential, assertProfileUnchanged) {
         let credentialSaved = false;
         let configSaveAttempted = false;
         try {
             credentialSaved = await saveModelCredential(options, credential);
+            await assertProfileUnchanged();
             configSaveAttempted = true;
             await saveConfigDashboardFile({
                 ...options,
@@ -78,16 +120,19 @@ export class ModelSetupService {
             });
         }
         catch (error) {
-            if (error instanceof ModelSetupError)
-                throw error;
+            if (error instanceof ModelSetupError) {
+                if (!credentialSaved || error.credentialSaved)
+                    throw error;
+                throw new ModelSetupError(error.code, error.message, error.statusCode, true);
+            }
             if (error instanceof ConfigFileConflictError)
                 throw new ModelSetupError("config_changed", error.message, 409, credentialSaved);
-            const modelCommitted = configSaveAttempted && hasCommittedModelAddition(options, candidate);
+            const modelCommitted = configSaveAttempted &&
+                (await hasCommittedModelAddition(transaction, candidate));
             if (!modelCommitted)
                 throw new ModelSetupError("model_save_failed", credentialSaved
                     ? "The credential is saved, but the model save could not be confirmed. Refresh Configuration, then retry without re-entering the key if the model is missing."
                     : "The model save could not be confirmed. Refresh Configuration before trying again.", 500, credentialSaved);
         }
-        return modelSetupResult(provider, input);
     }
 }

package/dist/src/web-ui/local-runtime/model-setup-validation.d.ts

@@ -1,5 +1,6 @@
 /** Staging beside the selected source preserves every existing relative reference. */
-export declare function validateModelAddition(config: Record<string, unknown>, options: {
+export declare function validateModelConfigurationChange(config: Record<string, unknown>, options: {
     rootDir: string;
     configPath: string;
 }): Promise<void>;
+export { validateModelConfigurationChange as validateModelAddition };

package/dist/src/web-ui/local-runtime/model-setup-validation.js

@@ -5,7 +5,7 @@ import { loadRuntimeConfig } from "../../runtime/config.js";
 import { isRecord } from "../../runtime/config/utils.js";
 import { validateRuntimeConfigFile } from "../../runtime/config/validation.js";
 /** Staging beside the selected source preserves every existing relative reference. */
-export async function validateModelAddition(config, options) {
+export async function validateModelConfigurationChange(config, options) {
     validateRuntimeConfigFile(config, options.configPath);
     const temporary = join(dirname(options.configPath), `.model-addition-validation-${randomUUID()}.json`);
     try {
@@ -31,3 +31,4 @@ export async function validateModelAddition(config, options) {
         await rm(temporary, { force: true });
     }
 }
+export { validateModelConfigurationChange as validateModelAddition };

package/dist/src/web-ui/local-runtime/pending-tool-approvals.d.ts

@@ -0,0 +1,29 @@
+import type { ToolApprovalController, ToolApprovalDecision, ToolApprovalRequest } from "../../runtime/ports.js";
+import type { ActiveRequest, JsonObject } from "./contracts.js";
+export type PendingWebToolApproval = {
+    environmentId: string;
+    sessionId: string;
+    requestId: string;
+    approvalId: string;
+    event: JsonObject;
+    generation?: string;
+    waitId?: string;
+    revision?: number;
+};
+export type WebToolApprovalDecision = Omit<PendingWebToolApproval, "event"> & ToolApprovalDecision & {
+    commandId?: string;
+};
+/** Own the transport's existing live promises; persisted events are never authority. */
+export declare class PendingToolApprovals implements ToolApprovalController {
+    private readonly activeRequest;
+    private readonly onChanged?;
+    private readonly pending;
+    constructor(activeRequest: (id: string) => ActiveRequest | undefined, onChanged?: ((requestId: string) => void) | undefined);
+    requestToolApproval(request: ToolApprovalRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<ToolApprovalDecision>;
+    private notifyChanged;
+    list(environmentId: string): PendingWebToolApproval[];
+    decide(decision: WebToolApprovalDecision): boolean;
+    resolveRealtime(message: JsonObject): void;
+}

package/dist/src/web-ui/local-runtime/pending-tool-approvals.js

@@ -0,0 +1,104 @@
+import { getString } from "./http.js";
+function isRequiredApprovalEvent(event, requestId, approvalId) {
+    if (event.name !== "tool.approval.required")
+        return false;
+    if (event.approvalId !== approvalId)
+        return false;
+    return event.requestId === requestId;
+}
+function findRequiredApprovalEvent(active, approvalId) {
+    return active.events.find((event) => isRequiredApprovalEvent(event, active.requestId, approvalId));
+}
+function isLiveApprovalRequest(active, environmentId) {
+    if (!active || active.finalState)
+        return false;
+    return active.environmentId === environmentId;
+}
+function canResolvePendingApproval(pending, active, decision) {
+    if (!pending || pending.requestId !== decision.requestId)
+        return false;
+    if (!isLiveApprovalRequest(active, decision.environmentId))
+        return false;
+    if (active.sessionId !== decision.sessionId)
+        return false;
+    return Boolean(findRequiredApprovalEvent(active, decision.approvalId));
+}
+/** Own the transport's existing live promises; persisted events are never authority. */
+export class PendingToolApprovals {
+    activeRequest;
+    onChanged;
+    pending = new Map();
+    constructor(activeRequest, onChanged) {
+        this.activeRequest = activeRequest;
+        this.onChanged = onChanged;
+    }
+    requestToolApproval(request, options) {
+        return new Promise((resolve) => {
+            if (options?.abortSignal?.aborted) {
+                resolve({ approved: false, reason: "Tool approval was cancelled." });
+                return;
+            }
+            const complete = (decision) => {
+                const removed = this.pending.delete(request.approvalId);
+                options?.abortSignal?.removeEventListener("abort", onAbort);
+                resolve(decision);
+                if (removed)
+                    this.notifyChanged(request.requestId);
+            };
+            const onAbort = () => complete({ approved: false, reason: "Tool approval was cancelled." });
+            options?.abortSignal?.addEventListener("abort", onAbort, { once: true });
+            this.pending.set(request.approvalId, {
+                requestId: request.requestId,
+                resolve: complete,
+            });
+            this.notifyChanged(request.requestId);
+        });
+    }
+    notifyChanged(requestId) {
+        try {
+            this.onChanged?.(requestId);
+        }
+        catch {
+            // Client refresh failures cannot change a pending approval decision.
+        }
+    }
+    list(environmentId) {
+        const approvals = [];
+        for (const [approvalId, pending] of this.pending) {
+            const active = this.activeRequest(pending.requestId);
+            if (!isLiveApprovalRequest(active, environmentId))
+                continue;
+            const event = findRequiredApprovalEvent(active, approvalId);
+            if (!event)
+                continue;
+            approvals.push({
+                environmentId,
+                sessionId: active.sessionId,
+                requestId: active.requestId,
+                approvalId,
+                event,
+            });
+        }
+        return approvals;
+    }
+    decide(decision) {
+        const pending = this.pending.get(decision.approvalId);
+        const active = this.activeRequest(decision.requestId);
+        if (!canResolvePendingApproval(pending, active, decision))
+            return false;
+        pending.resolve({ approved: decision.approved });
+        return true;
+    }
+    resolveRealtime(message) {
+        const approvalId = getString(message.approvalId);
+        if (!approvalId)
+            return;
+        const pending = this.pending.get(approvalId);
+        if (!pending)
+            return;
+        pending.resolve({
+            approved: message.approved === true,
+            reason: getString(message.reason).trim() || undefined,
+        });
+    }
+}

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

@@ -8,6 +8,7 @@ export declare class LocalRealtimeController {
     private readonly environments;
     private readonly requests;
     private readonly clients;
+    private readonly approvals;
     constructor(options: LocalRuntimeBackendOptions, environments: RuntimeEnvironmentRegistry, requests: LocalRequestExecution, clients: RealtimeClientHub);
     connect(client: WebSocket): void;
     private handleMessage;

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

@@ -1,14 +1,17 @@
 import { getNumber, getString, requestEnvironmentId } from "./http.js";
+import { ManagedWebToolApprovals } from "./managed-tool-approvals.js";
 export class LocalRealtimeController {
     options;
     environments;
     requests;
     clients;
+    approvals;
     constructor(options, environments, requests, clients) {
         this.options = options;
         this.environments = environments;
         this.requests = requests;
         this.clients = clients;
+        this.approvals = new ManagedWebToolApprovals((id) => environments.get(id), requests);
     }
     connect(client) {
         this.clients.add(client);
@@ -27,8 +30,20 @@ export class LocalRealtimeController {
         if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
             return;
         const message = parsed;
+        if (message.type === "notification_presence") {
+            this.clients.updatePresence(client, message);
+            return;
+        }
         if (message.type === "tool_approval_response") {
-            this.requests.resolveToolApproval(message);
+            const accepted = await this.approvals.resolveRealtime(message, this.options.defaultEnvironmentId ?? "");
+            this.clients.send(client, {
+                type: "tool_approval_ack",
+                approvalId: message.approvalId,
+                accepted,
+                environment: message.environment,
+                sessionId: message.sessionId,
+                ...(accepted ? {} : { reason: "approval_conflict_or_unavailable" }),
+            });
             return;
         }
         if (message.type === "steer_request") {
@@ -45,7 +60,11 @@ export class LocalRealtimeController {
             return;
         const environmentId = requestEnvironmentId(new URL("/", "http://localhost"), message, this.options.defaultEnvironmentId);
         const environment = this.environments.get(environmentId);
-        const replay = await environment.services.sessions.getRequestReplayById(requestId, getNumber(message.afterSeq));
+        let replay = await environment.services.sessions.getRequestReplayById(requestId, getNumber(message.afterSeq));
+        if (!replay?.finalState) {
+            await this.approvals.resume(environmentId, requestId);
+            replay = await environment.services.sessions.getRequestReplayById(requestId, getNumber(message.afterSeq));
+        }
         for (const event of replay?.events ?? []) {
             this.clients.send(client, { ...event, environment: environmentId });
         }

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

@@ -1,8 +1,16 @@
 import type WebSocket from "ws";
 import type { JsonObject } from "./contracts.js";
+import { NotificationPresence } from "../notifications/presence.js";
 export declare class RealtimeClientHub {
+    private readonly observe?;
     private readonly clients;
+    readonly presence: NotificationPresence;
+    constructor(observe?: ((payload: JsonObject) => void) | undefined);
     add(client: WebSocket): void;
     broadcast(payload: JsonObject): void;
     send(client: WebSocket, payload: JsonObject): void;
+    updatePresence(client: WebSocket, payload: JsonObject): void;
+    private canAcceptPresence;
+    private pruneNonOpenClients;
+    private remove;
 }

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

@@ -1,18 +1,58 @@
+import { NotificationPresence } from "../notifications/presence.js";
+function isRealtimeClientOpen(client) {
+    return client.readyState === client.OPEN;
+}
 export class RealtimeClientHub {
+    observe;
     clients = new Set();
+    presence = new NotificationPresence();
+    constructor(observe) {
+        this.observe = observe;
+    }
     add(client) {
         this.clients.add(client);
-        const remove = () => this.clients.delete(client);
+        const remove = () => this.remove(client);
         client.on("close", remove);
         client.on("error", remove);
     }
     broadcast(payload) {
-        for (const client of this.clients)
-            this.send(client, payload);
+        this.pruneNonOpenClients();
+        this.observe?.(payload);
+        for (const client of this.clients) {
+            try {
+                this.send(client, payload);
+            }
+            catch {
+                this.remove(client);
+            }
+        }
     }
     send(client, payload) {
-        if (client.readyState !== client.OPEN)
+        if (!isRealtimeClientOpen(client))
             return;
         client.send(JSON.stringify(payload));
     }
+    updatePresence(client, payload) {
+        if (!this.canAcceptPresence(client)) {
+            this.presence.remove(client);
+            return;
+        }
+        this.presence.update(client, payload);
+    }
+    canAcceptPresence(client) {
+        if (!this.clients.has(client))
+            return false;
+        return isRealtimeClientOpen(client);
+    }
+    pruneNonOpenClients() {
+        for (const client of this.clients) {
+            if (isRealtimeClientOpen(client))
+                continue;
+            this.remove(client);
+        }
+    }
+    remove(client) {
+        this.clients.delete(client);
+        this.presence.remove(client);
+    }
 }