@xfey/tutti 0.1.79 → 0.1.80

package/README.md

@@ -28,7 +28,7 @@
 
 ## 当前状态
 
-- 已具备 Fastify host shell、后台 host manager CLI 套件、用户级 desktop integration / strict `tutti://projects` bridge、带 `service status / stop / restart`、卸载前 `shutdown`、并发启动锁、版本替换、strict terminal / desktop browser context、当前 runtime version bootstrap projection、idle / package update cleanup、全机readiness、exact npm global install、跨版本worker / recovery与私有日志的机器级 Local Console、Dev Runner、Host Project API、SSE、SQLite store、collaboration-state、workspace read-state、project timeline observability helper、Control Plane、Procedure / Run、workspace-ops、checks、Relay staged upload finalize、user skills 文件服务、artifacts 可视化产物查看层和 OpenAI / Codex provider 接入。
+- 已具备 Fastify host shell、后台 host manager CLI 套件、用户级 desktop integration / strict `tutti://projects` bridge、带 `service status / stop / restart`、卸载前 `shutdown`、并发启动锁、版本替换、strict terminal / desktop browser context、当前 runtime version bootstrap projection、idle / package update cleanup、全机readiness、exact npm global install、跨版本worker / recovery与私有日志的机器级 Local Console、Dev Runner、Host Project API、SSE、SQLite store、collaboration-state、workspace read-state、project timeline observability helper、Control Plane、Procedure / Run、workspace-ops、checks、Relay staged upload finalize、user skills 文件服务、artifacts 可视化产物查看层、Owner-only provider model discovery / update 和 OpenAI / Codex provider 接入。
 - 新 Host project 的空群聊会由 collaboration-state 幂等写入一条 Tutti 欢迎消息；它不经过 browser message command，不触发 `@tutti`、Chat read-state、Scratchpad 或 Timeline / execution 流程。
 - Host server 与 Local Console 支持在显式 `webStatic.root` 或 packaged `web/` 存在时服务 Web 静态产物；`/api/*`、SSE、health、host-local control 和 `/local-console/*` API 不被 SPA fallback 吞掉。
 - Root `pack:dry-run` 会先清理 build output、重新构建，再复制 `apps/web/dist` 到 package-local `web/`，生成临时 staging `@xfey/tutti` artifact，并校验 npm pack 文件列表包含 CLI、migrations、prompts、Web index、bundled `@tutti/shared` / `@tutti/relay-client` 以及它们的外部 runtime dependencies，同时排除源码、source map、日志、SQLite、`.env`、`.tutti-dev` 与测试产物。

package/dist/providers/openai/index.d.ts

@@ -8,6 +8,7 @@ export * from "./credential-store.js";
 export * from "./credential-validation.js";
 export * from "./model-config.js";
 export * from "./provider-config.js";
+export * from "./provider-models.js";
 export * from "./provider-setup.js";
 export * from "./sdk-procedure-runner.js";
 export * from "./token-usage.js";

package/dist/providers/openai/index.js

@@ -8,6 +8,7 @@ export * from "./credential-store.js";
 export * from "./credential-validation.js";
 export * from "./model-config.js";
 export * from "./provider-config.js";
+export * from "./provider-models.js";
 export * from "./provider-setup.js";
 export * from "./sdk-procedure-runner.js";
 export * from "./token-usage.js";

package/dist/providers/openai/machine-local-files.d.ts

@@ -8,7 +8,7 @@ export type JsonFileReadResult = {
 };
 export declare function ensurePrivateDirectory(directoryPath: string): void;
 export declare function writePrivateJsonFile(filePath: string, value: unknown): void;
-export declare function writePrivateTextFile(filePath: string, value: string): void;
+export declare function writePrivateTextFileAtomically(filePath: string, value: string): void;
 export declare function readJsonFile(filePath: string): JsonFileReadResult;
 export declare function readTextFile(filePath: string): {
     kind: "missing";

package/dist/providers/openai/machine-local-files.js

@@ -1,5 +1,6 @@
-import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { basename, dirname, join } from "node:path";
 function isErrnoException(error) {
     return error instanceof Error && "code" in error;
 }
@@ -15,13 +16,35 @@ export function writePrivateJsonFile(filePath, value) {
     });
     chmodSync(filePath, 0o600);
 }
-export function writePrivateTextFile(filePath, value) {
-    ensurePrivateDirectory(dirname(filePath));
-    writeFileSync(filePath, value, {
-        encoding: "utf8",
-        mode: 0o600,
-    });
-    chmodSync(filePath, 0o600);
+export function writePrivateTextFileAtomically(filePath, value) {
+    const directoryPath = dirname(filePath);
+    ensurePrivateDirectory(directoryPath);
+    const temporaryPath = join(directoryPath, `.${basename(filePath)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+    let descriptor;
+    try {
+        descriptor = openSync(temporaryPath, "wx", 0o600);
+        writeFileSync(descriptor, value, { encoding: "utf8" });
+        closeSync(descriptor);
+        descriptor = undefined;
+        renameSync(temporaryPath, filePath);
+    }
+    catch (error) {
+        if (descriptor !== undefined) {
+            try {
+                closeSync(descriptor);
+            }
+            catch {
+                // Preserve the original write or close failure.
+            }
+        }
+        try {
+            unlinkSync(temporaryPath);
+        }
+        catch {
+            // The temporary file may already have been renamed or never created.
+        }
+        throw error;
+    }
 }
 export function readJsonFile(filePath) {
     let raw;

package/dist/providers/openai/provider-config.d.ts

@@ -3,7 +3,7 @@ import { type OpenAiCredentialRef } from "./credential-store.js";
 import type { OPENAI_API_KEY_AUTH_KIND, OPENAI_PROVIDER } from "./model-config.js";
 import { OpenAiProviderConfigError } from "./provider-config-errors.js";
 export { OpenAiProviderConfigError } from "./provider-config-errors.js";
-export { parseOpenAiProviderConfig, } from "./provider-config-shape.js";
+export { parseOpenAiProviderConfig } from "./provider-config-shape.js";
 export type OpenAiProviderConfig = {
     provider: typeof OPENAI_PROVIDER;
     auth_kind: typeof OPENAI_API_KEY_AUTH_KIND;
@@ -58,6 +58,10 @@ export type OpenAiProviderConfigResolution = {
 };
 export declare function resolveTuttiHome(input: string | undefined, cwd?: string): string;
 export declare function getProjectProviderConfigPath(tuttiHome: string, projectId: ProjectId): string;
+export declare function withProjectOpenAiProviderConfigLock<T>(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+}, operation: () => Promise<T>): Promise<T>;
 export declare function readProjectOpenAiProviderConfig(tuttiHome: string, projectId: ProjectId): ProviderConfigReadResult<OpenAiProviderConfig>;
 export declare function resolveOpenAiProviderConfig(options: {
     tuttiHome: string;

package/dist/providers/openai/provider-config.js

@@ -1,12 +1,12 @@
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
-import { openAiCredentialExists, } from "./credential-store.js";
-import { readTextFile, writePrivateTextFile } from "./machine-local-files.js";
+import { openAiCredentialExists } from "./credential-store.js";
+import { readTextFile, writePrivateTextFileAtomically } from "./machine-local-files.js";
 import { OpenAiProviderConfigError } from "./provider-config-errors.js";
 import { parseOpenAiProviderConfig } from "./provider-config-shape.js";
 import { formatProjectOpenAiProviderConfig, parseTomlOpenAiSection, parseTuttiConfigToml, } from "./provider-config-toml.js";
 export { OpenAiProviderConfigError } from "./provider-config-errors.js";
-export { parseOpenAiProviderConfig, } from "./provider-config-shape.js";
+export { parseOpenAiProviderConfig } from "./provider-config-shape.js";
 export function resolveTuttiHome(input, cwd = process.cwd()) {
     if (input === undefined || input.trim() === "") {
         return join(homedir(), ".tutti");
@@ -23,6 +23,27 @@ export function resolveTuttiHome(input, cwd = process.cwd()) {
 export function getProjectProviderConfigPath(tuttiHome, projectId) {
     return join(tuttiHome, "projects", projectId, "config.toml");
 }
+const providerConfigMutationTails = new Map();
+export async function withProjectOpenAiProviderConfigLock(options, operation) {
+    const key = getProjectProviderConfigPath(options.tuttiHome, options.projectId);
+    const previous = providerConfigMutationTails.get(key) ?? Promise.resolve();
+    let release = () => { };
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    const tail = previous.then(() => current);
+    providerConfigMutationTails.set(key, tail);
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (providerConfigMutationTails.get(key) === tail) {
+            providerConfigMutationTails.delete(key);
+        }
+    }
+}
 export function readProjectOpenAiProviderConfig(tuttiHome, projectId) {
     const sourcePath = getProjectProviderConfigPath(tuttiHome, projectId);
     const readResult = readTextFile(sourcePath);
@@ -77,7 +98,7 @@ export function resolveOpenAiProviderConfig(options) {
     };
 }
 export function writeProjectOpenAiProviderConfig(tuttiHome, projectId, config) {
-    writePrivateTextFile(getProjectProviderConfigPath(tuttiHome, projectId), formatProjectOpenAiProviderConfig(config));
+    writePrivateTextFileAtomically(getProjectProviderConfigPath(tuttiHome, projectId), formatProjectOpenAiProviderConfig(config));
 }
 export function createRedactedOpenAiProviderConfigProjection(config) {
     const projection = {

package/dist/providers/openai/provider-models.d.ts

@@ -0,0 +1,41 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type OpenAiCredentialValidationFailureReason, type OpenAiCredentialValidationInput, type OpenAiCredentialValidationResult, type OpenAiModelDiscoveryInput, type OpenAiModelDiscoveryResult } from "./credential-validation.js";
+import { type RedactedOpenAiProviderConfigProjection } from "./provider-config.js";
+export type ProjectOpenAiProviderUnavailableReason = "provider_not_configured" | "provider_config_invalid" | "provider_credential_missing";
+export type ProjectOpenAiModelDiscoveryResult = OpenAiModelDiscoveryResult | {
+    kind: "unavailable";
+    reason: ProjectOpenAiProviderUnavailableReason;
+};
+export type UpdateProjectOpenAiDefaultModelResult = {
+    kind: "updated";
+    projection: RedactedOpenAiProviderConfigProjection;
+} | {
+    kind: "unchanged";
+    projection: RedactedOpenAiProviderConfigProjection;
+} | {
+    kind: "stale_default_model";
+    current_default_model: string;
+} | {
+    kind: "validation_failed";
+    reason: OpenAiCredentialValidationFailureReason;
+    retryable: boolean;
+} | {
+    kind: "provider_unavailable";
+    reason: ProjectOpenAiProviderUnavailableReason;
+};
+export type DiscoverProjectOpenAiModelsOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    discoverModels?: (input: OpenAiModelDiscoveryInput) => Promise<OpenAiModelDiscoveryResult>;
+};
+export type UpdateProjectOpenAiDefaultModelOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    defaultModel: string;
+    expectedDefaultModel: string;
+    now?: () => Date;
+    validateCredential?: (input: OpenAiCredentialValidationInput) => Promise<OpenAiCredentialValidationResult>;
+};
+export declare function discoverProjectOpenAiModels(options: DiscoverProjectOpenAiModelsOptions): Promise<ProjectOpenAiModelDiscoveryResult>;
+export declare function updateProjectOpenAiDefaultModel(options: UpdateProjectOpenAiDefaultModelOptions): Promise<UpdateProjectOpenAiDefaultModelResult>;
+//# sourceMappingURL=provider-models.d.ts.map

package/dist/providers/openai/provider-models.js

@@ -0,0 +1,82 @@
+import { readOpenAiApiKeyCredential } from "./credential-store.js";
+import { discoverOpenAiModels, validateOpenAiCredential, } from "./credential-validation.js";
+import { createRedactedOpenAiProviderConfigProjection, readProjectOpenAiProviderConfig, withProjectOpenAiProviderConfigLock, writeProjectOpenAiProviderConfig, } from "./provider-config.js";
+function providerConfigSnapshot(options) {
+    const config = readProjectOpenAiProviderConfig(options.tuttiHome, options.projectId);
+    if (config.kind === "missing") {
+        return { kind: "unavailable", reason: "provider_not_configured" };
+    }
+    if (config.kind === "invalid") {
+        return { kind: "unavailable", reason: "provider_config_invalid" };
+    }
+    try {
+        const credential = readOpenAiApiKeyCredential(options.tuttiHome, options.projectId, config.config.credential_ref);
+        return { kind: "ready", config: config.config, apiKey: credential.secret };
+    }
+    catch {
+        return { kind: "unavailable", reason: "provider_credential_missing" };
+    }
+}
+function providerInput(config, apiKey) {
+    return {
+        apiKey,
+        ...(config.api_base_url === undefined ? {} : { apiBaseUrl: config.api_base_url }),
+        ...(config.organization_id === undefined ? {} : { organizationId: config.organization_id }),
+        ...(config.openai_project_id === undefined
+            ? {}
+            : { openAiProjectId: config.openai_project_id }),
+    };
+}
+export async function discoverProjectOpenAiModels(options) {
+    return await withProjectOpenAiProviderConfigLock(options, async () => {
+        const snapshot = providerConfigSnapshot(options);
+        if (snapshot.kind === "unavailable") {
+            return snapshot;
+        }
+        return await (options.discoverModels ?? discoverOpenAiModels)(providerInput(snapshot.config, snapshot.apiKey));
+    });
+}
+export async function updateProjectOpenAiDefaultModel(options) {
+    return await withProjectOpenAiProviderConfigLock(options, async () => {
+        const snapshot = providerConfigSnapshot(options);
+        if (snapshot.kind === "unavailable") {
+            return { kind: "provider_unavailable", reason: snapshot.reason };
+        }
+        if (snapshot.config.default_model !== options.expectedDefaultModel) {
+            return {
+                kind: "stale_default_model",
+                current_default_model: snapshot.config.default_model,
+            };
+        }
+        if (snapshot.config.default_model === options.defaultModel) {
+            return {
+                kind: "unchanged",
+                projection: createRedactedOpenAiProviderConfigProjection(snapshot.config),
+            };
+        }
+        const validator = options.validateCredential ??
+            ((input) => validateOpenAiCredential(input, options.now === undefined ? {} : { now: options.now }));
+        const validation = await validator({
+            ...providerInput(snapshot.config, snapshot.apiKey),
+            defaultModel: options.defaultModel,
+        });
+        if (validation.kind === "failed") {
+            return {
+                kind: "validation_failed",
+                reason: validation.reason,
+                retryable: validation.retryable,
+            };
+        }
+        const config = {
+            ...snapshot.config,
+            default_model: validation.default_model,
+            validated_at: validation.validated_at,
+        };
+        writeProjectOpenAiProviderConfig(options.tuttiHome, options.projectId, config);
+        return {
+            kind: "updated",
+            projection: createRedactedOpenAiProviderConfigProjection(config),
+        };
+    });
+}
+//# sourceMappingURL=provider-models.js.map

package/dist/providers/openai/provider-setup.js

@@ -1,7 +1,7 @@
 import { createOpenAiCredentialRef, createRedactedOpenAiApiKeyLabel, isOpenAiApiKey, writeOpenAiApiKeyCredential, } from "./credential-store.js";
 import { validateOpenAiCredential, } from "./credential-validation.js";
 import { DEFAULT_OPENAI_MODEL, OPENAI_API_KEY_AUTH_KIND, OPENAI_PROVIDER } from "./model-config.js";
-import { createRedactedOpenAiProviderConfigProjection, writeProjectOpenAiProviderConfig, } from "./provider-config.js";
+import { createRedactedOpenAiProviderConfigProjection, withProjectOpenAiProviderConfigLock, writeProjectOpenAiProviderConfig, } from "./provider-config.js";
 function trimOptional(value) {
     const trimmed = value?.trim();
     return trimmed === undefined || trimmed === "" ? undefined : trimmed;
@@ -32,7 +32,7 @@ function validationInput(options) {
     }
     return input;
 }
-export async function configureProjectOpenAiProvider(options) {
+async function configureProjectOpenAiProviderUnlocked(options) {
     const apiKey = options.apiKey.trim();
     if (!isOpenAiApiKey(apiKey)) {
         return {
@@ -85,4 +85,7 @@ export async function configureProjectOpenAiProvider(options) {
         projection: createRedactedOpenAiProviderConfigProjection(config),
     };
 }
+export async function configureProjectOpenAiProvider(options) {
+    return await withProjectOpenAiProviderConfigLock(options, () => configureProjectOpenAiProviderUnlocked(options));
+}
 //# sourceMappingURL=provider-setup.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,4 +1,5 @@
 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";
@@ -11,7 +12,7 @@ import { resolveProjectOpenAiProcedureWorkflowRunner } from "../../control-plane
 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";
@@ -36,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) {
@@ -442,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);

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`,