mirror of
https://github.com/microsoft/agent-framework.git
synced 2026-06-16 21:04:09 +08:00
Eduard van Valkenburg
49a6e433a3
* Python: progressive tool exposure via FunctionInvocationContext Add first-class progressive tool exposure to the Python core function-calling loop. Tools can now add or remove real FunctionTool schemas at runtime via the injected FunctionInvocationContext, taking effect on the next iteration of the loop. - FunctionInvocationContext gains a live `tools` list plus experimental `add_tools()` / `remove_tools()` helpers (feature: PROGRESSIVE_TOOLS). - The function-calling loop establishes a run-local, normalized tools list and threads it into the context at both invocation paths so mutations propagate. - Add a sample (dynamic_tool_exposure.py) and a tools samples README, including a note that CodeAct providers (Monty/Hyperlight) use their own provider-level tool management instead. Supersedes #3877. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Validate non-negative input in dynamic_tool_exposure sample tools Address review feedback: factorial and fibonacci now return an error message for negative n instead of producing incorrect results. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Make add_tools atomic and surface swallowed function errors Address review feedback on progressive tool exposure: - add_tools now validates the full batch against a throwaway copy before committing, so a duplicate-name clash partway through a sequence leaves the live tool list unchanged (all-or-nothing). - _auto_invoke_function now logs a warning (with traceback) when a tool raises, so contract errors such as a duplicate-name ValueError from add_tools are debuggable without enabling include_detailed_errors. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Avoid retaining tracebacks when logging swallowed function errors Logging with exc_info=exc fed the exception traceback to the logging machinery, whose frame references created reference cycles collected lazily by the cyclic GC. On Windows that could drop a hyperlight WasmSandbox on a non-owning thread ("unsendable, dropped on another thread"), crashing the xdist worker. Log a pre-formatted message with the exception repr instead, so no traceback object is retained. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * added missing decorator --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
80 lines
2.9 KiB
Python
80 lines
2.9 KiB
Python
# Copyright (c) Microsoft. All rights reserved.
|
|
|
|
import asyncio
|
|
from typing import Annotated
|
|
|
|
from agent_framework import Agent, FunctionInvocationContext, tool
|
|
from agent_framework.openai import OpenAIChatClient
|
|
from dotenv import load_dotenv
|
|
from pydantic import Field
|
|
|
|
# Load environment variables from .env file
|
|
load_dotenv()
|
|
|
|
"""
|
|
Dynamic Tool Exposure (Progressive Tool Loading) Example
|
|
|
|
This example demonstrates "progressive tool exposure": a tool that adds more tools to
|
|
the agent at runtime, in the same run, via ``FunctionInvocationContext``.
|
|
|
|
Frontloading a model with hundreds of tools hurts tool-selection accuracy, bloats
|
|
context, and raises cost. Instead, you can start with a small set of "loader" tools and
|
|
let the model pull in additional tools on demand. Tools added with ``ctx.add_tools(...)``
|
|
(or removed with ``ctx.remove_tools(...)``) become available to the model on the next
|
|
iteration of the function-calling loop.
|
|
"""
|
|
|
|
|
|
# These math tools are not registered on the agent up front. They are added on demand by
|
|
# the ``load_math_tools`` tool below, and only then become callable by the model.
|
|
@tool(approval_mode="never_require")
|
|
def factorial(n: Annotated[int, Field(description="A non-negative integer.")]) -> str:
|
|
"""Compute the factorial of n."""
|
|
if n < 0:
|
|
return "Error: n must be a non-negative integer."
|
|
result = 1
|
|
for value in range(2, n + 1):
|
|
result *= value
|
|
return f"{n}! = {result}"
|
|
|
|
|
|
@tool(approval_mode="never_require")
|
|
def fibonacci(n: Annotated[int, Field(description="The 0-based index in the Fibonacci sequence.")]) -> str:
|
|
"""Compute the n-th Fibonacci number."""
|
|
if n < 0:
|
|
return "Error: n must be a non-negative integer."
|
|
a, b = 0, 1
|
|
for _ in range(n):
|
|
a, b = b, a + b
|
|
return f"fib({n}) = {a}"
|
|
|
|
|
|
# The only tool the agent starts with. When called, it exposes the math tools above so the
|
|
# model can use them on the next turn. Note the ``ctx`` parameter is injected by the
|
|
# framework and is not visible to the model.
|
|
@tool(approval_mode="never_require")
|
|
def load_math_tools(ctx: FunctionInvocationContext) -> str:
|
|
"""Load additional math tools (factorial, fibonacci) so they can be used."""
|
|
ctx.add_tools([factorial, fibonacci])
|
|
return "Loaded math tools: factorial, fibonacci. You can now call them."
|
|
|
|
|
|
async def main() -> None:
|
|
agent = Agent(
|
|
client=OpenAIChatClient(),
|
|
name="MathAgent",
|
|
instructions=(
|
|
"You are a math assistant. If you need math capabilities that are not yet "
|
|
"available, call load_math_tools first, then use the newly available tools."
|
|
),
|
|
tools=[load_math_tools],
|
|
)
|
|
|
|
# The agent starts with only ``load_math_tools``. To answer the question it must first
|
|
# load the math tools, then call ``factorial`` on the next iteration.
|
|
print(f"Agent: {await agent.run('What is 5 factorial?')}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(main())
|