@abot-ai/runtime 1.4.0 → 1.5.0

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

@@ -0,0 +1,58 @@
+import { createRequestSteeringInbox } from "../../runtime/request/request-steering.js";
+function hasMatchingRequestView(active, input) {
+    if (active.environmentId !== input.environmentId)
+        return false;
+    return active.sessionId === input.pending.sessionId;
+}
+/** Restore only a projection of an owner-confirmed pending request, never a new run. */
+export async function attachApprovalRequest(input) {
+    const { pending, environmentId, environment, activeRequests } = input;
+    const requestId = pending.request.requestId;
+    let active = activeRequests.get(requestId);
+    const createdProjection = !active;
+    if (active && !hasMatchingRequestView(active, input))
+        throw new Error("tool_approval_request_identity_mismatch");
+    if (!active) {
+        active = {
+            requestId,
+            sessionId: pending.sessionId,
+            environmentId,
+            startedAt: Date.now(),
+            lastEventAt: Date.now(),
+            lastEventName: "tool.approval.required",
+            events: [...input.events],
+            finalState: null,
+            requestSteering: createRequestSteeringInbox({ requestId }),
+        };
+        activeRequests.set(requestId, active);
+    }
+    if (pending.run)
+        return;
+    const projection = active;
+    await new Promise((resolve, reject) => {
+        let accepted = false;
+        void environment.approvals
+            .attach(requestId, pending.sessionId, { send: input.publish }, { toolApprovalController: input.toolApprovals }, () => {
+            accepted = true;
+            resolve();
+        })
+            .catch((error) => {
+            if (createdProjection && activeRequests.get(requestId) === projection)
+                activeRequests.delete(requestId);
+            if (accepted)
+                input.publish(JSON.stringify({
+                    type: "control",
+                    requestId,
+                    name: "local_runtime_approval_attachment_lost",
+                    error: error instanceof Error ? error.message : String(error),
+                }));
+            reject(error);
+        })
+            .finally(() => {
+            if (!projection.finalState)
+                return;
+            if (activeRequests.get(requestId) === projection)
+                activeRequests.delete(requestId);
+        });
+    });
+}

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

@@ -2,6 +2,7 @@ import type { WebUiEnvironmentConfig } from "../environment-config.js";
 import type { RuntimeSetupActivation } from "./runtime-setup-input.js";
 import { type LocalRuntimeApplicationOptions } from "../../runtime/local-application.js";
 import type { LocalRuntimeBackendOptions, RuntimeEnvironment, RuntimeModelCatalogState, RuntimeSetupRequirement } from "./contracts.js";
+import type { LearningChangedEvent } from "../../runtime/passive-learning/contracts.js";
 export declare class RuntimeEnvironmentRegistry {
     private readonly options;
     private readonly schedulerBindings;
@@ -15,6 +16,7 @@ export declare class RuntimeEnvironmentRegistry {
     constructor(options: LocalRuntimeBackendOptions, schedulerBindings?: {
         requestOptions?: LocalRuntimeApplicationOptions["scheduledRequestOptions"];
         publish?: (event: Record<string, unknown>) => void;
+        publishLearning?: (environmentId: string, event?: LearningChangedEvent) => void;
     });
     environmentConfig(): WebUiEnvironmentConfig | undefined;
     applyConfiguration(): Promise<RuntimeSetupActivation>;

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

@@ -143,6 +143,7 @@ export class RuntimeEnvironmentRegistry {
         if (this.schedulerBindings.publish) {
             environment.subscribeScheduledEvents(this.schedulerBindings.publish);
         }
+        environment.subscribeLearningEvents?.((event) => this.schedulerBindings.publishLearning?.(environmentId, event));
         return environment;
     }
     async start(environmentIds) {

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

@@ -0,0 +1,2 @@
+import type { RealtimeClientHub } from "./realtime-hub.js";
+export declare function createLearningChangeNotifier(realtime: Pick<RealtimeClientHub, "broadcast">): (environmentId: string, change?: unknown) => void;

package/dist/src/web-ui/local-runtime/learning-notifications.js

@@ -0,0 +1,20 @@
+import { projectLearningChangedEvent } from "../../runtime/local-host/learning-events.js";
+import { createWorkspaceChangeNotifier } from "./workspace-notifications.js";
+export function createLearningChangeNotifier(realtime) {
+    const notifyWorkspace = createWorkspaceChangeNotifier(realtime);
+    return (environmentId, change) => {
+        const event = projectLearningChangedEvent(change);
+        try {
+            realtime.broadcast({
+                type: "learning.changed",
+                environmentId,
+                ...(event ? { event } : {}),
+            });
+        }
+        catch {
+            // Persisted conversations and proposal status are fetched on reconnect.
+        }
+        if (event)
+            notifyWorkspace(environmentId, ["sessions"]);
+    };
+}

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

@@ -0,0 +1,19 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { PassiveLearningManagement } from "../../runtime/local-host/client-learning.js";
+type LearningRouteRequest = Readonly<{
+    method: string;
+    route: string;
+    segments: readonly string[];
+    url: URL;
+    body: Record<string, unknown> | null;
+    environmentId: string;
+    request: IncomingMessage;
+    response: ServerResponse;
+}>;
+export declare class PassiveLearningRoutes {
+    private readonly resolveService;
+    constructor(resolveService: (environmentId: string) => PassiveLearningManagement);
+    handle(input: LearningRouteRequest): Promise<boolean>;
+    private dispatch;
+}
+export {};

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

@@ -0,0 +1,184 @@
+import { acceptConfigMutationRequest } from "./config-mutation-request.js";
+import { sendJson } from "./http.js";
+import { readLearningPreferencesInput } from "../../runtime/local-host/learning-preferences-input.js";
+import { isLearningEventId } from "../../runtime/local-host/learning-events.js";
+export class PassiveLearningRoutes {
+    resolveService;
+    constructor(resolveService) {
+        this.resolveService = resolveService;
+    }
+    async handle(input) {
+        if (!isLearningRoute(input.segments))
+            return false;
+        input.response.setHeader("cache-control", "no-store");
+        if (isLearningMutation(input.method, input.route) &&
+            !acceptConfigMutationRequest(input.request, input.response))
+            return true;
+        try {
+            await this.dispatch(input, this.resolveService(input.environmentId));
+        }
+        catch (error) {
+            const message = publicLearningFailure(error);
+            sendJson(input.response, 409, {
+                ok: false,
+                error: "passive_learning_unavailable",
+                message,
+            });
+        }
+        return true;
+    }
+    async dispatch(input, service) {
+        if (input.route === "runtime/learning") {
+            if (input.method === "GET") {
+                sendJson(input.response, 200, {
+                    ok: true,
+                    status: await service.status(),
+                });
+                return;
+            }
+            if (input.method === "PUT") {
+                const preferences = readLearningPreferences(input.body);
+                if (!preferences) {
+                    sendJson(input.response, 400, {
+                        ok: false,
+                        error: "passive_learning_preferences_invalid",
+                    });
+                    return;
+                }
+                sendJson(input.response, 200, {
+                    ok: true,
+                    status: await service.configure(preferences),
+                });
+                return;
+            }
+            sendLearningMethodNotAllowed(input.response, "GET, PUT");
+            return;
+        }
+        if (input.route === "runtime/learning/collection/restart") {
+            if (input.method !== "POST") {
+                sendLearningMethodNotAllowed(input.response, "POST");
+                return;
+            }
+            if (!service.restartCollection)
+                throw new Error("passive_learning_unavailable");
+            sendJson(input.response, 200, {
+                ok: true,
+                status: await service.restartCollection(),
+            });
+            return;
+        }
+        if (input.segments[2] === "proposals") {
+            if (input.method !== "DELETE") {
+                sendLearningMethodNotAllowed(input.response, "DELETE");
+                return;
+            }
+            const id = input.segments[3];
+            if (!isLearningEventId(id)) {
+                sendJson(input.response, 400, {
+                    ok: false,
+                    error: "passive_learning_proposal_invalid",
+                });
+                return;
+            }
+            if (!service.dismissProposal)
+                throw new Error("passive_learning_unavailable");
+            await service.dismissProposal(id);
+            sendJson(input.response, 200, { ok: true });
+            return;
+        }
+        if (input.route === "runtime/learning/pending") {
+            if (input.method !== "DELETE") {
+                sendLearningMethodNotAllowed(input.response, "DELETE");
+                return;
+            }
+            sendJson(input.response, 200, {
+                ok: true,
+                status: await service.clearPending(),
+            });
+            return;
+        }
+        if (input.method !== "GET") {
+            sendLearningMethodNotAllowed(input.response, "GET");
+            return;
+        }
+        if (input.route === "runtime/learning/candidates") {
+            if (!service.candidates)
+                throw new Error("passive_learning_unavailable");
+            sendJson(input.response, 200, {
+                ok: true,
+                items: await service.candidates(),
+            });
+            return;
+        }
+        if (input.route === "runtime/learning/batches") {
+            sendJson(input.response, 200, {
+                ok: true,
+                items: await service.batches({ limit: 20 }),
+            });
+            return;
+        }
+        const batch = await service.batch(input.segments[3]);
+        if (!batch) {
+            sendJson(input.response, 404, {
+                ok: false,
+                error: "passive_learning_batch_not_found",
+            });
+            return;
+        }
+        sendJson(input.response, 200, { ok: true, batch });
+    }
+}
+function isLearningRoute(segments) {
+    if (segments[0] !== "runtime" || segments[1] !== "learning")
+        return false;
+    if (segments.length === 2)
+        return true;
+    if (segments[2] === "collection")
+        return segments.length === 4 && segments[3] === "restart";
+    if (segments[2] === "pending")
+        return segments.length === 3;
+    if (segments[2] === "candidates")
+        return segments.length === 3;
+    if (segments[2] === "proposals")
+        return segments.length === 4;
+    if (segments[2] !== "batches")
+        return false;
+    return segments.length === 3 || segments.length === 4;
+}
+function isLearningMutation(method, route) {
+    if (method === "POST")
+        return route === "runtime/learning/collection/restart";
+    return method === "PUT" || method === "DELETE";
+}
+function readLearningPreferences(body) {
+    if (!body)
+        return undefined;
+    const { environment: _environment, environmentId: _environmentId, ...preferences } = body;
+    try {
+        return readLearningPreferencesInput(preferences);
+    }
+    catch {
+        return undefined;
+    }
+}
+function publicLearningFailure(error) {
+    const actionableFailures = new Set([
+        "learning_model_required",
+        "proactive_model_required",
+        "learning_activity_not_allowed",
+        "learning_model_profile_unavailable",
+        "learning_model_profile_overridden",
+        "learning_memory_unavailable",
+        "invalid_learning_preferences",
+        "invalid_learning_model_profile",
+        "invalid_learning_exclusions",
+        "learning_storage_unavailable",
+    ]);
+    return error instanceof Error && actionableFailures.has(error.message)
+        ? error.message
+        : "passive_learning_unavailable";
+}
+function sendLearningMethodNotAllowed(response, allow) {
+    response.setHeader("allow", allow);
+    sendJson(response, 405, { ok: false, error: "method_not_allowed" });
+}

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

@@ -0,0 +1,15 @@
+import type { JsonObject, RuntimeEnvironment } from "./contracts.js";
+import type { LocalRequestExecution } from "./request-execution.js";
+import type { PendingWebToolApproval, WebToolApprovalDecision } from "./pending-tool-approvals.js";
+/** Read and decide canonical saved waits and the owner's legacy live approvals. */
+export declare class ManagedWebToolApprovals {
+    private readonly environment;
+    private readonly requests;
+    constructor(environment: (id: string) => RuntimeEnvironment, requests: LocalRequestExecution);
+    list(environmentId: string): Promise<PendingWebToolApproval[]>;
+    decide(decision: WebToolApprovalDecision): Promise<boolean>;
+    resume(environmentId: string, requestId: string): Promise<void>;
+    resolveRealtime(message: JsonObject, defaultEnvironmentId: string): Promise<boolean>;
+    private attach;
+    private events;
+}

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

@@ -0,0 +1,121 @@
+import { getString } from "./http.js";
+function matchesApprovalScope(pending, decision) {
+    if (pending.sessionId !== decision.sessionId)
+        return false;
+    if (pending.request.requestId !== decision.requestId)
+        return false;
+    return pending.request.approvalId === decision.approvalId;
+}
+function isApprovalRequiredEvent(event, approvalId) {
+    if (event.name !== "tool.approval.required")
+        return false;
+    return event.approvalId === approvalId;
+}
+/** Read and decide canonical saved waits and the owner's legacy live approvals. */
+export class ManagedWebToolApprovals {
+    environment;
+    requests;
+    constructor(environment, requests) {
+        this.environment = environment;
+        this.requests = requests;
+    }
+    async list(environmentId) {
+        const environment = this.environment(environmentId);
+        const pending = await environment.approvals.list();
+        const approvals = [];
+        for (const entry of pending) {
+            const events = await this.events(environmentId, environment, entry);
+            const event = events.find((value) => isApprovalRequiredEvent(value, entry.request.approvalId));
+            if (!event)
+                continue;
+            approvals.push({
+                ...(entry.wait ? entry.wait : {}),
+                environmentId,
+                sessionId: entry.sessionId,
+                requestId: entry.request.requestId,
+                approvalId: entry.request.approvalId,
+                event,
+            });
+        }
+        return approvals;
+    }
+    async decide(decision) {
+        const environment = this.environment(decision.environmentId);
+        const pending = await environment.approvals.list(decision.sessionId);
+        const entry = pending.find((value) => matchesApprovalScope(value, decision));
+        if (!entry && !decision.waitId)
+            return false;
+        if (entry && !entry.wait)
+            await this.attach(decision.environmentId, environment, entry);
+        const result = await environment.approvals.decide({
+            sessionId: decision.sessionId,
+            requestId: decision.requestId,
+            approvalId: decision.approvalId,
+            approved: decision.approved,
+            reason: decision.reason,
+            ...(decision.waitId
+                ? {
+                    generation: decision.generation,
+                    waitId: decision.waitId,
+                    revision: decision.revision,
+                    commandId: decision.commandId,
+                }
+                : {}),
+        });
+        return result.accepted;
+    }
+    async resume(environmentId, requestId) {
+        const environment = this.environment(environmentId);
+        const pending = await environment.approvals.list();
+        const entry = pending.find((value) => value.request.requestId === requestId);
+        if (entry && !entry.wait)
+            await this.attach(environmentId, environment, entry);
+    }
+    async resolveRealtime(message, defaultEnvironmentId) {
+        if (typeof message.approved !== "boolean")
+            return false;
+        const approvalId = getString(message.approvalId);
+        if (!approvalId)
+            return false;
+        const environmentId = getString(message.environment) || defaultEnvironmentId;
+        if (typeof message.waitId === "string") {
+            return this.decide({
+                environmentId,
+                approvalId,
+                sessionId: getString(message.sessionId),
+                requestId: getString(message.requestId),
+                generation: getString(message.generation),
+                waitId: message.waitId,
+                revision: Number(message.revision),
+                commandId: getString(message.commandId),
+                approved: message.approved,
+                ...(typeof message.reason === "string"
+                    ? { reason: message.reason }
+                    : {}),
+            });
+        }
+        const approvals = await this.list(environmentId);
+        const pending = approvals.find((value) => value.approvalId === approvalId);
+        if (!pending)
+            return false;
+        return this.decide({
+            ...pending,
+            approved: message.approved,
+            reason: getString(message.reason).trim() || undefined,
+        });
+    }
+    async attach(environmentId, environment, pending) {
+        const events = await this.events(environmentId, environment, pending);
+        await this.requests.attachToolApproval(environmentId, environment, pending, events);
+    }
+    async events(environmentId, environment, pending) {
+        const active = this.requests.activeReplayForSession(pending.request.requestId, pending.sessionId, environmentId);
+        const hasRequiredEvent = active?.some((event) => isApprovalRequiredEvent(event, pending.request.approvalId));
+        if (hasRequiredEvent)
+            return active;
+        const replay = await environment.services.sessions.getRequestReplayById(pending.request.requestId);
+        if (replay?.sessionId !== pending.sessionId)
+            return [];
+        return replay.events;
+    }
+}

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

@@ -3,9 +3,13 @@ const ENVIRONMENT_FIELDS = ["environment", "environmentId"];
 export function readMemoryPage(url) {
     const limit = readOptionalInteger(url, "limit", false);
     const offset = readOptionalInteger(url, "offset", true);
+    const origin = url.searchParams.get("origin");
+    if (origin !== null && origin !== "passive_observation")
+        throw invalidManagementInput();
     return Object.freeze({
         ...(limit === undefined ? {} : { limit }),
         ...(offset === undefined ? {} : { offset }),
+        ...(origin === "passive_observation" ? { origin } : {}),
     });
 }
 export function readMemoryCreateInput(body) {

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

@@ -1,12 +1,14 @@
 import type { ServerResponse } from "node:http";
 import type { LongTermMemoryRecord, LongTermMemoryStatus } from "../../runtime/long-term-memory/contracts.js";
+import type { ObservationMemorySource } from "../../runtime/long-term-memory/observation-contracts.js";
 export type WebMemoryRecord = Readonly<{
     id: string;
     content: string;
     tags: readonly string[];
-    origin: "passive_response" | "web_ui" | "management_api";
+    origin: "passive_response" | "passive_observation" | "web_ui" | "management_api";
     createdAt: string;
     updatedAt: string;
+    observationSources?: readonly Pick<ObservationMemorySource, "kind" | "batchId" | "observedAt" | "reason" | "certainty">[];
 }>;
 export type WebMemoryStatus = Readonly<{
     enabled: boolean;

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

@@ -7,15 +7,29 @@ export function projectWebMemoryStatus(status) {
     });
 }
 export function projectWebMemoryRecord(record) {
+    const sources = record.provenance.kind === "passive_observation"
+        ? [record.provenance, ...(record.observationSources ?? [])]
+        : [...(record.observationSources ?? [])];
     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,
+        origin: record.provenance.kind === "manual"
+            ? record.provenance.source
+            : record.provenance.kind,
         createdAt: record.createdAt,
         updatedAt: record.updatedAt,
+        ...(sources.length
+            ? {
+                observationSources: sources.map(({ kind, batchId, observedAt, reason, certainty }) => ({
+                    kind,
+                    batchId,
+                    observedAt,
+                    reason,
+                    certainty,
+                })),
+            }
+            : {}),
     });
 }
 export function sendMemoryManagementError(response, error) {

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

@@ -0,0 +1,13 @@
+import { type ConfigFileTransaction } from "../../runtime/adapters/config-file-transaction.js";
+export type ModelRemovalInput = Readonly<{
+    profileId: string;
+    expectedRevision: string;
+}>;
+/** Remove the declaration only; referenced files and provider credentials remain intact. */
+export declare function removeRuntimeModelDeclaration(options: {
+    rootDir: string;
+    configPath: string;
+}, transaction: ConfigFileTransaction, body: Record<string, unknown>): Promise<{
+    profileId: string;
+    restartRequired: boolean;
+}>;

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

@@ -0,0 +1,74 @@
+import { ConfigFileConflictError, canonicalConfigFilePath, } from "../../runtime/adapters/config-file-transaction.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { RuntimeConfigValidationError } from "../../runtime/config/validation.js";
+import { ModelSetupError } from "./model-setup-input.js";
+import { validateModelConfigurationChange } from "./model-setup-validation.js";
+function hasUnsupportedRemovalFields(body) {
+    return Object.keys(body).some((key) => !["profileId", "expectedRevision"].includes(key));
+}
+function hasRemovalProfileId(body) {
+    if (typeof body.profileId !== "string")
+        return false;
+    return body.profileId.trim().length > 0;
+}
+function hasRemovalRevision(body) {
+    if (typeof body.expectedRevision !== "string")
+        return false;
+    return body.expectedRevision.trim().length > 0;
+}
+function parseModelRemovalInput(body) {
+    if (hasUnsupportedRemovalFields(body))
+        throw new ModelSetupError("invalid_model_input", "The model removal contains unsupported fields.");
+    if (!hasRemovalProfileId(body))
+        throw new ModelSetupError("invalid_model_input", "Choose a registered model to remove.");
+    if (!hasRemovalRevision(body))
+        throw new ModelSetupError("config_revision_required", "Reload Configuration before removing this model.", 428);
+    return { profileId: body.profileId, expectedRevision: body.expectedRevision };
+}
+async function validateRemovalCandidate(candidate, options) {
+    try {
+        await validateModelConfigurationChange(candidate, options);
+    }
+    catch (error) {
+        if (!(error instanceof RuntimeConfigValidationError))
+            throw error;
+        throw new ModelSetupError("model_removal_invalid_config", "Removing this model would leave an invalid configuration. " +
+            error.issues.join("; "), 409);
+    }
+}
+async function hasSelectedRemovalTarget(configPath, transaction) {
+    return transaction.path === (await canonicalConfigFilePath(configPath));
+}
+/** Remove the declaration only; referenced files and provider credentials remain intact. */
+export async function removeRuntimeModelDeclaration(options, transaction, body) {
+    const input = parseModelRemovalInput(body);
+    if (!(await hasSelectedRemovalTarget(options.configPath, transaction)))
+        throw new Error("Model removal requires the canonical Runtime transaction.");
+    if (transaction.snapshot.revision !== input.expectedRevision)
+        throw new ModelSetupError("config_changed", "Configuration changed since it was loaded. Reload Configuration before removing this model.", 409);
+    const config = transaction.snapshot.config;
+    const models = isRecord(config.models) ? config.models : {};
+    const profiles = isRecord(models.profiles) ? models.profiles : {};
+    if (!Object.hasOwn(profiles, input.profileId))
+        throw new ModelSetupError("model_profile_not_registered", "This model is no longer registered. Reload Configuration.", 409);
+    const remainingProfiles = { ...profiles };
+    delete remainingProfiles[input.profileId];
+    const candidate = {
+        ...config,
+        models: { ...models, profiles: remainingProfiles },
+    };
+    await validateRemovalCandidate(candidate, options);
+    try {
+        if (!(await hasSelectedRemovalTarget(options.configPath, transaction)))
+            throw new ConfigFileConflictError();
+        await transaction.write(candidate, {
+            expectedRevision: input.expectedRevision,
+        });
+    }
+    catch (error) {
+        if (!(error instanceof ConfigFileConflictError))
+            throw error;
+        throw new ModelSetupError("config_changed", error.message, 409);
+    }
+    return { profileId: input.profileId, restartRequired: true };
+}

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

@@ -39,7 +39,9 @@ export async function getModelSetupCatalog(options) {
         providers,
         defaultContextWindowTokens: await readDefaultContextWindowTokens(),
         profileIds: [
-            ...new Set(dashboard.files.models.map((profile) => profile.id)),
+            ...new Set(dashboard.files.models
+                .filter((profile) => profile.registered)
+                .map((profile) => profile.id)),
         ],
     };
 }

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

@@ -39,6 +39,15 @@ function requireIdentifier(value, kind) {
     }
     return kind === "profile" ? parseRuntimeModelProfileId(value) : value;
 }
+function hasWindowsDeviceBasename(value) {
+    return /^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/iu.test(value);
+}
+function requirePortableModelProfileId(value) {
+    const profileId = requireIdentifier(value, "profile");
+    if (hasWindowsDeviceBasename(profileId))
+        throw new ModelSetupError("invalid_profile_id", "Choose a profile ID that is not a reserved Windows device name.");
+    return profileId;
+}
 function readNewProvider(value) {
     if (!isRecord(value))
         throw new ModelSetupError("invalid_model_provider", "Choose a configured provider or add a new provider.");
@@ -78,7 +87,7 @@ export function parseModelSetupInput(body) {
         "newProvider",
         "apiKey",
     ]);
-    const profileId = requireIdentifier(inputString(body, "profileId"), "profile");
+    const profileId = requirePortableModelProfileId(inputString(body, "profileId"));
     let contextWindowTokens;
     try {
         contextWindowTokens = parseContextWindowTokens(body.contextWindowTokens);

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

@@ -0,0 +1,17 @@
+import { type ConfigFileTransaction } from "../../runtime/adapters/config-file-transaction.js";
+type ProfileFileOptions = {
+    rootDir: string;
+    configPath: string;
+};
+export declare function modelSetupProfilePath(options: ProfileFileOptions, profileId: string): Promise<string>;
+export declare function isDiscoveredModelSetupProfileAtTarget(options: ProfileFileOptions, profileId: string, discoveredPath: string): Promise<boolean>;
+/** The caller holds the Runtime lock; a new or exact existing profile is locked until commit. */
+export declare function withModelSetupProfile<T>(options: ProfileFileOptions, root: ConfigFileTransaction, profileId: string, profile: Record<string, unknown>, commit: (declaration: {
+    configRef: string;
+}, assertProfileUnchanged: () => Promise<void>) => Promise<T>): Promise<T>;
+/** Preserve exact retry identity for both legacy inline and linked declarations. */
+export declare function readSavedModelSetupProfile(options: ProfileFileOptions, declaration: Record<string, unknown>): Promise<{
+    profile: Record<string, unknown>;
+    assertUnchanged: () => Promise<void>;
+}>;
+export {};