unregister_function leaves ghost schemas in LLMContext (manual registration)

[omChauhanDev]

pipecat version

0.0.98

Python version

3.12.3

Operating System

macOs

Issue description

I ran into a runtime error when trying to unregister a tool that I registered manually (using register_function + ToolsSchema).

It looks like unregister_function correctly removes the Python handler from the execution list, but it doesn't remove the JSON schema from the LLMContext. This leaves the LLM thinking the tool is still available. If the LLM tries to call it later in the conversation, Pipecat crashes (or errors out) because the handler is gone.

This is inconsistent with unregister_direct_function, which seems to clean up both the handler and the schema automatically.

Reproduction steps

1. Register a function manually: llm.register_function("get_weather", weather_handler).
2. Add the schema to the context: context = LLMContext(..., tools=[weather_schema]).
3. Start the bot.
4. In the middle of the flow, call llm.unregister_function("get_weather").
5. Ask the bot a question that triggers that tool.

Expected behavior

I expected unregister_function to either:

1. Automatically remove the schema from the context (like the direct method does).
2. Or at least warn me that I need to manually clean up the schema myself.

Actual behavior

The function handler is removed silently. The LLM still sees the tool in its system prompt, attempts to call it, and the bot fails because no handler exists for "get_weather".

Logs

[omChauhanDev]

After giving it a 2nd thought, realized that it's not exactly a bug, but just a gap in how manual functions are handled compared to direct ones.

Since register_function doesn't currently store the schema we pass in, unregister_function doesn't know it exists and can't clean it up. This leads to the runtime error because the LLM keeps trying to call a function that's gone.

So, we can either just add a log warning in unregister_function that reminds the dev to manually remove the schema from their context if they are using manual registration.

OR

Can simply, update register_function to accept an optional schema argument. This way, the service actually knows about the schema and can automatically remove it when we call unregister.

this way, final change would look like -
In llm_service.py:

# 1. Accept optional schema so we can track it
def register_function(self, function_name: str, callback: Callable, schema: dict | None = None):
    self._function_call_handlers[function_name] = callback
    if schema:
        self._manual_tool_schemas[function_name] = schema 

# 2. Cleanup both handler and schema
def unregister_function(self, function_name: str | None):
    if function_name in self._function_call_handlers:
        del self._function_call_handlers[function_name]
    if function_name in self._manual_tool_schemas:
        del self._manual_tool_schemas[function_name]

# 3. Expose unified tool list
@property
def tools(self) -> list:
    return self._direct_tools + list(self._manual_tool_schemas.values())

in llm_context :

@property
def tools(self):
    if self._tool_source:
         return self._tool_source.tools
    return self._static_tools

Can push a pr for this, but lmk if the "simple warning" is preferred instead, or if I'm missing any context.