@xfey/tutti 0.1.78 → 0.1.80

package/dist/server-shell/cli/host-project-runtime-lifecycle.js

@@ -0,0 +1,54 @@
+export class HostProjectRuntimeShutdownError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "HostProjectRuntimeShutdownError";
+    }
+}
+const DEFAULT_GRACEFUL_DRAIN_MS = 1_000;
+const DEFAULT_FORCED_DRAIN_MS = 10_000;
+function wait(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+async function settlesWithin(promise, timeoutMs) {
+    return await Promise.race([
+        promise.then(() => true),
+        wait(timeoutMs).then(() => false),
+    ]);
+}
+export class HostProjectRuntimeLifecycle {
+    options;
+    closePromise;
+    constructor(options) {
+        this.options = options;
+    }
+    close() {
+        this.closePromise ??= this.closeOnce();
+        return this.closePromise;
+    }
+    async closeOnce() {
+        this.options.controlPlane.beginShutdown();
+        this.options.chatAssistant.stopAccepting();
+        this.options.invocationCoordinator.stopAccepting();
+        this.options.checkProcessCoordinator.stopAccepting();
+        this.options.approvalManager.clearPending();
+        const waitForOwners = () => Promise.all([
+            this.options.chatAssistant.waitForIdle(),
+            this.options.controlPlane.waitForIdle(),
+            this.options.invocationCoordinator.waitForIdle(),
+            this.options.checkProcessCoordinator.waitForIdle(),
+        ]).then(() => undefined);
+        if (!(await settlesWithin(waitForOwners(), this.options.gracefulDrainMs ?? DEFAULT_GRACEFUL_DRAIN_MS))) {
+            await Promise.all([
+                this.options.invocationCoordinator.closeActive(),
+                this.options.checkProcessCoordinator.terminateActive(),
+            ]);
+            if (!(await settlesWithin(waitForOwners(), this.options.forcedDrainMs ?? DEFAULT_FORCED_DRAIN_MS))) {
+                throw new HostProjectRuntimeShutdownError("drain_timeout", "Host project runtime did not settle within the bounded shutdown window.");
+            }
+        }
+        this.options.approvalManager.dispose();
+    }
+}
+//# sourceMappingURL=host-project-runtime-lifecycle.js.map

package/dist/server-shell/cli/host-server-runtime.d.ts

@@ -1,5 +1,5 @@
 import type { FastifyInstance } from "fastify";
-import type { ExecutionStatusProjection } from "@tutti/shared/schemas/api";
+import { type ExecutionStatusProjection } from "@tutti/shared/schemas/api";
 import { type HostProjectStore } from "../../store/index.js";
 import type { createHostServer } from "../http/create-server.js";
 import type { HostLocalLaunchStatus } from "../http/routes/local-control.js";

package/dist/server-shell/cli/host-server-runtime.js

@@ -1,14 +1,18 @@
 import { basename, join } from "node:path";
+import { MAX_PROVIDER_MODEL_NAME_LENGTH, } from "@tutti/shared/schemas/api";
 import { serializeRuntimeLogLine } from "@tutti/shared/utils";
 import { completeRelayUpload, resolveRelayUpload } from "@tutti/relay-client";
 import { ApprovalRequestManager } from "../../approvals/index.js";
 import { ArtifactPreviewManager } from "../../artifacts/index.js";
 import { ReadOnlyChatAssistant } from "../../chat-assistant/index.js";
+import { CheckProcessCoordinator } from "../../checks/index.js";
 import { ensureInitialProjectWelcomeMessage } from "../../collaboration-state/index.js";
 import { Phase5ControlPlane } from "../../control-plane/index.js";
 import { resolveProjectOpenAiProcedureWorkflowRunner } from "../../control-plane/workflows/index.js";
+import { cleanupStaleCodexAppServerTempRoots } from "../../providers/openai/app-server/stale-temp-cleanup.js";
+import { CodexAppServerInvocationCoordinator } from "../../providers/openai/app-server/invocation-coordinator.js";
 import { resolveProjectOpenAiReadOnlyChatAssistantModel } from "../../providers/openai/chat-assistant.js";
-import { configureProjectOpenAiProvider, readOpenAiProviderConfigProjection, } from "../../providers/openai/index.js";
+import { configureProjectOpenAiProvider, discoverProjectOpenAiModels, readOpenAiProviderConfigProjection, updateProjectOpenAiDefaultModel, } from "../../providers/openai/index.js";
 import { readProviderUsageProjection, recordProviderUsageEvent, } from "../../provider-usage/index.js";
 import { resolveProjectOpenAiRunPipelineRunner } from "../../run-pipeline/openai.js";
 import { openHostProjectStore } from "../../store/index.js";
@@ -18,6 +22,7 @@ import { readHostRepoProjection } from "../http/routes/project-api.js";
 import { WorkspaceEventBus } from "../http/workspace-events.js";
 import { createTrustedRelaySessionMetadataStore, } from "../session/relay-session-context.js";
 import { LaunchError } from "./errors.js";
+import { HostProjectRuntimeLifecycle } from "./host-project-runtime-lifecycle.js";
 import { readCliVersion } from "./version.js";
 import { relayStateFromLaunchStatus } from "./host-relay-status.js";
 import { appendHostLogLine, readHostRegistrationSecret, createMachineRuntimeEndpointToken, deleteMachineRuntimeEndpoint, ensureHostLogFile, getHostLogFilePath, updateMachineProjectDisplayNameSnapshot, writeMachineRuntimeEndpoint, } from "./machine-local.js";
@@ -32,6 +37,62 @@ export function packageUpdateReadinessFromExecutionStatus(execution) {
         ? "busy"
         : "ready";
 }
+function createHostProviderModelService(options) {
+    return {
+        discover: async () => {
+            const result = await discoverProjectOpenAiModels(options);
+            if (result.kind !== "ok") {
+                return { status: "unavailable", reason: result.reason };
+            }
+            const models = result.models.filter((model) => model.length <= MAX_PROVIDER_MODEL_NAME_LENGTH && /^\S(?:.*\S)?$/.test(model));
+            return models.length > 0
+                ? { status: "available", models }
+                : { status: "unavailable", reason: "model_list_empty" };
+        },
+        update: async (payload) => {
+            const result = await updateProjectOpenAiDefaultModel({
+                ...options,
+                defaultModel: payload.default_model,
+                expectedDefaultModel: payload.expected_default_model,
+            });
+            if (result.kind === "updated") {
+                return {
+                    disposition: { kind: "updated" },
+                    provider_config: result.projection,
+                };
+            }
+            if (result.kind === "unchanged") {
+                return {
+                    disposition: { kind: "unchanged" },
+                    provider_config: result.projection,
+                };
+            }
+            if (result.kind === "stale_default_model") {
+                return {
+                    disposition: {
+                        kind: result.kind,
+                        current_default_model: result.current_default_model,
+                    },
+                };
+            }
+            if (result.kind === "validation_failed") {
+                return {
+                    disposition: {
+                        kind: result.kind,
+                        reason: result.reason,
+                        retryable: result.retryable,
+                    },
+                };
+            }
+            return {
+                disposition: {
+                    kind: result.kind,
+                    reason: result.reason,
+                },
+            };
+        },
+    };
+}
 function createHostRuntimeLogger(options) {
     return {
         info(fields, message) {
@@ -47,6 +108,15 @@ function createHostRuntimeLogger(options) {
         },
     };
 }
+function createLifecycleIncidentReporter(logger, consumer) {
+    return (incident) => {
+        logger.info({
+            consumer,
+            incident_code: incident.code,
+            error_code: incident.error_code,
+        }, "Codex app-server lifecycle incident");
+    };
+}
 function createAgentContextRuntime(options) {
     return {
         baseUrl: new URL(AGENT_CONTEXT_BASE_PATH, options.baseUrl).toString(),
@@ -214,10 +284,25 @@ export async function startForegroundHostServer(options) {
         logFilePath,
         now,
     });
+    const procedureLifecycleIncident = createLifecycleIncidentReporter(controlPlaneLogger, "procedure");
+    const runLifecycleIncident = createLifecycleIncidentReporter(runPipelineLogger, "run");
+    const chatLifecycleIncident = createLifecycleIncidentReporter(controlPlaneLogger, "chat_assistant");
+    const staleTempCleanup = await cleanupStaleCodexAppServerTempRoots({
+        onIncident: (incident) => {
+            controlPlaneLogger.info({
+                consumer: "maintenance",
+                incident_code: incident.code,
+                error_code: incident.error_code,
+            }, "Codex app-server lifecycle incident");
+        },
+    });
+    controlPlaneLogger.info(staleTempCleanup, "Codex app-server stale temp cleanup completed");
     const approvalManager = new ApprovalRequestManager({
         events: workspaceEvents,
         now,
     });
+    const codexInvocationCoordinator = new CodexAppServerInvocationCoordinator();
+    const checkProcessCoordinator = new CheckProcessCoordinator();
     const artifactPreviewManager = new ArtifactPreviewManager({
         onStatusChange: () => {
             workspaceEvents.publish({
@@ -254,6 +339,9 @@ export async function startForegroundHostServer(options) {
             approvalManager,
             logger: runPipelineLogger,
             recordUsage,
+            invocationCoordinator: codexInvocationCoordinator,
+            checkProcessCoordinator,
+            onLifecycleIncident: runLifecycleIncident,
         }),
         resolveWorkflowRunner: () => resolveProjectOpenAiProcedureWorkflowRunner({
             tuttiHome: options.preparation.tutti_home,
@@ -261,6 +349,8 @@ export async function startForegroundHostServer(options) {
             workspaceRoot: options.preparation.workspace_root,
             agentContext: agentContextRuntime,
             recordUsage,
+            invocationCoordinator: codexInvocationCoordinator,
+            onLifecycleIncident: procedureLifecycleIncident,
         }),
     });
     const chatAssistant = new ReadOnlyChatAssistant({
@@ -276,6 +366,8 @@ export async function startForegroundHostServer(options) {
                     workspaceRoot: options.preparation.workspace_root,
                     agentContext: agentContextRuntime,
                     recordUsage,
+                    invocationCoordinator: codexInvocationCoordinator,
+                    onLifecycleIncident: chatLifecycleIncident,
                 });
                 if (resolution.kind !== "ready") {
                     throw new Error("Provider is not configured.");
@@ -283,9 +375,17 @@ export async function startForegroundHostServer(options) {
                 return await resolution.model.answer(input);
             },
         },
+        waitForInspectionAvailability: () => controlPlane.waitForRepoInspectionIdle(),
         onScratchpadSourceChanged: (message) => controlPlane.notifyScratchpadSourceChanged(message),
         now,
     });
+    const projectRuntimeLifecycle = new HostProjectRuntimeLifecycle({
+        controlPlane,
+        chatAssistant,
+        invocationCoordinator: codexInvocationCoordinator,
+        checkProcessCoordinator,
+        approvalManager,
+    });
     let close = async () => { };
     let relayConnectionManager;
     const packageUpdateReadiness = () => packageUpdateReadinessFromExecutionStatus(controlPlane.getExecutionStatus());
@@ -372,6 +472,9 @@ export async function startForegroundHostServer(options) {
                 },
             },
             logger: { file: logFilePath },
+            lifecycle: {
+                close: () => projectRuntimeLifecycle.close(),
+            },
             localControl,
             now,
             projectApi: {
@@ -396,6 +499,11 @@ export async function startForegroundHostServer(options) {
                 chatAssistant,
                 tuttiHome: options.preparation.tutti_home,
                 getProviderConfig,
+                providerModel: createHostProviderModelService({
+                    tuttiHome: options.preparation.tutti_home,
+                    projectId: options.preparation.project_id,
+                    now,
+                }),
                 getProviderUsage: () => readProviderUsageProjection(store.db),
                 updateProjectDisplayName: (displayName) => {
                     updateRuntimeProjectDisplayName(displayName);
@@ -456,30 +564,47 @@ export async function startForegroundHostServer(options) {
         recoverInProgressCommands: true,
     });
     let resolveClosed;
-    const closed = new Promise((resolve) => {
+    let rejectClosed;
+    const closed = new Promise((resolve, reject) => {
         resolveClosed = resolve;
+        rejectClosed = reject;
     });
     let closePromise;
     close = () => {
         closePromise ??= (async () => {
+            let closeError;
+            let appClosed = false;
             try {
-                await relayConnectionManager?.stop();
-                await app.close();
-            }
-            finally {
                 try {
-                    approvalManager.dispose();
-                    store.close();
+                    await relayConnectionManager?.stop();
                 }
-                finally {
-                    deleteMachineRuntimeEndpoint({
-                        tuttiHome: options.preparation.tutti_home,
-                        projectId: options.preparation.project_id,
-                        expectedToken: token,
-                    });
-                    resolveClosed();
+                catch (error) {
+                    closeError = error;
+                }
+                try {
+                    await app.close();
+                    appClosed = true;
                 }
+                catch (error) {
+                    closeError ??= error;
+                }
+                if (appClosed) {
+                    store.close();
+                }
+            }
+            finally {
+                deleteMachineRuntimeEndpoint({
+                    tuttiHome: options.preparation.tutti_home,
+                    projectId: options.preparation.project_id,
+                    expectedToken: token,
+                });
+            }
+            if (closeError !== undefined) {
+                const normalizedCloseError = closeError instanceof Error ? closeError : new Error("Host server close failed.");
+                rejectClosed(normalizedCloseError);
+                throw normalizedCloseError;
             }
+            resolveClosed();
         })();
         return closePromise;
     };

package/dist/server-shell/http/create-server.d.ts

@@ -16,6 +16,9 @@ export type HostServerOptions = {
     logger?: false | {
         file?: string;
     };
+    lifecycle?: {
+        close: () => void | Promise<void>;
+    };
     localControl?: HostLocalControlOptions;
     now?: () => Date;
     projectApi?: false | HostProjectApiRouteOptions;

package/dist/server-shell/http/create-server.js

@@ -24,10 +24,11 @@ export function createHostServer(options = {}) {
     if (options.projectApi !== undefined && options.projectApi !== false) {
         const projectApiOptions = options.projectApi;
         registerHostProjectApiRoutes(app, projectApiOptions);
-        app.addHook("onClose", (_instance, done) => {
-            projectApiOptions.controlPlane?.dispose();
-            done();
-        });
+        if (options.lifecycle === undefined) {
+            app.addHook("onClose", async () => {
+                await projectApiOptions.controlPlane?.dispose();
+            });
+        }
         if (options.agentContext !== false) {
             registerAgentContextRoutes(app, {
                 project: projectApiOptions.project,
@@ -46,6 +47,11 @@ export function createHostServer(options = {}) {
             });
         }
     }
+    if (options.lifecycle !== undefined) {
+        app.addHook("onClose", async () => {
+            await options.lifecycle?.close();
+        });
+    }
     if (options.webStatic !== undefined && options.webStatic !== false) {
         registerHostWebStaticRoutes(app, options.webStatic);
     }

package/dist/server-shell/http/routes/project-api/invalidations.d.ts

@@ -7,5 +7,6 @@ export declare function clarificationRoundInvalidates(roundId: ClarificationRoun
 export declare function approvalInvalidates(): QueryInvalidationHint[];
 export declare function readStateInvalidates(): QueryInvalidationHint[];
 export declare function projectMetadataInvalidates(): QueryInvalidationHint[];
+export declare function providerConfigInvalidates(): QueryInvalidationHint[];
 export declare function projectDisplayNameInvalidates(): QueryInvalidationHint[];
 //# sourceMappingURL=invalidations.d.ts.map

package/dist/server-shell/http/routes/project-api/invalidations.js

@@ -1,9 +1,5 @@
 export function mainChatMessageInvalidates() {
-    return [
-        { kind: "messages", scope: "main_chat" },
-        { kind: "read_state" },
-        { kind: "bootstrap" },
-    ];
+    return [{ kind: "messages", scope: "main_chat" }, { kind: "read_state" }, { kind: "bootstrap" }];
 }
 export function worklistSubmitInvalidates() {
     return [
@@ -54,6 +50,9 @@ export function readStateInvalidates() {
 export function projectMetadataInvalidates() {
     return [{ kind: "workspace" }, { kind: "bootstrap" }];
 }
+export function providerConfigInvalidates() {
+    return [{ kind: "provider_config" }, { kind: "workspace" }, { kind: "bootstrap" }];
+}
 export function projectDisplayNameInvalidates() {
     return projectMetadataInvalidates();
 }

package/dist/server-shell/http/routes/project-api/openapi-workspace-routes.d.ts

@@ -76,6 +76,36 @@ export declare const HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES: ({
         };
     };
     requestBody?: never;
+} | {
+    method: "get";
+    path: string;
+    summary: string;
+    tags: string[];
+    responses: {
+        200: {
+            description: string;
+            schema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                status: import("@sinclair/typebox").TLiteral<"available">;
+                models: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>, import("@sinclair/typebox").TObject<{
+                status: import("@sinclair/typebox").TLiteral<"unavailable">;
+                reason: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"model_list_unavailable">, import("@sinclair/typebox").TLiteral<"model_list_empty">, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"provider_not_configured">, import("@sinclair/typebox").TLiteral<"provider_config_invalid">, import("@sinclair/typebox").TLiteral<"provider_credential_missing">]>]>;
+            }>]>;
+        };
+    };
+    requestBody?: never;
+} | {
+    method: "post";
+    path: string;
+    summary: string;
+    tags: string[];
+    requestBody: import("@sinclair/typebox").TSchema;
+    responses: {
+        200: {
+            description: string;
+            schema: import("@sinclair/typebox").TSchema;
+        };
+    };
 } | {
     method: "get";
     path: string;
@@ -555,7 +585,7 @@ export declare const HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES: ({
                     };
                     readonly capabilities: {
                         readonly type: "object";
-                        readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
+                        readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "provider_model_update", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
                         readonly additionalProperties: false;
                         readonly properties: {
                             readonly sse: {
@@ -570,6 +600,9 @@ export declare const HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES: ({
                             readonly provider_config_query: {
                                 readonly type: "boolean";
                             };
+                            readonly provider_model_update: {
+                                readonly type: "boolean";
+                            };
                             readonly browser_secret_write: {
                                 readonly type: "boolean";
                                 readonly enum: readonly [false];
@@ -590,18 +623,6 @@ export declare const HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES: ({
         };
     };
     requestBody?: never;
-} | {
-    method: "post";
-    path: string;
-    summary: string;
-    tags: string[];
-    requestBody: import("@sinclair/typebox").TSchema;
-    responses: {
-        200: {
-            description: string;
-            schema: import("@sinclair/typebox").TSchema;
-        };
-    };
 } | {
     method: "get";
     path: string;
@@ -755,7 +776,7 @@ export declare const HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES: ({
                             };
                             readonly capabilities: {
                                 readonly type: "object";
-                                readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
+                                readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "provider_model_update", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
                                 readonly additionalProperties: false;
                                 readonly properties: {
                                     readonly sse: {
@@ -770,6 +791,9 @@ export declare const HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES: ({
                                     readonly provider_config_query: {
                                         readonly type: "boolean";
                                     };
+                                    readonly provider_model_update: {
+                                        readonly type: "boolean";
+                                    };
                                     readonly browser_secret_write: {
                                         readonly type: "boolean";
                                         readonly enum: readonly [false];

package/dist/server-shell/http/routes/project-api/openapi-workspace-routes.js

@@ -1,4 +1,4 @@
-import { MarkReadBodySchema, MarkReadResponseSchema, ReadStateSummaryProjectionSchema, UpdateProjectDescriptionBodySchema, UpdateProjectDescriptionResponseSchema, UpdateProjectDisplayNameBodySchema, UpdateProjectDisplayNameResponseSchema, } from "@tutti/shared/schemas/api";
+import { MarkReadBodySchema, MarkReadResponseSchema, ReadStateSummaryProjectionSchema, UpdateProjectDescriptionBodySchema, UpdateProjectDescriptionResponseSchema, UpdateProjectDisplayNameBodySchema, UpdateProjectDisplayNameResponseSchema, GetProviderModelsResponseSchema, UpdateProviderDefaultModelBodySchema, UpdateProviderDefaultModelResponseSchema, } from "@tutti/shared/schemas/api";
 import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
 import { BootstrapResponseSchema, ProviderConfigProjectionSchema, ProviderUsageProjectionSchema, SessionResponseSchema, WorkspaceResponseSchema, } from "./schemas.js";
 export const HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES = [
@@ -14,6 +14,31 @@ export const HOST_PROJECT_WORKSPACE_OPENAPI_ROUTES = [
             },
         },
     },
+    {
+        method: "get",
+        path: `${HOST_PROJECT_API_BASE_PATH}/provider/models`,
+        summary: "Discover model names with the configured provider credential (owner only).",
+        tags: ["provider"],
+        responses: {
+            200: {
+                description: "Bounded provider model discovery result.",
+                schema: GetProviderModelsResponseSchema,
+            },
+        },
+    },
+    {
+        method: "post",
+        path: `${HOST_PROJECT_API_BASE_PATH}/provider/default-model`,
+        summary: "Validate and update the default provider model (owner only).",
+        tags: ["provider"],
+        requestBody: UpdateProviderDefaultModelBodySchema,
+        responses: {
+            200: {
+                description: "Default-model update command response.",
+                schema: UpdateProviderDefaultModelResponseSchema,
+            },
+        },
+    },
     {
         method: "get",
         path: `${HOST_PROJECT_API_BASE_PATH}/provider/usage`,

package/dist/server-shell/http/routes/project-api/openapi.d.ts

@@ -1350,6 +1350,36 @@ export declare const HOST_PROJECT_OPENAPI_ROUTES: ({
         };
     };
     requestBody?: never;
+} | {
+    method: "get";
+    path: string;
+    summary: string;
+    tags: string[];
+    responses: {
+        200: {
+            description: string;
+            schema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                status: import("@sinclair/typebox").TLiteral<"available">;
+                models: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>, import("@sinclair/typebox").TObject<{
+                status: import("@sinclair/typebox").TLiteral<"unavailable">;
+                reason: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"model_list_unavailable">, import("@sinclair/typebox").TLiteral<"model_list_empty">, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"provider_not_configured">, import("@sinclair/typebox").TLiteral<"provider_config_invalid">, import("@sinclair/typebox").TLiteral<"provider_credential_missing">]>]>;
+            }>]>;
+        };
+    };
+    requestBody?: never;
+} | {
+    method: "post";
+    path: string;
+    summary: string;
+    tags: string[];
+    requestBody: import("@sinclair/typebox").TSchema;
+    responses: {
+        200: {
+            description: string;
+            schema: import("@sinclair/typebox").TSchema;
+        };
+    };
 } | {
     method: "get";
     path: string;
@@ -1829,7 +1859,7 @@ export declare const HOST_PROJECT_OPENAPI_ROUTES: ({
                     };
                     readonly capabilities: {
                         readonly type: "object";
-                        readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
+                        readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "provider_model_update", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
                         readonly additionalProperties: false;
                         readonly properties: {
                             readonly sse: {
@@ -1844,6 +1874,9 @@ export declare const HOST_PROJECT_OPENAPI_ROUTES: ({
                             readonly provider_config_query: {
                                 readonly type: "boolean";
                             };
+                            readonly provider_model_update: {
+                                readonly type: "boolean";
+                            };
                             readonly browser_secret_write: {
                                 readonly type: "boolean";
                                 readonly enum: readonly [false];
@@ -1864,18 +1897,6 @@ export declare const HOST_PROJECT_OPENAPI_ROUTES: ({
         };
     };
     requestBody?: never;
-} | {
-    method: "post";
-    path: string;
-    summary: string;
-    tags: string[];
-    requestBody: import("@sinclair/typebox").TSchema;
-    responses: {
-        200: {
-            description: string;
-            schema: import("@sinclair/typebox").TSchema;
-        };
-    };
 } | {
     method: "get";
     path: string;
@@ -2029,7 +2050,7 @@ export declare const HOST_PROJECT_OPENAPI_ROUTES: ({
                             };
                             readonly capabilities: {
                                 readonly type: "object";
-                                readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
+                                readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "provider_model_update", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
                                 readonly additionalProperties: false;
                                 readonly properties: {
                                     readonly sse: {
@@ -2044,6 +2065,9 @@ export declare const HOST_PROJECT_OPENAPI_ROUTES: ({
                                     readonly provider_config_query: {
                                         readonly type: "boolean";
                                     };
+                                    readonly provider_model_update: {
+                                        readonly type: "boolean";
+                                    };
                                     readonly browser_secret_write: {
                                         readonly type: "boolean";
                                         readonly enum: readonly [false];

package/dist/server-shell/http/routes/project-api/schemas.d.ts

@@ -560,7 +560,7 @@ export declare const WorkspaceResponseSchema: {
         };
         readonly capabilities: {
             readonly type: "object";
-            readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
+            readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "provider_model_update", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
             readonly additionalProperties: false;
             readonly properties: {
                 readonly sse: {
@@ -575,6 +575,9 @@ export declare const WorkspaceResponseSchema: {
                 readonly provider_config_query: {
                     readonly type: "boolean";
                 };
+                readonly provider_model_update: {
+                    readonly type: "boolean";
+                };
                 readonly browser_secret_write: {
                     readonly type: "boolean";
                     readonly enum: readonly [false];
@@ -737,7 +740,7 @@ export declare const BootstrapResponseSchema: {
                 };
                 readonly capabilities: {
                     readonly type: "object";
-                    readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
+                    readonly required: readonly ["sse", "relay_join", "repo_viewer", "provider_config_query", "provider_model_update", "browser_secret_write", "task_auto_scheduler", "task_run_now_scheduler", "clarification"];
                     readonly additionalProperties: false;
                     readonly properties: {
                         readonly sse: {
@@ -752,6 +755,9 @@ export declare const BootstrapResponseSchema: {
                         readonly provider_config_query: {
                             readonly type: "boolean";
                         };
+                        readonly provider_model_update: {
+                            readonly type: "boolean";
+                        };
                         readonly browser_secret_write: {
                             readonly type: "boolean";
                             readonly enum: readonly [false];