@useago/sdk 0.3.0 → 0.3.2

package/dist/AgoClient-B-SONi_K.js

@@ -1,861 +0,0 @@
-class AgoError extends Error {
-  constructor(message, code, statusCode) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "AgoError";
-  }
-}
-class AgoApiError extends AgoError {
-  constructor(message, code, statusCode, type, param, docUrl) {
-    super(message, code, statusCode);
-    this.type = type;
-    this.param = param;
-    this.docUrl = docUrl;
-    this.name = "AgoApiError";
-  }
-  static fromResponse(data, statusCode) {
-    const error = data.error;
-    return new AgoApiError(
-      error.message,
-      error.code,
-      statusCode,
-      error.type,
-      error.param,
-      error.doc_url
-    );
-  }
-}
-class AgoNetworkError extends AgoError {
-  constructor(message, originalError) {
-    super(message, "network_error");
-    this.originalError = originalError;
-    this.name = "AgoNetworkError";
-  }
-}
-class AgoStreamError extends AgoError {
-  constructor(message) {
-    super(message, "stream_error");
-    this.name = "AgoStreamError";
-  }
-}
-class AgoFunctionError extends AgoError {
-  constructor(message, functionName, originalError) {
-    super(message, "function_error");
-    this.functionName = functionName;
-    this.originalError = originalError;
-    this.name = "AgoFunctionError";
-  }
-}
-class Logger {
-  constructor(enabled = false) {
-    this.enabled = enabled;
-  }
-  enable() {
-    this.enabled = true;
-  }
-  disable() {
-    this.enabled = false;
-  }
-  log(...args) {
-    if (this.enabled) {
-      console.log("[AGO SDK]", ...args);
-    }
-  }
-  warn(...args) {
-    if (this.enabled) {
-      console.warn("[AGO SDK]", ...args);
-    }
-  }
-  error(...args) {
-    console.error("[AGO SDK]", ...args);
-  }
-  debug(...args) {
-    if (this.enabled) {
-      console.debug("[AGO SDK]", ...args);
-    }
-  }
-}
-const logger = new Logger();
-const WIDGET_ID_KEY = "ago_widget_id";
-function generateWidgetId() {
-  if (typeof localStorage !== "undefined") {
-    const stored = localStorage.getItem(WIDGET_ID_KEY);
-    if (stored) return stored;
-  }
-  const id = crypto.randomUUID();
-  if (typeof localStorage !== "undefined") {
-    try {
-      localStorage.setItem(WIDGET_ID_KEY, id);
-    } catch {
-    }
-  }
-  return id;
-}
-class HttpClient {
-  constructor(config) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.headers = {
-      "X-Widget-Id": config.widgetId || generateWidgetId()
-    };
-    if (config.userEmail) {
-      this.headers["X-User-Email"] = config.userEmail;
-    }
-    if (config.userJwt) {
-      this.headers["Authorization"] = `Bearer ${config.userJwt}`;
-    }
-  }
-  /**
-   * Update configuration (e.g., JWT token)
-   */
-  updateConfig(config) {
-    if (config.baseUrl) {
-      this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    }
-    if (config.widgetId) {
-      this.headers["X-Widget-Id"] = config.widgetId;
-    }
-    if (config.userEmail) {
-      this.headers["X-User-Email"] = config.userEmail;
-    }
-    if (config.userJwt) {
-      this.headers["Authorization"] = `Bearer ${config.userJwt}`;
-    }
-  }
-  /**
-   * Make a GET request
-   */
-  async get(path) {
-    return this.request("GET", path);
-  }
-  /**
-   * Make a POST request with JSON body
-   */
-  async post(path, body) {
-    return this.request("POST", path, body);
-  }
-  /**
-   * Make a POST request and return the raw Response (for streaming)
-   */
-  async postStream(path, body) {
-    const url = `${this.baseUrl}${path}`;
-    logger.debug("POST (stream)", url, body);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          ...this.headers,
-          "Content-Type": "application/json"
-        },
-        body: body ? JSON.stringify(body) : void 0
-      });
-      if (!response.ok) {
-        await this.handleErrorResponse(response);
-      }
-      return response;
-    } catch (error) {
-      if (error instanceof AgoApiError) {
-        throw error;
-      }
-      throw new AgoNetworkError(
-        `Network error: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-  /**
-   * Make a POST request with FormData (for file uploads)
-   */
-  async postFormData(path, formData) {
-    const url = `${this.baseUrl}${path}`;
-    logger.debug("POST (formData)", url);
-    const headers = { ...this.headers };
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers,
-        body: formData
-      });
-      if (!response.ok) {
-        await this.handleErrorResponse(response);
-      }
-      return response;
-    } catch (error) {
-      if (error instanceof AgoApiError) {
-        throw error;
-      }
-      throw new AgoNetworkError(
-        `Network error: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-  async request(method, path, body) {
-    const url = `${this.baseUrl}${path}`;
-    logger.debug(method, url, body);
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: {
-          ...this.headers,
-          "Content-Type": "application/json"
-        },
-        body: body ? JSON.stringify(body) : void 0
-      });
-      if (!response.ok) {
-        await this.handleErrorResponse(response);
-      }
-      if (response.status === 204) {
-        return void 0;
-      }
-      return response.json();
-    } catch (error) {
-      if (error instanceof AgoApiError) {
-        throw error;
-      }
-      throw new AgoNetworkError(
-        `Network error: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-  async handleErrorResponse(response) {
-    let errorData;
-    try {
-      errorData = await response.json();
-    } catch {
-    }
-    if (errorData == null ? void 0 : errorData.error) {
-      throw AgoApiError.fromResponse(errorData, response.status);
-    }
-    throw new AgoApiError(
-      `HTTP ${response.status}: ${response.statusText}`,
-      "http_error",
-      response.status,
-      "api_error"
-    );
-  }
-}
-class FunctionRegistry {
-  constructor() {
-    this.functions = /* @__PURE__ */ new Map();
-  }
-  register(nameOrDef, handler, schema) {
-    if (typeof nameOrDef === "object") {
-      const { name: name2, handler: h, description, parameters } = nameOrDef;
-      return this.register(name2, h, { description, parameters });
-    }
-    const name = nameOrDef;
-    if (!handler || !schema) {
-      throw new Error("handler and schema are required");
-    }
-    if (this.functions.has(name)) {
-      logger.warn(`Function "${name}" is being overwritten`);
-    }
-    this.functions.set(name, {
-      schema: { ...schema, name },
-      handler
-    });
-    logger.log(`Registered function: ${name}`);
-  }
-  /**
-   * Unregister a function
-   */
-  unregister(name) {
-    const deleted = this.functions.delete(name);
-    if (deleted) {
-      logger.log(`Unregistered function: ${name}`);
-    }
-    return deleted;
-  }
-  /**
-   * Get a registered function
-   */
-  get(name) {
-    return this.functions.get(name);
-  }
-  /**
-   * Check if a function is registered
-   */
-  has(name) {
-    return this.functions.has(name);
-  }
-  /**
-   * Get all registered function schemas (for sending to backend)
-   */
-  getSchemas() {
-    return Array.from(this.functions.values()).map((f) => f.schema);
-  }
-  /**
-   * Execute a registered function
-   */
-  async execute(name, args) {
-    const registration = this.functions.get(name);
-    if (!registration) {
-      throw new AgoFunctionError(
-        `Function "${name}" is not registered`,
-        name
-      );
-    }
-    logger.log(`Executing function: ${name}`, args);
-    try {
-      const result = await registration.handler(args);
-      logger.log(`Function ${name} completed:`, result);
-      return result;
-    } catch (error) {
-      logger.error(`Function ${name} failed:`, error);
-      throw new AgoFunctionError(
-        `Function "${name}" execution failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-        name,
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-  /**
-   * Clear all registered functions
-   */
-  clear() {
-    this.functions.clear();
-    logger.log("Cleared all registered functions");
-  }
-  /**
-   * Get the number of registered functions
-   */
-  get size() {
-    return this.functions.size;
-  }
-}
-class SSEHandler {
-  constructor(callbacks) {
-    this.callbacks = callbacks;
-    this.buffer = "";
-    this.message = {};
-    this.toolCalls = [];
-    this.sources = [];
-    this.followUpReplies = [];
-    this.isFirstChunk = true;
-  }
-  /**
-   * Process a streaming response
-   */
-  async processStream(response) {
-    var _a, _b;
-    if (!response.body) {
-      throw new AgoStreamError("Response has no body");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        const text = decoder.decode(value, { stream: true });
-        this.buffer += text;
-        this.processBuffer();
-      }
-      if (this.buffer.trim()) {
-        this.processBuffer();
-      }
-      return this.buildFinalMessage();
-    } catch (error) {
-      const streamError = error instanceof Error ? error : new AgoStreamError("Stream processing failed");
-      (_b = (_a = this.callbacks).onError) == null ? void 0 : _b.call(_a, streamError);
-      throw streamError;
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  processBuffer() {
-    const parts = this.buffer.split("\n\n");
-    this.buffer = parts.pop() || "";
-    for (const part of parts) {
-      if (!part.trim()) continue;
-      const lines = part.split("\n");
-      for (const line of lines) {
-        if (line.startsWith(": ")) {
-          continue;
-        }
-        if (line.startsWith("data: ")) {
-          const jsonStr = line.slice(6);
-          try {
-            const data = JSON.parse(jsonStr);
-            this.handleChunk(data);
-          } catch (error) {
-            logger.warn("Failed to parse SSE data:", jsonStr, error);
-          }
-        }
-      }
-    }
-  }
-  handleChunk(data) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-    if (data.message_id && !this.message.id) {
-      this.message.id = data.message_id;
-    }
-    if ((_a = data.thread) == null ? void 0 : _a.id) {
-      this.message.conversationId = data.thread.id;
-      if (this.isFirstChunk && this.message.id) {
-        this.isFirstChunk = false;
-        (_c = (_b = this.callbacks).onStart) == null ? void 0 : _c.call(_b, {
-          conversationId: this.message.conversationId,
-          messageId: this.message.id
-        });
-      }
-    }
-    if (data.content !== void 0) {
-      this.message.content = (this.message.content || "") + data.content;
-      if (this.message.conversationId && this.message.id) {
-        (_e = (_d = this.callbacks).onChunk) == null ? void 0 : _e.call(_d, {
-          content: data.content,
-          conversationId: this.message.conversationId,
-          messageId: this.message.id
-        });
-      }
-    }
-    if (data.full_content !== void 0) {
-      this.message.content = data.full_content;
-    }
-    if (data.status) {
-      this.message.status = data.status;
-    }
-    if (data.agent) {
-      this.message.agent = {
-        id: data.agent.id,
-        name: data.agent.name,
-        displayName: data.agent.display_name
-      };
-    }
-    if (data.knowledge_sources) {
-      this.sources = data.knowledge_sources.map((s) => {
-        const doc = s.knowledge_document;
-        return {
-          id: doc.id,
-          title: doc.title,
-          url: doc.use_external_link ? doc.external_link_url : doc.internal_link_url
-        };
-      });
-    }
-    if (data.type === "client_function" && data.function_name) {
-      (_g = (_f = this.callbacks).onClientFunction) == null ? void 0 : _g.call(_f, {
-        invocationId: data.id || "",
-        functionName: data.function_name,
-        arguments: data.arguments || {},
-        conversationId: this.message.conversationId || ""
-      });
-    }
-    if (data.tool_call_data && data.type && data.type !== "client_function") {
-      const toolCall = this.parseToolCall(data);
-      (_i = (_h = this.callbacks).onToolCall) == null ? void 0 : _i.call(_h, toolCall);
-      const existingIndex = this.toolCalls.findIndex((t) => t.id === toolCall.id);
-      if (existingIndex >= 0) {
-        this.toolCalls[existingIndex] = toolCall;
-      } else {
-        this.toolCalls.push(toolCall);
-      }
-    }
-    if (data.follow_up_replies) {
-      this.followUpReplies = data.follow_up_replies;
-    }
-  }
-  parseToolCall(data) {
-    return {
-      id: data.id || "",
-      type: data.type || "status_message",
-      status: data.status || "unknown",
-      toolName: data.tool_name || "",
-      toolDisplayName: data.tool_display_name,
-      message: data.message,
-      formSchema: data.form_schema,
-      data: data.data,
-      functionName: data.function_name,
-      arguments: data.arguments
-    };
-  }
-  buildFinalMessage() {
-    var _a, _b;
-    const message = {
-      id: this.message.id || "",
-      conversationId: this.message.conversationId || "",
-      content: this.message.content || "",
-      role: "assistant",
-      status: this.message.status || "DONE",
-      agent: this.message.agent,
-      sources: this.sources.length > 0 ? this.sources : void 0,
-      toolCalls: this.toolCalls.length > 0 ? this.toolCalls : void 0,
-      followUpReplies: this.followUpReplies.length > 0 ? this.followUpReplies : void 0,
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    (_b = (_a = this.callbacks).onComplete) == null ? void 0 : _b.call(_a, message);
-    return message;
-  }
-}
-function isStreamNetworkError(error) {
-  const message = error.message.toLowerCase();
-  return message.includes("load failed") || message.includes("failed to fetch") || message.includes("network") || message.includes("abort");
-}
-class EventEmitter {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
-  }
-  on(event, handler) {
-    if (!this.handlers.has(event)) {
-      this.handlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.handlers.get(event).add(handler);
-  }
-  off(event, handler) {
-    const eventHandlers = this.handlers.get(event);
-    if (eventHandlers) {
-      eventHandlers.delete(handler);
-    }
-  }
-  emit(event, data) {
-    const eventHandlers = this.handlers.get(event);
-    if (eventHandlers) {
-      eventHandlers.forEach((handler) => {
-        try {
-          handler(data);
-        } catch (error) {
-          console.error(`Error in event handler for ${String(event)}:`, error);
-        }
-      });
-    }
-  }
-  /**
-   * Subscribe to an event and auto-unsubscribe after the first call.
-   */
-  once(event, handler) {
-    const wrapper = (data) => {
-      this.off(event, wrapper);
-      handler(data);
-    };
-    this.on(event, wrapper);
-  }
-  /**
-   * Returns a Promise that resolves the next time `event` fires.
-   * Rejects if `timeout` (ms) is reached first.
-   */
-  waitFor(event, options) {
-    return new Promise((resolve, reject) => {
-      let timer;
-      const handler = (data) => {
-        if (timer) clearTimeout(timer);
-        resolve(data);
-      };
-      this.once(event, handler);
-      if (options == null ? void 0 : options.timeout) {
-        timer = setTimeout(() => {
-          this.off(event, handler);
-          reject(new Error(`waitFor("${String(event)}") timed out after ${options.timeout}ms`));
-        }, options.timeout);
-      }
-    });
-  }
-  removeAllListeners(event) {
-    if (event) {
-      this.handlers.delete(event);
-    } else {
-      this.handlers.clear();
-    }
-  }
-}
-class AgoClient {
-  constructor(config) {
-    this.config = config;
-    this.httpClient = new HttpClient(config);
-    this.functionRegistry = new FunctionRegistry();
-    this.eventEmitter = new EventEmitter();
-    if (config.debug) {
-      logger.enable();
-    }
-    logger.log("AgoClient initialized");
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // Messaging
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Send a message and receive a streaming response
-   */
-  async sendMessage(content, options) {
-    const clientFunctions = this.functionRegistry.getSchemas();
-    const body = {
-      content,
-      conversation_id: options == null ? void 0 : options.conversationId,
-      agent_id: (options == null ? void 0 : options.agentId) || this.config.defaultAgentId
-    };
-    if (clientFunctions.length > 0) {
-      body.client_functions = clientFunctions;
-    }
-    let response;
-    if ((options == null ? void 0 : options.files) && options.files.length > 0) {
-      const formData = new FormData();
-      formData.append("content", content);
-      if (options.conversationId) {
-        formData.append("conversation_id", options.conversationId);
-      }
-      if (options.agentId || this.config.defaultAgentId) {
-        formData.append("agent_id", options.agentId || this.config.defaultAgentId || "");
-      }
-      if (clientFunctions.length > 0) {
-        formData.append("client_functions", JSON.stringify(clientFunctions));
-      }
-      for (const file of options.files) {
-        formData.append("files", file);
-      }
-      response = await this.httpClient.postFormData("/api/sdk/v1/messages", formData);
-    } else {
-      response = await this.httpClient.postStream("/api/sdk/v1/messages", body);
-    }
-    return this.processSSEResponse(response);
-  }
-  async processSSEResponse(response) {
-    const handler = new SSEHandler({
-      onStart: (data) => {
-        this.eventEmitter.emit("message:start", data);
-      },
-      onChunk: (data) => {
-        this.eventEmitter.emit("message:chunk", data);
-      },
-      onToolCall: (toolCall) => {
-        this.eventEmitter.emit("toolCall:received", toolCall);
-        if (toolCall.type === "form") {
-          this.eventEmitter.emit("toolCall:form", toolCall);
-        }
-      },
-      onClientFunction: async (data) => {
-        this.eventEmitter.emit("function:invoke", data);
-        await this.handleClientFunctionInvocation(data);
-      },
-      onComplete: (message) => {
-        this.eventEmitter.emit("message:complete", message);
-      },
-      onError: (error) => {
-        this.eventEmitter.emit("message:error", { error: error.message });
-      }
-    });
-    return handler.processStream(response);
-  }
-  async handleClientFunctionInvocation(data) {
-    let result;
-    let error;
-    try {
-      result = await this.functionRegistry.execute(data.functionName, data.arguments);
-    } catch (err) {
-      error = err instanceof Error ? err.message : "Unknown error";
-      logger.error("Client function execution failed:", err);
-    }
-    if (data.invocationId) {
-      try {
-        await this.submitToolCallForm(data.invocationId, {
-          result,
-          error,
-          _type: "client_function_result"
-        });
-      } catch (submitError) {
-        logger.error("Failed to submit function result:", submitError);
-      }
-    }
-    this.eventEmitter.emit("function:result", {
-      invocationId: data.invocationId,
-      result,
-      error
-    });
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // Conversations
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Get list of conversations
-   */
-  async getConversations() {
-    const response = await this.httpClient.get("/api/sdk/v1/conversations");
-    return response.items.map((item) => ({
-      id: item.id,
-      title: item.title,
-      lastMessageDate: new Date(item.last_message_date)
-    }));
-  }
-  /**
-   * Get a specific conversation with messages
-   */
-  async getConversation(conversationId) {
-    const response = await this.httpClient.get(`/api/sdk/v1/conversations/${conversationId}`);
-    return {
-      id: response.id,
-      title: response.title,
-      lastMessageDate: new Date(response.last_message_date),
-      messages: response.messages.map((m) => ({
-        id: m.id,
-        conversationId: response.id,
-        content: m.content,
-        role: m.role,
-        status: m.status,
-        createdAt: new Date(m.created_at)
-      }))
-    };
-  }
-  /**
-   * Get messages for a conversation
-   */
-  async getMessages(conversationId) {
-    const conversation = await this.getConversation(conversationId);
-    return conversation.messages || [];
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // Tool Calls
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Submit form data for a tool call
-   */
-  async submitToolCallForm(toolCallId, formData) {
-    await this.httpClient.post(`/api/tool-calls/${toolCallId}/submit/`, {
-      formData
-    });
-  }
-  /**
-   * Confirm a tool call
-   */
-  async confirmToolCall(toolCallId) {
-    await this.httpClient.post(`/api/tool-calls/${toolCallId}/confirm/`);
-  }
-  /**
-   * Reject a tool call
-   */
-  async rejectToolCall(toolCallId) {
-    await this.httpClient.post(`/api/tool-calls/${toolCallId}/reject/`);
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // Feedback
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Submit feedback for a message
-   */
-  async submitFeedback(messageId, rating) {
-    await this.httpClient.post(`/api/sdk/v1/messages/${messageId}/feedback`, {
-      rating
-    });
-  }
-  registerFunction(nameOrDef, handler, schema) {
-    if (typeof nameOrDef === "object") {
-      this.functionRegistry.register(nameOrDef);
-    } else {
-      this.functionRegistry.register(nameOrDef, handler, schema);
-    }
-  }
-  /**
-   * Unregister a client-side function
-   */
-  unregisterFunction(name) {
-    return this.functionRegistry.unregister(name);
-  }
-  /**
-   * Get all registered function schemas
-   */
-  getRegisteredFunctions() {
-    return this.functionRegistry.getSchemas();
-  }
-  /**
-   * Register a navigation function that lets AGO navigate users to different pages.
-   * @param navigate - A callback that performs the navigation (e.g. react-router's navigate)
-   * @param routes - Map of route names to paths, with descriptions for the LLM
-   */
-  registerNavigationFunction(navigate, routes) {
-    const routeNames = routes.map((r) => r.name);
-    const routeDescriptions = routes.map((r) => `- "${r.name}": ${r.description}`).join("\n");
-    this.registerFunction(
-      "navigateToPage",
-      async (args) => {
-        const pageName = args.page;
-        const route = routes.find((r) => r.name === pageName);
-        if (!route) {
-          return { success: false, error: `Unknown page: ${pageName}` };
-        }
-        navigate(route.path);
-        return { success: true, navigatedTo: route.path };
-      },
-      {
-        description: `Navigate the user to a page in the application. Available pages:
-${routeDescriptions}`,
-        parameters: {
-          type: "object",
-          properties: {
-            page: {
-              type: "string",
-              description: "The page to navigate to",
-              enum: routeNames
-            }
-          },
-          required: ["page"]
-        }
-      }
-    );
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // Events
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Subscribe to an event
-   */
-  on(event, handler) {
-    this.eventEmitter.on(event, handler);
-  }
-  /**
-   * Unsubscribe from an event
-   */
-  off(event, handler) {
-    this.eventEmitter.off(event, handler);
-  }
-  /**
-   * Subscribe to an event once — auto-unsubscribes after the first call.
-   */
-  once(event, handler) {
-    this.eventEmitter.once(event, handler);
-  }
-  /**
-   * Returns a Promise that resolves the next time `event` fires.
-   *
-   * ```ts
-   * const msg = await client.waitFor("message:complete", { timeout: 10000 });
-   * ```
-   */
-  waitFor(event, options) {
-    return this.eventEmitter.waitFor(event, options);
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // Configuration
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Update client configuration
-   */
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
-    this.httpClient.updateConfig(config);
-    if (config.debug !== void 0) {
-      config.debug ? logger.enable() : logger.disable();
-    }
-  }
-  /**
-   * Clean up resources
-   */
-  destroy() {
-    this.eventEmitter.removeAllListeners();
-    this.functionRegistry.clear();
-    logger.log("AgoClient destroyed");
-  }
-}
-export {
-  AgoClient as A,
-  EventEmitter as E,
-  FunctionRegistry as F,
-  SSEHandler as S,
-  AgoApiError as a,
-  AgoError as b,
-  AgoFunctionError as c,
-  AgoNetworkError as d,
-  AgoStreamError as e,
-  isStreamNetworkError as i,
-  logger as l
-};
-//# sourceMappingURL=AgoClient-B-SONi_K.js.map