airops js

@airops/airops-js

Utilisez l'API AirOps dans votre application client avec notre SDK JavaScript.

Commencer

Installation

 npm i @airops/airops-js

ou utilisez le CDN :

 < script src = “https://cdn.jsdelivr.net/npm/@airops/airops-js/dist/index.umd.min.js” > </ script > 

Configuration du serveur

Pour vous authentifier auprès de notre API à l'aide du SDK, vous aurez besoin de trois informations : votre identifiant d'espace de travail, votre clé API et votre identifiant utilisateur (identifiant de l'utilisateur dans votre application). Tout d’abord, utilisez la clé API pour hacher votre identifiant utilisateur sur votre serveur back-end. Cela entraînera un identifiant utilisateur haché unique à votre combinaison de clé API et d'identifiant utilisateur. L’identifiant de l’espace de travail et la clé API se trouvent dans les paramètres de votre espace de travail.

Exemple de configuration du backend Node.js.

 const crypto = require ( 'crypto' ) ;

const userIdHash = ( ) => {
  const apiKey = 'YOUR_API_KEY' ;
  const userId = 'YOUR_USER_ID' ;

  // Convert your api key to a buffer
  const key = Buffer . from ( apiKey , 'utf-8' ) ;

  // Hash the message using HMAC-SHA256 and the key
  const hash = crypto . createHmac ( 'sha256' , key ) . update ( userId ) . digest ( 'hex' ) ;

  return hash ;
} ; 

Initialiser le SDK

 const airopsInstance = AirOps . identify ( {
  userId : 'YOUR_USER_ID' ,
  workspaceId : 'YOUR_WORKSPACE_ID' ,
  hashedUserId : 'YOUR_USER_ID_HASH' ,
} ) ;

Notez qu'aucune autorisation n'est requise pour exécuter des applications publiques. Si vous travaillez avec public initialize sans arguments :

 const airopsInstance = new AirOps ( ) ; 

Usage

Une fois que vous avez initialisé avec succès le SDK, vous pouvez commencer à utiliser les méthodes disponibles pour interagir avec notre API. Notez que les méthodes renverront des promesses.

Exécuter une application

Le SDK fournit une méthode pour exécuter une application. Afin de diffuser les résultats de l'application, vous devrez activer le flux et transmettre une fonction de rappel à la méthode d'exécution. En option, vous pouvez transmettre une fonction de rappel supplémentaire pour recevoir une notification lorsque l'application est terminée.

 // Execute an app
const response = await airopsInstance . apps . execute ( {
  appId : 1 ,
  version : 1 ,
  payload : {
    inputs : {
      name : 'XXXXYYYYZZZZ' ,
    } ,
  } ,
  stream : true , // Optional - Default false
  streamCallback : ( data : { content : string } ) => {
    // Do something with the data
  } , // Optional, required if stream is true
  streamCompletedCallback : ( data : { content : string } ) => {
    // Do something with the data
  } , // Optional
} ) ;

// Wait for result
const result = await response . result ( ) ;
// Do something with result.output

// Cancel execution
await response . cancel ( ) ;

Réponse

La réponse de la méthode d'exécution contiendra l'identifiant d'exécution qui pourra être utilisé pour récupérer les résultats ultérieurement ainsi que deux méthodes pour attendre les résultats ou annuler l'exécution :

 interface ExecuteResponse {
  executionId : number ;
  result : ( ) => Promise < AppExecution > ;
  cancel : ( ) => Promise < void > ;
}

interface AppExecution {
  airops_app_id : number ;
  id : number ;
  status : string ;
  output : string ;
  stream_channel_id : string ;
}

La méthode result implémente une logique d'extraction pour les résultats avec un délai d'attente de 10 minutes . Si vous souhaitez implémenter votre propre logique d'extraction, vous pouvez utiliser la méthode getResults décrite ci-dessous.

Extraire les résultats de manière asynchrone

Vous pouvez implémenter votre propre logique d'extraction à l'aide de la méthode getResults.

 const result = await airopsInstance . apps . getResults ( {
  executionId : response . executionId ,
} ) ;

Flux de discussion

Pour les applications Chat, vous pouvez utiliser la méthode chatStream qui vous permet d'envoyer des messages à l'application Chat.

 const response = await airopsInstance . apps . chatStream ( {
  appId : 2 ,
  message ,
  inputs : {
    name : 'XXXXYYYYZZZZ' ,
  } ,
  streamCallback : ( { action : ChatAction , ... data ) => {
    // ChatAction can either be 'agent-response', 'agent-action' or 'agent-action-error'
    // data will have different values depending on the action:
    //   - agent-response: { token: string, stream_finished: boolean, result :string }
    //   - agent-action: { tool: string, tool_input: Record<string, string> }
    //   - agent-action-error: { tool: string, tool_error: string }
  } ,
  streamCompletedCallback : ( data : { result : string } ) => {
    // do something with data.result
  } ,
  ... ( sessionId && { sessionId } ) , // optionally pass sessionId to continue chat.
} ) ;

// Wait for result
const result = await response . result ( ) ;
// Do something with result.result

// Cancel execution
await response . cancel ( ) ;

// Use session id to continue chat
response . sessionId ;

Réponse

La réponse de la méthode chatStream contiendra le sessionId et une méthode de résultat pour attendre la réponse. Afin de continuer le chat, transmettez le sessionId avec le message.

 export interface ChatStreamResponse {
  sessionId : string ;
  result : Promise < { result : string } > ; // result is a promise that resolves when the execution is completed.
}

Gestion des erreurs

 try {
  await airopsInstance . apps . execute ( {
    appId : 1 ,
    version : 4 ,
    payload : {
      inputs : { name : 'XXXXYYYYZZZZ' } ,
    } ,
  } ) ;
} catch ( e ) {
  // Do something with error.message
} 

Besoin d'aide ?

Rejoignez notre communauté Slack de constructeur AirOps.