Tool params typed Sequence/Set/Tuple/BaseModel are advertised as "string" and never coerced, Task.depends_on does not order or validate execution, and import still installs the root log handler
メンテナーはふだん 1 日以内に返信
まだ誰も着手していません。
- #6295 @praisonai-triage-agent による — マージされずにクローズ
評価
調査の方向性
Start with tools/schema.py::annotation_to_json_schema and agent/tool_execution.py::_cast_arguments for the tool parameter cases; compare the schema converters in mcp/mcp_utils.py and runtime/context_builder.py. Then trace Task.depends_on through task/task.py and AgentTeam in agents/agents.py, and inspect _logging.py and __init__.py for import side effects. The acceptance criteria specify the expected schemas, execution order and logging behavior; an open linked pull request already covers work on this issue.
索引モデルが issue の本文から書いたものです。
説明
All findings are in src/praisonai-agents/praisonaiagents. Reproduced on main (v4.7.24) with no LLM, using small scripts. I checked open and closed issues first. #6279 covers malformed tool-call arguments and cached schemas. #6134 is the earlier import-side-effects fix, and finding 3 is the part of it that is still open.
1. Container and model-typed tool parameters get a "string" schema, and the runtime does not cast them
tools/schema.py::annotation_to_json_schema handles list, dict, Union, Literal and Enum. Everything else falls through to type_map.get(annotation, "string"). Measured on this checkout:
from typing import Sequence, Set, Tuple, Mapping, Iterable, FrozenSet, Optional, List, TypedDict
from dataclasses import dataclass
from pydantic import BaseModel
from praisonaiagents.tools.schema import annotation_to_json_schema as s
class Addr(BaseModel): city: str
@dataclass
class P: x: int
class TD(TypedDict): a: int
for t in (Sequence[str], Set[str], Tuple[int, int], Mapping[str, int], Iterable[int],
FrozenSet[int], tuple, set, Addr, List[Addr], P, TD):
print(t, s(t))
# every one of these prints {"type": "string"} (List[Addr] -> array of string items)
So the model is told to send a plain string for Sequence[str], Tuple[float, float], a Pydantic model, a dataclass and so on. Nothing converts it back. Agent._cast_arguments (agent/tool_execution.py:879) only handles the exact annotations int, float and bool:
def send(recipients: Sequence[str], tags: Set[str], point: Tuple[float, float]) -> str: ...
agent.execute_tool("send", {"recipients": "[email protected],[email protected]", "tags": "a,b", "point": "1.0,2.0"})
# tool receives: recipients=<str>, tags=<str>, point=<str>
# list(recipients)[:5] -> ['a', 'l', 'i', 'c', 'e'] # silently iterates characters
The cast has the same gap for wrapped scalars (param.annotation == int is a direct equality check):
def f(n: Optional[int] = None): ...
agent.execute_tool("f", {"n": "5"}) # -> '5' (str); plain `n: int` gives 5
def g(xs: List[int]): ...
agent.execute_tool("g", {"xs": "[1,2]"}) # stays the str '[1,2]'
Three schema generators have drifted from each other. mcp/mcp_utils.py::python_type_to_json_schema handles tuple and set but not Sequence or BaseModel. runtime/context_builder.py::_python_type_to_json_type is a third copy. In build_tool_definition (tools/schema.py:~365), a failed schema build is swallowed by except Exception and logged only at debug level, then replaced with {"type": "string"}.
Suggested fix: make annotation_to_json_schema the single converter, extend it, and drive the cast from the same annotation.
# tools/schema.py
import collections.abc as cabc, dataclasses
_SEQ = (list, tuple, set, frozenset, cabc.Sequence, cabc.MutableSequence,
cabc.Set, cabc.MutableSet, cabc.Iterable, cabc.Collection)
def annotation_to_json_schema(annotation):
...
if origin in _SEQ or annotation in _SEQ:
item = annotation_to_json_schema(args[0]) if args else {}
schema = {"type": "array", "items": item}
if origin in (set, frozenset, cabc.Set, cabc.MutableSet):
schema["uniqueItems"] = True
return schema
if origin in (dict, cabc.Mapping, cabc.MutableMapping): ...
if isinstance(annotation, type):
if hasattr(annotation, "model_json_schema"): # pydantic v2
return annotation.model_json_schema()
if dataclasses.is_dataclass(annotation) or hasattr(annotation, "__required_keys__"):
return _object_schema_from_hints(annotation) # dataclass / TypedDict via get_type_hints
# agent/tool_execution.py (_cast_arguments): reuse one coercer instead of ==int/float/bool checks
def _coerce(value, annotation):
origin, args = get_origin(annotation), get_args(annotation)
if origin is Union: # Optional[int] etc.
for a in args:
if a is type(None): continue
try: return _coerce(value, a)
except (TypeError, ValueError): pass
return value
if annotation in (int, float, bool) or origin is None and annotation in (int, float, bool): ...
if origin in _SEQ and isinstance(value, str):
value = json.loads(value) # "[1,2]" -> [1, 2]
if origin in (set, frozenset): return origin(value)
if origin is tuple: return tuple(value)
if hasattr(annotation, "model_validate"): return annotation.model_validate(value)
Acceptance: Sequence[str], Set[str], Tuple[int, int], Mapping, BaseModel, dataclass and TypedDict parameters produce array or object schemas, and a JSON array or object from the model reaches the tool as the annotated type. Note the full-signature Optional[int] and List[int] cases above.
2. Task.depends_on is an alias for context: it neither orders execution nor is validated
task/task.py:435 documents depends_on as "Alias for context". AgentTeam runs tasks in list order for sequential and workflow. The only dependency-aware code is _depends_on_pending (agents/agents.py:1910, used at :2009), which only flushes a parallel async batch. Measured with a stubbed Agent.chat:
t1 = Task(name="t1", description="d1", agent=a, expected_output="o")
t2 = Task(name="t2", description="d2", agent=a, expected_output="o", depends_on=[t1])
AgentTeam(agents=[a], tasks=[t2, t1], process="sequential").start() # order run: t2, t1
AgentTeam(agents=[a], tasks=[t2, t1], process="workflow").start() # order run: t2, t1
t2 runs first and builds its prompt from an empty t1 result, with no error or warning. Two related cases are also accepted without any error:
t1.depends_on = [t2] # cycle: t1 <-> t2
AgentTeam(agents=[a], tasks=[t1, t2], process="workflow").start() # runs both, status "completed"
t4 = Task(..., depends_on=[t3]) # t3 is not in the team
AgentTeam(agents=[a], tasks=[t4], process="sequential").start() # runs t4; t3 never runs
The name depends_on promises ordering, and most users will read it that way. A mistyped graph produces plausible but wrong output instead of a failure.
Suggested fix: validate once in AgentTeam.__init__, and for non-parallel processes order tasks topologically only when depends_on / context edges exist, so existing linear flows are unchanged.
# agents/agents.py
def _validate_and_order_tasks(self, tasks):
ids = {id(t): t for t in tasks}
deps = {id(t): [d for d in (t.context or []) if isinstance(d, Task)] for t in tasks}
for t in tasks:
for d in deps[id(t)]:
if id(d) not in ids:
raise ValueError(f"Task '{t.name}' depends on '{d.name}', which is not part of this AgentTeam")
# Kahn's algorithm, stable w.r.t. the user's original order
order, seen, visiting = [], set(), set()
def visit(t):
if id(t) in seen: return
if id(t) in visiting:
raise ValueError(f"Circular task dependency involving '{t.name}'")
visiting.add(id(t))
for d in deps[id(t)]: visit(d)
visiting.discard(id(t)); seen.add(id(t)); order.append(t)
for t in tasks: visit(t)
return order # unchanged when no edges point "forward"
Acceptance: the cycle and dangling cases raise ValueError at construction. tasks=[t2, t1] with t2.depends_on=[t1] runs t1 first. A list with no forward references runs in exactly the same order as today.
3. import praisonaiagents still installs a root log handler, so a host's later logging.basicConfig() becomes a no-op (follow-up to #6134)
The #6134 fix added _host_configured_logging() (_logging.py:62). That only protects hosts that configure logging before they import the SDK. The usual order is the reverse: imports at the top of the file, then basicConfig in main(). __init__.py:57 still calls _logging.configure_root_logger(), which runs logging.basicConfig(...) (_logging.py:161) on import. The host's own call then does nothing:
import logging, praisonaiagents # SDK adds a stderr StreamHandler at WARNING
logging.basicConfig(filename="app.log", level=logging.DEBUG)
logging.getLogger("myapp").debug("hello")
# app.log is never created; root level stays 30 (WARNING)
Measured effects of a bare import praisonaiagents on current main:
logging.getLogger().handlersgoes from[]to[<StreamHandler stderr>], and the root level goes to 30.- The
httpx,litellm,LiteLLMandpydanticloggers are set to level 50 (CRITICAL). A host that uses httpx or pydantic directly loses their errors. - The global warning filters include
ignore, UserWarning, module=pydantic.*, which hides pydanticUserWarnings from the host's own code. - Import time is not the problem:
import Agenttakes about 0.07s andAgent()about 16ms, with no heavy modules loaded. Only the global-state mutation is.
Suggested fix: a library should attach a NullHandler to its own logger at import and leave the root alone. The stderr handler and LOGLEVEL handling move to the places where the SDK owns the output.
# __init__.py
logging.getLogger("praisonaiagents").addHandler(logging.NullHandler()) # replaces configure_root_logger()
# _logging.py
def configure_logging(*, force: bool = False) -> None:
"""Explicit opt-in; the praisonai CLI entrypoint and `Agent(output="verbose")` call this."""
if _host_configured_logging() and not force:
return
logging.basicConfig(...)
def _configure_noisy_loggers():
for name in _NOISY: # applied lazily with configure_litellm(), not at import
logging.getLogger(name).setLevel(logging.WARNING) # raise the level; do not use CRITICAL, do not clear handlers
Acceptance: a subprocess test shows import praisonaiagents leaves logging.getLogger().handlers and the level unchanged and the httpx / litellm / pydantic logger levels untouched, and that a later logging.basicConfig(filename=...) takes effect. The praisonai CLI still shows warnings on stderr by default.
All three are core-SDK changes that add no new public API. They reuse annotation_to_json_schema, Task.context and the existing logger names.
- 主要言語
- Python
- スター
- 9.3k
- フォーク
- 1.5k
- 平均マージ
- 1日 5時間
- マージ済み PR(30日)
- 520
環境構築
このプロジェクトには開発コンテナ、Dockerfile、コントリビューションガイドがありません。まず README を読み、一般的な手順ははじめてのコントリビューションガイドを参照してください。
はじめの一歩
- issue を最後まで読み、次にプロジェクトのコントリビューションガイドを読みます。
- 着手することを issue にコメントします — 二人が同じ作業をするのを防げます。
- リポジトリをフォークし、ブランチを切って変更します。
- issue 番号を参照したプルリクエストを送ります。
MervinPraison/PraisonAI のほかの issue
-
難易度 2/5 1〜3時間 初心者へのやさしさ 82/100
MervinPraison/PraisonAI#6710 · コメント 1 件 ·
メンテナーはふだん 1 日以内に返信
-
claude
難易度 2/5 1〜3時間 初心者へのやさしさ 74/100
MervinPraison/PraisonAI#6707 ·
メンテナーはふだん 1 日以内に返信
-
bug claude
難易度 1/5 1時間未満 初心者へのやさしさ 90/100
MervinPraison/PraisonAI#6671 ·
メンテナーはふだん 1 日以内に返信
-
Compaction budget regression fixture remains below budget with accurate tokenization再び着手できるかも このイシューのプルリクエストはマージされずにクローズされました。 オープン
難易度 2/5 1〜3時間 初心者へのやさしさ 62/100
MervinPraison/PraisonAI#5418 · コメント 3 件 ·
メンテナーはふだん 1 日以内に返信
-
bug claude documentation
難易度 2/5 1〜3時間 初心者へのやさしさ 70/100
MervinPraison/PraisonAI#5341 · コメント 3 件 ·
メンテナーはふだん 1 日以内に返信
MervinPraison/PraisonAI の issue をすべて見る
似ている issue
-
難易度 2/5 1〜3時間 初心者へのやさしさ 76/100
メンテナーはふだん 2 日以内に返信
-
[Bug]: LANGSMITH_SAMPLING_RATE ignores fractional values (isdigit check), traces 100% of requestsオープン
難易度 2/5 1〜3時間 初心者へのやさしさ 84/100
メンテナーはふだん 1 日以内に返信
-
platform/backend tests
難易度 2/5 1〜3時間 初心者へのやさしさ 78/100
Significant-Gravitas/AutoGPT#17100 ·
メンテナーはふだん 1 日以内に返信
-
bug good first issue
難易度 2/5 1〜3時間 初心者へのやさしさ 64/100
-
難易度 1/5 1時間未満 初心者へのやさしさ 61/100
scverse/infercnvpy#238 ·
メンテナーはふだん 1 日以内に返信