@carlonicora/nextjs-jsonapi 2.0.2 → 2.1.0

package/src/features/assistant/contexts/__tests__/AssistantContext.spec.tsx

@@ -523,4 +523,85 @@ describe("AssistantContext", () => {
     expect(result.current.messages.map((m) => m.content)).toEqual(["retry-me", "ok"]);
     expect(appendMock).toHaveBeenCalledTimes(2);
   });
+
+  it("loads only threads bound to the scope", async () => {
+    const findMany = vi.fn().mockResolvedValue([]);
+    AssistantService.findMany = findMany;
+
+    renderHook(() => useAssistantContext(), {
+      wrapper: ({ children }) => (
+        <AssistantProvider scope={{ type: "campaigns", id: "camp-1" }}>{children}</AssistantProvider>
+      ),
+    });
+
+    await waitFor(() => expect(findMany).toHaveBeenCalledWith({ boundType: "campaigns", boundId: "camp-1" }));
+  });
+
+  it("creates the first thread bound to the scope", async () => {
+    const replaceState = vi.spyOn(window.history, "replaceState").mockImplementation(() => {});
+    const create = vi.fn().mockResolvedValue(buildAssistantStub({ id: "a1" }));
+    AssistantService.create = create;
+    AssistantMessageService.findByAssistant = vi.fn().mockResolvedValue([]);
+
+    const { result } = renderHook(() => useAssistantContext(), {
+      wrapper: ({ children }) => (
+        <AssistantProvider scope={{ type: "campaigns", id: "camp-1" }}>{children}</AssistantProvider>
+      ),
+    });
+    await act(async () => {
+      await result.current.sendMessage("hello");
+    });
+
+    expect(create).toHaveBeenCalledWith(expect.objectContaining({ boundContent: { type: "campaigns", id: "camp-1" } }));
+    replaceState.mockRestore();
+  });
+
+  it("uses threadUrl for history replacement", () => {
+    const replaceState = vi.spyOn(window.history, "replaceState").mockImplementation(() => {});
+
+    const { result } = renderHook(() => useAssistantContext(), {
+      wrapper: ({ children }) => (
+        <AssistantProvider
+          scope={{ type: "campaigns", id: "camp-1" }}
+          threadUrl={(id?: string) => (id ? `/campaigns/camp-1/assistant/${id}` : "/campaigns/camp-1/assistant")}
+        >
+          {children}
+        </AssistantProvider>
+      ),
+    });
+
+    act(() => {
+      result.current.startNew();
+    });
+
+    expect(replaceState).toHaveBeenCalledWith(null, "", "/campaigns/camp-1/assistant");
+    replaceState.mockRestore();
+  });
+
+  it("forwards contentBlocks from the composer to create and appendMessage", async () => {
+    const replaceState = vi.spyOn(window.history, "replaceState").mockImplementation(() => {});
+    const blocks = [{ type: "paragraph", content: [] }];
+
+    AssistantService.create = vi.fn().mockResolvedValue(buildAssistantStub({ id: "a-blocks" }));
+    AssistantMessageService.findByAssistant = vi.fn().mockResolvedValue([]);
+    const { result } = renderHook(() => useAssistantContext(), {
+      wrapper: ({ children }) => <AssistantProvider>{children}</AssistantProvider>,
+    });
+    await act(async () => {
+      await result.current.sendMessage("hello", { contentBlocks: blocks });
+    });
+    expect(AssistantService.create).toHaveBeenCalledWith(expect.objectContaining({ contentBlocks: blocks }));
+
+    const existing = buildAssistantDehydrated({ id: "a-blocks-2" });
+    AssistantService.appendMessage = vi.fn().mockResolvedValue([]);
+    const { result: followUp } = renderHook(() => useAssistantContext(), {
+      wrapper: ({ children }) => <AssistantProvider dehydratedAssistant={existing}>{children}</AssistantProvider>,
+    });
+    await act(async () => {
+      await followUp.current.sendMessage("more", { contentBlocks: blocks });
+    });
+    expect(AssistantService.appendMessage).toHaveBeenCalledWith(expect.objectContaining({ contentBlocks: blocks }));
+
+    replaceState.mockRestore();
+  });
 });

package/src/features/assistant/data/Assistant.ts

@@ -5,6 +5,8 @@ export class Assistant extends AbstractApiData implements AssistantInterface {
   private _title?: string;
   private _messageCount?: number;
   private _engine?: string;
+  private _boundContentType?: string;
+  private _boundContentId?: string;
 
   get title(): string {
     return this._title ?? "";
@@ -18,6 +20,14 @@ export class Assistant extends AbstractApiData implements AssistantInterface {
     return this._engine;
   }
 
+  get boundContentType(): string | undefined {
+    return this._boundContentType;
+  }
+
+  get boundContentId(): string | undefined {
+    return this._boundContentId;
+  }
+
   rehydrate(data: JsonApiHydratedDataInterface): this {
     super.rehydrate(data);
     this._title = data.jsonApi.attributes?.title;
@@ -25,6 +35,13 @@ export class Assistant extends AbstractApiData implements AssistantInterface {
     const fromMeta = data.jsonApi.meta?.messageCount;
     const fromAttrs = data.jsonApi.attributes?.messageCount;
     this._messageCount = typeof fromMeta === "number" ? fromMeta : typeof fromAttrs === "number" ? fromAttrs : 0;
+    // Read the linkage pointer directly instead of `_readIncluded`: the bound
+    // resource is not side-loaded on this endpoint and only its {type, id} is
+    // needed to know which scope the thread belongs to.
+    const contentLinkage = data.jsonApi.relationships?.content?.data;
+    const boundContent = Array.isArray(contentLinkage) ? contentLinkage[0] : contentLinkage;
+    this._boundContentType = boundContent?.type;
+    this._boundContentId = boundContent?.id;
     return this;
   }
 
@@ -33,11 +50,22 @@ export class Assistant extends AbstractApiData implements AssistantInterface {
       data: {
         type: Modules.Assistant.name,
         attributes: {
-          content: data.firstMessage,
+          // narr8 convention for BlockNote-backed fields: the document travels
+          // as a JSON string in the entity's own string attribute, exactly as
+          // Npc.description does (`JSON.stringify` out, `JSON.parse` back).
+          // The server detects the shape and derives the stored markdown.
+          content: data.contentBlocks !== undefined ? JSON.stringify(data.contentBlocks) : data.firstMessage,
           ...(data.title !== undefined ? { title: data.title } : {}),
           ...(data.howToMode !== undefined ? { howToMode: data.howToMode } : {}),
           ...(data.limitToHowToId !== undefined ? { limitToHowToId: data.limitToHowToId } : {}),
         },
+        ...(data.boundContent !== undefined
+          ? {
+              relationships: {
+                content: { data: { type: data.boundContent.type, id: data.boundContent.id } },
+              },
+            }
+          : {}),
       },
       included: [],
     };

package/src/features/assistant/data/AssistantInterface.ts

@@ -5,6 +5,17 @@ export type AssistantInput = {
   title?: string;
   howToMode?: boolean;
   limitToHowToId?: string;
+  /**
+   * BlockNote document behind `firstMessage`. Sent alongside the flattened
+   * text so the server can re-derive the content and read `@`-mentions from
+   * the inline nodes; the flattened text is never trusted on its own.
+   */
+  contentBlocks?: unknown[];
+  /**
+   * Resource the thread is bound to (e.g. a campaign). Confines every agent
+   * data-access point in the run to that resource's scope.
+   */
+  boundContent?: { type: string; id: string };
 };
 
 export interface AssistantInterface extends ApiDataInterface {
@@ -12,4 +23,8 @@ export interface AssistantInterface extends ApiDataInterface {
   get messageCount(): number;
   /** Agent engine the thread runs on — `"operator"` or undefined (responder). */
   get engine(): string | undefined;
+  /** JSON:API type of the resource this thread is bound to, when bound. */
+  get boundContentType(): string | undefined;
+  /** Id of the resource this thread is bound to, when bound. */
+  get boundContentId(): string | undefined;
 }

package/src/features/assistant/data/AssistantService.ts

@@ -12,9 +12,18 @@ export class AssistantService extends AbstractService {
     });
   }
 
-  static async findMany(params: { fetchAll?: boolean } = {}): Promise<AssistantInterface[]> {
+  /**
+   * Lists threads. `boundType`/`boundId` narrow the list to the threads bound
+   * to one resource (e.g. a campaign), so a scoped surface never shows the
+   * user's unrelated threads.
+   */
+  static async findMany(
+    params: { fetchAll?: boolean; boundType?: string; boundId?: string } = {},
+  ): Promise<AssistantInterface[]> {
     const endpoint = new EndpointCreator({ endpoint: Modules.Assistant });
     if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.boundType) endpoint.addAdditionalParam("boundType", params.boundType);
+    if (params.boundId) endpoint.addAdditionalParam("boundId", params.boundId);
     return this.callApi({
       type: Modules.Assistant,
       method: HttpMethod.GET,
@@ -58,6 +67,8 @@ export class AssistantService extends AbstractService {
     content: string;
     howToMode?: boolean;
     limitToHowToId?: string;
+    /** BlockNote document. Serialised by the model into `content`; never its own attribute. */
+    contentBlocks?: unknown[];
   }): Promise<AssistantMessageInterface[]> {
     const message = new AssistantMessage();
     return this.callApi<AssistantMessageInterface[]>({
@@ -72,6 +83,7 @@ export class AssistantService extends AbstractService {
         content: params.content,
         howToMode: params.howToMode,
         limitToHowToId: params.limitToHowToId,
+        contentBlocks: params.contentBlocks,
       }),
       overridesJsonApiCreation: true,
     });
@@ -86,6 +98,8 @@ export class AssistantService extends AbstractService {
   static async appendMessageOperator(params: {
     assistantId: string;
     content: string;
+    /** BlockNote document. Serialised by the model into `content`; never its own attribute. */
+    contentBlocks?: unknown[];
   }): Promise<AssistantMessageInterface[]> {
     const message = new AssistantMessage();
     return this.callApi<AssistantMessageInterface[]>({
@@ -96,7 +110,10 @@ export class AssistantService extends AbstractService {
         id: params.assistantId,
         childEndpoint: Modules.AssistantMessage,
       }).generate(),
-      input: message.createAppendMessageJsonApi({ content: params.content }),
+      input: message.createAppendMessageJsonApi({
+        content: params.content,
+        contentBlocks: params.contentBlocks,
+      }),
       overridesJsonApiCreation: true,
     });
   }

package/src/features/assistant/data/__tests__/Assistant.scope.spec.ts

@@ -0,0 +1,64 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { ApiRequestDataTypeInterface } from "../../../../core/interfaces/ApiRequestDataTypeInterface";
+import { ModuleRegistry } from "../../../../core/registry/ModuleRegistry";
+import { Assistant } from "../Assistant";
+
+// `createJsonApi()` reads `Modules.Assistant.name` for the JSON:API `type`, so
+// the module must exist in the registry. ModuleRegistry is backed by a
+// globalThis symbol shared across test files in a worker, hence the
+// register-if-absent guard (same idiom as AssistantAction.spec.ts).
+const registerIfAbsent = (key: string, module: ApiRequestDataTypeInterface) => {
+  try {
+    ModuleRegistry.get(key as any);
+  } catch {
+    ModuleRegistry.register(key, module);
+  }
+};
+
+beforeAll(() => {
+  registerIfAbsent("Assistant", { name: "assistants", model: Assistant } as any);
+});
+
+describe("Assistant.createJsonApi", () => {
+  it("emits the bound content relationship", () => {
+    const payload: any = new Assistant().createJsonApi({
+      firstMessage: "hello",
+      boundContent: { type: "campaigns", id: "camp-1" },
+    });
+
+    expect(payload.data.relationships.content).toEqual({ data: { type: "campaigns", id: "camp-1" } });
+    expect(payload.data.attributes.content).toBe("hello");
+  });
+
+  it("serialises the rich document into `content` when the composer supplied one", () => {
+    // BlockNote-backed fields travel as a JSON string inside the entity's own
+    // string attribute (same convention as Npc.description) — there is no
+    // separate `contentBlocks` attribute on the wire.
+    const blocks = [{ type: "paragraph", content: [] }];
+    const payload: any = new Assistant().createJsonApi({ firstMessage: "hello", contentBlocks: blocks });
+    expect(payload.data.attributes.content).toBe(JSON.stringify(blocks));
+    expect(payload.data.attributes.contentBlocks).toBeUndefined();
+  });
+
+  it("omits the relationships key entirely when no content is bound", () => {
+    const payload: any = new Assistant().createJsonApi({ firstMessage: "hello" });
+    expect(payload.data.relationships?.content).toBeUndefined();
+  });
+});
+
+describe("Assistant.rehydrate", () => {
+  it("exposes the bound content type and id", () => {
+    const assistant = new Assistant().rehydrate({
+      jsonApi: {
+        type: "assistants",
+        id: "a1",
+        attributes: { title: "T" },
+        relationships: { content: { data: { type: "campaigns", id: "camp-1" } } },
+      },
+      included: [],
+    } as any);
+
+    expect(assistant.boundContentType).toBe("campaigns");
+    expect(assistant.boundContentId).toBe("camp-1");
+  });
+});

package/src/features/assistant-action/AssistantActionModule.ts

@@ -0,0 +1,13 @@
+import { ShieldCheckIcon } from "lucide-react";
+import { ModuleFactory } from "../../permissions";
+import { AssistantAction } from "./data/AssistantAction";
+
+export const AssistantActionModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/assistant-actions",
+    name: "assistant-actions",
+    model: AssistantAction,
+    identifier: ["summary"],
+    moduleId: "e3c27517-bac0-43cb-adff-cc20c4210c12",
+    icon: ShieldCheckIcon,
+  });

package/src/features/assistant-action/components/ApprovalActionCard.tsx

@@ -0,0 +1,127 @@
+"use client";
+
+import { ShieldAlert } from "lucide-react";
+import { useTranslations } from "next-intl";
+import { useEffect, useState } from "react";
+import { MicroLabel } from "../../../components/typography";
+import { Badge, Button } from "../../../shadcnui";
+import type { AssistantMessageInterface } from "../../assistant-message/data/AssistantMessageInterface";
+import type { AssistantActionStatus } from "../data/AssistantActionInterface";
+import { AssistantActionService } from "../data/AssistantActionService";
+
+/**
+ * Status pill variants. Soft `Badge` variants only — a hand-rolled
+ * `bg-*-100 text-*-800` span is never a status pill (typography rule 8).
+ */
+const STATUS_VARIANT: Record<AssistantActionStatus, "softBlue" | "softGreen" | "softRed" | "softGray"> = {
+  pending: "softBlue",
+  approved: "softBlue",
+  executed: "softGreen",
+  denied: "softRed",
+  failed: "softRed",
+  expired: "softGray",
+};
+
+/**
+ * Literal i18n keys (not a template literal) so the key set stays greppable
+ * and every one of them can be verified against the app's messages file.
+ */
+const STATUS_LABEL_KEY: Record<AssistantActionStatus, string> = {
+  pending: "features.assistant.approval.status.pending",
+  approved: "features.assistant.approval.status.approved",
+  executed: "features.assistant.approval.status.executed",
+  denied: "features.assistant.approval.status.denied",
+  failed: "features.assistant.approval.status.failed",
+  expired: "features.assistant.approval.status.expired",
+};
+
+interface Props {
+  /** Id of the pending AssistantAction linked to the approval-request message. */
+  actionId: string;
+  /** Human-readable summary fallback (the approval-request message content). */
+  summary?: string;
+  /** Invoked with the resumed assistant message returned by approve/deny. */
+  onResolved?: (message: AssistantMessageInterface) => void;
+}
+
+/**
+ * Renders an `approval-request` assistant message as an action card:
+ * the destructive-tool summary plus Approve / Deny buttons. Buttons are
+ * only actionable while the underlying AssistantAction is `pending`.
+ *
+ * NOTE: plain `<Button>` elements on purpose — never wrapped inside any
+ * Base UI trigger component (no nested buttons, no `asChild`).
+ */
+export function ApprovalActionCard({ actionId, summary, onResolved }: Props) {
+  const t = useTranslations();
+  const [status, setStatus] = useState<AssistantActionStatus | undefined>(undefined);
+  const [actionSummary, setActionSummary] = useState<string | undefined>(undefined);
+  const [busy, setBusy] = useState<boolean>(false);
+  const [failed, setFailed] = useState<boolean>(false);
+
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        const action = await AssistantActionService.findOne({ id: actionId });
+        if (cancelled || !action) return;
+        setStatus(action.status);
+        setActionSummary(action.summary);
+      } catch (error) {
+        console.error(`ApprovalActionCard: failed to fetch assistant action ${actionId}`, error);
+        if (!cancelled) setFailed(true);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [actionId]);
+
+  const actionable = status === "pending" && !busy && !failed;
+
+  const resolve = async (kind: "approve" | "deny") => {
+    if (!actionable) return;
+    setBusy(true);
+    try {
+      const message =
+        kind === "approve"
+          ? await AssistantActionService.approve({ id: actionId })
+          : await AssistantActionService.deny({ id: actionId });
+      setStatus(kind === "approve" ? "executed" : "denied");
+      if (message) onResolved?.(message);
+    } catch (error) {
+      console.error(`ApprovalActionCard: failed to ${kind} assistant action ${actionId}`, error);
+      setFailed(true);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="border-border bg-muted/30 flex flex-col gap-2 rounded-xl border p-3.5">
+      <MicroLabel className="flex items-center gap-2">
+        <ShieldAlert className="text-warning h-3.5 w-3.5" />
+        <span>{t("features.assistant.approval.title")}</span>
+        {status && status !== "pending" && (
+          <Badge variant={STATUS_VARIANT[status]} className="ml-auto tracking-normal normal-case">
+            {t(STATUS_LABEL_KEY[status])}
+          </Badge>
+        )}
+      </MicroLabel>
+      <div className="text-foreground text-sm leading-relaxed">{actionSummary ?? summary}</div>
+      {failed && (
+        <div role="alert" className="text-destructive text-xs/relaxed">
+          {t("features.assistant.approval.error")}
+        </div>
+      )}
+      <div className="flex items-center gap-2 pt-1">
+        <Button size="sm" disabled={!actionable} onClick={() => void resolve("approve")}>
+          {t("features.assistant.approval.approve")}
+        </Button>
+        <Button size="sm" variant="outline" disabled={!actionable} onClick={() => void resolve("deny")}>
+          {t("features.assistant.approval.deny")}
+        </Button>
+      </div>
+    </div>
+  );
+}

package/src/features/assistant-action/components/AssistantContainerWithApprovals.tsx

@@ -0,0 +1,34 @@
+"use client";
+
+import type { AssistantMessageInterface } from "../../assistant-message/data/AssistantMessageInterface";
+import { AssistantContainer } from "../../assistant/components/containers/AssistantContainer";
+import { useAssistantContext } from "../../assistant/contexts/AssistantContext";
+import { ApprovalActionCard } from "./ApprovalActionCard";
+
+/**
+ * AssistantContainer with the operator approval card wired in. The container
+ * renders `approval-request` messages through the `renderApprovalAction` slot,
+ * which stays a slot so the plain chat container has no dependency on the
+ * AssistantAction module. Must be rendered inside an `AssistantProvider`.
+ */
+export function AssistantContainerWithApprovals() {
+  const ctx = useAssistantContext();
+
+  return (
+    <AssistantContainer
+      renderApprovalAction={(message: AssistantMessageInterface) =>
+        message.actionId ? (
+          <ApprovalActionCard
+            actionId={message.actionId}
+            summary={message.content}
+            onResolved={ctx.appendResolvedMessage}
+          />
+        ) : (
+          <div className="bg-muted text-foreground rounded-2xl rounded-bl-sm px-3.5 py-2.5 text-sm leading-relaxed">
+            {message.content}
+          </div>
+        )
+      }
+    />
+  );
+}

package/src/features/assistant-action/components/index.ts

@@ -0,0 +1,2 @@
+export * from "./ApprovalActionCard";
+export * from "./AssistantContainerWithApprovals";

package/src/features/assistant-action/data/AssistantAction.ts

@@ -0,0 +1,58 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { AssistantActionInput, AssistantActionInterface, AssistantActionStatus } from "./AssistantActionInterface";
+
+export class AssistantAction extends AbstractApiData implements AssistantActionInterface {
+  private _status?: AssistantActionStatus;
+  private _toolName?: string;
+  private _summary?: string;
+  private _resolvedAt?: Date;
+  private _expiresAt?: Date;
+
+  get status(): AssistantActionStatus {
+    // Fail-safe: a missing status must never render actionable Approve/Deny buttons, so default to the non-actionable "expired".
+    return this._status ?? "expired";
+  }
+
+  get toolName(): string {
+    return this._toolName ?? "";
+  }
+
+  get summary(): string {
+    return this._summary ?? "";
+  }
+
+  get resolvedAt(): Date | undefined {
+    return this._resolvedAt;
+  }
+
+  get expiresAt(): Date | undefined {
+    return this._expiresAt;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._status = data.jsonApi.attributes.status;
+    this._toolName = data.jsonApi.attributes.toolName;
+    this._summary = data.jsonApi.attributes.summary;
+    this._resolvedAt = data.jsonApi.attributes.resolvedAt ? new Date(data.jsonApi.attributes.resolvedAt) : undefined;
+    this._expiresAt = data.jsonApi.attributes.expiresAt ? new Date(data.jsonApi.attributes.expiresAt) : undefined;
+
+    return this;
+  }
+
+  /**
+   * Minimal payload (id only): the frontend never POSTs assistant actions —
+   * approve/deny are body-less POSTs handled by AssistantActionService.
+   */
+  createJsonApi(data: AssistantActionInput) {
+    return {
+      data: {
+        type: Modules.AssistantAction.name,
+        id: data.id,
+        attributes: {},
+      },
+      included: [],
+    };
+  }
+}

package/src/features/assistant-action/data/AssistantActionInterface.ts

@@ -0,0 +1,24 @@
+import { ApiDataInterface } from "../../../core";
+
+/**
+ * Lifecycle of a destructive tool call the operator engine paused on.
+ * Only `pending` is actionable from the UI.
+ */
+export type AssistantActionStatus = "pending" | "approved" | "denied" | "expired" | "executed" | "failed";
+
+/**
+ * The frontend never creates assistant actions — the operator engine does.
+ * The input therefore carries the id alone, so `createJsonApi()` can emit a
+ * well-formed (if minimal) JSON:API resource object.
+ */
+export type AssistantActionInput = {
+  id: string;
+};
+
+export interface AssistantActionInterface extends ApiDataInterface {
+  get status(): AssistantActionStatus;
+  get toolName(): string;
+  get summary(): string;
+  get resolvedAt(): Date | undefined;
+  get expiresAt(): Date | undefined;
+}

package/src/features/assistant-action/data/AssistantActionService.ts

@@ -0,0 +1,51 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules } from "../../../core";
+import { AssistantMessageInterface } from "../../assistant-message/data/AssistantMessageInterface";
+import { AssistantActionInterface } from "./AssistantActionInterface";
+
+export class AssistantActionService extends AbstractService {
+  /**
+   * GET single assistant action by ID
+   */
+  static async findOne(params: { id: string }): Promise<AssistantActionInterface> {
+    return this.callApi<AssistantActionInterface>({
+      type: Modules.AssistantAction,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.AssistantAction,
+        id: params.id,
+      }).generate(),
+    });
+  }
+
+  /**
+   * POST (body-less) approve action — resumes the paused run and
+   * returns the resumed assistant message.
+   */
+  static async approve(params: { id: string }): Promise<AssistantMessageInterface> {
+    return this.callApi<AssistantMessageInterface>({
+      type: Modules.AssistantMessage,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.AssistantAction,
+        id: params.id,
+        childEndpoint: "approve",
+      }).generate(),
+    });
+  }
+
+  /**
+   * POST (body-less) deny action — resumes the paused run with a denial and
+   * returns the resumed assistant message.
+   */
+  static async deny(params: { id: string }): Promise<AssistantMessageInterface> {
+    return this.callApi<AssistantMessageInterface>({
+      type: Modules.AssistantMessage,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.AssistantAction,
+        id: params.id,
+        childEndpoint: "deny",
+      }).generate(),
+    });
+  }
+}