Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

Add POST create for model providers, MCP servers, and skills and raise 409 on name clash (#210)

Bhavesh Patel05228a4ba16b
diff --git a/.github/fern/openapi/openapi.json b/.github/fern/openapi/openapi.json
index 3175c8c5f..8cc7779e5 100644
--- a/.github/fern/openapi/openapi.json
+++ b/.github/fern/openapi/openapi.json
@@ -819,6 +819,45 @@
],
"type": "object"
},
+ "CreateMcpServerRequest": {
+ "additionalProperties": false,
+ "properties": {
+ "auth": {
+ "allOf": [
+ {
+ "$ref": "#/components/schemas/ConfiguredMcpServerAuth"
+ },
+ {
+ "description": "Optional auth settings. Omit when the server needs no credentials."
+ }
+ ]
+ },
+ "name": {
+ "allOf": [
+ {
+ "$ref": "#/components/schemas/ResourceName"
+ },
+ {
+ "description": "Fully qualified name. Unique within a tenant."
+ }
+ ]
+ },
+ "type": {
+ "$ref": "#/components/schemas/McpServerType"
+ },
+ "url": {
+ "description": "URL of the remote MCP server.",
+ "format": "uri",
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "name",
+ "url"
+ ],
+ "type": "object"
+ },
"CreateSessionAgent": {
"anyOf": [
{
@@ -6348,6 +6387,70 @@
],
"x-fern-sdk-method-name": "list"
},
+ "post": {
+ "description": "Creates an MCP server by `name`. Fails if `name` is already taken. Runs DCR registration when `auth.type` is `dcr`. Header secrets: real value required; redacted with no stored value returns 400.",
+ "requestBody": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/CreateMcpServerRequest"
+ }
+ }
+ },
+ "required": true
+ },
+ "responses": {
+ "200": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/PutMcpServerResponse"
+ }
+ }
+ },
+ "description": "The created MCP server with auth_status"
+ },
+ "400": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/RequestErrorResponse"
+ }
+ }
+ },
+ "description": "Invalid request body, or redacted header secret with no stored value to keep."
+ },
+ "409": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/RequestErrorResponse"
+ }
+ }
+ },
+ "description": "An MCP server with this name already exists."
+ },
+ "422": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/RequestErrorResponse"
+ }
+ }
+ },
+ "description": "The server cannot satisfy `auth.type: dcr` (e.g. it advertises no registration_endpoint)."
+ }
+ },
+ "summary": "Create an MCP server",
+ "tags": [
+ "MCP Servers"
+ ],
+ "x-fern-sdk-group-name": [
+ "settings",
+ "mcpServers"
+ ],
+ "x-fern-sdk-method-name": "create"
+ },
"put": {
"description": "Create or replace by `name`. Does not start DCR or change oauth client columns. Header secrets: real value sets/rotates; redacted keeps existing (400 if none).",
"requestBody": {
@@ -6576,6 +6679,60 @@
],
"x-fern-sdk-method-name": "list"
},
+ "post": {
+ "description": "Creates a provider (models included). Fails if `name` is already taken. Well-known types use `type` as `name` (one each); `custom` is named by the caller. `auth.api_key`: real value required; redacted with no stored secret returns 400.",
+ "requestBody": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/ModelProvider"
+ }
+ }
+ },
+ "required": true
+ },
+ "responses": {
+ "200": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/PutModelProviderResponse"
+ }
+ }
+ },
+ "description": "The created provider"
+ },
+ "400": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/RequestErrorResponse"
+ }
+ }
+ },
+ "description": "Invalid request body, or redacted API key with no stored secret to keep."
+ },
+ "409": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/RequestErrorResponse"
+ }
+ }
+ },
+ "description": "A model provider with this name already exists."
+ }
+ },
+ "summary": "Create a model provider",
+ "tags": [
+ "Model Providers"
+ ],
+ "x-fern-sdk-group-name": [
+ "settings",
+ "modelProviders"
+ ],
+ "x-fern-sdk-method-name": "create"
+ },
"put": {
"description": "Create or replace a provider (models included). Well-known types use `type` as `name` (one each); `custom` is named by the caller. `auth.api_key`: real value sets/rotates; redacted keeps existing (400 if none).",
"requestBody": {
@@ -6746,6 +6903,60 @@
],
"x-fern-sdk-method-name": "list"
},
+ "post": {
+ "description": "Creates a skill keyed by `name`. Fails if `name` is already taken.",
+ "requestBody": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/SkillManifest"
+ }
+ }
+ },
+ "required": true
+ },
+ "responses": {
+ "200": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/PutSkillResponse"
+ }
+ }
+ },
+ "description": "The created skill."
+ },
+ "400": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/RequestErrorResponse"
+ }
+ }
+ },
+ "description": "Invalid request body."
+ },
+ "409": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/RequestErrorResponse"
+ }
+ }
+ },
+ "description": "A skill with this name already exists."
+ }
+ },
+ "summary": "Create a skill",
+ "tags": [
+ "Skills"
+ ],
+ "x-fern-sdk-group-name": [
+ "settings",
+ "skills"
+ ],
+ "x-fern-sdk-method-name": "create"
+ },
"put": {
"description": "Full upsert keyed by `name`: creates the skill or replaces its entire manifest.",
"requestBody": {
diff --git a/packages/sdk/.fern/metadata.json b/packages/sdk/.fern/metadata.json
index 2f07eb7fa..17bb01d45 100644
--- a/packages/sdk/.fern/metadata.json
+++ b/packages/sdk/.fern/metadata.json
@@ -28,7 +28,7 @@
"streamType": "web",
"useDefaultRequestParameterValues": true
},
- "originGitCommit": "5c2a556b861f2d72781df14d00a04e64fbcc6566",
+ "originGitCommit": "f5a7441846b361cf22892b725f31a3e3717e0fa4",
"originGitCommitIsDirty": true,
"invokedBy": "ci",
"requestedVersion": "0.0.0",
diff --git a/packages/sdk/reference.md b/packages/sdk/reference.md
index b261f6eb1..fcee4249c 100644
--- a/packages/sdk/reference.md
+++ b/packages/sdk/reference.md
@@ -2076,6 +2076,72 @@ await client.settings.mcpServers.list();
</dl>
+</dd>
+</dl>
+</details>
+
+<details><summary><code>client.settings.mcpServers.<a href="/src/api/resources/settings/resources/mcpServers/client/Client.ts">create</a>({ ...params }) -> TrueForge.PutMcpServerResponse</code></summary>
+<dl>
+<dd>
+
+#### πŸ“ Description
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+Creates an MCP server by `name`. Fails if `name` is already taken. Runs DCR registration when `auth.type` is `dcr`. Header secrets: real value required; redacted with no stored value returns 400.
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### πŸ”Œ Usage
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+```typescript
+await client.settings.mcpServers.create({
+ name: "name",
+ url: "url"
+});
+
+```
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### βš™οΈ Parameters
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+**request:** `TrueForge.settings.CreateMcpServerRequest`
+
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**requestOptions:** `McpServersClient.RequestOptions`
+
+</dd>
+</dl>
+</dd>
+</dl>
+
+
</dd>
</dl>
</details>
@@ -2324,6 +2390,79 @@ await client.settings.modelProviders.list();
</dl>
+</dd>
+</dl>
+</details>
+
+<details><summary><code>client.settings.modelProviders.<a href="/src/api/resources/settings/resources/modelProviders/client/Client.ts">create</a>({ ...params }) -> TrueForge.PutModelProviderResponse</code></summary>
+<dl>
+<dd>
+
+#### πŸ“ Description
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+Creates a provider (models included). Fails if `name` is already taken. Well-known types use `type` as `name` (one each); `custom` is named by the caller. `auth.api_key`: real value required; redacted with no stored secret returns 400.
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### πŸ”Œ Usage
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+```typescript
+await client.settings.modelProviders.create({
+ auth: {
+ apiKey: "api_key"
+ },
+ models: [{
+ modelId: "model_id",
+ name: "name",
+ properties: {}
+ }],
+ type: "alibaba"
+});
+
+```
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### βš™οΈ Parameters
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+**request:** `TrueForge.ModelProvider`
+
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**requestOptions:** `ModelProvidersClient.RequestOptions`
+
+</dd>
+</dl>
+</dd>
+</dl>
+
+
</dd>
</dl>
</details>
@@ -2582,6 +2721,75 @@ await client.settings.skills.list();
</dl>
+</dd>
+</dl>
+</details>
+
+<details><summary><code>client.settings.skills.<a href="/src/api/resources/settings/resources/skills/client/Client.ts">create</a>({ ...params }) -> TrueForge.PutSkillResponse</code></summary>
+<dl>
+<dd>
+
+#### πŸ“ Description
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+Creates a skill keyed by `name`. Fails if `name` is already taken.
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### πŸ”Œ Usage
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+```typescript
+await client.settings.skills.create({
+ description: "description",
+ name: "name",
+ ref: "ref",
+ type: "git",
+ url: "url"
+});
+
+```
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### βš™οΈ Parameters
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+**request:** `TrueForge.SkillManifest`
+
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**requestOptions:** `SkillsClient.RequestOptions`
+
+</dd>
+</dl>
+</dd>
+</dl>
+
+
</dd>
</dl>
</details>
diff --git a/packages/sdk/src/api/resources/settings/resources/mcpServers/client/Client.ts b/packages/sdk/src/api/resources/settings/resources/mcpServers/client/Client.ts
index 307ab12ad..f8b349af6 100644
--- a/packages/sdk/src/api/resources/settings/resources/mcpServers/client/Client.ts
+++ b/packages/sdk/src/api/resources/settings/resources/mcpServers/client/Client.ts
@@ -115,6 +115,130 @@ export class McpServersClient {
return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/v1/settings/mcp-servers");
}
+ /**
+ * Creates an MCP server by `name`. Fails if `name` is already taken. Runs DCR registration when `auth.type` is `dcr`. Header secrets: real value required; redacted with no stored value returns 400.
+ *
+ * @param {TrueForge.settings.CreateMcpServerRequest} request
+ * @param {McpServersClient.RequestOptions} requestOptions - Request-specific configuration.
+ *
+ * @throws {@link TrueForge.BadRequestError}
+ * @throws {@link TrueForge.ConflictError}
+ * @throws {@link TrueForge.UnprocessableEntityError}
+ * @throws {@link errors.TrueForgeError}
+ * @throws {@link errors.TrueForgeTimeoutError}
+ *
+ * @example
+ * await client.settings.mcpServers.create({
+ * name: "name",
+ * url: "url"
+ * })
+ */
+ public create(
+ request: TrueForge.settings.CreateMcpServerRequest,
+ requestOptions?: McpServersClient.RequestOptions,
+ ): core.HttpResponsePromise<TrueForge.PutMcpServerResponse> {
+ return core.HttpResponsePromise.fromPromise(this.__create(request, requestOptions));
+ }
+
+ private async __create(
+ request: TrueForge.settings.CreateMcpServerRequest,
+ requestOptions?: McpServersClient.RequestOptions,
+ ): Promise<core.WithRawResponse<TrueForge.PutMcpServerResponse>> {
+ const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+ const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+ _authRequest.headers,
+ this._options?.headers,
+ requestOptions?.headers,
+ );
+ const _response = await (this._options.fetcher ?? core.fetcher)({
+ url: core.url.join(
+ (await core.Supplier.get(this._options.baseUrl)) ??
+ (await core.Supplier.get(this._options.environment)),
+ "api/v1/settings/mcp-servers",
+ ),
+ method: "POST",
+ headers: _headers,
+ contentType: "application/json",
+ queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+ requestType: "json",
+ body: mergeAdditionalBodyParameters(
+ {
+ ...serializers.settings.CreateMcpServerRequest.jsonOrThrow(request, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ omitUndefined: true,
+ }),
+ type: "remote",
+ },
+ requestOptions?.additionalBodyParameters,
+ ),
+ timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+ maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+ abortSignal: requestOptions?.abortSignal,
+ fetchFn: this._options?.fetch,
+ logging: this._options.logging,
+ });
+ if (_response.ok) {
+ return {
+ data: serializers.PutMcpServerResponse.parseOrThrow(_response.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ rawResponse: _response.rawResponse,
+ };
+ }
+
+ if (_response.error.reason === "status-code") {
+ switch (_response.error.statusCode) {
+ case 400:
+ throw new TrueForge.BadRequestError(
+ serializers.RequestErrorResponse.parseOrThrow(_response.error.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ _response.rawResponse,
+ );
+ case 409:
+ throw new TrueForge.ConflictError(
+ serializers.RequestErrorResponse.parseOrThrow(_response.error.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ _response.rawResponse,
+ );
+ case 422:
+ throw new TrueForge.UnprocessableEntityError(
+ serializers.RequestErrorResponse.parseOrThrow(_response.error.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ _response.rawResponse,
+ );
+ default:
+ throw new errors.TrueForgeError({
+ statusCode: _response.error.statusCode,
+ body: _response.error.body,
+ rawResponse: _response.rawResponse,
+ });
+ }
+ }
+
+ return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/api/v1/settings/mcp-servers");
+ }
+
/**
* Create or replace by `name`. Does not start DCR or change oauth client columns. Header secrets: real value sets/rotates; redacted keeps existing (400 if none).
*
diff --git a/packages/sdk/src/api/resources/settings/resources/mcpServers/client/requests/CreateMcpServerRequest.ts b/packages/sdk/src/api/resources/settings/resources/mcpServers/client/requests/CreateMcpServerRequest.ts
new file mode 100644
index 000000000..8ff7dfef2
--- /dev/null
+++ b/packages/sdk/src/api/resources/settings/resources/mcpServers/client/requests/CreateMcpServerRequest.ts
@@ -0,0 +1,19 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as TrueForge from "../../../../../../index.js";
+
+/**
+ * @example
+ * {
+ * name: "name",
+ * url: "url"
+ * }
+ */
+export interface CreateMcpServerRequest {
+ /** Optional auth settings. Omit when the server needs no credentials. */
+ auth?: TrueForge.settings.CreateMcpServerRequestAuth;
+ /** Fully qualified name. Unique within a tenant. */
+ name: string;
+ /** URL of the remote MCP server. */
+ url: string;
+}
diff --git a/packages/sdk/src/api/resources/settings/resources/mcpServers/client/requests/index.ts b/packages/sdk/src/api/resources/settings/resources/mcpServers/client/requests/index.ts
index 24fbbe294..d66903ce0 100644
--- a/packages/sdk/src/api/resources/settings/resources/mcpServers/client/requests/index.ts
+++ b/packages/sdk/src/api/resources/settings/resources/mcpServers/client/requests/index.ts
@@ -1 +1,2 @@
+export type { CreateMcpServerRequest } from "./CreateMcpServerRequest.js";
export type { McpServerManifest } from "./McpServerManifest.js";
diff --git a/packages/sdk/src/api/resources/settings/resources/mcpServers/types/CreateMcpServerRequestAuth.ts b/packages/sdk/src/api/resources/settings/resources/mcpServers/types/CreateMcpServerRequestAuth.ts
new file mode 100644
index 000000000..e13af3865
--- /dev/null
+++ b/packages/sdk/src/api/resources/settings/resources/mcpServers/types/CreateMcpServerRequestAuth.ts
@@ -0,0 +1,8 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as TrueForge from "../../../../../index.js";
+
+/**
+ * Optional auth settings. Omit when the server needs no credentials.
+ */
+export type CreateMcpServerRequestAuth = TrueForge.McpServerDcrAuth | TrueForge.McpServerHeaderAuth;
diff --git a/packages/sdk/src/api/resources/settings/resources/mcpServers/types/index.ts b/packages/sdk/src/api/resources/settings/resources/mcpServers/types/index.ts
index d6d7776f0..c33cc3c2b 100644
--- a/packages/sdk/src/api/resources/settings/resources/mcpServers/types/index.ts
+++ b/packages/sdk/src/api/resources/settings/resources/mcpServers/types/index.ts
@@ -1 +1,2 @@
+export * from "./CreateMcpServerRequestAuth.js";
export * from "./McpServerManifestAuth.js";
diff --git a/packages/sdk/src/api/resources/settings/resources/modelProviders/client/Client.ts b/packages/sdk/src/api/resources/settings/resources/modelProviders/client/Client.ts
index 560f053aa..6e2054171 100644
--- a/packages/sdk/src/api/resources/settings/resources/modelProviders/client/Client.ts
+++ b/packages/sdk/src/api/resources/settings/resources/modelProviders/client/Client.ts
@@ -120,6 +120,127 @@ export class ModelProvidersClient {
);
}
+ /**
+ * Creates a provider (models included). Fails if `name` is already taken. Well-known types use `type` as `name` (one each); `custom` is named by the caller. `auth.api_key`: real value required; redacted with no stored secret returns 400.
+ *
+ * @param {TrueForge.ModelProvider} request
+ * @param {ModelProvidersClient.RequestOptions} requestOptions - Request-specific configuration.
+ *
+ * @throws {@link TrueForge.BadRequestError}
+ * @throws {@link TrueForge.ConflictError}
+ * @throws {@link errors.TrueForgeError}
+ * @throws {@link errors.TrueForgeTimeoutError}
+ *
+ * @example
+ * await client.settings.modelProviders.create({
+ * auth: {
+ * apiKey: "api_key"
+ * },
+ * models: [{
+ * modelId: "model_id",
+ * name: "name",
+ * properties: {}
+ * }],
+ * type: "alibaba"
+ * })
+ */
+ public create(
+ request: TrueForge.ModelProvider,
+ requestOptions?: ModelProvidersClient.RequestOptions,
+ ): core.HttpResponsePromise<TrueForge.PutModelProviderResponse> {
+ return core.HttpResponsePromise.fromPromise(this.__create(request, requestOptions));
+ }
+
+ private async __create(
+ request: TrueForge.ModelProvider,
+ requestOptions?: ModelProvidersClient.RequestOptions,
+ ): Promise<core.WithRawResponse<TrueForge.PutModelProviderResponse>> {
+ const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+ const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+ _authRequest.headers,
+ this._options?.headers,
+ requestOptions?.headers,
+ );
+ const _response = await (this._options.fetcher ?? core.fetcher)({
+ url: core.url.join(
+ (await core.Supplier.get(this._options.baseUrl)) ??
+ (await core.Supplier.get(this._options.environment)),
+ "api/v1/settings/model-providers",
+ ),
+ method: "POST",
+ headers: _headers,
+ contentType: "application/json",
+ queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+ requestType: "json",
+ body: mergeAdditionalBodyParameters(
+ serializers.ModelProvider.jsonOrThrow(request, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ omitUndefined: true,
+ }),
+ requestOptions?.additionalBodyParameters,
+ ),
+ timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+ maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+ abortSignal: requestOptions?.abortSignal,
+ fetchFn: this._options?.fetch,
+ logging: this._options.logging,
+ });
+ if (_response.ok) {
+ return {
+ data: serializers.PutModelProviderResponse.parseOrThrow(_response.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ rawResponse: _response.rawResponse,
+ };
+ }
+
+ if (_response.error.reason === "status-code") {
+ switch (_response.error.statusCode) {
+ case 400:
+ throw new TrueForge.BadRequestError(
+ serializers.RequestErrorResponse.parseOrThrow(_response.error.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ _response.rawResponse,
+ );
+ case 409:
+ throw new TrueForge.ConflictError(
+ serializers.RequestErrorResponse.parseOrThrow(_response.error.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ _response.rawResponse,
+ );
+ default:
+ throw new errors.TrueForgeError({
+ statusCode: _response.error.statusCode,
+ body: _response.error.body,
+ rawResponse: _response.rawResponse,
+ });
+ }
+ }
+
+ return handleNonStatusCodeError(
+ _response.error,
+ _response.rawResponse,
+ "POST",
+ "/api/v1/settings/model-providers",
+ );
+ }
+
/**
* Create or replace a provider (models included). Well-known types use `type` as `name` (one each); `custom` is named by the caller. `auth.api_key`: real value sets/rotates; redacted keeps existing (400 if none).
*
diff --git a/packages/sdk/src/api/resources/settings/resources/skills/client/Client.ts b/packages/sdk/src/api/resources/settings/resources/skills/client/Client.ts
index 337d10a8a..34b778ab7 100644
--- a/packages/sdk/src/api/resources/settings/resources/skills/client/Client.ts
+++ b/packages/sdk/src/api/resources/settings/resources/skills/client/Client.ts
@@ -115,6 +115,118 @@ export class SkillsClient {
return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/api/v1/settings/skills");
}
+ /**
+ * Creates a skill keyed by `name`. Fails if `name` is already taken.
+ *
+ * @param {TrueForge.SkillManifest} request
+ * @param {SkillsClient.RequestOptions} requestOptions - Request-specific configuration.
+ *
+ * @throws {@link TrueForge.BadRequestError}
+ * @throws {@link TrueForge.ConflictError}
+ * @throws {@link errors.TrueForgeError}
+ * @throws {@link errors.TrueForgeTimeoutError}
+ *
+ * @example
+ * await client.settings.skills.create({
+ * description: "description",
+ * name: "name",
+ * ref: "ref",
+ * type: "git",
+ * url: "url"
+ * })
+ */
+ public create(
+ request: TrueForge.SkillManifest,
+ requestOptions?: SkillsClient.RequestOptions,
+ ): core.HttpResponsePromise<TrueForge.PutSkillResponse> {
+ return core.HttpResponsePromise.fromPromise(this.__create(request, requestOptions));
+ }
+
+ private async __create(
+ request: TrueForge.SkillManifest,
+ requestOptions?: SkillsClient.RequestOptions,
+ ): Promise<core.WithRawResponse<TrueForge.PutSkillResponse>> {
+ const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+ const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+ _authRequest.headers,
+ this._options?.headers,
+ requestOptions?.headers,
+ );
+ const _response = await (this._options.fetcher ?? core.fetcher)({
+ url: core.url.join(
+ (await core.Supplier.get(this._options.baseUrl)) ??
+ (await core.Supplier.get(this._options.environment)),
+ "api/v1/settings/skills",
+ ),
+ method: "POST",
+ headers: _headers,
+ contentType: "application/json",
+ queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+ requestType: "json",
+ body: mergeAdditionalBodyParameters(
+ serializers.SkillManifest.jsonOrThrow(request, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ omitUndefined: true,
+ }),
+ requestOptions?.additionalBodyParameters,
+ ),
+ timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+ maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+ abortSignal: requestOptions?.abortSignal,
+ fetchFn: this._options?.fetch,
+ logging: this._options.logging,
+ });
+ if (_response.ok) {
+ return {
+ data: serializers.PutSkillResponse.parseOrThrow(_response.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ rawResponse: _response.rawResponse,
+ };
+ }
+
+ if (_response.error.reason === "status-code") {
+ switch (_response.error.statusCode) {
+ case 400:
+ throw new TrueForge.BadRequestError(
+ serializers.RequestErrorResponse.parseOrThrow(_response.error.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ _response.rawResponse,
+ );
+ case 409:
+ throw new TrueForge.ConflictError(
+ serializers.RequestErrorResponse.parseOrThrow(_response.error.body, {
+ unrecognizedObjectKeys: "passthrough",
+ allowUnrecognizedUnionMembers: true,
+ allowUnrecognizedEnumValues: true,
+ skipValidation: true,
+ breadcrumbsPrefix: ["response"],
+ }),
+ _response.rawResponse,
+ );
+ default:
+ throw new errors.TrueForgeError({
+ statusCode: _response.error.statusCode,
+ body: _response.error.body,
+ rawResponse: _response.rawResponse,
+ });
+ }
+ }
+
+ return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/api/v1/settings/skills");
+ }
+
/**
* Full upsert keyed by `name`: creates the skill or replaces its entire manifest.
*
diff --git a/packages/sdk/src/serialization/resources/settings/resources/mcpServers/client/requests/CreateMcpServerRequest.ts b/packages/sdk/src/serialization/resources/settings/resources/mcpServers/client/requests/CreateMcpServerRequest.ts
new file mode 100644
index 000000000..b2d21b153
--- /dev/null
+++ b/packages/sdk/src/serialization/resources/settings/resources/mcpServers/client/requests/CreateMcpServerRequest.ts
@@ -0,0 +1,23 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as TrueForge from "../../../../../../../api/index.js";
+import * as core from "../../../../../../../core/index.js";
+import type * as serializers from "../../../../../../index.js";
+import { CreateMcpServerRequestAuth } from "../../types/CreateMcpServerRequestAuth.js";
+
+export const CreateMcpServerRequest: core.serialization.Schema<
+ serializers.settings.CreateMcpServerRequest.Raw,
+ TrueForge.settings.CreateMcpServerRequest
+> = core.serialization.object({
+ auth: CreateMcpServerRequestAuth.optional(),
+ name: core.serialization.string(),
+ url: core.serialization.string(),
+});
+
+export declare namespace CreateMcpServerRequest {
+ export interface Raw {
+ auth?: CreateMcpServerRequestAuth.Raw | null;
+ name: string;
+ url: string;
+ }
+}
diff --git a/packages/sdk/src/serialization/resources/settings/resources/mcpServers/client/requests/index.ts b/packages/sdk/src/serialization/resources/settings/resources/mcpServers/client/requests/index.ts
index 29be17470..9aacc709f 100644
--- a/packages/sdk/src/serialization/resources/settings/resources/mcpServers/client/requests/index.ts
+++ b/packages/sdk/src/serialization/resources/settings/resources/mcpServers/client/requests/index.ts
@@ -1 +1,2 @@
+export { CreateMcpServerRequest } from "./CreateMcpServerRequest.js";
export { McpServerManifest } from "./McpServerManifest.js";
diff --git a/packages/sdk/src/serialization/resources/settings/resources/mcpServers/types/CreateMcpServerRequestAuth.ts b/packages/sdk/src/serialization/resources/settings/resources/mcpServers/types/CreateMcpServerRequestAuth.ts
new file mode 100644
index 000000000..d92fe35da
--- /dev/null
+++ b/packages/sdk/src/serialization/resources/settings/resources/mcpServers/types/CreateMcpServerRequestAuth.ts
@@ -0,0 +1,16 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as TrueForge from "../../../../../../api/index.js";
+import * as core from "../../../../../../core/index.js";
+import type * as serializers from "../../../../../index.js";
+import { McpServerDcrAuth } from "../../../../../types/McpServerDcrAuth.js";
+import { McpServerHeaderAuth } from "../../../../../types/McpServerHeaderAuth.js";
+
+export const CreateMcpServerRequestAuth: core.serialization.Schema<
+ serializers.settings.CreateMcpServerRequestAuth.Raw,
+ TrueForge.settings.CreateMcpServerRequestAuth
+> = core.serialization.undiscriminatedUnion([McpServerDcrAuth, McpServerHeaderAuth]);
+
+export declare namespace CreateMcpServerRequestAuth {
+ export type Raw = McpServerDcrAuth.Raw | McpServerHeaderAuth.Raw;
+}
diff --git a/packages/sdk/src/serialization/resources/settings/resources/mcpServers/types/index.ts b/packages/sdk/src/serialization/resources/settings/resources/mcpServers/types/index.ts
index d6d7776f0..c33cc3c2b 100644
--- a/packages/sdk/src/serialization/resources/settings/resources/mcpServers/types/index.ts
+++ b/packages/sdk/src/serialization/resources/settings/resources/mcpServers/types/index.ts
@@ -1 +1,2 @@
+export * from "./CreateMcpServerRequestAuth.js";
export * from "./McpServerManifestAuth.js";
diff --git a/packages/sdk/tests/wire/settings/mcpServers.test.ts b/packages/sdk/tests/wire/settings/mcpServers.test.ts
index 6631b2f04..8dd732bfc 100644
--- a/packages/sdk/tests/wire/settings/mcpServers.test.ts
+++ b/packages/sdk/tests/wire/settings/mcpServers.test.ts
@@ -85,6 +85,118 @@ describe("McpServersClient", () => {
}).rejects.toThrow(TrueForgeTypes.ForbiddenError);
});
+ test("create (1)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = { name: "name", type: "remote", url: "url" };
+ const rawResponseBody = {
+ data: {
+ auth: { type: "dcr" },
+ auth_status: { authorization_url: "authorization_url", status: "authenticated" },
+ name: "name",
+ type: "remote",
+ url: "url",
+ },
+ };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/mcp-servers")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(200)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ const response = await client.settings.mcpServers.create({
+ name: "name",
+ url: "url",
+ });
+ expect(response).toEqual({
+ data: {
+ auth: {
+ type: "dcr",
+ },
+ authStatus: {
+ authorizationUrl: "authorization_url",
+ status: "authenticated",
+ },
+ name: "name",
+ type: "remote",
+ url: "url",
+ },
+ });
+ });
+
+ test("create (2)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = { name: "xy", type: "remote", url: "url" };
+ const rawResponseBody = { error: { message: "message" } };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/mcp-servers")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(400)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ await expect(async () => {
+ return await client.settings.mcpServers.create({
+ name: "xy",
+ url: "url",
+ });
+ }).rejects.toThrow(TrueForgeTypes.BadRequestError);
+ });
+
+ test("create (3)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = { name: "xy", type: "remote", url: "url" };
+ const rawResponseBody = { error: { message: "message" } };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/mcp-servers")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(409)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ await expect(async () => {
+ return await client.settings.mcpServers.create({
+ name: "xy",
+ url: "url",
+ });
+ }).rejects.toThrow(TrueForgeTypes.ConflictError);
+ });
+
+ test("create (4)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = { name: "xy", type: "remote", url: "url" };
+ const rawResponseBody = { error: { message: "message" } };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/mcp-servers")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(422)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ await expect(async () => {
+ return await client.settings.mcpServers.create({
+ name: "xy",
+ url: "url",
+ });
+ }).rejects.toThrow(TrueForgeTypes.UnprocessableEntityError);
+ });
+
test("upsert (1)", async () => {
const server = mockServerPool.createServer();
const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
diff --git a/packages/sdk/tests/wire/settings/modelProviders.test.ts b/packages/sdk/tests/wire/settings/modelProviders.test.ts
index 2e3c381ff..38274f604 100644
--- a/packages/sdk/tests/wire/settings/modelProviders.test.ts
+++ b/packages/sdk/tests/wire/settings/modelProviders.test.ts
@@ -87,6 +87,151 @@ describe("ModelProvidersClient", () => {
}).rejects.toThrow(TrueForgeTypes.ForbiddenError);
});
+ test("create (1)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = {
+ auth: { api_key: "api_key" },
+ models: [{ model_id: "model_id", name: "name", properties: {} }],
+ type: "alibaba",
+ };
+ const rawResponseBody = {
+ data: {
+ auth: { api_key: "api_key" },
+ base_url: "base_url",
+ models: [{ model_id: "model_id", name: "name", properties: {} }],
+ type: "alibaba",
+ },
+ };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/model-providers")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(200)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ const response = await client.settings.modelProviders.create({
+ auth: {
+ apiKey: "api_key",
+ },
+ models: [
+ {
+ modelId: "model_id",
+ name: "name",
+ properties: {},
+ },
+ ],
+ type: "alibaba",
+ });
+ expect(response).toEqual({
+ data: {
+ auth: {
+ apiKey: "api_key",
+ },
+ baseUrl: "base_url",
+ models: [
+ {
+ modelId: "model_id",
+ name: "name",
+ properties: {},
+ },
+ ],
+ type: "alibaba",
+ },
+ });
+ });
+
+ test("create (2)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = {
+ auth: { api_key: "x" },
+ models: [
+ { model_id: "x", name: "xy", properties: {} },
+ { model_id: "x", name: "xy", properties: {} },
+ ],
+ type: "alibaba",
+ };
+ const rawResponseBody = { error: { message: "message" } };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/model-providers")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(400)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ await expect(async () => {
+ return await client.settings.modelProviders.create({
+ auth: {
+ apiKey: "x",
+ },
+ models: [
+ {
+ modelId: "x",
+ name: "xy",
+ properties: {},
+ },
+ {
+ modelId: "x",
+ name: "xy",
+ properties: {},
+ },
+ ],
+ type: "alibaba",
+ });
+ }).rejects.toThrow(TrueForgeTypes.BadRequestError);
+ });
+
+ test("create (3)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = {
+ auth: { api_key: "x" },
+ models: [
+ { model_id: "x", name: "xy", properties: {} },
+ { model_id: "x", name: "xy", properties: {} },
+ ],
+ type: "alibaba",
+ };
+ const rawResponseBody = { error: { message: "message" } };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/model-providers")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(409)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ await expect(async () => {
+ return await client.settings.modelProviders.create({
+ auth: {
+ apiKey: "x",
+ },
+ models: [
+ {
+ modelId: "x",
+ name: "xy",
+ properties: {},
+ },
+ {
+ modelId: "x",
+ name: "xy",
+ properties: {},
+ },
+ ],
+ type: "alibaba",
+ });
+ }).rejects.toThrow(TrueForgeTypes.ConflictError);
+ });
+
test("upsert (1)", async () => {
const server = mockServerPool.createServer();
const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
diff --git a/packages/sdk/tests/wire/settings/skills.test.ts b/packages/sdk/tests/wire/settings/skills.test.ts
index 26bf97f6e..0a9e34382 100644
--- a/packages/sdk/tests/wire/settings/skills.test.ts
+++ b/packages/sdk/tests/wire/settings/skills.test.ts
@@ -74,6 +74,94 @@ describe("SkillsClient", () => {
}).rejects.toThrow(TrueForgeTypes.ForbiddenError);
});
+ test("create (1)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = { description: "description", name: "name", ref: "ref", type: "git", url: "url" };
+ const rawResponseBody = {
+ data: { description: "description", name: "name", path: "path", ref: "ref", type: "git", url: "url" },
+ };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/skills")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(200)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ const response = await client.settings.skills.create({
+ description: "description",
+ name: "name",
+ ref: "ref",
+ type: "git",
+ url: "url",
+ });
+ expect(response).toEqual({
+ data: {
+ description: "description",
+ name: "name",
+ path: "path",
+ ref: "ref",
+ type: "git",
+ url: "url",
+ },
+ });
+ });
+
+ test("create (2)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = { description: "x", name: "xy", ref: "x", type: "git", url: "x" };
+ const rawResponseBody = { error: { message: "message" } };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/skills")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(400)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ await expect(async () => {
+ return await client.settings.skills.create({
+ description: "x",
+ name: "xy",
+ ref: "x",
+ type: "git",
+ url: "x",
+ });
+ }).rejects.toThrow(TrueForgeTypes.BadRequestError);
+ });
+
+ test("create (3)", async () => {
+ const server = mockServerPool.createServer();
+ const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
+ const rawRequestBody = { description: "x", name: "xy", ref: "x", type: "git", url: "x" };
+ const rawResponseBody = { error: { message: "message" } };
+
+ server
+ .mockEndpoint()
+ .post("/api/v1/settings/skills")
+ .jsonBody(rawRequestBody)
+ .respondWith()
+ .statusCode(409)
+ .jsonBody(rawResponseBody)
+ .build();
+
+ await expect(async () => {
+ return await client.settings.skills.create({
+ description: "x",
+ name: "xy",
+ ref: "x",
+ type: "git",
+ url: "x",
+ });
+ }).rejects.toThrow(TrueForgeTypes.ConflictError);
+ });
+
test("upsert (1)", async () => {
const server = mockServerPool.createServer();
const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
diff --git a/packages/server/src/apis/mcpServers.ts b/packages/server/src/apis/mcpServers.ts
index 4ad52ed43..2b1498cdb 100644
--- a/packages/server/src/apis/mcpServers.ts
+++ b/packages/server/src/apis/mcpServers.ts
@@ -3,13 +3,14 @@ import { extractErrorLogFields, isAuthRequired, McpConnectionError, RemoteMCP }
import type { Logger } from 'winston';
import type { ResolveUserContext } from '../auth/identity';
import configuration from '../config';
-import type { IMcpServerStore, McpServerRecord } from '../db/mcpServerStore';
+import { McpServerNameConflictError, type IMcpServerStore, type McpServerRecord } from '../db/mcpServerStore';
import type { WithTransaction } from '../db/transaction';
import { createMcpOAuthClient, isMcpAuthRequired, resolveMcpAuth } from '../mcp/auth/mcpDcr';
import { mcpOAuthCallbackUrl, validateRedirectUris } from '../mcp/auth/mcpOAuthHelpers';
import type { IOAuthTokenStore, OAuthClientRecord, OAuthToken } from '../mcp/auth/types';
import {
authorizeMcpServerRoute,
+ createMcpServerRoute,
deleteMcpServerAuthRoute,
getMcpServerRoute,
listAvailableMcpServersRoute,
@@ -162,6 +163,68 @@ export function createSettingsMcpServersRouter<TTransaction>(deps: SettingsMcpSe
return c.json({ data: toConfiguredMcpServer({ record, token }) }, 200);
};
+ const createHandler: RouteHandler<typeof createMcpServerRoute> = async c => {
+ const incomingManifest: McpServerManifest = c.req.valid('json');
+
+ // DCR must finish before the txn (remote I/O cannot run inside withTransaction).
+ let dcrClientToSave: OAuthClientRecord | undefined;
+ if (incomingManifest.auth?.type === 'dcr') {
+ try {
+ dcrClientToSave = await createMcpOAuthClient({
+ mcpServerUrl: incomingManifest.url,
+ mcpServerName: incomingManifest.name,
+ redirectUri: mcpOAuthCallbackUrl(),
+ clientName: configuration.MCP_DCR_OAUTH_CLIENT_NAME,
+ });
+ } catch (error) {
+ deps.logger.error(
+ `DCR client registration failed for "${incomingManifest.name}"; rejecting create`,
+ extractErrorLogFields(error),
+ );
+ const message = error instanceof Error ? error.message : 'Failed to register OAuth client for this MCP server';
+ return c.json({ error: { message } }, 422);
+ }
+ }
+
+ let manifest: McpServerManifest;
+ try {
+ // Create has no prior row; redacted header keep resolves to MissingStoredSecretError β†’ 400.
+ manifest = resolveMcpServerManifestForWrite({
+ incoming: incomingManifest,
+ existing: undefined,
+ });
+ } catch (error) {
+ if (error instanceof MissingStoredSecretError) {
+ return c.json({ error: { message: 'Header secret is required' } }, 400);
+ }
+ throw error;
+ }
+
+ try {
+ const record = await deps.withTransaction(async transaction => {
+ const saved = await deps.mcpServerStore.createServer(
+ {
+ tenant_id: TENANT_ID,
+ name: manifest.name,
+ manifest,
+ },
+ transaction,
+ );
+ if (dcrClientToSave !== undefined) {
+ await deps.mcpServerStore.saveClient({ id: saved.id, record: dcrClientToSave }, transaction);
+ }
+ return saved;
+ });
+
+ return c.json({ data: toConfiguredMcpServer({ record, token: undefined }) }, 200);
+ } catch (error) {
+ if (error instanceof McpServerNameConflictError) {
+ return c.json({ error: { message: error.message } }, 409);
+ }
+ throw error;
+ }
+ };
+
const putHandler: RouteHandler<typeof putMcpServerRoute> = async c => {
const userRef = deps.resolveUserContext(c).userRef;
const incomingManifest: McpServerManifest = c.req.valid('json');
@@ -288,6 +351,7 @@ export function createSettingsMcpServersRouter<TTransaction>(deps: SettingsMcpSe
const router = new OpenAPIHono();
router.openapi(listMcpServersRoute, listHandler);
+ router.openapi(createMcpServerRoute, createHandler);
router.openapi(putMcpServerRoute, putHandler);
// `/{name}/tools` before `/{name}` so the tools suffix is not swallowed.
router.openapi(listMcpServerToolsRoute, listToolsHandler);
diff --git a/packages/server/src/apis/modelProviders.ts b/packages/server/src/apis/modelProviders.ts
index 6ead6621c..5d64d86fc 100644
--- a/packages/server/src/apis/modelProviders.ts
+++ b/packages/server/src/apis/modelProviders.ts
@@ -1,7 +1,11 @@
import { OpenAPIHono, type RouteHandler } from '@hono/zod-openapi';
-import type { IModelProviderStore } from '../db/modelProviderStore';
+import { ModelProviderNameConflictError, type IModelProviderStore } from '../db/modelProviderStore';
import type { WithTransaction } from '../db/transaction';
-import { listModelProvidersRoute, putModelProviderRoute } from '../routes/modelProviderRoutes';
+import {
+ createModelProviderRoute,
+ listModelProvidersRoute,
+ putModelProviderRoute,
+} from '../routes/modelProviderRoutes';
import { modelProviderName, type ModelProvider } from '../schemas/modelProvider';
import { MissingStoredSecretError, resolveStoredSecretValue, toRedactedSecretValue } from '../utils/secretRedaction';
import { TENANT_ID } from './sessions';
@@ -21,12 +25,52 @@ function redactModelProvider(manifest: ModelProvider): ModelProvider {
};
}
+function resolveModelProviderManifestForWrite({
+ incoming,
+ existing,
+}: {
+ incoming: ModelProvider;
+ existing: ModelProvider | undefined;
+}): ModelProvider {
+ if (incoming.auth === undefined) {
+ return incoming;
+ }
+ return {
+ ...incoming,
+ auth: {
+ api_key: resolveStoredSecretValue({
+ incoming: incoming.auth.api_key,
+ existing: existing?.auth?.api_key,
+ }),
+ },
+ };
+}
+
export function createModelProvidersRouter<TTransaction>(deps: ModelProvidersRouterDeps<TTransaction>) {
const listHandler: RouteHandler<typeof listModelProvidersRoute> = async c => {
const records = await deps.modelProviderStore.listProviders(TENANT_ID);
return c.json({ data: records.map(record => redactModelProvider(record.manifest)) }, 200);
};
+ const createHandler: RouteHandler<typeof createModelProviderRoute> = async c => {
+ const provider = c.req.valid('json');
+ const name = modelProviderName(provider);
+ try {
+ // Create has no prior row; redacted keep resolves to MissingStoredSecretError β†’ 400.
+ const manifest = resolveModelProviderManifestForWrite({ incoming: provider, existing: undefined });
+ const record = await deps.modelProviderStore.createProvider({ tenant_id: TENANT_ID, name, manifest });
+ return c.json({ data: redactModelProvider(record.manifest) }, 200);
+ } catch (error) {
+ if (error instanceof MissingStoredSecretError) {
+ return c.json({ error: { message: 'API key is required' } }, 400);
+ }
+ if (error instanceof ModelProviderNameConflictError) {
+ return c.json({ error: { message: error.message } }, 409);
+ }
+ throw error;
+ }
+ };
+
const putHandler: RouteHandler<typeof putModelProviderRoute> = async c => {
const provider = c.req.valid('json');
const name = modelProviderName(provider);
@@ -38,18 +82,10 @@ export function createModelProvidersRouter<TTransaction>(deps: ModelProvidersRou
{ tenant_id: TENANT_ID, name },
transaction,
);
- const manifest: ModelProvider =
- provider.auth === undefined
- ? provider
- : {
- ...provider,
- auth: {
- api_key: resolveStoredSecretValue({
- incoming: provider.auth.api_key,
- existing: existing?.manifest.auth?.api_key,
- }),
- },
- };
+ const manifest = resolveModelProviderManifestForWrite({
+ incoming: provider,
+ existing: existing?.manifest,
+ });
return deps.modelProviderStore.upsertProvider({ tenant_id: TENANT_ID, name, manifest }, transaction);
});
return c.json({ data: redactModelProvider(record.manifest) }, 200);
@@ -63,6 +99,7 @@ export function createModelProvidersRouter<TTransaction>(deps: ModelProvidersRou
const router = new OpenAPIHono();
router.openapi(listModelProvidersRoute, listHandler);
+ router.openapi(createModelProviderRoute, createHandler);
router.openapi(putModelProviderRoute, putHandler);
return router;
}
diff --git a/packages/server/src/apis/skills.ts b/packages/server/src/apis/skills.ts
index be027e952..db5216648 100644
--- a/packages/server/src/apis/skills.ts
+++ b/packages/server/src/apis/skills.ts
@@ -1,7 +1,12 @@
import { OpenAPIHono, type RouteHandler } from '@hono/zod-openapi';
-import type { ISkillStore, SkillRecord } from '../db/skillStore';
+import { SkillNameConflictError, type ISkillStore, type SkillRecord } from '../db/skillStore';
import type { WithTransaction } from '../db/transaction';
-import { listAvailableSkillsRoute, listConfiguredSkillsRoute, putSkillRoute } from '../routes/skillRoutes';
+import {
+ createSkillRoute,
+ listAvailableSkillsRoute,
+ listConfiguredSkillsRoute,
+ putSkillRoute,
+} from '../routes/skillRoutes';
import type { ConfiguredSkill, SkillManifest } from '../schemas/skill';
import { TENANT_ID } from './sessions';
@@ -25,6 +30,23 @@ export function createSkillsRouter<TTransaction>(deps: SkillsRouterDeps<TTransac
return c.json({ data: records.map(toConfiguredSkill) }, 200);
};
+ const createHandler: RouteHandler<typeof createSkillRoute> = async c => {
+ const manifest: SkillManifest = c.req.valid('json');
+ try {
+ const record = await deps.skillStore.createSkill({
+ tenant_id: TENANT_ID,
+ name: manifest.name,
+ manifest,
+ });
+ return c.json({ data: toConfiguredSkill(record) }, 200);
+ } catch (error) {
+ if (error instanceof SkillNameConflictError) {
+ return c.json({ error: { message: error.message } }, 409);
+ }
+ throw error;
+ }
+ };
+
const putHandler: RouteHandler<typeof putSkillRoute> = async c => {
const manifest: SkillManifest = c.req.valid('json');
const record = await deps.skillStore.upsertSkill({
@@ -37,6 +59,7 @@ export function createSkillsRouter<TTransaction>(deps: SkillsRouterDeps<TTransac
const router = new OpenAPIHono();
router.openapi(listConfiguredSkillsRoute, listConfiguredHandler);
+ router.openapi(createSkillRoute, createHandler);
router.openapi(putSkillRoute, putHandler);
return router;
}
diff --git a/packages/server/src/db/mcpServerStore.ts b/packages/server/src/db/mcpServerStore.ts
index 3337698a4..64f1aa792 100644
--- a/packages/server/src/db/mcpServerStore.ts
+++ b/packages/server/src/db/mcpServerStore.ts
@@ -40,12 +40,28 @@ export interface ListMcpServersInput {
names: readonly string[] | undefined;
}
-export interface UpsertMcpServerInput {
+export interface CreateMcpServerInput {
tenant_id: string;
name: ResourceName;
manifest: McpServerManifest;
}
+/** Same shape as create for now; kept as a distinct name for the upsert path. */
+export type UpsertMcpServerInput = CreateMcpServerInput;
+
+/** Unique `(tenant_id, name)` violation on create. */
+export class McpServerNameConflictError extends Error {
+ readonly tenant_id: string;
+ readonly server_name: string;
+
+ constructor({ tenant_id, name }: { tenant_id: string; name: string }, options?: ErrorOptions) {
+ super(`MCP server name already exists: ${name}`, options);
+ this.name = 'McpServerNameConflictError';
+ this.tenant_id = tenant_id;
+ this.server_name = name;
+ }
+}
+
export interface IMcpServerStore<TTransaction = never> extends IOAuthClientStore<TTransaction> {
listServers(input: ListMcpServersInput, transaction?: TTransaction): Promise<McpServerRecord[]>;
getServer(input: GetMcpServerInput, transaction?: TTransaction): Promise<McpServerRecord | undefined>;
@@ -55,6 +71,8 @@ export interface IMcpServerStore<TTransaction = never> extends IOAuthClientStore
* Required before read-modify-write of header secrets so concurrent keep/rotate cannot interleave.
*/
getServerForUpdate(input: GetMcpServerInput, transaction: TTransaction): Promise<McpServerRecord | undefined>;
+ /** Inserts a new server with a generated ULID. Throws McpServerNameConflictError on name clash. */
+ createServer(input: CreateMcpServerInput, transaction?: TTransaction): Promise<McpServerRecord>;
/**
* Creates the server or replaces `manifest` (+ `updated_at`) only.
* Never overwrites `id`, `oauth_server`, or `oauth_client`.
diff --git a/packages/server/src/db/modelProviderStore.ts b/packages/server/src/db/modelProviderStore.ts
index 2bf14d44d..2f38037ab 100644
--- a/packages/server/src/db/modelProviderStore.ts
+++ b/packages/server/src/db/modelProviderStore.ts
@@ -16,29 +16,50 @@ export interface ModelProviderRecord {
updated_at: string;
}
-export interface GetProviderInput {
+export interface GetModelProviderInput {
tenant_id: string;
name: string;
}
-export interface UpsertProviderInput {
+export interface CreateModelProviderInput {
tenant_id: string;
/** Derived from the document by `modelProviderName`, never chosen by the caller. */
name: ResourceName;
manifest: ModelProvider;
}
+/** Same shape as create for now; kept as a distinct name for the upsert path. */
+export type UpsertModelProviderInput = CreateModelProviderInput;
+
+/** Unique `(tenant_id, name)` violation on create. */
+export class ModelProviderNameConflictError extends Error {
+ readonly tenant_id: string;
+ readonly provider_name: string;
+
+ constructor({ tenant_id, name }: { tenant_id: string; name: string }, options?: ErrorOptions) {
+ super(`Model provider name already exists: ${name}`, options);
+ this.name = 'ModelProviderNameConflictError';
+ this.tenant_id = tenant_id;
+ this.provider_name = name;
+ }
+}
+
export interface IModelProviderStore<TTransaction = never> {
listProviders(tenantId: string, transaction?: TTransaction): Promise<ModelProviderRecord[]>;
- getProvider(input: GetProviderInput, transaction?: TTransaction): Promise<ModelProviderRecord | undefined>;
+ getProvider(input: GetModelProviderInput, transaction?: TTransaction): Promise<ModelProviderRecord | undefined>;
/**
* Load one provider while holding a row lock for the lifetime of `transaction`.
* Postgres: `SELECT … FOR UPDATE`. SQLite: plain read under a write txn (BEGIN IMMEDIATE).
* Required before read-modify-write of secrets so concurrent keep/rotate cannot interleave.
*/
- getProviderForUpdate(input: GetProviderInput, transaction: TTransaction): Promise<ModelProviderRecord | undefined>;
+ getProviderForUpdate(
+ input: GetModelProviderInput,
+ transaction: TTransaction,
+ ): Promise<ModelProviderRecord | undefined>;
+ /** Inserts a new provider. Throws ModelProviderNameConflictError on name clash. */
+ createProvider(input: CreateModelProviderInput, transaction?: TTransaction): Promise<ModelProviderRecord>;
/** Single-row write: creates the provider or replaces the whole manifest (models included). */
- upsertProvider(input: UpsertProviderInput, transaction?: TTransaction): Promise<ModelProviderRecord>;
+ upsertProvider(input: UpsertModelProviderInput, transaction?: TTransaction): Promise<ModelProviderRecord>;
/** Flattens manifests into the FQN read view for GET /models. */
listModels(tenantId: string, transaction?: TTransaction): Promise<Model[]>;
}
diff --git a/packages/server/src/db/postgres/mcp-server-store/PostgresMcpServerStore.ts b/packages/server/src/db/postgres/mcp-server-store/PostgresMcpServerStore.ts
index 5a367b59e..553c73ab2 100644
--- a/packages/server/src/db/postgres/mcp-server-store/PostgresMcpServerStore.ts
+++ b/packages/server/src/db/postgres/mcp-server-store/PostgresMcpServerStore.ts
@@ -3,13 +3,16 @@ import { ulid } from 'ulid';
import type { OAuthClientRecord } from '../../../mcp/auth/types';
import {
fromStoredOAuthClientRecord,
+ McpServerNameConflictError,
toStoredOAuthClientRecord,
+ type CreateMcpServerInput,
type GetMcpServerInput,
type IMcpServerStore,
type ListMcpServersInput,
type McpServerRecord,
type UpsertMcpServerInput,
} from '../../mcpServerStore';
+import { isUniqueViolation } from '../client';
import { json, now } from '../sqlExpressions';
import type { Database, McpServerTable } from '../types';
@@ -69,6 +72,32 @@ export class PostgresMcpServerStore implements IMcpServerStore<Transaction<Datab
return row ? toRecord(row) : undefined;
}
+ async createServer(input: CreateMcpServerInput, transaction?: Transaction<Database>): Promise<McpServerRecord> {
+ const db = transaction ?? this.#db;
+ try {
+ const row = await db
+ .insertInto('mcp_server')
+ .values({
+ id: ulid(),
+ tenant_id: input.tenant_id,
+ name: input.name,
+ manifest: json(input.manifest),
+ oauth_server: null,
+ oauth_client: null,
+ created_at: now(),
+ updated_at: now(),
+ })
+ .returningAll()
+ .executeTakeFirstOrThrow();
+ return toRecord(row);
+ } catch (error) {
+ if (isUniqueViolation(error)) {
+ throw new McpServerNameConflictError({ tenant_id: input.tenant_id, name: input.name }, { cause: error });
+ }
+ throw error;
+ }
+ }
+
async upsertServer(input: UpsertMcpServerInput, transaction?: Transaction<Database>): Promise<McpServerRecord> {
const db = transaction ?? this.#db;
const row = await db
diff --git a/packages/server/src/db/postgres/model-provider-store/PostgresModelProviderStore.ts b/packages/server/src/db/postgres/model-provider-store/PostgresModelProviderStore.ts
index 68865d248..e484b20e6 100644
--- a/packages/server/src/db/postgres/model-provider-store/PostgresModelProviderStore.ts
+++ b/packages/server/src/db/postgres/model-provider-store/PostgresModelProviderStore.ts
@@ -2,11 +2,14 @@ import type { Kysely, Selectable, Transaction } from 'kysely';
import type { Model } from '../../../schemas/modelProvider';
import {
flattenProviderModels,
- type GetProviderInput,
+ ModelProviderNameConflictError,
+ type CreateModelProviderInput,
+ type GetModelProviderInput,
type IModelProviderStore,
type ModelProviderRecord,
- type UpsertProviderInput,
+ type UpsertModelProviderInput,
} from '../../modelProviderStore';
+import { isUniqueViolation } from '../client';
import { json, now } from '../sqlExpressions';
import type { Database, ModelProviderTable } from '../types';
@@ -39,7 +42,7 @@ export class PostgresModelProviderStore implements IModelProviderStore<Transacti
}
async getProvider(
- input: GetProviderInput,
+ input: GetModelProviderInput,
transaction?: Transaction<Database>,
): Promise<ModelProviderRecord | undefined> {
const db = transaction ?? this.#db;
@@ -53,7 +56,7 @@ export class PostgresModelProviderStore implements IModelProviderStore<Transacti
}
async getProviderForUpdate(
- input: GetProviderInput,
+ input: GetModelProviderInput,
transaction: Transaction<Database>,
): Promise<ModelProviderRecord | undefined> {
const row = await transaction
@@ -66,7 +69,36 @@ export class PostgresModelProviderStore implements IModelProviderStore<Transacti
return row ? toRecord(row) : undefined;
}
- async upsertProvider(input: UpsertProviderInput, transaction?: Transaction<Database>): Promise<ModelProviderRecord> {
+ async createProvider(
+ input: CreateModelProviderInput,
+ transaction?: Transaction<Database>,
+ ): Promise<ModelProviderRecord> {
+ const db = transaction ?? this.#db;
+ try {
+ const row = await db
+ .insertInto('model_provider')
+ .values({
+ tenant_id: input.tenant_id,
+ name: input.name,
+ manifest: json(input.manifest),
+ created_at: now(),
+ updated_at: now(),
+ })
+ .returningAll()
+ .executeTakeFirstOrThrow();
+ return toRecord(row);
+ } catch (error) {
+ if (isUniqueViolation(error)) {
+ throw new ModelProviderNameConflictError({ tenant_id: input.tenant_id, name: input.name }, { cause: error });
+ }
+ throw error;
+ }
+ }
+
+ async upsertProvider(
+ input: UpsertModelProviderInput,
+ transaction?: Transaction<Database>,
+ ): Promise<ModelProviderRecord> {
const db = transaction ?? this.#db;
const row = await db
.insertInto('model_provider')
diff --git a/packages/server/src/db/postgres/skill-store/PostgresSkillStore.ts b/packages/server/src/db/postgres/skill-store/PostgresSkillStore.ts
index c8bfa94fe..02ee203fc 100644
--- a/packages/server/src/db/postgres/skill-store/PostgresSkillStore.ts
+++ b/packages/server/src/db/postgres/skill-store/PostgresSkillStore.ts
@@ -1,11 +1,14 @@
import type { Kysely, Selectable, Transaction } from 'kysely';
import {
+ SkillNameConflictError,
+ type CreateSkillInput,
type GetSkillInput,
type ISkillStore,
type ListSkillsInput,
type SkillRecord,
type UpsertSkillInput,
} from '../../skillStore';
+import { isUniqueViolation } from '../client';
import { json, now } from '../sqlExpressions';
import type { Database, SkillTable } from '../types';
@@ -50,6 +53,29 @@ export class PostgresSkillStore implements ISkillStore<Transaction<Database>> {
return row === undefined ? undefined : toRecord(row);
}
+ async createSkill(input: CreateSkillInput, transaction?: Transaction<Database>): Promise<SkillRecord> {
+ const db = transaction ?? this.#db;
+ try {
+ const row = await db
+ .insertInto('skill')
+ .values({
+ tenant_id: input.tenant_id,
+ name: input.name,
+ manifest: json(input.manifest),
+ created_at: now(),
+ updated_at: now(),
+ })
+ .returningAll()
+ .executeTakeFirstOrThrow();
+ return toRecord(row);
+ } catch (error) {
+ if (isUniqueViolation(error)) {
+ throw new SkillNameConflictError({ tenant_id: input.tenant_id, name: input.name }, { cause: error });
+ }
+ throw error;
+ }
+ }
+
async upsertSkill(input: UpsertSkillInput, transaction?: Transaction<Database>): Promise<SkillRecord> {
const db = transaction ?? this.#db;
const row = await db
diff --git a/packages/server/src/db/skillStore.ts b/packages/server/src/db/skillStore.ts
index 0db8cd483..312ec14a7 100644
--- a/packages/server/src/db/skillStore.ts
+++ b/packages/server/src/db/skillStore.ts
@@ -27,15 +27,33 @@ export interface ListSkillsInput {
names: readonly string[] | undefined;
}
-export interface UpsertSkillInput {
+export interface CreateSkillInput {
tenant_id: string;
name: ResourceName;
manifest: SkillManifest;
}
+/** Same shape as create for now; kept as a distinct name for the upsert path. */
+export type UpsertSkillInput = CreateSkillInput;
+
+/** Unique `(tenant_id, name)` violation on create. */
+export class SkillNameConflictError extends Error {
+ readonly tenant_id: string;
+ readonly skill_name: string;
+
+ constructor({ tenant_id, name }: { tenant_id: string; name: string }, options?: ErrorOptions) {
+ super(`Skill name already exists: ${name}`, options);
+ this.name = 'SkillNameConflictError';
+ this.tenant_id = tenant_id;
+ this.skill_name = name;
+ }
+}
+
export interface ISkillStore<TTransaction = never> {
listSkills(input: ListSkillsInput, transaction?: TTransaction): Promise<SkillRecord[]>;
getSkill(input: GetSkillInput, transaction?: TTransaction): Promise<SkillRecord | undefined>;
+ /** Inserts a new skill. Throws SkillNameConflictError on name clash. */
+ createSkill(input: CreateSkillInput, transaction?: TTransaction): Promise<SkillRecord>;
/** Single-row write: creates the skill or replaces the whole manifest. */
upsertSkill(input: UpsertSkillInput, transaction?: TTransaction): Promise<SkillRecord>;
}
diff --git a/packages/server/src/db/sqlite/mcp-server-store/SqliteMcpServerStore.ts b/packages/server/src/db/sqlite/mcp-server-store/SqliteMcpServerStore.ts
index 4db327ec4..2ef987ad8 100644
--- a/packages/server/src/db/sqlite/mcp-server-store/SqliteMcpServerStore.ts
+++ b/packages/server/src/db/sqlite/mcp-server-store/SqliteMcpServerStore.ts
@@ -4,7 +4,9 @@ import type { OAuthClientRecord } from '../../../mcp/auth/types';
import type { McpServerManifest } from '../../../schemas/mcpServer';
import {
fromStoredOAuthClientRecord,
+ McpServerNameConflictError,
toStoredOAuthClientRecord,
+ type CreateMcpServerInput,
type GetMcpServerInput,
type IMcpServerStore,
type ListMcpServersInput,
@@ -13,6 +15,7 @@ import {
type OAuthServer,
type UpsertMcpServerInput,
} from '../../mcpServerStore';
+import { isUniqueViolation } from '../client';
import { jsonbBind, jsonText, nowIso } from '../sqlExpressions';
import type { Database } from '../types';
@@ -73,6 +76,32 @@ export class SqliteMcpServerStore implements IMcpServerStore<Transaction<Databas
.executeTakeFirst();
}
+ async createServer(input: CreateMcpServerInput, transaction?: Transaction<Database>): Promise<McpServerRecord> {
+ const db = transaction ?? this.#db;
+ const timestamp = nowIso();
+ try {
+ return await db
+ .insertInto('mcp_server')
+ .values({
+ id: ulid(),
+ tenant_id: input.tenant_id,
+ name: input.name,
+ manifest: jsonbBind(input.manifest),
+ oauth_server: null,
+ oauth_client: null,
+ created_at: timestamp,
+ updated_at: timestamp,
+ })
+ .returning(recordColumns)
+ .executeTakeFirstOrThrow();
+ } catch (error) {
+ if (isUniqueViolation(error)) {
+ throw new McpServerNameConflictError({ tenant_id: input.tenant_id, name: input.name }, { cause: error });
+ }
+ throw error;
+ }
+ }
+
async upsertServer(input: UpsertMcpServerInput, transaction?: Transaction<Database>): Promise<McpServerRecord> {
const db = transaction ?? this.#db;
const timestamp = nowIso();
diff --git a/packages/server/src/db/sqlite/model-provider-store/SqliteModelProviderStore.ts b/packages/server/src/db/sqlite/model-provider-store/SqliteModelProviderStore.ts
index 1862aed9e..8576f01fb 100644
--- a/packages/server/src/db/sqlite/model-provider-store/SqliteModelProviderStore.ts
+++ b/packages/server/src/db/sqlite/model-provider-store/SqliteModelProviderStore.ts
@@ -2,11 +2,14 @@ import type { ExpressionBuilder, Kysely, Transaction } from 'kysely';
import type { Model, ModelProvider } from '../../../schemas/modelProvider';
import {
flattenProviderModels,
- type GetProviderInput,
+ ModelProviderNameConflictError,
+ type CreateModelProviderInput,
+ type GetModelProviderInput,
type IModelProviderStore,
type ModelProviderRecord,
- type UpsertProviderInput,
+ type UpsertModelProviderInput,
} from '../../modelProviderStore';
+import { isUniqueViolation } from '../client';
import { jsonbBind, jsonText, nowIso } from '../sqlExpressions';
import type { Database } from '../types';
@@ -39,7 +42,7 @@ export class SqliteModelProviderStore implements IModelProviderStore<Transaction
}
async getProvider(
- input: GetProviderInput,
+ input: GetModelProviderInput,
transaction?: Transaction<Database>,
): Promise<ModelProviderRecord | undefined> {
const db = transaction ?? this.#db;
@@ -56,7 +59,7 @@ export class SqliteModelProviderStore implements IModelProviderStore<Transaction
* serializes concurrent writers so RMW of secrets stays consistent.
*/
async getProviderForUpdate(
- input: GetProviderInput,
+ input: GetModelProviderInput,
transaction: Transaction<Database>,
): Promise<ModelProviderRecord | undefined> {
return await transaction
@@ -67,7 +70,36 @@ export class SqliteModelProviderStore implements IModelProviderStore<Transaction
.executeTakeFirst();
}
- async upsertProvider(input: UpsertProviderInput, transaction?: Transaction<Database>): Promise<ModelProviderRecord> {
+ async createProvider(
+ input: CreateModelProviderInput,
+ transaction?: Transaction<Database>,
+ ): Promise<ModelProviderRecord> {
+ const db = transaction ?? this.#db;
+ const timestamp = nowIso();
+ try {
+ return await db
+ .insertInto('model_provider')
+ .values({
+ tenant_id: input.tenant_id,
+ name: input.name,
+ manifest: jsonbBind(input.manifest),
+ created_at: timestamp,
+ updated_at: timestamp,
+ })
+ .returning(recordColumns)
+ .executeTakeFirstOrThrow();
+ } catch (error) {
+ if (isUniqueViolation(error)) {
+ throw new ModelProviderNameConflictError({ tenant_id: input.tenant_id, name: input.name }, { cause: error });
+ }
+ throw error;
+ }
+ }
+
+ async upsertProvider(
+ input: UpsertModelProviderInput,
+ transaction?: Transaction<Database>,
+ ): Promise<ModelProviderRecord> {
const db = transaction ?? this.#db;
const timestamp = nowIso();
return await db
diff --git a/packages/server/src/db/sqlite/skill-store/SqliteSkillStore.ts b/packages/server/src/db/sqlite/skill-store/SqliteSkillStore.ts
index d4d153f44..c82b593a8 100644
--- a/packages/server/src/db/sqlite/skill-store/SqliteSkillStore.ts
+++ b/packages/server/src/db/sqlite/skill-store/SqliteSkillStore.ts
@@ -1,12 +1,15 @@
import type { ExpressionBuilder, Kysely, Transaction } from 'kysely';
import type { SkillManifest } from '../../../schemas/skill';
import {
+ SkillNameConflictError,
+ type CreateSkillInput,
type GetSkillInput,
type ISkillStore,
type ListSkillsInput,
type SkillRecord,
type UpsertSkillInput,
} from '../../skillStore';
+import { isUniqueViolation } from '../client';
import { jsonbBind, jsonText, nowIso } from '../sqlExpressions';
import type { Database } from '../types';
@@ -50,6 +53,29 @@ export class SqliteSkillStore implements ISkillStore<Transaction<Database>> {
.executeTakeFirst();
}
+ async createSkill(input: CreateSkillInput, transaction?: Transaction<Database>): Promise<SkillRecord> {
+ const db = transaction ?? this.#db;
+ const timestamp = nowIso();
+ try {
+ return await db
+ .insertInto('skill')
+ .values({
+ tenant_id: input.tenant_id,
+ name: input.name,
+ manifest: jsonbBind(input.manifest),
+ created_at: timestamp,
+ updated_at: timestamp,
+ })
+ .returning(recordColumns)
+ .executeTakeFirstOrThrow();
+ } catch (error) {
+ if (isUniqueViolation(error)) {
+ throw new SkillNameConflictError({ tenant_id: input.tenant_id, name: input.name }, { cause: error });
+ }
+ throw error;
+ }
+ }
+
async upsertSkill(input: UpsertSkillInput, transaction?: Transaction<Database>): Promise<SkillRecord> {
const db = transaction ?? this.#db;
const timestamp = nowIso();
diff --git a/packages/server/src/routes/mcpServerRoutes.ts b/packages/server/src/routes/mcpServerRoutes.ts
index 2d8a440f8..670274cbc 100644
--- a/packages/server/src/routes/mcpServerRoutes.ts
+++ b/packages/server/src/routes/mcpServerRoutes.ts
@@ -6,6 +6,7 @@
import { createRoute, z } from '@hono/zod-openapi';
import { RequestErrorResponseSchema } from '../schemas/errors';
import {
+ CreateMcpServerRequestSchema,
GetMcpServerResponseSchema,
ListAvailableMcpServersResponseSchema,
ListMcpServersResponseSchema,
@@ -90,6 +91,42 @@ export const getMcpServerRoute = createRoute({
},
});
+export const createMcpServerRoute = createRoute({
+ method: 'post',
+ path: '/',
+ tags: [MCP_SERVERS_TAG],
+ summary: 'Create an MCP server',
+ description:
+ 'Creates an MCP server by `name`. Fails if `name` is already taken. Runs DCR registration when `auth.type` is `dcr`. ' +
+ 'Header secrets: real value required; redacted with no stored value returns 400.',
+ 'x-fern-sdk-group-name': ['settings', 'mcpServers'],
+ 'x-fern-sdk-method-name': 'create',
+ request: {
+ body: {
+ content: { 'application/json': { schema: CreateMcpServerRequestSchema } },
+ required: true,
+ },
+ },
+ responses: {
+ 200: {
+ content: { 'application/json': { schema: PutMcpServerResponseSchema } },
+ description: 'The created MCP server with auth_status',
+ },
+ 400: {
+ content: { 'application/json': { schema: RequestErrorResponseSchema } },
+ description: 'Invalid request body, or redacted header secret with no stored value to keep.',
+ },
+ 409: {
+ content: { 'application/json': { schema: RequestErrorResponseSchema } },
+ description: 'An MCP server with this name already exists.',
+ },
+ 422: {
+ content: { 'application/json': { schema: RequestErrorResponseSchema } },
+ description: 'The server cannot satisfy `auth.type: dcr` (e.g. it advertises no registration_endpoint).',
+ },
+ },
+});
+
export const putMcpServerRoute = createRoute({
method: 'put',
path: '/',
diff --git a/packages/server/src/routes/modelProviderRoutes.ts b/packages/server/src/routes/modelProviderRoutes.ts
index da74a09bb..eca10bb96 100644
--- a/packages/server/src/routes/modelProviderRoutes.ts
+++ b/packages/server/src/routes/modelProviderRoutes.ts
@@ -7,7 +7,7 @@ import { createRoute } from '@hono/zod-openapi';
import { RequestErrorResponseSchema } from '../schemas/errors';
import {
ListModelProvidersResponseSchema,
- PutModelProviderRequestSchema,
+ ModelProviderSchema,
PutModelProviderResponseSchema,
} from '../schemas/modelProvider';
@@ -37,6 +37,38 @@ export const listModelProvidersRoute = createRoute({
},
});
+export const createModelProviderRoute = createRoute({
+ method: 'post',
+ path: '/',
+ tags: [MODEL_PROVIDERS_TAG],
+ summary: 'Create a model provider',
+ description:
+ 'Creates a provider (models included). Fails if `name` is already taken. Well-known types use `type` as `name` (one each); ' +
+ '`custom` is named by the caller. `auth.api_key`: real value required; redacted with no stored secret returns 400.',
+ 'x-fern-sdk-group-name': ['settings', 'modelProviders'],
+ 'x-fern-sdk-method-name': 'create',
+ request: {
+ body: {
+ content: { 'application/json': { schema: ModelProviderSchema } },
+ required: true,
+ },
+ },
+ responses: {
+ 200: {
+ content: { 'application/json': { schema: PutModelProviderResponseSchema } },
+ description: 'The created provider',
+ },
+ 400: {
+ content: { 'application/json': { schema: RequestErrorResponseSchema } },
+ description: 'Invalid request body, or redacted API key with no stored secret to keep.',
+ },
+ 409: {
+ content: { 'application/json': { schema: RequestErrorResponseSchema } },
+ description: 'A model provider with this name already exists.',
+ },
+ },
+});
+
export const putModelProviderRoute = createRoute({
method: 'put',
path: '/',
@@ -49,7 +81,7 @@ export const putModelProviderRoute = createRoute({
'x-fern-sdk-method-name': 'upsert',
request: {
body: {
- content: { 'application/json': { schema: PutModelProviderRequestSchema } },
+ content: { 'application/json': { schema: ModelProviderSchema } },
required: true,
},
},
diff --git a/packages/server/src/routes/skillRoutes.ts b/packages/server/src/routes/skillRoutes.ts
index 8ca72a38a..2f68417e6 100644
--- a/packages/server/src/routes/skillRoutes.ts
+++ b/packages/server/src/routes/skillRoutes.ts
@@ -9,8 +9,8 @@ import { RequestErrorResponseSchema } from '../schemas/errors';
import {
ListAvailableSkillsResponseSchema,
ListConfiguredSkillsResponseSchema,
- PutSkillRequestSchema,
PutSkillResponseSchema,
+ SkillManifestSchema,
} from '../schemas/skill';
const SKILLS_TAG = 'Skills';
@@ -60,6 +60,36 @@ export const listConfiguredSkillsRoute = createRoute({
},
});
+export const createSkillRoute = createRoute({
+ method: 'post',
+ path: '/',
+ tags: [SKILLS_TAG],
+ summary: 'Create a skill',
+ description: 'Creates a skill keyed by `name`. Fails if `name` is already taken.',
+ 'x-fern-sdk-group-name': ['settings', 'skills'],
+ 'x-fern-sdk-method-name': 'create',
+ request: {
+ body: {
+ content: { 'application/json': { schema: SkillManifestSchema } },
+ required: true,
+ },
+ },
+ responses: {
+ 200: {
+ content: { 'application/json': { schema: PutSkillResponseSchema } },
+ description: 'The created skill.',
+ },
+ 400: {
+ content: { 'application/json': { schema: RequestErrorResponseSchema } },
+ description: 'Invalid request body.',
+ },
+ 409: {
+ content: { 'application/json': { schema: RequestErrorResponseSchema } },
+ description: 'A skill with this name already exists.',
+ },
+ },
+});
+
export const putSkillRoute = createRoute({
method: 'put',
path: '/',
@@ -70,7 +100,7 @@ export const putSkillRoute = createRoute({
'x-fern-sdk-method-name': 'upsert',
request: {
body: {
- content: { 'application/json': { schema: PutSkillRequestSchema } },
+ content: { 'application/json': { schema: SkillManifestSchema } },
required: true,
},
},
diff --git a/packages/server/src/schemas/mcpServer.ts b/packages/server/src/schemas/mcpServer.ts
index cbf80a6ee..26d3d8ba1 100644
--- a/packages/server/src/schemas/mcpServer.ts
+++ b/packages/server/src/schemas/mcpServer.ts
@@ -72,8 +72,12 @@ export const ConfiguredMcpServerSchema = McpServerManifestObjectSchema.extend({
auth_status: McpAuthStatusSchema,
}).openapi('ConfiguredMcpServer');
+/** PUT body β€” same Zod shape as `McpServerManifest` (OpenAPI name stays `McpServerManifest`). */
export const PutMcpServerRequestSchema = McpServerManifestSchema;
+/** Shared create/upsert/disconnect response envelope (`{ data: ConfiguredMcpServer }`). */
export const PutMcpServerResponseSchema = z.object({ data: ConfiguredMcpServerSchema }).openapi('PutMcpServerResponse');
+/** POST create body β€” separate OpenAPI name so Fern keeps the main-branch upsert request + `type` inject. */
+export const CreateMcpServerRequestSchema = McpServerManifestObjectSchema.openapi('CreateMcpServerRequest');
export const GetMcpServerResponseSchema = z.object({ data: ConfiguredMcpServerSchema }).openapi('GetMcpServerResponse');
export const ListMcpServersResponseSchema = z
.object({ data: z.array(ConfiguredMcpServerSchema) })
diff --git a/packages/server/src/schemas/modelProvider.ts b/packages/server/src/schemas/modelProvider.ts
index 6cd0d0328..ecb7f2672 100644
--- a/packages/server/src/schemas/modelProvider.ts
+++ b/packages/server/src/schemas/modelProvider.ts
@@ -155,7 +155,7 @@ export type ModelProperties = z.infer<typeof ModelPropertiesSchema>;
* in one shape. Only `custom` carries a name, so the row's key column comes from
* `modelProviderName` rather than from a field every type repeats.
*/
-export const ModelProviderSchema = z
+const ModelProviderBodySchema = z
.discriminatedUnion('type', [
OpenAiModelProviderSchema,
AnthropicModelProviderSchema,
@@ -167,22 +167,22 @@ export const ModelProviderSchema = z
AlibabaModelProviderSchema,
CustomModelProviderSchema,
])
- .superRefine(refineModelProviderManifest)
- .openapi('ModelProvider');
+ .superRefine(refineModelProviderManifest);
+
+export const ModelProviderSchema = ModelProviderBodySchema.openapi('ModelProvider');
/** The row's key: only `custom` carries a name of its own. */
export function modelProviderName(provider: ModelProvider): ResourceName {
return provider.type === 'custom' ? provider.name : provider.type;
}
-export const PutModelProviderRequestSchema = ModelProviderSchema;
-
export const ListModelProvidersResponseSchema = z
.object({
data: z.array(ModelProviderSchema),
})
.openapi('ListModelProvidersResponse');
+/** Shared create/upsert response envelope (`{ data: ModelProvider }`). */
export const PutModelProviderResponseSchema = z
.object({
data: ModelProviderSchema,
diff --git a/packages/server/src/schemas/skill.ts b/packages/server/src/schemas/skill.ts
index c80bf9b8b..306ef3910 100644
--- a/packages/server/src/schemas/skill.ts
+++ b/packages/server/src/schemas/skill.ts
@@ -74,7 +74,7 @@ export const SkillManifestSchema = SkillManifestObjectSchema.openapi('SkillManif
/** Admin/settings wire view β€” same fields as the stored manifest (no auth_status). */
export const ConfiguredSkillSchema = SkillManifestSchema;
-export const PutSkillRequestSchema = SkillManifestSchema;
+/** Shared create/upsert response envelope (`{ data: SkillManifest }`). */
export const PutSkillResponseSchema = z.object({ data: ConfiguredSkillSchema }).openapi('PutSkillResponse');
export const ListConfiguredSkillsResponseSchema = z
.object({ data: z.array(ConfiguredSkillSchema) })
diff --git a/packages/server/tests/db/mcpServerStoreContractSuite.ts b/packages/server/tests/db/mcpServerStoreContractSuite.ts
index 3856137d7..a8219db7b 100644
--- a/packages/server/tests/db/mcpServerStoreContractSuite.ts
+++ b/packages/server/tests/db/mcpServerStoreContractSuite.ts
@@ -2,7 +2,7 @@
* Backend-agnostic behavioural contract for IMcpServerStore.
* Runs under jest against a fresh store per test (see backend test files).
*/
-import type { IMcpServerStore } from '../../src/db/mcpServerStore';
+import { McpServerNameConflictError, type IMcpServerStore } from '../../src/db/mcpServerStore';
import type { OAuthClientRecord } from '../../src/mcp/auth/types';
import type { McpServerManifest } from '../../src/schemas/mcpServer';
@@ -52,6 +52,20 @@ export function runMcpServerStoreContractSuite(getStore: () => IMcpServerStore):
expect(fetched).toEqual(created);
});
+ it('createServer inserts and throws McpServerNameConflictError on name clash', async () => {
+ const store = getStore();
+ const created = await store.createServer({
+ tenant_id: TENANT,
+ name: 'linear',
+ manifest: manifest(),
+ });
+ expect(created.name).toBe('linear');
+
+ await expect(
+ store.createServer({ tenant_id: TENANT, name: 'linear', manifest: manifest() }),
+ ).rejects.toBeInstanceOf(McpServerNameConflictError);
+ });
+
it('getServer returns undefined for unknown servers', async () => {
const store = getStore();
expect(await store.getServer({ tenant_id: TENANT, name: 'missing' })).toBeUndefined();
diff --git a/packages/server/tests/db/modelProviderStoreContractSuite.ts b/packages/server/tests/db/modelProviderStoreContractSuite.ts
index 853a1568f..620b5d74c 100644
--- a/packages/server/tests/db/modelProviderStoreContractSuite.ts
+++ b/packages/server/tests/db/modelProviderStoreContractSuite.ts
@@ -2,7 +2,7 @@
* Backend-agnostic behavioural contract for IModelProviderStore.
* Runs under jest against a fresh store per test (see backend test files).
*/
-import type { IModelProviderStore } from '../../src/db/modelProviderStore';
+import { ModelProviderNameConflictError, type IModelProviderStore } from '../../src/db/modelProviderStore';
import type { ModelProvider } from '../../src/schemas/modelProvider';
const TENANT = 'default';
@@ -55,6 +55,16 @@ export function runModelProviderStoreContractSuite(getStore: () => IModelProvide
expect(fetched).toEqual(created);
});
+ it('createProvider inserts and throws ModelProviderNameConflictError on name clash', async () => {
+ const store = getStore();
+ const created = await store.createProvider({ tenant_id: TENANT, name: 'anthropic', manifest: anthropic });
+ expect(created.manifest).toEqual(anthropic);
+
+ await expect(
+ store.createProvider({ tenant_id: TENANT, name: 'anthropic', manifest: anthropic }),
+ ).rejects.toBeInstanceOf(ModelProviderNameConflictError);
+ });
+
it('getProvider returns undefined for unknown providers', async () => {
const store = getStore();
expect(await store.getProvider({ tenant_id: TENANT, name: 'missing' })).toBeUndefined();
diff --git a/packages/server/tests/db/skillStoreContractSuite.ts b/packages/server/tests/db/skillStoreContractSuite.ts
index 3931fb526..499121547 100644
--- a/packages/server/tests/db/skillStoreContractSuite.ts
+++ b/packages/server/tests/db/skillStoreContractSuite.ts
@@ -2,7 +2,7 @@
* Backend-agnostic behavioural contract for ISkillStore.
* Runs under jest against a fresh store per test (see backend test files).
*/
-import type { ISkillStore } from '../../src/db/skillStore';
+import { SkillNameConflictError, type ISkillStore } from '../../src/db/skillStore';
import type { SkillManifest } from '../../src/schemas/skill';
const TENANT = 'default';
@@ -40,6 +40,20 @@ export function runSkillStoreContractSuite(getStore: () => ISkillStore): void {
expect(fetched).toEqual(created);
});
+ it('createSkill inserts and throws SkillNameConflictError on name clash', async () => {
+ const store = getStore();
+ const created = await store.createSkill({
+ tenant_id: TENANT,
+ name: 'algorithmic-art',
+ manifest: manifest(),
+ });
+ expect(created.name).toBe('algorithmic-art');
+
+ await expect(
+ store.createSkill({ tenant_id: TENANT, name: 'algorithmic-art', manifest: manifest() }),
+ ).rejects.toBeInstanceOf(SkillNameConflictError);
+ });
+
it('getSkill returns undefined for unknown skills', async () => {
const store = getStore();
expect(await store.getSkill({ tenant_id: TENANT, name: 'missing' })).toBeUndefined();
diff --git a/packages/server/tests/unit/apis/mcpServers.test.ts b/packages/server/tests/unit/apis/mcpServers.test.ts
index 143efa7ac..889450291 100644
--- a/packages/server/tests/unit/apis/mcpServers.test.ts
+++ b/packages/server/tests/unit/apis/mcpServers.test.ts
@@ -56,6 +56,14 @@ function putInit(body: unknown): RequestInit {
};
}
+function postInit(body: unknown): RequestInit {
+ return {
+ method: 'POST',
+ headers: { 'content-type': 'application/json' },
+ body: JSON.stringify(body),
+ };
+}
+
describe('mcp-servers routers', () => {
let settingsRouter: ReturnType<typeof createSettingsMcpServersRouter>;
let catalogRouter: ReturnType<typeof createCatalogRouter>;
@@ -153,6 +161,25 @@ describe('mcp-servers routers', () => {
});
});
+ it('POST creates a server and returns 409 on name clash', async () => {
+ const createBody = {
+ type: 'remote' as const,
+ name: 'create-only-mcp',
+ url: 'https://mcp.example.com/create-only',
+ };
+ const created = await settingsRouter.request('/', postInit(createBody));
+ expect(created.status).toBe(200);
+ expect(await created.json()).toEqual({
+ data: { ...createBody, auth_status: { status: 'not_required' } },
+ });
+
+ const clash = await settingsRouter.request('/', postInit(createBody));
+ expect(clash.status).toBe(409);
+ expect(await clash.json()).toEqual({
+ error: { message: 'MCP server name already exists: create-only-mcp' },
+ });
+ });
+
it('GET /{name} returns the configured server and 404s unknowns', async () => {
const response = await settingsRouter.request(`/${putBody.name}`);
expect(response.status).toBe(200);
@@ -178,6 +205,18 @@ describe('mcp-servers routers', () => {
expect(await mcpServerStore.getServer({ tenant_id: TENANT_ID, name: putBodyWithDcr.name })).toBeUndefined();
});
+ it('POST with DCR fails registration without writing a server row', async () => {
+ const createDcr = {
+ type: 'remote' as const,
+ name: 'create-dcr-fail',
+ url: 'https://mcp.example.com/dcr-fail',
+ auth: { type: 'dcr' as const },
+ };
+ const response = await settingsRouter.request('/', postInit(createDcr));
+ expect(response.status).toBe(422);
+ expect(await mcpServerStore.getServer({ tenant_id: TENANT_ID, name: createDcr.name })).toBeUndefined();
+ });
+
it('DCR server reads authenticated when a token row exists, auth_required once deleted', async () => {
const record = await seedDcrServerWithClient();
diff --git a/packages/server/tests/unit/apis/modelProviders.test.ts b/packages/server/tests/unit/apis/modelProviders.test.ts
index 6fe93aba8..1fb394604 100644
--- a/packages/server/tests/unit/apis/modelProviders.test.ts
+++ b/packages/server/tests/unit/apis/modelProviders.test.ts
@@ -60,6 +60,14 @@ function putInit(body: unknown): RequestInit {
};
}
+function postInit(body: unknown): RequestInit {
+ return {
+ method: 'POST',
+ headers: { 'content-type': 'application/json' },
+ body: JSON.stringify(body),
+ };
+}
+
function withRedactedApiKey<T extends { auth: { api_key: string } }>(provider: T): T {
return {
...provider,
@@ -134,6 +142,19 @@ describe('settings model-providers and models routers', () => {
expect(await list.json()).toEqual({ data: [anthropicProviderWire] });
});
+ it('POST creates a provider and returns 409 on name clash', async () => {
+ const { settingsRouter: fresh } = await createRouters();
+ const created = await fresh.request('/model-providers', postInit(anthropicBody));
+ expect(created.status).toBe(200);
+ expect(await created.json()).toEqual({ data: anthropicProviderWire });
+
+ const clash = await fresh.request('/model-providers', postInit(anthropicBody));
+ expect(clash.status).toBe(409);
+ expect(await clash.json()).toEqual({
+ error: { message: 'Model provider name already exists: anthropic' },
+ });
+ });
+
it('PUT requires base_url for custom providers', async () => {
const { base_url: _, ...withoutBaseUrl } = customBody;
const missingBaseUrl = await settingsRouter.request('/model-providers', putInit(withoutBaseUrl));
@@ -309,6 +330,19 @@ describe('model-provider secret redaction and strict PUT', () => {
expect(await response.json()).toEqual({ error: { message: 'API key is required' } });
});
+ it('POST create with a redacted api_key returns 400', async () => {
+ const { settingsRouter } = await createRouters();
+ const response = await settingsRouter.request(
+ '/model-providers',
+ postInit({
+ ...anthropicBody,
+ auth: { api_key: toRedactedSecretValue('sk-ant-secret') },
+ }),
+ );
+ expect(response.status).toBe(400);
+ expect(await response.json()).toEqual({ error: { message: 'API key is required' } });
+ });
+
it('PUT rejects a missing api_key at the Zod layer', async () => {
const { settingsRouter } = await createRouters();
const response = await settingsRouter.request('/model-providers', putInit({ ...anthropicBody, auth: {} }));
diff --git a/packages/server/tests/unit/apis/skills.test.ts b/packages/server/tests/unit/apis/skills.test.ts
index 2ba4b20b6..011b385f9 100644
--- a/packages/server/tests/unit/apis/skills.test.ts
+++ b/packages/server/tests/unit/apis/skills.test.ts
@@ -25,6 +25,14 @@ function putInit(body: unknown): RequestInit {
};
}
+function postInit(body: unknown): RequestInit {
+ return {
+ method: 'POST',
+ headers: { 'content-type': 'application/json' },
+ body: JSON.stringify(body),
+ };
+}
+
describe('skills routers', () => {
let settingsRouter: ReturnType<typeof createSkillsRouter>;
let catalogRouter: ReturnType<typeof createCatalogRouter>;
@@ -71,11 +79,31 @@ describe('skills routers', () => {
expect(await list.json()).toEqual({ data: [putBody] });
});
+ it('POST creates a skill and returns 409 on name clash', async () => {
+ const createBody = {
+ ...putBody,
+ name: 'create-only-skill',
+ path: 'skills/create-only-skill',
+ };
+ const created = await settingsRouter.request('/', postInit(createBody));
+ expect(created.status).toBe(200);
+ expect(await created.json()).toEqual({ data: createBody });
+
+ const clash = await settingsRouter.request('/', postInit(createBody));
+ expect(clash.status).toBe(409);
+ expect(await clash.json()).toEqual({
+ error: { message: 'Skill name already exists: create-only-skill' },
+ });
+ });
+
it('GET / on the chat router returns the slim name/description projection', async () => {
const response = await availableRouter.request('/');
expect(response.status).toBe(200);
expect(await response.json()).toEqual({
- data: [{ name: putBody.name, description: putBody.description }],
+ data: [
+ { name: putBody.name, description: putBody.description },
+ { name: 'create-only-skill', description: putBody.description },
+ ],
});
});