docs: update streamx related documents

Author: DMwangnima

content/en/docs/kitex/Tutorials/basic-feature/streamx/Kitex+StreamX+-+Stream+Basic+Programming.md

@@ -14,10 +14,10 @@ Current support:
 
   - Transport protocol: TTHeader
   - IDL Definition Language and Serialization Protocol: Thrift
-- **gRPC Streaming** : ~~~~(planned implementation)
+- **gRPC Streaming**
 
-  - ~~Transport protocol: gRPC~~
-  - ~~IDL Definition Language and Serialization Protocol: Protobuf Encoding~~
+  - Transport protocol: gRPC
+  - IDL Definition Language and Serialization Protocol: Thrift / Protobuf
 
 The protocol selected here only affects code generated from IDL. Regardless of the protocol, the following usage is consistent.
 
@@ -44,11 +44,15 @@ service TestService {
 ```
 
 #### Generate code
+Please make sure that Kitex Tool has been upgraded to v0.13.0+:
+```
+go install github.com/cloudwego/kitex/tool/cmd/kitex@latest
+```
 
-To maintain compatibility with legacy stream-generated code, Command Line needs to add `the -streamx ` flag.
+To maintain compatibility with legacy stream-generated code, Command Line needs to add the `-streamx` flag.
 
 ```
-kitex -streamx -module <go module> -service P.S.M echo.thrift
+kitex -streamx -module <go module> -service service echo.thrift
 ```
 
 ##### Initialization
@@ -57,25 +61,25 @@ kitex -streamx -module <go module> -service P.S.M echo.thrift
 
 ```go
 import ".../kitex_gen/echo/testservice"
-import "github.com/cloudwego/kitex/client/streamxclient"
+import "github.com/cloudwego/kitex/client"
 
 cli, err := testservice.NewClient(
     "a.b.c",
-    streamxclient.WithStreamRecvMiddleware(...),
-    streamxclient.WithStreamSendMiddleware(...),
+    client.WithStreamRecvMiddleware(...),
+    client.WithStreamSendMiddleware(...),
 )
 ```
 
 #### Create Server
 
 ```go
-import ".../kitex_gen/echo/streamserver"
-import "github.com/cloudwego/kitex/server/streamxserver"
+import ".../kitex_gen/echo/testservice"
+import "github.com/cloudwego/kitex/server"
 
-svr := streamserver.NewServer(
+svr := testservice.NewServer(
     new(serviceImpl),
-    streamxserver.WithStreamRecvMiddleware(...),
-    streamxserver.WithStreamSendMiddleware(...),
+    server.WithStreamRecvMiddleware(...),
+    server.WithStreamSendMiddleware(...),
 )
 ```
 
@@ -101,14 +105,14 @@ client.CloseAndRecv(res) === EOF ==>       server.Recv(EOF)
 
 #### Client Usage
 
-- [**Must**] : The client must call the CloseAndRecv () or (CloseSend + Recv) method to inform the server that there is no new data to send.
+- [**Must**] : The client must call the CloseAndRecv() or (CloseSend + Recv) method to inform the server that there is no new data to send.
 
 ```go
-ctx, cs, err := cli.ClientStream(ctx)
+stream, err := cli.EchoClient(ctx)
 for i := 0; i < 3; i++ {
-    err = cs.Send(ctx, req)
+    err = stream.Send(stream.Context(), req)
 }
-res, err = cs.CloseAndRecv(ctx)
+res, err = stream.CloseAndRecv(stream.Context())
 ```
 
 #### Server usage
@@ -117,14 +121,14 @@ res, err = cs.CloseAndRecv(ctx)
 
 ```go
 
-func (si *serviceImpl) ClientStream(
-    ctx context.Context, stream streamx.ClientStreamingServer[Request, Response]
-) (res *Response, err error) {
+func (si *serviceImpl) EchoClient(
+    ctx context.Context, stream echo.TestService_EchoClientServer
+) (err error) {
     for {
        req, err := stream.Recv(ctx)
        if err == io.EOF {
            res := new(Response)
-           return res, nil
+           return stream.SendAndClose(ctx, res)
        }
        if err != nil {
           return nil, err
@@ -153,12 +157,12 @@ client.Recv(EOF)   <== EOF ===   server handler return
 
 #### Client Usage
 
-- [**Must**] : The client must check the io. EOF error and end the loop
+- [**Must**] : The client must check the io.EOF error and end the loop
 
 ```go
-ctx, ss, err := cli.ServerStream(ctx, req)
+stream, err := cli.EchoServer(ctx, req)
 for {
-    res, err := ss.Recv(ctx)
+    res, err := stream.Recv(stream.Context())
     if errors.Is(err, io.EOF) {
        break
     }
@@ -168,7 +172,7 @@ for {
 #### Server usage
 
 ```go
-func (si *serviceImpl) ServerStream(ctx context.Context, req *Request, stream streamx.ServerStreamingServer[Response]) error {
+func (si *serviceImpl) EchoServer(ctx context.Context, req *echo.Request, stream echo.TestService_EchoServerServer) error {
     for i := 0; i < 3; i++ {
        err := stream.Send(ctx, resp)
        if err != nil {
@@ -204,23 +208,23 @@ client.Recv(EOF)   <== EOF ===   server handler return
 #### Client Usage
 
 - [**Must**] : client must call CloseSend after sending
-- [**Must**] : client must judge io. EOF and end the loop when Recv
+- [**Must**] : client must judge io.EOF and end the loop when Recv
 
 ```go
-ctx, bs, err := cli.BidiStream(ctx)
+stream, err := cli.EchoBidi(ctx)
 var wg sync.WaitGroup
 wg.Add(2)
 go func() {
     defer wg.Done()
     for i := 0; i < round; i++ {
-       err := bs.Send(ctx, req)
+       err := stream.Send(stream.Context(), req)
     }
-    err = bs.CloseSend(ctx)
+    err = stream.CloseSend(stream.Context())
 }()
 go func() {
     defer wg.Done()
     for {
-       res, err := bs.Recv(ctx)
+       res, err := stream.Recv(stream.Context())
        if errors.Is(err, io.EOF) {
           break
        }
@@ -234,7 +238,7 @@ wg.Wait()
 - [**Must**] : The server must determine io. EOF and end the loop when Recv
 
 ```go
-func (si *serviceImpl) BidiStream(ctx context.Context, stream streamx.BidiStreamingServer[Request, Response]) error {
+func (si *serviceImpl) EchoBidi(ctx context.Context, stream echo.TestService_EchoBidiServer) error {
     for {
        req, err := stream.Recv(ctx)
        if err == io.EOF {

content/en/docs/kitex/Tutorials/basic-feature/streamx/Kitex+StreamX+-+Stream+Error+Handling.md

@@ -19,14 +19,14 @@ Unlike  RPC, stream errors can occur at any time during stream processing. For e
 Server implementation:
 
 ```go
-func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *Request, stream streamx.ServerStreamingServer[Response]) error {
+func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *echo.Request, stream echo.TestService_ServerStreamWithErrServer) error {
     // 检查用户账户余额
     for isHasBalance (req.UserId) {
         stream.Send(ctx, res)
     }
     // 返回用户余额不足错误
     bizErr := kerrors.NewBizStatusErrorWithExtra(
-        10001, "insufficient user balance", map[string]string{"testKey": "testVal"}，
+        10001, "insufficient user balance", map[string]string{"testKey": "testVal"},
     )
     return bizErr
 }
@@ -35,11 +35,11 @@ func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *Reques
 Client implementation:
 
 ```go
-svrStream, err = streamClient.ServerStreamWithErr(ctx, req)
+stream, err = cli.ServerStreamWithErr(ctx, req)
 
 var err error
 for {
-    res, err = stream.Recv(ctx)
+    res, err = stream.Recv(stream.Context())
     if err != nil {
          break
     }
@@ -52,12 +52,12 @@ if ok {
 
 ### Other errors
 
-If the Error returned by the Server is a non-business exception, the framework will be uniformly encapsulated as `(* thrift.ApplicationException) `. At this time, only the error Message can be obtained.
+If the Error returned by the Server is a non-business exception, the framework will be uniformly encapsulated as `(*thrift.ApplicationException)`. At this time, only the error Message can be obtained.
 
 Server implementation:
 
 ```go
-func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *Request, stream streamx.ServerStreamingServer[Response]) error {
+func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *echo.Request, stream echo.TestService_ServerStreamWithErrServer) error {
     // ...
     return errors.New("test error")
 }
@@ -66,16 +66,16 @@ func (si *streamingService) ServerStreamWithErr(ctx context.Context, req *Reques
 Client implementation:
 
 ```go
-svrStream, err = streamClient.ServerStreamWithErr(ctx, req)
-test.Assert(t, err == nil, err)
+stream, err = cli.ServerStreamWithErr(ctx, req)
 
 var err error
 for {
-    res, err = stream.Recv(ctx)
+    res, err = stream.Recv(stream.Context())
     if err != nil {
          break
     }
 }
+
 ex, ok := err.(*thrift.ApplicationException)
 if ok {
      println(ex.TypeID(), ex.Msg())

content/en/docs/kitex/Tutorials/basic-feature/streamx/Kitex+StreamX+-+Stream+Metainfo.md

@@ -18,14 +18,15 @@ The overall usage of message pass-through is similar to [Kitex - 元信息透传
 ctx = metainfo.WithPersistentValue(ctx, "k1", "v1")
 ctx = metainfo.WithValue(ctx, "k2", "v2")
 
-s, err := streamClient.ClientStream(ctx)
+stream, err := cli.EchoClient(ctx)
 ```
+> If using gRPC streaming, make sure the key is uppercase and use _ instead of - or it will be discarded. TTHeader streaming does not make this requirement.
 
 ### Server receives meta message
 
 ```go
-func (s *streamingService) ClientStream(ctx context.Context,
-    stream streamx.ClientStreamingServer[Request, Response]) (*Response, error) {
+func (s *streamingService) EchoClient(ctx context.Context,
+    stream echo.TestService_EchoClientServer) (err error) {
 
    v, ok := metainfo.GetPersistentValue(ctx, "k1")
    // v == "v1"
@@ -39,30 +40,32 @@ func (s *streamingService) ClientStream(ctx context.Context,
 Reverse pass-through introduces a new concept, Header and Trailer. Any complete data stream must include Header and Trailer. Use these two frames to reverse pass-through information.
 
 ```go
-func (s *streamingService) ClientStream(ctx context.Context,
-    stream streamx.ClientStreamingServer[Request, Response]) (*Response, error) {
+import "github.com/cloudwego/pkg/streaming"
+
+func (s *streamingService) EchoClient(ctx context.Context,
+    stream echo.TestService_EchoClientServer) (err error) {
 
-    // SetTrailer set 的 trailer 会在 server handler 结束后发送
-    err := stream.SetTrailer(streamx.Trailer{"t1": "v1"})
-    // 立刻发送 Header
-    err = stream.SendHeader(streamx.Header{"h1": "v1"})
+    // the trailer set by SetTrailer would be sent after server handler finishing
+    err := stream.SetTrailer(streaming.Trailer{"t1": "v1"})
+    // send Header directly
+    err = stream.SendHeader(streaming.Header{"h1": "v1"})
     if err != nil {
         return err
     }
-    // 发送正常数据
+    // send normal data
     err = stream.Send(req)
 }
 ```
 
 ### Client receives a reverse pass-through meta message
 
 ```go
-s, err := streamClient.ClientStream(ctx)
+stream, err := cli.EchoClient(ctx)
 
-// Header/Trailer 函数会一直阻塞到对端发送了 Header/Trailer 为止，或中间发生了错误
-hd, err := s.Header()
+// Header/Trailer calling would block constantly until the remote side has sent Header/Trailer, or there was an error in the intermediate process
+hd, err := stream.Header()
 // hd["h1"] == "v1"
-tl, err := s.Trailer()
+tl, err := stream.Trailer()
 // tl["t1"] == "v1"
 ```