@smithery/api 0.30.0 → 0.32.0

package/src/internal/parse.ts

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import type { FinalRequestOptions } from './request-options';
+import { Stream } from '../core/streaming';
 import { type Smithery } from '../client';
 import { formatRequestDetails, loggerFor } from './utils/log';
 
@@ -16,6 +17,19 @@ export type APIResponseProps = {
 export async function defaultParseResponse<T>(client: Smithery, props: APIResponseProps): Promise<T> {
   const { response, requestLogID, retryOfRequestLogID, startTime } = props;
   const body = await (async () => {
+    if (props.options.stream) {
+      loggerFor(client).debug('response', response.status, response.url, response.headers, response.body);
+
+      // Note: there is an invariant here that isn't represented in the type system
+      // that if you set `stream: true` the response type must also be `Stream<T>`
+
+      if (props.options.__streamClass) {
+        return props.options.__streamClass.fromSSEResponse(response, props.controller, client) as any;
+      }
+
+      return Stream.fromSSEResponse(response, props.controller, client) as any;
+    }
+
     // fetch refuses to read the body when the status code is 204.
     if (response.status === 204) {
       return null as T;

package/src/internal/request-options.ts

@@ -3,6 +3,7 @@
 import { NullableHeaders } from './headers';
 
 import type { BodyInit } from './builtin-types';
+import { Stream } from '../core/streaming';
 import type { HTTPMethod, MergedRequestInit } from './types';
 import { type HeadersLike } from './headers';
 
@@ -76,6 +77,7 @@ export type RequestOptions = {
   defaultBaseURL?: string | undefined;
 
   __binaryResponse?: boolean | undefined;
+  __streamClass?: typeof Stream;
 };
 
 export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit };

package/src/resources/beta/beta.ts

@@ -1,25 +1,15 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../../core/resource';
-import * as ToolsAPI from './tools';
-import { ToolSearchParams, ToolSearchResponse, Tools } from './tools';
 import * as ConnectAPI from './connect/connect';
 import { Connect } from './connect/connect';
 
 export class Beta extends APIResource {
-  tools: ToolsAPI.Tools = new ToolsAPI.Tools(this._client);
   connect: ConnectAPI.Connect = new ConnectAPI.Connect(this._client);
 }
 
-Beta.Tools = Tools;
 Beta.Connect = Connect;
 
 export declare namespace Beta {
-  export {
-    Tools as Tools,
-    type ToolSearchResponse as ToolSearchResponse,
-    type ToolSearchParams as ToolSearchParams,
-  };
-
   export { Connect as Connect };
 }

package/src/resources/beta/connect/mcp.ts

@@ -14,17 +14,13 @@ export class Mcp extends APIResource {
    * ```ts
    * const jsonRpcResponse = await client.beta.connect.mcp.call(
    *   'connectionId',
-   *   {
-   *     namespace: 'namespace',
-   *     jsonrpc: '2.0',
-   *     method: 'tools/list',
-   *   },
+   *   { namespace: 'namespace' },
    * );
    * ```
    */
   call(connectionID: string, params: McpCallParams, options?: RequestOptions): APIPromise<JsonRpcResponse> {
-    const { namespace, ...body } = params;
-    return this._client.post(path`/connect/${namespace}/${connectionID}/mcp`, { body, ...options });
+    const { namespace } = params;
+    return this._client.post(path`/connect/${namespace}/${connectionID}/mcp`, options);
   }
 }
 
@@ -53,30 +49,7 @@ export interface JsonRpcResponse {
 }
 
 export interface McpCallParams {
-  /**
-   * Path param
-   */
   namespace: string;
-
-  /**
-   * Body param
-   */
-  jsonrpc: '2.0';
-
-  /**
-   * Body param: MCP method to call
-   */
-  method: string;
-
-  /**
-   * Body param
-   */
-  id?: string | number;
-
-  /**
-   * Body param: Method parameters
-   */
-  params?: unknown;
 }
 
 export declare namespace Mcp {

package/src/resources/beta/index.ts

@@ -2,4 +2,3 @@
 
 export { Beta } from './beta';
 export { Connect } from './connect/index';
-export { Tools, type ToolSearchResponse, type ToolSearchParams } from './tools';

package/src/resources/index.ts

@@ -16,6 +16,7 @@ export {
   type ServerListResponse,
   type ServerDeleteResponse,
   type ServerGetResponse,
+  type ServerGetByNamespaceResponse,
   type ServerListParams,
   type ServerDeleteParams,
   type ServerDownloadParams,

package/src/resources/servers/deployments.ts

@@ -2,7 +2,9 @@
 
 import { APIResource } from '../../core/resource';
 import { APIPromise } from '../../core/api-promise';
+import { Stream } from '../../core/streaming';
 import { type Uploadable } from '../../core/uploads';
+import { buildHeaders } from '../../internal/headers';
 import { RequestOptions } from '../../internal/request-options';
 import { multipartFormRequestOptions } from '../../internal/uploads';
 import { path } from '../../internal/utils/path';
@@ -51,6 +53,29 @@ export class Deployments extends APIResource {
     );
   }
 
+  /**
+   * Upload and deploy an MCP server (hosted or external)
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.servers.deployments.deployByNamespace(
+   *     'namespace',
+   *     { payload: 'payload' },
+   *   );
+   * ```
+   */
+  deployByNamespace(
+    namespace: string,
+    body: DeploymentDeployByNamespaceParams,
+    options?: RequestOptions,
+  ): APIPromise<DeploymentDeployByNamespaceResponse> {
+    return this._client.put(
+      path`/servers/${namespace}/deployments`,
+      multipartFormRequestOptions({ body, ...options }, this._client),
+    );
+  }
+
   /**
    * Get deployment status
    *
@@ -67,6 +92,44 @@ export class Deployments extends APIResource {
     return this._client.get(path`/servers/${namespace}/${server}/deployments/${id}`, options);
   }
 
+  /**
+   * Get deployment status
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.servers.deployments.getByNamespace('id', {
+   *     namespace: 'namespace',
+   *   });
+   * ```
+   */
+  getByNamespace(
+    id: string,
+    params: DeploymentGetByNamespaceParams,
+    options?: RequestOptions,
+  ): APIPromise<DeploymentGetByNamespaceResponse> {
+    const { namespace } = params;
+    return this._client.get(path`/servers/${namespace}/deployments/${id}`, options);
+  }
+
+  /**
+   * List deployments for a server
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.servers.deployments.listByNamespace(
+   *     'namespace',
+   *   );
+   * ```
+   */
+  listByNamespace(
+    namespace: string,
+    options?: RequestOptions,
+  ): APIPromise<DeploymentListByNamespaceResponse> {
+    return this._client.get(path`/servers/${namespace}/deployments`, options);
+  }
+
   /**
    * Use id='latest' to resume the most recent deployment
    *
@@ -86,6 +149,76 @@ export class Deployments extends APIResource {
     const { namespace, server } = params;
     return this._client.post(path`/servers/${namespace}/${server}/deployments/${id}/resume`, options);
   }
+
+  /**
+   * Use id='latest' to resume the most recent deployment
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.servers.deployments.resumeByNamespace('id', {
+   *     namespace: 'namespace',
+   *   });
+   * ```
+   */
+  resumeByNamespace(
+    id: string,
+    params: DeploymentResumeByNamespaceParams,
+    options?: RequestOptions,
+  ): APIPromise<DeploymentResumeByNamespaceResponse> {
+    const { namespace } = params;
+    return this._client.post(path`/servers/${namespace}/deployments/${id}/resume`, options);
+  }
+
+  /**
+   * Returns a real-time SSE stream of deployment logs and status updates. Connect to
+   * this endpoint to receive live updates as the deployment progresses.
+   *
+   * @example
+   * ```ts
+   * const response = await client.servers.deployments.stream(
+   *   'id',
+   *   { namespace: 'namespace', server: 'server' },
+   * );
+   * ```
+   */
+  stream(
+    id: string,
+    params: DeploymentStreamParams,
+    options?: RequestOptions,
+  ): APIPromise<Stream<DeploymentStreamResponse>> {
+    const { namespace, server } = params;
+    return this._client.get(path`/servers/${namespace}/${server}/deployments/${id}/stream`, {
+      ...options,
+      headers: buildHeaders([{ Accept: 'text/event-stream' }, options?.headers]),
+      stream: true,
+    }) as APIPromise<Stream<DeploymentStreamResponse>>;
+  }
+
+  /**
+   * Returns a real-time SSE stream of deployment logs and status updates. Connect to
+   * this endpoint to receive live updates as the deployment progresses.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.servers.deployments.streamByNamespace('id', {
+   *     namespace: 'namespace',
+   *   });
+   * ```
+   */
+  streamByNamespace(
+    id: string,
+    params: DeploymentStreamByNamespaceParams,
+    options?: RequestOptions,
+  ): APIPromise<Stream<DeploymentStreamByNamespaceResponse>> {
+    const { namespace } = params;
+    return this._client.get(path`/servers/${namespace}/deployments/${id}/stream`, {
+      ...options,
+      headers: buildHeaders([{ Accept: 'text/event-stream' }, options?.headers]),
+      stream: true,
+    }) as APIPromise<Stream<DeploymentStreamByNamespaceResponse>>;
+  }
 }
 
 export type DeployPayload =
@@ -356,9 +489,19 @@ export namespace DeploymentListResponse {
 
     status: string;
 
+    type: string;
+
     updatedAt: string;
 
+    branch?: string | null;
+
+    commit?: string | null;
+
+    commitMessage?: string | null;
+
     mcpUrl?: string;
+
+    upstreamUrl?: string | null;
   }
 }
 
@@ -372,6 +515,16 @@ export interface DeploymentDeployResponse {
   warnings?: Array<string>;
 }
 
+export interface DeploymentDeployByNamespaceResponse {
+  deploymentId: string;
+
+  mcpUrl: string;
+
+  status: string;
+
+  warnings?: Array<string>;
+}
+
 export interface DeploymentGetResponse {
   id: string;
 
@@ -379,11 +532,21 @@ export interface DeploymentGetResponse {
 
   status: string;
 
+  type: string;
+
   updatedAt: string;
 
+  branch?: string | null;
+
+  commit?: string | null;
+
+  commitMessage?: string | null;
+
   logs?: Array<DeploymentGetResponse.Log>;
 
   mcpUrl?: string;
+
+  upstreamUrl?: string | null;
 }
 
 export namespace DeploymentGetResponse {
@@ -406,12 +569,99 @@ export namespace DeploymentGetResponse {
   }
 }
 
+export interface DeploymentGetByNamespaceResponse {
+  id: string;
+
+  createdAt: string;
+
+  status: string;
+
+  type: string;
+
+  updatedAt: string;
+
+  branch?: string | null;
+
+  commit?: string | null;
+
+  commitMessage?: string | null;
+
+  logs?: Array<DeploymentGetByNamespaceResponse.Log>;
+
+  mcpUrl?: string;
+
+  upstreamUrl?: string | null;
+}
+
+export namespace DeploymentGetByNamespaceResponse {
+  export interface Log {
+    level: string;
+
+    message: string;
+
+    stage: 'deploy' | 'scan' | 'metadata' | 'publish';
+
+    timestamp: string;
+
+    error?: Log.Error;
+  }
+
+  export namespace Log {
+    export interface Error {
+      message?: string;
+    }
+  }
+}
+
+export type DeploymentListByNamespaceResponse =
+  Array<DeploymentListByNamespaceResponse.DeploymentListByNamespaceResponseItem>;
+
+export namespace DeploymentListByNamespaceResponse {
+  export interface DeploymentListByNamespaceResponseItem {
+    id: string;
+
+    createdAt: string;
+
+    status: string;
+
+    type: string;
+
+    updatedAt: string;
+
+    branch?: string | null;
+
+    commit?: string | null;
+
+    commitMessage?: string | null;
+
+    mcpUrl?: string;
+
+    upstreamUrl?: string | null;
+  }
+}
+
 export interface DeploymentResumeResponse {
   deploymentId: string;
 
   status: string;
 }
 
+export interface DeploymentResumeByNamespaceResponse {
+  deploymentId: string;
+
+  status: string;
+}
+
+/**
+ * SSE events: init (with buffered logs), log, status, complete
+ */
+export type DeploymentStreamResponse = string;
+
+/**
+ * SSE events: init (with buffered logs), log, status, complete
+ */
+export type DeploymentStreamByNamespaceResponse = string;
+
 export interface DeploymentListParams {
   namespace: string;
 }
@@ -444,18 +694,58 @@ export interface DeploymentDeployParams {
   sourcemap?: Uploadable;
 }
 
+export interface DeploymentDeployByNamespaceParams {
+  /**
+   * JSON-encoded deployment payload. See DeployPayload schema for structure.
+   */
+  payload: string;
+
+  /**
+   * MCPB bundle file (for stdio deployments)
+   */
+  bundle?: Uploadable;
+
+  /**
+   * JavaScript module file (for hosted deployments)
+   */
+  module?: Uploadable;
+
+  /**
+   * Source map file (for hosted deployments)
+   */
+  sourcemap?: Uploadable;
+}
+
 export interface DeploymentGetParams {
   namespace: string;
 
   server: string;
 }
 
+export interface DeploymentGetByNamespaceParams {
+  namespace: string;
+}
+
 export interface DeploymentResumeParams {
   namespace: string;
 
   server: string;
 }
 
+export interface DeploymentResumeByNamespaceParams {
+  namespace: string;
+}
+
+export interface DeploymentStreamParams {
+  namespace: string;
+
+  server: string;
+}
+
+export interface DeploymentStreamByNamespaceParams {
+  namespace: string;
+}
+
 export declare namespace Deployments {
   export {
     type DeployPayload as DeployPayload,
@@ -465,11 +755,22 @@ export declare namespace Deployments {
     type StdioDeployPayload as StdioDeployPayload,
     type DeploymentListResponse as DeploymentListResponse,
     type DeploymentDeployResponse as DeploymentDeployResponse,
+    type DeploymentDeployByNamespaceResponse as DeploymentDeployByNamespaceResponse,
     type DeploymentGetResponse as DeploymentGetResponse,
+    type DeploymentGetByNamespaceResponse as DeploymentGetByNamespaceResponse,
+    type DeploymentListByNamespaceResponse as DeploymentListByNamespaceResponse,
     type DeploymentResumeResponse as DeploymentResumeResponse,
+    type DeploymentResumeByNamespaceResponse as DeploymentResumeByNamespaceResponse,
+    type DeploymentStreamResponse as DeploymentStreamResponse,
+    type DeploymentStreamByNamespaceResponse as DeploymentStreamByNamespaceResponse,
     type DeploymentListParams as DeploymentListParams,
     type DeploymentDeployParams as DeploymentDeployParams,
+    type DeploymentDeployByNamespaceParams as DeploymentDeployByNamespaceParams,
     type DeploymentGetParams as DeploymentGetParams,
+    type DeploymentGetByNamespaceParams as DeploymentGetByNamespaceParams,
     type DeploymentResumeParams as DeploymentResumeParams,
+    type DeploymentResumeByNamespaceParams as DeploymentResumeByNamespaceParams,
+    type DeploymentStreamParams as DeploymentStreamParams,
+    type DeploymentStreamByNamespaceParams as DeploymentStreamByNamespaceParams,
   };
 }

package/src/resources/servers/index.ts

@@ -9,31 +9,57 @@ export {
   type StdioDeployPayload,
   type DeploymentListResponse,
   type DeploymentDeployResponse,
+  type DeploymentDeployByNamespaceResponse,
   type DeploymentGetResponse,
+  type DeploymentGetByNamespaceResponse,
+  type DeploymentListByNamespaceResponse,
   type DeploymentResumeResponse,
+  type DeploymentResumeByNamespaceResponse,
+  type DeploymentStreamResponse,
+  type DeploymentStreamByNamespaceResponse,
   type DeploymentListParams,
   type DeploymentDeployParams,
+  type DeploymentDeployByNamespaceParams,
   type DeploymentGetParams,
+  type DeploymentGetByNamespaceParams,
   type DeploymentResumeParams,
+  type DeploymentResumeByNamespaceParams,
+  type DeploymentStreamParams,
+  type DeploymentStreamByNamespaceParams,
 } from './deployments';
-export { Logs, type LogListResponse, type LogListParams } from './logs';
+export {
+  Logs,
+  type LogListResponse,
+  type LogListByNamespaceResponse,
+  type LogListParams,
+  type LogListByNamespaceParams,
+} from './logs';
 export {
   Repo,
   type RepoDeleteResponse,
+  type RepoDeleteByNamespaceResponse,
   type RepoGetResponse,
+  type RepoGetByNamespaceResponse,
   type RepoSetResponse,
+  type RepoSetByNamespaceResponse,
   type RepoDeleteParams,
   type RepoGetParams,
   type RepoSetParams,
+  type RepoSetByNamespaceParams,
 } from './repo';
 export {
   Secrets,
   type SecretListResponse,
   type SecretDeleteResponse,
+  type SecretDeleteByNamespaceResponse,
+  type SecretListByNamespaceResponse,
   type SecretSetResponse,
+  type SecretSetByNamespaceResponse,
   type SecretListParams,
   type SecretDeleteParams,
+  type SecretDeleteByNamespaceParams,
   type SecretSetParams,
+  type SecretSetByNamespaceParams,
 } from './secrets';
 export {
   Servers,
@@ -43,6 +69,7 @@ export {
   type ServerListResponse,
   type ServerDeleteResponse,
   type ServerGetResponse,
+  type ServerGetByNamespaceResponse,
   type ServerListParams,
   type ServerDeleteParams,
   type ServerDownloadParams,