feat:精简

backend/open_webui/utils/misc.py

@@ -665,24 +665,12 @@ def stream_chunks_handler(
     :return: An async generator that yields the stream data.
     """
 
-    from open_webui.utils.credit.usage import CreditDeduct
-
     max_buffer_size = CHAT_STREAM_RESPONSE_CHUNK_MAX_BUFFER_SIZE
     if max_buffer_size is None or max_buffer_size <= 0:
 
         async def consumer_content(stream: aiohttp.StreamReader):
-            with CreditDeduct(
-                user=user,
-                model_id=model_id,
-                body=form_data,
-                is_stream=True,
-            ) as credit_deduct:
-                # change to avoid multi \n\n cause message lose
-                async for chunk in stream:
-                    credit_deduct.run(response=chunk)
-                    yield chunk
-
-                yield credit_deduct.usage_message
+            async for chunk in stream:
+                yield chunk
 
         return consumer_content(stream)
 
@@ -690,65 +678,53 @@ def stream_chunks_handler(
         buffer = b""
         skip_mode = False
 
-        with CreditDeduct(
-            user=user,
-            model_id=model_id,
-            body=form_data,
-            is_stream=True,
-        ) as credit_deduct:
-            # change to avoid multi \n\n cause message lose
-            async for data in stream:
+        async for data in stream:
 
-                if not data:
-                    continue
+            if not data:
+                continue
 
-                credit_deduct.run(response=data)
+            # In skip_mode, if buffer already exceeds the limit, clear it (it's part of an oversized line)
+            if skip_mode and len(buffer) > max_buffer_size:
+                buffer = b""
 
-                # In skip_mode, if buffer already exceeds the limit, clear it (it's part of an oversized line)
-                if skip_mode and len(buffer) > max_buffer_size:
-                    buffer = b""
+            lines = (buffer + data).split(b"\n")
 
-                lines = (buffer + data).split(b"\n")
+            # Process complete lines (except the last possibly incomplete fragment)
+            for i in range(len(lines) - 1):
+                line = lines[i]
 
-                # Process complete lines (except the last possibly incomplete fragment)
-                for i in range(len(lines) - 1):
-                    line = lines[i]
-
-                    if skip_mode:
-                        # Skip mode: check if current line is small enough to exit skip mode
-                        if len(line) <= max_buffer_size:
-                            skip_mode = False
-                            yield line
-                        else:
-                            yield b"data: {}"
-                            yield b"\n"
+                if skip_mode:
+                    # Skip mode: check if current line is small enough to exit skip mode
+                    if len(line) <= max_buffer_size:
+                        skip_mode = False
+                        yield line
                     else:
-                        # Normal mode: check if line exceeds limit
-                        if len(line) > max_buffer_size:
-                            skip_mode = True
-                            yield b"data: {}"
-                            yield b"\n"
-                            log.info(f"Skip mode triggered, line size: {len(line)}")
-                        else:
-                            yield line
-                            yield b"\n"
+                        yield b"data: {}"
+                        yield b"\n"
+                else:
+                    # Normal mode: check if line exceeds limit
+                    if len(line) > max_buffer_size:
+                        skip_mode = True
+                        yield b"data: {}"
+                        yield b"\n"
+                        log.info(f"Skip mode triggered, line size: {len(line)}")
+                    else:
+                        yield line
+                        yield b"\n"
 
-                # Save the last incomplete fragment
-                buffer = lines[-1]
+            # Save the last incomplete fragment
+            buffer = lines[-1]
 
-                # Check if buffer exceeds limit
-                if not skip_mode and len(buffer) > max_buffer_size:
-                    skip_mode = True
-                    log.info(f"Skip mode triggered, buffer size: {len(buffer)}")
-                    # Clear oversized buffer to prevent unlimited growth
-                    buffer = b""
+            # Check if buffer exceeds limit
+            if not skip_mode and len(buffer) > max_buffer_size:
+                skip_mode = True
+                log.info(f"Skip mode triggered, buffer size: {len(buffer)}")
+                # Clear oversized buffer to prevent unlimited growth
+                buffer = b""
 
-            # Process remaining buffer data
-            if buffer and not skip_mode:
-                credit_deduct.run(response=buffer)
-                yield buffer
-                yield b"\n"
-
-            yield credit_deduct.usage_message
+        # Process remaining buffer data
+        if buffer and not skip_mode:
+            yield buffer
+            yield b"\n"
 
     return yield_safe_stream_chunks()