@superatomai/sdk-web 0.0.13 → 0.0.14

package/dist/index.cjs

@@ -704,6 +704,82 @@ zod.z.object({
   to: MessageParticipantSchema.optional(),
   payload: BookmarksResponsePayloadSchema
 });
+var KbNodeDataSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  title: zod.z.string(),
+  content: zod.z.string(),
+  category: zod.z.string().nullable().optional(),
+  tags: zod.z.array(zod.z.string()).nullable().optional(),
+  createdBy: zod.z.number(),
+  updatedBy: zod.z.number().optional(),
+  createdAt: zod.z.string().optional(),
+  updatedAt: zod.z.string().optional()
+});
+var KbNodesQueryFiltersSchema = zod.z.object({
+  query: zod.z.string().optional(),
+  category: zod.z.string().optional(),
+  tags: zod.z.array(zod.z.string()).optional(),
+  createdBy: zod.z.number().optional()
+});
+var KbNodesRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "search", "getByCategory", "getByUser", "getCategories", "getTags"]),
+  data: zod.z.object({
+    id: zod.z.number().optional(),
+    title: zod.z.string().optional(),
+    content: zod.z.string().optional(),
+    category: zod.z.string().optional(),
+    tags: zod.z.array(zod.z.string()).optional(),
+    createdBy: zod.z.number().optional(),
+    updatedBy: zod.z.number().optional(),
+    userId: zod.z.number().optional(),
+    // Query/search operation fields
+    query: zod.z.string().optional(),
+    filters: KbNodesQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    offset: zod.z.number().optional()
+  }).optional()
+});
+var KbNodesRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("KB_NODES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: KbNodesRequestPayloadSchema
+});
+var KbNodesResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    // Single node operations
+    id: zod.z.number().optional(),
+    title: zod.z.string().optional(),
+    content: zod.z.string().optional(),
+    category: zod.z.string().nullable().optional(),
+    tags: zod.z.array(zod.z.string()).nullable().optional(),
+    createdBy: zod.z.number().optional(),
+    updatedBy: zod.z.number().optional(),
+    createdAt: zod.z.string().optional(),
+    updatedAt: zod.z.string().optional(),
+    message: zod.z.string().optional(),
+    // GetOne response
+    node: KbNodeDataSchema.optional(),
+    // List operations
+    nodes: zod.z.array(KbNodeDataSchema).optional(),
+    count: zod.z.number().optional(),
+    // getByCategory/getByUser
+    userId: zod.z.number().optional(),
+    // getCategories
+    categories: zod.z.array(zod.z.string()).optional()
+    // getTags
+  }).optional()
+});
+var KbNodesResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("KB_NODES_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: KbNodesResponsePayloadSchema
+});
 var ClientConfigSchema = zod.z.object({
   userId: zod.z.string(),
   projectId: zod.z.string(),
@@ -728,23 +804,31 @@ __export(services_exports, {
   UIElementSchema: () => UIElementSchema,
   createBookmark: () => createBookmark,
   createDashboard: () => createDashboard,
+  createKbNode: () => createKbNode,
   createReport: () => createReport,
   createUI: () => createUI,
   createUser: () => createUser,
   deleteBookmark: () => deleteBookmark,
   deleteDashboard: () => deleteDashboard,
+  deleteKbNode: () => deleteKbNode,
   deleteReport: () => deleteReport,
   deleteUI: () => deleteUI,
   deleteUser: () => deleteUser,
   getActions: () => getActions,
   getAllBookmarks: () => getAllBookmarks,
   getAllDashboards: () => getAllDashboards,
+  getAllKbNodes: () => getAllKbNodes,
   getAllReports: () => getAllReports,
   getAllUIs: () => getAllUIs,
   getAllUsers: () => getAllUsers,
   getBookmark: () => getBookmark,
   getComponentSuggestions: () => getComponentSuggestions,
   getDashboard: () => getDashboard,
+  getKbNode: () => getKbNode,
+  getKbNodeCategories: () => getKbNodeCategories,
+  getKbNodeTags: () => getKbNodeTags,
+  getKbNodesByCategory: () => getKbNodesByCategory,
+  getKbNodesByUser: () => getKbNodesByUser,
   getReport: () => getReport,
   getUI: () => getUI,
   getUser: () => getUser,
@@ -755,6 +839,7 @@ __export(services_exports, {
   queryUsers: () => queryUsers,
   requestBundle: () => requestBundle,
   requestData: () => requestData,
+  searchKbNodes: () => searchKbNodes,
   sendAuthLoginRequest: () => sendAuthLoginRequest,
   sendAuthVerifyRequest: () => sendAuthVerifyRequest,
   sendComponents: () => sendComponents,
@@ -762,6 +847,7 @@ __export(services_exports, {
   sendUserPromptSuggestionsRequest: () => sendUserPromptSuggestionsRequest,
   updateBookmark: () => updateBookmark,
   updateDashboard: () => updateDashboard,
+  updateKbNode: () => updateKbNode,
   updateReport: () => updateReport,
   updateUI: () => updateUI,
   updateUser: () => updateUser
@@ -1787,6 +1873,277 @@ async function queryUIs(client, options = {}, timeout) {
   };
 }
 
+// src/services/kb-nodes.ts
+async function createKbNode(client, title, content, createdBy, category, tags, timeout) {
+  const messageId = `kb_nodes_create_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        title,
+        content,
+        createdBy,
+        category,
+        tags
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    node: payload.data ? {
+      id: payload.data.id,
+      title: payload.data.title || title,
+      content: payload.data.content || content,
+      category: payload.data.category,
+      tags: payload.data.tags,
+      createdBy: payload.data.createdBy || createdBy,
+      updatedBy: payload.data.updatedBy,
+      createdAt: payload.data.createdAt,
+      updatedAt: payload.data.updatedAt
+    } : void 0
+  };
+}
+async function updateKbNode(client, id, updatedBy, updates, timeout) {
+  const messageId = `kb_nodes_update_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        id,
+        updatedBy,
+        ...updates
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    node: payload.data ? {
+      id: payload.data.id,
+      title: payload.data.title || "",
+      content: payload.data.content || "",
+      category: payload.data.category,
+      tags: payload.data.tags,
+      createdBy: payload.data.createdBy || 0,
+      updatedBy: payload.data.updatedBy,
+      createdAt: payload.data.createdAt,
+      updatedAt: payload.data.updatedAt
+    } : void 0
+  };
+}
+async function deleteKbNode(client, id, timeout) {
+  const messageId = `kb_nodes_delete_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "delete",
+      data: {
+        id
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message
+  };
+}
+async function getAllKbNodes(client, limit, offset, timeout) {
+  const messageId = `kb_nodes_getall_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll",
+      data: {
+        limit,
+        offset
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    nodes: payload.data?.nodes,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getKbNode(client, id, timeout) {
+  const messageId = `kb_nodes_getone_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getOne",
+      data: {
+        id
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    node: payload.data?.node,
+    message: payload.data?.message
+  };
+}
+async function searchKbNodes(client, options = {}, timeout) {
+  const { query, category, tags, createdBy, limit, offset } = options;
+  const messageId = `kb_nodes_search_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "search",
+      data: {
+        query,
+        category,
+        tags,
+        createdBy,
+        limit,
+        offset
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    nodes: payload.data?.nodes,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getKbNodesByCategory(client, category, limit, offset, timeout) {
+  const messageId = `kb_nodes_getbycategory_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getByCategory",
+      data: {
+        category,
+        limit,
+        offset
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    nodes: payload.data?.nodes,
+    count: payload.data?.count,
+    category: payload.data?.category || category,
+    message: payload.data?.message
+  };
+}
+async function getKbNodesByUser(client, userId, limit, offset, timeout) {
+  const messageId = `kb_nodes_getbyuser_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getByUser",
+      data: {
+        userId,
+        limit,
+        offset
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    nodes: payload.data?.nodes,
+    count: payload.data?.count,
+    userId: payload.data?.userId || userId,
+    message: payload.data?.message
+  };
+}
+async function getKbNodeCategories(client, timeout) {
+  const messageId = `kb_nodes_getcategories_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getCategories"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    categories: payload.data?.categories,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getKbNodeTags(client, timeout) {
+  const messageId = `kb_nodes_gettags_${Date.now()}`;
+  const message = KbNodesRequestMessageSchema.parse({
+    id: messageId,
+    type: "KB_NODES",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getTags"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  const responseData = payload.data;
+  return {
+    success: payload.success,
+    error: payload.error,
+    tags: responseData?.tags,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+
 // src/client.ts
 var SuperatomClient = class {
   constructor(config) {
@@ -2372,6 +2729,88 @@ var SuperatomClient = class {
     this.log("info", "Querying UIs with filters:", options?.filters);
     return queryUIs(this, options, timeout);
   }
+  // ==================== KB Nodes (Knowledge Base) Management Methods ====================
+  // These methods delegate to kb-nodes service for knowledge base CRUD operations
+  /**
+   * Create a new knowledge base node
+   * Delegates to kb-nodes service
+   */
+  async createKbNode(title, content, createdBy, category, tags, timeout) {
+    this.log("info", "Creating KB node:", title);
+    return createKbNode(this, title, content, createdBy, category, tags, timeout);
+  }
+  /**
+   * Update an existing knowledge base node
+   * Delegates to kb-nodes service
+   */
+  async updateKbNode(id, updatedBy, updates, timeout) {
+    this.log("info", "Updating KB node:", id);
+    return updateKbNode(this, id, updatedBy, updates, timeout);
+  }
+  /**
+   * Delete a knowledge base node
+   * Delegates to kb-nodes service
+   */
+  async deleteKbNode(id, timeout) {
+    this.log("info", "Deleting KB node:", id);
+    return deleteKbNode(this, id, timeout);
+  }
+  /**
+   * Get all knowledge base nodes
+   * Delegates to kb-nodes service
+   */
+  async getAllKbNodes(limit, offset, timeout) {
+    this.log("info", "Fetching all KB nodes");
+    return getAllKbNodes(this, limit, offset, timeout);
+  }
+  /**
+   * Get a specific knowledge base node by ID
+   * Delegates to kb-nodes service
+   */
+  async getKbNode(id, timeout) {
+    this.log("info", "Fetching KB node:", id);
+    return getKbNode(this, id, timeout);
+  }
+  /**
+   * Search knowledge base nodes with full-text search and filters
+   * Delegates to kb-nodes service
+   */
+  async searchKbNodes(options = {}, timeout) {
+    this.log("info", "Searching KB nodes with query:", options.query);
+    return searchKbNodes(this, options, timeout);
+  }
+  /**
+   * Get knowledge base nodes by category
+   * Delegates to kb-nodes service
+   */
+  async getKbNodesByCategory(category, limit, offset, timeout) {
+    this.log("info", "Fetching KB nodes by category:", category);
+    return getKbNodesByCategory(this, category, limit, offset, timeout);
+  }
+  /**
+   * Get knowledge base nodes by user (creator)
+   * Delegates to kb-nodes service
+   */
+  async getKbNodesByUser(userId, limit, offset, timeout) {
+    this.log("info", "Fetching KB nodes by user:", userId);
+    return getKbNodesByUser(this, userId, limit, offset, timeout);
+  }
+  /**
+   * Get all unique categories from knowledge base nodes
+   * Delegates to kb-nodes service
+   */
+  async getKbNodeCategories(timeout) {
+    this.log("info", "Fetching KB node categories");
+    return getKbNodeCategories(this, timeout);
+  }
+  /**
+   * Get all unique tags from knowledge base nodes
+   * Delegates to kb-nodes service
+   */
+  async getKbNodeTags(timeout) {
+    this.log("info", "Fetching KB node tags");
+    return getKbNodeTags(this, timeout);
+  }
   /**
    * Internal logging
    */
@@ -2443,6 +2882,12 @@ exports.DataRequestMessageSchema = DataRequestMessageSchema;
 exports.DataRequestPayloadSchema = DataRequestPayloadSchema;
 exports.DataResponseMessageSchema = DataResponseMessageSchema;
 exports.DataResponsePayloadSchema = DataResponsePayloadSchema;
+exports.KbNodeDataSchema = KbNodeDataSchema;
+exports.KbNodesQueryFiltersSchema = KbNodesQueryFiltersSchema;
+exports.KbNodesRequestMessageSchema = KbNodesRequestMessageSchema;
+exports.KbNodesRequestPayloadSchema = KbNodesRequestPayloadSchema;
+exports.KbNodesResponseMessageSchema = KbNodesResponseMessageSchema;
+exports.KbNodesResponsePayloadSchema = KbNodesResponsePayloadSchema;
 exports.MessageParticipantSchema = MessageParticipantSchema;
 exports.MessageSchema = MessageSchema;
 exports.SDK_VERSION = SDK_VERSION;