v0.4

examples/functions/invoke.py

@@ -25,6 +25,7 @@ async def invoker(
             "invoke",
             app_id=client.app_id,
             function_id="invokee",
+            timeout=60_000,
         )
         print(res)
 
@@ -56,6 +57,7 @@ def invoker(
             "invoke",
             app_id=client.app_id,
             function_id="invokee",
+            timeout=60_000,
         )
         print(type(res))
         print(res)

inngest/__init__.py

@@ -1,10 +1,9 @@
 """Public entrypoint for the Inngest SDK."""
 
 
-from ._internal.client_lib import Inngest
+from ._internal.client_lib import Inngest, SendEventsResult
 from ._internal.errors import NonRetriableError, RetryAfterError, StepError
 from ._internal.event_lib import Event
-from ._internal.execution import Output
 from ._internal.function import Context, Function
 from ._internal.function_config import (
     Batch,
@@ -16,8 +15,12 @@
     TriggerCron,
     TriggerEvent,
 )
-from ._internal.middleware_lib import Middleware, MiddlewareSync
-from ._internal.step_lib import FunctionID, Step, StepSync
+from ._internal.middleware_lib import (
+    Middleware,
+    MiddlewareSync,
+    TransformOutputResult,
+)
+from ._internal.step_lib import Step, StepMemos, StepSync
 from ._internal.types import JSON
 
 __all__ = [
@@ -28,19 +31,20 @@
     "Debounce",
     "Event",
     "Function",
-    "FunctionID",
     "Inngest",
     "JSON",
     "Middleware",
     "MiddlewareSync",
     "NonRetriableError",
-    "Output",
     "RateLimit",
     "RetryAfterError",
+    "SendEventsResult",
     "Step",
     "StepError",
+    "StepMemos",
     "StepSync",
     "Throttle",
+    "TransformOutputResult",
     "TriggerCron",
     "TriggerEvent",
 ]

inngest/_internal/client_lib/__init__.py

@@ -0,0 +1,4 @@
+from .client import Inngest
+from .models import SendEventsResult
+
+__all__ = ["Inngest", "SendEventsResult"]

inngest/_internal/client_lib.py → inngest/_internal/client_lib/client.py

@@ -8,7 +8,7 @@
 
 import httpx
 
-from . import (
+from inngest._internal import (
     const,
     env_lib,
     errors,
@@ -20,6 +20,8 @@
     types,
 )
 
+from . import models
+
 # Dummy value
 _DEV_SERVER_EVENT_KEY = "NO_EVENT_KEY_SET"
 
@@ -404,21 +406,39 @@ async def send(
         if not isinstance(events, list):
             events = [events]
 
+        middleware = None
         if not skip_middleware:
-            middleware = middleware_lib.MiddlewareManager.from_client(self)
+            middleware = middleware_lib.MiddlewareManager.from_client(
+                self,
+                raw_request=None,
+            )
             await middleware.before_send_events(events)
 
         req = self._build_send_request(events)
         if isinstance(req, Exception):
             raise req
 
-        res = await net.fetch_with_thready_safety(
-            self._http_client,
-            self._http_client_sync,
-            req,
+        result = models.SendEventsResult.from_raw(
+            (
+                await net.fetch_with_thready_safety(
+                    self._http_client,
+                    self._http_client_sync,
+                    req,
+                )
+            ).json()
         )
+        if isinstance(result, Exception):
+            raise result
+
+        if middleware is not None:
+            err = await middleware.after_send_events(result)
+            if isinstance(err, Exception):
+                raise err
+
+        if result.error is not None:
+            raise errors.SendEventsError(result.error, result.ids)
 
-        return _extract_ids(res.json())
+        return result.ids
 
     def send_sync(
         self,
@@ -438,28 +458,38 @@ def send_sync(
         if not isinstance(events, list):
             events = [events]
 
+        middleware = None
         if not skip_middleware:
-            middleware = middleware_lib.MiddlewareManager.from_client(self)
-            middleware.before_send_events_sync(events)
+            middleware = middleware_lib.MiddlewareManager.from_client(
+                self,
+                raw_request=None,
+            )
+            err = middleware.before_send_events_sync(events)
+            if isinstance(err, Exception):
+                raise err
 
         req = self._build_send_request(events)
         if isinstance(req, Exception):
             raise req
-        return _extract_ids((self._http_client_sync.send(req)).json())
 
-    def set_logger(self, logger: types.Logger) -> None:
-        self.logger = logger
+        result = models.SendEventsResult.from_raw(
+            (self._http_client_sync.send(req)).json(),
+        )
+        if isinstance(result, Exception):
+            raise result
 
+        if middleware is not None:
+            err = middleware.after_send_events_sync(result)
+            if isinstance(err, Exception):
+                raise err
 
-def _extract_ids(body: object) -> list[str]:
-    if not isinstance(body, dict) or "ids" not in body:
-        raise errors.BodyInvalidError("unexpected response when sending events")
+        if result.error is not None:
+            raise errors.SendEventsError(result.error, result.ids)
 
-    ids = body["ids"]
-    if not isinstance(ids, list):
-        raise errors.BodyInvalidError("unexpected response when sending events")
+        return result.ids
 
-    return ids
+    def set_logger(self, logger: types.Logger) -> None:
+        self.logger = logger
 
 
 def _get_mode(

inngest/_internal/client_lib_test.py → inngest/_internal/client_lib/client_test.py

@@ -3,7 +3,7 @@
 
 import pytest
 
-from . import client_lib, const, errors, event_lib
+from inngest._internal import client_lib, const, errors, event_lib
 
 
 class Test(unittest.TestCase):

inngest/_internal/client_lib/models.py

@@ -0,0 +1,8 @@
+import typing
+
+from inngest._internal import types
+
+
+class SendEventsResult(types.BaseModel):
+    error: typing.Optional[str] = None
+    ids: list[str]