@aiqa/sdk 0.0.5 → 0.0.6

package/dist/browser/browser.d.ts

@@ -1,2 +1,100 @@
+import { Socket } from 'socket.io-client';
 
-export {  }
+type Application = {
+    application_id: string;
+    client_name: string;
+    client_phone_number: string;
+    agent_id: string;
+    agent_first_name: string;
+    agent_last_name: string;
+};
+declare enum Methods {
+    AUTHENTICATE = "AUTHENTICATE",
+    GET_FACTS = "GET_FACTS",
+    START_RECORDING = "START_RECORDING",
+    STOP_RECORDING = "STOP_RECORDING",
+    IS_RECORDING = "IS_RECORDING",
+    ADD_FACT = "ADD_FACT"
+}
+type SdkEvent = Methods | 'connect' | 'disconnect' | 'close' | 'error' | 'reconnect_attempt' | 'reconnect_error' | 'reconnect_failed' | 'authenticated' | 'app_version';
+declare enum FactAnswerFormatType {
+    string = "STRING",
+    number = "NUMBER",
+    integer = "INT",
+    float = "FLOAT",
+    bool = "BOOL",
+    list = "LIST",
+    strict = "STRICT",
+    single_choice = "SINGLE_CHOICE",
+    multiple_choices = "MULTIPLE_CHOICES"
+}
+type ApplicationFactAnswerChoice = {
+    key: string;
+    text: string;
+};
+type ApplicationFactAnswerFormat = {
+    type: FactAnswerFormatType;
+    choices?: ApplicationFactAnswerChoice[];
+};
+type ApplicationFactInput = {
+    id: string;
+    question: string;
+    expected_answer: any;
+    answer_format: ApplicationFactAnswerFormat;
+    category_id?: string;
+    category_name?: string;
+    language?: string;
+    critical?: boolean;
+    is_skipped?: boolean;
+};
+type QuestionStatus = 'searching' | 'asked' | 'not_asked';
+type VerificationStatus = 'processing' | 'matched' | 'unmatched';
+type ApplicationFact = ApplicationFactInput & {
+    ai_answer?: any;
+    question_status: QuestionStatus;
+    verification_status: VerificationStatus;
+};
+type FactIsMatched = boolean;
+type SdkError = {
+    code: 'INVALID_CONFIG' | 'CONNECTION_ERROR' | 'TIMEOUT' | 'SERVER_ERROR' | 'UNEXPECTED_RESPONSE';
+    message: string;
+    details?: any;
+};
+declare abstract class IAiqaSdk {
+    abstract connect(): void;
+    abstract disconnect(): void;
+    abstract on(eventName: string, callback: (...args: any[]) => any): void;
+    abstract off(eventName: string): void;
+    abstract getApplication(): Promise<Application>;
+    abstract addFact(fact: ApplicationFactInput): Promise<FactIsMatched>;
+    abstract getFacts(): Promise<ApplicationFact[]>;
+}
+
+declare class AiQaSdk implements IAiqaSdk {
+    socket: Socket | null;
+    url: string;
+    applicationId: string;
+    applicationSecretKey: string;
+    cachedApplication?: Application;
+    internalListeners: Map<SdkEvent, Set<(...args: any[]) => void>>;
+    internalEvents: Set<SdkEvent>;
+    constructor(applicationId: string, applicationSecret: string, url?: string);
+    on(name: SdkEvent, callback: (...args: any[]) => any): void;
+    off(name: SdkEvent, callback?: (...args: any[]) => any): void;
+    connect(): void;
+    disconnect(): void;
+    sendMessage(method: Methods, data?: any): Promise<any>;
+    getApplication(): Promise<Application>;
+    getFacts(): Promise<ApplicationFact[]>;
+    addFact(fact: ApplicationFactInput): Promise<FactIsMatched>;
+    authenticate(): Promise<void>;
+    startRecording(): Promise<boolean>;
+    stopRecording(): Promise<boolean>;
+    isRecordingNow(): Promise<boolean>;
+    private compareVersions;
+    private emitInternal;
+    private createRequestId;
+    private isManagerEvent;
+}
+
+export { AiQaSdk, type Application, type ApplicationFact, type ApplicationFactAnswerChoice, type ApplicationFactAnswerFormat, type ApplicationFactInput, FactAnswerFormatType, type FactIsMatched, IAiqaSdk, Methods, type QuestionStatus, type SdkError, type SdkEvent, type VerificationStatus };

package/dist/browser/browser.js

@@ -3398,16 +3398,41 @@ Object.assign(lookup2, {
   connect: lookup2
 });
 
+// src/types.ts
+var Methods = /* @__PURE__ */ ((Methods2) => {
+  Methods2["AUTHENTICATE"] = "AUTHENTICATE";
+  Methods2["GET_FACTS"] = "GET_FACTS";
+  Methods2["START_RECORDING"] = "START_RECORDING";
+  Methods2["STOP_RECORDING"] = "STOP_RECORDING";
+  Methods2["IS_RECORDING"] = "IS_RECORDING";
+  Methods2["ADD_FACT"] = "ADD_FACT";
+  return Methods2;
+})(Methods || {});
+var FactAnswerFormatType = /* @__PURE__ */ ((FactAnswerFormatType2) => {
+  FactAnswerFormatType2["string"] = "STRING";
+  FactAnswerFormatType2["number"] = "NUMBER";
+  FactAnswerFormatType2["integer"] = "INT";
+  FactAnswerFormatType2["float"] = "FLOAT";
+  FactAnswerFormatType2["bool"] = "BOOL";
+  FactAnswerFormatType2["list"] = "LIST";
+  FactAnswerFormatType2["strict"] = "STRICT";
+  FactAnswerFormatType2["single_choice"] = "SINGLE_CHOICE";
+  FactAnswerFormatType2["multiple_choices"] = "MULTIPLE_CHOICES";
+  return FactAnswerFormatType2;
+})(FactAnswerFormatType || {});
+var IAiqaSdk = class {
+};
+
 // package.json
 var package_default = {
   name: "@aiqa/sdk",
-  version: "0.0.3",
+  version: "0.0.5",
   main: "dist/node/node.js",
   module: "dist/node/node.js",
   types: "dist/node/node.d.ts",
   engines: { node: ">=18" },
   scripts: {
-    build: "tsup",
+    build: `tsup && node -e "const fs=require('fs');['dist/node/node','dist/browser/browser'].forEach(f=>{const mts=f+'.d.mts';const ts=f+'.d.ts';if(fs.existsSync(mts)){fs.renameSync(mts,ts);}});"`,
     "dev:node": "tsx src/node.ts",
     "start:node": "node dist/node/node.js",
     "serve:browser": "serve .",
@@ -3457,4 +3482,219 @@ var package_default = {
 
 // src/shared.ts
 var SDK_VERSION = package_default.version ?? "0.0.1";
+var DEFAULT_URL = "ws://localhost:3025/ws";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var AiQaSdk = class {
+  constructor(applicationId, applicationSecret, url2) {
+    this.socket = null;
+    this.url = url2 ?? DEFAULT_URL;
+    this.internalListeners = /* @__PURE__ */ new Map();
+    this.internalEvents = /* @__PURE__ */ new Set(["authenticated"]);
+    if (applicationId && applicationSecret) {
+      this.applicationId = applicationId;
+      this.applicationSecretKey = applicationSecret;
+    } else {
+      throw new Error("Application id and application secret are required");
+    }
+  }
+  on(name, callback) {
+    if (this.internalEvents.has(name)) {
+      if (!this.internalListeners.has(name)) {
+        this.internalListeners.set(name, /* @__PURE__ */ new Set());
+      }
+      this.internalListeners.get(name).add(callback);
+      return;
+    }
+    if (!this.socket) {
+      throw new Error("Not connected");
+    }
+    if (this.isManagerEvent(name)) {
+      this.socket.io.on(name, callback);
+    } else {
+      this.socket.on(name, callback);
+    }
+  }
+  off(name, callback) {
+    if (this.internalEvents.has(name)) {
+      if (!callback) {
+        this.internalListeners.delete(name);
+        return;
+      }
+      const handlers = this.internalListeners.get(name);
+      if (handlers) {
+        handlers.delete(callback);
+        if (handlers.size === 0) {
+          this.internalListeners.delete(name);
+        }
+      }
+      return;
+    }
+    if (!this.socket) {
+      throw new Error("Not connected");
+    }
+    if (this.isManagerEvent(name)) {
+      this.socket.io.off(name, callback);
+    } else {
+      this.socket.off(name, callback);
+    }
+  }
+  connect() {
+    if (!this.url) {
+      return;
+    }
+    const url2 = new URL(this.url);
+    const socketOptions = {
+      reconnectionDelayMax: 1e4,
+      path: url2.pathname
+    };
+    this.socket = lookup2(url2.origin, socketOptions);
+    this.socket.on("connect", () => {
+      this.authenticate();
+    });
+    this.socket.on("app_version", (payload) => {
+      let versionRange = payload;
+      if (typeof payload === "string") {
+        try {
+          versionRange = JSON.parse(payload);
+        } catch (error) {
+          versionRange = payload;
+        }
+      }
+      const minVersion = versionRange?.min;
+      const maxVersion = versionRange?.max;
+      if (minVersion || maxVersion) {
+        const tooLow = minVersion ? this.compareVersions(SDK_VERSION, minVersion) < 0 : false;
+        const tooHigh = maxVersion ? this.compareVersions(SDK_VERSION, maxVersion) > 0 : false;
+        if (tooLow || tooHigh) {
+          const error = new Error(
+            `SDK version ${SDK_VERSION} is not supported. Supported range: ${minVersion || "-"} to ${maxVersion || "-"}.`
+          );
+          this.socket.disconnect();
+          this.socket.emit("error", error);
+        }
+      }
+    });
+  }
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+    }
+  }
+  sendMessage(method, data) {
+    return new Promise((resolve, reject) => {
+      if (!this.socket || !this.socket.connected) {
+        reject(new Error("Socket is not connected"));
+        return;
+      }
+      const requestId = this.createRequestId();
+      let timeout;
+      const handler = (payload2) => {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        this.socket.off(requestId, handler);
+        let parsed = payload2;
+        if (typeof payload2 === "string") {
+          try {
+            parsed = JSON.parse(payload2);
+          } catch (error) {
+            parsed = payload2;
+          }
+        }
+        if (parsed && parsed.error !== void 0) {
+          reject(parsed.error);
+          return;
+        }
+        resolve(parsed && parsed.data !== void 0 ? parsed.data : parsed);
+      };
+      this.socket.on(requestId, handler);
+      const payload = data && typeof data === "object" ? { ...data, requestId } : { requestId, data };
+      this.socket.emit(method, JSON.stringify(payload));
+      timeout = setTimeout(() => {
+        this.socket.off(requestId, handler);
+        reject(new Error(`Request timed out for ${method}`));
+      }, DEFAULT_TIMEOUT_MS);
+    });
+  }
+  async getApplication() {
+    if (this.cachedApplication) {
+      return this.cachedApplication;
+    }
+    throw new Error("Application is not available yet. Wait for authentication to complete.");
+  }
+  async getFacts() {
+    const result = await this.sendMessage("GET_FACTS" /* GET_FACTS */);
+    return result && result.data !== void 0 ? result.data : result;
+  }
+  async addFact(fact) {
+    const payload = {
+      ...fact,
+      critical: fact.critical ?? false,
+      is_skipped: fact.is_skipped ?? false
+    };
+    const result = await this.sendMessage("ADD_FACT" /* ADD_FACT */, payload);
+    return result && result.data !== void 0 ? result.data : result;
+  }
+  async authenticate() {
+    try {
+      const result = await this.sendMessage("AUTHENTICATE" /* AUTHENTICATE */, {
+        applicationId: this.applicationId,
+        applicationSecretKey: this.applicationSecretKey
+      });
+      const application = result && result.data !== void 0 ? result.data : result;
+      this.cachedApplication = application;
+      this.emitInternal("authenticated", application);
+    } catch (error) {
+      this.socket.emit("error", error);
+    }
+  }
+  async startRecording() {
+    const result = await this.sendMessage("START_RECORDING" /* START_RECORDING */);
+    return result && result.data !== void 0 ? result.data : result;
+  }
+  async stopRecording() {
+    const result = await this.sendMessage("STOP_RECORDING" /* STOP_RECORDING */);
+    return result && result.data !== void 0 ? result.data : result;
+  }
+  async isRecordingNow() {
+    const result = await this.sendMessage("IS_RECORDING" /* IS_RECORDING */);
+    return result && result.data !== void 0 ? result.data : result;
+  }
+  compareVersions(left, right) {
+    const leftParts = left.split(".").map((part) => Number(part));
+    const rightParts = right.split(".").map((part) => Number(part));
+    const maxLength = Math.max(leftParts.length, rightParts.length);
+    for (let i = 0; i < maxLength; i += 1) {
+      const l = leftParts[i] ?? 0;
+      const r = rightParts[i] ?? 0;
+      if (l > r) {
+        return 1;
+      }
+      if (l < r) {
+        return -1;
+      }
+    }
+    return 0;
+  }
+  emitInternal(name, ...args) {
+    const handlers = this.internalListeners.get(name);
+    if (!handlers) {
+      return;
+    }
+    handlers.forEach((handler) => handler(...args));
+  }
+  createRequestId() {
+    return `req_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+  }
+  isManagerEvent(name) {
+    return name === "reconnect_attempt" || name === "reconnect_error" || name === "reconnect_failed" || name === "error";
+  }
+};
+var shared_default = AiQaSdk;
+export {
+  shared_default as AiQaSdk,
+  FactAnswerFormatType,
+  IAiqaSdk,
+  Methods
+};
 //# sourceMappingURL=browser.js.map