@superatomai/sdk-web 0.0.1-mds

package/dist/index.cjs

@@ -0,0 +1,3904 @@
+'use strict';
+
+var zod = require('zod');
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var ExpressionSchema = zod.z.object({
+  $exp: zod.z.string(),
+  $deps: zod.z.array(zod.z.string()).optional()
+});
+var BindingSchema = zod.z.object({
+  $bind: zod.z.string(),
+  $transform: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      args: zod.z.array(zod.z.any()).optional()
+    })
+  ).optional()
+});
+var ForDirectiveSchema = zod.z.object({
+  in: zod.z.union([ExpressionSchema, BindingSchema, zod.z.string()]),
+  as: zod.z.string(),
+  key: zod.z.string().optional(),
+  index: zod.z.string().optional()
+});
+var QuerySpecSchema = zod.z.object({
+  graphql: zod.z.string().optional(),
+  sql: zod.z.string().optional(),
+  variables: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  params: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  key: zod.z.string().optional(),
+  refetchPolicy: zod.z.enum(["cache-first", "network-only", "cache-and-network"]).optional(),
+  dependencies: zod.z.array(zod.z.string()).optional()
+});
+var UIElementSchema = zod.z.lazy(
+  () => zod.z.object({
+    id: zod.z.string(),
+    type: zod.z.string(),
+    key: zod.z.union([zod.z.string(), ExpressionSchema]).optional(),
+    props: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    query: QuerySpecSchema.optional(),
+    if: ExpressionSchema.optional(),
+    elseIf: ExpressionSchema.optional(),
+    for: ForDirectiveSchema.optional(),
+    "link-to": zod.z.union([
+      zod.z.string(),
+      ExpressionSchema,
+      BindingSchema,
+      zod.z.object({
+        ui: zod.z.union([zod.z.string(), ExpressionSchema, BindingSchema]),
+        params: zod.z.record(zod.z.string(), zod.z.any()).optional()
+      })
+    ]).optional(),
+    _meta: zod.z.object({
+      id: zod.z.string().optional(),
+      version: zod.z.string().optional(),
+      created: zod.z.string().optional(),
+      lastModified: zod.z.string().optional()
+    }).optional(),
+    children: zod.z.any().optional(),
+    else: UIElementSchema.optional(),
+    slots: zod.z.record(zod.z.string(), zod.z.union([UIElementSchema, zod.z.array(UIElementSchema)])).optional(),
+    platform: zod.z.object({
+      web: zod.z.any().optional(),
+      ios: zod.z.any().optional(),
+      android: zod.z.any().optional()
+    }).optional()
+  })
+);
+var PageSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  order: zod.z.number(),
+  icon: zod.z.string().optional(),
+  render: UIElementSchema
+});
+var UIComponentSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string().optional(),
+  props: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  states: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  methods: zod.z.record(
+    zod.z.string(),
+    zod.z.object({
+      fn: zod.z.string(),
+      params: zod.z.record(zod.z.string(), zod.z.any()).optional()
+    })
+  ).optional(),
+  effects: zod.z.array(
+    zod.z.object({
+      fn: zod.z.string(),
+      deps: zod.z.array(zod.z.string()).optional()
+    })
+  ).optional(),
+  data: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  // OLD: Single page (optional for backward compatibility)
+  render: UIElementSchema.optional(),
+  // NEW: Multi-page support
+  pages: zod.z.array(PageSchema).optional(),
+  defaultPageId: zod.z.string().optional(),
+  query: QuerySpecSchema.optional()
+});
+var DSLRendererPropsSchema = zod.z.object({
+  dsl: UIComponentSchema,
+  data: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  context: zod.z.record(zod.z.string(), zod.z.any()).optional()
+});
+var ExpressionSchema2 = zod.z.object({
+  $exp: zod.z.string(),
+  $deps: zod.z.array(zod.z.string()).optional()
+});
+var BindingSchema2 = zod.z.object({
+  $bind: zod.z.string(),
+  $transform: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      args: zod.z.array(zod.z.any()).optional()
+    })
+  ).optional()
+});
+var ForDirectiveSchema2 = zod.z.object({
+  in: zod.z.union([ExpressionSchema2, BindingSchema2, zod.z.string()]),
+  as: zod.z.string(),
+  key: zod.z.string().optional(),
+  index: zod.z.string().optional()
+});
+var QuerySpecSchema2 = zod.z.object({
+  graphql: zod.z.string().optional(),
+  sql: zod.z.string().optional(),
+  variables: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  params: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  key: zod.z.string().optional(),
+  refetchPolicy: zod.z.enum(["cache-first", "network-only", "cache-and-network"]).optional(),
+  dependencies: zod.z.array(zod.z.string()).optional()
+});
+var UIElementSchema2 = zod.z.lazy(
+  () => zod.z.object({
+    id: zod.z.string(),
+    type: zod.z.string(),
+    key: zod.z.union([zod.z.string(), ExpressionSchema2]).optional(),
+    props: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    query: QuerySpecSchema2.optional(),
+    if: ExpressionSchema2.optional(),
+    elseIf: ExpressionSchema2.optional(),
+    for: ForDirectiveSchema2.optional(),
+    "link-to": zod.z.union([
+      zod.z.string(),
+      ExpressionSchema2,
+      BindingSchema2,
+      zod.z.object({
+        ui: zod.z.union([zod.z.string(), ExpressionSchema2, BindingSchema2]),
+        params: zod.z.record(zod.z.string(), zod.z.any()).optional()
+      })
+    ]).optional(),
+    _meta: zod.z.object({
+      id: zod.z.string().optional(),
+      version: zod.z.string().optional(),
+      created: zod.z.string().optional(),
+      lastModified: zod.z.string().optional()
+    }).optional(),
+    children: zod.z.any().optional(),
+    else: UIElementSchema2.optional(),
+    slots: zod.z.record(zod.z.string(), zod.z.union([UIElementSchema2, zod.z.array(UIElementSchema2)])).optional(),
+    platform: zod.z.object({
+      web: zod.z.any().optional(),
+      ios: zod.z.any().optional(),
+      android: zod.z.any().optional()
+    }).optional()
+  })
+);
+var UIComponentSchema2 = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string().optional(),
+  props: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  states: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  methods: zod.z.record(
+    zod.z.string(),
+    zod.z.object({
+      fn: zod.z.string(),
+      params: zod.z.record(zod.z.string(), zod.z.any()).optional()
+    })
+  ).optional(),
+  effects: zod.z.array(
+    zod.z.object({
+      fn: zod.z.string(),
+      deps: zod.z.array(zod.z.string()).optional()
+    })
+  ).optional(),
+  data: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  // Made optional to align with dashboards schema (dashboards use pages instead)
+  render: UIElementSchema2.optional(),
+  query: QuerySpecSchema2.optional()
+});
+var DSLRendererPropsSchema2 = zod.z.object({
+  dsl: UIComponentSchema2,
+  data: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  context: zod.z.record(zod.z.string(), zod.z.any()).optional()
+});
+
+// src/types.ts
+var MessageParticipantSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  type: zod.z.string().optional()
+});
+var MessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.string(),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: zod.z.unknown()
+});
+var AuthLoginPayloadSchema = zod.z.object({
+  login_data: zod.z.string()
+  // Base64 encoded login data (username + SHA-1 hashed password)
+});
+var AuthLoginRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("AUTH_LOGIN_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthLoginPayloadSchema
+});
+var AuthLoginResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.unknown().optional()
+  // User ID or additional auth data
+});
+var AuthLoginResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("AUTH_LOGIN_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthLoginResponsePayloadSchema
+});
+var AuthVerifyPayloadSchema = zod.z.object({
+  token: zod.z.string()
+  // Base64 encoded authentication token
+});
+var AuthVerifyRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("AUTH_VERIFY_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthVerifyPayloadSchema
+});
+var AuthVerifyResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.unknown().optional()
+});
+var AuthVerifyResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("AUTH_VERIFY_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthVerifyResponsePayloadSchema
+});
+var UserPromptRequestPayloadSchema = zod.z.object({
+  prompt: zod.z.string(),
+  userId: zod.z.string().optional(),
+  SA_RUNTIME: zod.z.object({
+    threadId: zod.z.string(),
+    uiBlockId: zod.z.string()
+  }).optional(),
+  responseMode: zod.z.enum(["component", "text"]).optional()
+});
+var UserPromptRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USER_PROMPT_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptRequestPayloadSchema
+});
+var ComponentPropsSchema = zod.z.object({
+  query: zod.z.string().or(zod.z.record(zod.z.string(), zod.z.unknown())).nullable().optional(),
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+}).passthrough();
+var ComponentSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  type: zod.z.string(),
+  description: zod.z.string(),
+  props: ComponentPropsSchema,
+  category: zod.z.string().optional(),
+  keywords: zod.z.array(zod.z.string()).optional()
+});
+var UserPromptResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    component: ComponentSchema.optional()
+  }).optional(),
+  uiBlockId: zod.z.string().optional(),
+  threadId: zod.z.string().optional()
+});
+var UserPromptResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USER_PROMPT_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptResponsePayloadSchema
+});
+var UserPromptSuggestionsRequestPayloadSchema = zod.z.object({
+  prompt: zod.z.string(),
+  userId: zod.z.string().optional(),
+  limit: zod.z.number().int().positive().default(5)
+});
+var UserPromptSuggestionsRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USER_PROMPT_SUGGESTIONS_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptSuggestionsRequestPayloadSchema
+});
+var UserPromptSuggestionsResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    prompt: zod.z.string(),
+    suggestions: zod.z.array(ComponentSchema),
+    count: zod.z.number(),
+    message: zod.z.string().optional()
+  }).optional()
+});
+var UserPromptSuggestionsResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USER_PROMPT_SUGGESTIONS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptSuggestionsResponsePayloadSchema
+});
+var DashCompRequestPayloadSchema = zod.z.object({
+  prompt: zod.z.string(),
+  userId: zod.z.string().optional(),
+  SA_RUNTIME: zod.z.object({
+    threadId: zod.z.string().optional(),
+    uiBlockId: zod.z.string().optional()
+  }).optional(),
+  existingComponents: zod.z.array(ComponentSchema).optional(),
+  req_type: zod.z.enum(["create", "update", "filter"]).optional()
+});
+var DashCompRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DASH_COMP_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DashCompRequestPayloadSchema
+});
+zod.z.object({
+  toolId: zod.z.string(),
+  toolName: zod.z.string(),
+  action: zod.z.enum(["get", "create", "update", "delete"]),
+  params: zod.z.record(zod.z.string(), zod.z.unknown())
+});
+zod.z.object({
+  filterId: zod.z.string(),
+  filterField: zod.z.string(),
+  targetComponentId: zod.z.string(),
+  targetField: zod.z.string()
+});
+var DashCompResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  errors: zod.z.array(zod.z.string()).optional(),
+  data: zod.z.object({
+    // For create/update requests
+    component: ComponentSchema.optional(),
+    reasoning: zod.z.string().optional(),
+    dataSource: zod.z.enum(["database", "external_tool", "none"]).optional(),
+    // For filter requests
+    filterComponent: ComponentSchema.optional(),
+    updatedComponents: zod.z.array(ComponentSchema).optional(),
+    filterBindings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+  }).optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DASH_COMP_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DashCompResponsePayloadSchema
+});
+var BundleRequestPayloadSchema = zod.z.object({
+  devbundlereq: zod.z.boolean().optional().default(false)
+});
+var BundleRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("BUNDLE_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BundleRequestPayloadSchema
+});
+var BundleChunkPayloadSchema = zod.z.object({
+  chunk: zod.z.string(),
+  chunkIndex: zod.z.number(),
+  totalChunks: zod.z.number(),
+  isComplete: zod.z.boolean(),
+  progress: zod.z.number()
+});
+var BundleChunkMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("BUNDLE_CHUNK"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BundleChunkPayloadSchema
+});
+var BundleErrorPayloadSchema = zod.z.object({
+  error: zod.z.string()
+});
+var BundleErrorMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("BUNDLE_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BundleErrorPayloadSchema
+});
+var DataRequestPayloadSchema = zod.z.object({
+  collection: zod.z.string(),
+  op: zod.z.string(),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  SA_RUNTIME: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var DataRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DATA_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DataRequestPayloadSchema
+});
+var DataResponsePayloadSchema = zod.z.object({
+  collection: zod.z.string(),
+  op: zod.z.string(),
+  data: zod.z.unknown(),
+  executionMs: zod.z.number().optional(),
+  error: zod.z.string().optional()
+});
+var DataResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DATA_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DataResponsePayloadSchema
+});
+var UILogEntrySchema = zod.z.object({
+  timestamp: zod.z.number(),
+  level: zod.z.enum(["info", "error", "warn", "debug"]),
+  message: zod.z.string(),
+  type: zod.z.enum(["explanation", "query", "general"]).optional(),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var UILogsPayloadSchema = zod.z.object({
+  logs: zod.z.array(UILogEntrySchema)
+});
+var UILogsMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  // uiBlockId
+  type: zod.z.literal("UI_LOGS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UILogsPayloadSchema
+});
+var ActionsRequestPayloadSchema = zod.z.object({
+  userId: zod.z.string().optional(),
+  SA_RUNTIME: zod.z.object({
+    threadId: zod.z.string(),
+    uiBlockId: zod.z.string()
+  }).optional()
+});
+var ActionsRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  from: MessageParticipantSchema,
+  type: zod.z.literal("ACTIONS"),
+  payload: ActionsRequestPayloadSchema
+});
+var ActionsResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  data: zod.z.any().optional(),
+  error: zod.z.string().optional()
+});
+var ActionsResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("ACTIONS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ActionsResponsePayloadSchema
+});
+var ComponentsSendPayloadSchema = zod.z.object({
+  components: zod.z.array(zod.z.any())
+});
+var ComponentsSendMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("COMPONENT_LIST_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ComponentsSendPayloadSchema
+});
+var UserQueryFiltersSchema = zod.z.object({
+  username: zod.z.string().optional(),
+  email: zod.z.string().optional(),
+  role: zod.z.string().optional(),
+  fullname: zod.z.string().optional(),
+  id: zod.z.number().optional()
+});
+var UsersRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
+  data: zod.z.object({
+    id: zod.z.number().optional(),
+    username: zod.z.string().optional(),
+    email: zod.z.string().email("Invalid email format").optional(),
+    password: zod.z.string().optional(),
+    fullname: zod.z.string().optional(),
+    role: zod.z.string().optional(),
+    userInfo: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+    // Query operation fields
+    filters: UserQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    sort: zod.z.enum(["ASC", "DESC"]).optional()
+  }).optional()
+});
+var UsersRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USERS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UsersRequestPayloadSchema
+});
+var UsersResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    username: zod.z.string().optional(),
+    email: zod.z.string().optional(),
+    fullname: zod.z.string().optional(),
+    role: zod.z.string().optional(),
+    message: zod.z.string().optional(),
+    users: zod.z.array(zod.z.object({
+      id: zod.z.number(),
+      username: zod.z.string(),
+      email: zod.z.string().optional(),
+      fullname: zod.z.string().optional(),
+      role: zod.z.string().optional(),
+      userInfo: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+      wsIds: zod.z.array(zod.z.string()).optional(),
+      createdAt: zod.z.string().optional(),
+      updatedAt: zod.z.string().optional()
+    })).optional(),
+    user: zod.z.object({
+      id: zod.z.number(),
+      username: zod.z.string(),
+      email: zod.z.string().optional(),
+      fullname: zod.z.string().optional(),
+      role: zod.z.string().optional(),
+      userInfo: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+      wsIds: zod.z.array(zod.z.string()).optional(),
+      createdAt: zod.z.string().optional(),
+      updatedAt: zod.z.string().optional()
+    }).optional(),
+    count: zod.z.number().optional()
+  }).optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USERS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UsersResponsePayloadSchema
+});
+var DashboardQueryFiltersSchema = zod.z.object({
+  dashboardId: zod.z.string().optional(),
+  projectId: zod.z.string().optional(),
+  createdBy: zod.z.string().optional(),
+  updatedBy: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  published: zod.z.boolean().optional()
+});
+var DashboardsRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
+  data: zod.z.object({
+    id: zod.z.number().optional(),
+    dashboardId: zod.z.string().optional(),
+    projectId: zod.z.string().optional(),
+    name: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    published: zod.z.boolean().optional(),
+    createdBy: zod.z.string().optional(),
+    updatedBy: zod.z.string().optional(),
+    allowedUsers: zod.z.array(zod.z.string()).optional(),
+    dashboard: DSLRendererPropsSchema.optional(),
+    // Query operation fields
+    filters: DashboardQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    sort: zod.z.enum(["ASC", "DESC"]).optional()
+  }).optional()
+});
+var DashboardsRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DASHBOARDS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DashboardsRequestPayloadSchema
+});
+var DashboardsResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    dashboardId: zod.z.string().optional(),
+    dashboard: DSLRendererPropsSchema.optional(),
+    dashboards: zod.z.array(zod.z.object({
+      dashboardId: zod.z.string(),
+      dashboard: DSLRendererPropsSchema
+    })).optional(),
+    count: zod.z.number().optional(),
+    message: zod.z.string().optional()
+  }).optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DASHBOARDS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DashboardsResponsePayloadSchema
+});
+var ReportQueryFiltersSchema = zod.z.object({
+  reportId: zod.z.string().optional(),
+  projectId: zod.z.string().optional(),
+  createdBy: zod.z.string().optional(),
+  updatedBy: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  published: zod.z.boolean().optional()
+});
+var ReportsRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
+  data: zod.z.object({
+    id: zod.z.number().optional(),
+    reportId: zod.z.string().optional(),
+    projectId: zod.z.string().optional(),
+    name: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    published: zod.z.boolean().optional(),
+    createdBy: zod.z.string().optional(),
+    updatedBy: zod.z.string().optional(),
+    report: DSLRendererPropsSchema2.optional(),
+    // Query operation fields
+    filters: ReportQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    sort: zod.z.enum(["ASC", "DESC"]).optional()
+  }).optional()
+});
+var ReportsRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("REPORTS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ReportsRequestPayloadSchema
+});
+var ReportsResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    reportId: zod.z.string().optional(),
+    report: DSLRendererPropsSchema2.optional(),
+    reports: zod.z.array(zod.z.object({
+      reportId: zod.z.string(),
+      report: DSLRendererPropsSchema2
+    })).optional(),
+    count: zod.z.number().optional(),
+    message: zod.z.string().optional()
+  }).optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("REPORTS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ReportsResponsePayloadSchema
+});
+var UIQueryFiltersSchema = zod.z.object({
+  uiId: zod.z.string().optional(),
+  projectId: zod.z.string().optional(),
+  createdBy: zod.z.string().optional(),
+  updatedBy: zod.z.string().optional(),
+  name: zod.z.string().optional()
+});
+var UIsRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
+  data: zod.z.object({
+    id: zod.z.number().optional(),
+    uiId: zod.z.string().optional(),
+    projectId: zod.z.string().optional(),
+    name: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    createdBy: zod.z.string().optional(),
+    updatedBy: zod.z.string().optional(),
+    ui: DSLRendererPropsSchema.optional(),
+    // Query operation fields
+    filters: UIQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    sort: zod.z.enum(["ASC", "DESC"]).optional()
+  }).optional()
+});
+var UIsRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("UIS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UIsRequestPayloadSchema
+});
+var UIsResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    uiId: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+    ui: DSLRendererPropsSchema.optional(),
+    uis: zod.z.array(zod.z.object({
+      uiId: zod.z.string(),
+      ui: DSLRendererPropsSchema.optional()
+    })).optional(),
+    count: zod.z.number().optional(),
+    message: zod.z.string().optional()
+  }).optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("UIS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UIsResponsePayloadSchema
+});
+var DBUIBlockSchema = zod.z.object({
+  id: zod.z.string(),
+  component: zod.z.record(zod.z.string(), zod.z.any()).nullable(),
+  analysis: zod.z.string().nullable(),
+  user_prompt: zod.z.string()
+});
+var BookmarkDataSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  uiblock: DBUIBlockSchema,
+  created_at: zod.z.string().optional(),
+  updated_at: zod.z.string().optional()
+});
+var BookmarkQueryFiltersSchema = zod.z.object({
+  userId: zod.z.string().optional(),
+  threadId: zod.z.string().optional(),
+  name: zod.z.string().optional()
+});
+var BookmarksRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
+  data: zod.z.object({
+    id: zod.z.number().optional(),
+    userId: zod.z.string().optional(),
+    threadId: zod.z.string().optional(),
+    name: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    uiblock: DBUIBlockSchema.optional(),
+    // Query operation fields
+    filters: BookmarkQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    sort: zod.z.enum(["ASC", "DESC"]).optional()
+  }).optional()
+});
+var BookmarksRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("BOOKMARKS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BookmarksRequestPayloadSchema
+});
+var BookmarksResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.union([
+    BookmarkDataSchema,
+    zod.z.array(BookmarkDataSchema)
+  ]).optional(),
+  count: zod.z.number().optional(),
+  message: zod.z.string().optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("BOOKMARKS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BookmarksResponsePayloadSchema
+});
+var ArtifactDataSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  name: zod.z.string(),
+  createdBy: zod.z.string().nullable().optional(),
+  dsl: zod.z.record(zod.z.string(), zod.z.any()).nullable().optional(),
+  type: zod.z.string().nullable().optional(),
+  filters: zod.z.any().nullable().optional(),
+  status: zod.z.string().nullable().optional(),
+  deleted: zod.z.boolean().optional(),
+  createdAt: zod.z.string().optional(),
+  updatedAt: zod.z.string().optional()
+});
+var ArtifactsQueryFiltersSchema = zod.z.object({
+  createdBy: zod.z.string().optional(),
+  type: zod.z.string().optional(),
+  status: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  deleted: zod.z.boolean().optional(),
+  createdAt: zod.z.string().optional()
+});
+var ArtifactsRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
+  data: zod.z.object({
+    id: zod.z.number().optional(),
+    name: zod.z.string().optional(),
+    createdBy: zod.z.string().optional(),
+    dsl: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    status: zod.z.string().optional(),
+    deleted: zod.z.boolean().optional(),
+    limit: zod.z.number().optional(),
+    offset: zod.z.number().optional(),
+    // Query operation fields
+    filters: ArtifactsQueryFiltersSchema.optional(),
+    sort: zod.z.enum(["ASC", "DESC"]).optional(),
+    // Menu grouping fields
+    type: zod.z.string().optional(),
+    menuId: zod.z.number().optional(),
+    artifactGroupName: zod.z.string().optional(),
+    artifactGroupId: zod.z.string().optional(),
+    artifactGroupIcon: zod.z.string().optional()
+  }).optional()
+});
+var ArtifactsRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("ARTIFACTS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ArtifactsRequestPayloadSchema
+});
+var ArtifactsResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.union([
+    ArtifactDataSchema,
+    zod.z.array(ArtifactDataSchema)
+  ]).optional(),
+  count: zod.z.number().optional(),
+  message: zod.z.string().optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("ARTIFACTS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ArtifactsResponsePayloadSchema
+});
+var KbNodeTypeSchema = zod.z.enum(["global", "user", "query"]);
+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(),
+  type: KbNodeTypeSchema.nullable().optional(),
+  createdBy: zod.z.string(),
+  updatedBy: zod.z.string().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(),
+  type: KbNodeTypeSchema.optional(),
+  createdBy: zod.z.string().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(),
+    type: KbNodeTypeSchema.optional(),
+    createdBy: zod.z.string().optional(),
+    updatedBy: zod.z.string().optional(),
+    userId: zod.z.string().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(),
+    type: KbNodeTypeSchema.nullable().optional(),
+    createdBy: zod.z.string().optional(),
+    updatedBy: zod.z.string().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.string().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 MenuDataSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  name: zod.z.string(),
+  componentName: zod.z.string(),
+  icon: zod.z.string().nullable().optional(),
+  userMessage: zod.z.string().nullable().optional(),
+  parentId: zod.z.number().nullable().optional(),
+  sortOrder: zod.z.number().optional(),
+  props: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
+  isActive: zod.z.boolean().optional(),
+  createdAt: zod.z.string().optional(),
+  updatedAt: zod.z.string().optional(),
+  children: zod.z.lazy(() => zod.z.array(MenuDataSchema)).optional(),
+  menuJson: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
+  version: zod.z.number().optional()
+});
+var MenuQueryFiltersSchema = zod.z.object({
+  parentId: zod.z.number().nullable().optional(),
+  isActive: zod.z.boolean().optional()
+});
+var MenusRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne", "query", "getRootMenus", "getChildMenus", "getHierarchy", "reorder"]),
+  data: zod.z.object({
+    id: zod.z.number().optional(),
+    name: zod.z.string().optional(),
+    componentName: zod.z.string().optional(),
+    icon: zod.z.string().optional(),
+    userMessage: zod.z.string().optional(),
+    parentId: zod.z.number().nullable().optional(),
+    sortOrder: zod.z.number().optional(),
+    props: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+    isActive: zod.z.boolean().optional(),
+    // Query operation fields
+    filters: MenuQueryFiltersSchema.optional(),
+    limit: zod.z.number().optional(),
+    sort: zod.z.enum(["ASC", "DESC"]).optional(),
+    // Reorder operation
+    items: zod.z.array(zod.z.object({
+      id: zod.z.number(),
+      sortOrder: zod.z.number()
+    })).optional()
+  }).optional()
+});
+var MenusRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("MENUS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: MenusRequestPayloadSchema
+});
+var MenusResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.union([
+    MenuDataSchema,
+    zod.z.array(MenuDataSchema)
+  ]).optional(),
+  count: zod.z.number().optional(),
+  message: zod.z.string().optional()
+});
+var MenusResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("MENUS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: MenusResponsePayloadSchema
+});
+var SchemaColumnStatisticsSchema = zod.z.object({
+  distinct: zod.z.number().optional(),
+  min: zod.z.number().optional(),
+  max: zod.z.number().optional()
+});
+var SchemaColumnSchema = zod.z.object({
+  name: zod.z.string(),
+  type: zod.z.string(),
+  nativeType: zod.z.string(),
+  nullable: zod.z.boolean(),
+  description: zod.z.string(),
+  statistics: SchemaColumnStatisticsSchema.optional(),
+  cardinality: zod.z.enum(["unique", "high", "medium", "low"]).optional(),
+  sampleValues: zod.z.array(zod.z.string()).optional()
+});
+var SchemaTableSchema = zod.z.object({
+  name: zod.z.string(),
+  fullName: zod.z.string(),
+  rowCount: zod.z.number(),
+  description: zod.z.string(),
+  columns: zod.z.array(SchemaColumnSchema)
+});
+var SchemaRelationshipSchema = zod.z.object({
+  from: zod.z.string(),
+  to: zod.z.string(),
+  type: zod.z.string(),
+  keys: zod.z.array(zod.z.string())
+});
+var DatabaseSchemaSchema = zod.z.object({
+  database: zod.z.string(),
+  databaseType: zod.z.string().optional(),
+  schema: zod.z.string(),
+  description: zod.z.string(),
+  tables: zod.z.array(SchemaTableSchema),
+  relationships: zod.z.array(SchemaRelationshipSchema).optional()
+});
+var SchemaRequestPayloadSchema = zod.z.object({
+  /** If true, returns the formatted documentation string in addition to raw JSON */
+  formatted: zod.z.boolean().optional()
+});
+var SchemaRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("SCHEMA_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: SchemaRequestPayloadSchema
+});
+var SchemaResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    schema: DatabaseSchemaSchema,
+    /** Formatted schema documentation (only if formatted: true was requested) */
+    formatted: zod.z.string().optional()
+  }).optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("SCHEMA_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: SchemaResponsePayloadSchema
+});
+var ClientConfigSchema = zod.z.object({
+  userId: zod.z.string(),
+  projectId: zod.z.string(),
+  baseUrl: zod.z.string().default("wss://ws.superatom.ai/websocket"),
+  type: zod.z.string().default("runtime"),
+  maxReconnectAttempts: zod.z.number().min(0).default(Infinity),
+  initialReconnectDelay: zod.z.number().min(0).default(1e3),
+  maxReconnectDelay: zod.z.number().min(0).default(3e4),
+  defaultTimeout: zod.z.number().min(0).default(3e4),
+  debug: zod.z.boolean().default(false)
+});
+
+// src/services/index.ts
+var services_exports = {};
+__export(services_exports, {
+  BindingSchema: () => BindingSchema,
+  DSLRendererPropsSchema: () => DSLRendererPropsSchema,
+  ExpressionSchema: () => ExpressionSchema,
+  ForDirectiveSchema: () => ForDirectiveSchema,
+  PageSchema: () => PageSchema,
+  QuerySpecSchema: () => QuerySpecSchema,
+  UIComponentSchema: () => UIComponentSchema,
+  UIElementSchema: () => UIElementSchema,
+  createArtifact: () => createArtifact,
+  createBookmark: () => createBookmark,
+  createDashboard: () => createDashboard,
+  createKbNode: () => createKbNode,
+  createMenu: () => createMenu,
+  createReport: () => createReport,
+  createUI: () => createUI,
+  createUser: () => createUser,
+  deleteArtifact: () => deleteArtifact,
+  deleteBookmark: () => deleteBookmark,
+  deleteDashboard: () => deleteDashboard,
+  deleteKbNode: () => deleteKbNode,
+  deleteMenu: () => deleteMenu,
+  deleteReport: () => deleteReport,
+  deleteUI: () => deleteUI,
+  deleteUser: () => deleteUser,
+  getActions: () => getActions,
+  getAllArtifacts: () => getAllArtifacts,
+  getAllBookmarks: () => getAllBookmarks,
+  getAllDashboards: () => getAllDashboards,
+  getAllKbNodes: () => getAllKbNodes,
+  getAllMenus: () => getAllMenus,
+  getAllReports: () => getAllReports,
+  getAllUIs: () => getAllUIs,
+  getAllUsers: () => getAllUsers,
+  getArtifact: () => getArtifact,
+  getBookmark: () => getBookmark,
+  getChildMenus: () => getChildMenus,
+  getComponentSuggestions: () => getComponentSuggestions,
+  getDashboard: () => getDashboard,
+  getKbNode: () => getKbNode,
+  getKbNodeCategories: () => getKbNodeCategories,
+  getKbNodeTags: () => getKbNodeTags,
+  getKbNodesByCategory: () => getKbNodesByCategory,
+  getKbNodesByUser: () => getKbNodesByUser,
+  getMenu: () => getMenu,
+  getMenusHierarchy: () => getMenusHierarchy,
+  getReport: () => getReport,
+  getRootMenus: () => getRootMenus,
+  getSchema: () => getSchema,
+  getUI: () => getUI,
+  getUser: () => getUser,
+  queryArtifacts: () => queryArtifacts,
+  queryBookmarks: () => queryBookmarks,
+  queryDashboards: () => queryDashboards,
+  queryMenus: () => queryMenus,
+  queryReports: () => queryReports,
+  queryUIs: () => queryUIs,
+  queryUsers: () => queryUsers,
+  reorderMenus: () => reorderMenus,
+  requestBundle: () => requestBundle,
+  requestData: () => requestData,
+  searchKbNodes: () => searchKbNodes,
+  sendAuthLoginRequest: () => sendAuthLoginRequest,
+  sendAuthVerifyRequest: () => sendAuthVerifyRequest,
+  sendComponents: () => sendComponents,
+  sendDashCompRequest: () => sendDashCompRequest,
+  sendUserPromptRequest: () => sendUserPromptRequest,
+  sendUserPromptSuggestionsRequest: () => sendUserPromptSuggestionsRequest,
+  updateArtifact: () => updateArtifact,
+  updateBookmark: () => updateBookmark,
+  updateDashboard: () => updateDashboard,
+  updateKbNode: () => updateKbNode,
+  updateMenu: () => updateMenu,
+  updateReport: () => updateReport,
+  updateUI: () => updateUI,
+  updateUser: () => updateUser
+});
+
+// src/services/auth.ts
+async function sendAuthLoginRequest(client, loginDataBase64, timeout) {
+  const messageId = `login_${Date.now()}`;
+  const message = AuthLoginRequestMessageSchema.parse({
+    id: messageId,
+    type: "AUTH_LOGIN_REQ",
+    from: {
+      type: client.type
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      login_data: loginDataBase64
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  console.log("sdk auth login response", response);
+  return response;
+}
+async function sendAuthVerifyRequest(client, token, timeout) {
+  const messageId = `verify_${Date.now()}`;
+  const message = AuthVerifyRequestMessageSchema.parse({
+    id: messageId,
+    type: "AUTH_VERIFY_REQ",
+    from: {
+      type: client.type
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      token
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+
+// src/services/userPrompt.ts
+async function sendUserPromptRequest(client, prompt, threadId, uiBlockId, userId, responseMode, onStream, timeout) {
+  const messageId = `user_prompt_req_msg_${Date.now()}`;
+  const message = UserPromptRequestMessageSchema.parse({
+    id: messageId,
+    type: "USER_PROMPT_REQ",
+    from: {
+      type: client.type
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      prompt,
+      userId,
+      SA_RUNTIME: {
+        threadId,
+        uiBlockId
+      },
+      responseMode
+    }
+  });
+  let streamUnsubscribe = null;
+  if (responseMode === "text" && onStream) {
+    streamUnsubscribe = client.onMessage((msg) => {
+      if (msg.type === "USER_PROMPT_STREAM" && msg.id === `stream_${uiBlockId}`) {
+        const chunk = msg.payload?.chunk;
+        if (chunk) {
+          onStream(chunk);
+        }
+      }
+    });
+  }
+  try {
+    const response = await client.sendWithResponse(message, timeout);
+    return response;
+  } finally {
+    if (streamUnsubscribe) {
+      streamUnsubscribe();
+    }
+  }
+}
+async function sendUserPromptSuggestionsRequest(client, prompt, userId, limit = 5, timeout) {
+  if (!prompt || prompt.trim().length === 0) {
+    return null;
+  }
+  const messageId = `suggestions_${Date.now()}`;
+  const message = UserPromptSuggestionsRequestMessageSchema.parse({
+    id: messageId,
+    type: "USER_PROMPT_SUGGESTIONS_REQ",
+    from: {
+      type: client.type
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      prompt,
+      userId,
+      limit
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+
+// src/services/bundle.ts
+async function requestBundle(client, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = BundleRequestMessageSchema.parse({
+    id: messageId,
+    type: "BUNDLE_REQ",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: { devbundlereq: options?.devbundlereq ?? false }
+  });
+  const chunks = [];
+  let totalChunks = 0;
+  const unsubscribe = client.onMessage((msg) => {
+    try {
+      if (msg.type === "BUNDLE_CHUNK" && msg.id?.startsWith(messageId)) {
+        const chunkMessage = BundleChunkMessageSchema.parse(msg);
+        const payload = chunkMessage.payload;
+        chunks[payload.chunkIndex] = payload.chunk;
+        totalChunks = payload.totalChunks;
+        if (options?.onProgress) {
+          options.onProgress(payload.progress);
+        }
+      }
+    } catch (error) {
+      console.error("[SuperAtom] Failed to parse bundle chunk:", error);
+    }
+  });
+  client.send(message);
+  const timeout = options?.timeout ?? 6e4;
+  const startTime = Date.now();
+  return new Promise((resolve, reject) => {
+    const checkInterval = setInterval(() => {
+      if (Date.now() - startTime > timeout) {
+        clearInterval(checkInterval);
+        unsubscribe();
+        reject(new Error(`Bundle request timeout after ${timeout}ms`));
+        return;
+      }
+      if (totalChunks > 0 && chunks.length === totalChunks) {
+        clearInterval(checkInterval);
+        unsubscribe();
+        const bundle = chunks.join("");
+        resolve(bundle);
+      }
+    }, 100);
+  });
+}
+
+// src/services/data.ts
+async function requestData(client, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = DataRequestMessageSchema.parse({
+    id: messageId,
+    type: "DATA_REQ",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      collection: options.collection,
+      op: options.operation,
+      params: options.params,
+      SA_RUNTIME: options.SA_RUNTIME
+    }
+  });
+  const response = await client.sendWithResponse(message, options.timeout);
+  const payload = response.payload;
+  return {
+    data: payload.data,
+    error: payload.error,
+    executionMs: payload.executionMs
+  };
+}
+
+// src/services/component.ts
+async function getComponentSuggestions(client, query, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = {
+    id: messageId,
+    type: "USER_PROMPT_REQ",
+    to: { type: "data-agent" },
+    payload: {
+      prompt: query
+    }
+  };
+  const response = await client.sendWithResponse(message, options?.timeout);
+  const payload = response.payload;
+  return {
+    component: payload.component,
+    error: payload.error
+  };
+}
+async function sendComponents(client, components) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const ws_msg = {
+    id: messageId,
+    type: "COMPONENT_LIST_RES",
+    from: {
+      type: client.type
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      components
+    }
+  };
+  client.send(ws_msg);
+}
+
+// src/services/users.ts
+async function createUser(client, username, password, email, fullname, role, userInfo, timeout) {
+  const messageId = `users_create_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        username,
+        password,
+        email,
+        fullname,
+        role,
+        userInfo
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    username: payload.data?.username,
+    email: payload.data?.email,
+    fullname: payload.data?.fullname,
+    role: payload.data?.role
+  };
+}
+async function updateUser(client, id, updates, timeout) {
+  const messageId = `users_update_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        id,
+        ...updates
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    username: payload.data?.username,
+    email: payload.data?.email,
+    fullname: payload.data?.fullname,
+    role: payload.data?.role
+  };
+}
+async function deleteUser(client, id, timeout) {
+  const messageId = `users_delete_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    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,
+    username: payload.data?.username,
+    email: payload.data?.email,
+    fullname: payload.data?.fullname,
+    role: payload.data?.role
+  };
+}
+async function getAllUsers(client, timeout) {
+  const messageId = `users_getall_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    users: payload.data?.users,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getUser(client, username, timeout) {
+  const messageId = `users_getone_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getOne",
+      data: {
+        username
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    user: payload.data?.user,
+    message: payload.data?.message
+  };
+}
+async function queryUsers(client, options = {}, timeout) {
+  const { filters, limit, sort } = options;
+  const messageId = `users_query_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "query",
+      data: {
+        filters,
+        limit,
+        sort
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    users: payload.data?.users,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+
+// src/services/dashboards/index.ts
+async function createDashboard(client, options, timeout) {
+  const { dashboardId, projectId, name, description, published, createdBy, allowedUsers, dashboard } = options;
+  const messageId = `dashboards_create_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        dashboardId,
+        projectId,
+        name,
+        description,
+        published,
+        createdBy,
+        allowedUsers,
+        dashboard
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    id: payload.data?.id,
+    dashboardId: payload.data?.dashboardId,
+    dashboard: payload.data?.dashboard
+  };
+}
+async function updateDashboard(client, options, timeout) {
+  const { id, name, description, published, createdBy, updatedBy, allowedUsers, dashboard } = options;
+  const messageId = `dashboards_update_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        id,
+        name,
+        description,
+        published,
+        createdBy,
+        updatedBy,
+        allowedUsers,
+        dashboard
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    id: payload.data?.id,
+    dashboardId: payload.data?.dashboardId,
+    dashboard: payload.data?.dashboard
+  };
+}
+async function deleteDashboard(client, id, timeout) {
+  const messageId = `dashboards_delete_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    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,
+    id: payload.data?.id
+  };
+}
+async function getAllDashboards(client, timeout) {
+  const messageId = `dashboards_getall_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    dashboards: payload.data?.dashboards,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getDashboard(client, id, timeout) {
+  const messageId = `dashboards_getone_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    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,
+    id: payload.data?.id,
+    dashboardId: payload.data?.dashboardId,
+    dashboard: payload.data?.dashboard,
+    message: payload.data?.message
+  };
+}
+async function queryDashboards(client, options = {}, timeout) {
+  const { filters, limit, sort } = options;
+  const messageId = `dashboards_query_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "query",
+      data: {
+        filters,
+        limit,
+        sort
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    dashboards: payload.data?.dashboards,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+
+// src/services/reports/index.ts
+async function createReport(client, options, timeout) {
+  const { reportId, projectId, name, description, published, createdBy, report } = options;
+  const messageId = `reports_create_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        reportId,
+        projectId,
+        name,
+        description,
+        published,
+        createdBy,
+        report
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    id: payload.data?.id,
+    reportId: payload.data?.reportId,
+    report: payload.data?.report
+  };
+}
+async function updateReport(client, options, timeout) {
+  const { id, name, description, published, createdBy, updatedBy, report } = options;
+  const messageId = `reports_update_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        id,
+        name,
+        description,
+        published,
+        createdBy,
+        updatedBy,
+        report
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    id: payload.data?.id,
+    reportId: payload.data?.reportId,
+    report: payload.data?.report
+  };
+}
+async function deleteReport(client, id, timeout) {
+  const messageId = `reports_delete_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    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,
+    id: payload.data?.id
+  };
+}
+async function getAllReports(client, timeout) {
+  const messageId = `reports_getall_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    reports: payload.data?.reports,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getReport(client, id, timeout) {
+  const messageId = `reports_getone_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    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,
+    id: payload.data?.id,
+    reportId: payload.data?.reportId,
+    report: payload.data?.report,
+    message: payload.data?.message
+  };
+}
+async function queryReports(client, options = {}, timeout) {
+  const { filters, limit, sort } = options;
+  const messageId = `reports_query_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "query",
+      data: {
+        filters,
+        limit,
+        sort
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    reports: payload.data?.reports,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+
+// src/services/bookmarks/index.ts
+async function createBookmark(client, options, timeout) {
+  const { userId, uiblock, threadId, name, description } = options;
+  const messageId = `bookmarks_create_${Date.now()}`;
+  const message = BookmarksRequestMessageSchema.parse({
+    id: messageId,
+    type: "BOOKMARKS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        userId,
+        threadId,
+        name,
+        description,
+        uiblock
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.message,
+    data: Array.isArray(payload.data) ? payload.data[0] : payload.data
+  };
+}
+async function updateBookmark(client, options, timeout) {
+  const { id, uiblock, threadId, name, description } = options;
+  const messageId = `bookmarks_update_${Date.now()}`;
+  const message = BookmarksRequestMessageSchema.parse({
+    id: messageId,
+    type: "BOOKMARKS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        id,
+        threadId,
+        name,
+        description,
+        uiblock
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.message,
+    data: Array.isArray(payload.data) ? payload.data[0] : payload.data
+  };
+}
+async function deleteBookmark(client, id, timeout) {
+  const messageId = `bookmarks_delete_${Date.now()}`;
+  const message = BookmarksRequestMessageSchema.parse({
+    id: messageId,
+    type: "BOOKMARKS",
+    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.message,
+    data: Array.isArray(payload.data) ? payload.data[0] : payload.data
+  };
+}
+async function getAllBookmarks(client, timeout) {
+  const messageId = `bookmarks_getall_${Date.now()}`;
+  const message = BookmarksRequestMessageSchema.parse({
+    id: messageId,
+    type: "BOOKMARKS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    data: Array.isArray(payload.data) ? payload.data : payload.data ? [payload.data] : [],
+    count: payload.count,
+    message: payload.message
+  };
+}
+async function getBookmark(client, id, timeout) {
+  const messageId = `bookmarks_getone_${Date.now()}`;
+  const message = BookmarksRequestMessageSchema.parse({
+    id: messageId,
+    type: "BOOKMARKS",
+    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,
+    data: Array.isArray(payload.data) ? payload.data[0] : payload.data,
+    message: payload.message
+  };
+}
+async function queryBookmarks(client, options = {}, timeout) {
+  const { filters, limit, sort } = options;
+  const messageId = `bookmarks_query_${Date.now()}`;
+  const message = BookmarksRequestMessageSchema.parse({
+    id: messageId,
+    type: "BOOKMARKS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "query",
+      data: {
+        filters,
+        limit,
+        sort
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    data: Array.isArray(payload.data) ? payload.data : payload.data ? [payload.data] : [],
+    count: payload.count,
+    message: payload.message
+  };
+}
+
+// src/services/artifacts/index.ts
+async function createArtifact(client, options, timeout) {
+  console.log("[SDK-WEB] createArtifact called with options:", JSON.stringify(options, null, 2));
+  const { name, createdBy, dsl, type, filters, status } = options;
+  console.log("[SDK-WEB] Extracted parameters:", JSON.stringify({
+    name,
+    createdBy,
+    dsl: dsl ? "present" : "undefined",
+    type,
+    filters: filters ? "present" : "undefined",
+    status
+  }, null, 2));
+  const messageId = `artifacts_create_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const messageData = {
+    name,
+    createdBy,
+    dsl,
+    type,
+    filters,
+    status
+  };
+  console.log("[SDK-WEB] Sending message data:", JSON.stringify(messageData, null, 2));
+  const message = ArtifactsRequestMessageSchema.parse({
+    id: messageId,
+    type: "ARTIFACTS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: messageData
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.message,
+    data: Array.isArray(payload.data) ? payload.data[0] : payload.data
+  };
+}
+async function updateArtifact(client, options, timeout) {
+  const { id, name, dsl, type, filters, status, deleted } = options;
+  const messageId = `artifacts_update_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = ArtifactsRequestMessageSchema.parse({
+    id: messageId,
+    type: "ARTIFACTS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        id,
+        name,
+        dsl,
+        type,
+        filters,
+        status,
+        deleted
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.message,
+    data: Array.isArray(payload.data) ? payload.data[0] : payload.data
+  };
+}
+async function deleteArtifact(client, id, timeout) {
+  const messageId = `artifacts_delete_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = ArtifactsRequestMessageSchema.parse({
+    id: messageId,
+    type: "ARTIFACTS",
+    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.message,
+    data: Array.isArray(payload.data) ? payload.data[0] : payload.data
+  };
+}
+async function getAllArtifacts(client, limit, timeout) {
+  const messageId = `artifacts_getall_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = ArtifactsRequestMessageSchema.parse({
+    id: messageId,
+    type: "ARTIFACTS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll",
+      data: limit ? { limit } : void 0
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    data: Array.isArray(payload.data) ? payload.data : payload.data ? [payload.data] : [],
+    count: payload.count,
+    message: payload.message
+  };
+}
+async function getArtifact(client, id, timeout) {
+  const messageId = `artifacts_getone_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = ArtifactsRequestMessageSchema.parse({
+    id: messageId,
+    type: "ARTIFACTS",
+    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,
+    data: Array.isArray(payload.data) ? payload.data[0] : payload.data,
+    message: payload.message
+  };
+}
+async function queryArtifacts(client, options = {}, timeout) {
+  const { filters, limit, offset, sort } = options;
+  const messageId = `artifacts_query_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  console.log("[SDK-WEB] queryArtifacts - options.filters:", JSON.stringify(filters, null, 2));
+  const messageBeforeParse = {
+    id: messageId,
+    type: "ARTIFACTS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "query",
+      data: {
+        filters,
+        limit,
+        offset,
+        sort
+      }
+    }
+  };
+  console.log("[SDK-WEB] queryArtifacts - BEFORE parse - payload.data.filters:", JSON.stringify(messageBeforeParse.payload.data.filters, null, 2));
+  const message = ArtifactsRequestMessageSchema.parse(messageBeforeParse);
+  console.log("[SDK-WEB] queryArtifacts - AFTER parse - payload.data.filters:", JSON.stringify(message.payload.data?.filters, null, 2));
+  console.log("[SDK-WEB] queryArtifacts - filters.type:", message.payload.data?.filters?.type);
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    data: Array.isArray(payload.data) ? payload.data : payload.data ? [payload.data] : [],
+    count: payload.count,
+    message: payload.message
+  };
+}
+
+// src/services/actions.ts
+async function getActions(client, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = ActionsRequestMessageSchema.parse({
+    id: messageId,
+    type: "ACTIONS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      userId: options.userId,
+      SA_RUNTIME: options.SA_RUNTIME
+    }
+  });
+  const response = await client.sendWithResponse(message, options.timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    data: payload.data,
+    error: payload.error
+  };
+}
+
+// src/services/uis/index.ts
+async function createUI(client, options, timeout) {
+  const { uiId, projectId, name, description, createdBy, ui } = options;
+  const messageId = `uis_create_${Date.now()}`;
+  const message = UIsRequestMessageSchema.parse({
+    id: messageId,
+    type: "UIS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        uiId,
+        projectId,
+        name,
+        description,
+        createdBy,
+        ui
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    id: payload.data?.id,
+    uiId: payload.data?.uiId,
+    ui: payload.data?.ui
+  };
+}
+async function updateUI(client, options, timeout) {
+  const { id, name, description, createdBy, updatedBy, ui } = options;
+  const messageId = `uis_update_${Date.now()}`;
+  const message = UIsRequestMessageSchema.parse({
+    id: messageId,
+    type: "UIS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        id,
+        name,
+        description,
+        createdBy,
+        updatedBy,
+        ui
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    id: payload.data?.id,
+    uiId: payload.data?.uiId,
+    ui: payload.data?.ui
+  };
+}
+async function deleteUI(client, id, timeout) {
+  const messageId = `uis_delete_${Date.now()}`;
+  const message = UIsRequestMessageSchema.parse({
+    id: messageId,
+    type: "UIS",
+    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,
+    id: payload.data?.id
+  };
+}
+async function getAllUIs(client, timeout) {
+  const messageId = `uis_getall_${Date.now()}`;
+  const message = UIsRequestMessageSchema.parse({
+    id: messageId,
+    type: "UIS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    uis: payload.data?.uis,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getUI(client, id, timeout) {
+  const messageId = `uis_getone_${Date.now()}`;
+  const message = UIsRequestMessageSchema.parse({
+    id: messageId,
+    type: "UIS",
+    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,
+    id: payload.data?.id,
+    uiId: payload.data?.uiId,
+    ui: payload.data?.ui,
+    message: payload.data?.message
+  };
+}
+async function queryUIs(client, options = {}, timeout) {
+  const { filters, limit, sort } = options;
+  const messageId = `uis_query_${Date.now()}`;
+  const message = UIsRequestMessageSchema.parse({
+    id: messageId,
+    type: "UIS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "query",
+      data: {
+        filters,
+        limit,
+        sort
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    uis: payload.data?.uis,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+
+// src/services/kb-nodes.ts
+async function createKbNode(client, title, content, createdBy, category, tags, type, 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,
+        type: type || "query"
+      }
+    }
+  });
+  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,
+      type: payload.data.type,
+      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,
+      type: payload.data.type,
+      createdBy: payload.data.createdBy || "",
+      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, type, 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,
+        type,
+        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/services/dash-comp.ts
+async function sendDashCompRequest(client, options) {
+  const { prompt, userId, threadId, uiBlockId, timeout, existingComponents, reqType } = options;
+  const messageId = `dash_comp_req_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = DashCompRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASH_COMP_REQ",
+    from: {
+      type: client.type
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      prompt,
+      userId,
+      SA_RUNTIME: threadId || uiBlockId ? {
+        threadId,
+        uiBlockId
+      } : void 0,
+      existingComponents,
+      req_type: reqType
+    }
+  });
+  try {
+    const response = await client.sendWithResponse(message, timeout);
+    const payload = response.payload;
+    if (!payload.success) {
+      return {
+        success: false,
+        errors: payload.errors || ["Unknown error occurred"]
+      };
+    }
+    if (reqType === "filter") {
+      return {
+        success: true,
+        filterComponent: payload.data?.filterComponent,
+        updatedComponents: payload.data?.updatedComponents,
+        filterBindings: payload.data?.filterBindings,
+        reasoning: payload.data?.reasoning
+      };
+    }
+    return {
+      success: true,
+      component: payload.data?.component,
+      reasoning: payload.data?.reasoning,
+      dataSource: payload.data?.dataSource
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Request failed";
+    return {
+      success: false,
+      errors: [errorMessage]
+    };
+  }
+}
+
+// src/services/menus/index.ts
+async function createMenu(client, options, timeout) {
+  const { name, componentName, icon, userMessage, parentId, sortOrder, props, isActive } = options;
+  const messageId = `menus_create_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        name,
+        componentName,
+        icon,
+        userMessage,
+        parentId,
+        sortOrder,
+        props,
+        isActive
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.message,
+    data: payload.data
+  };
+}
+async function updateMenu(client, options, timeout) {
+  const { id, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive } = options;
+  const messageId = `menus_update_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        id,
+        name,
+        componentName,
+        icon,
+        userMessage,
+        parentId,
+        sortOrder,
+        props,
+        isActive
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.message,
+    data: payload.data
+  };
+}
+async function deleteMenu(client, id, timeout) {
+  const messageId = `menus_delete_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    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.message,
+    data: payload.data
+  };
+}
+async function getAllMenus(client, timeout) {
+  const messageId = `menus_getall_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    menus: Array.isArray(payload.data) ? payload.data : void 0,
+    count: payload.count,
+    message: payload.message
+  };
+}
+async function getMenu(client, id, timeout) {
+  const messageId = `menus_getone_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    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,
+    menu: payload.data,
+    message: payload.message
+  };
+}
+async function getRootMenus(client, timeout) {
+  const messageId = `menus_getrootmenus_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getRootMenus"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    menus: Array.isArray(payload.data) ? payload.data : void 0,
+    count: payload.count,
+    message: payload.message
+  };
+}
+async function getChildMenus(client, parentId, timeout) {
+  const messageId = `menus_getchildmenus_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getChildMenus",
+      data: {
+        parentId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    menus: Array.isArray(payload.data) ? payload.data : void 0,
+    count: payload.count,
+    message: payload.message
+  };
+}
+async function getMenusHierarchy(client, timeout) {
+  const messageId = `menus_gethierarchy_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getHierarchy"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    menus: Array.isArray(payload.data) ? payload.data : void 0,
+    count: payload.count,
+    message: payload.message
+  };
+}
+async function queryMenus(client, options = {}, timeout) {
+  const { filters, limit, sort } = options;
+  const messageId = `menus_query_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "query",
+      data: {
+        filters,
+        limit,
+        sort
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    menus: Array.isArray(payload.data) ? payload.data : void 0,
+    count: payload.count,
+    message: payload.message
+  };
+}
+async function reorderMenus(client, items, timeout) {
+  const messageId = `menus_reorder_${Date.now()}`;
+  const message = MenusRequestMessageSchema.parse({
+    id: messageId,
+    type: "MENUS",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "reorder",
+      data: {
+        items
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.message,
+    data: Array.isArray(payload.data) ? payload.data : void 0
+  };
+}
+
+// src/services/schema.ts
+async function getSchema(client, options = {}) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = SchemaRequestMessageSchema.parse({
+    id: messageId,
+    type: "SCHEMA_REQ",
+    from: { type: client.type },
+    to: { type: "data-agent" },
+    payload: {
+      formatted: options.formatted ?? false
+    }
+  });
+  const response = await client.sendWithResponse(message, options.timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    data: payload.data
+  };
+}
+
+// src/client.ts
+var SuperatomClient = class {
+  constructor(config) {
+    this.socket = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.shouldReconnect = true;
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.connectionHandlers = /* @__PURE__ */ new Set();
+    this.disconnectionHandlers = /* @__PURE__ */ new Set();
+    this.errorHandlers = /* @__PURE__ */ new Set();
+    this.connectPromise = null;
+    this.connectResolve = null;
+    const parsed = ClientConfigSchema.parse(config);
+    this.config = parsed;
+  }
+  /**
+   * Get WebSocket URL with query parameters
+   */
+  getWebSocketUrl() {
+    const params = new URLSearchParams({
+      userId: this.config.userId,
+      projectId: this.config.projectId,
+      type: this.config.type
+    });
+    return `${this.config.baseUrl}?${params.toString()}`;
+  }
+  /**
+   * Calculate reconnection delay with exponential backoff
+   */
+  calculateReconnectDelay() {
+    const delay = Math.min(
+      this.config.initialReconnectDelay * Math.pow(2, this.reconnectAttempts),
+      this.config.maxReconnectDelay
+    );
+    return delay + Math.random() * 1e3;
+  }
+  /**
+   * Schedule reconnection attempt
+   */
+  scheduleReconnect() {
+    if (!this.shouldReconnect) {
+      return;
+    }
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      const error = new Error("Max reconnection attempts reached");
+      this.log("error", error.message);
+      this.errorHandlers.forEach((handler) => handler(error));
+      return;
+    }
+    const delay = this.calculateReconnectDelay();
+    this.log("info", `Scheduling reconnection attempt ${this.reconnectAttempts + 1} in ${delay}ms`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectAttempts++;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Setup WebSocket event handlers
+   */
+  setupSocketHandlers() {
+    if (!this.socket) {
+      return;
+    }
+    this.socket.onopen = () => {
+      this.log("info", "Connected to SuperAtom");
+      this.reconnectAttempts = 0;
+      if (this.connectResolve) {
+        this.connectResolve();
+        this.connectResolve = null;
+      }
+      this.connectionHandlers.forEach((handler) => handler());
+    };
+    this.socket.onmessage = (event) => {
+      try {
+        const parsed = JSON.parse(event.data);
+        const message = MessageSchema.parse(parsed);
+        this.messageHandlers.forEach((handler) => handler(message));
+      } catch (error) {
+        this.log("error", "Failed to parse message:", error);
+        const err = error instanceof Error ? error : new Error("Parse error");
+        this.errorHandlers.forEach((handler) => handler(err));
+      }
+    };
+    this.socket.onclose = (event) => {
+      this.log("info", "Disconnected from SuperAtom", {
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      this.disconnectionHandlers.forEach((handler) => handler());
+      if (this.shouldReconnect && !event.wasClean) {
+        this.scheduleReconnect();
+      }
+    };
+    this.socket.onerror = (error) => {
+      this.log("error", "WebSocket error:", error);
+      this.errorHandlers.forEach((handler) => handler(error));
+    };
+  }
+  /**
+   * Connect to SuperAtom WebSocket server
+   * Returns a Promise that resolves when the connection is established
+   * The Promise never rejects - failures are logged silently and auto-reconnect is triggered
+   */
+  connect() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.log("warn", "Already connected");
+      return Promise.resolve();
+    }
+    if (this.socket?.readyState === WebSocket.CONNECTING && this.connectPromise) {
+      this.log("warn", "Connection already in progress");
+      return this.connectPromise;
+    }
+    this.connectPromise = new Promise((resolve) => {
+      this.connectResolve = resolve;
+    });
+    try {
+      this.socket = new WebSocket(this.getWebSocketUrl());
+      this.setupSocketHandlers();
+    } catch (error) {
+      this.log("error", "Failed to create WebSocket:", error);
+      const err = error instanceof Error ? error : new Error("Connection failed");
+      this.errorHandlers.forEach((handler) => handler(err));
+      this.scheduleReconnect();
+    }
+    return this.connectPromise;
+  }
+  /**
+   * Disconnect from WebSocket server
+   */
+  disconnect() {
+    this.shouldReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.socket) {
+      this.socket.close(1e3, "Client disconnect");
+      this.socket = null;
+    }
+    this.reconnectAttempts = 0;
+  }
+  /**
+   * Update client configuration
+   */
+  updateConfig(config) {
+    const merged = { ...this.config, ...config };
+    const parsed = ClientConfigSchema.parse(merged);
+    this.config = parsed;
+  }
+  /**
+   * Reconnect with new configuration
+   * Disconnects from existing connection and reconnects with updated config
+   * Returns a Promise that resolves when the new connection is established
+   */
+  reconnectWithConfig(config) {
+    this.updateConfig(config);
+    if (this.socket) {
+      this.disconnect();
+    }
+    this.shouldReconnect = true;
+    return this.connect();
+  }
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    const fullMessage = {
+      ...message,
+      from: message.from || { type: this.config.type }
+    };
+    try {
+      this.socket.send(JSON.stringify(fullMessage));
+    } catch (error) {
+      this.log("error", "Failed to send message:", error);
+      throw error;
+    }
+  }
+  /**
+   * Send a message and wait for a response with the same ID
+   * Uses closure-based approach - no global state management needed
+   */
+  async sendWithResponse(message, timeout) {
+    const messageId = message.id || `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const messageWithId = { ...message, id: messageId };
+    const timeoutMs = timeout ?? this.config.defaultTimeout;
+    this.send(messageWithId);
+    return new Promise((resolve, reject) => {
+      let isResolved = false;
+      const responseHandler = (msg) => {
+        if (msg.id === messageId && !isResolved) {
+          isResolved = true;
+          clearTimeout(timer);
+          unsubscribe();
+          resolve(msg);
+        }
+      };
+      const unsubscribe = this.onMessage(responseHandler);
+      const timer = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          unsubscribe();
+          reject(new Error(`Request timeout after ${timeoutMs}ms`));
+        }
+      }, timeoutMs);
+    });
+  }
+  /**
+   * Register message handler
+   */
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  /**
+   * Register connection handler
+   */
+  onConnect(handler) {
+    this.connectionHandlers.add(handler);
+    return () => this.connectionHandlers.delete(handler);
+  }
+  /**
+   * Register disconnection handler
+   */
+  onDisconnect(handler) {
+    this.disconnectionHandlers.add(handler);
+    return () => this.disconnectionHandlers.delete(handler);
+  }
+  /**
+   * Register error handler
+   */
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  /**
+   * Check if client is connected
+   */
+  isConnected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Get current reconnection attempts
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  /**
+   * Get client type
+   */
+  get type() {
+    return this.config.type;
+  }
+  /**
+   * Send a message and wait for response with timeout (alias for sendWithResponse)
+   */
+  async ask(message, options) {
+    return this.sendWithResponse(message, options?.timeout);
+  }
+  // ==================== Service Methods ====================
+  // These methods delegate to service functions for better code organization
+  /**
+   * Send authentication login request
+   * Delegates to auth service
+   */
+  async sendAuthLoginRequest(loginDataBase64, timeout) {
+    this.log("info", "Sending auth login request");
+    return sendAuthLoginRequest(this, loginDataBase64, timeout);
+  }
+  /**
+   * Send authentication verify request
+   * Delegates to auth service
+   */
+  async sendAuthVerifyRequest(token, timeout) {
+    this.log("info", "Sending auth verify request");
+    return sendAuthVerifyRequest(this, token, timeout);
+  }
+  /**
+   * Send a user prompt request
+   * Delegates to user prompt service
+   * @param userId - User ID for the request
+   * @param responseMode - 'component' for component response (default), 'text' for text streaming
+   * @param onStream - Optional callback for streaming text chunks (only for text mode)
+   */
+  async sendUserPromptRequest(prompt, threadId, uiBlockId, userId, responseMode, onStream, timeout) {
+    this.log("info", "Sending user prompt request with streaming support");
+    return sendUserPromptRequest(this, prompt, threadId, uiBlockId, userId, responseMode, onStream, timeout);
+  }
+  /**
+   * Send a user prompt suggestions request
+   * Delegates to user prompt service
+   * @param userId - User ID for the request
+   */
+  async sendUserPromptSuggestionsRequest(prompt, userId, limit = 5, timeout) {
+    this.log("info", "Sending user prompt suggestions request");
+    return sendUserPromptSuggestionsRequest(this, prompt, userId, limit, timeout);
+  }
+  /**
+   * Request bundle from server
+   * Delegates to bundle service
+   */
+  async requestBundle(options) {
+    this.log("info", "Requesting bundle from server");
+    return requestBundle(this, options);
+  }
+  /**
+   * Request data from a collection
+   * Delegates to data service
+   */
+  async requestData(options) {
+    this.log("info", `Requesting data from collection: ${options.collection}, operation: ${options.operation}`);
+    return requestData(this, options);
+  }
+  /**
+   * Get AI-powered component suggestions based on a query
+   * Delegates to component service
+   */
+  async getComponentSuggestions(query, options) {
+    this.log("info", "Requesting component suggestions for query:", query);
+    return getComponentSuggestions(this, query, options);
+  }
+  /**
+   * Get AI-powered component suggestions based on a query
+   * Delegates to component service
+   * @param userId - User ID for the request
+   */
+  async getActions(options) {
+    this.log("info", "Requesting actions");
+    return getActions(this, options);
+  }
+  async sendComponents(components) {
+    this.log("info", "Sending components");
+    return sendComponents(this, components);
+  }
+  // ==================== User Management Methods ====================
+  // These methods delegate to user service for admin user CRUD operations
+  /**
+   * Create a new user
+   * Delegates to users service
+   */
+  async createUser(username, password, email, fullname, role, userInfo, timeout) {
+    this.log("info", "Creating user:", username);
+    return createUser(this, username, password, email, fullname, role, userInfo, timeout);
+  }
+  /**
+   * Update an existing user
+   * Delegates to users service
+   */
+  async updateUser(id, updates, timeout) {
+    this.log("info", "Updating user:", id);
+    return updateUser(this, id, updates, timeout);
+  }
+  /**
+   * Delete a user
+   * Delegates to users service
+   */
+  async deleteUser(id, timeout) {
+    this.log("info", "Deleting user:", id);
+    return deleteUser(this, id, timeout);
+  }
+  /**
+   * Get all users
+   * Delegates to users service
+   */
+  async getAllUsers(timeout) {
+    this.log("info", "Fetching all users");
+    return getAllUsers(this, timeout);
+  }
+  /**
+   * Get a specific user by username
+   * Delegates to users service
+   */
+  async getUser(username, timeout) {
+    this.log("info", "Fetching user:", username);
+    return getUser(this, username, timeout);
+  }
+  /**
+   * Query users with filters, limit, and sort
+   * Delegates to users service
+   */
+  async queryUsers(options = {}, timeout) {
+    this.log("info", "Querying users with filters:", options.filters);
+    return queryUsers(this, options, timeout);
+  }
+  // ==================== Dashboard Management Methods ====================
+  // These methods delegate to dashboard service for admin dashboard CRUD operations
+  /**
+   * Create a new dashboard
+   * Delegates to dashboards service
+   */
+  async createDashboard(options, timeout) {
+    this.log("info", "Creating dashboard:", options.dashboardId, options.projectId);
+    return createDashboard(this, options, timeout);
+  }
+  /**
+   * Update an existing dashboard
+   * Delegates to dashboards service
+   */
+  async updateDashboard(options, timeout) {
+    this.log("info", "Updating dashboard:", options.id);
+    return updateDashboard(this, options, timeout);
+  }
+  /**
+   * Delete a dashboard
+   * Delegates to dashboards service
+   */
+  async deleteDashboard(id, timeout) {
+    this.log("info", "Deleting dashboard:", id);
+    return deleteDashboard(this, id, timeout);
+  }
+  /**
+   * Get all dashboards
+   * Delegates to dashboards service
+   */
+  async getAllDashboards(timeout) {
+    this.log("info", "Fetching all dashboards");
+    return getAllDashboards(this, timeout);
+  }
+  /**
+   * Get a specific dashboard by ID
+   * Delegates to dashboards service
+   */
+  async getDashboard(id, timeout) {
+    this.log("info", "Fetching dashboard:", id);
+    return getDashboard(this, id, timeout);
+  }
+  /**
+   * Query dashboards with filters
+   * Delegates to dashboards service
+   */
+  async queryDashboards(options, timeout) {
+    this.log("info", "Querying dashboards with filters:", options?.filters);
+    return queryDashboards(this, options, timeout);
+  }
+  // ==================== Bookmark Management Methods ====================
+  // These methods delegate to bookmark service for bookmark CRUD operations
+  /**
+   * Create a new bookmark
+   * Delegates to bookmarks service
+   */
+  async createBookmark(options, timeout) {
+    this.log("info", "Creating bookmark for user:", options.userId);
+    return createBookmark(this, options, timeout);
+  }
+  /**
+   * Update an existing bookmark
+   * Delegates to bookmarks service
+   */
+  async updateBookmark(options, timeout) {
+    this.log("info", "Updating bookmark:", options.id);
+    return updateBookmark(this, options, timeout);
+  }
+  /**
+   * Delete a bookmark
+   * Delegates to bookmarks service
+   */
+  async deleteBookmark(id, timeout) {
+    this.log("info", "Deleting bookmark:", id);
+    return deleteBookmark(this, id, timeout);
+  }
+  /**
+   * Get all bookmarks
+   * Delegates to bookmarks service
+   */
+  async getAllBookmarks(timeout) {
+    this.log("info", "Fetching all bookmarks");
+    return getAllBookmarks(this, timeout);
+  }
+  /**
+   * Get a specific bookmark by ID
+   * Delegates to bookmarks service
+   */
+  async getBookmark(id, timeout) {
+    this.log("info", "Fetching bookmark:", id);
+    return getBookmark(this, id, timeout);
+  }
+  /**
+   * Query bookmarks with filters, limit, and sort
+   * Delegates to bookmarks service
+   */
+  async queryBookmarks(options = {}, timeout) {
+    this.log("info", "Querying bookmarks with filters:", options.filters);
+    return queryBookmarks(this, options, timeout);
+  }
+  // ==================== Artifact Management Methods ====================
+  // These methods delegate to artifact service for artifact CRUD operations
+  /**
+   * Create a new artifact
+   * Delegates to artifacts service
+   */
+  async createArtifact(options, timeout) {
+    this.log("info", "Creating artifact:", options.name);
+    return createArtifact(this, options, timeout);
+  }
+  /**
+   * Update an existing artifact
+   * Delegates to artifacts service
+   */
+  async updateArtifact(options, timeout) {
+    this.log("info", "Updating artifact:", options.id);
+    return updateArtifact(this, options, timeout);
+  }
+  /**
+   * Delete an artifact (soft delete)
+   * Delegates to artifacts service
+   */
+  async deleteArtifact(id, timeout) {
+    this.log("info", "Deleting artifact:", id);
+    return deleteArtifact(this, id, timeout);
+  }
+  /**
+   * Get all artifacts
+   * Delegates to artifacts service
+   */
+  async getAllArtifacts(limit, timeout) {
+    this.log("info", "Fetching all artifacts");
+    return getAllArtifacts(this, limit, timeout);
+  }
+  /**
+   * Get a specific artifact by ID
+   * Delegates to artifacts service
+   */
+  async getArtifact(id, timeout) {
+    this.log("info", "Fetching artifact:", id);
+    return getArtifact(this, id, timeout);
+  }
+  /**
+   * Query artifacts with filters
+   * Delegates to artifacts service
+   */
+  async queryArtifacts(options = {}, timeout) {
+    this.log("info", "Querying artifacts with filters:", JSON.stringify(options.filters));
+    return queryArtifacts(this, options, timeout);
+  }
+  // ==================== Report Management Methods ====================
+  // These methods delegate to report service for admin report CRUD operations
+  /**
+   * Create a new report
+   * Delegates to reports service
+   */
+  async createReport(options, timeout) {
+    this.log("info", "Creating report:", options.reportId);
+    return createReport(this, options, timeout);
+  }
+  /**
+   * Update an existing report
+   * Delegates to reports service
+   */
+  async updateReport(options, timeout) {
+    this.log("info", "Updating report:", options.id);
+    return updateReport(this, options, timeout);
+  }
+  /**
+   * Delete a report
+   * Delegates to reports service
+   */
+  async deleteReport(id, timeout) {
+    this.log("info", "Deleting report:", id);
+    return deleteReport(this, id, timeout);
+  }
+  /**
+   * Get all reports
+   * Delegates to reports service
+   */
+  async getAllReports(timeout) {
+    this.log("info", "Fetching all reports");
+    return getAllReports(this, timeout);
+  }
+  /**
+   * Get a specific report by ID
+   * Delegates to reports service
+   */
+  async getReport(id, timeout) {
+    this.log("info", "Fetching report:", id);
+    return getReport(this, id, timeout);
+  }
+  /**
+   * Query reports with filters
+   * Delegates to reports service
+   */
+  async queryReports(options, timeout) {
+    this.log("info", "Querying reports with filters:", options?.filters);
+    return queryReports(this, options, timeout);
+  }
+  // ==================== UI Management Methods ====================
+  // These methods delegate to uis service for admin UI CRUD operations
+  /**
+   * Create a new UI
+   * Delegates to uis service
+   */
+  async createUI(options, timeout) {
+    this.log("info", "Creating UI:", options.uiId);
+    return createUI(this, options, timeout);
+  }
+  /**
+   * Update an existing UI
+   * Delegates to uis service
+   */
+  async updateUI(options, timeout) {
+    this.log("info", "Updating UI:", options.id);
+    return updateUI(this, options, timeout);
+  }
+  /**
+   * Delete a UI
+   * Delegates to uis service
+   */
+  async deleteUI(id, timeout) {
+    this.log("info", "Deleting UI:", id);
+    return deleteUI(this, id, timeout);
+  }
+  /**
+   * Get all UIs
+   * Delegates to uis service
+   */
+  async getAllUIs(timeout) {
+    this.log("info", "Fetching all UIs");
+    return getAllUIs(this, timeout);
+  }
+  /**
+   * Get a specific UI by ID
+   * Delegates to uis service
+   */
+  async getUI(id, timeout) {
+    this.log("info", "Fetching UI:", id);
+    return getUI(this, id, timeout);
+  }
+  /**
+   * Query UIs with filters
+   * Delegates to uis service
+   */
+  async queryUIs(options, timeout) {
+    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, type, timeout) {
+    this.log("info", "Creating KB node:", title);
+    return createKbNode(this, title, content, createdBy, category, tags, type, 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);
+  }
+  // ==================== Dashboard Component Methods ====================
+  // These methods delegate to dash-comp service for component selection
+  /**
+   * Request a dashboard component based on user prompt
+   * Uses LLM to pick the best component and generate props
+   * Supports both database queries and external tools as data sources
+   * Delegates to dash-comp service
+   *
+   * @example
+   * ```typescript
+   * const response = await client.sendDashCompRequest({
+   *   prompt: "Show me a bar chart of sales by category",
+   *   threadId: "thread-123",
+   * });
+   *
+   * if (response.success && response.component) {
+   *   console.log('Component:', response.component.name);
+   *   console.log('Props:', response.component.props);
+   *   console.log('Data source:', response.dataSource);
+   * }
+   * ```
+   */
+  async sendDashCompRequest(options) {
+    this.log("info", "Sending dash comp request for prompt:", options.prompt.substring(0, 50) + "...");
+    return sendDashCompRequest(this, options);
+  }
+  // ==================== Menu Management Methods ====================
+  // These methods delegate to menus service for menu CRUD operations
+  /**
+   * Create a new menu
+   * Delegates to menus service
+   */
+  async createMenu(options, timeout) {
+    this.log("info", "Creating menu:", options.name);
+    return createMenu(this, options, timeout);
+  }
+  /**
+   * Update an existing menu
+   * Delegates to menus service
+   */
+  async updateMenu(options, timeout) {
+    this.log("info", "Updating menu:", options.id);
+    return updateMenu(this, options, timeout);
+  }
+  /**
+   * Delete a menu
+   * Delegates to menus service
+   */
+  async deleteMenu(id, timeout) {
+    this.log("info", "Deleting menu:", id);
+    return deleteMenu(this, id, timeout);
+  }
+  /**
+   * Get all menus
+   * Delegates to menus service
+   */
+  async getAllMenus(timeout) {
+    this.log("info", "Fetching all menus");
+    return getAllMenus(this, timeout);
+  }
+  /**
+   * Get a specific menu by ID
+   * Delegates to menus service
+   */
+  async getMenu(id, timeout) {
+    this.log("info", "Fetching menu:", id);
+    return getMenu(this, id, timeout);
+  }
+  /**
+   * Get root menus (top-level sidebar items)
+   * Delegates to menus service
+   */
+  async getRootMenus(timeout) {
+    this.log("info", "Fetching root menus");
+    return getRootMenus(this, timeout);
+  }
+  /**
+   * Get child menus by parent ID
+   * Delegates to menus service
+   */
+  async getChildMenus(parentId, timeout) {
+    this.log("info", "Fetching child menus for parent:", parentId);
+    return getChildMenus(this, parentId, timeout);
+  }
+  /**
+   * Get menus with hierarchy (nested structure)
+   * Delegates to menus service
+   */
+  async getMenusHierarchy(timeout) {
+    this.log("info", "Fetching menus hierarchy");
+    return getMenusHierarchy(this, timeout);
+  }
+  /**
+   * Query menus with filters
+   * Delegates to menus service
+   */
+  async queryMenus(options, timeout) {
+    this.log("info", "Querying menus with filters:", options?.filters);
+    return queryMenus(this, options, timeout);
+  }
+  /**
+   * Reorder menus
+   * Delegates to menus service
+   */
+  async reorderMenus(items, timeout) {
+    this.log("info", "Reordering", items.length, "menus");
+    return reorderMenus(this, items, timeout);
+  }
+  // ==================== Schema Methods ====================
+  /**
+   * Get the database schema
+   * Retrieves the schema.json containing table definitions, columns, and relationships
+   */
+  async getSchema(options) {
+    this.log("info", "Fetching database schema");
+    return getSchema(this, options);
+  }
+  /**
+   * Internal logging
+   */
+  log(level, ...args) {
+    if (!this.config.debug && level === "debug") {
+      return;
+    }
+    console[level]("[SuperAtom]", ...args);
+  }
+};
+
+// src/setup.ts
+function setup(components) {
+  if (typeof window === "undefined") {
+    throw new Error("setup() can only be called in a browser environment");
+  }
+  window.SUPERATOM = window.SUPERATOM || {};
+  window.SA = window.SUPERATOM;
+  window.SUPERATOM.COMPONENTS = components;
+  if (window.SUPERATOM.runtime?.componentsLoaded) {
+    window.SUPERATOM.runtime.componentsLoaded();
+  }
+}
+function getComponents() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window.SUPERATOM?.COMPONENTS;
+}
+function getComponent(name) {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window.SUPERATOM?.COMPONENTS?.[name];
+}
+function hasComponents() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return !!window.SUPERATOM?.COMPONENTS;
+}
+
+// src/index.ts
+var SDK_VERSION = "0.1.0";
+
+exports.ActionsRequestMessageSchema = ActionsRequestMessageSchema;
+exports.ActionsRequestPayloadSchema = ActionsRequestPayloadSchema;
+exports.ActionsResponseMessageSchema = ActionsResponseMessageSchema;
+exports.ActionsResponsePayloadSchema = ActionsResponsePayloadSchema;
+exports.AuthLoginPayloadSchema = AuthLoginPayloadSchema;
+exports.AuthLoginRequestMessageSchema = AuthLoginRequestMessageSchema;
+exports.AuthLoginResponseMessageSchema = AuthLoginResponseMessageSchema;
+exports.AuthLoginResponsePayloadSchema = AuthLoginResponsePayloadSchema;
+exports.AuthVerifyPayloadSchema = AuthVerifyPayloadSchema;
+exports.AuthVerifyRequestMessageSchema = AuthVerifyRequestMessageSchema;
+exports.AuthVerifyResponseMessageSchema = AuthVerifyResponseMessageSchema;
+exports.AuthVerifyResponsePayloadSchema = AuthVerifyResponsePayloadSchema;
+exports.BundleChunkMessageSchema = BundleChunkMessageSchema;
+exports.BundleChunkPayloadSchema = BundleChunkPayloadSchema;
+exports.BundleErrorMessageSchema = BundleErrorMessageSchema;
+exports.BundleErrorPayloadSchema = BundleErrorPayloadSchema;
+exports.BundleRequestMessageSchema = BundleRequestMessageSchema;
+exports.BundleRequestPayloadSchema = BundleRequestPayloadSchema;
+exports.ClientConfigSchema = ClientConfigSchema;
+exports.ComponentSchema = ComponentSchema;
+exports.ComponentsSendMessageSchema = ComponentsSendMessageSchema;
+exports.ComponentsSendPayloadSchema = ComponentsSendPayloadSchema;
+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.MenuDataSchema = MenuDataSchema;
+exports.MenuQueryFiltersSchema = MenuQueryFiltersSchema;
+exports.MenusRequestMessageSchema = MenusRequestMessageSchema;
+exports.MenusRequestPayloadSchema = MenusRequestPayloadSchema;
+exports.MenusResponseMessageSchema = MenusResponseMessageSchema;
+exports.MenusResponsePayloadSchema = MenusResponsePayloadSchema;
+exports.MessageParticipantSchema = MessageParticipantSchema;
+exports.MessageSchema = MessageSchema;
+exports.SDK_VERSION = SDK_VERSION;
+exports.SuperatomClient = SuperatomClient;
+exports.UILogEntrySchema = UILogEntrySchema;
+exports.UILogsMessageSchema = UILogsMessageSchema;
+exports.UILogsPayloadSchema = UILogsPayloadSchema;
+exports.UserPromptRequestMessageSchema = UserPromptRequestMessageSchema;
+exports.UserPromptRequestPayloadSchema = UserPromptRequestPayloadSchema;
+exports.UserPromptResponseMessageSchema = UserPromptResponseMessageSchema;
+exports.UserPromptResponsePayloadSchema = UserPromptResponsePayloadSchema;
+exports.UserPromptSuggestionsRequestMessageSchema = UserPromptSuggestionsRequestMessageSchema;
+exports.UserPromptSuggestionsRequestPayloadSchema = UserPromptSuggestionsRequestPayloadSchema;
+exports.UserPromptSuggestionsResponseMessageSchema = UserPromptSuggestionsResponseMessageSchema;
+exports.UserPromptSuggestionsResponsePayloadSchema = UserPromptSuggestionsResponsePayloadSchema;
+exports.getComponent = getComponent;
+exports.getComponents = getComponents;
+exports.hasComponents = hasComponents;
+exports.services = services_exports;
+exports.setup = setup;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map