airops js

@airops/airops-js

Verwenden Sie die AirOps-API in Ihrer Client-Anwendung mit unserem JavaScript SDK.

Erste Schritte

Installation

 npm i @airops/airops-js

oder nutzen Sie das CDN:

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

Serverkonfiguration

Für die Authentifizierung bei unserer API mithilfe des SDK benötigen Sie drei Informationen: Ihre Workspace-ID, Ihren API-Schlüssel und Ihre Benutzer-ID (Identifikator für den Benutzer in Ihrer Anwendung). Verwenden Sie zunächst den API-Schlüssel, um Ihre Benutzer-ID auf Ihrem Back-End-Server zu hashen. Dies führt zu einer gehashten Benutzer-ID, die für Ihre Kombination aus API-Schlüssel und Benutzer-ID eindeutig ist. Workspace-ID und API-Schlüssel finden Sie in Ihren Workspace-Einstellungen.

Beispiel einer Node.js-Backend-Konfiguration.

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

Initialisieren Sie das SDK

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

Beachten Sie, dass zum Ausführen öffentlicher Apps keine Autorisierung erforderlich ist. Wenn Sie mit public initialize ohne Argumente arbeiten:

 const airopsInstance = new AirOps ( ) ; 

Verwendung

Sobald Sie das SDK erfolgreich initialisiert haben, können Sie mit der Verwendung der verfügbaren Methoden zur Interaktion mit unserer API beginnen. Beachten Sie, dass die Methoden Versprechen zurückgeben.

Führen Sie eine App aus

Das SDK bietet eine Methode zum Ausführen einer App. Um die App-Ergebnisse zu streamen, müssen Sie den Stream aktivieren und eine Rückruffunktion an die Ausführungsmethode übergeben. Optional können Sie eine zusätzliche Callback-Funktion übergeben, um eine Benachrichtigung zu erhalten, wenn die App fertig ist.

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

Antwort

Die Antwort der Ausführungsmethode enthält die Ausführungs-ID, die zum späteren Abrufen von Ergebnissen verwendet werden kann, sowie zwei Methoden zum Warten auf Ergebnisse oder zum Abbrechen der Ausführung:

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

Die Ergebnismethode implementiert eine Pull-Logik für Ergebnisse mit einem Timeout von 10 Minuten . Wenn Sie Ihre eigene Pull-Logik implementieren möchten, können Sie die unten beschriebene getResults-Methode verwenden.

Ergebnisse asynchron abrufen

Mit der getResults-Methode können Sie Ihre eigene Pull-Logik implementieren.

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

Chat-Stream

Für Chat-Apps können Sie die chatStream -Methode verwenden, mit der Sie Nachrichten an die Chat-App senden können.

 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 ;

Antwort

Die Antwort der chatStream-Methode enthält die Sitzungs-ID und eine Ergebnismethode, um auf die Antwort zu warten. Um mit dem Chat fortzufahren, übergeben Sie die Sitzungs-ID zusammen mit der Nachricht.

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

Fehlerbehandlung

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

Brauchen Sie Hilfe?

Treten Sie unserer AirOps-Builder-Slack-Community bei.