@smithery/api 0.63.1 → 0.64.1

package/src/resources/connections/tools.ts

@@ -0,0 +1,185 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Tools extends APIResource {
+  /**
+   * List tools exposed by a connection.
+   *
+   * @example
+   * ```ts
+   * const toolList = await client.connections.tools.list(
+   *   'connectionId',
+   *   { namespace: 'namespace' },
+   * );
+   * ```
+   */
+  list(connectionID: string, params: ToolListParams, options?: RequestOptions): APIPromise<ToolList> {
+    const { namespace } = params;
+    return this._client.get(path`/${namespace}/${connectionID}/.tools`, {
+      defaultBaseURL: 'https://smithery.run',
+      ...options,
+    });
+  }
+
+  /**
+   * Invoke a tool with JSON arguments.
+   *
+   * @example
+   * ```ts
+   * const response = await client.connections.tools.call(
+   *   'toolPath',
+   *   {
+   *     namespace: 'namespace',
+   *     connectionId: 'connectionId',
+   *     body: { foo: 'bar' },
+   *   },
+   * );
+   * ```
+   */
+  call(toolPath: string, params: ToolCallParams, options?: RequestOptions): APIPromise<ToolCallResponse> {
+    const { namespace, connectionId, body } = params;
+    return this._client.post(path`/${namespace}/${connectionId}/.tools/${toolPath}`, {
+      body: body,
+      defaultBaseURL: 'https://smithery.run',
+      ...options,
+    });
+  }
+
+  /**
+   * Get one tool or list tools under a slash-separated category.
+   *
+   * @example
+   * ```ts
+   * const toolResponse = await client.connections.tools.get(
+   *   'toolPath',
+   *   { namespace: 'namespace', connectionId: 'connectionId' },
+   * );
+   * ```
+   */
+  get(toolPath: string, params: ToolGetParams, options?: RequestOptions): APIPromise<ToolResponse> {
+    const { namespace, connectionId } = params;
+    return this._client.get(path`/${namespace}/${connectionId}/.tools/${toolPath}`, {
+      defaultBaseURL: 'https://smithery.run',
+      ...options,
+    });
+  }
+}
+
+export interface Tool {
+  inputSchema: Tool.InputSchema;
+
+  name: string;
+
+  _meta?: { [key: string]: unknown };
+
+  annotations?: Tool.Annotations;
+
+  description?: string;
+
+  execution?: Tool.Execution;
+
+  icons?: Array<Tool.Icon>;
+
+  outputSchema?: Tool.OutputSchema;
+
+  title?: string;
+}
+
+export namespace Tool {
+  export interface InputSchema {
+    type: 'object';
+
+    properties?: { [key: string]: unknown };
+
+    required?: Array<string>;
+
+    [k: string]: unknown;
+  }
+
+  export interface Annotations {
+    destructiveHint?: boolean;
+
+    idempotentHint?: boolean;
+
+    openWorldHint?: boolean;
+
+    readOnlyHint?: boolean;
+
+    title?: string;
+  }
+
+  export interface Execution {
+    taskSupport?: 'required' | 'optional' | 'forbidden';
+  }
+
+  export interface Icon {
+    src: string;
+
+    mimeType?: string;
+
+    sizes?: Array<string>;
+
+    theme?: 'light' | 'dark';
+  }
+
+  export interface OutputSchema {
+    type: 'object';
+
+    properties?: { [key: string]: unknown };
+
+    required?: Array<string>;
+
+    [k: string]: unknown;
+  }
+}
+
+export interface ToolList {
+  tools: Array<Tool>;
+}
+
+export type ToolResponse = Tool | ToolList;
+
+export type ToolCallResponse = { [key: string]: unknown };
+
+export interface ToolListParams {
+  namespace: string;
+}
+
+export interface ToolCallParams {
+  /**
+   * Path param
+   */
+  namespace: string;
+
+  /**
+   * Path param
+   */
+  connectionId: string;
+
+  /**
+   * Body param
+   */
+  body: { [key: string]: unknown };
+}
+
+export interface ToolGetParams {
+  namespace: string;
+
+  connectionId: string;
+}
+
+export declare namespace Tools {
+  export {
+    type Tool as Tool,
+    type ToolList as ToolList,
+    type ToolResponse as ToolResponse,
+    type ToolCallResponse as ToolCallResponse,
+    type ToolListParams as ToolListParams,
+    type ToolCallParams as ToolCallParams,
+    type ToolGetParams as ToolGetParams,
+  };
+}

package/src/resources/connections/triggers.ts

@@ -15,6 +15,7 @@ export class Triggers extends APIResource {
    *   await client.connections.triggers.create('triggerName', {
    *     namespace: 'namespace',
    *     connectionId: 'connectionId',
+   *     params: { foo: 'bar' },
    *   });
    * ```
    */
@@ -23,8 +24,9 @@ export class Triggers extends APIResource {
     params: TriggerCreateParams,
     options?: RequestOptions,
   ): APIPromise<TriggerInstance> {
-    const { namespace, connectionId } = params;
+    const { namespace, connectionId, ...body } = params;
     return this._client.post(path`/${namespace}/${connectionId}/.triggers/${triggerName}`, {
+      body,
       defaultBaseURL: 'https://smithery.run',
       ...options,
     });
@@ -198,9 +200,20 @@ export interface TriggerDeleteResponse {
 }
 
 export interface TriggerCreateParams {
+  /**
+   * Path param
+   */
   namespace: string;
 
+  /**
+   * Path param
+   */
   connectionId: string;
+
+  /**
+   * Body param: Trigger-specific parameters defined by the trigger inputSchema
+   */
+  params: { [key: string]: unknown };
 }
 
 export interface TriggerListParams {

package/src/resources/index.ts

@@ -64,6 +64,7 @@ export {
   type Subscription,
   type SubscriptionList,
   type SubscriptionDeleteResponse,
+  type SubscriptionCreateParams,
   type SubscriptionDeleteParams,
 } from './subscriptions';
 export {

package/src/resources/organizations/api-keys.ts

@@ -49,7 +49,17 @@ export interface APIKeyCreateResponse {
 }
 
 export interface APIKeyListResponse {
-  apiKeys: Array<unknown>;
+  apiKeys: Array<APIKeyListResponse.APIKey>;
+}
+
+export namespace APIKeyListResponse {
+  export interface APIKey {
+    id: string;
+
+    createdAt: string;
+
+    name: string;
+  }
 }
 
 export interface APIKeyDeleteResponse {

package/src/resources/servers/releases.ts

@@ -161,6 +161,8 @@ export interface HostedDeployPayload {
 
   configSchema?: { [key: string]: unknown };
 
+  secretNames?: Array<string>;
+
   serverCard?: ServerCard;
 
   source?: HostedDeployPayload.Source;
@@ -497,7 +499,7 @@ export namespace ReleaseGetResponse {
 
     /**
      * Pipeline stage: deploy (bundle upload), scan (security/OAuth check), metadata
-     * (tool discovery), publish (making the server live).
+     * (tool discovery), publish (generated artifacts).
      */
     stage: 'deploy' | 'scan' | 'metadata' | 'publish';
 

package/src/resources/servers/servers.ts

@@ -392,6 +392,8 @@ export namespace ServerGetResponse {
     inputSchema: Tool.InputSchema;
 
     name: string;
+
+    outputSchema?: Tool.OutputSchema;
   }
 
   export namespace Tool {
@@ -400,6 +402,14 @@ export namespace ServerGetResponse {
 
       properties?: { [key: string]: unknown };
     }
+
+    export interface OutputSchema {
+      type: 'object';
+
+      properties?: { [key: string]: unknown };
+
+      required?: Array<string>;
+    }
   }
 }
 

package/src/resources/subscriptions.ts

@@ -9,9 +9,26 @@ export class Subscriptions extends APIResource {
   /**
    * Create a namespace-scoped subscription that receives events from every
    * connection in the namespace.
+   *
+   * @example
+   * ```ts
+   * const subscription = await client.subscriptions.create(
+   *   'namespace',
+   *   {
+   *     secret:
+   *       'whsec_dGVzdF9zZWNyZXRfMjRfYnl0ZXNfbWluaW11bSE=',
+   *     url: 'https://my-app.example.com/events',
+   *   },
+   * );
+   * ```
    */
-  create(namespace: string, options?: RequestOptions): APIPromise<CreateSubscriptionResponse> {
+  create(
+    namespace: string,
+    body: SubscriptionCreateParams,
+    options?: RequestOptions,
+  ): APIPromise<Subscription> {
     return this._client.post(path`/${namespace}/.subscriptions`, {
+      body,
       defaultBaseURL: 'https://smithery.run',
       ...options,
     });
@@ -20,6 +37,13 @@ export class Subscriptions extends APIResource {
   /**
    * List namespace-scoped trigger subscriptions for all connections in the
    * namespace.
+   *
+   * @example
+   * ```ts
+   * const subscriptionList = await client.subscriptions.list(
+   *   'namespace',
+   * );
+   * ```
    */
   list(namespace: string, options?: RequestOptions): APIPromise<SubscriptionList> {
     return this._client.get(path`/${namespace}/.subscriptions`, {
@@ -30,6 +54,14 @@ export class Subscriptions extends APIResource {
 
   /**
    * Delete a namespace-scoped trigger subscription.
+   *
+   * @example
+   * ```ts
+   * const subscription = await client.subscriptions.delete(
+   *   'subscriptionId',
+   *   { namespace: 'namespace' },
+   * );
+   * ```
    */
   delete(
     subscriptionID: string,
@@ -45,6 +77,11 @@ export class Subscriptions extends APIResource {
 }
 
 export interface CreateSubscriptionRequest {
+  /**
+   * Standard Webhooks signing secret generated and stored by the receiver
+   */
+  secret: string;
+
   /**
    * HTTPS webhook destination
    */
@@ -67,11 +104,6 @@ export interface CreateSubscriptionResponse {
    */
   created_at: string;
 
-  /**
-   * Webhook signing secret. Returned only once at creation time.
-   */
-  secret: string;
-
   /**
    * Destination URL for webhook deliveries
    */
@@ -106,6 +138,18 @@ export interface SubscriptionDeleteResponse {
   success: true;
 }
 
+export interface SubscriptionCreateParams {
+  /**
+   * Standard Webhooks signing secret generated and stored by the receiver
+   */
+  secret: string;
+
+  /**
+   * HTTPS webhook destination
+   */
+  url: string;
+}
+
 export interface SubscriptionDeleteParams {
   namespace: string;
 }
@@ -117,6 +161,7 @@ export declare namespace Subscriptions {
     type Subscription as Subscription,
     type SubscriptionList as SubscriptionList,
     type SubscriptionDeleteResponse as SubscriptionDeleteResponse,
+    type SubscriptionCreateParams as SubscriptionCreateParams,
     type SubscriptionDeleteParams as SubscriptionDeleteParams,
   };
 }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.63.1'; // x-release-please-version
+export const VERSION = '0.64.1'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.63.1";
+export declare const VERSION = "0.64.1";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.63.1";
+export declare const VERSION = "0.64.1";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.63.1'; // x-release-please-version
+exports.VERSION = '0.64.1'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.63.1'; // x-release-please-version
+export const VERSION = '0.64.1'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map