@verentis/sdk 1.0.0 → 1.0.1

package/README.md

@@ -295,6 +295,37 @@ contracts must not assume a locally present feature-branch API is already deploy
 | `BridgeAuth` | Auth strategy that receives tokens via the bridge |
 | `matchMimeType` / `findBestMatch` | MIME type matching utilities |
 
+### Chat
+
+`client.chat` is the documented workspace chat API (`/v1/chat`). The caller and workspace always come from the
+token; message content is untrusted Markdown that readers render without raw HTML.
+
+```ts
+const conversation = await client.chat.openDirect({ kind: 'user', id: colleagueId })
+await client.chat.sendText(conversation.id, 'Hi **there**', { idempotencyKey: crypto.randomUUID() })
+
+// Inside the workspace (needs the approved `chat.read` permission): identifier-only live hints over the
+// host's realtime connection. Hints can be lost or repeated, so catch up from durable events.
+const stop = client.chat.subscribeChanges({
+  onChange: async (hint) => {
+    const page = await client.chat.events(hint.conversationId, { afterSeq: lastAppliedSeq })
+    // apply page.items; if page.resetRequired, reload the conversation and its history
+  },
+  onConnection: (status) => { if (status === 'connected') void reconcile() },
+})
+
+// From an installed app's script: post as the app's bot (declared in `spec.chat.bots`). A command script receives
+// chat_conversation_id and chat_invocation_key with its arguments; reusing the key makes a retried run reply once.
+await client.chat.postAsBot({
+  conversationId: params.chat_conversation_id,
+  parts: [{ type: 'text', data: { markdown: 'Invoice 42 needs approval' } }],
+  idempotencyKey: params.chat_invocation_key,
+})
+
+// Run an installed app's slash command as the current user.
+await client.chat.runCommand(conversationId, 'invoicing/approve-invoice', { invoice: 'INV-42' })
+```
+
 ### Workspace settings
 
 Apps whose manifest declares `spec.settings[]` get workspace setting definitions auto-registered

package/dist/index.cjs

@@ -292,7 +292,8 @@ var ExecutionsModule = class {
         tool: options?.tool,
         mode: options?.mode,
         arguments: options?.arguments ?? [],
-        parameters: serializeParameters(options?.parameters)
+        parameters: serializeParameters(options?.parameters),
+        ...options?.invocationKey ? { invocationKey: options.invocationKey } : {}
       }),
       headers: { "Content-Type": "application/json" }
     });
@@ -338,9 +339,9 @@ var ExecutionsModule = class {
     return descriptor;
   }
   /** Get an execution by id. */
-  async get(id, options) {
+  async get(id2, options) {
     const workspaceId = this.requireWorkspaceId(options?.workspaceId);
-    return this.http.request("GET", `/executions/${encodeURIComponent(id)}`, {
+    return this.http.request("GET", `/executions/${encodeURIComponent(id2)}`, {
       params: { workspaceId }
     });
   }
@@ -365,17 +366,17 @@ var ExecutionsModule = class {
     });
   }
   /** Get the captured stdout/stderr of an execution. */
-  async logs(id, options) {
+  async logs(id2, options) {
     const workspaceId = this.requireWorkspaceId(options?.workspaceId);
-    return this.http.request("GET", `/executions/${encodeURIComponent(id)}/logs`, {
+    return this.http.request("GET", `/executions/${encodeURIComponent(id2)}/logs`, {
       params: { workspaceId }
     });
   }
   /** Cancel a pending or running execution. */
-  async cancel(id, options) {
+  async cancel(id2, options) {
     const workspaceId = this.requireWorkspaceId(options?.workspaceId);
-    return this.http.request("POST", `/executions/${encodeURIComponent(id)}/cancel`, {
-      body: JSON.stringify({ id, workspaceId }),
+    return this.http.request("POST", `/executions/${encodeURIComponent(id2)}/cancel`, {
+      body: JSON.stringify({ id: id2, workspaceId }),
       headers: { "Content-Type": "application/json" }
     });
   }
@@ -383,16 +384,16 @@ var ExecutionsModule = class {
    * Poll an execution until it reaches a terminal status. Returns immediately if it is already
    * terminal. Throws if `timeoutMs` elapses or the supplied signal aborts.
    */
-  async wait(id, options) {
+  async wait(id2, options) {
     const interval = options?.intervalMs ?? 1e3;
     const deadline = options?.timeoutMs ? Date.now() + options.timeoutMs : void 0;
     for (; ; ) {
-      const execution = await this.get(id, { workspaceId: options?.workspaceId });
+      const execution = await this.get(id2, { workspaceId: options?.workspaceId });
       if (isTerminalStatus(execution.status)) {
         return execution;
       }
       if (deadline !== void 0 && Date.now() >= deadline) {
-        throw new Error(`Timed out waiting for execution '${id}' to complete`);
+        throw new Error(`Timed out waiting for execution '${id2}' to complete`);
       }
       await delay(interval, options?.signal);
     }
@@ -409,11 +410,11 @@ var ExecutionsModule = class {
     return this.wait(execution.id, options);
   }
   requireWorkspaceId(override) {
-    const id = override ?? this.workspaceId;
-    if (!id) {
+    const id2 = override ?? this.workspaceId;
+    if (!id2) {
       throw new Error("workspaceId is required: provide it in options or when creating the client");
     }
-    return id;
+    return id2;
   }
 };
 function serializeParameters(parameters) {
@@ -454,8 +455,8 @@ var EnginesModule = class {
       }
     });
   }
-  async get(id, options) {
-    return this.http.request("GET", `/engines/${encodeURIComponent(id)}`, {
+  async get(id2, options) {
+    return this.http.request("GET", `/engines/${encodeURIComponent(id2)}`, {
       params: { workspaceId: this.requireWorkspaceId(options?.workspaceId) }
     });
   }
@@ -676,11 +677,11 @@ var FilesModule = class {
     });
   }
   workspaceHeaders() {
-    const headers = {};
+    const headers2 = {};
     if (this.workspaceId) {
-      headers["X-Workspace-Id"] = this.workspaceId;
+      headers2["X-Workspace-Id"] = this.workspaceId;
     }
-    return headers;
+    return headers2;
   }
 };
 function requireNonBlank(value, name) {
@@ -772,14 +773,14 @@ var InstallationsModule = class {
       }
     });
   }
-  async update(id, options) {
+  async update(id2, options) {
     const workspaceId = this.requireWorkspaceId(options?.workspaceId);
     return this.http.request(
       "PUT",
-      `/installations/${encodeURIComponent(id)}`,
+      `/installations/${encodeURIComponent(id2)}`,
       {
         body: JSON.stringify({
-          id,
+          id: id2,
           workspaceId,
           packageVersion: options?.packageVersion,
           installMode: options?.installMode
@@ -788,8 +789,8 @@ var InstallationsModule = class {
       }
     );
   }
-  async uninstall(id, options) {
-    await this.http.request("DELETE", `/installations/${encodeURIComponent(id)}`, {
+  async uninstall(id2, options) {
+    await this.http.request("DELETE", `/installations/${encodeURIComponent(id2)}`, {
       params: { workspaceId: this.requireWorkspaceId(options?.workspaceId) }
     });
   }
@@ -815,10 +816,10 @@ var ResourcesModule = class {
       params: { workspaceId: this.requireWorkspaceId(options?.workspaceId) }
     });
   }
-  async get(id, options) {
+  async get(id2, options) {
     return this.http.request(
       "GET",
-      `/resources/${encodeURIComponent(id)}`,
+      `/resources/${encodeURIComponent(id2)}`,
       { params: { workspaceId: this.requireWorkspaceId(options?.workspaceId) } }
     );
   }
@@ -982,10 +983,10 @@ var NotificationsModule = class {
       }
     }
   }
-  async request(id, options) {
+  async request(id2, options) {
     return this.http.request(
       "GET",
-      `/notifications/requests/${encodeURIComponent(id)}`,
+      `/notifications/requests/${encodeURIComponent(id2)}`,
       {
         params: {
           workspaceId: this.requireWorkspaceId(options?.workspaceId),
@@ -1029,8 +1030,8 @@ var BusinessModule = class _BusinessModule {
       body: JSON.stringify(command)
     });
   }
-  async read(id) {
-    return this.http.request("GET", `/business/records/${encodeURIComponent(id)}`, { headers: this.headers() });
+  async read(id2) {
+    return this.http.request("GET", `/business/records/${encodeURIComponent(id2)}`, { headers: this.headers() });
   }
   async list(kind) {
     return this.http.request("GET", "/business/records", {
@@ -1072,6 +1073,190 @@ var BusinessModule = class _BusinessModule {
   }
 };
 
+// src/modules/chat.ts
+var JSON_HEADERS = { "Content-Type": "application/json" };
+var ChatModule = class {
+  constructor(http, bridge = null, executions) {
+    this.http = http;
+    this.bridge = bridge;
+    this.executions = executions;
+  }
+  http;
+  bridge;
+  executions;
+  // ── Conversations ─────────────────────────────────────────────────
+  listConversations(options) {
+    return this.http.request("GET", "/chat/conversations", { params: page(options) });
+  }
+  createConversation(options) {
+    const { idempotencyKey, ...body } = options;
+    return this.http.request("POST", "/chat/conversations", { body: JSON.stringify(body), headers: headers(idempotencyKey) });
+  }
+  /** Opens (or returns the existing) direct conversation with one participant. */
+  openDirect(participant) {
+    return this.createConversation({ kind: "direct", participants: [participant] });
+  }
+  getConversation(conversationId) {
+    return this.http.request("GET", `/chat/conversations/${id(conversationId)}`);
+  }
+  updateConversation(conversationId, changes) {
+    return this.http.request("PATCH", `/chat/conversations/${id(conversationId)}`, { body: JSON.stringify(changes), headers: JSON_HEADERS });
+  }
+  join(conversationId) {
+    return this.http.request("POST", `/chat/conversations/${id(conversationId)}/join`, { body: "{}", headers: JSON_HEADERS });
+  }
+  listPublicChannels(options) {
+    return this.http.request("GET", "/chat/channels", { params: { ...page(options), query: options?.query } });
+  }
+  // ── Members ───────────────────────────────────────────────────────
+  listMembers(conversationId) {
+    return this.http.request("GET", `/chat/conversations/${id(conversationId)}/members`);
+  }
+  addMembers(conversationId, participants, role) {
+    return this.http.request("POST", `/chat/conversations/${id(conversationId)}/members`, {
+      body: JSON.stringify({ participants, role }),
+      headers: JSON_HEADERS
+    });
+  }
+  /** Removes a member; pass yourself to leave. */
+  async removeMember(conversationId, participant) {
+    await this.http.request("DELETE", `/chat/conversations/${id(conversationId)}/members/${participant.kind}/${id(participant.id)}`);
+  }
+  changeRole(conversationId, participant, role) {
+    return this.http.request("PUT", `/chat/conversations/${id(conversationId)}/members/${participant.kind}/${id(participant.id)}/role`, {
+      body: JSON.stringify({ role }),
+      headers: JSON_HEADERS
+    });
+  }
+  // ── Messages ──────────────────────────────────────────────────────
+  listMessages(conversationId, options) {
+    return this.http.request("GET", `/chat/conversations/${id(conversationId)}/messages`, {
+      params: { before: options?.before, limit: options?.limit }
+    });
+  }
+  getMessage(conversationId, messageId) {
+    return this.http.request("GET", `/chat/conversations/${id(conversationId)}/messages/${id(messageId)}`);
+  }
+  send(conversationId, parts, options) {
+    return this.http.request("POST", `/chat/conversations/${id(conversationId)}/messages`, {
+      body: JSON.stringify({ parts, replyTo: options?.replyTo }),
+      headers: headers(options?.idempotencyKey)
+    });
+  }
+  /** Sends Markdown text (rendered without raw HTML by every reader). */
+  sendText(conversationId, markdown, options) {
+    return this.send(conversationId, [{ type: "text", data: { markdown } }], options);
+  }
+  /** Edits your own message; pass the revision you saw to reject a concurrent edit. */
+  edit(conversationId, messageId, parts, options) {
+    return this.http.request("PATCH", `/chat/conversations/${id(conversationId)}/messages/${id(messageId)}`, {
+      body: JSON.stringify({ parts }),
+      headers: { ...JSON_HEADERS, ...options?.revision ? { "If-Match": `"${options.revision}"` } : {} }
+    });
+  }
+  delete(conversationId, messageId) {
+    return this.http.request("DELETE", `/chat/conversations/${id(conversationId)}/messages/${id(messageId)}`);
+  }
+  /**
+   * Durable changes after a position: `afterSeq` is a snapshot's `highWatermark` (or the last sequence you applied);
+   * `after` is the `next` cursor of a previous page.
+   */
+  events(conversationId, options) {
+    return this.http.request("GET", `/chat/conversations/${id(conversationId)}/events`, {
+      params: { after: options?.after, afterSeq: options?.afterSeq, limit: options?.limit }
+    });
+  }
+  // ── Read state and preferences ────────────────────────────────────
+  /** Marks messages read through a sequence; never moves back and never past what the server has. */
+  markRead(conversationId, readThroughSeq) {
+    return this.http.request("PUT", `/chat/conversations/${id(conversationId)}/read-state`, {
+      body: JSON.stringify({ readThroughSeq }),
+      headers: JSON_HEADERS
+    });
+  }
+  setPreferences(conversationId, preferences) {
+    return this.http.request("PUT", `/chat/conversations/${id(conversationId)}/preferences`, {
+      body: JSON.stringify(preferences),
+      headers: JSON_HEADERS
+    });
+  }
+  // ── People, bots and commands ─────────────────────────────────────
+  /** People in your workspace (name and avatar only). */
+  searchPeople(options) {
+    return this.http.request("GET", "/chat/people", { params: { ...page(options), query: options?.query } });
+  }
+  listBots() {
+    return this.http.request("GET", "/chat/bots");
+  }
+  /** Workspace managers (`chat.manage`) decide whether a bot may message people directly. */
+  updateBotSettings(botId, settings) {
+    return this.http.request("PUT", `/chat/bots/${id(botId)}/settings`, { body: JSON.stringify(settings), headers: JSON_HEADERS });
+  }
+  listCommands() {
+    return this.http.request("GET", "/chat/commands");
+  }
+  /** Validates and records a command invocation, returning the Execution request to run as you. */
+  invokeCommand(conversationId, command, args, options) {
+    return this.http.request("POST", `/chat/conversations/${id(conversationId)}/commands`, {
+      body: JSON.stringify({ command, arguments: args ?? {} }),
+      headers: headers(options?.idempotencyKey)
+    });
+  }
+  /**
+   * Invokes an installed app's command and runs its script with your own authorisation. Retrying with the same
+   * idempotency key reuses the invocation key, so Execution never runs it twice.
+   */
+  async runCommand(conversationId, command, args, options) {
+    if (!this.executions) throw new Error("Running commands needs the executions module.");
+    const invocation = await this.invokeCommand(conversationId, command, args, options);
+    const execution = await this.executions.run(invocation.filePath, {
+      workspaceId: invocation.workspaceId,
+      branch: invocation.branch,
+      parameters: JSON.parse(invocation.parameters),
+      invocationKey: invocation.invocationKey
+    });
+    return { invocation, execution };
+  }
+  /**
+   * Posts as the installed app's bot from a running script. The bot is derived from the script's execution; the
+   * conversation must have added the bot (or, for `userId`, the workspace must allow it to message people).
+   * Retries briefly while Execution's start event is still on its way.
+   */
+  async postAsBot(options) {
+    const { idempotencyKey, ...body } = options;
+    const request = { body: JSON.stringify(body), headers: headers(idempotencyKey ?? globalThis.crypto?.randomUUID?.()) };
+    const deadline = Date.now() + 1e4;
+    for (; ; ) {
+      try {
+        return await this.http.request("POST", "/chat/bot-messages", request);
+      } catch (error) {
+        if (!(error instanceof ApiError) || error.status !== 409 || error.code !== "execution_not_ready") throw error;
+        const delay2 = Math.max(250, error.retryAfterMs ?? 1e3);
+        if (Date.now() + delay2 > deadline) throw error;
+        await new Promise((resolve) => setTimeout(resolve, delay2));
+      }
+    }
+  }
+  // ── Live hints ────────────────────────────────────────────────────
+  /**
+   * Subscribes to live change hints through the host (installed apps only). Returns an unsubscribe function.
+   * Hints carry ids only; duplicates and reordering are normal, and hints are lost while disconnected.
+   */
+  subscribeChanges(handlers) {
+    if (!this.bridge) throw new Error("Live chat hints are only available to apps running inside the workspace.");
+    return this.bridge.subscribeChat(handlers);
+  }
+};
+function id(value) {
+  return encodeURIComponent(value);
+}
+function page(options) {
+  return { cursor: options?.cursor, limit: options?.limit };
+}
+function headers(idempotencyKey) {
+  return idempotencyKey ? { ...JSON_HEADERS, "Idempotency-Key": idempotencyKey } : JSON_HEADERS;
+}
+
 // src/transport/app-commands.ts
 var APP_COMMAND_BATCH_SIZE = 200;
 var APP_COMMANDS_CAPABILITY = "commands";
@@ -1115,7 +1300,7 @@ function element(value) {
   return record(value) && identifier(value.id) && natural(value.version) && (value.versionNonce === void 0 || natural(value.versionNonce)) && (value.isDeleted === void 0 || typeof value.isDeleted === "boolean");
 }
 function files(value) {
-  return record(value) && Object.keys(value).length <= 1e4 && Object.entries(value).every(([id, file]) => record(file) && identifier(id) && file.id === id && typeof file.dataURL === "string" && file.dataURL.length <= 10 * 1024 * 1024 && typeof file.mimeType === "string" && file.mimeType.length > 0 && file.mimeType.length <= 128 && natural(file.created) && (file.lastRetrieved === void 0 || natural(file.lastRetrieved)));
+  return record(value) && Object.keys(value).length <= 1e4 && Object.entries(value).every(([id2, file]) => record(file) && identifier(id2) && file.id === id2 && typeof file.dataURL === "string" && file.dataURL.length <= 10 * 1024 * 1024 && typeof file.mimeType === "string" && file.mimeType.length > 0 && file.mimeType.length <= 128 && natural(file.created) && (file.lastRetrieved === void 0 || natural(file.lastRetrieved)));
 }
 function isNativeSnapshot(value) {
   if (!record(value) || !natural(value.sequence) || !natural(value.savedSequence) || value.savedSequence > value.sequence || typeof value.revision !== "string" || !value.revision || value.revision.length > 1024 || typeof value.readOnly !== "boolean" || !record(value.scene) || !Array.isArray(value.scene.elements) || value.scene.elements.length > 1e4 || !value.scene.elements.every(element) || !files(value.scene.files) || !record(value.scene.appState) || !Array.isArray(value.participants) || value.participants.length > 20)
@@ -1230,6 +1415,7 @@ var Bridge = class {
   commandFlushScheduled = false;
   commandRequests = /* @__PURE__ */ new Set();
   _hostCapabilities = [];
+  chatSubscribers = /* @__PURE__ */ new Set();
   hostMessageHandlers = /* @__PURE__ */ new Map();
   hostMessageRequests = /* @__PURE__ */ new Set();
   wopiRequests = /* @__PURE__ */ new Map();
@@ -1433,13 +1619,13 @@ var Bridge = class {
       }
     };
   }
-  queueCommand(id, change) {
+  queueCommand(id2, change) {
     if (change === "upsert") {
-      this.commandRemovals.delete(id);
-      this.commandUpserts.add(id);
+      this.commandRemovals.delete(id2);
+      this.commandUpserts.add(id2);
     } else {
-      this.commandUpserts.delete(id);
-      this.commandRemovals.add(id);
+      this.commandUpserts.delete(id2);
+      this.commandRemovals.add(id2);
     }
     this.scheduleCommandFlush();
   }
@@ -1451,14 +1637,14 @@ var Bridge = class {
       this.flushCommands();
     });
   }
-  commandSnapshot(id) {
-    const command = this.commands.get(id);
+  commandSnapshot(id2) {
+    const command = this.commands.get(id2);
     if (!command) return null;
     return command.busy ? { ...command.descriptor, busy: true } : command.descriptor;
   }
   flushCommands() {
     if (!this.sessionId || !this._hostOrigin || this._destroyed) return;
-    const upsert = [...this.commandUpserts].map((id) => this.commandSnapshot(id)).filter((c) => !!c);
+    const upsert = [...this.commandUpserts].map((id2) => this.commandSnapshot(id2)).filter((c) => !!c);
     const remove = this.commandReset ? [] : [...this.commandRemovals];
     let reset = this.commandReset;
     this.commandUpserts.clear();
@@ -1598,6 +1784,41 @@ var Bridge = class {
       this.postToHost({ ...reply, error: "The reply could not be sent to the workspace." });
     }
   }
+  /**
+   * Subscribes to the host's chat live hints (see `ChatModule.subscribeChanges`). The first subscriber asks the host
+   * to relay; the last one to leave stops it. Messages from another session are ignored.
+   */
+  subscribeChat(handlers) {
+    if (this._destroyed) throw new Error("Bridge has been destroyed.");
+    this.chatSubscribers.add(handlers);
+    const subscribe = () => {
+      if (this.sessionId && this._hostOrigin && this.chatSubscribers.size > 0)
+        this.postToHost({ type: "verentis:chat:subscribe", version: 1, sessionId: this.sessionId });
+    };
+    if (this.chatSubscribers.size === 1) {
+      if (this._hostOrigin) subscribe();
+      else void this._initPromise.then(subscribe, () => void 0);
+    }
+    return () => {
+      if (!this.chatSubscribers.delete(handlers) || this.chatSubscribers.size > 0) return;
+      if (!this._destroyed && this.sessionId && this._hostOrigin)
+        this.postToHost({ type: "verentis:chat:unsubscribe", version: 1, sessionId: this.sessionId });
+    };
+  }
+  receiveChat(data) {
+    if (data.type !== "verentis:chat:changed" && data.type !== "verentis:chat:connection" && data.type !== "verentis:chat:subscribed" && data.type !== "verentis:chat:error") return false;
+    if (!this._hostOrigin || data.sessionId !== this.sessionId) return true;
+    for (const subscriber of [...this.chatSubscribers]) {
+      try {
+        if (data.type === "verentis:chat:changed") subscriber.onChange(data.hint);
+        else if (data.type === "verentis:chat:error") subscriber.onError?.(String(data.reason).slice(0, 500));
+        else subscriber.onConnection?.(data.status);
+      } catch (error) {
+        console.error("[Verentis SDK] Chat subscriber failed", error);
+      }
+    }
+    return true;
+  }
   /** Subscribe to a specific message type from the host */
   on(type, listener) {
     if (!this.listeners.has(type)) {
@@ -1622,6 +1843,7 @@ var Bridge = class {
     this.commandRequests.clear();
     this.hostMessageHandlers.clear();
     this.hostMessageRequests.clear();
+    this.chatSubscribers.clear();
     this.listeners.clear();
     for (const pending of this.wopiRequests.values()) {
       clearTimeout(pending.timer);
@@ -1654,7 +1876,7 @@ var Bridge = class {
       if (this.sessionId && this.commands.size > 0) {
         this.commandReset = true;
         this.commandRemovals.clear();
-        for (const id of this.commands.keys()) this.commandUpserts.add(id);
+        for (const id2 of this.commands.keys()) this.commandUpserts.add(id2);
         this.scheduleCommandFlush();
       }
       console.info("[Verentis SDK] Received verentis:init from host", {
@@ -1702,6 +1924,7 @@ var Bridge = class {
       void this.receiveHostMessage(data);
       return;
     }
+    if (this.receiveChat(data)) return;
     const typeListeners = this.listeners.get(data.type);
     if (typeListeners) {
       for (const listener of typeListeners) {
@@ -1736,17 +1959,17 @@ var HttpTransport = class {
   async request(method, path, options) {
     const url = this.buildUrl(path, options?.params);
     console.info("[Verentis SDK] Request started", { method, path, url });
-    const headers = {};
+    const headers2 = {};
     const authHeader = await this.auth.getAuthHeader();
     if (authHeader) {
-      headers["Authorization"] = authHeader;
+      headers2["Authorization"] = authHeader;
     }
     if (options?.headers) {
-      Object.assign(headers, options.headers);
+      Object.assign(headers2, options.headers);
     }
     const response = await fetch(url, {
       method,
-      headers,
+      headers: headers2,
       body: options?.body
     });
     await this.ensureSuccess(response);
@@ -1765,15 +1988,15 @@ var HttpTransport = class {
   async requestRaw(method, path, options) {
     const url = this.buildUrl(path, options?.params);
     console.info("[Verentis SDK] Raw request started", { method, path, url });
-    const headers = {};
+    const headers2 = {};
     const authHeader = await this.auth.getAuthHeader();
     if (authHeader) {
-      headers["Authorization"] = authHeader;
+      headers2["Authorization"] = authHeader;
     }
     if (options?.headers) {
-      Object.assign(headers, options.headers);
+      Object.assign(headers2, options.headers);
     }
-    const response = await fetch(url, { method, headers, body: options?.body });
+    const response = await fetch(url, { method, headers: headers2, body: options?.body });
     console.info("[Verentis SDK] Raw request completed", {
       method,
       path,
@@ -1842,6 +2065,7 @@ var VerentisClient = class {
   settings;
   notifications;
   business;
+  chat;
   context;
   bridge;
   collaboration;
@@ -1878,6 +2102,7 @@ var VerentisClient = class {
       this.settings = new SettingsModule(this._http, options?.workspaceId);
       this.notifications = new NotificationsModule(this._http, options?.workspaceId);
       this.business = new BusinessModule(this._http);
+      this.chat = new ChatModule(this._http, null, this.executions);
       this._ready = Promise.resolve();
       return;
     }
@@ -1928,6 +2153,7 @@ var VerentisClient = class {
     this.settings = new SettingsModule(http, context.workspace.id);
     this.notifications = new NotificationsModule(http, context.workspace.id);
     this.business = new BusinessModule(http);
+    this.chat = new ChatModule(http, this.bridge, this.executions);
   }
 };
 function detectEnvironment() {
@@ -2031,6 +2257,7 @@ exports.ApiKeyAuth = ApiKeyAuth;
 exports.Bridge = Bridge;
 exports.BridgeAuth = BridgeAuth;
 exports.BusinessModule = BusinessModule;
+exports.ChatModule = ChatModule;
 exports.ContextModule = ContextModule;
 exports.EnginesModule = EnginesModule;
 exports.ExecutionsModule = ExecutionsModule;