code
stringlengths 66
870k
| docstring
stringlengths 19
26.7k
| func_name
stringlengths 1
138
| language
stringclasses 1
value | repo
stringlengths 7
68
| path
stringlengths 5
324
| url
stringlengths 46
389
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
def write_jsonl(filename: str, data: Iterable[Dict], append: bool = False):
"""
Writes an iterable of dictionaries to jsonl
"""
if append:
mode = 'ab'
else:
mode = 'wb'
filename = os.path.expanduser(filename)
if filename.endswith(".gz"):
with open(filename, mode) as fp:
with gzip.GzipFile(fileobj=fp, mode='wb') as gzfp:
for x in data:
gzfp.write((json.dumps(x) + "\n").encode('utf-8'))
else:
with open(filename, mode) as fp:
for x in data:
fp.write((json.dumps(x) + "\n").encode('utf-8'))
|
Writes an iterable of dictionaries to jsonl
|
write_jsonl
|
python
|
xjdr-alt/entropix
|
evals/human-eval/human_eval/data.py
|
https://github.com/xjdr-alt/entropix/blob/master/evals/human-eval/human_eval/data.py
|
Apache-2.0
|
def entry_point(
sample_file: str,
k: str = "1,10,100",
n_workers: int = 4,
timeout: float = 3.0,
problem_file: str = HUMAN_EVAL,
):
"""
Evaluates the functional correctness of generated samples, and writes
results to f"{sample_file}_results.jsonl.gz"
"""
k = list(map(int, k.split(",")))
results = evaluate_functional_correctness(sample_file, k, n_workers, timeout, problem_file)
print(results)
|
Evaluates the functional correctness of generated samples, and writes
results to f"{sample_file}_results.jsonl.gz"
|
entry_point
|
python
|
xjdr-alt/entropix
|
evals/human-eval/human_eval/evaluate_functional_correctness.py
|
https://github.com/xjdr-alt/entropix/blob/master/evals/human-eval/human_eval/evaluate_functional_correctness.py
|
Apache-2.0
|
def estimate_pass_at_k(
num_samples: Union[int, List[int], np.ndarray],
num_correct: Union[List[int], np.ndarray],
k: int
) -> np.ndarray:
"""
Estimates pass@k of each problem and returns them in an array.
"""
def estimator(n: int, c: int, k: int) -> float:
"""
Calculates 1 - comb(n - c, k) / comb(n, k).
"""
if n - c < k:
return 1.0
return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))
if isinstance(num_samples, int):
num_samples_it = itertools.repeat(num_samples, len(num_correct))
else:
assert len(num_samples) == len(num_correct)
num_samples_it = iter(num_samples)
return np.array([estimator(int(n), int(c), k) for n, c in zip(num_samples_it, num_correct)])
|
Estimates pass@k of each problem and returns them in an array.
|
estimate_pass_at_k
|
python
|
xjdr-alt/entropix
|
evals/human-eval/human_eval/evaluation.py
|
https://github.com/xjdr-alt/entropix/blob/master/evals/human-eval/human_eval/evaluation.py
|
Apache-2.0
|
def evaluate_functional_correctness(
sample_file: str,
k: List[int] = [1, 10, 100],
n_workers: int = 4,
timeout: float = 3.0,
problem_file: str = HUMAN_EVAL,
):
"""
Evaluates the functional correctness of generated samples, and writes
results to f"{sample_file}_results.jsonl.gz"
"""
problems = read_problems(problem_file)
# Check the generated samples against test suites.
with ThreadPoolExecutor(max_workers=n_workers) as executor:
futures = []
completion_id = Counter()
n_samples = 0
results = defaultdict(list)
print("Reading samples...")
for sample in tqdm.tqdm(stream_jsonl(sample_file)):
task_id = sample["task_id"]
completion = sample["completion"]
args = (problems[task_id], completion, timeout, completion_id[task_id])
future = executor.submit(check_correctness, *args)
futures.append(future)
completion_id[task_id] += 1
n_samples += 1
assert len(completion_id) == len(problems), "Some problems are not attempted."
print("Running test suites...")
for future in tqdm.tqdm(as_completed(futures), total=len(futures)):
result = future.result()
results[result["task_id"]].append((result["completion_id"], result))
# Calculate pass@k.
total, correct = [], []
for result in results.values():
result.sort()
passed = [r[1]["passed"] for r in result]
total.append(len(passed))
correct.append(sum(passed))
total = np.array(total)
correct = np.array(correct)
ks = k
pass_at_k = {f"pass@{k}": estimate_pass_at_k(total, correct, k).mean()
for k in ks if (total >= k).all()}
# Finally, save the results in one file:
def combine_results():
for sample in stream_jsonl(sample_file):
task_id = sample["task_id"]
result = results[task_id].pop(0)
sample["result"] = result[1]["result"]
sample["passed"] = result[1]["passed"]
yield sample
out_file = sample_file + "_results.jsonl"
print(f"Writing results to {out_file}...")
write_jsonl(out_file, tqdm.tqdm(combine_results(), total=n_samples))
return pass_at_k
|
Evaluates the functional correctness of generated samples, and writes
results to f"{sample_file}_results.jsonl.gz"
|
evaluate_functional_correctness
|
python
|
xjdr-alt/entropix
|
evals/human-eval/human_eval/evaluation.py
|
https://github.com/xjdr-alt/entropix/blob/master/evals/human-eval/human_eval/evaluation.py
|
Apache-2.0
|
def check_correctness(problem: Dict, completion: str, timeout: float,
completion_id: Optional[int] = None) -> Dict:
"""
Evaluates the functional correctness of a completion by running the test
suite provided in the problem.
:param completion_id: an optional completion ID so we can match
the results later even if execution finishes asynchronously.
"""
def unsafe_execute():
with create_tempdir():
# These system calls are needed when cleaning up tempdir.
import os
import shutil
rmtree = shutil.rmtree
rmdir = os.rmdir
chdir = os.chdir
# Disable functionalities that can make destructive changes to the test.
reliability_guard()
# Construct the check program and run it.
check_program = (
problem["prompt"] + completion + "\n" +
problem["test"] + "\n" +
f"check({problem['entry_point']})"
)
try:
exec_globals = {}
with swallow_io():
with time_limit(timeout):
exec(check_program, exec_globals)
result.append("passed")
except TimeoutException:
result.append("timed out")
except BaseException as e:
result.append(f"failed: {e}")
# Needed for cleaning up.
shutil.rmtree = rmtree
os.rmdir = rmdir
os.chdir = chdir
manager = multiprocessing.Manager()
result = manager.list()
p = multiprocessing.Process(target=unsafe_execute)
p.start()
p.join(timeout=timeout + 1)
if p.is_alive():
p.kill()
if not result:
result.append("timed out")
return dict(
task_id=problem["task_id"],
passed=result[0] == "passed",
result=result[0],
completion_id=completion_id,
)
|
Evaluates the functional correctness of a completion by running the test
suite provided in the problem.
:param completion_id: an optional completion ID so we can match
the results later even if execution finishes asynchronously.
|
check_correctness
|
python
|
xjdr-alt/entropix
|
evals/human-eval/human_eval/execution.py
|
https://github.com/xjdr-alt/entropix/blob/master/evals/human-eval/human_eval/execution.py
|
Apache-2.0
|
def reliability_guard(maximum_memory_bytes: Optional[int] = None):
"""
This disables various destructive functions and prevents the generated code
from interfering with the test (e.g. fork bomb, killing other processes,
removing filesystem files, etc.)
WARNING
This function is NOT a security sandbox. Untrusted code, including, model-
generated code, should not be blindly executed outside of one. See the
Codex paper for more information about OpenAI's code sandbox, and proceed
with caution.
"""
if maximum_memory_bytes is not None:
import resource
resource.setrlimit(resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes))
resource.setrlimit(resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes))
if not platform.uname().system == 'Darwin':
resource.setrlimit(resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes))
faulthandler.disable()
import builtins
builtins.exit = None
builtins.quit = None
import os
os.environ['OMP_NUM_THREADS'] = '1'
os.kill = None
os.system = None
os.putenv = None
os.remove = None
os.removedirs = None
os.rmdir = None
os.fchdir = None
os.setuid = None
os.fork = None
os.forkpty = None
os.killpg = None
os.rename = None
os.renames = None
os.truncate = None
os.replace = None
os.unlink = None
os.fchmod = None
os.fchown = None
os.chmod = None
os.chown = None
os.chroot = None
os.fchdir = None
os.lchflags = None
os.lchmod = None
os.lchown = None
os.getcwd = None
os.chdir = None
import shutil
shutil.rmtree = None
shutil.move = None
shutil.chown = None
import subprocess
subprocess.Popen = None # type: ignore
__builtins__['help'] = None
import sys
sys.modules['ipdb'] = None
sys.modules['joblib'] = None
sys.modules['resource'] = None
sys.modules['psutil'] = None
sys.modules['tkinter'] = None
|
This disables various destructive functions and prevents the generated code
from interfering with the test (e.g. fork bomb, killing other processes,
removing filesystem files, etc.)
WARNING
This function is NOT a security sandbox. Untrusted code, including, model-
generated code, should not be blindly executed outside of one. See the
Codex paper for more information about OpenAI's code sandbox, and proceed
with caution.
|
reliability_guard
|
python
|
xjdr-alt/entropix
|
evals/human-eval/human_eval/execution.py
|
https://github.com/xjdr-alt/entropix/blob/master/evals/human-eval/human_eval/execution.py
|
Apache-2.0
|
def setup_logger(
level: int = logging.ERROR,
rich_tracebacks: bool = True,
log_format: str | None = None,
propagate: bool = False,
**kwargs: Any,
) -> None:
"""Configure the any_agent logger with the specified settings.
Args:
level: The logging level to use (default: logging.INFO)
rich_tracebacks: Whether to enable rich tracebacks (default: True)
log_format: Optional custom log format string
propagate: Whether to propagate logs to parent loggers (default: False)
**kwargs: Additional keyword arguments to pass to RichHandler
"""
logger.setLevel(level)
logger.propagate = propagate
# Remove any existing handlers
for handler in logger.handlers[:]:
logger.removeHandler(handler)
handler = RichHandler(rich_tracebacks=rich_tracebacks, markup=True, **kwargs)
if log_format:
formatter = logging.Formatter(log_format)
handler.setFormatter(formatter)
logger.addHandler(handler)
|
Configure the any_agent logger with the specified settings.
Args:
level: The logging level to use (default: logging.INFO)
rich_tracebacks: Whether to enable rich tracebacks (default: True)
log_format: Optional custom log format string
propagate: Whether to propagate logs to parent loggers (default: False)
**kwargs: Additional keyword arguments to pass to RichHandler
|
setup_logger
|
python
|
mozilla-ai/any-agent
|
src/any_agent/logging.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/logging.py
|
Apache-2.0
|
def get_evidence_from_spans(self) -> str:
"""Get a summary of what happened in each step/span of the agent trace.
This includes information about the input, output, and tool calls for each step.
Returns:
str: The evidence of all the spans in the trace
"""
evidence = ""
for idx, span in enumerate(self.trace.spans):
evidence += (
f"### Step {idx}: {span.attributes.get('gen_ai.operation.name')}\n"
)
if idx == 0:
input_val = span.attributes.get("gen_ai.input.messages")
# messages should always be json
if input_val:
input_json = json.loads(input_val)
evidence += f"Input: {json.dumps(input_json, indent=2)}\n\n"
tool_args = span.attributes.get("gen_ai.tool.args")
if tool_args:
args_json = json.loads(tool_args)
tool_name = span.attributes.get("gen_ai.tool.name")
evidence += f"Tool called: {tool_name}\n\n"
evidence += f"Tool arguments: {json.dumps(args_json, indent=2)}\n\n"
output = span.attributes.get("gen_ai.output")
if output:
try:
output_json = json.loads(output)
# the output can be quite long, truncate if needed
pretty_output = json.dumps(output_json, indent=2)
pretty_output = (
pretty_output[:MAX_EVIDENCE_LENGTH] + "...[TRUNCATED]"
if len(pretty_output) > MAX_EVIDENCE_LENGTH
else pretty_output
)
evidence += f"Output: {pretty_output}\n\n"
except json.JSONDecodeError:
evidence += f"Output: {output}\n\n"
return evidence
|
Get a summary of what happened in each step/span of the agent trace.
This includes information about the input, output, and tool calls for each step.
Returns:
str: The evidence of all the spans in the trace
|
get_evidence_from_spans
|
python
|
mozilla-ai/any-agent
|
src/any_agent/evaluation/agent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/evaluation/agent.py
|
Apache-2.0
|
def from_yaml(cls, evaluation_case_path: str) -> EvaluationCase:
"""Load a test case from a YAML file and process it."""
with open(evaluation_case_path, encoding="utf-8") as f:
evaluation_case_dict = yaml.safe_load(f)
if "ground_truth" in evaluation_case_dict:
# remove the points from the ground_truth but keep the name and value
evaluation_case_dict["ground_truth"].pop("points")
# verify that the llm_judge is a valid litellm model
validate_environment(evaluation_case_dict["llm_judge"])
return cls.model_validate(evaluation_case_dict)
|
Load a test case from a YAML file and process it.
|
from_yaml
|
python
|
mozilla-ai/any-agent
|
src/any_agent/evaluation/evaluation_case.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/evaluation/evaluation_case.py
|
Apache-2.0
|
def evaluate_checkpoints(
model: str,
trace: AgentTrace,
checkpoints: Sequence[CheckpointCriteria],
) -> list[EvaluationResult]:
"""Verify each checkpoint against the trace data using LLM.
Args:
model: The model to use for evaluation
trace: The trace data to evaluate
checkpoints: List of checkpoint criteria to verify
processor: Trace processor to extract evidence
Returns:
List of evaluation results
"""
results = []
checking_agent: AnyAgent = get_agent(trace, model)
for checkpoint in checkpoints:
if callable(checkpoint.criteria):
eval_output = checkpoint.criteria(trace)
else:
# Agent as a Judge
evaluation = checking_agent.run(
prompt=checkpoint.criteria, instrument=False
)
eval_output = evaluation.final_output # type: ignore[assignment]
result = EvaluationResult(
passed=eval_output.passed,
reason=eval_output.reasoning,
criteria=checkpoint.criteria,
points=checkpoint.points,
)
results.append(result)
return results
|
Verify each checkpoint against the trace data using LLM.
Args:
model: The model to use for evaluation
trace: The trace data to evaluate
checkpoints: List of checkpoint criteria to verify
processor: Trace processor to extract evidence
Returns:
List of evaluation results
|
evaluate_checkpoints
|
python
|
mozilla-ai/any-agent
|
src/any_agent/evaluation/evaluators.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/evaluation/evaluators.py
|
Apache-2.0
|
def _calculate_f1_score(prediction: str, ground_truth: str) -> float:
"""Calculate F1 score between prediction and ground truth strings."""
# Normalize strings: lowercase and roughly split into words
pred_tokens = set(prediction.lower().split())
truth_tokens = set(ground_truth.lower().split())
if not truth_tokens:
return 1.0 if not pred_tokens else 0.0
if not pred_tokens:
return 0.0
# Calculate precision and recall
common_tokens = pred_tokens.intersection(truth_tokens)
precision = len(common_tokens) / len(pred_tokens)
recall = len(common_tokens) / len(truth_tokens)
return 2 * (precision * recall) / (precision + recall)
|
Calculate F1 score between prediction and ground truth strings.
|
_calculate_f1_score
|
python
|
mozilla-ai/any-agent
|
src/any_agent/evaluation/evaluators.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/evaluation/evaluators.py
|
Apache-2.0
|
def evaluate_final_output(
final_output: str,
ground_truth_answer: GroundTruthAnswer,
) -> EvaluationResult:
"""Compare answers using simple string matching and F1 score."""
ground_truth_text = str(ground_truth_answer["value"])
# Check for exact match (case-insensitive)
exact_match = final_output.strip().lower() == ground_truth_text.strip().lower()
# Calculate F1 score for partial matching
f1_score = _calculate_f1_score(final_output, ground_truth_text)
return EvaluationResult(
passed=exact_match,
reason=f"Partial Match (F1) score is {round(f1_score, 2)}",
criteria="Is the answer a direct match?",
points=1,
)
|
Compare answers using simple string matching and F1 score.
|
evaluate_final_output
|
python
|
mozilla-ai/any-agent
|
src/any_agent/evaluation/evaluators.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/evaluation/evaluators.py
|
Apache-2.0
|
def score(self) -> float:
"""Calculate the score based on the evaluation results."""
if self.ground_truth_result is not None:
all_results = [*self.checkpoint_results, self.ground_truth_result]
else:
all_results = self.checkpoint_results
total_points = sum([result.points for result in all_results])
if total_points == 0:
msg = "Total points is 0, cannot calculate score."
raise ValueError(msg)
passed_points = sum([result.points for result in all_results if result.passed])
return float(passed_points / total_points)
|
Calculate the score based on the evaluation results.
|
score
|
python
|
mozilla-ai/any-agent
|
src/any_agent/evaluation/schemas.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/evaluation/schemas.py
|
Apache-2.0
|
def _get_model(self, agent_config: AgentConfig) -> "Model":
"""Get the model configuration for an Agno agent."""
model_type = agent_config.model_type or DEFAULT_MODEL_TYPE
return model_type(
id=agent_config.model_id,
api_base=agent_config.api_base,
api_key=agent_config.api_key,
request_params=agent_config.model_args or {}, # type: ignore[arg-type]
)
|
Get the model configuration for an Agno agent.
|
_get_model
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/agno.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/agno.py
|
Apache-2.0
|
def create(
cls,
agent_framework: AgentFramework | str,
agent_config: AgentConfig,
) -> AnyAgent:
"""Create an agent using the given framework and config."""
return run_async_in_sync(
cls.create_async(
agent_framework=agent_framework,
agent_config=agent_config,
)
)
|
Create an agent using the given framework and config.
|
create
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/any_agent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/any_agent.py
|
Apache-2.0
|
async def create_async(
cls,
agent_framework: AgentFramework | str,
agent_config: AgentConfig,
) -> AnyAgent:
"""Create an agent using the given framework and config."""
agent_cls = cls._get_agent_type_by_framework(agent_framework)
agent = agent_cls(agent_config)
await agent._load_agent()
return agent
|
Create an agent using the given framework and config.
|
create_async
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/any_agent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/any_agent.py
|
Apache-2.0
|
async def run_async(
self, prompt: str, instrument: bool = True, **kwargs: Any
) -> AgentTrace:
"""Run the agent asynchronously with the given prompt.
Args:
prompt: The user prompt to be passed to the agent.
instrument: Whether to instrument the underlying framework
to generate LLM Calls and Tool Execution Spans.
If `False` the returned `AgentTrace` will only
contain a single `invoke_agent` span.
kwargs: Will be passed to the underlying runner used
by the framework.
Returns:
The `AgentTrace` containing information about the
steps taken by the agent.
"""
try:
trace = AgentTrace()
with self._tracer.start_as_current_span(
f"invoke_agent [{self.config.name}]"
) as invoke_span:
if instrument and self._instrumentor:
trace_id = invoke_span.get_span_context().trace_id
async with self._lock:
# We check the locked `_running_traces` inside `instrument`.
# If there is more than 1 entry in `running_traces`, it means that the agent has
# already being instrumented so me won't instrument it again.
self._running_traces[trace_id] = AgentTrace()
self._instrumentor.instrument(
agent=self, # type: ignore[arg-type]
)
invoke_span.set_attributes(
{
"gen_ai.operation.name": "invoke_agent",
"gen_ai.agent.name": self.config.name,
"gen_ai.agent.description": self.config.description
or "No description.",
"gen_ai.request.model": self.config.model_id,
}
)
final_output = await self._run_async(prompt, **kwargs)
if instrument and self._instrumentor:
async with self._lock:
self._instrumentor.uninstrument(self) # type: ignore[arg-type]
trace = self._running_traces.pop(trace_id)
except Exception as e:
if instrument:
async with self._lock:
trace = self._running_traces.pop(trace_id)
trace.add_span(invoke_span)
raise AgentRunError(trace) from e
else:
trace.add_span(invoke_span)
trace.final_output = final_output
return trace
|
Run the agent asynchronously with the given prompt.
Args:
prompt: The user prompt to be passed to the agent.
instrument: Whether to instrument the underlying framework
to generate LLM Calls and Tool Execution Spans.
If `False` the returned `AgentTrace` will only
contain a single `invoke_agent` span.
kwargs: Will be passed to the underlying runner used
by the framework.
Returns:
The `AgentTrace` containing information about the
steps taken by the agent.
|
run_async
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/any_agent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/any_agent.py
|
Apache-2.0
|
def serve(self, serving_config: A2AServingConfig | None = None) -> None:
"""Serve this agent using the protocol defined in the serving_config.
Args:
serving_config: Configuration for serving the agent. If None, uses default A2AServingConfig.
Must be an instance of A2AServingConfig.
Raises:
ImportError: If the `serving` dependencies are not installed.
Example:
agent = AnyAgent.create("tinyagent", AgentConfig(...))
config = A2AServingConfig(port=8080, endpoint="/my-agent")
agent.serve(config)
"""
from any_agent.serving import A2AServingConfig, _get_a2a_app, serve_a2a
if serving_config is None:
serving_config = A2AServingConfig()
app = _get_a2a_app(self, serving_config=serving_config)
serve_a2a(
app,
host=serving_config.host,
port=serving_config.port,
endpoint=serving_config.endpoint,
log_level=serving_config.log_level,
)
|
Serve this agent using the protocol defined in the serving_config.
Args:
serving_config: Configuration for serving the agent. If None, uses default A2AServingConfig.
Must be an instance of A2AServingConfig.
Raises:
ImportError: If the `serving` dependencies are not installed.
Example:
agent = AnyAgent.create("tinyagent", AgentConfig(...))
config = A2AServingConfig(port=8080, endpoint="/my-agent")
agent.serve(config)
|
serve
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/any_agent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/any_agent.py
|
Apache-2.0
|
async def serve_async(
self, serving_config: A2AServingConfig | None = None
) -> tuple[asyncio.Task[Any], uvicorn.Server]:
"""Serve this agent asynchronously using the protocol defined in the serving_config.
Args:
serving_config: Configuration for serving the agent. If None, uses default A2AServingConfig.
Must be an instance of A2AServingConfig.
Returns:
A tuple containing:
- asyncio.Task: The server task (keep a reference to prevent garbage collection)
- uvicorn.Server: The server instance for controlling the server lifecycle
Raises:
ImportError: If the `serving` dependencies are not installed.
Example:
>>> agent = await AnyAgent.create_async("tinyagent", AgentConfig(...))
>>> config = A2AServingConfig(port=8080)
>>> task, server = await agent.serve_async(config)
>>> try:
... # Server is running
... await asyncio.sleep(10)
>>> finally:
... server.should_exit = True
... await task
"""
from any_agent.serving import A2AServingConfig, _get_a2a_app, serve_a2a_async
if serving_config is None:
serving_config = A2AServingConfig()
if not isinstance(serving_config, A2AServingConfig):
msg = (
f"serving_config must be an instance of A2AServingConfig, "
f"got {serving_config.type}. "
f"Currently only A2A serving is supported."
)
raise ValueError(msg)
app = _get_a2a_app(self, serving_config=serving_config)
return await serve_a2a_async(
app,
host=serving_config.host,
port=serving_config.port,
endpoint=serving_config.endpoint,
log_level=serving_config.log_level,
)
|
Serve this agent asynchronously using the protocol defined in the serving_config.
Args:
serving_config: Configuration for serving the agent. If None, uses default A2AServingConfig.
Must be an instance of A2AServingConfig.
Returns:
A tuple containing:
- asyncio.Task: The server task (keep a reference to prevent garbage collection)
- uvicorn.Server: The server instance for controlling the server lifecycle
Raises:
ImportError: If the `serving` dependencies are not installed.
Example:
>>> agent = await AnyAgent.create_async("tinyagent", AgentConfig(...))
>>> config = A2AServingConfig(port=8080)
>>> task, server = await agent.serve_async(config)
>>> try:
... # Server is running
... await asyncio.sleep(10)
>>> finally:
... server.should_exit = True
... await task
|
serve_async
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/any_agent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/any_agent.py
|
Apache-2.0
|
async def _run_async(self, prompt: str, **kwargs: Any) -> str | BaseModel:
"""To be implemented by each framework."""
|
To be implemented by each framework.
|
_run_async
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/any_agent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/any_agent.py
|
Apache-2.0
|
def _get_model(self, agent_config: AgentConfig) -> "BaseLlm":
"""Get the model configuration for a Google agent."""
model_type = agent_config.model_type or DEFAULT_MODEL_TYPE
model_args = agent_config.model_args or {}
if self.config.output_type:
model_args["tool_choice"] = "required"
return model_type(
model=agent_config.model_id,
api_key=agent_config.api_key,
api_base=agent_config.api_base,
**model_args,
)
|
Get the model configuration for a Google agent.
|
_get_model
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/google.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/google.py
|
Apache-2.0
|
async def _load_agent(self) -> None:
"""Load the Google agent with the given configuration."""
if not adk_available:
msg = "You need to `pip install 'any-agent[google]'` to use this agent"
raise ImportError(msg)
tools, _ = await self._load_tools(self.config.tools)
agent_type = self.config.agent_type or LlmAgent
self._tools = tools
instructions = self.config.instructions or ""
if self.config.output_type:
instructions += (
"You must call the final_output tool when finished."
"The 'answer' argument passed to the final_output tool must be a JSON string that matches the following schema:\n"
f"{self.config.output_type.model_json_schema()}"
)
output_fn = FinalOutputTool(self.config.output_type)
tools.append(output_fn)
self._agent = agent_type(
name=self.config.name,
instruction=instructions,
model=self._get_model(self.config),
tools=tools,
**self.config.agent_args or {},
output_key="response",
)
|
Load the Google agent with the given configuration.
|
_load_agent
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/google.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/google.py
|
Apache-2.0
|
def _get_model(self, agent_config: AgentConfig) -> "LanguageModelLike":
"""Get the model configuration for a LangChain agent."""
model_type = agent_config.model_type or DEFAULT_MODEL_TYPE
model_args = agent_config.model_args or {}
return cast(
"LanguageModelLike",
model_type(
model=agent_config.model_id,
api_key=agent_config.api_key,
api_base=agent_config.api_base,
model_kwargs=model_args, # type: ignore[arg-type]
),
)
|
Get the model configuration for a LangChain agent.
|
_get_model
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/langchain.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/langchain.py
|
Apache-2.0
|
async def _load_agent(self) -> None:
"""Load the LangChain agent with the given configuration."""
if not langchain_available:
msg = "You need to `pip install 'any-agent[langchain]'` to use this agent"
raise ImportError(msg)
imported_tools, _ = await self._load_tools(self.config.tools)
self._tools = imported_tools
agent_type = self.config.agent_type or DEFAULT_AGENT_TYPE
agent_args = self.config.agent_args or {}
if self.config.output_type:
agent_args["response_format"] = self.config.output_type
self._agent = agent_type(
name=self.config.name,
model=self._get_model(self.config),
tools=imported_tools,
prompt=self.config.instructions,
**agent_args,
)
|
Load the LangChain agent with the given configuration.
|
_load_agent
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/langchain.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/langchain.py
|
Apache-2.0
|
def _get_model(self, agent_config: AgentConfig) -> "LLM":
"""Get the model configuration for a llama_index agent."""
model_type = agent_config.model_type or DEFAULT_MODEL_TYPE
return cast(
"LLM",
model_type(
model=agent_config.model_id,
api_key=agent_config.api_key,
api_base=agent_config.api_base,
additional_kwargs=agent_config.model_args or {}, # type: ignore[arg-type]
),
)
|
Get the model configuration for a llama_index agent.
|
_get_model
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/llama_index.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/llama_index.py
|
Apache-2.0
|
async def _load_agent(self) -> None:
"""Load the LLamaIndex agent with the given configuration."""
if not llama_index_available:
msg = "You need to `pip install 'any-agent[llama_index]'` to use this agent"
raise ImportError(msg)
instructions = self.config.instructions
tools_to_use = list(self.config.tools)
if self.config.output_type:
instructions = instructions or ""
instructions += f"""You must return a {self.config.output_type.__name__} JSON string.
This object must match the following schema:
{self.config.output_type.model_json_schema()}
You can use the 'final_output' tool to help verify your output
"""
tools_to_use.append(FinalOutputTool(self.config.output_type))
imported_tools, _ = await self._load_tools(tools_to_use)
agent_type = self.config.agent_type or DEFAULT_AGENT_TYPE
# if agent type is FunctionAgent but there are no tools, throw an error
if agent_type == FunctionAgent and not imported_tools:
logger.warning(
"FunctionAgent requires tools and none were provided. Using ReActAgent instead."
)
agent_type = ReActAgent
self._tools = imported_tools
self._agent = agent_type(
name=self.config.name,
tools=imported_tools,
description=self.config.description or "The main agent",
llm=self._get_model(self.config),
system_prompt=instructions,
**self.config.agent_args or {},
)
|
Load the LLamaIndex agent with the given configuration.
|
_load_agent
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/llama_index.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/llama_index.py
|
Apache-2.0
|
def _get_model(
self,
agent_config: AgentConfig,
) -> "Model":
"""Get the model configuration for an OpenAI agent."""
model_type = agent_config.model_type or DEFAULT_MODEL_TYPE
return model_type(
model=agent_config.model_id,
base_url=agent_config.api_base,
api_key=agent_config.api_key,
)
|
Get the model configuration for an OpenAI agent.
|
_get_model
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/openai.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/openai.py
|
Apache-2.0
|
async def _load_agent(self) -> None:
"""Load the OpenAI agent with the given configuration."""
if not agents_available:
msg = "You need to `pip install 'any-agent[openai]'` to use this agent"
raise ImportError(msg)
if not agents_available:
msg = "You need to `pip install openai-agents` to use this agent"
raise ImportError(msg)
tools, mcp_servers = await self._load_tools(self.config.tools)
tools = self._filter_mcp_tools(tools, mcp_servers)
kwargs_ = self.config.agent_args or {}
if self.config.model_args:
kwargs_["model_settings"] = ModelSettings(**self.config.model_args)
if self.config.output_type:
kwargs_["output_type"] = self.config.output_type
self._tools = tools
self._agent = Agent(
name=self.config.name,
instructions=self.config.instructions,
model=self._get_model(self.config),
tools=tools,
mcp_servers=[mcp_server.server for mcp_server in mcp_servers],
**kwargs_,
)
|
Load the OpenAI agent with the given configuration.
|
_load_agent
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/openai.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/openai.py
|
Apache-2.0
|
def _filter_mcp_tools(self, tools: list[Any], mcp_servers: list[Any]) -> list[Any]:
"""OpenAI frameowrk doesn't expect the mcp tool to be included in `tools`."""
non_mcp_tools = []
for tool in tools:
if any(tool in mcp_server.tools for mcp_server in mcp_servers):
continue
non_mcp_tools.append(tool)
return non_mcp_tools
|
OpenAI frameowrk doesn't expect the mcp tool to be included in `tools`.
|
_filter_mcp_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/openai.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/openai.py
|
Apache-2.0
|
def _get_model(self, agent_config: AgentConfig) -> Any:
"""Get the model configuration for a smolagents agent."""
model_type = agent_config.model_type or DEFAULT_MODEL_TYPE
model_args = agent_config.model_args or {}
kwargs = {
"model_id": agent_config.model_id,
"api_key": agent_config.api_key,
"api_base": agent_config.api_base,
**model_args,
}
return model_type(**kwargs)
|
Get the model configuration for a smolagents agent.
|
_get_model
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/smolagents.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/smolagents.py
|
Apache-2.0
|
async def _load_agent(self) -> None:
"""Load the Smolagents agent with the given configuration."""
if not smolagents_available:
msg = "You need to `pip install 'any-agent[smolagents]'` to use this agent"
raise ImportError(msg)
tools, _ = await self._load_tools(self.config.tools)
main_agent_type = self.config.agent_type or DEFAULT_AGENT_TYPE
agent_args = self.config.agent_args or {}
self._tools = tools
self._agent = main_agent_type(
name=self.config.name,
model=self._get_model(self.config),
tools=tools,
verbosity_level=-1, # OFF
**agent_args,
)
if self.config.instructions:
self._agent.prompt_templates["system_prompt"] = self.config.instructions
if self.config.output_type:
output_type = self.config.output_type
class CustomFinalAnswerTool(FinalAnswerTool): # type: ignore[no-untyped-call]
inputs = { # noqa: RUF012
"answer": {
"type": "string",
"description": f"The final answer to the problem. The input must be a string that conforms to the{output_type.__name__} object.",
}
}
def forward(self, answer: str) -> Any:
output_type.model_validate_json(answer)
return answer
self._agent.tools["final_answer"] = CustomFinalAnswerTool() # type: ignore[no-untyped-call]
self._agent.prompt_templates[
"system_prompt"
] += f"""\n\nYour final answer must be a {self.config.output_type.__name__} object.
This object must match the following schema:
{self.config.output_type.model_json_schema()}
"""
assert self._agent
|
Load the Smolagents agent with the given configuration.
|
_load_agent
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/smolagents.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/smolagents.py
|
Apache-2.0
|
async def call_tool(self, request: dict[str, Any]) -> str:
"""Call the tool function.
Args:
request: The tool request with name and arguments
Returns:
Tool execution result
"""
try:
arguments = request.get("arguments", {})
if hasattr(self.tool_function, "__annotations__"):
func_args = self.tool_function.__annotations__
for arg_name, arg_type in func_args.items():
if arg_name in arguments:
with suppress(Exception):
arguments[arg_name] = arg_type(arguments[arg_name])
if asyncio.iscoroutinefunction(self.tool_function):
result = await self.tool_function(**arguments)
else:
result = self.tool_function(**arguments)
if (
isinstance(result, CallToolResult)
and result.content
and isinstance(result.content[0], TextContent)
):
result = result.content[0].text
return str(result)
except Exception as e:
return f"Error executing tool: {e}"
|
Call the tool function.
Args:
request: The tool request with name and arguments
Returns:
Tool execution result
|
call_tool
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/tinyagent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/tinyagent.py
|
Apache-2.0
|
def __init__(self, config: AgentConfig) -> None:
"""Initialize the TinyAgent.
Args:
config: Agent configuration
tracing: Optional tracing configuration
"""
super().__init__(config)
self.clients: dict[str, ToolExecutor] = {}
self.completion_params = {
"model": self.config.model_id,
"tools": [],
"tool_choice": "auto",
**(self.config.model_args or {}),
}
if self.config.api_key:
self.completion_params["api_key"] = self.config.api_key
if self.config.api_base:
self.completion_params["api_base"] = self.config.api_base
|
Initialize the TinyAgent.
Args:
config: Agent configuration
tracing: Optional tracing configuration
|
__init__
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/tinyagent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/tinyagent.py
|
Apache-2.0
|
async def _load_agent(self) -> None:
"""Load the agent and its tools."""
wrapped_tools, mcp_servers = await self._load_tools(self.config.tools)
self._mcp_servers = (
mcp_servers # Store servers so that they don't get garbage collected
)
self._tools = wrapped_tools
for tool in wrapped_tools:
tool_name = tool.__name__
tool_desc = tool.__doc__ or f"Tool to {tool_name}"
if not hasattr(tool, "__input_schema__"):
sig = inspect.signature(tool)
properties = {}
required = []
for param_name, param in sig.parameters.items():
if param.kind in (
inspect.Parameter.VAR_POSITIONAL,
inspect.Parameter.VAR_KEYWORD,
):
continue
properties[param_name] = {
"type": "string",
"description": f"Parameter {param_name}",
}
if param.default == inspect.Parameter.empty:
required.append(param_name)
input_schema = {
"type": "object",
"properties": properties,
"required": required,
}
else:
input_schema = tool.__input_schema__
self.completion_params["tools"].append(
{
"type": "function",
"function": {
"name": tool_name,
"description": tool_desc,
"parameters": input_schema,
},
}
)
self.clients[tool_name] = ToolExecutor(tool)
logger.debug("Registered tool: %s", tool_name)
|
Load the agent and its tools.
|
_load_agent
|
python
|
mozilla-ai/any-agent
|
src/any_agent/frameworks/tinyagent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/frameworks/tinyagent.py
|
Apache-2.0
|
async def serve_a2a_async(
server: A2AStarletteApplication,
host: str,
port: int,
endpoint: str,
log_level: str = "warning",
) -> tuple[asyncio.Task[Any], uvicorn.Server]:
"""Provide an A2A server to be used in an event loop."""
uv_server = _create_server(server, host, port, endpoint, log_level)
task = asyncio.create_task(uv_server.serve())
while not uv_server.started: # noqa: ASYNC110
await asyncio.sleep(0.1)
if port == 0:
server_port = uv_server.servers[0].sockets[0].getsockname()[1]
server.agent_card.url = f"http://{host}:{server_port}/{endpoint.lstrip('/')}"
return (task, uv_server)
|
Provide an A2A server to be used in an event loop.
|
serve_a2a_async
|
python
|
mozilla-ai/any-agent
|
src/any_agent/serving/server.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/serving/server.py
|
Apache-2.0
|
async def a2a_tool_async(
url: str, toolname: str | None = None, http_kwargs: dict[str, Any] | None = None
) -> Callable[[str], Coroutine[Any, Any, str]]:
"""Perform a query using A2A to another agent.
Args:
url (str): The url in which the A2A agent is located.
toolname (str): The name for the created tool. Defaults to `call_{agent name in card}`.
Leading and trailing whitespace are removed. Whitespace in the middle is replaced by `_`.
http_kwargs (dict): Additional kwargs to pass to the httpx client.
Returns:
An async `Callable` that takes a query and returns the agent response.
"""
if not a2a_tool_available:
msg = "You need to `pip install 'any-agent[a2a]'` to use this tool"
raise ImportError(msg)
async with httpx.AsyncClient(follow_redirects=True) as resolver_client:
a2a_agent_card: AgentCard = await (
A2ACardResolver(httpx_client=resolver_client, base_url=url)
).get_agent_card()
async def _send_query(query: str) -> str:
async with httpx.AsyncClient(follow_redirects=True) as query_client:
client = A2AClient(httpx_client=query_client, agent_card=a2a_agent_card)
send_message_payload = SendMessageRequest(
id=str(uuid4),
params=MessageSendParams(
message=Message(
role=Role.user,
parts=[Part(root=TextPart(text=query))],
# the id is not currently tracked
messageId=uuid4().hex,
)
),
)
# TODO check how to capture exceptions and pass them on to the enclosing framework
response = await client.send_message(
send_message_payload, http_kwargs=http_kwargs
)
result: str = response.model_dump_json()
return result
new_name = toolname or a2a_agent_card.name
new_name = re.sub(r"\s+", "_", new_name.strip())
_send_query.__name__ = f"call_{new_name}"
_send_query.__doc__ = f"""{a2a_agent_card.description}
Send a query to the agent named {a2a_agent_card.name}.
Agent description: {a2a_agent_card.description}
Args:
query (str): The query to perform.
Returns:
The result from the A2A agent, encoded in json.
"""
return _send_query
|
Perform a query using A2A to another agent.
Args:
url (str): The url in which the A2A agent is located.
toolname (str): The name for the created tool. Defaults to `call_{agent name in card}`.
Leading and trailing whitespace are removed. Whitespace in the middle is replaced by `_`.
http_kwargs (dict): Additional kwargs to pass to the httpx client.
Returns:
An async `Callable` that takes a query and returns the agent response.
|
a2a_tool_async
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/a2a.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/a2a.py
|
Apache-2.0
|
def a2a_tool(
url: str, toolname: str | None = None, http_kwargs: dict[str, Any] | None = None
) -> Callable[[str], str]:
"""Perform a query using A2A to another agent (synchronous version).
Args:
url (str): The url in which the A2A agent is located.
toolname (str): The name for the created tool. Defaults to `call_{agent name in card}`.
Leading and trailing whitespace are removed. Whitespace in the middle is replaced by `_`.
http_kwargs (dict): Additional kwargs to pass to the httpx client.
Returns:
A sync `Callable` that takes a query and returns the agent response.
"""
if not a2a_tool_available:
msg = "You need to `pip install 'any-agent[a2a]'` to use this tool"
raise ImportError(msg)
# Fetch the async tool upfront to get proper name and documentation (otherwise the tool doesn't have the right name and documentation)
async_tool = run_async_in_sync(a2a_tool_async(url, toolname, http_kwargs))
def sync_wrapper(query: str) -> Any:
"""Execute the A2A tool query synchronously."""
return run_async_in_sync(async_tool(query))
# Copy essential metadata from the async tool
sync_wrapper.__name__ = async_tool.__name__
sync_wrapper.__doc__ = async_tool.__doc__
return sync_wrapper
|
Perform a query using A2A to another agent (synchronous version).
Args:
url (str): The url in which the A2A agent is located.
toolname (str): The name for the created tool. Defaults to `call_{agent name in card}`.
Leading and trailing whitespace are removed. Whitespace in the middle is replaced by `_`.
http_kwargs (dict): Additional kwargs to pass to the httpx client.
Returns:
A sync `Callable` that takes a query and returns the agent response.
|
a2a_tool
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/a2a.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/a2a.py
|
Apache-2.0
|
def __init__(self, output_type: type[BaseModel]):
"""Create the function that will be used as a tool."""
self.output_type = output_type
# Set docstring for the callable object
self.__doc__ = f"""You must call this tool in order to return the final answer.
Args:
answer: The final output that can be loaded as a Pydantic model. This must be a JSON compatible string that matches the following schema:
{output_type.model_json_schema()}
Returns:
A dictionary with the following keys:
- success: True if the output is valid, False otherwise.
- result: The final output if success is True, otherwise an error message.
"""
# Set function name for tool frameworks that expect it
self.__name__ = "final_output"
|
Create the function that will be used as a tool.
|
__init__
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/final_output.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/final_output.py
|
Apache-2.0
|
def search_web(query: str) -> str:
"""Perform a duckduckgo web search based on your query (think a Google search) then returns the top search results.
Args:
query (str): The search query to perform.
Returns:
The top search results.
"""
ddgs = DDGS()
results = ddgs.text(query, max_results=10)
return "\n".join(
f"[{result['title']}]({result['href']})\n{result['body']}" for result in results
)
|
Perform a duckduckgo web search based on your query (think a Google search) then returns the top search results.
Args:
query (str): The search query to perform.
Returns:
The top search results.
|
search_web
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/web_browsing.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/web_browsing.py
|
Apache-2.0
|
def visit_webpage(url: str) -> str:
"""Visits a webpage at the given url and reads its content as a markdown string. Use this to browse webpages.
Args:
url: The url of the webpage to visit.
"""
try:
response = requests.get(url)
response.raise_for_status()
markdown_content = markdownify(response.text).strip() # type: ignore[no-untyped-call]
markdown_content = re.sub(r"\n{2,}", "\n", markdown_content)
return _truncate_content(markdown_content, 10000)
except RequestException as e:
return f"Error fetching the webpage: {e!s}"
except Exception as e:
return f"An unexpected error occurred: {e!s}"
|
Visits a webpage at the given url and reads its content as a markdown string. Use this to browse webpages.
Args:
url: The url of the webpage to visit.
|
visit_webpage
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/web_browsing.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/web_browsing.py
|
Apache-2.0
|
def search_tavily(query: str, include_images: bool = False) -> str:
"""Perform a Tavily web search based on your query and return the top search results.
See https://blog.tavily.com/getting-started-with-the-tavily-search-api for more information.
Args:
query (str): The search query to perform.
include_images (bool): Whether to include images in the results.
Returns:
The top search results as a formatted string.
"""
if not tavily_available:
msg = "You need to `pip install 'tavily-python'` to use this tool"
raise ImportError(msg)
api_key = os.getenv("TAVILY_API_KEY")
if not api_key:
return "TAVILY_API_KEY environment variable not set."
try:
client = TavilyClient(api_key)
response = client.search(query, include_images=include_images)
results = response.get("results", [])
output = []
for result in results:
output.append(
f"[{result.get('title', 'No Title')}]({result.get('url', '#')})\n{result.get('content', '')}"
)
if include_images and "images" in response:
output.append("\nImages:")
for image in response["images"]:
output.append(image)
return "\n\n".join(output) if output else "No results found."
except Exception as e:
return f"Error performing Tavily search: {e!s}"
|
Perform a Tavily web search based on your query and return the top search results.
See https://blog.tavily.com/getting-started-with-the-tavily-search-api for more information.
Args:
query (str): The search query to perform.
include_images (bool): Whether to include images in the results.
Returns:
The top search results as a formatted string.
|
search_tavily
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/web_browsing.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/web_browsing.py
|
Apache-2.0
|
def verify_callable(tool: Callable[..., Any]) -> None:
"""Verify that `tool` is a valid callable.
- It needs to have some sort of docstring that describes what it does
- It needs to have typed argument
- It needs to have a typed return.
We need these things because this info gets provided to the agent so that they know how and when to call the tool.
"""
signature = inspect.signature(tool)
if not tool.__doc__:
msg = f"Tool {tool} needs to have a docstring but does not"
raise ValueError(msg)
# Check if the function has a return type
if signature.return_annotation is inspect.Signature.empty:
msg = f"Tool {tool} needs to have a return type but does not"
raise ValueError(msg)
# Check if all parameters have type annotations
for param in signature.parameters.values():
if param.annotation is inspect.Signature.empty:
msg = f"Tool {tool} needs to have typed arguments but does not"
raise ValueError(msg)
|
Verify that `tool` is a valid callable.
- It needs to have some sort of docstring that describes what it does
- It needs to have typed argument
- It needs to have a typed return.
We need these things because this info gets provided to the agent so that they know how and when to call the tool.
|
verify_callable
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/wrappers.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/wrappers.py
|
Apache-2.0
|
async def list_tools(self) -> list[T]:
"""List tools from the MCP server."""
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/mcp_connection.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/mcp_connection.py
|
Apache-2.0
|
def _filter_tools(self, tools: Sequence[T]) -> Sequence[T]:
"""Filter the tools to only include the ones listed in mcp_tool['tools']."""
requested_tools = list(self.mcp_tool.tools or [])
if not requested_tools:
return tools
name_to_tool = {
tool.name if isinstance(tool, HasName) else tool: tool for tool in tools
}
missing_tools = [name for name in requested_tools if name not in name_to_tool]
if missing_tools:
error_message = dedent(
f"""Could not find all requested tools in the MCP server:
Requested ({len(requested_tools)}): {requested_tools}
Set ({len(name_to_tool)}): {list(name_to_tool.keys())}
Missing: {missing_tools}
"""
)
raise ValueError(error_message)
return [name_to_tool[name] for name in requested_tools]
|
Filter the tools to only include the ones listed in mcp_tool['tools'].
|
_filter_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/mcp_connection.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/mcp_connection.py
|
Apache-2.0
|
async def list_tools(self) -> list["AgnoMCPTools"]:
"""List tools from the MCP server."""
if self._server is None:
msg = "MCP server is not set up. Please call `list_tools` from a concrete class."
raise ValueError(msg)
tools = await self._exit_stack.enter_async_context(self._server)
return [tools]
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/agno.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/agno.py
|
Apache-2.0
|
async def list_tools(self) -> list["AgnoMCPTools"]:
"""List tools from the MCP server."""
from mcp import StdioServerParameters
server_params = StdioServerParameters(
command=self.mcp_tool.command,
args=list(self.mcp_tool.args),
env=self.mcp_tool.env,
)
kwargs = {}
if self.mcp_tool.client_session_timeout_seconds:
kwargs["timeout_seconds"] = int(
self.mcp_tool.client_session_timeout_seconds
)
self._server = AgnoMCPTools(
server_params=server_params,
env=self.mcp_tool.env,
include_tools=list(self.mcp_tool.tools) if self.mcp_tool.tools else None,
**kwargs, # type: ignore[arg-type]
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/agno.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/agno.py
|
Apache-2.0
|
async def list_tools(self) -> list["AgnoMCPTools"]:
"""List tools from the MCP server."""
client = sse_client(
url=self.mcp_tool.url,
headers=dict(self.mcp_tool.headers or {}),
)
sse_transport = await self._exit_stack.enter_async_context(client)
stdio, write = sse_transport
kwargs = {}
if self.mcp_tool.client_session_timeout_seconds:
kwargs["read_timeout_seconds"] = timedelta(
seconds=self.mcp_tool.client_session_timeout_seconds
)
client_session = ClientSession(stdio, write, **kwargs) # type: ignore[arg-type]
session = await self._exit_stack.enter_async_context(client_session)
await session.initialize()
self._server = AgnoMCPTools(
session=session,
include_tools=list(self.mcp_tool.tools) if self.mcp_tool.tools else None,
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/agno.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/agno.py
|
Apache-2.0
|
def _check_dependencies(self) -> None:
"""Check if the required dependencies for the MCP server are available."""
self.libraries = "any-agent[mcp,agno]"
self.mcp_available = mcp_available
super()._check_dependencies()
|
Check if the required dependencies for the MCP server are available.
|
_check_dependencies
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/agno.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/agno.py
|
Apache-2.0
|
async def list_tools(self) -> list["GoogleMCPTool"]:
"""List tools from the MCP server."""
if not self._params:
msg = "MCP params is not set up. Please call `list_tools` from a concrete class."
raise ValueError(msg)
server = GoogleMCPToolset(connection_params=self._params)
tools = await server.get_tools()
return self._filter_tools(tools) # type: ignore[return-value]
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/google.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/google.py
|
Apache-2.0
|
async def list_tools(self) -> list["GoogleMCPTool"]:
"""List tools from the MCP server."""
self._params = GoogleStdioServerParameters(
command=self.mcp_tool.command,
args=list(self.mcp_tool.args),
env=self.mcp_tool.env,
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/google.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/google.py
|
Apache-2.0
|
async def list_tools(self) -> list["GoogleMCPTool"]:
"""List tools from the MCP server."""
self._params = GoogleSseServerParameters(
url=self.mcp_tool.url,
headers=dict(self.mcp_tool.headers or {}),
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/google.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/google.py
|
Apache-2.0
|
def _check_dependencies(self) -> None:
"""Check if the required dependencies for the MCP server are available."""
self.libraries = "any-agent[mcp,google]"
self.mcp_available = mcp_available
super()._check_dependencies()
|
Check if the required dependencies for the MCP server are available.
|
_check_dependencies
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/google.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/google.py
|
Apache-2.0
|
async def list_tools(self) -> list["BaseTool"]:
"""List tools from the MCP server."""
if not self._client:
msg = "MCP client is not set up. Please call `list_tools` from a concrete class."
raise ValueError(msg)
stdio, write = await self._exit_stack.enter_async_context(self._client)
kwargs = {}
if self.mcp_tool.client_session_timeout_seconds:
kwargs["read_timeout_seconds"] = timedelta(
seconds=self.mcp_tool.client_session_timeout_seconds
)
client_session = ClientSession(
stdio,
write,
**kwargs, # type: ignore[arg-type]
)
session = await self._exit_stack.enter_async_context(client_session)
await session.initialize()
tools = await load_mcp_tools(session)
return self._filter_tools(tools) # type: ignore[return-value]
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/langchain.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/langchain.py
|
Apache-2.0
|
async def list_tools(self) -> list["BaseTool"]:
"""List tools from the MCP server."""
server_params = StdioServerParameters(
command=self.mcp_tool.command,
args=list(self.mcp_tool.args),
env=self.mcp_tool.env,
)
self._client = stdio_client(server_params)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/langchain.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/langchain.py
|
Apache-2.0
|
async def list_tools(self) -> list["BaseTool"]:
"""List tools from the MCP server."""
kwargs = {}
if self.mcp_tool.client_session_timeout_seconds:
kwargs["sse_read_timeout"] = self.mcp_tool.client_session_timeout_seconds
self._client = sse_client(
url=self.mcp_tool.url,
headers=dict(self.mcp_tool.headers or {}),
**kwargs, # type: ignore[arg-type]
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/langchain.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/langchain.py
|
Apache-2.0
|
async def list_tools(self) -> list["LlamaIndexFunctionTool"]:
"""List tools from the MCP server."""
if not self._client:
msg = "MCP client is not set up. Please call `list_tool` from a concrete class."
raise ValueError(msg)
allowed_tools = self.mcp_tool.tools
if allowed_tools is not None:
allowed_tools = list(allowed_tools)
mcp_tool_spec = LlamaIndexMcpToolSpec(
client=self._client,
allowed_tools=allowed_tools,
)
return await mcp_tool_spec.to_tool_list_async()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/llama_index.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/llama_index.py
|
Apache-2.0
|
async def list_tools(self) -> list["LlamaIndexFunctionTool"]:
"""List tools from the MCP server."""
kwargs = {}
if self.mcp_tool.client_session_timeout_seconds:
kwargs["timeout"] = self.mcp_tool.client_session_timeout_seconds
self._client = LlamaIndexMCPClient(
command_or_url=self.mcp_tool.command,
args=list(self.mcp_tool.args),
env=self.mcp_tool.env,
**kwargs, # type: ignore[arg-type]
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/llama_index.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/llama_index.py
|
Apache-2.0
|
async def list_tools(self) -> list["LlamaIndexFunctionTool"]:
"""List tools from the MCP server."""
kwargs = {}
if self.mcp_tool.client_session_timeout_seconds:
kwargs["timeout"] = self.mcp_tool.client_session_timeout_seconds
self._client = LlamaIndexMCPClient(
command_or_url=self.mcp_tool.url,
**kwargs, # type: ignore[arg-type]
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/llama_index.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/llama_index.py
|
Apache-2.0
|
def _check_dependencies(self) -> None:
"""Check if the required dependencies for the MCP server are available."""
self.libraries = "any-agent[mcp,llama_index]"
self.mcp_available = mcp_available
super()._check_dependencies()
|
Check if the required dependencies for the MCP server are available.
|
_check_dependencies
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/llama_index.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/llama_index.py
|
Apache-2.0
|
async def list_tools(self) -> list["MCPTool"]:
"""List tools from the MCP server."""
if not self._server:
msg = "MCP server is not set up. Please call `setup` from a concrete class."
raise ValueError(msg)
await self._exit_stack.enter_async_context(self._server)
tools = await self._server.list_tools()
return self._filter_tools(tools) # type: ignore[return-value]
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/openai.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/openai.py
|
Apache-2.0
|
async def list_tools(self) -> list["MCPTool"]:
"""List tools from the MCP server."""
params = OpenAIInternalMCPServerStdioParams(
command=self.mcp_tool.command,
args=list(self.mcp_tool.args),
env=self.mcp_tool.env, # type: ignore[typeddict-item]
)
self._server = OpenAIInternalMCPServerStdio(
name="OpenAI MCP Server",
params=params,
client_session_timeout_seconds=self.mcp_tool.client_session_timeout_seconds,
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/openai.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/openai.py
|
Apache-2.0
|
async def list_tools(self) -> list["MCPTool"]:
"""List tools from the MCP server."""
params = OpenAIInternalMCPServerSseParams(url=self.mcp_tool.url)
self._server = OpenAIInternalMCPServerSse(
name="OpenAI MCP Server",
params=params,
client_session_timeout_seconds=self.mcp_tool.client_session_timeout_seconds,
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/openai.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/openai.py
|
Apache-2.0
|
def _check_dependencies(self) -> None:
"""Check if the required dependencies for the MCP server are available."""
self.libraries = "any-agent[mcp,openai]"
self.mcp_available = mcp_available
super()._check_dependencies()
|
Check if the required dependencies for the MCP server are available.
|
_check_dependencies
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/openai.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/openai.py
|
Apache-2.0
|
async def list_tools(self) -> list["SmolagentsTool"]:
"""List tools from the MCP server."""
if not self._client:
msg = "Tool collection is not set up. Please call `list_tools` from a concrete class."
raise ValueError(msg)
tools = self._client.get_tools()
return self._filter_tools(tools) # type: ignore[return-value]
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/smolagents.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/smolagents.py
|
Apache-2.0
|
async def list_tools(self) -> list["SmolagentsTool"]:
"""List tools from the MCP server."""
server_parameters = StdioServerParameters(
command=self.mcp_tool.command,
args=list(self.mcp_tool.args),
env=self.mcp_tool.env,
)
self._client = MCPClient(server_parameters)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/smolagents.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/smolagents.py
|
Apache-2.0
|
async def list_tools(self) -> list["SmolagentsTool"]:
"""List tools from the MCP server."""
server_parameters = {
"url": self.mcp_tool.url,
}
self._client = MCPClient(server_parameters)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/smolagents.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/smolagents.py
|
Apache-2.0
|
def _check_dependencies(self) -> None:
"""Check if the required dependencies for the MCP server are available."""
self.libraries = "any-agent[mcp,smolagents]"
self.mcp_available = mcp_available
super()._check_dependencies()
|
Check if the required dependencies for the MCP server are available.
|
_check_dependencies
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/smolagents.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/smolagents.py
|
Apache-2.0
|
async def list_tools(self) -> list["MCPTool"]:
"""List tools from the MCP server."""
if not self._client:
msg = "MCP client is not set up. Please call `setup` from a concrete class."
raise ValueError(msg)
# Setup the client connection using exit stack to manage lifecycle
stdio, write = await self._exit_stack.enter_async_context(self._client)
# Create a client session
client_session = ClientSession(
stdio,
write,
timedelta(seconds=self.mcp_tool.client_session_timeout_seconds)
if self.mcp_tool.client_session_timeout_seconds
else None,
)
# Start the session
session: ClientSession = await self._exit_stack.enter_async_context(
client_session
)
if not session:
msg = "Failed to create MCP session"
raise ValueError(msg)
await session.initialize()
# Get the available tools from the MCP server using schema
available_tools = await session.list_tools()
# Filter tools if specific tools were requested
filtered_tools = self._filter_tools(available_tools.tools)
# Create callable tool functions
tool_list = list[Any]()
for tool_info in filtered_tools:
tool_list.append(self._create_tool_from_info(tool_info, session)) # type: ignore[arg-type]
return tool_list
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/tinyagent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/tinyagent.py
|
Apache-2.0
|
def _create_tool_from_info(
self, tool: Tool, session: "ClientSession"
) -> Callable[..., Any]:
"""Create a tool function from tool information."""
tool_name = tool.name if hasattr(tool, "name") else tool
tool_description = tool.description if hasattr(tool, "description") else ""
input_schema = tool.inputSchema if hasattr(tool, "inputSchema") else None
if not session:
msg = "Not connected to MCP server"
raise ValueError(msg)
async def tool_function(*args, **kwargs) -> Any: # type: ignore[no-untyped-def]
"""Tool function that calls the MCP server."""
# Combine args and kwargs
combined_args = {}
if args and len(args) > 0:
combined_args = args[0]
combined_args.update(kwargs)
if not session:
msg = "Not connected to MCP server"
raise ValueError(msg)
# Call the tool on the MCP server
try:
return await session.call_tool(tool_name, combined_args) # type: ignore[arg-type]
except Exception as e:
return f"Error calling tool {tool_name}: {e!s}"
# Set attributes for the tool function
tool_function.__name__ = tool_name # type: ignore[assignment]
tool_function.__doc__ = tool_description
# this isn't a defined attribute of a callable, but we pass it to tinyagent so that it can use it appropriately
# when constructing the ToolExecutor.
tool_function.__input_schema__ = input_schema # type: ignore[attr-defined]
return tool_function
|
Create a tool function from tool information.
|
_create_tool_from_info
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/tinyagent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/tinyagent.py
|
Apache-2.0
|
async def tool_function(*args, **kwargs) -> Any: # type: ignore[no-untyped-def]
"""Tool function that calls the MCP server."""
# Combine args and kwargs
combined_args = {}
if args and len(args) > 0:
combined_args = args[0]
combined_args.update(kwargs)
if not session:
msg = "Not connected to MCP server"
raise ValueError(msg)
# Call the tool on the MCP server
try:
return await session.call_tool(tool_name, combined_args) # type: ignore[arg-type]
except Exception as e:
return f"Error calling tool {tool_name}: {e!s}"
|
Tool function that calls the MCP server.
|
tool_function
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/tinyagent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/tinyagent.py
|
Apache-2.0
|
async def list_tools(self) -> list["MCPTool"]:
"""List tools from the MCP server."""
server_params = StdioServerParameters(
command=self.mcp_tool.command,
args=list(self.mcp_tool.args),
env={**os.environ},
)
self._client = stdio_client(server_params)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/tinyagent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/tinyagent.py
|
Apache-2.0
|
async def list_tools(self) -> list["MCPTool"]:
"""List tools from the MCP server."""
kwargs = {}
if self.mcp_tool.client_session_timeout_seconds:
kwargs["sse_read_timeout"] = self.mcp_tool.client_session_timeout_seconds
self._client = sse_client(
url=self.mcp_tool.url,
headers=dict(self.mcp_tool.headers or {}),
**kwargs, # type: ignore[arg-type]
)
return await super().list_tools()
|
List tools from the MCP server.
|
list_tools
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tools/mcp/frameworks/tinyagent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tools/mcp/frameworks/tinyagent.py
|
Apache-2.0
|
def from_otel(cls, otel_span: Span) -> AgentSpan:
"""Create an AgentSpan from an OTEL Span."""
return cls(
name=otel_span.name,
kind=SpanKind.from_otel(otel_span.kind),
parent=SpanContext.from_otel(otel_span.parent),
start_time=otel_span.start_time,
end_time=otel_span.end_time,
status=Status.from_otel(otel_span.status),
context=SpanContext.from_otel(otel_span.context),
attributes=dict(otel_span.attributes) if otel_span.attributes else {},
links=[Link.from_otel(link) for link in otel_span.links],
events=[Event.from_otel(event) for event in otel_span.events],
resource=Resource.from_otel(otel_span.resource),
)
|
Create an AgentSpan from an OTEL Span.
|
from_otel
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/agent_trace.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/agent_trace.py
|
Apache-2.0
|
def to_readable_span(self) -> ReadableSpan:
"""Create an ReadableSpan from the AgentSpan."""
return ReadableSpan(
name=self.name,
kind=self.kind,
parent=self.parent,
start_time=self.start_time,
end_time=self.end_time,
status=self.status,
context=self.context,
attributes=self.attributes,
links=self.links,
events=self.events,
resource=self.resource,
)
|
Create an ReadableSpan from the AgentSpan.
|
to_readable_span
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/agent_trace.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/agent_trace.py
|
Apache-2.0
|
def serialize_final_output(self, value: str | BaseModel | None) -> Any:
"""Serialize the final_output and handle any BaseModel subclass."""
if value is None:
return None
if isinstance(value, str):
return value
if isinstance(value, BaseModel):
# This will properly serialize any BaseModel subclass
return value.model_dump()
return value
|
Serialize the final_output and handle any BaseModel subclass.
|
serialize_final_output
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/agent_trace.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/agent_trace.py
|
Apache-2.0
|
def _invalidate_usage_and_cost_cache(self) -> None:
"""Clear the cached usage_and_cost property if it exists."""
if "usage" in self.__dict__:
del self.tokens
if "cost" in self.__dict__:
del self.cost
|
Clear the cached usage_and_cost property if it exists.
|
_invalidate_usage_and_cost_cache
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/agent_trace.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/agent_trace.py
|
Apache-2.0
|
def add_span(self, span: AgentSpan | Span) -> None:
"""Add an AgentSpan to the trace and clear the usage_and_cost cache if present."""
if not isinstance(span, AgentSpan):
span = AgentSpan.from_otel(span)
self.spans.append(span)
self._invalidate_usage_and_cost_cache()
|
Add an AgentSpan to the trace and clear the usage_and_cost cache if present.
|
add_span
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/agent_trace.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/agent_trace.py
|
Apache-2.0
|
def duration(self) -> timedelta:
"""Duration of the parent `invoke_agent` span as a datetime.timedelta object.
The duration is computed from the span's start and end time (in nanoseconds).
Raises ValueError if:
- There are no spans.
- The invoke_agent span is not the last span.
- Any of the start/end times are missing.
"""
if not self.spans:
msg = "No spans found in trace"
raise ValueError(msg)
span = self.spans[-1]
if not span.is_agent_invocation():
msg = "Last span is not `invoke_agent`"
raise ValueError(msg)
if span.start_time is not None and span.end_time is not None:
duration_ns = span.end_time - span.start_time
return timedelta(seconds=duration_ns / 1_000_000_000)
msg = "Start or end time is missing for the `invoke_agent` span"
raise ValueError(msg)
|
Duration of the parent `invoke_agent` span as a datetime.timedelta object.
The duration is computed from the span's start and end time (in nanoseconds).
Raises ValueError if:
- There are no spans.
- The invoke_agent span is not the last span.
- Any of the start/end times are missing.
|
duration
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/agent_trace.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/agent_trace.py
|
Apache-2.0
|
def tokens(self) -> TokenInfo:
"""The current total token count for this trace. Cached after first computation."""
sum_input_tokens = 0
sum_output_tokens = 0
for span in self.spans:
if span.is_llm_call():
sum_input_tokens += span.attributes.get("gen_ai.usage.input_tokens", 0)
sum_output_tokens += span.attributes.get(
"gen_ai.usage.output_tokens", 0
)
return TokenInfo(input_tokens=sum_input_tokens, output_tokens=sum_output_tokens)
|
The current total token count for this trace. Cached after first computation.
|
tokens
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/agent_trace.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/agent_trace.py
|
Apache-2.0
|
def cost(self) -> CostInfo:
"""The current total cost for this trace. Cached after first computation."""
sum_input_cost = 0.0
sum_output_cost = 0.0
for span in self.spans:
if span.is_llm_call():
cost_info = compute_cost_info(span.attributes)
if cost_info:
sum_input_cost += cost_info.input_cost
sum_output_cost += cost_info.output_cost
return CostInfo(input_cost=sum_input_cost, output_cost=sum_output_cost)
|
The current total cost for this trace. Cached after first computation.
|
cost
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/agent_trace.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/agent_trace.py
|
Apache-2.0
|
def enable_console_traces() -> None:
"""Enable printing traces to the console."""
has_console_exporter = any(
isinstance(getattr(p, "span_exporter", None), _ConsoleExporter)
for p in TRACE_PROVIDER._active_span_processor._span_processors
)
if not has_console_exporter:
TRACE_PROVIDER.add_span_processor(SimpleSpanProcessor(_ConsoleExporter()))
|
Enable printing traces to the console.
|
enable_console_traces
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/__init__.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/__init__.py
|
Apache-2.0
|
def disable_console_traces() -> None:
"""Disable printing traces to the console."""
with TRACE_PROVIDER._active_span_processor._lock:
TRACE_PROVIDER._active_span_processor._span_processors = tuple(
p
for p in TRACE_PROVIDER._active_span_processor._span_processors
if not isinstance(getattr(p, "span_exporter", None), _ConsoleExporter)
)
|
Disable printing traces to the console.
|
disable_console_traces
|
python
|
mozilla-ai/any-agent
|
src/any_agent/tracing/__init__.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/tracing/__init__.py
|
Apache-2.0
|
def run_async_in_sync(coro: Coroutine[Any, Any, T]) -> T:
"""Run an async coroutine in a synchronous context.
Handles different event loop scenarios:
- If a loop is running, uses threading to avoid conflicts
- If no loop exists, creates one or uses the current loop
Args:
coro: The coroutine to execute
Returns:
The result of the coroutine execution
"""
try:
# Check if there's a running event loop
asyncio.get_running_loop()
# If we get here, there's a loop running, so we can't use run_until_complete()
# or asyncio.run() - must use threading approach
def run_in_thread() -> T:
return asyncio.run(coro)
with concurrent.futures.ThreadPoolExecutor() as executor:
return executor.submit(run_in_thread).result()
except RuntimeError:
# No running event loop - try to get available loop
try:
loop = asyncio.get_event_loop()
return loop.run_until_complete(coro)
except RuntimeError:
# No event loop at all - create one
return asyncio.run(coro)
|
Run an async coroutine in a synchronous context.
Handles different event loop scenarios:
- If a loop is running, uses threading to avoid conflicts
- If no loop exists, creates one or uses the current loop
Args:
coro: The coroutine to execute
Returns:
The result of the coroutine execution
|
run_async_in_sync
|
python
|
mozilla-ai/any-agent
|
src/any_agent/utils/asyncio_sync.py
|
https://github.com/mozilla-ai/any-agent/blob/master/src/any_agent/utils/asyncio_sync.py
|
Apache-2.0
|
async def echo_sse_server() -> AsyncGenerator[dict[str, str]]:
"""This fixture runs a FastMCP server in a subprocess.
I thought about trying to mock all the individual mcp client calls,
but I went with this because this way we don't need to actually mock anything.
This is similar to what MCPAdapt does in their testing https://github.com/grll/mcpadapt/blob/main/tests/test_core.py
"""
import asyncio
process = await asyncio.create_subprocess_exec(
"python",
"-c",
SSE_MCP_SERVER_SCRIPT,
)
# Smart ping instead of hardcoded sleep
await wait_for_server_async("http://127.0.0.1:8000")
try:
yield {"url": "http://127.0.0.1:8000/sse"}
finally:
# Clean up the process when test is done
process.kill()
await process.wait()
|
This fixture runs a FastMCP server in a subprocess.
I thought about trying to mock all the individual mcp client calls,
but I went with this because this way we don't need to actually mock anything.
This is similar to what MCPAdapt does in their testing https://github.com/grll/mcpadapt/blob/main/tests/test_core.py
|
echo_sse_server
|
python
|
mozilla-ai/any-agent
|
tests/conftest.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/conftest.py
|
Apache-2.0
|
def configure_logging(pytestconfig: pytest.Config) -> None:
"""Configure the logging level based on the verbosity of the test run.
This is a session fixture, so it only gets called once per test session.
"""
verbosity = pytestconfig.getoption("verbose")
level = logging.DEBUG if verbosity > 0 else logging.INFO
setup_logger(level=level)
|
Configure the logging level based on the verbosity of the test run.
This is a session fixture, so it only gets called once per test session.
|
configure_logging
|
python
|
mozilla-ai/any-agent
|
tests/conftest.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/conftest.py
|
Apache-2.0
|
def mock_litellm_response() -> ModelResponse:
"""Fixture to create a standard mock LiteLLM response"""
return ModelResponse.model_validate_json(
'{"id":"chatcmpl-BWnfbHWPsQp05roQ06LAD1mZ9tOjT","created":1747157127,"model":"gpt-4o-2024-08-06","object":"chat.completion","system_fingerprint":"fp_f5bdcc3276","choices":[{"finish_reason":"stop","index":0,"message":{"content":"The state capital of Pennsylvania is Harrisburg.","role":"assistant","tool_calls":null,"function_call":null,"annotations":[]}}],"usage":{"completion_tokens":11,"prompt_tokens":138,"total_tokens":149,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0}},"service_tier":"default"}'
)
|
Fixture to create a standard mock LiteLLM response
|
mock_litellm_response
|
python
|
mozilla-ai/any-agent
|
tests/conftest.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/conftest.py
|
Apache-2.0
|
def mock_litellm_streaming() -> Callable[[Any, Any], AsyncGenerator[Any]]:
"""
Create a fixture that returns an async generator function to mock streaming responses.
This returns a function that can be used as a side_effect.
"""
async def _mock_streaming_response(
*args: Any, **kwargs: Any
) -> AsyncGenerator[Any]:
# First chunk with role
yield {
"choices": [
{
"delta": {"role": "assistant", "content": "The state "},
"index": 0,
"finish_reason": None,
}
]
}
# Middle chunks with content
yield {
"choices": [
{"delta": {"content": "capital of "}, "index": 0, "finish_reason": None}
]
}
yield {
"choices": [
{
"delta": {"content": "Pennsylvania is "},
"index": 0,
"finish_reason": None,
}
]
}
# Final chunk with finish reason
yield {
"choices": [
{
"delta": {"content": "Harrisburg."},
"index": 0,
"finish_reason": "stop",
}
]
}
return _mock_streaming_response
|
Create a fixture that returns an async generator function to mock streaming responses.
This returns a function that can be used as a side_effect.
|
mock_litellm_streaming
|
python
|
mozilla-ai/any-agent
|
tests/conftest.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/conftest.py
|
Apache-2.0
|
def mock_visit_webpage(url: str) -> str:
"""Visits a webpage at the given url and reads its content as a markdown string. Use this to browse webpages.
Args:
url: The url of the webpage to visit.
"""
return (
"# Any Agent Framework Review\n"
"Any Agent is the top choice for developers needing flexibility and power in multi-agent systems."
)
|
Visits a webpage at the given url and reads its content as a markdown string. Use this to browse webpages.
Args:
url: The url of the webpage to visit.
|
mock_visit_webpage
|
python
|
mozilla-ai/any-agent
|
tests/integration/conftest.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/conftest.py
|
Apache-2.0
|
def pytest_addoption(parser: pytest.Parser) -> None:
"""
Add custom command-line options to pytest.
This hook adds the `--update-trace-assets` flag to pytest, which can be used when running integration tests.
When this flag is set, tests that generate trace asset files (aka the integration test that
produces agent traces) will update the asset files in the assets directory.
This is useful when the expected trace output changes and you
want to regenerate the reference files.
"""
parser.addoption(
"--update-trace-assets",
action="store_true",
default=False,
help="Update trace asset files instead of asserting equality.",
)
|
Add custom command-line options to pytest.
This hook adds the `--update-trace-assets` flag to pytest, which can be used when running integration tests.
When this flag is set, tests that generate trace asset files (aka the integration test that
produces agent traces) will update the asset files in the assets directory.
This is useful when the expected trace output changes and you
want to regenerate the reference files.
|
pytest_addoption
|
python
|
mozilla-ai/any-agent
|
tests/integration/conftest.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/conftest.py
|
Apache-2.0
|
def _is_port_available(port: int, host: str = "localhost") -> bool:
"""Check if a port is available for binding.
This isn't a perfect check but it at least tells us if there is absolutely no chance of binding to the port.
"""
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
try:
sock.bind((host, port))
except OSError:
return False
return True
|
Check if a port is available for binding.
This isn't a perfect check but it at least tells us if there is absolutely no chance of binding to the port.
|
_is_port_available
|
python
|
mozilla-ai/any-agent
|
tests/integration/conftest.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/conftest.py
|
Apache-2.0
|
def _get_deterministic_port(test_name: str, framework_name: str) -> int:
"""Generate a deterministic port number based on test name and framework.
This ensures each test gets a unique port that remains consistent across runs.
"""
# Create a unique string by combining test name and framework
unique_string = f"{test_name}_{framework_name}"
# Generate a hash and convert to a port number in the range 6000-9999
hash_value = int(hashlib.md5(unique_string.encode()).hexdigest()[:4], 16) # noqa: S324
return 6000 + (hash_value % 4000)
|
Generate a deterministic port number based on test name and framework.
This ensures each test gets a unique port that remains consistent across runs.
|
_get_deterministic_port
|
python
|
mozilla-ai/any-agent
|
tests/integration/conftest.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/conftest.py
|
Apache-2.0
|
def test_port(request, agent_framework):
"""Single fixture that provides a unique, deterministic port for each test."""
test_name = request.node.name
framework_name = agent_framework.value
port = _get_deterministic_port(test_name, framework_name)
# Ensure the port is available, if not, try nearby ports
original_port = port
attempts = 0
while not _is_port_available(port) and attempts < 50:
port = original_port + attempts + 1
attempts += 1
if not _is_port_available(port):
msg = f"Could not find an available port starting from {original_port}"
raise RuntimeError(msg)
return port
|
Single fixture that provides a unique, deterministic port for each test.
|
test_port
|
python
|
mozilla-ai/any-agent
|
tests/integration/conftest.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/conftest.py
|
Apache-2.0
|
def assert_first_llm_call(llm_call: AgentSpan) -> None:
"""Checks the `_set_llm_inputs` implemented by each framework's instrumentation."""
assert llm_call.attributes.get("gen_ai.input.messages", None) is not None
# input.messages should be a valid JSON string (list of dicts)
input_messages = json.loads(llm_call.attributes.get("gen_ai.input.messages"))
assert input_messages[0]["role"] == "system"
assert input_messages[1]["role"] == "user"
|
Checks the `_set_llm_inputs` implemented by each framework's instrumentation.
|
assert_first_llm_call
|
python
|
mozilla-ai/any-agent
|
tests/integration/test_load_and_run_agent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/test_load_and_run_agent.py
|
Apache-2.0
|
def assert_first_tool_execution(tool_execution: AgentSpan) -> None:
"""Checks the tools setup implemented by each framework's instrumentation."""
assert tool_execution.attributes.get("gen_ai.tool.args", None) is not None
# tool.args should be a JSON string (dict)
args = json.loads(tool_execution.attributes.get("gen_ai.tool.args"))
assert "timezone" in args
assert isinstance(agent_trace, AgentTrace)
assert agent_trace.final_output
|
Checks the tools setup implemented by each framework's instrumentation.
|
assert_first_tool_execution
|
python
|
mozilla-ai/any-agent
|
tests/integration/test_load_and_run_agent.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/test_load_and_run_agent.py
|
Apache-2.0
|
def mock_capital(query: str) -> str:
"""Perform a duckduckgo web search based on your query (think a Google search) then returns the top search results.
Args:
query (str): The search query to perform.
Returns:
The top search results.
"""
if "France" in query:
return "The capital of France is Paris."
if "Spain" in query:
return "The capital of Spain is Madrid."
return "No info"
|
Perform a duckduckgo web search based on your query (think a Google search) then returns the top search results.
Args:
query (str): The search query to perform.
Returns:
The top search results.
|
mock_capital
|
python
|
mozilla-ai/any-agent
|
tests/integration/test_load_and_run_agent_twice.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/test_load_and_run_agent_twice.py
|
Apache-2.0
|
async def test_run_agent_twice(agent_framework: AgentFramework) -> None:
"""When an agent is run twice, state from the first run shouldn't bleed into the second run"""
model_id = "gpt-4.1-nano"
env_check = validate_environment(model_id)
if not env_check["keys_in_environment"]:
pytest.skip(f"{env_check['missing_keys']} needed for {agent_framework}")
model_args: dict[str, Any] = (
{"parallel_tool_calls": False}
if agent_framework not in [AgentFramework.AGNO, AgentFramework.LLAMA_INDEX]
else {}
)
model_args["temperature"] = 0.0
agent = await AnyAgent.create_async(
agent_framework,
AgentConfig(
model_id=model_id,
instructions="You must use the tools to find an answer",
model_args=model_args,
tools=[mock_capital],
),
)
results = await asyncio.gather(
agent.run_async("What is the capital of France?"),
agent.run_async("What is the capital of Spain?"),
)
outputs = [r.final_output for r in results]
assert all(o is not None for o in outputs)
assert sum("Paris" in o for o in outputs) == 1
assert sum("Madrid" in o for o in outputs) == 1
first_spans = results[0].spans
second_spans = results[1].spans
assert second_spans[: len(first_spans)] != first_spans, (
"Spans from the first run should not be in the second"
)
|
When an agent is run twice, state from the first run shouldn't bleed into the second run
|
test_run_agent_twice
|
python
|
mozilla-ai/any-agent
|
tests/integration/test_load_and_run_agent_twice.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/test_load_and_run_agent_twice.py
|
Apache-2.0
|
def _assert_contains_current_date_info(final_output: str) -> None:
"""Assert that the final output contains current date and time information."""
now = datetime.datetime.now()
assert all(
[
str(now.year) in final_output,
str(now.day) in final_output,
now.strftime("%B") in final_output,
]
)
|
Assert that the final output contains current date and time information.
|
_assert_contains_current_date_info
|
python
|
mozilla-ai/any-agent
|
tests/integration/test_load_and_run_multi_agent_a2a_tool.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/test_load_and_run_multi_agent_a2a_tool.py
|
Apache-2.0
|
def _assert_has_date_agent_tool_call(agent_trace: AgentTrace) -> None:
"""Assert that the agent trace contains a tool execution span for the date agent."""
assert any(
span.is_tool_execution()
and span.attributes.get("gen_ai.tool.name", None) == "call_date_agent"
for span in agent_trace.spans
)
|
Assert that the agent trace contains a tool execution span for the date agent.
|
_assert_has_date_agent_tool_call
|
python
|
mozilla-ai/any-agent
|
tests/integration/test_load_and_run_multi_agent_a2a_tool.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/test_load_and_run_multi_agent_a2a_tool.py
|
Apache-2.0
|
async def test_load_and_run_multi_agent_a2a(agent_framework: AgentFramework) -> None:
"""Tests that an agent contacts another using A2A using the adapter tool.
Note that there is an issue when using Google ADK: https://github.com/google/adk-python/pull/566
"""
if agent_framework in [
# async a2a is not supported
AgentFramework.SMOLAGENTS,
# spans are not built correctly
AgentFramework.LLAMA_INDEX,
# AgentFramework.GOOGLE,
]:
pytest.skip(
"https://github.com/mozilla-ai/any-agent/issues/357 tracks fixing so these tests can be re-enabled"
)
kwargs = {}
kwargs["model_id"] = "gpt-4.1-nano"
agent_model = kwargs["model_id"]
env_check = validate_environment(kwargs["model_id"])
if not env_check["keys_in_environment"]:
pytest.skip(f"{env_check['missing_keys']} needed for {agent_framework}")
model_args = (
{"parallel_tool_calls": False}
if agent_framework not in [AgentFramework.AGNO, AgentFramework.LLAMA_INDEX]
else None
)
main_agent = None
served_agent = None
served_task = None
served_server = None
try:
tool_agent_endpoint = "tool_agent"
# DATE AGENT
import datetime
def get_datetime() -> str:
"""Return the current date and time"""
return str(datetime.datetime.now())
date_agent_description = "Agent that can return the current date."
date_agent_cfg = AgentConfig(
instructions="Use the available tools to obtain additional information to answer the query.",
name="date_agent",
model_id=agent_model,
description=date_agent_description,
tools=[get_datetime],
model_args=model_args,
)
date_agent = await AnyAgent.create_async(
agent_framework=agent_framework,
agent_config=date_agent_cfg,
)
# SERVING PROPER
served_agent = date_agent
(served_task, served_server) = await served_agent.serve_async(
serving_config=A2AServingConfig(
port=0,
endpoint=f"/{tool_agent_endpoint}",
log_level="info",
)
)
test_port = served_server.servers[0].sockets[0].getsockname()[1]
server_url = f"http://localhost:{test_port}/{tool_agent_endpoint}"
await wait_for_server_async(server_url)
# Search agent is ready for card resolution
logger.info(
"Setting up agent",
extra={"endpoint": server_url},
)
main_agent_cfg = AgentConfig(
instructions="Use the available tools to obtain additional information to answer the query.",
description="The orchestrator that can use other agents via tools using the A2A protocol.",
tools=[await a2a_tool_async(server_url, http_kwargs={"timeout": 10.0})],
model_args=model_args,
**kwargs, # type: ignore[arg-type]
)
main_agent = await AnyAgent.create_async(
agent_framework=agent_framework,
agent_config=main_agent_cfg,
)
agent_trace = await main_agent.run_async(DATE_PROMPT)
_assert_valid_agent_trace(agent_trace)
_assert_contains_current_date_info(agent_trace.final_output)
_assert_has_date_agent_tool_call(agent_trace)
try:
span_tree = build_tree(agent_trace.spans).model_dump_json(indent=2)
logger.info("span tree:")
logger.info(span_tree)
except KeyError as e:
pytest.fail(f"The span tree was not built successfully: {e}")
final_output_log = f"Final output: {agent_trace.final_output}"
logger.info(final_output_log)
finally:
if served_server:
await served_server.shutdown()
if served_task:
served_task.cancel()
|
Tests that an agent contacts another using A2A using the adapter tool.
Note that there is an issue when using Google ADK: https://github.com/google/adk-python/pull/566
|
test_load_and_run_multi_agent_a2a
|
python
|
mozilla-ai/any-agent
|
tests/integration/test_load_and_run_multi_agent_a2a_tool.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/test_load_and_run_multi_agent_a2a_tool.py
|
Apache-2.0
|
def _run_server(
agent_framework_str: str,
port: int,
endpoint: str,
model_id: str,
server_queue: Queue,
):
"""Run the server for the sync test. This needs to be defined outside the test function so that it can be run in a separate process."""
date_agent_description = "Agent that can return the current date."
date_agent_cfg = AgentConfig(
instructions="Use the available tools to obtain additional information to answer the query.",
name="date_agent",
model_id=model_id,
description=date_agent_description,
tools=[get_datetime],
model_args={"parallel_tool_calls": False}
if agent_framework_str not in ["agno", "llama_index"]
else None,
)
date_agent = AnyAgent.create(
agent_framework=AgentFramework.from_string(agent_framework_str),
agent_config=date_agent_cfg,
)
from any_agent.serving import A2AServingConfig, _get_a2a_app, serve_a2a
serving_config = A2AServingConfig(
port=port,
endpoint=f"/{endpoint}",
log_level="info",
)
app = _get_a2a_app(date_agent, serving_config=serving_config)
serve_a2a(
app,
host=serving_config.host,
port=serving_config.port,
endpoint=serving_config.endpoint,
log_level=serving_config.log_level,
server_queue=server_queue,
)
|
Run the server for the sync test. This needs to be defined outside the test function so that it can be run in a separate process.
|
_run_server
|
python
|
mozilla-ai/any-agent
|
tests/integration/test_load_and_run_multi_agent_a2a_tool.py
|
https://github.com/mozilla-ai/any-agent/blob/master/tests/integration/test_load_and_run_multi_agent_a2a_tool.py
|
Apache-2.0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.