supermemory 3.0.0a19__py3-none-any.whl → 3.0.0a20__py3-none-any.whl

{supermemory → supermemory_new}/resources/memories.py

@@ -2,13 +2,14 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Mapping, cast
+from typing import Dict, List, Union
+from typing_extensions import Literal
 
 import httpx
 
-from ..types import memory_add_params, memory_update_params, memory_upload_file_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven, FileTypes
-from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
+from ..types import memory_add_params, memory_list_params, memory_update_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
+from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -20,8 +21,8 @@ from .._response import (
 from .._base_client import make_request_options
 from ..types.memory_add_response import MemoryAddResponse
 from ..types.memory_get_response import MemoryGetResponse
+from ..types.memory_list_response import MemoryListResponse
 from ..types.memory_update_response import MemoryUpdateResponse
-from ..types.memory_upload_file_response import MemoryUploadFileResponse
 
 __all__ = ["MemoriesResource", "AsyncMemoriesResource"]
 
@@ -113,6 +114,66 @@ class MemoriesResource(SyncAPIResource):
             cast_to=MemoryUpdateResponse,
         )
 
+    def list(
+        self,
+        *,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        filters: str | NotGiven = NOT_GIVEN,
+        limit: Union[str, float] | NotGiven = NOT_GIVEN,
+        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        page: Union[str, float] | NotGiven = NOT_GIVEN,
+        sort: Literal["createdAt", "updatedAt"] | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> MemoryListResponse:
+        """
+        Retrieves a paginated list of memories with their metadata and workflow status
+
+        Args:
+          container_tags: Optional tags this memory should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to group memories.
+
+          filters: Optional filters to apply to the search
+
+          limit: Number of items per page
+
+          order: Sort order
+
+          page: Page number to fetch
+
+          sort: Field to sort by
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/v3/memories/list",
+            body=maybe_transform(
+                {
+                    "container_tags": container_tags,
+                    "filters": filters,
+                    "limit": limit,
+                    "order": order,
+                    "page": page,
+                    "sort": sort,
+                },
+                memory_list_params.MemoryListParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryListResponse,
+        )
+
     def delete(
         self,
         id: str,
@@ -244,45 +305,6 @@ class MemoriesResource(SyncAPIResource):
             cast_to=MemoryGetResponse,
         )
 
-    def upload_file(
-        self,
-        *,
-        file: FileTypes,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> MemoryUploadFileResponse:
-        """
-        Upload a file to be processed
-
-        Args:
-          extra_headers: Send extra headers
-
-          extra_query: Add additional query parameters to the request
-
-          extra_body: Add additional JSON properties to the request
-
-          timeout: Override the client-level default timeout for this request, in seconds
-        """
-        body = deepcopy_minimal({"file": file})
-        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
-        # It should be noted that the actual Content-Type header that will be
-        # sent to the server will contain a `boundary` parameter, e.g.
-        # multipart/form-data; boundary=---abc--
-        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
-        return self._post(
-            "/v3/memories/file",
-            body=maybe_transform(body, memory_upload_file_params.MemoryUploadFileParams),
-            files=files,
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=MemoryUploadFileResponse,
-        )
-
 
 class AsyncMemoriesResource(AsyncAPIResource):
     @cached_property
@@ -371,6 +393,66 @@ class AsyncMemoriesResource(AsyncAPIResource):
             cast_to=MemoryUpdateResponse,
         )
 
+    async def list(
+        self,
+        *,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        filters: str | NotGiven = NOT_GIVEN,
+        limit: Union[str, float] | NotGiven = NOT_GIVEN,
+        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        page: Union[str, float] | NotGiven = NOT_GIVEN,
+        sort: Literal["createdAt", "updatedAt"] | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> MemoryListResponse:
+        """
+        Retrieves a paginated list of memories with their metadata and workflow status
+
+        Args:
+          container_tags: Optional tags this memory should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to group memories.
+
+          filters: Optional filters to apply to the search
+
+          limit: Number of items per page
+
+          order: Sort order
+
+          page: Page number to fetch
+
+          sort: Field to sort by
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/v3/memories/list",
+            body=await async_maybe_transform(
+                {
+                    "container_tags": container_tags,
+                    "filters": filters,
+                    "limit": limit,
+                    "order": order,
+                    "page": page,
+                    "sort": sort,
+                },
+                memory_list_params.MemoryListParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryListResponse,
+        )
+
     async def delete(
         self,
         id: str,
@@ -502,45 +584,6 @@ class AsyncMemoriesResource(AsyncAPIResource):
             cast_to=MemoryGetResponse,
         )
 
-    async def upload_file(
-        self,
-        *,
-        file: FileTypes,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> MemoryUploadFileResponse:
-        """
-        Upload a file to be processed
-
-        Args:
-          extra_headers: Send extra headers
-
-          extra_query: Add additional query parameters to the request
-
-          extra_body: Add additional JSON properties to the request
-
-          timeout: Override the client-level default timeout for this request, in seconds
-        """
-        body = deepcopy_minimal({"file": file})
-        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
-        # It should be noted that the actual Content-Type header that will be
-        # sent to the server will contain a `boundary` parameter, e.g.
-        # multipart/form-data; boundary=---abc--
-        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
-        return await self._post(
-            "/v3/memories/file",
-            body=await async_maybe_transform(body, memory_upload_file_params.MemoryUploadFileParams),
-            files=files,
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=MemoryUploadFileResponse,
-        )
-
 
 class MemoriesResourceWithRawResponse:
     def __init__(self, memories: MemoriesResource) -> None:
@@ -549,6 +592,9 @@ class MemoriesResourceWithRawResponse:
         self.update = to_raw_response_wrapper(
             memories.update,
         )
+        self.list = to_raw_response_wrapper(
+            memories.list,
+        )
         self.delete = to_raw_response_wrapper(
             memories.delete,
         )
@@ -558,9 +604,6 @@ class MemoriesResourceWithRawResponse:
         self.get = to_raw_response_wrapper(
             memories.get,
         )
-        self.upload_file = to_raw_response_wrapper(
-            memories.upload_file,
-        )
 
 
 class AsyncMemoriesResourceWithRawResponse:
@@ -570,6 +613,9 @@ class AsyncMemoriesResourceWithRawResponse:
         self.update = async_to_raw_response_wrapper(
             memories.update,
         )
+        self.list = async_to_raw_response_wrapper(
+            memories.list,
+        )
         self.delete = async_to_raw_response_wrapper(
             memories.delete,
         )
@@ -579,9 +625,6 @@ class AsyncMemoriesResourceWithRawResponse:
         self.get = async_to_raw_response_wrapper(
             memories.get,
         )
-        self.upload_file = async_to_raw_response_wrapper(
-            memories.upload_file,
-        )
 
 
 class MemoriesResourceWithStreamingResponse:
@@ -591,6 +634,9 @@ class MemoriesResourceWithStreamingResponse:
         self.update = to_streamed_response_wrapper(
             memories.update,
         )
+        self.list = to_streamed_response_wrapper(
+            memories.list,
+        )
         self.delete = to_streamed_response_wrapper(
             memories.delete,
         )
@@ -600,9 +646,6 @@ class MemoriesResourceWithStreamingResponse:
         self.get = to_streamed_response_wrapper(
             memories.get,
         )
-        self.upload_file = to_streamed_response_wrapper(
-            memories.upload_file,
-        )
 
 
 class AsyncMemoriesResourceWithStreamingResponse:
@@ -612,6 +655,9 @@ class AsyncMemoriesResourceWithStreamingResponse:
         self.update = async_to_streamed_response_wrapper(
             memories.update,
         )
+        self.list = async_to_streamed_response_wrapper(
+            memories.list,
+        )
         self.delete = async_to_streamed_response_wrapper(
             memories.delete,
         )
@@ -621,6 +667,3 @@ class AsyncMemoriesResourceWithStreamingResponse:
         self.get = async_to_streamed_response_wrapper(
             memories.get,
         )
-        self.upload_file = async_to_streamed_response_wrapper(
-            memories.upload_file,
-        )

supermemory_new/resources/search.py

@@ -0,0 +1,300 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import search_execute_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.search_execute_response import SearchExecuteResponse
+
+__all__ = ["SearchResource", "AsyncSearchResource"]
+
+
+class SearchResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> SearchResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return SearchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SearchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#with_streaming_response
+        """
+        return SearchResourceWithStreamingResponse(self)
+
+    def execute(
+        self,
+        *,
+        q: str,
+        categories_filter: List[Literal["technology", "science", "business", "health"]] | NotGiven = NOT_GIVEN,
+        chunk_threshold: float | NotGiven = NOT_GIVEN,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        doc_id: str | NotGiven = NOT_GIVEN,
+        document_threshold: float | NotGiven = NOT_GIVEN,
+        filters: search_execute_params.Filters | NotGiven = NOT_GIVEN,
+        include_full_docs: bool | NotGiven = NOT_GIVEN,
+        include_summary: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        only_matching_chunks: bool | NotGiven = NOT_GIVEN,
+        rerank: bool | NotGiven = NOT_GIVEN,
+        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SearchExecuteResponse:
+        """
+        Search memories with advanced filtering
+
+        Args:
+          q: Search query string
+
+          categories_filter: Optional category filters
+
+          chunk_threshold: Threshold / sensitivity for chunk selection. 0 is least sensitive (returns most
+              chunks, more results), 1 is most sensitive (returns lesser chunks, accurate
+              results)
+
+          container_tags: Optional tags this search should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to filter memories.
+
+          doc_id: Optional document ID to search within. You can use this to find chunks in a very
+              large document.
+
+          document_threshold: Threshold / sensitivity for document selection. 0 is least sensitive (returns
+              most documents, more results), 1 is most sensitive (returns lesser documents,
+              accurate results)
+
+          filters: Optional filters to apply to the search
+
+          include_full_docs: If true, include full document in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          include_summary: If true, include document summary in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          limit: Maximum number of results to return
+
+          only_matching_chunks: If true, only return matching chunks without context. Normally, we send the
+              previous and next chunk to provide more context for LLMs. If you only want the
+              matching chunk, set this to true.
+
+          rerank: If true, rerank the results based on the query. This is helpful if you want to
+              ensure the most relevant results are returned.
+
+          rewrite_query: If true, rewrites the query to make it easier to find documents. This increases
+              the latency by about 400ms
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/v3/search",
+            body=maybe_transform(
+                {
+                    "q": q,
+                    "categories_filter": categories_filter,
+                    "chunk_threshold": chunk_threshold,
+                    "container_tags": container_tags,
+                    "doc_id": doc_id,
+                    "document_threshold": document_threshold,
+                    "filters": filters,
+                    "include_full_docs": include_full_docs,
+                    "include_summary": include_summary,
+                    "limit": limit,
+                    "only_matching_chunks": only_matching_chunks,
+                    "rerank": rerank,
+                    "rewrite_query": rewrite_query,
+                },
+                search_execute_params.SearchExecuteParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchExecuteResponse,
+        )
+
+
+class AsyncSearchResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncSearchResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSearchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSearchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/supermemoryai/python-sdk#with_streaming_response
+        """
+        return AsyncSearchResourceWithStreamingResponse(self)
+
+    async def execute(
+        self,
+        *,
+        q: str,
+        categories_filter: List[Literal["technology", "science", "business", "health"]] | NotGiven = NOT_GIVEN,
+        chunk_threshold: float | NotGiven = NOT_GIVEN,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        doc_id: str | NotGiven = NOT_GIVEN,
+        document_threshold: float | NotGiven = NOT_GIVEN,
+        filters: search_execute_params.Filters | NotGiven = NOT_GIVEN,
+        include_full_docs: bool | NotGiven = NOT_GIVEN,
+        include_summary: bool | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        only_matching_chunks: bool | NotGiven = NOT_GIVEN,
+        rerank: bool | NotGiven = NOT_GIVEN,
+        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SearchExecuteResponse:
+        """
+        Search memories with advanced filtering
+
+        Args:
+          q: Search query string
+
+          categories_filter: Optional category filters
+
+          chunk_threshold: Threshold / sensitivity for chunk selection. 0 is least sensitive (returns most
+              chunks, more results), 1 is most sensitive (returns lesser chunks, accurate
+              results)
+
+          container_tags: Optional tags this search should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to filter memories.
+
+          doc_id: Optional document ID to search within. You can use this to find chunks in a very
+              large document.
+
+          document_threshold: Threshold / sensitivity for document selection. 0 is least sensitive (returns
+              most documents, more results), 1 is most sensitive (returns lesser documents,
+              accurate results)
+
+          filters: Optional filters to apply to the search
+
+          include_full_docs: If true, include full document in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          include_summary: If true, include document summary in the response. This is helpful if you want a
+              chatbot to know the full context of the document.
+
+          limit: Maximum number of results to return
+
+          only_matching_chunks: If true, only return matching chunks without context. Normally, we send the
+              previous and next chunk to provide more context for LLMs. If you only want the
+              matching chunk, set this to true.
+
+          rerank: If true, rerank the results based on the query. This is helpful if you want to
+              ensure the most relevant results are returned.
+
+          rewrite_query: If true, rewrites the query to make it easier to find documents. This increases
+              the latency by about 400ms
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/v3/search",
+            body=await async_maybe_transform(
+                {
+                    "q": q,
+                    "categories_filter": categories_filter,
+                    "chunk_threshold": chunk_threshold,
+                    "container_tags": container_tags,
+                    "doc_id": doc_id,
+                    "document_threshold": document_threshold,
+                    "filters": filters,
+                    "include_full_docs": include_full_docs,
+                    "include_summary": include_summary,
+                    "limit": limit,
+                    "only_matching_chunks": only_matching_chunks,
+                    "rerank": rerank,
+                    "rewrite_query": rewrite_query,
+                },
+                search_execute_params.SearchExecuteParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchExecuteResponse,
+        )
+
+
+class SearchResourceWithRawResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.execute = to_raw_response_wrapper(
+            search.execute,
+        )
+
+
+class AsyncSearchResourceWithRawResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.execute = async_to_raw_response_wrapper(
+            search.execute,
+        )
+
+
+class SearchResourceWithStreamingResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.execute = to_streamed_response_wrapper(
+            search.execute,
+        )
+
+
+class AsyncSearchResourceWithStreamingResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.execute = async_to_streamed_response_wrapper(
+            search.execute,
+        )

supermemory_new/types/__init__.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .memory_add_params import MemoryAddParams as MemoryAddParams
+from .memory_list_params import MemoryListParams as MemoryListParams
+from .memory_add_response import MemoryAddResponse as MemoryAddResponse
+from .memory_get_response import MemoryGetResponse as MemoryGetResponse
+from .memory_list_response import MemoryListResponse as MemoryListResponse
+from .memory_update_params import MemoryUpdateParams as MemoryUpdateParams
+from .setting_get_response import SettingGetResponse as SettingGetResponse
+from .search_execute_params import SearchExecuteParams as SearchExecuteParams
+from .setting_update_params import SettingUpdateParams as SettingUpdateParams
+from .connection_list_params import ConnectionListParams as ConnectionListParams
+from .memory_update_response import MemoryUpdateResponse as MemoryUpdateResponse
+from .search_execute_response import SearchExecuteResponse as SearchExecuteResponse
+from .setting_update_response import SettingUpdateResponse as SettingUpdateResponse
+from .connection_create_params import ConnectionCreateParams as ConnectionCreateParams
+from .connection_import_params import ConnectionImportParams as ConnectionImportParams
+from .connection_list_response import ConnectionListResponse as ConnectionListResponse
+from .connection_create_response import ConnectionCreateResponse as ConnectionCreateResponse
+from .connection_get_by_id_response import ConnectionGetByIDResponse as ConnectionGetByIDResponse
+from .connection_get_by_tags_params import ConnectionGetByTagsParams as ConnectionGetByTagsParams
+from .connection_get_by_tags_response import ConnectionGetByTagsResponse as ConnectionGetByTagsResponse
+from .connection_list_documents_params import ConnectionListDocumentsParams as ConnectionListDocumentsParams
+from .connection_list_documents_response import ConnectionListDocumentsResponse as ConnectionListDocumentsResponse
+from .connection_delete_by_provider_params import ConnectionDeleteByProviderParams as ConnectionDeleteByProviderParams
+from .connection_delete_by_provider_response import (
+    ConnectionDeleteByProviderResponse as ConnectionDeleteByProviderResponse,
+)

supermemory_new/types/connection_delete_by_provider_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ConnectionDeleteByProviderParams"]
+
+
+class ConnectionDeleteByProviderParams(TypedDict, total=False):
+    container_tags: Required[Annotated[List[str], PropertyInfo(alias="containerTags")]]
+    """Optional comma-separated list of container tags to filter connections by"""

supermemory/types/memory_upload_file_response.py → supermemory_new/types/connection_delete_by_provider_response.py

@@ -2,10 +2,10 @@
 
 from .._models import BaseModel
 
-__all__ = ["MemoryUploadFileResponse"]
+__all__ = ["ConnectionDeleteByProviderResponse"]
 
 
-class MemoryUploadFileResponse(BaseModel):
+class ConnectionDeleteByProviderResponse(BaseModel):
     id: str
 
-    status: str
+    provider: str