@carlonicora/nextjs-jsonapi 3.12.0 → 3.13.0

package/dist/{chunk-Q2BREXH3.mjs → chunk-OSFYCSTW.mjs}

@@ -5922,6 +5922,18 @@ var HowToService = class extends AbstractService {
       endpoint: new EndpointCreator({ endpoint: Modules.HowTo, id: params.howToId }).generate()
     });
   }
+  /**
+   * POST /howtos/reindex — re-queues every guide for chunking. Replies 204.
+   * Chunking otherwise only happens on create and update, so a guide that was
+   * never chunked stays invisible to help-mode retrieval with no way back.
+   */
+  static async reindex() {
+    await this.callApi({
+      type: Modules.HowTo,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.HowTo, id: "reindex" }).generate()
+    });
+  }
   static async findPublished(params = {}) {
     const endpoint = new EndpointCreator({ endpoint: `public/${Modules.HowTo.name}` });
     if (params.howToType) endpoint.addAdditionalParam("type", params.howToType);
@@ -5980,6 +5992,675 @@ var HowToService = class extends AbstractService {
   }
 };
 
+// src/features/handbook/HandbookPageModule.ts
+import { BookOpenIcon } from "lucide-react";
+
+// src/features/handbook/data/HandbookPage.ts
+var HandbookPage = class extends AbstractApiData {
+  static {
+    __name(this, "HandbookPage");
+  }
+  _path;
+  _title;
+  _content;
+  _contentHash;
+  _wordCount;
+  _aiStatus;
+  _section;
+  _order;
+  _summary;
+  _displayTitle;
+  _displaySummary;
+  _displayContent;
+  get path() {
+    return this._path ?? "";
+  }
+  get title() {
+    return this._title ?? "";
+  }
+  get content() {
+    return this._content ?? "";
+  }
+  get contentHash() {
+    return this._contentHash ?? "";
+  }
+  get wordCount() {
+    return this._wordCount ?? 0;
+  }
+  get aiStatus() {
+    return this._aiStatus;
+  }
+  get section() {
+    return this._section ?? "";
+  }
+  get order() {
+    return this._order ?? "";
+  }
+  get summary() {
+    return this._summary;
+  }
+  get displayTitle() {
+    return this._displayTitle;
+  }
+  get displaySummary() {
+    return this._displaySummary;
+  }
+  get displayContent() {
+    return this._displayContent;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._path = data.jsonApi.attributes.path;
+    this._title = data.jsonApi.attributes.title;
+    this._content = data.jsonApi.attributes.content;
+    this._contentHash = data.jsonApi.attributes.contentHash;
+    this._wordCount = data.jsonApi.attributes.wordCount;
+    this._aiStatus = data.jsonApi.attributes.aiStatus;
+    this._section = data.jsonApi.attributes.section;
+    this._order = data.jsonApi.attributes.order;
+    this._summary = data.jsonApi.attributes.summary;
+    this._displayTitle = data.jsonApi.attributes.displayTitle;
+    this._displaySummary = data.jsonApi.attributes.displaySummary;
+    this._displayContent = data.jsonApi.attributes.displayContent;
+    return this;
+  }
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.HandbookPage.name,
+        id: data.id,
+        attributes: {},
+        relationships: {}
+      },
+      included: []
+    };
+    return response;
+  }
+};
+
+// src/features/handbook/HandbookPageModule.ts
+var HandbookPageModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: "b1f1c2d6-6a0e-4e93-9b6d-3f5f4a2c81e7",
+  pageUrl: "/administration/handbook",
+  name: "handbookpages",
+  model: HandbookPage,
+  icon: BookOpenIcon,
+  inclusions: {
+    lists: {
+      // `content` is deliberately omitted: the list renders titles and
+      // status, and a thousand pages of markdown do not belong in a list
+      // payload. `section`, `order` and `summary` are the index fields the
+      // contents page groups, orders and describes pages by, so they are the
+      // one part of the payload the list surface cannot do without.
+      //
+      // `displayTitle` and `displaySummary` are the translated halves of the
+      // two strings the contents page prints, and a sparse fieldset that
+      // omitted them would leave every row in English. `displayContent` is
+      // NOT here for the same reason `content` is not: it is the whole
+      // markdown body, and it belongs to the detail read alone.
+      fields: [
+        createJsonApiInclusion("handbookpages", [
+          "path",
+          "title",
+          "displayTitle",
+          "section",
+          "order",
+          "summary",
+          "displaySummary",
+          "wordCount",
+          "aiStatus"
+        ])
+      ]
+    }
+  }
+}), "HandbookPageModule");
+
+// src/features/handbook/HandbookSectionModule.ts
+import { LibraryIcon } from "lucide-react";
+
+// src/features/handbook/data/HandbookSection.ts
+var HandbookSection = class extends AbstractApiData {
+  static {
+    __name(this, "HandbookSection");
+  }
+  _key;
+  _title;
+  _summary;
+  _order;
+  _displayTitle;
+  _displaySummary;
+  get key() {
+    return this._key ?? "";
+  }
+  get title() {
+    return this._title ?? "";
+  }
+  get summary() {
+    return this._summary;
+  }
+  get order() {
+    return this._order ?? "";
+  }
+  get displayTitle() {
+    return this._displayTitle;
+  }
+  get displaySummary() {
+    return this._displaySummary;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    this._key = data.jsonApi.attributes.key;
+    this._title = data.jsonApi.attributes.title;
+    this._summary = data.jsonApi.attributes.summary;
+    this._order = data.jsonApi.attributes.order;
+    this._displayTitle = data.jsonApi.attributes.displayTitle;
+    this._displaySummary = data.jsonApi.attributes.displaySummary;
+    return this;
+  }
+  /**
+   * Nothing calls this: sections are read-only over HTTP and written only by
+   * the ingest. It exists because every model implements `createJsonApi()`, and
+   * a model that throws on serialisation is a trap for the next writer.
+   */
+  createJsonApi(data) {
+    const response = {
+      data: {
+        type: Modules.HandbookSection.name,
+        id: data.id,
+        attributes: {},
+        relationships: {}
+      },
+      included: []
+    };
+    if (data.key !== void 0) response.data.attributes.key = data.key;
+    if (data.title !== void 0) response.data.attributes.title = data.title;
+    if (data.summary !== void 0) response.data.attributes.summary = data.summary;
+    if (data.order !== void 0) response.data.attributes.order = data.order;
+    return response;
+  }
+};
+
+// src/features/handbook/HandbookSectionModule.ts
+var HandbookSectionModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: "6b0a2f74-1c53-4a0e-9c1d-2e7b4a9d6f30",
+  name: "handbooksections",
+  model: HandbookSection,
+  icon: LibraryIcon,
+  inclusions: {
+    lists: {
+      // `HandbookSectionService.findMany` is the ONLY read of this resource and
+      // it limits to these fields, so the translated halves have to be here:
+      // without them every section heading on the contents page and in the
+      // reader's navigator would stay English however good the translation is.
+      fields: [
+        createJsonApiInclusion("handbooksections", [
+          "key",
+          "title",
+          "displayTitle",
+          "summary",
+          "displaySummary",
+          "order"
+        ])
+      ]
+    }
+  }
+}), "HandbookSectionModule");
+
+// src/features/handbook/HandbookThreadMessageModule.ts
+import { MessageCircleQuestionIcon } from "lucide-react";
+
+// src/features/handbook/data/HandbookThreadMessage.ts
+import { v4 as uuidv4 } from "uuid";
+var HandbookThreadMessage = class _HandbookThreadMessage extends AbstractApiData {
+  static {
+    __name(this, "HandbookThreadMessage");
+  }
+  _role;
+  _content;
+  _position;
+  _sources;
+  _isOptimistic = false;
+  get role() {
+    return this._role ?? "assistant";
+  }
+  get content() {
+    return this._content ?? "";
+  }
+  get position() {
+    return this._position ?? 0;
+  }
+  get sources() {
+    return this._sources ?? [];
+  }
+  /** The handbook agent returns no follow-ups. */
+  get suggestedQuestions() {
+    return [];
+  }
+  /** Token accounting is not billed against a handbook thread. */
+  get inputTokens() {
+    return void 0;
+  }
+  get outputTokens() {
+    return void 0;
+  }
+  /** The handbook answers from pages, never from product entities. */
+  get references() {
+    return [];
+  }
+  /** Cited pages travel in `sources`, not as Chunk resources. */
+  get citations() {
+    return [];
+  }
+  /** Set only by `buildLocal`; a rehydrated message is always real. */
+  get isOptimistic() {
+    return this._isOptimistic;
+  }
+  /** There is no operator engine behind the handbook, so never an approval request. */
+  get messageType() {
+    return "text";
+  }
+  get actionId() {
+    return void 0;
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    const attributes = data.jsonApi.attributes ?? {};
+    this._role = attributes.role;
+    this._content = attributes.content;
+    this._position = typeof attributes.position === "number" ? attributes.position : Number(attributes.position ?? 0);
+    this._sources = Array.isArray(attributes.sources) ? attributes.sources : [];
+    return this;
+  }
+  /**
+   * The envelope `POST /handbookthreads/:id/handbookthreadmessages` accepts:
+   * only the question. Role and position are derived server-side from the
+   * thread, and there is no client-chosen id for the pair of messages the turn
+   * creates.
+   *
+   * `handbookPageId` rides the same way `question` does, through this method
+   * and never through `overridesJsonApiCreation`. It is written only when the
+   * caller supplied it: the DTO takes it as optional, and sending an explicit
+   * `null` would fail validation rather than mean "the whole manual".
+   */
+  createJsonApi(data) {
+    return {
+      data: {
+        type: Modules.HandbookThreadMessage.name,
+        attributes: {
+          question: data.question,
+          ...data.handbookPageId !== void 0 ? { handbookPageId: data.handbookPageId } : {}
+        }
+      },
+      included: []
+    };
+  }
+  /**
+   * A message that exists only on the client: the optimistic user turn while
+   * the agent runs, and the failure notice when it does not answer. Mirrors
+   * `AssistantMessage.buildLocal`, which the stateless handbook surface used
+   * before threads existed.
+   */
+  static buildLocal(params) {
+    const message = new _HandbookThreadMessage();
+    message.rehydrate({
+      jsonApi: {
+        id: uuidv4(),
+        type: Modules.HandbookThreadMessage.name,
+        attributes: {
+          role: params.role,
+          content: params.content,
+          position: params.position
+        }
+      },
+      included: []
+    });
+    message._isOptimistic = params.isOptimistic ?? false;
+    return message;
+  }
+};
+
+// src/features/handbook/HandbookThreadMessageModule.ts
+var HandbookThreadMessageModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: "bef354f2-70e1-4f4f-9953-10d3d74cad0c",
+  name: "handbookthreadmessages",
+  model: HandbookThreadMessage,
+  icon: MessageCircleQuestionIcon,
+  inclusions: {
+    lists: {
+      fields: [createJsonApiInclusion("handbookthreadmessages", ["role", "content", "position", "sources"])]
+    }
+  }
+}), "HandbookThreadMessageModule");
+
+// src/features/handbook/HandbookThreadModule.ts
+import { MessagesSquareIcon } from "lucide-react";
+
+// src/features/handbook/data/HandbookThread.ts
+var HandbookThread = class extends AbstractApiData {
+  static {
+    __name(this, "HandbookThread");
+  }
+  _title;
+  _messageCount;
+  _messages;
+  get title() {
+    return this._title ?? "";
+  }
+  get messageCount() {
+    return this._messageCount ?? 0;
+  }
+  /**
+   * The handbook runs one agent and has no engine choice, so nothing routes on
+   * this. It exists because `AssistantInterface` declares it, which is what
+   * lets the shared chat chrome take a handbook thread unchanged.
+   */
+  get engine() {
+    return void 0;
+  }
+  /** A handbook thread is never bound to a product resource. */
+  get boundContentType() {
+    return void 0;
+  }
+  get boundContentId() {
+    return void 0;
+  }
+  get messages() {
+    return this._messages ?? [];
+  }
+  rehydrate(data) {
+    super.rehydrate(data);
+    const attributes = data.jsonApi.attributes ?? {};
+    this._title = attributes.title;
+    const fromMeta = data.jsonApi.meta?.messageCount;
+    this._messageCount = typeof fromMeta === "number" ? fromMeta : typeof attributes.messageCount === "number" ? attributes.messageCount : 0;
+    const messages = this._readIncluded(
+      data,
+      "messages",
+      Modules.HandbookThreadMessage
+    );
+    this._messages = Array.isArray(messages) ? messages : messages ? [messages] : [];
+    if (this._updatedAt === void 0 && attributes.updatedAt !== void 0)
+      this._updatedAt = new Date(attributes.updatedAt);
+    if (this._createdAt === void 0 && attributes.createdAt !== void 0)
+      this._createdAt = new Date(attributes.createdAt);
+    return this;
+  }
+  /**
+   * The envelope `POST /handbookthreads` accepts: the opening question. The
+   * server derives the title from it, so no title is sent and no client id —
+   * the thread's identity is the server's to mint.
+   *
+   * `handbookPageId` rides the same way `question` does, through this method
+   * and never through `overridesJsonApiCreation`. It is written only when the
+   * caller supplied it: the DTO takes it as optional, and sending an explicit
+   * `null` would fail validation rather than mean "the whole manual".
+   */
+  createJsonApi(data) {
+    return {
+      data: {
+        type: Modules.HandbookThread.name,
+        attributes: {
+          question: data.question,
+          ...data.handbookPageId !== void 0 ? { handbookPageId: data.handbookPageId } : {}
+        }
+      },
+      included: []
+    };
+  }
+  /**
+   * The envelope `PATCH /handbookthreads/:id` accepts. A dedicated method
+   * rather than a branch inside `createJsonApi`: the rename sends the title and
+   * nothing else, while a create sends the question and nothing else, and the
+   * service must never hand-build either.
+   */
+  createRenameJsonApi(params) {
+    return {
+      data: {
+        type: Modules.HandbookThread.name,
+        id: params.id,
+        attributes: {
+          title: params.title
+        }
+      },
+      included: []
+    };
+  }
+};
+
+// src/features/handbook/HandbookThreadModule.ts
+var HandbookThreadModule = /* @__PURE__ */ __name((factory) => factory({
+  moduleId: "aea692c4-7163-49bd-9ddc-1052cc06fa14",
+  name: "handbookthreads",
+  model: HandbookThread,
+  icon: MessagesSquareIcon,
+  identifier: ["title"],
+  inclusions: {
+    lists: {
+      fields: [createJsonApiInclusion("handbookthreads", ["title"])]
+    }
+  }
+}), "HandbookThreadModule");
+
+// src/features/handbook/data/handbookDisplay.ts
+function handbookPageTitle(page) {
+  return page.displayTitle ?? page.title;
+}
+__name(handbookPageTitle, "handbookPageTitle");
+function handbookPageSummary(page) {
+  return page.displaySummary ?? page.summary;
+}
+__name(handbookPageSummary, "handbookPageSummary");
+function handbookPageContent(page) {
+  return page.displayContent ?? page.content;
+}
+__name(handbookPageContent, "handbookPageContent");
+function handbookSectionTitle(section) {
+  return section.displayTitle ?? section.title;
+}
+__name(handbookSectionTitle, "handbookSectionTitle");
+function handbookSectionSummary(section) {
+  return section.displaySummary ?? section.summary;
+}
+__name(handbookSectionSummary, "handbookSectionSummary");
+
+// src/features/handbook/data/HandbookPageFields.ts
+var HandbookPageFields = /* @__PURE__ */ ((HandbookPageFields2) => {
+  HandbookPageFields2["handbookPageId"] = "handbookPageId";
+  HandbookPageFields2["path"] = "path";
+  HandbookPageFields2["title"] = "title";
+  HandbookPageFields2["displayTitle"] = "displayTitle";
+  HandbookPageFields2["section"] = "section";
+  HandbookPageFields2["order"] = "order";
+  HandbookPageFields2["summary"] = "summary";
+  HandbookPageFields2["displaySummary"] = "displaySummary";
+  HandbookPageFields2["displayContent"] = "displayContent";
+  HandbookPageFields2["wordCount"] = "wordCount";
+  HandbookPageFields2["aiStatus"] = "aiStatus";
+  return HandbookPageFields2;
+})(HandbookPageFields || {});
+
+// src/features/handbook/data/HandbookPageService.ts
+var HandbookPageService = class extends AbstractService {
+  static {
+    __name(this, "HandbookPageService");
+  }
+  /**
+   * `next` / `prev` are not optional extras: `useDataListRetriever` drives
+   * pagination by handing the cursor back here, so a findMany that drops them
+   * renders exactly one page and no navigation, however many rows exist.
+   * Mirrors HowToService.findMany.
+   */
+  static async findMany(params = {}) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.HandbookPage });
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    if (Modules.HandbookPage.inclusions?.lists?.fields)
+      endpoint.limitToFields(Modules.HandbookPage.inclusions.lists.fields);
+    if (Modules.HandbookPage.inclusions?.lists?.types)
+      endpoint.limitToType(Modules.HandbookPage.inclusions.lists.types);
+    return this.callApi({
+      type: Modules.HandbookPage,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  static async findOne(params) {
+    return this.callApi({
+      type: Modules.HandbookPage,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.HandbookPage, id: params.id }).generate()
+    });
+  }
+  /** POST /handbookpages/sync — replies 204; the caller refetches the list. */
+  static async sync() {
+    await this.callApi({
+      type: Modules.HandbookPage,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.HandbookPage, id: "sync" }).generate()
+    });
+  }
+  static async delete(params) {
+    await this.callApi({
+      type: Modules.HandbookPage,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.HandbookPage, id: params.id }).generate()
+    });
+  }
+};
+
+// src/features/handbook/data/HandbookSectionService.ts
+var HandbookSectionService = class extends AbstractService {
+  static {
+    __name(this, "HandbookSectionService");
+  }
+  /**
+   * Every section in one read, always.
+   *
+   * There are as many sections as an application has documentation directories
+   * — ten or so — so this takes no `fetchAll` argument and no cursor: unlike
+   * the page list, nothing here is ever a second page, and a caller that could
+   * ask for one page of sections would only be able to get it wrong.
+   */
+  static async findMany() {
+    const endpoint = new EndpointCreator({ endpoint: Modules.HandbookSection });
+    endpoint.addAdditionalParam("fetchAll", "true");
+    if (Modules.HandbookSection.inclusions?.lists?.fields)
+      endpoint.limitToFields(Modules.HandbookSection.inclusions.lists.fields);
+    return this.callApi({
+      type: Modules.HandbookSection,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate()
+    });
+  }
+};
+
+// src/features/handbook/data/HandbookThreadMessageService.ts
+var HandbookThreadMessageService = class extends AbstractService {
+  static {
+    __name(this, "HandbookThreadMessageService");
+  }
+  /**
+   * Appends one question to an existing thread and runs the agent turn.
+   *
+   * It returns nothing on purpose: the caller reads the turn back with
+   * `HandbookThreadService.findOne`, which is the one endpoint the contract
+   * guarantees side-loads the full message list. That keeps a single code path
+   * for "load the thread after a mutation" — the same one the sidebar's select
+   * uses — instead of two ways of arriving at the transcript.
+   *
+   * The API answers 400 when the installation has no usable AI configuration
+   * and 403 for a non-administrator; both reach the caller as a thrown error.
+   */
+  static async ask(params) {
+    await this.callApi({
+      type: Modules.HandbookThreadMessage,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.HandbookThread,
+        id: params.threadId,
+        childEndpoint: Modules.HandbookThreadMessage
+      }).generate(),
+      input: { id: params.id, question: params.question, handbookPageId: params.handbookPageId },
+      suppressGlobalError: true
+    });
+  }
+};
+
+// src/features/handbook/data/HandbookThreadService.ts
+var HandbookThreadService = class extends AbstractService {
+  static {
+    __name(this, "HandbookThreadService");
+  }
+  /**
+   * `next` / `prev` are not optional extras: `useDataListRetriever` drives
+   * pagination by handing the cursor back here, so a findMany that drops them
+   * renders exactly one page and no navigation, however many rows exist.
+   * Mirrors HowToService.findMany.
+   */
+  static async findMany(params = {}) {
+    const endpoint = new EndpointCreator({ endpoint: Modules.HandbookThread });
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    if (Modules.HandbookThread.inclusions?.lists?.fields)
+      endpoint.limitToFields(Modules.HandbookThread.inclusions.lists.fields);
+    if (Modules.HandbookThread.inclusions?.lists?.types)
+      endpoint.limitToType(Modules.HandbookThread.inclusions.lists.types);
+    return this.callApi({
+      type: Modules.HandbookThread,
+      method: "GET" /* GET */,
+      endpoint: endpoint.generate(),
+      next: params.next
+    });
+  }
+  /** Returns the thread with its messages side-loaded — the sidebar's select. */
+  static async findOne(params) {
+    return this.callApi({
+      type: Modules.HandbookThread,
+      method: "GET" /* GET */,
+      endpoint: new EndpointCreator({ endpoint: Modules.HandbookThread, id: params.id }).generate()
+    });
+  }
+  /**
+   * Opens a thread with its first question. The response is the thread (title
+   * included); the messages are read back with `findOne`, because only the
+   * single-resource endpoint side-loads them.
+   *
+   * The API answers 400 when the installation has no usable AI configuration
+   * and 403 for a non-administrator; both reach the caller as a thrown error.
+   *
+   * `HandbookThreadInput.handbookPageId` scopes retrieval to one page. It rides
+   * through the model's `createJsonApi()`, exactly as `question` does — there is
+   * no `overridesJsonApiCreation` on this path.
+   */
+  static async create(params) {
+    return this.callApi({
+      type: Modules.HandbookThread,
+      method: "POST" /* POST */,
+      endpoint: new EndpointCreator({ endpoint: Modules.HandbookThread }).generate(),
+      input: params,
+      suppressGlobalError: true
+    });
+  }
+  static async rename(params) {
+    const thread = new HandbookThread();
+    await this.callApi({
+      type: Modules.HandbookThread,
+      method: "PATCH" /* PATCH */,
+      endpoint: new EndpointCreator({ endpoint: Modules.HandbookThread, id: params.id }).generate(),
+      input: thread.createRenameJsonApi({ id: params.id, title: params.title }),
+      overridesJsonApiCreation: true
+    });
+  }
+  static async delete(params) {
+    await this.callApi({
+      type: Modules.HandbookThread,
+      method: "DELETE" /* DELETE */,
+      endpoint: new EndpointCreator({ endpoint: Modules.HandbookThread, id: params.id }).generate()
+    });
+  }
+};
+
 // src/features/assistant/AssistantModule.ts
 import { BotIcon } from "lucide-react";
 
@@ -6033,7 +6714,9 @@ var Assistant = class extends AbstractApiData {
           content: data.contentBlocks !== void 0 ? JSON.stringify(data.contentBlocks) : data.firstMessage,
           ...data.title !== void 0 ? { title: data.title } : {},
           ...data.howToMode !== void 0 ? { howToMode: data.howToMode } : {},
-          ...data.limitToHowToId !== void 0 ? { limitToHowToId: data.limitToHowToId } : {}
+          ...data.limitToHowToId !== void 0 ? { limitToHowToId: data.limitToHowToId } : {},
+          ...data.handbookMode !== void 0 ? { handbookMode: data.handbookMode } : {},
+          ...data.limitToHandbookPageId !== void 0 ? { limitToHandbookPageId: data.limitToHandbookPageId } : {}
         },
         ...data.boundContent !== void 0 ? {
           relationships: {
@@ -6062,7 +6745,7 @@ var AssistantModule = /* @__PURE__ */ __name((factory) => factory({
 }), "AssistantModule");
 
 // src/features/assistant-message/data/AssistantMessage.ts
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv42 } from "uuid";
 
 // src/features/assistant/utils/resolveReferenceableModules.ts
 function resolveReferenceableModules() {
@@ -6184,18 +6867,32 @@ var AssistantMessage = class _AssistantMessage extends AbstractApiData {
           // stored markdown from it.
           content: params.contentBlocks !== void 0 ? JSON.stringify(params.contentBlocks) : params.content,
           ...params.howToMode !== void 0 ? { howToMode: params.howToMode } : {},
-          ...params.limitToHowToId !== void 0 ? { limitToHowToId: params.limitToHowToId } : {}
+          ...params.limitToHowToId !== void 0 ? { limitToHowToId: params.limitToHowToId } : {},
+          ...params.handbookMode !== void 0 ? { handbookMode: params.handbookMode } : {},
+          ...params.limitToHandbookPageId !== void 0 ? { limitToHandbookPageId: params.limitToHandbookPageId } : {}
         }
       }
     };
   }
   static buildOptimistic(params) {
+    return _AssistantMessage.buildLocal({ ...params, role: "user", isOptimistic: true });
+  }
+  /**
+   * A message that exists only on the client, for a surface that renders the
+   * chat presentation without persisting a thread.
+   *
+   * `buildOptimistic` is the user-turn case and delegates here. The handbook
+   * ask surface is the other caller: it has no Assistant and no stored
+   * messages, but it renders through MessageList/MessageItem like every other
+   * chat in the product, so it needs both roles.
+   */
+  static buildLocal(params) {
     const msg = new _AssistantMessage();
     const jsonApi = {
-      id: uuidv4(),
+      id: uuidv42(),
       type: Modules.AssistantMessage.name,
       attributes: {
-        role: "user",
+        role: params.role,
         content: params.content,
         position: params.position
       }
@@ -6206,7 +6903,7 @@ var AssistantMessage = class _AssistantMessage extends AbstractApiData {
       };
     }
     msg.rehydrate({ jsonApi, included: [] });
-    msg._isOptimistic = true;
+    msg._isOptimistic = params.isOptimistic ?? false;
     return msg;
   }
 };
@@ -6282,6 +6979,8 @@ var AssistantService = class extends AbstractService {
         content: params.content,
         howToMode: params.howToMode,
         limitToHowToId: params.limitToHowToId,
+        handbookMode: params.handbookMode,
+        limitToHandbookPageId: params.limitToHandbookPageId,
         contentBlocks: params.contentBlocks
       }),
       overridesJsonApiCreation: true
@@ -8911,6 +9610,24 @@ export {
   HowToModule,
   HowToFields,
   HowToService,
+  HandbookPage,
+  HandbookPageModule,
+  HandbookSection,
+  HandbookSectionModule,
+  HandbookThreadMessage,
+  HandbookThreadMessageModule,
+  HandbookThread,
+  HandbookThreadModule,
+  handbookPageTitle,
+  handbookPageSummary,
+  handbookPageContent,
+  handbookSectionTitle,
+  handbookSectionSummary,
+  HandbookPageFields,
+  HandbookPageService,
+  HandbookSectionService,
+  HandbookThreadMessageService,
+  HandbookThreadService,
   Assistant,
   AssistantModule,
   AssistantMessage,
@@ -8984,4 +9701,4 @@ export {
   AuditLogService,
   AuditLogModule
 };
-//# sourceMappingURL=chunk-Q2BREXH3.mjs.map
+//# sourceMappingURL=chunk-OSFYCSTW.mjs.map