@omnizap-system/omnizap 2.6.1 → 2.6.2

package/app/services/multiSession/groupOwnershipService.test.js

@@ -0,0 +1,309 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createGroupOwnershipService } from './groupOwnershipService.js';
+import { closePool } from '../../../database/index.js';
+
+const cloneDate = (value) => (value instanceof Date ? new Date(value.getTime()) : null);
+
+const createInMemoryRepository = () => {
+  const assignments = new Map();
+  const history = [];
+
+  const normalizeGroupJid = (value) => {
+    const normalized = String(value || '').trim().slice(0, 255);
+    return normalized || null;
+  };
+  const normalizeSessionId = (value) => {
+    const normalized = String(value || '').trim().slice(0, 64);
+    return normalized || null;
+  };
+  const normalizeReason = (value) => {
+    const normalized = String(value || '').trim().slice(0, 64);
+    return normalized || null;
+  };
+  const normalizeChangedBy = (value) => {
+    const normalized = String(value || 'system').trim().slice(0, 64);
+    return normalized || 'system';
+  };
+
+  const cloneAssignment = (row) => {
+    if (!row) return null;
+    return {
+      groupJid: row.groupJid,
+      ownerSessionId: row.ownerSessionId,
+      leaseExpiresAt: cloneDate(row.leaseExpiresAt),
+      cooldownUntil: cloneDate(row.cooldownUntil),
+      assignmentVersion: Number(row.assignmentVersion || 1),
+      pinned: row.pinned === true,
+      lastReason: row.lastReason || null,
+      createdAt: cloneDate(row.createdAt),
+      updatedAt: cloneDate(row.updatedAt),
+    };
+  };
+
+  const upsertAssignment = (assignment) => {
+    const now = new Date();
+    const current = assignments.get(assignment.groupJid);
+    const next = {
+      groupJid: assignment.groupJid,
+      ownerSessionId: assignment.ownerSessionId,
+      leaseExpiresAt: cloneDate(assignment.leaseExpiresAt),
+      cooldownUntil: cloneDate(assignment.cooldownUntil),
+      assignmentVersion: Number(assignment.assignmentVersion || 1),
+      pinned: assignment.pinned === true,
+      lastReason: assignment.lastReason || null,
+      createdAt: current?.createdAt ? cloneDate(current.createdAt) : now,
+      updatedAt: now,
+    };
+    assignments.set(next.groupJid, next);
+    return cloneAssignment(next);
+  };
+
+  return {
+    normalizeGroupJid,
+    normalizeSessionId,
+    normalizeReason,
+    normalizeChangedBy,
+    getAssignment: async (groupJid) => cloneAssignment(assignments.get(normalizeGroupJid(groupJid))),
+    getAssignmentForUpdate: async (groupJid) => cloneAssignment(assignments.get(normalizeGroupJid(groupJid))),
+    listAssignments: async ({ groupJid = null, ownerSessionId = null, includeExpired = true, limit = 200 } = {}) => {
+      const safeGroupJid = normalizeGroupJid(groupJid);
+      const safeOwnerSessionId = normalizeSessionId(ownerSessionId);
+      const nowMs = Date.now();
+      const rows = Array.from(assignments.values())
+        .filter((row) => (safeGroupJid ? row.groupJid === safeGroupJid : true))
+        .filter((row) => (safeOwnerSessionId ? row.ownerSessionId === safeOwnerSessionId : true))
+        .filter((row) => (includeExpired ? true : row.leaseExpiresAt?.getTime?.() > nowMs))
+        .slice(0, Math.max(1, Number(limit || 200)));
+      return rows.map((row) => cloneAssignment(row));
+    },
+    createAssignment: async ({ groupJid, ownerSessionId, leaseExpiresAt, cooldownUntil = null, pinned = false, reason = null, assignmentVersion = 1 } = {}) => {
+      const safeGroupJid = normalizeGroupJid(groupJid);
+      if (!safeGroupJid) {
+        throw new Error('groupJid invalido');
+      }
+      if (assignments.has(safeGroupJid)) {
+        const error = new Error('duplicate');
+        error.code = 'ER_DUP_ENTRY';
+        throw error;
+      }
+      return upsertAssignment({
+        groupJid: safeGroupJid,
+        ownerSessionId: normalizeSessionId(ownerSessionId),
+        leaseExpiresAt: cloneDate(leaseExpiresAt),
+        cooldownUntil: cloneDate(cooldownUntil),
+        assignmentVersion: Number(assignmentVersion || 1),
+        pinned: pinned === true,
+        lastReason: normalizeReason(reason),
+      });
+    },
+    updateAssignmentOwner: async ({ groupJid, ownerSessionId, leaseExpiresAt, reason = null, bumpVersion = true, cooldownUntil = undefined, pinned = undefined } = {}) => {
+      const safeGroupJid = normalizeGroupJid(groupJid);
+      const current = assignments.get(safeGroupJid);
+      if (!current) return null;
+      return upsertAssignment({
+        ...current,
+        ownerSessionId: normalizeSessionId(ownerSessionId) || current.ownerSessionId,
+        leaseExpiresAt: cloneDate(leaseExpiresAt),
+        cooldownUntil: cooldownUntil === undefined ? current.cooldownUntil : cloneDate(cooldownUntil),
+        pinned: pinned === undefined ? current.pinned : pinned === true,
+        lastReason: normalizeReason(reason),
+        assignmentVersion: bumpVersion ? Number(current.assignmentVersion || 1) + 1 : Number(current.assignmentVersion || 1),
+      });
+    },
+    updateAssignmentLease: async ({ groupJid, ownerSessionId, leaseExpiresAt, reason = undefined } = {}) => {
+      const safeGroupJid = normalizeGroupJid(groupJid);
+      const current = assignments.get(safeGroupJid);
+      if (!current) return null;
+      if (current.ownerSessionId !== normalizeSessionId(ownerSessionId)) return cloneAssignment(current);
+      return upsertAssignment({
+        ...current,
+        leaseExpiresAt: cloneDate(leaseExpiresAt),
+        lastReason: reason === undefined ? current.lastReason : normalizeReason(reason),
+      });
+    },
+    expireAssignment: async ({ groupJid, ownerSessionId = null, reason = null, bumpVersion = true, leaseExpiresAt = new Date() } = {}) => {
+      const safeGroupJid = normalizeGroupJid(groupJid);
+      const current = assignments.get(safeGroupJid);
+      if (!current) return null;
+      const safeOwnerSessionId = normalizeSessionId(ownerSessionId);
+      if (safeOwnerSessionId && current.ownerSessionId !== safeOwnerSessionId) return cloneAssignment(current);
+      return upsertAssignment({
+        ...current,
+        leaseExpiresAt: cloneDate(leaseExpiresAt),
+        lastReason: normalizeReason(reason),
+        assignmentVersion: bumpVersion ? Number(current.assignmentVersion || 1) + 1 : Number(current.assignmentVersion || 1),
+      });
+    },
+    renewLeasesByOwner: async ({ ownerSessionId, leaseExpiresAt, reason = null, now = undefined } = {}) => {
+      const safeOwnerSessionId = normalizeSessionId(ownerSessionId);
+      const safeNow = now instanceof Date ? now.getTime() : Date.now();
+      let renewed = 0;
+      for (const current of assignments.values()) {
+        if (current.ownerSessionId !== safeOwnerSessionId) continue;
+        if ((current.leaseExpiresAt?.getTime?.() || 0) <= safeNow) continue;
+        upsertAssignment({
+          ...current,
+          leaseExpiresAt: cloneDate(leaseExpiresAt),
+          lastReason: normalizeReason(reason),
+        });
+        renewed += 1;
+      }
+      return renewed;
+    },
+    insertAssignmentHistory: async ({ groupJid, previousSessionId = null, newSessionId, changeReason = null, changedBy = 'system', assignmentVersion = 1, metadata = null } = {}) => {
+      history.push({
+        groupJid: normalizeGroupJid(groupJid),
+        previousSessionId: normalizeSessionId(previousSessionId),
+        newSessionId: normalizeSessionId(newSessionId),
+        changeReason: normalizeReason(changeReason),
+        changedBy: normalizeChangedBy(changedBy),
+        assignmentVersion: Number(assignmentVersion || 1),
+        metadata,
+      });
+      return { id: history.length };
+    },
+    __state: {
+      assignments,
+      history,
+    },
+  };
+};
+
+const createSessionRegistryMock = () => ({
+  ensureSession: async () => ({ ok: true }),
+  heartbeatSession: async () => ({ ok: true }),
+});
+
+const createService = ({ nowRef }) => {
+  const repository = createInMemoryRepository();
+  const sessionRegistry = createSessionRegistryMock();
+  const service = createGroupOwnershipService({
+    repository,
+    sessionRegistry,
+    withTransactionImpl: async (handler) => handler({}),
+    nowImpl: () => nowRef.value,
+    loggerImpl: { warn: () => {} },
+    cacheTtlMs: 1,
+  });
+  return { service, repository };
+};
+
+test.after(async () => {
+  await new Promise((resolve) => {
+    setTimeout(resolve, 200);
+  });
+  await closePool();
+});
+
+test('groupOwnershipService: claim concorrente no mesmo grupo resulta em owner unico', async () => {
+  const nowRef = { value: 1_000 };
+  const { service } = createService({ nowRef });
+
+  const [left, right] = await Promise.all([
+    service.tryAcquire({
+      groupJid: '120363222222222222@g.us',
+      sessionId: 'session-a',
+      reason: 'claim_a',
+    }),
+    service.tryAcquire({
+      groupJid: '120363222222222222@g.us',
+      sessionId: 'session-b',
+      reason: 'claim_b',
+    }),
+  ]);
+
+  const acquiredCount = [left, right].filter((item) => item?.acquired).length;
+  assert.equal(acquiredCount, 1);
+
+  const owner = await service.getOwner('120363222222222222@g.us', { bypassCache: true });
+  assert.ok(owner);
+  assert.equal(owner.assignmentVersion, 1);
+  assert.ok(owner.ownerSessionId === 'session-a' || owner.ownerSessionId === 'session-b');
+});
+
+test('groupOwnershipService: heartbeat renova lease e failover ocorre apos expirar', async () => {
+  const nowRef = { value: 10_000 };
+  const { service } = createService({ nowRef });
+  const groupJid = '120363333333333333@g.us';
+
+  const firstClaim = await service.tryAcquire({
+    groupJid,
+    sessionId: 'session-a',
+    leaseMs: 2_000,
+  });
+  assert.equal(firstClaim.acquired, true);
+  assert.equal(firstClaim.assignmentVersion, 1);
+
+  nowRef.value += 1_000;
+  const heartbeat = await service.heartbeatOwnerSession({
+    sessionId: 'session-a',
+    leaseMs: 2_000,
+    reason: 'test_heartbeat',
+  });
+  assert.ok(heartbeat.renewedAssignments >= 1);
+
+  nowRef.value = heartbeat.leaseExpiresAt.getTime() + 10;
+  const failover = await service.tryAcquire({
+    groupJid,
+    sessionId: 'session-b',
+    leaseMs: 2_000,
+    reason: 'failover_after_expiry',
+  });
+
+  assert.equal(failover.acquired, true);
+  assert.equal(failover.reason, 'reassigned');
+  assert.equal(failover.assignmentVersion, 2);
+
+  const owner = await service.getOwner(groupJid, { bypassCache: true });
+  assert.equal(owner?.ownerSessionId, 'session-b');
+  assert.equal(owner?.assignmentVersion, 2);
+});
+
+test('groupOwnershipService: fence token com assignment_version invalida sessao com token antigo', async () => {
+  const nowRef = { value: 50_000 };
+  const { service } = createService({ nowRef });
+  const groupJid = '120363444444444444@g.us';
+
+  const claimed = await service.tryAcquire({
+    groupJid,
+    sessionId: 'session-a',
+    leaseMs: 5_000,
+    reason: 'initial_claim',
+  });
+  assert.equal(claimed.acquired, true);
+  assert.equal(claimed.assignmentVersion, 1);
+
+  const tokenBefore = service.buildFencingToken({
+    groupJid,
+    ownerSessionId: 'session-a',
+    assignmentVersion: 1,
+  });
+  assert.equal(tokenBefore, `${groupJid}:session-a:1`);
+
+  const forced = await service.forceAssign({
+    groupJid,
+    sessionId: 'session-b',
+    reason: 'forced_failover',
+    changedBy: 'test',
+  });
+  assert.equal(forced.reassigned, true);
+  assert.equal(forced.assignmentVersion, 2);
+
+  const oldTokenValidation = await service.validateFenceToken({
+    groupJid,
+    sessionId: 'session-a',
+    assignmentVersion: 1,
+    bypassCache: true,
+  });
+  assert.equal(oldTokenValidation.valid, false);
+
+  const newTokenValidation = await service.validateFenceToken({
+    groupJid,
+    sessionId: 'session-b',
+    assignmentVersion: 2,
+    bypassCache: true,
+  });
+  assert.equal(newTokenValidation.valid, true);
+});

package/app/services/multiSession/sessionRegistryService.js

@@ -0,0 +1,293 @@
+import { executeQuery, TABLES } from '../../../database/index.js';
+import { normalizeSessionId } from './groupOwnershipRepository.js';
+
+const SESSION_REGISTRY_TABLE = TABLES.WA_SESSION_REGISTRY;
+const MAX_STATUS_LENGTH = 24;
+const MAX_BOT_JID_LENGTH = 255;
+const DEFAULT_STATUS = 'offline';
+const DEFAULT_WEIGHT = 1;
+
+const toDateOrNull = (value) => {
+  if (!value) return null;
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+};
+
+const toPositiveInt = (value, fallback = DEFAULT_WEIGHT, min = 1, max = 10_000) => {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(min, Math.min(max, parsed));
+};
+
+const toNumber = (value, fallback = 0) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+
+const normalizeStatus = (value, fallback = DEFAULT_STATUS) => {
+  const normalized = String(value || fallback)
+    .trim()
+    .toLowerCase()
+    .slice(0, MAX_STATUS_LENGTH);
+  return normalized || fallback;
+};
+
+const normalizeBotJid = (value) => {
+  if (value === undefined) return undefined;
+  if (value === null) return null;
+  const normalized = String(value)
+    .trim()
+    .toLowerCase()
+    .slice(0, MAX_BOT_JID_LENGTH);
+  return normalized || null;
+};
+
+const parseJson = (value) => {
+  if (!value) return null;
+  if (typeof value === 'object') return value;
+  try {
+    return JSON.parse(String(value));
+  } catch {
+    return null;
+  }
+};
+
+const serializeJson = (value) => {
+  if (value === undefined) return null;
+  if (value === null) return null;
+  if (typeof value === 'string') {
+    const normalized = value.trim();
+    return normalized || null;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+};
+
+const normalizeSessionRow = (row = null) => {
+  if (!row) return null;
+  return {
+    sessionId: normalizeSessionId(row.session_id),
+    botJid: normalizeBotJid(row.bot_jid) ?? null,
+    status: normalizeStatus(row.status, DEFAULT_STATUS),
+    capacityWeight: toPositiveInt(row.capacity_weight, DEFAULT_WEIGHT),
+    currentScore: toNumber(row.current_score, 0),
+    lastHeartbeatAt: toDateOrNull(row.last_heartbeat_at),
+    lastConnectedAt: toDateOrNull(row.last_connected_at),
+    lastDisconnectedAt: toDateOrNull(row.last_disconnected_at),
+    metadata: parseJson(row.metadata),
+    createdAt: toDateOrNull(row.created_at),
+    updatedAt: toDateOrNull(row.updated_at),
+  };
+};
+
+const SESSION_SELECT_COLUMNS = `session_id,
+  bot_jid,
+  status,
+  capacity_weight,
+  current_score,
+  last_heartbeat_at,
+  last_connected_at,
+  last_disconnected_at,
+  metadata,
+  created_at,
+  updated_at`;
+
+export const getSession = async (sessionId, { connection = null } = {}) => {
+  const safeSessionId = normalizeSessionId(sessionId);
+  if (!safeSessionId) return null;
+
+  const rows = await executeQuery(
+    `SELECT ${SESSION_SELECT_COLUMNS}
+       FROM ${SESSION_REGISTRY_TABLE}
+      WHERE session_id = ?
+      LIMIT 1`,
+    [safeSessionId],
+    connection,
+  );
+
+  return normalizeSessionRow(rows?.[0] || null);
+};
+
+export const listSessions = async ({ status = null, limit = 100, connection = null } = {}) => {
+  const safeLimit = Math.max(1, Math.min(2_000, toPositiveInt(limit, 100, 1, 2_000)));
+  const safeStatus = status ? normalizeStatus(status, '') : '';
+
+  const params = [];
+  let where = '';
+  if (safeStatus) {
+    where = 'WHERE status = ?';
+    params.push(safeStatus);
+  }
+
+  const rows = await executeQuery(
+    `SELECT ${SESSION_SELECT_COLUMNS}
+       FROM ${SESSION_REGISTRY_TABLE}
+      ${where}
+      ORDER BY updated_at DESC
+      LIMIT ${safeLimit}`,
+    params,
+    connection,
+  );
+
+  return (Array.isArray(rows) ? rows : []).map((row) => normalizeSessionRow(row));
+};
+
+export const upsertSession = async (
+  {
+    sessionId,
+    botJid = undefined,
+    status = DEFAULT_STATUS,
+    capacityWeight = DEFAULT_WEIGHT,
+    currentScore = 0,
+    metadata = undefined,
+    heartbeatAt = undefined,
+    connectedAt = undefined,
+    disconnectedAt = undefined,
+  } = {},
+  { connection = null } = {},
+) => {
+  const safeSessionId = normalizeSessionId(sessionId);
+  if (!safeSessionId) {
+    throw new Error('upsertSession requer sessionId valido.');
+  }
+
+  const safeBotJid = normalizeBotJid(botJid);
+  const safeStatus = normalizeStatus(status, DEFAULT_STATUS);
+  const safeCapacityWeight = toPositiveInt(capacityWeight, DEFAULT_WEIGHT);
+  const safeCurrentScore = toNumber(currentScore, 0);
+  const safeMetadata = serializeJson(metadata);
+  const safeHeartbeatAt = heartbeatAt === undefined ? null : toDateOrNull(heartbeatAt);
+  const safeConnectedAt = connectedAt === undefined ? null : toDateOrNull(connectedAt);
+  const safeDisconnectedAt = disconnectedAt === undefined ? null : toDateOrNull(disconnectedAt);
+
+  await executeQuery(
+    `INSERT INTO ${SESSION_REGISTRY_TABLE}
+      (session_id, bot_jid, status, capacity_weight, current_score, last_heartbeat_at, last_connected_at, last_disconnected_at, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON DUPLICATE KEY UPDATE
+      bot_jid = COALESCE(VALUES(bot_jid), bot_jid),
+      status = VALUES(status),
+      capacity_weight = VALUES(capacity_weight),
+      current_score = VALUES(current_score),
+      last_heartbeat_at = COALESCE(VALUES(last_heartbeat_at), last_heartbeat_at),
+      last_connected_at = COALESCE(VALUES(last_connected_at), last_connected_at),
+      last_disconnected_at = COALESCE(VALUES(last_disconnected_at), last_disconnected_at),
+      metadata = COALESCE(VALUES(metadata), metadata),
+      updated_at = CURRENT_TIMESTAMP`,
+    [safeSessionId, safeBotJid, safeStatus, safeCapacityWeight, safeCurrentScore, safeHeartbeatAt, safeConnectedAt, safeDisconnectedAt, safeMetadata],
+    connection,
+  );
+
+  return getSession(safeSessionId, { connection });
+};
+
+export const ensureSession = async (
+  sessionId,
+  {
+    status = 'online',
+    capacityWeight = DEFAULT_WEIGHT,
+    currentScore = 0,
+    metadata = undefined,
+    botJid = undefined,
+    connection = null,
+  } = {},
+) =>
+  upsertSession(
+    {
+      sessionId,
+      status,
+      capacityWeight,
+      currentScore,
+      metadata,
+      botJid,
+    },
+    { connection },
+  );
+
+export const heartbeatSession = async (
+  sessionId,
+  {
+    status = 'online',
+    currentScore = 0,
+    metadata = undefined,
+    botJid = undefined,
+    capacityWeight = DEFAULT_WEIGHT,
+    connection = null,
+  } = {},
+) =>
+  upsertSession(
+    {
+      sessionId,
+      status,
+      currentScore,
+      metadata,
+      botJid,
+      capacityWeight,
+      heartbeatAt: new Date(),
+    },
+    { connection },
+  );
+
+export const markSessionConnected = async (
+  sessionId,
+  {
+    botJid = undefined,
+    currentScore = 0,
+    metadata = undefined,
+    capacityWeight = DEFAULT_WEIGHT,
+    connection = null,
+  } = {},
+) =>
+  upsertSession(
+    {
+      sessionId,
+      botJid,
+      status: 'online',
+      currentScore,
+      metadata,
+      capacityWeight,
+      heartbeatAt: new Date(),
+      connectedAt: new Date(),
+    },
+    { connection },
+  );
+
+export const markSessionDisconnected = async (
+  sessionId,
+  {
+    status = 'offline',
+    currentScore = 0,
+    metadata = undefined,
+    capacityWeight = DEFAULT_WEIGHT,
+    connection = null,
+  } = {},
+) =>
+  upsertSession(
+    {
+      sessionId,
+      status,
+      currentScore,
+      metadata,
+      capacityWeight,
+      disconnectedAt: new Date(),
+    },
+    { connection },
+  );
+
+const sessionRegistryService = {
+  getSession,
+  listSessions,
+  upsertSession,
+  ensureSession,
+  heartbeatSession,
+  markSessionConnected,
+  markSessionDisconnected,
+};
+
+export default sessionRegistryService;

package/app/store/aiPromptStore.js

@@ -1,36 +1,53 @@
-import groupConfigStore from './groupConfigStore.js';
+import { TABLES, executeQuery, findById, remove, upsert } from '../../database/index.js';
+import { normalizeJid } from '../config/index.js';
 
-const PROMPT_CONFIG_ID = 'system:ai_prompts';
+const AI_PROMPTS_TABLE = TABLES.SYSTEM_AI_PROMPTS;
+const SELECT_AI_PROMPTS_SQL = `SELECT id, prompt FROM \`${AI_PROMPTS_TABLE}\` ORDER BY id ASC`;
 
-const normalizeMap = (map) => (map && typeof map === 'object' ? map : {});
+const normalizePromptJid = (jid) => {
+  const raw = String(jid || '').trim();
+  if (!raw) return '';
+  return normalizeJid(raw) || raw;
+};
+
+const normalizePromptValue = (prompt) => {
+  if (typeof prompt === 'string') return prompt;
+  if (prompt === null || prompt === undefined) return '';
+  return String(prompt);
+};
 
 const aiPromptStore = {
   getAllPrompts: async function () {
-    const config = await groupConfigStore.getGroupConfig(PROMPT_CONFIG_ID);
-    return normalizeMap(config.prompts);
+    const rows = await executeQuery(SELECT_AI_PROMPTS_SQL);
+    const prompts = {};
+    for (const row of rows) {
+      const promptJid = normalizePromptJid(row?.id);
+      if (!promptJid) continue;
+      prompts[promptJid] = normalizePromptValue(row?.prompt);
+    }
+    return prompts;
   },
 
   getPrompt: async function (jid) {
-    if (!jid) return null;
-    const prompts = await this.getAllPrompts();
-    return prompts[jid] || null;
+    const normalizedJid = normalizePromptJid(jid);
+    if (!normalizedJid) return null;
+    const row = await findById(AI_PROMPTS_TABLE, normalizedJid);
+    if (!row) return null;
+    return normalizePromptValue(row.prompt);
   },
 
   setPrompt: async function (jid, prompt) {
-    if (!jid) return null;
-    const prompts = await this.getAllPrompts();
-    prompts[jid] = prompt;
-    await groupConfigStore.updateGroupConfig(PROMPT_CONFIG_ID, { prompts });
-    return prompt;
+    const normalizedJid = normalizePromptJid(jid);
+    if (!normalizedJid) return null;
+    const normalizedPrompt = normalizePromptValue(prompt);
+    await upsert(AI_PROMPTS_TABLE, { id: normalizedJid, prompt: normalizedPrompt });
+    return normalizedPrompt;
   },
 
   clearPrompt: async function (jid) {
-    if (!jid) return null;
-    const prompts = await this.getAllPrompts();
-    if (prompts[jid]) {
-      delete prompts[jid];
-      await groupConfigStore.updateGroupConfig(PROMPT_CONFIG_ID, { prompts });
-    }
+    const normalizedJid = normalizePromptJid(jid);
+    if (!normalizedJid) return null;
+    await remove(AI_PROMPTS_TABLE, normalizedJid);
     return true;
   },
 };