zapry-openclaw-plugin 0.0.1

package/src/api-client.ts

@@ -0,0 +1,357 @@
+import type {
+  ZapryApiResponse,
+  SetMyProfilePayload,
+  SetMyProfileResponse,
+  FeedListResponse,
+  CreatePostResponse,
+  ChatHistoryResponse,
+} from "./types.js";
+
+type SetMySoulPayload = {
+  soulMd: string;
+  version?: string;
+  source?: string;
+  agentKey?: string;
+};
+
+type SetMySkillsPayload = {
+  skills: Array<Record<string, unknown>>;
+  version?: string;
+  source?: string;
+  agentKey?: string;
+};
+
+export class ZapryApiClient {
+  constructor(
+    private baseUrl: string,
+    private botToken: string,
+    private options?: {
+      defaultHeaders?: Record<string, string>;
+    },
+  ) {}
+
+  private buildHeaders(extraHeaders?: Record<string, string>): Record<string, string> {
+    return {
+      ...(this.options?.defaultHeaders ?? {}),
+      ...(extraHeaders ?? {}),
+    };
+  }
+
+  getRequestHeaders(extraHeaders?: Record<string, string>): Record<string, string> {
+    return this.buildHeaders(extraHeaders);
+  }
+
+  private async request<T = unknown>(opts: {
+    methodPath: string;
+    method: "GET" | "POST";
+    body?: Record<string, unknown>;
+  }): Promise<ZapryApiResponse<T>> {
+    const { methodPath, method, body } = opts;
+    const url = `${this.baseUrl}/${this.botToken}/${methodPath}`;
+    const resp = await fetch(url, {
+      method,
+      headers: this.buildHeaders({ "Content-Type": "application/json" }),
+      body: method === "POST" ? JSON.stringify(body ?? {}) : undefined,
+    });
+    if (!resp.ok) {
+      let errorBody = "";
+      try { errorBody = await resp.text(); } catch {}
+      const errorJson = (() => { try { return JSON.parse(errorBody); } catch { return null; } })();
+      const desc = errorJson?.description ?? errorBody.slice(0, 200) ?? resp.statusText;
+      return {
+        ok: false,
+        error_code: resp.status,
+        description: `HTTP ${resp.status} ${resp.statusText}${desc ? ` — ${desc}` : ""}`,
+      };
+    }
+    return (await resp.json()) as ZapryApiResponse<T>;
+  }
+
+  private async post<T = unknown>(
+    methodPath: string,
+    body?: Record<string, unknown>,
+  ): Promise<ZapryApiResponse<T>> {
+    return this.request({ methodPath, method: "POST", body });
+  }
+
+  private async get<T = unknown>(methodPath: string): Promise<ZapryApiResponse<T>> {
+    return this.request({ methodPath, method: "GET" });
+  }
+
+  // ── Messaging ──
+
+  async sendMessage(
+    chatId: string,
+    text: string,
+    opts?: {
+      replyToMessageId?: string;
+      messageThreadId?: string;
+      replyMarkup?: unknown;
+    },
+  ) {
+    return this.post("sendMessage", {
+      chat_id: chatId,
+      text,
+      reply_to_message_id: opts?.replyToMessageId,
+      message_thread_id: opts?.messageThreadId,
+      reply_markup: opts?.replyMarkup,
+    });
+  }
+
+  async sendPhoto(chatId: string, photo: string) {
+    return this.post("sendPhoto", { chat_id: chatId, photo });
+  }
+
+  async sendVideo(chatId: string, video: string) {
+    return this.post("sendVideo", { chat_id: chatId, video });
+  }
+
+  async sendDocument(chatId: string, document: string) {
+    return this.post("sendDocument", { chat_id: chatId, document });
+  }
+
+  async sendAudio(chatId: string, audio: string) {
+    return this.post("sendAudio", { chat_id: chatId, audio });
+  }
+
+  async sendVoice(chatId: string, voice: string) {
+    return this.post("sendVoice", { chat_id: chatId, voice });
+  }
+
+  async sendAnimation(chatId: string, animation: string) {
+    return this.post("sendAnimation", { chat_id: chatId, animation });
+  }
+
+  async sendChatAction(chatId: string, action: string) {
+    return this.post("sendChatAction", { chat_id: chatId, action });
+  }
+
+  async deleteMessage(chatId: string, messageId: string) {
+    return this.post("deleteMessage", { chat_id: chatId, message_id: messageId });
+  }
+
+  async answerCallbackQuery(
+    chatId: string,
+    callbackQueryId: string,
+    opts?: {
+      text?: string;
+      showAlert?: boolean;
+    },
+  ) {
+    return this.post("answerCallbackQuery", {
+      chat_id: chatId,
+      callback_query_id: callbackQueryId,
+      text: opts?.text,
+      show_alert: opts?.showAlert,
+    });
+  }
+
+  // ── Receive / Webhook ──
+
+  async getUpdates(offset?: number, limit?: number, timeout?: number) {
+    return this.post("getUpdates", { offset, limit, timeout });
+  }
+
+  async getFile(fileId: string) {
+    return this.post("getFile", { file_id: fileId });
+  }
+
+  async setWebhook(url: string) {
+    return this.post("setWebhook", { url });
+  }
+
+  async getWebhookInfo() {
+    return this.post("getWebhookInfo");
+  }
+
+  async deleteWebhook() {
+    return this.post("deleteWebhook");
+  }
+
+  // ── Skills ──
+
+  async setMySoul(payload: SetMySoulPayload) {
+    return this.post("setMySoul", payload);
+  }
+
+  async getMySoul() {
+    return this.get("getMySoul");
+  }
+
+  async setMySkills(payload: SetMySkillsPayload) {
+    return this.post("setMySkills", payload);
+  }
+
+  async getMySkills() {
+    return this.get("getMySkills");
+  }
+
+  async getMyProfile() {
+    return this.post("getMyProfile");
+  }
+
+  async setMyProfile(payload: SetMyProfilePayload): Promise<ZapryApiResponse<SetMyProfileResponse>> {
+    return this.post("setMyProfile", payload as unknown as Record<string, unknown>);
+  }
+
+  // ── Group Query & Moderation ──
+
+  async getMyGroups(page?: number, pageSize?: number) {
+    return this.post("getMyGroups", { page, page_size: pageSize });
+  }
+
+  async getMyChats(page?: number, pageSize?: number) {
+    return this.post("getMyChats", { page, page_size: pageSize });
+  }
+
+  async getChatMember(chatId: string, userId: string) {
+    return this.post("getChatMember", { chat_id: chatId, user_id: userId });
+  }
+
+  async getChatMembers(chatId: string, opts?: { page?: number; pageSize?: number; keyword?: string }) {
+    return this.post("getChatMembers", {
+      chat_id: chatId,
+      page: opts?.page,
+      page_size: opts?.pageSize,
+      keyword: opts?.keyword,
+    });
+  }
+
+  async getChatMemberCount(chatId: string) {
+    return this.post("getChatMemberCount", { chat_id: chatId });
+  }
+
+  async getChatHistory(chatId: string, limit?: number): Promise<ZapryApiResponse<ChatHistoryResponse>> {
+    return this.post("getChatHistory", { chat_id: chatId, limit: limit ?? 50 });
+  }
+
+  async getChatAdministrators(chatId: string) {
+    return this.post("getChatAdministrators", { chat_id: chatId });
+  }
+
+  async muteChatMember(chatId: string, userId: string, mute: boolean) {
+    return this.post("muteChatMember", { chat_id: chatId, user_id: userId, mute });
+  }
+
+  async kickChatMember(chatId: string, userId: string) {
+    return this.post("kickChatMember", { chat_id: chatId, user_id: userId });
+  }
+
+  async inviteChatMember(chatId: string, userId: string) {
+    return this.post("inviteChatMember", { chat_id: chatId, user_id: userId });
+  }
+
+  async setChatTitle(chatId: string, title: string) {
+    return this.post("setChatTitle", { chat_id: chatId, title });
+  }
+
+  async setChatDescription(chatId: string, description: string) {
+    return this.post("setChatDescription", { chat_id: chatId, description });
+  }
+
+  // ── Agent Self Management ──
+
+  async getMe() {
+    return this.get("getMe");
+  }
+
+  async getUserProfilePhotos(userId?: string) {
+    return this.post("getUserProfilePhotos", { user_id: userId });
+  }
+
+  async setMyWalletAddress(walletAddress: string) {
+    return this.post("setMyWalletAddress", { wallet_address: walletAddress });
+  }
+
+  async setMyFriendVerify(needVerify: boolean) {
+    return this.post("setMyFriendVerify", { need_verify: needVerify });
+  }
+
+  async getMyContacts(page?: number, pageSize?: number) {
+    return this.post("getMyContacts", { page, page_size: pageSize });
+  }
+
+  async getMyFriendRequests(pendingOnly?: boolean) {
+    return this.post("getMyFriendRequests", { pending_only: pendingOnly });
+  }
+
+  async acceptFriendRequest(userId: string) {
+    return this.post("acceptFriendRequest", { user_id: userId });
+  }
+
+  async rejectFriendRequest(userId: string) {
+    return this.post("rejectFriendRequest", { user_id: userId });
+  }
+
+  async addFriend(userId: string, message?: string, remark?: string) {
+    return this.post("addFriend", { user_id: userId, message, remark });
+  }
+
+  async deleteFriend(userId: string) {
+    return this.post("deleteFriend", { user_id: userId });
+  }
+
+  async setMyName(name: string) {
+    return this.post("setMyName", { name });
+  }
+
+  async setMyDescription(description: string) {
+    return this.post("setMyDescription", { description });
+  }
+
+  // ── Feed ──
+
+  async getTrendingPosts(page?: number, pageSize?: number): Promise<ZapryApiResponse<FeedListResponse>> {
+    return this.post("getTrendingPosts", { page, page_size: pageSize });
+  }
+
+  async getLatestPosts(page?: number, pageSize?: number): Promise<ZapryApiResponse<FeedListResponse>> {
+    return this.post("getLatestPosts", { page, page_size: pageSize });
+  }
+
+  async getMyPosts(page?: number, pageSize?: number): Promise<ZapryApiResponse<FeedListResponse>> {
+    return this.post("getMyPosts", { page, page_size: pageSize });
+  }
+
+  async searchPosts(keyword: string, page?: number, pageSize?: number): Promise<ZapryApiResponse<FeedListResponse>> {
+    return this.post("searchPosts", { keyword, page, page_size: pageSize });
+  }
+
+  async createPost(content: string, images?: string[]): Promise<ZapryApiResponse<CreatePostResponse>> {
+    return this.post("createPost", { content, images });
+  }
+
+  async deletePost(dynamicId: number) {
+    return this.post("deletePost", { dynamic_id: dynamicId });
+  }
+
+  async commentPost(dynamicId: number, content: string) {
+    return this.post("commentPost", { dynamic_id: dynamicId, content });
+  }
+
+  async likePost(dynamicId: number) {
+    return this.post("likePost", { dynamic_id: dynamicId });
+  }
+
+  async sharePost(dynamicId: number) {
+    return this.post("sharePost", { dynamic_id: dynamicId });
+  }
+
+  // ── Club ──
+
+  async getMyClubs(page?: number, pageSize?: number) {
+    return this.post("getMyClubs", { page, page_size: pageSize });
+  }
+
+  async createClub(name: string, desc?: string, avatar?: string) {
+    return this.post("createClub", { name, desc, avatar });
+  }
+
+  async updateClub(clubId: number, name?: string, desc?: string, avatar?: string) {
+    return this.post("updateClub", { club_id: clubId, name, desc, avatar });
+  }
+
+  async setMyPresence(online: boolean) {
+    return this.post("setMyPresence", { online });
+  }
+}

package/src/channel.ts

@@ -0,0 +1,268 @@
+import {
+  listZapryAccountIds,
+  resolveDefaultZapryAccountId,
+  resolveZapryAccount,
+} from "./config.js";
+import { sendMessageZapry } from "./send.js";
+import { monitorZapryProvider } from "./monitor.js";
+import { ZapryApiClient } from "./api-client.js";
+import { DEFAULT_ACCOUNT_ID } from "./types.js";
+import type { ResolvedZapryAccount } from "./types.js";
+import { syncProfileToZapry } from "./profile-sync.js";
+
+const IS_STANDARD_CHAT_ID = /^[gup]_\d+$/;
+
+async function resolveOutboundTarget(account: ResolvedZapryAccount, to: string): Promise<string> {
+  const trimmed = to.trim();
+  if (IS_STANDARD_CHAT_ID.test(trimmed) || trimmed.startsWith("chat:") || /^\d+$/.test(trimmed)) {
+    return trimmed;
+  }
+  try {
+    const client = new ZapryApiClient(account.config.apiBaseUrl, account.botToken);
+    const resp = await client.getMyGroups(1, 100);
+    if (!resp.ok) return trimmed;
+    const raw = (resp as any).result;
+    const groups: any[] = Array.isArray(raw) ? raw : raw?.items ?? raw?.groups ?? [];
+    for (const g of groups) {
+      const info = g.info ?? g;
+      const gName = info.group_name ?? info.name ?? info.title ?? "";
+      const gId = info.chat_id ?? info.group_id ?? info.id ?? "";
+      if (String(gName) === trimmed && gId) return String(gId);
+    }
+    for (const g of groups) {
+      const info = g.info ?? g;
+      const gName = String(info.group_name ?? info.name ?? info.title ?? "");
+      const gId = info.chat_id ?? info.group_id ?? info.id ?? "";
+      if (gName.includes(trimmed) && gId) return String(gId);
+    }
+  } catch {}
+  return trimmed;
+}
+
+export const zapryPlugin = {
+  id: "zapry",
+  meta: {
+    id: "zapry",
+    name: "Zapry",
+    emoji: "⚡",
+    description: "Zapry social platform — messaging, groups, feed, clubs",
+  },
+
+  capabilities: {
+    chatTypes: ["direct", "channel", "group"] as const,
+    polls: false,
+    reactions: false,
+    threads: false,
+    media: true,
+    nativeCommands: true,
+  },
+
+  streaming: {
+    blockStreamingCoalesceDefaults: { minChars: 1000, idleMs: 800 },
+  },
+
+  reload: { configPrefixes: ["channels.zapry"] },
+
+  config: {
+    listAccountIds: (cfg: any) => listZapryAccountIds(cfg),
+    resolveAccount: (cfg: any, accountId?: string) => resolveZapryAccount(cfg, accountId),
+    defaultAccountId: (cfg: any) => resolveDefaultZapryAccountId(cfg),
+    setAccountEnabled: ({ cfg, accountId, enabled }: any) => {
+      const next = structuredClone(cfg);
+      const zapry = next.channels?.zapry;
+      if (!zapry) return next;
+      if (zapry.accounts?.[accountId]) {
+        zapry.accounts[accountId].enabled = enabled;
+      } else if (accountId === DEFAULT_ACCOUNT_ID) {
+        zapry.enabled = enabled;
+      }
+      return next;
+    },
+    deleteAccount: ({ cfg, accountId }: any) => {
+      const next = structuredClone(cfg);
+      const zapry = next.channels?.zapry;
+      if (!zapry) return next;
+      if (zapry.accounts?.[accountId]) {
+        delete zapry.accounts[accountId];
+      }
+      return next;
+    },
+    isConfigured: (account: any) => Boolean(account.botToken?.trim()),
+    describeAccount: (account: any) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: Boolean(account.botToken?.trim()),
+      tokenSource: account.tokenSource,
+    }),
+  },
+
+  security: {
+    resolveDmPolicy: ({ account }: any) => ({
+      policy: account.config.dm?.policy ?? "open",
+      allowFrom: account.config.dm?.allowFrom ?? [],
+      allowFromPath: `channels.zapry.dm.`,
+    }),
+  },
+
+  messaging: {
+    normalizeTarget: (to: string) => to.replace(/^(chat|zapry):/i, "").trim(),
+    targetResolver: {
+      looksLikeId: (input: string) => /^(g_)?\d+$/.test(input.replace(/^(chat|zapry):/i, "").trim()),
+      hint: "<chatId|chat:ID>",
+    },
+  },
+
+  agentPrompt: {
+    messageToolHints: () => [
+      `For ALL Zapry operations, prefer "zapry_action" tool. ` +
+      `To send text messages: use "zapry_action" action="send-message" with chat_id and text — supports group names (auto-resolved). ` +
+      `To send photos: use "zapry_action" action="send-photo" with "prompt" parameter to auto-generate images (e.g. prompt="cute cat"). ` +
+      `To send video/audio/document: use "zapry_action" with send-video/send-audio/send-document. ` +
+      `IMPORTANT: Do NOT use "message" tool for Zapry group chats — it cannot resolve group names. Always use zapry_action instead. ` +
+      `To publish to feed (广场), use "zapry_post" with content and optional images.`,
+    ],
+  },
+
+  actions: {
+    listActions: () => [
+      "send",
+    ],
+    extractToolSend: (ctx: any) => {
+      if (ctx.action === "send" || ctx.action === "send-message") {
+        const result: Record<string, any> = {
+          to: ctx.params?.to ?? ctx.params?.chatId ?? ctx.params?.chat_id,
+          text: ctx.params?.message ?? ctx.params?.text,
+        };
+        const mediaUrl =
+          ctx.params?.photo ?? ctx.params?.video ?? ctx.params?.animation ??
+          ctx.params?.document ?? ctx.params?.audio ?? ctx.params?.voice ??
+          ctx.params?.mediaUrl ?? ctx.params?.media_url ?? ctx.params?.media;
+        if (mediaUrl) result.mediaUrl = mediaUrl;
+        return result;
+      }
+      return null;
+    },
+  },
+
+  outbound: {
+    deliveryMode: "direct" as const,
+    chunker: null,
+    textChunkLimit: 4096,
+    resolveTarget: ({ to }: { to: string }) => to.replace(/^(chat|zapry):/i, "").trim(),
+    sendText: async ({ to, text, accountId, deps, replyToId }: any) => {
+      const cfg = deps?.cfg;
+      const account = resolveZapryAccount(cfg, accountId);
+      const resolvedTo = await resolveOutboundTarget(account, to);
+      const result = await sendMessageZapry(account, resolvedTo, text, { replyTo: replyToId });
+      return { channel: "zapry", ...result };
+    },
+    sendMedia: async ({ to, text, mediaUrl, accountId, deps, replyToId }: any) => {
+      const cfg = deps?.cfg;
+      const account = resolveZapryAccount(cfg, accountId);
+      const resolvedTo = await resolveOutboundTarget(account, to);
+      const result = await sendMessageZapry(account, resolvedTo, text || "", { mediaUrl, replyTo: replyToId });
+      return { channel: "zapry", ...result };
+    },
+  },
+
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+      lastInboundAt: null,
+      lastOutboundAt: null,
+    },
+    probeAccount: async ({ account, timeoutMs }: any) => {
+      try {
+        const client = new ZapryApiClient(account.config.apiBaseUrl, account.botToken);
+        const resp = await client.getMe();
+        if (!resp.ok) {
+          return {
+            ok: false,
+            errorCode: resp.error_code,
+            error: resp.description ?? "getMe failed",
+          };
+        }
+        return { ok: true, bot: resp.result };
+      } catch (err) {
+        return { ok: false, error: String(err) };
+      }
+    },
+    buildAccountSnapshot: ({ account, runtime, probe }: any) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: Boolean(account.botToken?.trim()),
+      tokenSource: account.tokenSource,
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      lastInboundAt: runtime?.lastInboundAt ?? null,
+      lastOutboundAt: runtime?.lastOutboundAt ?? null,
+      probe,
+    }),
+  },
+
+  gateway: {
+    startAccount: async (ctx: any) => {
+      const { account } = ctx;
+      ctx.log?.info(`[${account.accountId}] starting Zapry provider (${account.config.mode} mode)`);
+
+      const client = new ZapryApiClient(account.config.apiBaseUrl, account.botToken);
+
+      try {
+        const probe = await client.getMe();
+        if (probe.ok) {
+          const bot = probe.result as any;
+          ctx.log?.info(`[${account.accountId}] bot: ${bot?.name ?? bot?.username ?? "unknown"}`);
+          ctx.setStatus?.({ accountId: account.accountId, bot });
+        } else {
+          ctx.log?.warn(
+            `[${account.accountId}] getMe probe failed: ` +
+              `${probe.error_code ?? "unknown"}:${probe.description ?? "unknown"}`,
+          );
+        }
+      } catch {
+        // probe is best-effort
+      }
+
+      client.setMyPresence(true).catch(() => {});
+      ctx.log?.info(`[${account.accountId}] presence set to online`);
+
+      const projectRoot =
+        ctx.runtime?.projectRoot ?? ctx.runtime?.config?.projectRoot ?? process.cwd();
+      syncProfileToZapry(account, { projectRoot, log: ctx.log }).catch((err) => {
+        ctx.log?.warn?.(
+          `[${account.accountId}] profile sync failed: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      });
+
+      ctx.abortSignal?.addEventListener("abort", () => {
+        client.setMyPresence(false).catch(() => {});
+        ctx.log?.info(`[${account.accountId}] presence set to offline`);
+      });
+
+      const effectiveRuntime = ctx.channelRuntime
+        ? { ...ctx.runtime, channel: ctx.channelRuntime }
+        : ctx.runtime;
+
+      return monitorZapryProvider({
+        account,
+        cfg: ctx.cfg,
+        runtime: effectiveRuntime,
+        abortSignal: ctx.abortSignal,
+        statusSink: (patch) => {
+          if (typeof ctx.setStatus === "function") {
+            ctx.setStatus({ accountId: ctx.accountId, ...patch });
+          }
+        },
+        log: ctx.log,
+      });
+    },
+  },
+};

package/src/config.ts

@@ -0,0 +1,68 @@
+import {
+  DEFAULT_ACCOUNT_ID,
+  DEFAULT_API_BASE_URL,
+  type ResolvedZapryAccount,
+  type ZapryChannelConfig,
+} from "./types.js";
+
+function getZapryConfig(cfg: any): ZapryChannelConfig | undefined {
+  return cfg?.channels?.zapry;
+}
+
+export function listZapryAccountIds(cfg: any): string[] {
+  const zapry = getZapryConfig(cfg);
+  if (!zapry) return [];
+  if (zapry.accounts && Object.keys(zapry.accounts).length > 0) {
+    return Object.keys(zapry.accounts);
+  }
+  if (zapry.botToken) return [DEFAULT_ACCOUNT_ID];
+  const envToken = process.env.ZAPRY_BOT_TOKEN;
+  if (envToken) return [DEFAULT_ACCOUNT_ID];
+  return [];
+}
+
+export function resolveZapryAccount(
+  cfg: any,
+  accountId?: string,
+): ResolvedZapryAccount {
+  const zapry = getZapryConfig(cfg) ?? {};
+  const resolvedId = accountId ?? DEFAULT_ACCOUNT_ID;
+
+  const acct = zapry.accounts?.[resolvedId];
+  if (acct) {
+    return {
+      accountId: resolvedId,
+      name: acct.name,
+      enabled: acct.enabled !== false,
+      botToken: acct.botToken ?? "",
+      tokenSource: "config",
+      config: {
+        apiBaseUrl: acct.apiBaseUrl ?? zapry.apiBaseUrl ?? DEFAULT_API_BASE_URL,
+        mode: acct.mode ?? zapry.mode ?? "polling",
+        webhookUrl: acct.webhookUrl ?? zapry.webhookUrl,
+        dm: acct.dm ?? zapry.dm,
+      },
+    };
+  }
+
+  const envToken = process.env.ZAPRY_BOT_TOKEN;
+  const token = zapry.botToken ?? envToken ?? "";
+  return {
+    accountId: resolvedId,
+    name: undefined,
+    enabled: zapry.enabled !== false,
+    botToken: token,
+    tokenSource: zapry.botToken ? "config" : "env",
+    config: {
+      apiBaseUrl: zapry.apiBaseUrl ?? DEFAULT_API_BASE_URL,
+      mode: zapry.mode ?? "polling",
+      webhookUrl: zapry.webhookUrl,
+      dm: zapry.dm,
+    },
+  };
+}
+
+export function resolveDefaultZapryAccountId(cfg: any): string {
+  const ids = listZapryAccountIds(cfg);
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}