airops js

@airops/airops-js

Utilice la API AirOps en su aplicación cliente con nuestro SDK de JavaScript.

Empezando

Instalación

 npm i @airops/airops-js

o utilice la CDN:

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

Configuración del servidor

Para autenticarse con nuestra API mediante el SDK, necesitará tres datos: la identificación de su espacio de trabajo, la clave API y la identificación de usuario (identificador del usuario en su aplicación). Primero, use la clave API para codificar su identificación de usuario en su servidor back-end. Esto dará como resultado una identificación de usuario con hash que es única para su combinación de clave API e identificación de usuario. La identificación del espacio de trabajo y la clave API se pueden encontrar en la configuración de su espacio de trabajo.

Ejemplo de configuración del backend de 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 ;
} ; 

Inicializar el SDK

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

Tenga en cuenta que no se requiere autorización para ejecutar aplicaciones públicas. Si está trabajando con inicialización pública sin argumentos:

 const airopsInstance = new AirOps ( ) ; 

Uso

Una vez que haya inicializado correctamente el SDK, podrá comenzar a utilizar los métodos disponibles para interactuar con nuestra API. Tenga en cuenta que los métodos devolverán promesas.

Ejecutar una aplicación

El SDK proporciona un método para ejecutar una aplicación. Para transmitir los resultados de la aplicación, deberá habilitar la transmisión y pasar una función de devolución de llamada al método de ejecución. Opcionalmente, puede pasar una función de devolución de llamada adicional para recibir una notificación cuando finalice la aplicación.

 // 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 ( ) ;

Respuesta

La respuesta del método de ejecución contendrá la identificación de ejecución que se puede usar para recuperar los resultados más adelante junto con dos métodos para esperar los resultados o cancelar la ejecución:

 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 ;
}

El método de resultados implementa una lógica de extracción de resultados con un tiempo de espera de 10 minutos . Si desea implementar su propia lógica de extracción, puede utilizar el método getResults que se describe a continuación.

Extraer resultados de forma asíncrona

Puede implementar su propia lógica de extracción utilizando el método getResults.

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

Transmisión de chat

Para las aplicaciones de chat, puede utilizar el método chatStream que le permite enviar mensajes a la aplicación de 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 ;

Respuesta

La respuesta del método chatStream contendrá el sessionId y un método de resultado para esperar la respuesta. Para continuar con el chat pasa el sessionId junto con el mensaje.

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

Manejo de errores

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

¿Necesitar ayuda?

Únase a nuestra comunidad slack de creación de AirOps.