how to asteam output without tools output?

[jeremygan2021]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

@csrf_exempt
@require_POST
async def listen_character_creation_async_(request):
    try:
        # Get user information
        username, email = await get_user_info(request)
        if not username:
            return JsonResponse({'status': 'error', 'message': 'User not logged in'}, status=401)

        data = json.loads(request.body)
        player_input = data.get('player_input')
        is_new_conversation = data.get('is_new_conversation', False)
        thread_id = data.get('thread_id')
        print(f"--------------[{thread_id}]---------------")
        print(f"--------------[Username: {username}]---------------")
        print(f"--------------[Email: {email}]---------------")
        res = await get_character_info(username)

        agent = Agent(thread_id=thread_id, user_email=email)

        if not player_input:
            return JsonResponse({'status': 'error', 'message': 'Missing player input'}, status=400)

        messages_exist = await get_session_data(request.session, 'messages', default=None)
        if messages_exist is None:
            await set_session_data(request.session, 'messages', [])

        if is_new_conversation:
            await set_session_data(request.session, 'messages', [])

        serialized_messages = await get_session_data(request.session, 'messages', [])
        messages = deserialize_messages(serialized_messages)

        async def event_stream():
            try:
                show_chunk = ''
                async for chunk in agent.process_message_stream_async(player_input,
                                                                      messages=messages,
                                                                      thread_id=thread_id):

                    if isinstance(chunk, str):
                        yield f"data: {json.dumps({'status': 'transfor'})}\n\n"
                        # Send regular content
                        yield f"data: {json.dumps({'content': chunk})}\n\n"
                        # Add AI's message to session messages
                        show_chunk += chunk

                    elif isinstance(chunk, dict):
                        # Send tool call information
                        yield f"data: {json.dumps(chunk)}\n\n"
                # Update messages in session
                await set_session_data(request.session, 'messages', serialize_messages(messages))

                if show_chunk == '' and agent.Create_info['name'] is not None:
                    finish = f"【{agent.Create_info['name']}】character creation and upload completed!"
                    print(finish)
                    yield f"data: {json.dumps({'content': finish, 'status': 'transfor'})}\n\n"
                    yield f"data: {json.dumps({'status': 'finish'})}"
                    return

                # Send completion signal
                print("--------Current Reply---------")
                print(f"AI: {show_chunk}")
                print("-------------------------")
                messages.append(AIMessage(content=show_chunk))
                show_chunk = ''
                yield f"data: {json.dumps({'status': 'complete', 'Create_info': agent.Create_info})}\n\n"

            except Exception as e:
                print(f"Error while processing message: {str(e)}")
                yield f"data: {json.dumps({'status': 'error', 'message': 'Error while processing message'})}\n\n"

        return StreamingHttpResponse(event_stream(), content_type='text/event-stream')


    except json.JSONDecodeError:
        return JsonResponse({'status': 'error', 'message': 'Invalid JSON data'}, status=400)
    except Exception as e:
        print(f"Exception occurred while handling the request: {str(e)}")
        return JsonResponse({'status': 'error', 'message': 'Internal server error'}, status=500)


@tool
def get_player_info(messages: str, thread_id: str, user_email: str):
    """
    Retrieves DND character creation information.
    Parameters:
        messages (str): Player's response content.
        thread_id (str): Unique identifier for the conversation.
        user_email (str): User's email, used as the unique index (primary key).
    Returns:
        str: Status of the character creation information. If all information is collected correctly, returns "Task completed"; otherwise, returns missing information.
    Description:
        Checks if all required information is present based on the player's responses. If the information is complete, updates the character creation information, uploads to the database, and returns completion status. If information is still missing, returns the missing details.
    """

    file_path = f'{BASEDIR}/json_data/{thread_id}.json'
    his = json_tool.return_json_history(file_path, 6)

    task = json_tool.check_character_task(file_path)
    print(f"Current task: {task}")

    # Check which information is incomplete
    json_tool.read_json_file(file_path)

    task_result, detect_detail = chat_bot.chat_flow_str_history(
        task=task,
        msg=messages,
        history=his,
    )

    if task_result:
        print("Answer obtained")
        parsed_info = "Information not parsed"
        parsed_info = story_parse(f"AI analysis: {detect_detail}")
        print(parsed_info)

        json_tool.update_character_info(parsed_info, file_path)

        res = json_tool.check_character_completion(file_path)

        if res is True:
            return "Task completed"
        else:
            print(res)
            return res

class Agent:
    def __init__(self, thread_id, user_email):
        self.thread_id = thread_id
        self.Agent_config = {"configurable": {"thread_id": self.thread_id}}
        self.his_limit = 6
        self.recent_history = []
        self.task_info = None
        .........hiden code.........

  
  async def process_message_stream_async(self,
                                         player_input,
                                         messages=None,
                                         thread_id=None):
      if messages is None:
          messages = []
  
      if thread_id is None:
          thread_id = id(messages)
          print(f"New thread_id created: {thread_id}")
  
      # Check if the character JSON file exists
      if os.path.exists(self.json_path):
          print("Character JSON file already exists")
      else:
          json_tool.create_json_to_file(self.json_path)
          print(f"Character JSON file created: {BASEDIR}/json_data/{self.thread_id}.json")
  
      role = 'Human'
      content = player_input
      # Save human dialog history
      json_tool.load_chat_his(self.json_path, role, content)
  
      messages.append(HumanMessage(content=player_input))
      state = {'messages': messages}
  
      AI_response = ''
      try:
          async for msg, metadata in self.app.astream(
                  state,
                  stream_mode="messages",
                  config={
                      "configurable": {
                          "thread_id": thread_id,
                          "checkpoint_ns": "default",
                      }
                  }
          ):
              if isinstance(msg, (AIMessage, AIMessageChunk)) and msg.content:
                  yield msg.content
                  AI_response += msg.content
  
              if isinstance(msg, AIMessageChunk) and msg.tool_call_chunks:
                  tool_calls = {"tool_calls": str(msg.tool_calls)}
                  # Uncomment below to yield tool call information
                  # yield json.dumps(tool_calls)
                  # print(tool_calls)
  
      except Exception as e:
          print(f"Error occurred while processing message: {str(e)}")
          yield json.dumps({"status": "error", "message": "An error occurred while processing your message."})
  
  
  async def call_model_async(self, state: AgentState):
          from asgiref.sync import sync_to_async
          messages = state["messages"]
  
          json_data = json_tool.read_json_file(self.json_path)
          info = json_data['character_info']
          self.Create_info = {
              'name': info['name'],
              'race': info['race'],
              'profession': info['profession'],
              'background': info['background'],
              'alignment': info['alignment'],
              'personality_traits': info['personality_traits'],
              'ideals': info['ideals'],
              'bonds': info['bonds'],
              'flaws': info['flaws'],
              'backstory': info['backstory']
          }
  
          self.task_info = json_tool.check_character_task(self.json_path)
  
          if self.task_info == 'All content collected':
              print("Task completed")
              print("---------------Starting database upload-----------------")
              return {"messages": 'finish_character_creation', 'agent_node': 'agent', 'sys_info': ''}
  
          llm = prompt_with_history | self.model
  
          self.recent_history = json_tool.return_json_history(self.json_path,
                                                              num_recent=self.his_limit)
          response = await llm.ainvoke({
              'history': self.recent_history,
              "messages": messages[-1],
              'task': self.task_info,
              'email': self.user_email,
              "thread_id": self.thread_id},
              config=self.Agent_config,
              checkpointer=self.checkpointer)
  
          return {"messages": [response], 'agent_node': 'agent', 'sys_info': ''}

Description

every time I invoke the Asteam output, to push the agent send(yield f"data: {json.dumps({'content': chunk})}\n\n") the output in django front_end, but it also output the AI reasoning(COT) output. how can I close the tools output(AI COT reasoning), just output agent's response。

System Info

AI: "I am an extremely evil person."

Based on the human’s latest response, "I am an extremely evil person," the AI has obtained the current player information needed: alignment. Thus, the answer is: True. The AI can continue asking for other information, such as the character's personality traits, ideals, bonds, and flaws, to further enrich the character's background.

json
复制代码
{
"name": null,
"race": null,
"profession": null,
"background": null,
"alignment": "extremely evil",
"personality_traits": null,
"ideals": null,
"bonds": null,
"flaws": null,
"backstory": null
}
AI: "Hi, A-Gan! We already know you are an extremely evil person, which adds a lot of depth to your character! Now, let's dive a little deeper into your personality traits. Personality traits can help us understand how A-Gan acts in daily life. For example, he might be someone who is ruthless, or he could have a hidden sense of humor beneath his evil appearance. Here are some options for you to consider:

Ruthless: A-Gan feels nothing for others’ pain and might even enjoy it.
Cunning and Clever: He always finds a way to take advantage of others and comes out on top.
Confident: A-Gan has great confidence in himself and believes he is the strongest.
Dark Sense of Humor: He might say surprising jokes even in serious moments, or even when others are suffering.
What do you think A-Gan’s personality traits are? Or do you have your own ideas for his traits? Let’s work together to bring his character to life!"

Human: "That's right, he is a ruthlessly cold-hearted man."

AI: "Hi, A-Gan! You just mentioned he’s a ‘ruthlessly cold-hearted man,’ which makes the character even more dimensional! However, I’d like to clarify, is he especially ruthless in certain situations? Is he cold-hearted toward enemies, friends, or others? This can help us better define his personality traits.

Meanwhile, we could also explore his ideals. What is he pursuing? Power, wealth, or something else? This will help add depth to A-Gan’s background. Do you have any ideas?"