@axiom-lattice/client-sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,648 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiError: () => ApiError,
+  AuthenticationError: () => AuthenticationError,
+  Client: () => Client,
+  NetworkError: () => NetworkError,
+  createSimpleMessageMerger: () => createSimpleMessageMerger
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types.ts
+var ApiError = class extends Error {
+  constructor(message, statusCode, responseBody) {
+    super(message);
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "ApiError";
+  }
+};
+var NetworkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+var AuthenticationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/client.ts
+var import_axios = __toESM(require("axios"));
+var Client = class {
+  /**
+   * Creates a new Client instance
+   * @param config - Configuration options for the client
+   */
+  constructor(config) {
+    this.tenantId = "";
+    this.registeredTools = /* @__PURE__ */ new Map();
+    /**
+     * Chat namespace for sending messages and streaming responses
+     */
+    this.chat = {
+      /**
+       * Sends a message to a thread and receives a response
+       * @param options - Options for sending a message
+       * @returns A promise that resolves to the chat response
+       */
+      send: async (options) => {
+        try {
+          const message = options.messages[options.messages.length - 1];
+          const result = await this.run({
+            threadId: options.threadId,
+            message: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+            streaming: false
+          });
+          return {
+            message: {
+              role: "ai",
+              content: result.output || "",
+              id: result.id || ""
+            },
+            traceId: result.id || ""
+          };
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Sends a message to a thread and streams the response
+       * @param options - Options for streaming a message
+       * @param onEvent - Callback function that receives stream events
+       * @param onComplete - Optional callback function called when streaming completes
+       * @param onError - Optional callback function called when an error occurs
+       * @returns A function that can be called to stop the stream
+       */
+      stream: (options, onEvent, onComplete, onError) => {
+        const message = options.messages[options.messages.length - 1];
+        return this.streamRun(
+          {
+            threadId: options.threadId,
+            message: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+            streaming: true,
+            background: options.background
+          },
+          onEvent,
+          onComplete,
+          onError
+        );
+      }
+    };
+    /**
+     * Tools namespace for registering and unregistering client-side tools
+     */
+    this.tools = {
+      /**
+       * Registers a client-side tool
+       * @param options - Options for registering a tool
+       */
+      register: (options) => {
+        if (this.config.transport !== "ws") {
+          throw new Error(
+            "Client-side tools are only supported with WebSocket transport"
+          );
+        }
+        this.registeredTools.set(options.name, options);
+      },
+      /**
+       * Unregisters a client-side tool
+       * @param name - Tool name
+       */
+      unregister: (name) => {
+        this.registeredTools.delete(name);
+      }
+    };
+    this.config = {
+      timeout: 3e4,
+      ...config
+    };
+    this.assistantId = config.assistantId;
+    this.client = import_axios.default.create({
+      baseURL: this.config.baseURL,
+      timeout: this.config.timeout,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.config.apiKey}`,
+        ...this.config.headers
+      }
+    });
+    this.setupInterceptors();
+  }
+  /**
+   * Sets up axios interceptors for error handling
+   * @private
+   */
+  setupInterceptors() {
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        if (error.response) {
+          if (error.response.status === 401) {
+            throw new AuthenticationError(
+              error.response.data.message || "Authentication failed"
+            );
+          } else {
+            throw new ApiError(
+              error.response.data.message || "API Error",
+              error.response.status,
+              error.response.data
+            );
+          }
+        } else if (error.request) {
+          throw new NetworkError("No response received from server");
+        } else {
+          throw new Error(`Request error: ${error.message}`);
+        }
+      }
+    );
+  }
+  /**
+   * Set tenant ID for multi-tenant environments
+   * @param tenantId - Tenant identifier
+   */
+  setTenantId(tenantId) {
+    this.tenantId = tenantId;
+    this.client.defaults.headers["x-tenant-id"] = tenantId;
+  }
+  /**
+   * Creates a new thread
+   * @param options - Options for creating a thread
+   * @returns A promise that resolves to the thread ID
+   */
+  async createThread(options) {
+    try {
+      const response = await this.client.post("/threads", {
+        ...options,
+        assistantId: this.assistantId
+      });
+      return response.data.id;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Retrieves thread information
+   * @param threadId - Thread identifier
+   * @returns A promise that resolves to the thread information
+   */
+  async getThread(threadId) {
+    try {
+      const response = await this.client.get(`/threads/${threadId}`, {
+        params: {
+          assistantId: this.assistantId
+        }
+      });
+      return response.data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Lists all threads
+   * @param options - Options for listing threads
+   * @returns A promise that resolves to an array of threads
+   */
+  async listThreads(options) {
+    try {
+      const response = await this.client.get("/threads", {
+        params: {
+          ...options,
+          assistantId: this.assistantId
+        }
+      });
+      return response.data.threads;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Deletes a thread
+   * @param threadId - Thread identifier
+   * @returns A promise that resolves when the thread is deleted
+   */
+  async deleteThread(threadId) {
+    try {
+      await this.client.delete(`/threads/${threadId}`, {
+        params: {
+          assistantId: this.assistantId
+        }
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Retrieves messages from a thread
+   * @param options - Options for retrieving messages
+   * @returns A promise that resolves to an array of messages
+   */
+  async getMessages(options) {
+    try {
+      const response = await this.client.get(
+        `/api/assistants/${this.assistantId}/${options.threadId}/memory`,
+        {
+          params: {
+            limit: options.limit,
+            after: options.after,
+            reverse: options.reverse,
+            assistantId: this.assistantId
+          }
+        }
+      );
+      return response.data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Retrieves agent state
+   * @param threadId - Thread identifier
+   * @returns A promise that resolves to the agent state
+   */
+  async getAgentState(threadId) {
+    try {
+      const response = await this.client.get(
+        `/api/assistants/${this.assistantId}/${threadId}/state`
+      );
+      return response.data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Gets agent graph visualization
+   * @returns A promise that resolves to the graph visualization data
+   */
+  async getAgentGraph() {
+    try {
+      const response = await this.client.get(
+        `/api/assistants/${this.assistantId}/graph`
+      );
+      return response.data.image;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Run agent with options
+   * @param options - Options for running the agent
+   * @returns A promise that resolves to the run result or a stream
+   */
+  async run(options) {
+    try {
+      const headers = {};
+      if (this.tenantId) {
+        headers["x-tenant-id"] = this.tenantId;
+      }
+      if (options.streaming) {
+        throw new Error(
+          "Streaming without callbacks is not supported. Use chat.stream with callbacks instead."
+        );
+      } else {
+        const response = await this.client.post(
+          "/api/runs",
+          {
+            assistant_id: this.assistantId,
+            thread_id: options.threadId,
+            message: options.message,
+            files: options.files,
+            command: options.command,
+            streaming: false,
+            background: options.background || false
+          },
+          { headers }
+        );
+        return response.data;
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Stream run results
+   * @param options - Options for streaming run results
+   * @param onEvent - Callback function that receives stream events
+   * @param onComplete - Optional callback function called when streaming completes
+   * @param onError - Optional callback function called when an error occurs
+   * @returns A function that can be called to stop the stream
+   */
+  streamRun(options, onEvent, onComplete, onError) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.tenantId) {
+      headers["x-tenant-id"] = this.tenantId;
+    }
+    const controller = new AbortController();
+    const signal = controller.signal;
+    (async () => {
+      try {
+        const response = await fetch(`${this.config.baseURL}/api/runs`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.config.apiKey}`,
+            ...headers
+          },
+          body: JSON.stringify({
+            assistant_id: this.assistantId,
+            thread_id: options.threadId,
+            message: options.message,
+            files: options.files,
+            command: options.command,
+            streaming: true,
+            background: options.background || false
+          }),
+          signal
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        if (!response.body) {
+          throw new Error("Response body is null");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            if (buffer.trim()) {
+              try {
+                const data = JSON.parse(buffer.trim());
+                onEvent(data);
+              } catch (error) {
+              }
+            }
+            break;
+          }
+          const chunk = decoder.decode(value, { stream: true });
+          buffer += chunk;
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.trim().startsWith("data: ")) {
+              try {
+                const data = JSON.parse(line.trim().slice(6));
+                onEvent(data);
+              } catch (error) {
+                if (onError) {
+                  onError(
+                    error instanceof Error ? error : new Error(String(error))
+                  );
+                }
+              }
+            }
+          }
+        }
+        if (onComplete) {
+          onComplete();
+        }
+      } catch (error) {
+        if (signal.aborted) {
+          return;
+        }
+        if (onError) {
+          onError(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    })();
+    return () => {
+      controller.abort();
+    };
+  }
+};
+
+// src/ChunkMessageMerger.ts
+function createSimpleMessageMerger() {
+  let messages = [];
+  const messageMap = /* @__PURE__ */ new Map();
+  const toolBuilders = /* @__PURE__ */ new Map();
+  function normalizeRole(type) {
+    switch (type) {
+      case "ai":
+        return "ai";
+      case "human":
+      case "user":
+        return "human";
+      case "system":
+        return "system";
+      case "tool":
+        return "tool";
+      case "developer":
+        return "developer";
+      default:
+        return "ai";
+    }
+  }
+  function safeJsonParse(str) {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  }
+  function ensureMessage(id, role) {
+    const index = messageMap.get(id);
+    if (index !== void 0) {
+      return messages[index];
+    }
+    let newMessage;
+    switch (role) {
+      case "human":
+        newMessage = { id, role: "human", content: "" };
+        break;
+      case "system":
+        newMessage = { id, role: "system", content: "" };
+        break;
+      case "tool":
+        newMessage = { id, role: "tool", content: "", tool_call_id: "" };
+        break;
+      case "developer":
+        newMessage = { id, role: "developer", content: "" };
+        break;
+      default:
+        newMessage = { id, role: "ai", content: "" };
+    }
+    messages.push(newMessage);
+    messageMap.set(id, messages.length - 1);
+    return newMessage;
+  }
+  function updateToolCalls(message) {
+    if (message.role !== "ai")
+      return;
+    const builders = toolBuilders.get(message.id);
+    if (!builders || builders.size === 0)
+      return;
+    const toolCalls = [];
+    for (const [index, builder] of Array.from(builders.entries())) {
+      if (builder.name && builder.id) {
+        const args = builder.args.trim();
+        const parsedArgs = safeJsonParse(args);
+        toolCalls.push({
+          id: builder.id,
+          name: builder.name,
+          args: typeof parsedArgs === "object" ? parsedArgs : { value: parsedArgs },
+          type: "tool_call"
+        });
+      }
+    }
+    if (toolCalls.length > 0) {
+      message.tool_calls = toolCalls;
+    }
+  }
+  function initialMessages(msgs) {
+    messages = msgs;
+  }
+  function push(chunk) {
+    const role = normalizeRole(chunk.type);
+    const message = ensureMessage(chunk.data.id, role);
+    if (chunk.data.content) {
+      message.content = (message.content || "") + chunk.data.content;
+    }
+    if (message.role === "tool" && chunk.data.tool_call_id) {
+      message.tool_call_id = chunk.data.tool_call_id;
+    }
+    if (chunk.data.tool_call_chunks && message.role === "ai") {
+      let builders = toolBuilders.get(message.id);
+      if (!builders) {
+        builders = /* @__PURE__ */ new Map();
+        toolBuilders.set(message.id, builders);
+      }
+      for (const chunk_item of chunk.data.tool_call_chunks) {
+        let builder = builders.get(chunk_item.index);
+        if (!builder) {
+          builder = { args: "" };
+          builders.set(chunk_item.index, builder);
+        }
+        if (chunk_item.name)
+          builder.name = chunk_item.name;
+        if (chunk_item.id)
+          builder.id = chunk_item.id;
+        if (chunk_item.args)
+          builder.args += chunk_item.args;
+      }
+      updateToolCalls(message);
+    }
+    if (chunk.data.tool_calls && message.role === "ai") {
+      const toolCalls = chunk.data.tool_calls.filter((tc) => tc.name && tc.id).map((tc) => ({
+        id: tc.id,
+        name: tc.name,
+        args: tc.args,
+        type: "tool_call",
+        response: tc.response
+      }));
+      if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+      }
+    }
+    if (chunk.data.additional_kwargs?.tool_calls && message.role === "ai" && !message.tool_calls) {
+      const toolCalls = [];
+      for (const tc of chunk.data.additional_kwargs.tool_calls) {
+        if (tc.function?.name && tc.id) {
+          const args = typeof tc.function.arguments === "string" ? safeJsonParse(tc.function.arguments) : tc.function.arguments || {};
+          toolCalls.push({
+            id: tc.id,
+            name: tc.function.name,
+            args,
+            type: "tool_call"
+          });
+        }
+      }
+      if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+      }
+    }
+  }
+  function getMessages() {
+    const toolResponsesMap = {};
+    messages.forEach((message) => {
+      if (message.role === "tool" && message.tool_call_id) {
+        toolResponsesMap[message.tool_call_id] = message;
+      }
+    });
+    return messages.filter((message) => {
+      return message.role !== "tool";
+    }).map((message) => {
+      if (message.role === "ai" && message.tool_calls) {
+        const mergedMessage = { ...message };
+        if (mergedMessage.tool_calls) {
+          mergedMessage.tool_calls = mergedMessage.tool_calls.map(
+            (toolCall) => {
+              const toolResponse = toolResponsesMap[toolCall.id];
+              if (toolResponse) {
+                return {
+                  ...toolCall,
+                  response: toolResponse.content
+                };
+              }
+              return toolCall;
+            }
+          );
+        }
+        return mergedMessage;
+      }
+      return message;
+    });
+  }
+  function getMessagesWithoutToolCalls() {
+    return messages.filter(
+      (message) => message.role !== "tool" && (message.role !== "ai" || !message.tool_calls)
+    );
+  }
+  function reset() {
+    messages.length = 0;
+    messageMap.clear();
+    toolBuilders.clear();
+  }
+  return {
+    push,
+    initialMessages,
+    getMessages,
+    getMessagesWithoutToolCalls,
+    reset
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  AuthenticationError,
+  Client,
+  NetworkError,
+  createSimpleMessageMerger
+});
+//# sourceMappingURL=index.js.map