linkedapi 1.1.0__tar.gz → 1.2.0__tar.gz

{linkedapi-1.1.0 → linkedapi-1.2.0}/.github/workflows/publish.yaml

@@ -10,10 +10,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.12'
 
@@ -38,10 +38,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.12'
 

{linkedapi-1.1.0 → linkedapi-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linkedapi
-Version: 1.1.0
+Version: 1.2.0
 Summary: Official synchronous Python SDK for Linked API.
 Project-URL: Homepage, https://linkedapi.io
 Project-URL: Repository, https://github.com/Linked-API/linkedapi-python

{linkedapi-1.1.0 → linkedapi-1.2.0}/linkedapi/__init__.py

@@ -29,6 +29,7 @@ from linkedapi.mappers import (
     VoidWorkflowMapper,
 )
 from linkedapi.operations import (
+    AcceptConnectionRequest,
     CheckConnectionStatus,
     CommentOnPost,
     CreatePost,
@@ -41,16 +42,21 @@ from linkedapi.operations import (
     FetchPersonMapper,
     FetchPost,
     FetchPostMapper,
+    IgnoreConnectionRequest,
+    ManageConversation,
     NvFetchCompany,
     NvFetchCompanyMapper,
     NvFetchPerson,
     NvFetchPersonMapper,
+    NvManageConversation,
     NvSearchCompanies,
     NvSearchPeople,
     NvSendMessage,
     NvSyncConversation,
+    NvSyncInbox,
     ReactToPost,
     RemoveConnection,
+    RetrieveConnectionRequests,
     RetrieveConnections,
     RetrievePendingRequests,
     RetrievePerformance,
@@ -61,17 +67,19 @@ from linkedapi.operations import (
     SendConnectionRequest,
     SendMessage,
     SyncConversation,
+    SyncInbox,
     WithdrawConnectionRequest,
 )
 from linkedapi.types import *  # noqa: F403
 from linkedapi.types import __all__ as _types_all
 from linkedapi.webhooks import parse_webhook_event
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 PredefinedOperation = Operation
 
 __all__ = [
     *_types_all,
+    "AcceptConnectionRequest",
     "AdminAccounts",
     "AdminHttpClient",
     "AdminLimits",
@@ -93,6 +101,7 @@ __all__ = [
     "FetchPost",
     "FetchPostMapper",
     "HttpClient",
+    "IgnoreConnectionRequest",
     "LINKED_API_ACTION_ERROR_TYPES",
     "LINKED_API_ERROR_TYPES",
     "LinkedApi",
@@ -103,20 +112,24 @@ __all__ = [
     "LinkedApiErrorType",
     "LinkedApiHttpClient",
     "LinkedApiWorkflowTimeoutError",
+    "ManageConversation",
     "MappedResponse",
     "NvFetchCompany",
     "NvFetchCompanyMapper",
     "NvFetchPerson",
     "NvFetchPersonMapper",
+    "NvManageConversation",
     "NvSearchCompanies",
     "NvSearchPeople",
     "NvSendMessage",
     "NvSyncConversation",
+    "NvSyncInbox",
     "Operation",
     "PredefinedOperation",
     "ReactToPost",
     "RemoveConnection",
     "ResponseMapping",
+    "RetrieveConnectionRequests",
     "RetrieveConnections",
     "RetrievePendingRequests",
     "RetrievePerformance",
@@ -128,6 +141,7 @@ __all__ = [
     "SendMessage",
     "SimpleWorkflowMapper",
     "SyncConversation",
+    "SyncInbox",
     "ThenWorkflowMapper",
     "VoidWorkflowMapper",
     "WithdrawConnectionRequest",

{linkedapi-1.1.0 → linkedapi-1.2.0}/linkedapi/client.py

@@ -8,6 +8,7 @@ from linkedapi.errors import LinkedApiError
 from linkedapi.http import HttpClient, LinkedApiHttpClient
 from linkedapi.mappers import MappedResponse
 from linkedapi.operations import (
+    AcceptConnectionRequest,
     CheckConnectionStatus,
     CommentOnPost,
     CreatePost,
@@ -16,14 +17,19 @@ from linkedapi.operations import (
     FetchJob,
     FetchPerson,
     FetchPost,
+    IgnoreConnectionRequest,
+    ManageConversation,
     NvFetchCompany,
     NvFetchPerson,
+    NvManageConversation,
     NvSearchCompanies,
     NvSearchPeople,
     NvSendMessage,
     NvSyncConversation,
+    NvSyncInbox,
     ReactToPost,
     RemoveConnection,
+    RetrieveConnectionRequests,
     RetrieveConnections,
     RetrievePendingRequests,
     RetrievePerformance,
@@ -34,10 +40,16 @@ from linkedapi.operations import (
     SendConnectionRequest,
     SendMessage,
     SyncConversation,
+    SyncInbox,
     WithdrawConnectionRequest,
 )
 from linkedapi.types import AccountInfo, LinkedApiActionError, serialize_value
-from linkedapi.types.message import ConversationPollRequest, ConversationPollResult
+from linkedapi.types.message import (
+    ConversationPollRequest,
+    ConversationPollResult,
+    InboxMessage,
+    InboxPollRequest,
+)
 from linkedapi.types.statistics import ApiUsageAction, ApiUsageParams
 
 
@@ -54,10 +66,15 @@ class LinkedApi:
         self.custom_workflow = CustomWorkflow(self.http_client)
         self.send_message = SendMessage(self.http_client)
         self.sync_conversation = SyncConversation(self.http_client)
+        self.sync_inbox = SyncInbox(self.http_client)
+        self.manage_conversation = ManageConversation(self.http_client)
         self.check_connection_status = CheckConnectionStatus(self.http_client)
         self.send_connection_request = SendConnectionRequest(self.http_client)
         self.withdraw_connection_request = WithdrawConnectionRequest(self.http_client)
+        self.accept_connection_request = AcceptConnectionRequest(self.http_client)
+        self.ignore_connection_request = IgnoreConnectionRequest(self.http_client)
         self.retrieve_pending_requests = RetrievePendingRequests(self.http_client)
+        self.retrieve_connection_requests = RetrieveConnectionRequests(self.http_client)
         self.retrieve_connections = RetrieveConnections(self.http_client)
         self.remove_connection = RemoveConnection(self.http_client)
         self.search_companies = SearchCompanies(self.http_client)
@@ -74,6 +91,8 @@ class LinkedApi:
         self.retrieve_performance = RetrievePerformance(self.http_client)
         self.nv_send_message = NvSendMessage(self.http_client)
         self.nv_sync_conversation = NvSyncConversation(self.http_client)
+        self.nv_sync_inbox = NvSyncInbox(self.http_client)
+        self.nv_manage_conversation = NvManageConversation(self.http_client)
         self.nv_search_companies = NvSearchCompanies(self.http_client)
         self.nv_search_people = NvSearchPeople(self.http_client)
         self.nv_fetch_company = NvFetchCompany(self.http_client)
@@ -83,10 +102,15 @@ class LinkedApi:
             self.custom_workflow,
             self.send_message,
             self.sync_conversation,
+            self.sync_inbox,
+            self.manage_conversation,
             self.check_connection_status,
             self.send_connection_request,
             self.withdraw_connection_request,
+            self.accept_connection_request,
+            self.ignore_connection_request,
             self.retrieve_pending_requests,
+            self.retrieve_connection_requests,
             self.retrieve_connections,
             self.remove_connection,
             self.search_companies,
@@ -103,6 +127,8 @@ class LinkedApi:
             self.retrieve_performance,
             self.nv_send_message,
             self.nv_sync_conversation,
+            self.nv_sync_inbox,
+            self.nv_manage_conversation,
             self.nv_search_companies,
             self.nv_search_people,
             self.nv_fetch_company,
@@ -139,6 +165,30 @@ class LinkedApi:
                 )
             raise
 
+    def poll_inbox(
+        self,
+        request: InboxPollRequest | None = None,
+    ) -> MappedResponse[list[InboxMessage]]:
+        """Read the monitored standard or Sales Navigator inbox, newest messages first."""
+
+        payload = serialize_value(request) if request is not None else {}
+        response = self.http_client.post("/inbox/poll", payload)
+        if response.success and response.result is not None:
+            messages = response.result.get("messages", [])
+            return MappedResponse(
+                data=[InboxMessage.model_validate(item) for item in messages],
+                errors=[],
+            )
+        return MappedResponse(
+            data=None,
+            errors=[
+                LinkedApiActionError(
+                    type=response.error.type if response.error else "",
+                    message=response.error.message if response.error else "",
+                ),
+            ],
+        )
+
     def get_account_info(self) -> MappedResponse[AccountInfo]:
         """Retrieve basic information about the current LinkedIn account."""
 

{linkedapi-1.1.0 → linkedapi-1.2.0}/linkedapi/errors.py

@@ -23,6 +23,7 @@ LinkedApiActionErrorType = Literal[
     "noPostingPermission",
     "noSalesNavigator",
     "conversationsNotSynced",
+    "threadNotFound",
 ]
 LINKED_API_ACTION_ERROR_TYPES: tuple[str, ...] = (
     "personNotFound",
@@ -45,6 +46,7 @@ LINKED_API_ACTION_ERROR_TYPES: tuple[str, ...] = (
     "noPostingPermission",
     "noSalesNavigator",
     "conversationsNotSynced",
+    "threadNotFound",
 )
 
 LinkedApiErrorType = Literal[

{linkedapi-1.1.0 → linkedapi-1.2.0}/linkedapi/operations/__init__.py

@@ -1,3 +1,4 @@
+from linkedapi.operations.accept_connection_request import AcceptConnectionRequest
 from linkedapi.operations.check_connection_status import CheckConnectionStatus
 from linkedapi.operations.comment_on_post import CommentOnPost
 from linkedapi.operations.create_post import CreatePost
@@ -6,14 +7,19 @@ from linkedapi.operations.fetch_company import FetchCompany, FetchCompanyMapper
 from linkedapi.operations.fetch_job import FetchJob, FetchJobMapper
 from linkedapi.operations.fetch_person import FetchPerson, FetchPersonMapper
 from linkedapi.operations.fetch_post import FetchPost, FetchPostMapper
+from linkedapi.operations.ignore_connection_request import IgnoreConnectionRequest
+from linkedapi.operations.manage_conversation import ManageConversation
 from linkedapi.operations.nv_fetch_company import NvFetchCompany, NvFetchCompanyMapper
 from linkedapi.operations.nv_fetch_person import NvFetchPerson, NvFetchPersonMapper
+from linkedapi.operations.nv_manage_conversation import NvManageConversation
 from linkedapi.operations.nv_search_companies import NvSearchCompanies
 from linkedapi.operations.nv_search_people import NvSearchPeople
 from linkedapi.operations.nv_send_message import NvSendMessage
 from linkedapi.operations.nv_sync_conversation import NvSyncConversation
+from linkedapi.operations.nv_sync_inbox import NvSyncInbox
 from linkedapi.operations.react_to_post import ReactToPost
 from linkedapi.operations.remove_connection import RemoveConnection
+from linkedapi.operations.retrieve_connection_requests import RetrieveConnectionRequests
 from linkedapi.operations.retrieve_connections import RetrieveConnections
 from linkedapi.operations.retrieve_pending_requests import RetrievePendingRequests
 from linkedapi.operations.retrieve_performance import RetrievePerformance
@@ -24,9 +30,11 @@ from linkedapi.operations.search_people import SearchPeople
 from linkedapi.operations.send_connection_request import SendConnectionRequest
 from linkedapi.operations.send_message import SendMessage
 from linkedapi.operations.sync_conversation import SyncConversation
+from linkedapi.operations.sync_inbox import SyncInbox
 from linkedapi.operations.withdraw_connection_request import WithdrawConnectionRequest
 
 __all__ = [
+    "AcceptConnectionRequest",
     "CheckConnectionStatus",
     "CommentOnPost",
     "CreatePost",
@@ -39,16 +47,21 @@ __all__ = [
     "FetchPersonMapper",
     "FetchPost",
     "FetchPostMapper",
+    "IgnoreConnectionRequest",
+    "ManageConversation",
     "NvFetchCompany",
     "NvFetchCompanyMapper",
     "NvFetchPerson",
     "NvFetchPersonMapper",
+    "NvManageConversation",
     "NvSearchCompanies",
     "NvSearchPeople",
     "NvSendMessage",
     "NvSyncConversation",
+    "NvSyncInbox",
     "ReactToPost",
     "RemoveConnection",
+    "RetrieveConnectionRequests",
     "RetrieveConnections",
     "RetrievePendingRequests",
     "RetrievePerformance",
@@ -59,5 +72,6 @@ __all__ = [
     "SendConnectionRequest",
     "SendMessage",
     "SyncConversation",
+    "SyncInbox",
     "WithdrawConnectionRequest",
 ]

linkedapi-1.2.0/linkedapi/operations/accept_connection_request.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import AcceptConnectionRequestParams
+
+
+class AcceptConnectionRequest(Operation[AcceptConnectionRequestParams, None]):
+    """Accept an incoming standard LinkedIn connection request."""
+
+    operation_name = "acceptConnectionRequest"
+    mapper = VoidWorkflowMapper[AcceptConnectionRequestParams]("st.acceptConnectionRequest")

linkedapi-1.2.0/linkedapi/operations/ignore_connection_request.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import IgnoreConnectionRequestParams
+
+
+class IgnoreConnectionRequest(Operation[IgnoreConnectionRequestParams, None]):
+    """Ignore an incoming standard LinkedIn connection request."""
+
+    operation_name = "ignoreConnectionRequest"
+    mapper = VoidWorkflowMapper[IgnoreConnectionRequestParams]("st.ignoreConnectionRequest")

linkedapi-1.2.0/linkedapi/operations/manage_conversation.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import ManageConversationParams
+
+
+class ManageConversation(Operation[ManageConversationParams, None]):
+    """Manage a standard LinkedIn conversation thread."""
+
+    operation_name = "manageConversation"
+    mapper = VoidWorkflowMapper[ManageConversationParams]("st.manageConversation")

linkedapi-1.2.0/linkedapi/operations/nv_manage_conversation.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import NvManageConversationParams
+
+
+class NvManageConversation(Operation[NvManageConversationParams, None]):
+    """Manage a Sales Navigator conversation thread."""
+
+    operation_name = "nvManageConversation"
+    mapper = VoidWorkflowMapper[NvManageConversationParams]("nv.manageConversation")

linkedapi-1.2.0/linkedapi/operations/nv_sync_inbox.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import NvSyncInboxParams
+
+
+class NvSyncInbox(Operation[NvSyncInboxParams, None]):
+    """Enable whole-inbox monitoring for Sales Navigator conversations."""
+
+    operation_name = "nvSyncInbox"
+    mapper = VoidWorkflowMapper[NvSyncInboxParams]("nv.syncInbox")

linkedapi-1.2.0/linkedapi/operations/retrieve_connection_requests.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ArrayWorkflowMapper
+from linkedapi.types import RetrieveConnectionRequestsResult
+
+
+class RetrieveConnectionRequests(Operation[None, list[RetrieveConnectionRequestsResult]]):
+    """Retrieve incoming standard LinkedIn connection requests."""
+
+    operation_name = "retrieveConnectionRequests"
+    mapper = ArrayWorkflowMapper[None, RetrieveConnectionRequestsResult](
+        "st.retrieveConnectionRequests",
+        RetrieveConnectionRequestsResult,
+    )

linkedapi-1.2.0/linkedapi/operations/sync_inbox.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import SyncInboxParams
+
+
+class SyncInbox(Operation[SyncInboxParams, None]):
+    """Enable whole-inbox monitoring for standard LinkedIn conversations."""
+
+    operation_name = "syncInbox"
+    mapper = VoidWorkflowMapper[SyncInboxParams]("st.syncInbox")

{linkedapi-1.1.0 → linkedapi-1.2.0}/linkedapi/types/__init__.py

@@ -68,13 +68,16 @@ from linkedapi.types.company import (
     StCompanyEmployeesRetrievalConfig,
 )
 from linkedapi.types.connection import (
+    AcceptConnectionRequestParams,
     CheckConnectionStatusParams,
     CheckConnectionStatusResult,
     ConnectionPerson,
     ConnectionStatus,
+    IgnoreConnectionRequestParams,
     NvOpenPersonPageParams,
     NvOpenPersonPageResult,
     RemoveConnectionParams,
+    RetrieveConnectionRequestsResult,
     RetrieveConnectionsFilter,
     RetrieveConnectionsParams,
     RetrieveConnectionsResult,
@@ -101,12 +104,18 @@ from linkedapi.types.message import (
     ConversationPollRequest,
     ConversationPollResult,
     ConversationType,
+    InboxMessage,
+    InboxPollRequest,
+    ManageConversationParams,
     Message,
     MessageSender,
+    NvManageConversationParams,
     NvSendMessageParams,
     NvSyncConversationParams,
+    NvSyncInboxParams,
     SendMessageParams,
     SyncConversationParams,
+    SyncInboxParams,
 )
 from linkedapi.types.params import BaseActionParams, LimitParams, LimitSinceParams
 from linkedapi.types.person import (
@@ -183,6 +192,8 @@ from linkedapi.types.webhooks import (
     AccountWebhookEventData,
     AccountWebhookStatus,
     DeleteWebhookParams,
+    MessageWebhookEvent,
+    MessageWebhookEventData,
     ReplayWebhookDeliveryParams,
     SetWebhookParams,
     SetWebhookPayloadModeParams,
@@ -213,6 +224,7 @@ from linkedapi.types.workflow import (
 )
 
 __all__ = [
+    "AcceptConnectionRequestParams",
     "AccountInfo",
     "AccountWebhookEvent",
     "AccountWebhookEventData",
@@ -269,6 +281,9 @@ __all__ = [
     "GetConnectionSessionParams",
     "GetLimitsParams",
     "GetLimitsUsageParams",
+    "IgnoreConnectionRequestParams",
+    "InboxMessage",
+    "InboxPollRequest",
     "Job",
     "JobCurrency",
     "JobDatePosted",
@@ -290,9 +305,12 @@ __all__ = [
     "LinkedApiRequestError",
     "LinkedApiResponse",
     "LocationType",
+    "ManageConversationParams",
     "MaxAnnualRevenue",
     "Message",
     "MessageSender",
+    "MessageWebhookEvent",
+    "MessageWebhookEventData",
     "MinAnnualRevenue",
     "NvBaseFetchCompanyParams",
     "NvBaseFetchCompanyParamsWide",
@@ -303,6 +321,7 @@ __all__ = [
     "NvCompanyEmployeeRetrievalConfig",
     "NvFetchCompanyParams",
     "NvFetchCompanyResult",
+    "NvManageConversationParams",
     "NvOpenPersonPageParams",
     "NvOpenPersonPageResult",
     "NvSearchCompaniesFilter",
@@ -313,6 +332,7 @@ __all__ = [
     "NvSearchPeopleResult",
     "NvSendMessageParams",
     "NvSyncConversationParams",
+    "NvSyncInboxParams",
     "PendingConnectionSession",
     "Person",
     "PersonEducation",
@@ -341,6 +361,7 @@ __all__ = [
     "ReparseAccountInfoResult",
     "ReplayWebhookDeliveryParams",
     "ResetLimitsParams",
+    "RetrieveConnectionRequestsResult",
     "RetrieveConnectionsFilter",
     "RetrieveConnectionsParams",
     "RetrieveConnectionsResult",
@@ -377,6 +398,7 @@ __all__ = [
     "SubscriptionStatus",
     "SubscriptionStatusValue",
     "SyncConversationParams",
+    "SyncInboxParams",
     "WebhookDelivery",
     "WebhookDeliveryStatus",
     "WebhookEvent",

{linkedapi-1.1.0 → linkedapi-1.2.0}/linkedapi/types/connection.py

@@ -5,7 +5,7 @@ from typing import Literal
 from linkedapi.types.base import LinkedApiModel
 from linkedapi.types.params import BaseActionParams, LimitParams
 
-ConnectionStatus = Literal["connected", "pending", "notConnected"]
+ConnectionStatus = Literal["connected", "pending", "incoming", "notConnected"]
 
 
 class ConnectionPerson(LinkedApiModel):
@@ -42,6 +42,20 @@ class RetrievePendingRequestsResult(LinkedApiModel):
     sent_time: str | None = None
 
 
+class AcceptConnectionRequestParams(BaseActionParams):
+    person_url: str
+
+
+class IgnoreConnectionRequestParams(BaseActionParams):
+    person_url: str
+
+
+class RetrieveConnectionRequestsResult(LinkedApiModel):
+    name: str | None = None
+    public_url: str | None = None
+    headline: str | None = None
+
+
 class RetrieveConnectionsFilter(LinkedApiModel):
     first_name: str | None = None
     last_name: str | None = None

{linkedapi-1.1.0 → linkedapi-1.2.0}/linkedapi/types/message.py

@@ -10,24 +10,44 @@ MessageSender = Literal["us", "them"]
 
 
 class SendMessageParams(BaseActionParams):
-    person_url: str
     text: str
+    person_url: str | None = None
+    thread_id: str | None = None
 
 
 class SyncConversationParams(BaseActionParams):
     person_url: str
 
 
+class SyncInboxParams(BaseActionParams):
+    pass
+
+
+class ManageConversationParams(BaseActionParams):
+    thread_id: str
+    operation: str
+
+
 class NvSendMessageParams(BaseActionParams):
-    person_url: str
     text: str
-    subject: str
+    person_url: str | None = None
+    subject: str | None = None
+    thread_id: str | None = None
 
 
 class NvSyncConversationParams(BaseActionParams):
     person_url: str
 
 
+class NvSyncInboxParams(BaseActionParams):
+    pass
+
+
+class NvManageConversationParams(BaseActionParams):
+    thread_id: str
+    operation: str
+
+
 class ConversationPollRequest(LinkedApiModel):
     person_url: str
     type: ConversationType
@@ -39,6 +59,7 @@ class Message(LinkedApiModel):
     sender: MessageSender | None = None
     text: str | None = None
     time: str | None = None
+    thread_id: str | None = None
 
 
 class ConversationPollResult(LinkedApiModel):
@@ -46,3 +67,19 @@ class ConversationPollResult(LinkedApiModel):
     type: ConversationType | None = None
     messages: list[Message] | None = None
     since: str | None = None
+
+
+class InboxPollRequest(LinkedApiModel):
+    since: str | None = None
+    type: ConversationType | None = None
+    thread_id: str | None = None
+
+
+class InboxMessage(LinkedApiModel):
+    id: str | None = None
+    type: ConversationType | None = None
+    thread_id: str | None = None
+    person_url: str | None = None
+    sender: MessageSender | None = None
+    text: str | None = None
+    time: str | None = None

{linkedapi-1.1.0 → linkedapi-1.2.0}/linkedapi/types/webhooks.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import Any, Literal
 
 from linkedapi.types.base import LinkedApiModel
+from linkedapi.types.message import ConversationType, MessageSender
 
 WebhookPayloadMode = Literal["thin", "fat"]
 WebhookEventType = Literal[
@@ -13,6 +14,8 @@ WebhookEventType = Literal[
     "account.reconnectionRequired",
     "account.frozen",
     "account.deleted",
+    "inbox.messageReceived",
+    "inbox.messageSent",
     "webhook.test",
 ]
 WebhookDeliveryStatus = Literal["pending", "delivering", "success", "failed"]
@@ -91,6 +94,24 @@ class AccountWebhookEvent(LinkedApiModel):
     data: AccountWebhookEventData
 
 
+class MessageWebhookEventData(LinkedApiModel):
+    account_id: str | None = None
+    type: ConversationType | None = None
+    thread_id: str | None = None
+    person_url: str | None = None
+    message_id: str | None = None
+    sender: MessageSender | None = None
+    text: str | None = None
+    time: str | None = None
+
+
+class MessageWebhookEvent(LinkedApiModel):
+    id: str
+    type: Literal["inbox.messageReceived", "inbox.messageSent"]
+    created_at: str | None = None
+    data: MessageWebhookEventData
+
+
 class WebhookTestEventData(LinkedApiModel):
     message: str | None = None
 
@@ -102,4 +123,6 @@ class WebhookTestEvent(LinkedApiModel):
     data: WebhookTestEventData
 
 
-WebhookEvent = WorkflowWebhookEvent | AccountWebhookEvent | WebhookTestEvent
+WebhookEvent = (
+    WorkflowWebhookEvent | AccountWebhookEvent | MessageWebhookEvent | WebhookTestEvent
+)

{linkedapi-1.1.0 → linkedapi-1.2.0}/linkedapi/webhooks/parse.py

@@ -4,6 +4,7 @@ import json
 
 from linkedapi.types.webhooks import (
     AccountWebhookEvent,
+    MessageWebhookEvent,
     WebhookEvent,
     WebhookTestEvent,
     WorkflowWebhookEvent,
@@ -41,6 +42,8 @@ def parse_webhook_event(raw_body: str | bytes) -> WebhookEvent:
         return WorkflowWebhookEvent.model_validate(parsed)
     if event_type.startswith("account."):
         return AccountWebhookEvent.model_validate(parsed)
+    if event_type.startswith("inbox."):
+        return MessageWebhookEvent.model_validate(parsed)
     if event_type == "webhook.test":
         return WebhookTestEvent.model_validate(parsed)
 

{linkedapi-1.1.0 → linkedapi-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "linkedapi"
-version = "1.1.0"
+version = "1.2.0"
 description = "Official synchronous Python SDK for Linked API."
 readme = "README.md"
 requires-python = ">=3.10"

{linkedapi-1.1.0 → linkedapi-1.2.0}/tests/test_direct_methods.py

@@ -6,6 +6,7 @@ from conftest import FakeHttpClient
 from linkedapi import (
     ApiUsageParams,
     ConversationPollRequest,
+    InboxPollRequest,
     LinkedApi,
     LinkedApiActionError,
     LinkedApiError,
@@ -76,6 +77,63 @@ def test_poll_conversations_other_thrown_error_is_raised(fake_http_client: FakeH
     assert error.value.type == "httpError"
 
 
+def test_poll_inbox_success(fake_http_client: FakeHttpClient) -> None:
+    linkedapi = LinkedApi(fake_http_client)
+    fake_http_client.queue_response(
+        result={
+            "messages": [
+                {
+                    "id": "m1",
+                    "type": "st",
+                    "threadId": "t1",
+                    "personUrl": "u",
+                    "sender": "them",
+                    "text": "hi",
+                    "time": "now",
+                }
+            ]
+        }
+    )
+
+    result = linkedapi.poll_inbox(InboxPollRequest(type="st", thread_id="t1"))
+
+    assert fake_http_client.calls[0] == (
+        "POST",
+        "/inbox/poll",
+        {"type": "st", "threadId": "t1"},
+    )
+    assert result.data is not None
+    assert result.data[0].thread_id == "t1"
+    assert result.data[0].sender == "them"
+    assert result.errors == []
+
+
+def test_poll_inbox_without_request_sends_empty_body(fake_http_client: FakeHttpClient) -> None:
+    linkedapi = LinkedApi(fake_http_client)
+    fake_http_client.queue_response(result={"messages": []})
+
+    result = linkedapi.poll_inbox()
+
+    assert fake_http_client.calls[0] == ("POST", "/inbox/poll", {})
+    assert result.data == []
+    assert result.errors == []
+
+
+def test_poll_inbox_response_error_maps_to_action_errors(
+    fake_http_client: FakeHttpClient,
+) -> None:
+    linkedapi = LinkedApi(fake_http_client)
+    fake_http_client.queue_response(
+        success=False,
+        error=LinkedApiRequestError(type="invalidRequestPayload", message="bad"),
+    )
+
+    result = linkedapi.poll_inbox(InboxPollRequest(type="st"))
+
+    assert result.data is None
+    assert result.errors == [LinkedApiActionError(type="invalidRequestPayload", message="bad")]
+
+
 def test_get_account_info_and_api_usage_paths(fake_http_client: FakeHttpClient) -> None:
     linkedapi = LinkedApi(fake_http_client)
     fake_http_client.queue_response(result={"name": "Jane", "url": "https://linkedin.com/in/jane"})

{linkedapi-1.1.0 → linkedapi-1.2.0}/tests/test_errors.py

@@ -49,6 +49,7 @@ def test_error_type_sets_match_node_contract() -> None:
         "noPostingPermission",
         "noSalesNavigator",
         "conversationsNotSynced",
+        "threadNotFound",
     )
 
 

{linkedapi-1.1.0 → linkedapi-1.2.0}/tests/test_operations.py

@@ -29,13 +29,20 @@ def test_linked_api_exposes_all_predefined_operations() -> None:
         "send_connection_request",
         "check_connection_status",
         "withdraw_connection_request",
+        "accept_connection_request",
+        "ignore_connection_request",
         "retrieve_pending_requests",
+        "retrieve_connection_requests",
         "retrieve_connections",
         "remove_connection",
         "send_message",
         "sync_conversation",
+        "sync_inbox",
+        "manage_conversation",
         "nv_send_message",
         "nv_sync_conversation",
+        "nv_sync_inbox",
+        "nv_manage_conversation",
         "react_to_post",
         "comment_on_post",
         "create_post",
@@ -48,7 +55,7 @@ def test_linked_api_exposes_all_predefined_operations() -> None:
         assert hasattr(operation, "execute")
         assert hasattr(operation, "result")
         assert hasattr(operation, "cancel")
-    assert len(linkedapi.operations) == 27
+    assert len(linkedapi.operations) == 34
 
 
 def test_operation_mappers_match_node_contract() -> None:
@@ -64,6 +71,23 @@ def test_operation_mappers_match_node_contract() -> None:
     assert linkedapi.fetch_job.mapper.default_params == {"basicInfo": True}
     assert isinstance(linkedapi.send_connection_request.mapper, VoidWorkflowMapper)
     assert linkedapi.send_connection_request.mapper.action_type == "st.sendConnectionRequest"
+    assert isinstance(linkedapi.accept_connection_request.mapper, VoidWorkflowMapper)
+    assert linkedapi.accept_connection_request.mapper.action_type == "st.acceptConnectionRequest"
+    assert isinstance(linkedapi.ignore_connection_request.mapper, VoidWorkflowMapper)
+    assert linkedapi.ignore_connection_request.mapper.action_type == "st.ignoreConnectionRequest"
+    assert isinstance(linkedapi.retrieve_connection_requests.mapper, ArrayWorkflowMapper)
+    assert (
+        linkedapi.retrieve_connection_requests.mapper.base_action_type
+        == "st.retrieveConnectionRequests"
+    )
+    assert isinstance(linkedapi.sync_inbox.mapper, VoidWorkflowMapper)
+    assert linkedapi.sync_inbox.mapper.action_type == "st.syncInbox"
+    assert isinstance(linkedapi.nv_sync_inbox.mapper, VoidWorkflowMapper)
+    assert linkedapi.nv_sync_inbox.mapper.action_type == "nv.syncInbox"
+    assert isinstance(linkedapi.manage_conversation.mapper, VoidWorkflowMapper)
+    assert linkedapi.manage_conversation.mapper.action_type == "st.manageConversation"
+    assert isinstance(linkedapi.nv_manage_conversation.mapper, VoidWorkflowMapper)
+    assert linkedapi.nv_manage_conversation.mapper.action_type == "nv.manageConversation"
 
 
 def test_execute_and_result_flow_returns_pydantic_data(

linkedapi-1.2.0/tests/test_webhooks.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from linkedapi import (
+    AccountWebhookEvent,
+    MessageWebhookEvent,
+    WorkflowWebhookEvent,
+    parse_webhook_event,
+)
+
+
+def test_parse_workflow_event() -> None:
+    event = parse_webhook_event(
+        json.dumps(
+            {
+                "id": "e1",
+                "type": "workflow.completed",
+                "data": {"workflowId": "wf1", "accountId": "a1", "status": "completed"},
+            }
+        )
+    )
+
+    assert isinstance(event, WorkflowWebhookEvent)
+    assert event.data.workflow_id == "wf1"
+
+
+def test_parse_account_event() -> None:
+    event = parse_webhook_event(
+        json.dumps({"id": "e2", "type": "account.frozen", "data": {"accountId": "a1"}})
+    )
+
+    assert isinstance(event, AccountWebhookEvent)
+    assert event.data.account_id == "a1"
+
+
+def test_parse_message_received_event() -> None:
+    event = parse_webhook_event(
+        json.dumps(
+            {
+                "id": "e3",
+                "type": "inbox.messageReceived",
+                "data": {
+                    "accountId": "a1",
+                    "type": "st",
+                    "threadId": "t1",
+                    "personUrl": "u",
+                    "messageId": "m1",
+                    "sender": "them",
+                    "text": "hello",
+                    "time": "now",
+                },
+            }
+        )
+    )
+
+    assert isinstance(event, MessageWebhookEvent)
+    assert event.type == "inbox.messageReceived"
+    assert event.data.thread_id == "t1"
+    assert event.data.message_id == "m1"
+    assert event.data.sender == "them"
+
+
+def test_parse_message_sent_event() -> None:
+    event = parse_webhook_event(
+        json.dumps(
+            {
+                "id": "e4",
+                "type": "inbox.messageSent",
+                "data": {"accountId": "a1", "type": "nv", "sender": "us", "text": "hi"},
+            }
+        )
+    )
+
+    assert isinstance(event, MessageWebhookEvent)
+    assert event.type == "inbox.messageSent"
+    assert event.data.type == "nv"
+
+
+def test_parse_unknown_event_raises() -> None:
+    with pytest.raises(ValueError):
+        parse_webhook_event(json.dumps({"id": "e5", "type": "unknown.thing", "data": {}}))