@nurama/sdk 1.4.3 → 1.4.5

package/src/routes/project.ts

@@ -19,6 +19,7 @@ import {
   type FeedVisibility,
   type ListFeedEventsParams,
   type CursorPaginatedFeedEvents,
+  type ReadState,
 } from '@nurama/types';
 
 // Combine pagination metadata with a results array
@@ -597,6 +598,44 @@ export default function createProjectMethods(client: NuramaClient) {
       });
     },
 
+    /**
+     * Gets where you had read up to in a project feed, and how many cards have
+     * moved since. `lastReadAt` is null if you have never recorded a position,
+     * and `unreadCount` is 0 then. Cards you are the actor on never count.
+     * @param {string} projectId - The ID of the project.
+     * @param {'creator' | 'reviewer'} visibility - Which feed to read.
+     * @returns {Promise<ReadState>} Your reading position in that feed.
+     */
+    async getFeedReadState(projectId: string, visibility: FeedVisibility): Promise<ReadState> {
+      if (!projectId) throw new Error('projectId is required.');
+      if (!visibility) throw new Error('visibility is required (creator or reviewer).');
+
+      return client._request<ReadState>({
+        method: 'GET',
+        endpoint: `/v1/projects/${projectId}/feed-events/${visibility}/read-state`,
+        sendJWT: true,
+      });
+    },
+
+    /**
+     * Marks a project feed as caught up. Pass `lastReadAt` (epoch ms) to catch
+     * up to the newest card you had loaded; omit it to catch up to now. The
+     * marker only moves forward and never past the present, so a stale value is
+     * a no-op rather than an error.
+     * @returns {Promise<ReadState>} Your updated reading position.
+     */
+    async markFeedCaughtUp(projectId: string, visibility: FeedVisibility, lastReadAt?: number): Promise<ReadState> {
+      if (!projectId) throw new Error('projectId is required.');
+      if (!visibility) throw new Error('visibility is required (creator or reviewer).');
+
+      return client._request<ReadState>({
+        method: 'POST',
+        endpoint: `/v1/projects/${projectId}/feed-events/${visibility}/read-state`,
+        body: lastReadAt === undefined ? {} : { lastReadAt },
+        sendJWT: true,
+      });
+    },
+
     // --- Folder Listing ---
 
     /**

package/src/routes/task.ts

@@ -28,6 +28,8 @@ export interface GetTasksBaseParams extends SortParams {
     relatedToId?: string;
     visibility?: TaskVisibility;
     acknowledged?: boolean;
+    /** `'chatMessage'` returns only mention-tasks; without it, board tasks assigned to you come too. */
+    originType?: 'chatMessage';
     limit?: number;
 }
 
@@ -223,31 +225,29 @@ export default function createTaskMethods(client: NuramaClient) {
     },
 
     /**
-         * Retrieves the count of unacknowledged tasks for the current user within a specific project.
-         * Requires authentication.
-         * @param {string} projectId - The ID of the project.
+         * Retrieves the count of unacknowledged tasks for the current user within a specific project,
+         * or across every project when none is given. Requires authentication.
+         * @param {string} [projectId] - The ID of the project; omit for every project.
          * @returns {Promise<UnacknowledgedTaskCountResponse>} An object containing total, creator, and reviewer unacknowledged task counts.
          */
-    async getUnacknowledgedTaskCount(projectId: string): Promise<UnacknowledgedTaskCountResponse> {
-      if (!projectId) throw new Error('projectId is required.');
+    async getUnacknowledgedTaskCount(projectId?: string): Promise<UnacknowledgedTaskCountResponse> {
       return client._request<UnacknowledgedTaskCountResponse>({
         method: 'GET',
-        endpoint: `/v1/tasks/unacknowledged/${projectId}`,
+        endpoint: projectId ? `/v1/tasks/unacknowledged/${projectId}` : '/v1/tasks/unacknowledged',
         sendJWT: true,
       });
     },
 
     /**
          * Acknowledge every unacknowledged mention-task the current user has in a
-         * project. Idempotent server-side.
-         * @param {string} projectId - The ID of the project.
+         * project, or in every project when none is given. Idempotent server-side.
+         * @param {string} [projectId] - The ID of the project; omit for every project.
          * @returns {Promise<AcknowledgeAllTasksResponse>} The number acknowledged and the remaining unacknowledged count.
          */
-    async acknowledgeAllTasks(projectId: string): Promise<AcknowledgeAllTasksResponse> {
-      if (!projectId) throw new Error('projectId is required.');
+    async acknowledgeAllTasks(projectId?: string): Promise<AcknowledgeAllTasksResponse> {
       return client._request<AcknowledgeAllTasksResponse>({
         method: 'PUT',
-        endpoint: `/v1/tasks/acknowledge-all/${projectId}`,
+        endpoint: projectId ? `/v1/tasks/acknowledge-all/${projectId}` : '/v1/tasks/acknowledge-all',
         sendJWT: true,
       });
     },

package/src/routes/userFeed.ts

@@ -0,0 +1,113 @@
+import NuramaClient from '../NuramaClient.js';
+import {
+  type ObjectId,
+  type ReadState,
+  type ListUserFeedParams,
+  type CursorPaginatedUserFeed,
+  type UserFeedEntry,
+  type UserFeedSummary,
+} from '@nurama/types';
+
+/**
+ * Defines the methods for the caller's own cross-project feed: project
+ * activity from every project they can read, and the things waiting on them.
+ * Every call is scoped to the signed-in user.
+ * @param {NuramaClient} client - The NuramaClient instance.
+ * @returns {object} An object containing the user feed methods.
+ */
+export default function createUserFeedMethods(client: NuramaClient) {
+  return {
+    /**
+     * Gets one page of your feed, most recent first. Pass `category` for only
+     * project activity or only action items; dismissed items are left out
+     * unless `states` asks for them.
+     * @returns {Promise<CursorPaginatedUserFeed>}
+     */
+    async getFeed(params?: ListUserFeedParams): Promise<CursorPaginatedUserFeed> {
+      return client._request<CursorPaginatedUserFeed>({
+        method: 'GET',
+        endpoint: '/v1/users/feed',
+        params,
+        sendJWT: true,
+      });
+    },
+
+    /**
+     * Gets every badge the app shows: open action items, project activity since
+     * you last caught up, and that activity broken down by project in
+     * `byProject` — one row per project with something new, for the badge on
+     * its icon. The two totals stop at 100.
+     *
+     * The totals and `byProject` move independently: the totals are measured
+     * against your feed-wide marker, each `byProject` row against that
+     * project's own. So catching up in the feed does not clear project badges,
+     * and reading one project does not clear the feed's own count.
+     * @returns {Promise<UserFeedSummary>}
+     */
+    async getSummary(): Promise<UserFeedSummary> {
+      return client._request<UserFeedSummary>({
+        method: 'GET',
+        endpoint: '/v1/users/feed/summary',
+        sendJWT: true,
+      });
+    },
+
+    /**
+     * Gets your reading position in your feed's project activity.
+     * @returns {Promise<ReadState>}
+     */
+    async getReadState(): Promise<ReadState> {
+      return client._request<ReadState>({
+        method: 'GET',
+        endpoint: '/v1/users/feed/read-state',
+        sendJWT: true,
+      });
+    },
+
+    /**
+     * Marks your feed's project activity as caught up. Pass `lastReadAt`
+     * (epoch ms) to catch up to the newest card you had loaded; omit it to
+     * catch up to now. The marker only moves forward.
+     * @returns {Promise<ReadState>}
+     */
+    async markCaughtUp(lastReadAt?: number): Promise<ReadState> {
+      return client._request<ReadState>({
+        method: 'POST',
+        endpoint: '/v1/users/feed/read-state',
+        body: lastReadAt === undefined ? {} : { lastReadAt },
+        sendJWT: true,
+      });
+    },
+
+    /**
+     * Clears one of your action items (`dismissed`), or brings a cleared one
+     * back (`open`).
+     * @returns {Promise<UserFeedEntry>} The updated item.
+     */
+    async setEntryState(entryId: ObjectId, state: 'dismissed' | 'open'): Promise<UserFeedEntry> {
+      if (!entryId) throw new Error('entryId is required.');
+
+      return client._request<UserFeedEntry>({
+        method: 'PATCH',
+        endpoint: `/v1/users/feed/${entryId}`,
+        body: { state },
+        sendJWT: true,
+      });
+    },
+
+    /**
+     * Clears every open action item up to `before` (epoch ms) — the newest one
+     * you had loaded — so one that arrived since stays. Omit it to clear
+     * everything open now.
+     * @returns {Promise<{ dismissed: number }>}
+     */
+    async dismissAll(before?: number): Promise<{ dismissed: number }> {
+      return client._request<{ dismissed: number }>({
+        method: 'POST',
+        endpoint: '/v1/users/feed/dismiss',
+        body: before === undefined ? {} : { before },
+        sendJWT: true,
+      });
+    },
+  };
+}

package/src/version.ts

@@ -14,9 +14,9 @@ export interface SDKVersionInfo {
 }
 
 export const SDK_VERSION: SDKVersionInfo = {
-  version: '1.4.3',
-  buildTimestamp: '2026-10-14T13:35:12.378Z',
-  buildHash: 'df74c9b4b055b19a9012e0c265c3b94f',
-  gitCommit: 'b66adea',
+  version: '1.4.5',
+  buildTimestamp: '2026-10-29T06:59:31.498Z',
+  buildHash: 'b0bbfd265120e5fd826237cc63c5bf7d',
+  gitCommit: '9307f8f',
   dirty: false,
 };