Assistant API (being unpublished)

# Sample code for reference only
def submit_message(thread, assistant, message):
    Messages.create(
        thread_id=thread.id,
        role="user",
        content=message
    )

    run = Runs.create(
        thread_id=thread.id,
        assistant_id=assistant.id,
        stream=True
    )
    
    for event, data in run:
        if event == 'thread.message.delta':
            yield data.delta.content.text.value
        if event == 'thread.message.completed':
            yield '\n'
        if event == 'thread.run.step.delta':
            # When step.delta is detected for the first time, output the tool name
            if not hasattr(submit_message, 'tool_name_shown'):
                submit_message.tool_name_shown = True
                tool_name = data.delta.step_details.tool_calls[0]['type']
                yield f"\nUsing tool: {tool_name}\n\n"
            
            formatted_output = format_tool_output(data.delta.step_details.tool_calls[0])
            if formatted_output is not None:
                yield formatted_output

# Sample code for reference only
while True:
    for event, data in run:
        elif event == 'thread.run.requires_action':
            # Tool call => May need to submit tool output => Leads to a new run generator
            tool_calls = data.required_action.submit_tool_outputs.tool_calls
            if not tool_calls:
                continue  
         
            tool_outputs = []
            for tool_call in tool_calls:
                name = tool_call.function.name
                arguments = json.loads(tool_call.function.arguments)
                output = tools_map[name](**arguments)
                # Normal tool
                tool_outputs.append({"output": output})

            # Submit the tool output to the run, which returns a new run generator
            run = Runs.submit_tool_outputs(
                thread_id=thread.id,  # Native conversation thread, no manual management needed
                run_id=data.id,
                tool_outputs=tool_outputs,
                stream=True
            )
            yield "Transferring...\n"
            break  # Break the current event loop and continue processing with the returned new_run

        elif event in ('thread.run.completed', 'thread.run.cancelled',
                    'thread.run.expired', 'thread.run.failed'):
            # The current run ends
            break
    else:
        # The for loop ends normally (without a break), indicating the run stream is exhausted
        break

# Sample code for reference only
# Get the multi-agent response. The input and output must align with the parameters on the Gradio frontend interface.
def get_multi_agent_response(query,history):
    # Handle cases where the input is empty
    if len(query) == 0:
        return "",history+[("","")],"",""
    # Get the execution order of the agents
    assistant_order = get_agent_response(PlannerAssistant,query)
    try:
        order_stk = ast.literal_eval(assistant_order)
        cur_query = query
        # Run the agents in order
        for i in range(len(order_stk)):
            yield "----->".join(order_stk),history+[(query,"The multi-agent is working...")],f"{order_stk[i]} is processing the information...",""
            cur_assistant = assistant_mapper[order_stk[i]]
            response = get_agent_response(cur_assistant,cur_query)
            yield "----->".join(order_stk),history+[(query,"The multi-agent is working...")],response,""
            # If the current agent is the last one, use its output as the output of the multi-agent system
            if i == len(order_stk)-1:
                yield "----->".join(order_stk),history+[(query,response)],"The assistant has finished processing.",""
            # If the current agent is not the last one, add its output response to the next round's query as reference information
            else:
                # Add special identifiers before and after the reference information to prevent the LLM from confusing it with the query
                cur_query = f"You can refer to the known information:\n{response}\nAnswer the user's question completely. The question is: {query}."
    # Fallback policy: If the program fails, call ChatAssistant directly
    except Exception as e:
        yield "ChatAssistant",[(query,get_agent_response(ChatAssistant,query))],"",""