[AgentGroupChat] Agent calling excluded functions

[j-ajim]

**settings_agent1**.function_choice_behavior = FunctionChoiceBehavior.Auto(filters={"included_plugins": ["FixPlugin"]})
**settings_agent2**.function_choice_behavior = FunctionChoiceBehavior.Auto(filters={"included_plugins": ["GenPlugin"]})

agent1 = ChatCompletionAgent(arguments=KernelArguments(
settings=settings_agent1,
))
agent2 = ChatCompletionAgent(arguments=KernelArguments(
settings=settings_agent2,
))

File "semantic_kernel/kernel.py", line 354, in invoke_function_call
raise FunctionExecutionException(
semantic_kernel.exceptions.function_exceptions.FunctionExecutionException: Only functions: ['GenPlugin-gen'] are allowed, FixPlugin-fix is not allowed.

The above expection occurs when Agent2 is executing. The message is correct but why was Agent2 provided with Agent1's plugin (FixPlugin) at first place? Why is it requesting kernel to invoke a function it should never have access to?

[sophialagerkranspandey]

Tagging @crickman

[moonbox3]

@sophialagerkranspandey this is Python, so I can handle.

Hi @j-ajim, are you providing the same kernel instance to both agent1 and agent2? We recommend using separate kernel instances.

I can't see from your code sample above, but when you create settings_agent or settings_agent2 are you giving them unique service_id args as well? If you are not, then when we get the AI service, the default implementation is for it to grab the first settings, which in your case, has the FixPlugin registered. See here for more details.

[j-ajim]

I am using the same kernel instance but passing unique service ids
settings_agent1 = kernel.get_prompt_execution_settings_from_service_id(service_id="Agent1Service")
settings_agent2 = kernel.get_prompt_execution_settings_from_service_id(service_id="Agent2Service")

[moonbox3]

Thanks for your response, @j-ajim. Would you be able to give me a little more code (with no sensitive data, of course) to try and repro? I believe I understand the flow enough to try to write it on my end, but I'd love to see more of what you have so it better represents the scenario. Let me know.

[j-ajim]

class Plugin1(helper_class) //error gen
  @kernel_function()
  def gen_errors()

class Plugin2(helper_class) //fix gen
  @kernel_function()
  def fix_errors()

class SharedKernel(Kernel): // agents need to access a variable final_plan

    final_plan: dict = Field(default_factory=dict) 
    kernels: List[Kernel] = Field(default_factory=list)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def add_kernel(self, kernel: Kernel):


kernel_fix_gen = SharedKernel()
kernel_error_gen = SharedKernel()

kernel_fix_gen .add_kernel(kernel_error_gen )


kernel_fix_gen.add_service(OpenAIChatCompletion(service_id="FixGenService"))
kernel_error_gen.add_service(OpenAIChatCompletion(service_id="ErrorGenService"))

kernel_error_gen.add_plugin(Plugin1(), plugin_name="Plugin1")
kernel_fix_gen.add_plugin(Plugin2(), plugin_name="Plugin2")

settings_error_gen = kernel_error_gen.get_prompt_execution_settings_from_service_id(service_id="ErrorGenService")
settings_fix_gen = kernel_fix_gen.get_prompt_execution_settings_from_service_id(service_id="FixGenService")


settings_error_gen .function_choice_behavior = FunctionChoiceBehavior.Auto(filters={"excluded_plugins": [ "Plugin2"]})
settings_fix_gen .function_choice_behavior = FunctionChoiceBehavior.Auto(filters={"excluded_plugins": [ "Plugin1"]})


selection_function = KernelFunctionFromPrompt(
            function_name="Agent_Router",
            prompt=f"""
)

termination_function = KernelFunctionFromPrompt(
        function_name="termination",
        prompt=f"""
)

error_gen_agent = ChatCompletionAgent(
        kernel=kernel_error_gen,
        name=ErrorGenAgent,
        description="Responsible for generating errors.",
        instructions=(
        ),
        arguments=KernelArguments(
            settings=settings_error_gen,
        ),
    )


fix_gen_agent = ChatCompletionAgent(
        kernel=kernel_fix_gen,
        name=ViolGenerationAgent,
        description="Responsible for fixing errors.",
        instructions=(
        ),
        arguments=KernelArguments(
            settings=settings_fix_gen,
        ),
    )

    history_reducer = ChatHistoryTruncationReducer(target_count=5)



    termination_strategy = KernelFunctionTerminationStrategy(

        agents=[<Both Agents>],
        function=termination_function,
        kernel=kernel_fix_gen,
        result_parser=result_parser_termination,
        agent_variable_name="agent",
        history_variable_name="lastmessage",
        maximum_iterations=10,
        history_reducer=history_reducer,
    )

    selection_strategy=KernelFunctionSelectionStrategy(
            agents=[<Both Agents>],
            function=selection_function,
            kernel=kernel_fix_gen,
            result_parser = result_parser_selection,
            history_variable_name="lastmessage",
            maximum_iterations=10,
            history_reducer=history_reducer,
        )

    chat = AgentGroupChat(

        agents=[error_gen_agent, fix_gen_agent],

        selection_strategy=selection_strategy,

        termination_strategy=termination_strategy,

    )

---

One agents generates errors and the other agent generates fixes, then the first agent validates those fixes. FixGenAgent is again called for remaining errors and the loop continues till all errors are resolved.

Issue:

When ErrorGenAgent says that it has generated errors, FixGenAgent calls the FixGen plugin and then tries to call ErrorGen plugin. The following error comes:

The function Plugin1-gen_errors is not part of the provided functions: Only functions: ['Plugin2-fix_errors'] are allowed, Plugin1-gen_errors is not allowed..

[moonbox3]

Thanks for providing the detailed code. It's not 100% apparent to me, because you are using the FunctionChoiceBehavior filter argument, but I believe that because the AgentGroupChat has a shared chat history where each agent is able to see context used by other agents, the LLM is thinking it has a plugin available (used by one agent) when in fact it is not available. There are some further details left out here - I can understand not wanting to provide everything in code. I would check how you are telling the agent which functions it is allowed to call. As an example, it may be worth it to provide in some system message or prompt that each agent only has "these plugins" available - you could even include the schema or names of functions - which they can use.

The other side is, move to separate kernel instances for each agent. One agent may still be able to see some context from another, related to plugin-use, but try adding some text in the instructions or prompt that the agent must only call functions advertised to it.