failproofai 1.0.3 → 1.0.4-beta.2

package/.next/standalone/sdk/python/tests/test_evaluator_source.py

@@ -0,0 +1,430 @@
+from __future__ import annotations
+
+import pytest
+
+from failproofai_sdk.evaluator import EvalResult, Score
+from failproofai_sdk.evaluator.protocol import SessionTranscript, TranscriptEvent
+from failproofai_sdk.evaluator.source import (
+    MAX_AST_NODES,
+    MAX_EVALUATOR_SOURCE_BYTES,
+    MAX_POW_EXPONENT,
+    MAX_SANDBOX_TIMEOUT_SECONDS,
+    EvaluationSandboxUnavailable,
+    EvaluationTimeout,
+    UnsafeEvaluatorSource,
+    _clamp_budget,
+    compile_condition,
+    compile_evaluator,
+    source_checksum,
+)
+
+
+def Session(event_count: int = 3) -> SessionTranscript:
+    """A real, serializable transcript — managed evals now run in a subprocess and
+    the transcript crosses the boundary via `to_wire`, so a dummy object won't do.
+    Each event carries a dict payload (so `events[0].payload.get` is reachable)."""
+    events = tuple(
+        TranscriptEvent(
+            id=f"e{i}",
+            ts="2026-08-28T12:00:00.000000Z",
+            event_type="tool_use",
+            payload={"k": "v", "tool_name": "search"},
+        )
+        for i in range(event_count)
+    )
+    return SessionTranscript(
+        assignment_id="a",
+        session_id="s",
+        session_revision_id="r",
+        agent_id="agent",
+        environment="test",
+        started_at="2026-08-28T12:00:00.000000Z",
+        ended_at="2026-08-28T12:00:01.000000Z",
+        event_count=event_count,
+        events=events,
+    )
+
+
+def test_restricted_expressions_can_evaluate_conditions_and_results():
+    assert compile_condition("session.event_count > 0")(Session()) is True
+    result = compile_evaluator("EvalResult(score=Score(0.75, passed=True))")(
+        Session()
+    )
+    assert isinstance(result, EvalResult)
+    assert result.score == Score(0.75, passed=True)
+
+
+@pytest.mark.parametrize(
+    "source",
+    [
+        "__import__('os').system('id')",
+        "session.__class__",
+        "(lambda: 1)()",
+        "[x for x in ().__class__.__base__.__subclasses__()]",
+    ],
+)
+def test_restricted_expressions_reject_escape_primitives(source):
+    with pytest.raises(UnsafeEvaluatorSource):
+        compile_evaluator(source)
+
+
+@pytest.mark.parametrize(
+    "source",
+    [
+        # `str.format` / `str.format_map` traverse a format string's field spec
+        # at the C level, reaching attributes the AST dunder guard never sees.
+        # These reached real `__builtins__` before the denylist landed.
+        '"{0.__class__.__init__.__globals__[__builtins__][__import__]}".format(session)',
+        '"{0.__class__}".format(session)',
+        'str.format("{0.__class__}", session)',
+        '"{a.__class__}".format_map({"a": session})',
+        # A reasoning string is where a leak would surface — block it there too.
+        'EvalResult(score=Score(0.5), reasoning="{0.__class__}".format(session))',
+    ],
+)
+def test_restricted_expressions_reject_format_string_traversal(source):
+    with pytest.raises(UnsafeEvaluatorSource):
+        compile_evaluator(source)
+
+
+@pytest.mark.parametrize(
+    "source",
+    [
+        # Generator/frame/code introspection reaches the eval globals and, via
+        # dict.update on them, could poison a shared namespace. None of these
+        # attribute names start with "_", so only the default-deny allowlist
+        # stops them.
+        "EvalResult(score=Score(0.5), reasoning=str((x for x in [1]).gi_frame.f_globals))",
+        "EvalResult(score=Score(0.5), reasoning=str((x for x in [1]).gi_code))",
+        'EvalResult(score=Score(0.5), reasoning=str((x for x in [1]).gi_frame.f_globals.update({"P": 1})))',
+        # `mro` is a public method on the type metaclass; it reaches `object`.
+        "EvalResult(score=Score(0.5), reasoning=str(str.mro()[-1]))",
+        "EvalResult(score=Score(0.5), reasoning=str(int.mro()))",
+        # A live function's identity would leak a heap pointer (ASLR defeat).
+        "EvalResult(score=Score(0.5), reasoning=str(EvalResult.result_items))",
+    ],
+)
+def test_restricted_expressions_reject_introspection_attributes(source):
+    with pytest.raises(UnsafeEvaluatorSource, match="attribute"):
+        compile_evaluator(source)
+
+
+def test_no_reachable_construct_leaks_a_heap_pointer_repr():
+    # An object's default repr (`<... object at 0x...>`) leaks a live host heap
+    # address (ASLR/memory-layout disclosure) if coerced into a result field.
+    # Generator expressions are rejected at compile; `enumerate` is not bound, so
+    # it raises NameError at run time and becomes a bounded failed run instead of
+    # a disclosure. Either way, a pointer must never reach a result string.
+    import re
+
+    from failproofai_sdk.evaluator.source import _SAFE_GLOBALS
+
+    with pytest.raises(UnsafeEvaluatorSource, match="GeneratorExp"):
+        compile_evaluator("EvalResult(score=Score(1.0), reasoning=str((x for x in [1])))")
+
+    evaluate = compile_evaluator(
+        "EvalResult(score=Score(1.0), reasoning=str(enumerate([1])))"
+    )
+    with pytest.raises(NameError):
+        evaluate(Session())
+
+    # No value bound into the evaluation namespace reprs to a heap pointer.
+    pointer = re.compile(r"0x[0-9a-fA-F]+")
+    leaky = {
+        name: repr(value)
+        for name, value in _SAFE_GLOBALS.items()
+        if name != "__builtins__" and pointer.search(repr(value))
+    }
+    assert leaky == {}
+
+
+@pytest.mark.parametrize(
+    "inner",
+    [
+        # A bound method's repr is `<... at 0xADDR>` — a live heap pointer. These
+        # methods stay allowlisted (real evals CALL them), but referencing one as a
+        # bare VALUE only serves to stringify that repr, so it is now rejected at
+        # COMPILE — the disclosure is closed at its source, not at the output.
+        "session.events[0].payload.get",
+        "''.join",
+        "'x'.encode",
+        "'a,b'.split",
+    ],
+)
+def test_bare_bound_method_reference_is_rejected_at_compile(inner):
+    for field in (
+        f'EvalResult(score=Score(1.0), reasoning=str({inner}))',
+        f'EvalResult(score=Score(1.0), summary=str({inner}))',
+        f'EvalResult(score=Score(1.0, display_value=str({inner})))',
+        f'EvalResult(score=Score(1.0), labels=(str({inner}),))',
+    ):
+        with pytest.raises(UnsafeEvaluatorSource, match="only to call it"):
+            compile_evaluator(field)
+
+
+def test_heap_pointer_output_guard_bypasses_are_closed_at_compile():
+    # An adversarial-review finding: the output-boundary regex was anchored on `<`,
+    # so a managed source could keep the address while reshaping the wrapper text —
+    # str(...).replace("<",""), an f-string, or %-formatting all coerce a bound
+    # method at a point the old scan missed. Each needs a BARE bound-method
+    # reference, which the compile-time call-site rule now rejects outright.
+    bypasses = [
+        # str(...).replace("<","") strips the old regex's `<` anchor.
+        'EvalResult(score=Score(1.0), reasoning=str(dict().get).replace("<", ""))',
+        # f-strings coerce at the C level, past the `str` global.
+        'EvalResult(score=Score(1.0), reasoning=f"{session.events[0].payload.get}")',
+        # %-formatting coerces at the C level too.
+        'EvalResult(score=Score(1.0), reasoning="%s" % session.events[0].payload.get)',
+    ]
+    for src in bypasses:
+        with pytest.raises(UnsafeEvaluatorSource, match="only to call it"):
+            compile_evaluator(src)
+
+
+def test_called_methods_and_data_attributes_still_stringify():
+    # The call-site rule blocks only BARE method references. Calling methods and
+    # reading data attributes (both pointer-free) must still work — including the
+    # f-string and %-formatting paths — so legitimate evaluations are unaffected.
+    reasoning_call = compile_evaluator(
+        'EvalResult(score=Score(1.0), '
+        'reasoning=str(session.events[0].payload.get("tool_name")))'
+    )(Session())
+    assert reasoning_call.reasoning == "search"
+
+    fstring = compile_evaluator(
+        'EvalResult(score=Score(1.0), reasoning=f"n={session.event_count}")'
+    )(Session())
+    assert fstring.reasoning == "n=3"
+
+    percent = compile_evaluator(
+        'EvalResult(score=Score(1.0), reasoning="pct=%d" % (session.event_count * 10))'
+    )(Session())
+    assert percent.reasoning == "pct=30"
+
+
+def test_each_evaluation_gets_isolated_globals_so_it_cannot_poison_the_next():
+    # Even setting aside the allowlist, one evaluation must not be able to leave
+    # state behind for the next. Compiling and running twice must not share a
+    # mutable namespace.
+    from failproofai_sdk.evaluator.source import _fresh_globals
+
+    first = _fresh_globals()
+    second = _fresh_globals()
+    assert first is not second
+    assert first["__builtins__"] is not second["__builtins__"]
+    first["__poison__"] = "leaked"
+    assert "__poison__" not in second
+
+
+def test_format_denylist_does_not_block_legitimate_string_methods():
+    # The fix is a targeted denylist of `format`/`format_map`, not a ban on all
+    # string methods — ordinary evaluations must still compile and run.
+    evaluate = compile_evaluator(
+        'EvalResult(score=Score(0.9, passed=True), '
+        'reasoning="tools=" + str(session.event_count).upper())'
+    )
+    result = evaluate(Session())
+    assert result.reasoning == "tools=3"
+
+
+def test_restricted_expressions_reject_statements_and_oversized_source():
+    with pytest.raises(UnsafeEvaluatorSource, match="one expression"):
+        compile_evaluator("import os")
+    with pytest.raises(UnsafeEvaluatorSource, match="exceeds"):
+        compile_evaluator("x" * (MAX_EVALUATOR_SOURCE_BYTES + 1))
+
+
+def test_result_and_condition_types_are_checked_at_runtime():
+    with pytest.raises(TypeError, match="EvalResult"):
+        compile_evaluator("True")(Session())
+    with pytest.raises(TypeError, match="bool or ConditionResult"):
+        compile_condition("1")(Session())
+
+
+def test_source_checksum_covers_condition_and_evaluator_together():
+    base = source_checksum(None, "EvalResult()")
+    assert base == source_checksum(None, "EvalResult()")
+    assert base != source_checksum("True", "EvalResult()")
+    assert base != source_checksum(None, "EvalResult(summary='changed')")
+
+
+# --- SEC-001: managed source cannot exhaust the worker (killable-fork sandbox) ---
+
+
+def test_compute_bomb_is_killed_within_its_budget():
+    # `sum(range(10**9))` would burn CPU for ~20s in-process, uncancellable — a
+    # CPU-bound loop (not a big allocation) so the wall-clock/CPU budget is what
+    # stops it, deterministically, rather than the memory ceiling. The forked
+    # sandbox kills it at its budget.
+    import time as _time
+
+    evaluate = compile_evaluator(
+        "EvalResult(score=Score(1.0), reasoning=str(sum(range(10**9))))",
+        timeout_seconds=1,
+    )
+    started = _time.monotonic()
+    with pytest.raises(EvaluationTimeout):
+        evaluate(Session())
+    assert _time.monotonic() - started < 5  # bounded by the ~1s budget, not ~20s
+
+
+def test_condition_compute_bomb_is_also_bounded():
+    # `10**9`, matching the evaluator bomb above, NOT `10**8`.
+    #
+    # The property under test is "a CPU bomb in a condition is stopped by the
+    # sandbox budget", and the bomb has to be big enough that it cannot finish
+    # inside that budget on ANY machine the suite runs on. At 10**8 it was only
+    # ~1.35 CPU-seconds against a 1-second budget — a 1.35x margin — so on a fast
+    # runner the sum simply completed and nothing timed out. It failed exactly
+    # that way on CI under Python 3.14, which is faster here than 3.13 (1.35s vs
+    # 1.44s measured), while passing locally: a machine-speed coin flip, not a
+    # real signal about the sandbox.
+    #
+    # 10**9 restores the ~13x margin the evaluator twin already had. It costs no
+    # extra wall-clock: the sandbox kills the child at its budget either way, so
+    # a bigger bomb only widens the gap between "killed" and "could have
+    # finished". Do not shrink it back.
+    condition = compile_condition("sum(range(10**9)) > 0", timeout_seconds=1)
+    with pytest.raises(EvaluationTimeout):
+        condition(Session())
+
+
+def test_literal_pow_exponent_bomb_is_rejected_at_compile():
+    with pytest.raises(UnsafeEvaluatorSource, match="exponent"):
+        compile_evaluator(f"EvalResult(score=Score(10 ** {MAX_POW_EXPONENT + 1}))")
+    # A small constant exponent stays allowed.
+    result = compile_evaluator(
+        "EvalResult(score=Score(1.0), reasoning=str(2 ** 3))"
+    )(Session())
+    assert result.reasoning == "8"
+
+
+def test_oversized_expression_is_rejected_at_compile():
+    huge = "[" + ",".join("1" for _ in range(MAX_AST_NODES)) + "]"
+    with pytest.raises(UnsafeEvaluatorSource, match="too large"):
+        compile_evaluator(f"EvalResult(score=Score(len({huge}) / len({huge})))")
+
+
+def test_normal_managed_eval_survives_the_fork_boundary():
+    # A session-dependent result must round-trip out of the forked child intact.
+    result = compile_evaluator(
+        "EvalResult(score=Score(1.0 if session.event_count > 0 else 0.0), "
+        "reasoning=str(session.event_count))"
+    )(Session())
+    assert isinstance(result, EvalResult)
+    assert result.score.value == 1.0
+    assert result.reasoning == "3"
+
+
+def test_sandbox_fails_closed_without_a_serializable_transcript():
+    # The transcript crosses into the subprocess via `to_wire`. A session that
+    # can't be serialized cannot be sandboxed, so refuse rather than run unbounded.
+    class NotATranscript:
+        event_count = 1
+
+    with pytest.raises(EvaluationSandboxUnavailable):
+        compile_evaluator("EvalResult(score=Score(1.0))")(NotATranscript())
+
+
+def test_server_timeout_cannot_exceed_the_hard_ceiling():
+    # SEC-001: a large server-provided timeout must not remove the execution bound.
+    assert _clamp_budget(10**9) == float(MAX_SANDBOX_TIMEOUT_SECONDS)
+    assert _clamp_budget(0) == 30.0
+    assert _clamp_budget(None) == 30.0
+    assert _clamp_budget(5) == 5.0
+
+
+def test_oversized_result_is_rejected_before_it_crosses_back():
+    # A result with far more than the 25-item limit must be rejected INSIDE the
+    # sandbox (via result_items), so a huge result can never be serialized and
+    # shipped back to OOM the worker (SEC-001).
+    src = (
+        "EvalResult(score=Score(1.0), "
+        "metrics={'m' + str(i): float(i) for i in range(200)})"
+    )
+    with pytest.raises(ValueError, match="at most"):
+        compile_evaluator(src, eval_key="q")(Session())
+
+
+def test_sandbox_slot_wait_counts_against_the_timeout(monkeypatch):
+    # SEC-001: acquiring a concurrency slot must count against the wall-clock budget.
+    # `asyncio.wait_for` only cancels the awaiter, so a run that blocked UNBOUNDED on
+    # a busy slot would still launch a sandbox after its caller was reported timed
+    # out — 28 threads could queue behind 4 long sandboxes and starve the worker.
+    # With one slot and three 1s compute bombs, all three must resolve within ~one
+    # budget (the holder is killed at ~1s; the two queued behind it exhaust their
+    # budget waiting and time out WITHOUT ever spawning a child), not three serialized
+    # budgets (~3s).
+    import threading
+    import time as _time
+
+    from failproofai_sdk.evaluator import source as _source
+
+    monkeypatch.setattr(_source, "_SANDBOX_SLOTS", threading.Semaphore(1))
+    bomb = compile_evaluator(
+        "EvalResult(score=Score(1.0), reasoning=str(sum(range(10**9))))",
+        timeout_seconds=1,
+    )
+    session = Session()
+    errors: list[str] = []
+
+    def run():
+        try:
+            bomb(session)
+        except Exception as error:  # noqa: BLE001
+            errors.append(type(error).__name__)
+
+    threads = [threading.Thread(target=run) for _ in range(3)]
+    started = _time.monotonic()
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join(timeout=15)
+    elapsed = _time.monotonic() - started
+
+    assert errors == ["EvaluationTimeout"] * 3, errors
+    # Bounded by ~one budget, NOT three serialized ones — proving the queued runs
+    # timed out on slot acquisition instead of each waiting then running in turn.
+    assert elapsed < 2.5, f"queued sandboxes were not bounded by the timeout: {elapsed:.2f}s"
+
+
+def test_allocation_bomb_is_bounded_by_the_per_sandbox_memory_limit():
+    # A ~1.6 GiB allocation exceeds the per-sandbox RLIMIT_AS and is killed, so it
+    # cannot exhaust the worker even wrapped in an otherwise-valid result. With the
+    # concurrent-sandbox cap this also bounds the aggregate across concurrent runs.
+    src = "EvalResult(score=Score(1.0 if len([0] * 200000000) >= 0 else 0.0))"
+    with pytest.raises((EvaluationTimeout, MemoryError)):
+        compile_evaluator(src, timeout_seconds=5)(Session())
+
+
+def test_sandbox_fails_closed_when_kernel_resource_limits_are_unavailable(monkeypatch):
+    # SEC-001: on a platform without the stdlib ``resource`` module (e.g. Windows),
+    # the sandbox child cannot install RLIMIT_CPU / RLIMIT_AS on itself, so managed
+    # source must be refused BEFORE any child is spawned rather than run unbounded.
+    import failproofai_sdk.evaluator.source as source
+
+    monkeypatch.setattr(source, "_resource", None)
+
+    def _no_spawn(*args, **kwargs):
+        raise AssertionError("a sandbox child must not be started when limits are unavailable")
+
+    monkeypatch.setattr(source.subprocess, "Popen", _no_spawn)
+
+    with pytest.raises(EvaluationSandboxUnavailable):
+        source.compile_evaluator("EvalResult(score=Score(1.0))")(Session())
+
+
+def test_comprehension_body_can_read_session():
+    # A list/set/dict comprehension resolves a free name like `session` from
+    # GLOBALS. When `session` was only in eval locals, such a source raised
+    # NameError on CPython 3.10 (a supported version). Both sandbox paths must
+    # now evaluate a session-dependent comprehension (COR-001).
+    assert (
+        compile_condition("len([session.event_count for i in range(1)]) > 0")(Session())
+        is True
+    )
+    result = compile_evaluator(
+        "EvalResult(score=Score(1.0), "
+        "reasoning=str([session.event_count for i in range(1)]))"
+    )(Session(event_count=3))
+    assert result.reasoning == "[3]"

package/.next/standalone/sdk/python/tests/test_zero_dependencies.py

@@ -300,6 +300,23 @@ def test_importing_the_package_loads_no_framework():
     )
 
 
+def test_importing_the_package_does_not_load_the_evaluator_runtime():
+    """Telemetry-only users do not pay for the separate worker surface."""
+    import json
+    import subprocess
+
+    probe = (
+        "import json, sys; import failproofai_sdk; "
+        "print(json.dumps(sorted(m for m in sys.modules "
+        "if m.startswith('failproofai_sdk.evaluator'))))"
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", probe], capture_output=True, text=True, cwd=str(ROOT), timeout=60
+    )
+    assert result.returncode == 0, result.stderr
+    assert json.loads(result.stdout.strip()) == []
+
+
 def test_the_adapter_registry_holds_strings_not_modules():
     """`_REGISTRY` maps a name to a dotted path; importing it here would defeat it."""
     from failproofai_sdk.integrations import _REGISTRY

package/.next/standalone/sdk/python/uv.lock

@@ -2,14 +2,14 @@ version = 1
 revision = 3
 requires-python = ">=3.10"
 resolution-markers = [
-    "python_full_version == '3.13.*'",
     "python_full_version >= '3.14' and sys_platform == 'win32'",
     "python_full_version >= '3.14' and sys_platform != 'win32'",
+    "python_full_version == '3.13.*'",
     "python_full_version == '3.12.*' and sys_platform == 'win32'",
-    "python_full_version == '3.11.*' and sys_platform == 'win32'",
-    "python_full_version < '3.11' and sys_platform == 'win32'",
     "python_full_version == '3.12.*' and sys_platform != 'win32'",
+    "python_full_version == '3.11.*' and sys_platform == 'win32'",
     "python_full_version == '3.11.*' and sys_platform != 'win32'",
+    "python_full_version < '3.11' and sys_platform == 'win32'",
     "python_full_version < '3.11' and sys_platform != 'win32'",
 ]
 
@@ -751,7 +751,7 @@ wheels = [
 
 [[package]]
 name = "crewai"
-version = "1.15.17"
+version = "1.15.20"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiofiles" },
@@ -786,14 +786,14 @@ dependencies = [
     { name = "tomli" },
     { name = "tomli-w" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/67/df7f2325cc92f6e5e94f8ee6c60a869125adaf211bb3822c2a109d243241/crewai-1.15.17.tar.gz", hash = "sha256:ead447c21c8622869f6b70ab2f5f927e7a11098da3a883b7a7397847416a8755", size = 7900244, upload-time = "2026-08-20T00:28:11.744Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/07/3a6d94fbb3bd465c653208a28d3e59d539d00cb5bef55626188a46ed7457/crewai-1.15.20.tar.gz", hash = "sha256:c4a4d02c27eca7502479ce8cf3fcdd1658fcc9948aa86962ad19e581530032b4", size = 7965515, upload-time = "2026-09-04T12:42:59.848Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8e/20/06326a19271b0d40fb454191712e47acd26dc175fa5e6220a4055bbdf7d7/crewai-1.15.17-py3-none-any.whl", hash = "sha256:54a7fda83b13eba0db6c7df716c713cb911287216b3c811adb3f2adf0bc0252a", size = 1120499, upload-time = "2026-08-20T00:28:09.063Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/cd/fa00e87bf061e8bb02546cd00f58c4d85694b0fe027afae5eb1f578c610c/crewai-1.15.20-py3-none-any.whl", hash = "sha256:8bf272a687ad3320b681f23a183a6ac445f2fa7fc78b52943b835acc2eb158d6", size = 1141815, upload-time = "2026-09-04T12:42:58.166Z" },
 ]
 
 [[package]]
 name = "crewai-cli"
-version = "1.15.17"
+version = "1.15.20"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "appdirs" },
@@ -813,14 +813,14 @@ dependencies = [
     { name = "tomli-w" },
     { name = "uv" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/32/52/1f9e57480832b86ef4efbca6cd17013f80cd188d1f742ed7b7c9a685822a/crewai_cli-1.15.17.tar.gz", hash = "sha256:a788c0823aeb32bfc96b9f77c150f0d32d647057273d57b292b85b129ee79d58", size = 228509, upload-time = "2026-08-20T00:28:15.285Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/30/8521f26795a71179b684c5b2d8135e78f8b4fcabe79acae93e0b3d9a42e2/crewai_cli-1.15.20.tar.gz", hash = "sha256:21f1735ee7e6818f658f46d59844d6f04700af5398c632a3e0fd42c8e6180c93", size = 233643, upload-time = "2026-09-04T12:43:02.502Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/57/6e/b38c32123edeccb334d386a8b33c1bc272b6299e74a4b773781f9ae60ad4/crewai_cli-1.15.17-py3-none-any.whl", hash = "sha256:d102fc0041c290b992fd3571186cf2039dfa88e05a673e2209d624e0137e9064", size = 195755, upload-time = "2026-08-20T00:28:13.711Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/eb/a04ae71e6226c10ae921911a8b8216cef6ae5d1db98c5b36f941058728c3/crewai_cli-1.15.20-py3-none-any.whl", hash = "sha256:2d692143cb4a46ef97f927fc1a2f6035790d2ee2fe4d1bb50fad9f884576ce6a", size = 198183, upload-time = "2026-09-04T12:43:01.266Z" },
 ]
 
 [[package]]
 name = "crewai-core"
-version = "1.15.17"
+version = "1.15.20"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "appdirs" },
@@ -836,9 +836,9 @@ dependencies = [
     { name = "rich" },
     { name = "tomli" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e5/54/f3e6ba7799363724bab15cda41d7c51d69438faff707a3d66f793219b592/crewai_core-1.15.17.tar.gz", hash = "sha256:40c659474c9f60dede2be9ea0236b80b7ea25e8df13891e409ccddd651286ac4", size = 35445, upload-time = "2026-08-20T00:28:17.678Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c8/7f/75b9f75f90f6639edb68e1591bc6fd54ef1381cbdd4f10f41f62ef12b985/crewai_core-1.15.20.tar.gz", hash = "sha256:5a3ad81107172f24b6ee14a24aff87f93e3b56da7220a0e5584992d9b9476939", size = 39207, upload-time = "2026-09-04T12:43:04.352Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/01/b65842de25f59ba683404e48183dfe2bebc2e9f7b75715a4ea7b6902841a/crewai_core-1.15.17-py3-none-any.whl", hash = "sha256:40059c8fbf74c1595048aceae6c06879d2ca5718be11f0bcfcb995251df2e4f4", size = 40427, upload-time = "2026-08-20T00:28:16.428Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/6a/f5e1f1114a6900275e240feffae6580ddccc6f5e4716372b3ec97511e3ab/crewai_core-1.15.20-py3-none-any.whl", hash = "sha256:09a96fbd08e2f849e4a521ecfdab88b62fcb3b94292f4e7039c0bc3b9de67d40", size = 42481, upload-time = "2026-09-04T12:43:03.421Z" },
 ]
 
 [[package]]
@@ -1200,15 +1200,15 @@ wheels = [
 
 [[package]]
 name = "genai-prices"
-version = "0.1.3"
+version = "0.1.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx2" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/09/14/a188df294f013ec9cd97fc6b145f5427f89067bfb2c260fc3fb5c8d1fb34/genai_prices-0.1.3.tar.gz", hash = "sha256:62c30cddd6c2d2199d878d1a70521c3e37347cd9394446d107dc774a78ed3780", size = 92638, upload-time = "2026-08-15T00:10:31.771Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/16/e5a507d42c0eb629b48ebe6c278f2d8c3f929bb6b28f18108bdd66d8ae12/genai_prices-0.1.6.tar.gz", hash = "sha256:802c1e4cc3ed5e70a09083b83af441a58d91f62e12768f7f1b6b26c98a33fcac", size = 111810, upload-time = "2026-09-02T14:53:54.895Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4e/cd/d94b47c26d6367e0b949edfe2da5a47fb74037e799a0edd5b825e049f2b9/genai_prices-0.1.3-py3-none-any.whl", hash = "sha256:a2603841429c843da91c987d9ef598c73bd940caf44e844ab046d551791c04bb", size = 96892, upload-time = "2026-08-15T00:10:30.595Z" },
+    { url = "https://files.pythonhosted.org/packages/48/a1/43fa2a4c5557cd977e83eecec265b0b77b726b0c7b9f2f180b46c6fdb458/genai_prices-0.1.6-py3-none-any.whl", hash = "sha256:35ac8043dbcf2958488129413bfecba7304fe12a68ad4a78c5b0d15281e82814", size = 118834, upload-time = "2026-09-02T14:53:53.758Z" },
 ]
 
 [[package]]
@@ -2003,7 +2003,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.6.0"
+version = "1.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -2017,9 +2017,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/97/88/ebc98df187c525d729725ab39759337c56d5d2803423632376aa35bde899/langchain_core-1.6.0.tar.gz", hash = "sha256:dc72e36678ed26683ec0ad8829b44011fba461d10f9b31dbd9110215e5ec2333", size = 992493, upload-time = "2026-08-19T15:55:40.642Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/12/aff76ca89c219ebe6f9dd3c5dbc4e3b1cf5450e9fc7037dccad23d45cd7a/langchain_core-1.6.1.tar.gz", hash = "sha256:1b156cb395aac4f009a8a1b38a574c7d948fe2d5f74c96e0d8a5017b4149e04f", size = 1003359, upload-time = "2026-08-27T19:31:14.956Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/4c/508a90b9d2e3bd7738fd93cb2ac2178ce734662c75e69b3b81c445f1b360/langchain_core-1.6.0-py3-none-any.whl", hash = "sha256:d8bb924cd413955d9d3192ccced140407427c3ff51e50ffb941222648da92cb2", size = 570006, upload-time = "2026-08-19T15:55:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/25/f50dd65673c819aa33d3c34df58c115dbb6ec627d19f93e6e401dd0fc8d7/langchain_core-1.6.1-py3-none-any.whl", hash = "sha256:954a84132a5cb0435d27b910e336347b6744ecc18fbeef1e2de7029a0959841a", size = 571478, upload-time = "2026-08-27T19:31:13.34Z" },
 ]
 
 [[package]]
@@ -2674,12 +2674,12 @@ name = "networkx"
 version = "3.6.1"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version == '3.13.*'",
     "python_full_version >= '3.14' and sys_platform == 'win32'",
     "python_full_version >= '3.14' and sys_platform != 'win32'",
+    "python_full_version == '3.13.*'",
     "python_full_version == '3.12.*' and sys_platform == 'win32'",
-    "python_full_version == '3.11.*' and sys_platform == 'win32'",
     "python_full_version == '3.12.*' and sys_platform != 'win32'",
+    "python_full_version == '3.11.*' and sys_platform == 'win32'",
     "python_full_version == '3.11.*' and sys_platform != 'win32'",
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" }
@@ -2857,9 +2857,9 @@ name = "numpy"
 version = "2.5.2"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version == '3.13.*'",
     "python_full_version >= '3.14' and sys_platform == 'win32'",
     "python_full_version >= '3.14' and sys_platform != 'win32'",
+    "python_full_version == '3.13.*'",
     "python_full_version == '3.12.*' and sys_platform == 'win32'",
     "python_full_version == '3.12.*' and sys_platform != 'win32'",
 ]
@@ -3906,7 +3906,7 @@ wheels = [
 
 [[package]]
 name = "pydantic-ai-slim"
-version = "2.33.0"
+version = "2.39.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -3919,9 +3919,9 @@ dependencies = [
     { name = "pydantic-graph" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ae/00/ab2ec7a91f499e33fadd524f380acae3acf960f2f9140c8adce2e91c872b/pydantic_ai_slim-2.33.0.tar.gz", hash = "sha256:7809e3000df0265ee93e7c55ff1d852621a23b22ccb5ad790d9228e457cfb10a", size = 1229403, upload-time = "2026-08-21T05:05:55.276Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/f9/17eb24ebd9c8dbc9812f94d15534e440df3fb9979bb351895cd9b83eb8cc/pydantic_ai_slim-2.39.0.tar.gz", hash = "sha256:7c4c6cba3f1658e456fe1686288667aaf4fda71bda6a95740304fef540549bc2", size = 1375061, upload-time = "2026-09-04T04:30:22.756Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/dc/c0/d6120efa7f6466da2194e80032c483f8f8ececc5bafcf07cf064792f9702/pydantic_ai_slim-2.33.0-py3-none-any.whl", hash = "sha256:5ab28c9f6d7c0a6dd8e5c4f75ba4bcfa84a7f6aa0faa7b64209fbcaa981f922b", size = 1448791, upload-time = "2026-08-21T05:05:46.881Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/62/fe1c2bbab6af6ea238c447e68f0113e2c555625c828f57575e8918214a81/pydantic_ai_slim-2.39.0-py3-none-any.whl", hash = "sha256:c8e7cd0b027a383fdf03ef6341737099dbe0f0b5b890a98a1461c4652e79e1b2", size = 1618873, upload-time = "2026-09-04T04:30:14.699Z" },
 ]
 
 [[package]]
@@ -4044,7 +4044,7 @@ wheels = [
 
 [[package]]
 name = "pydantic-graph"
-version = "2.33.0"
+version = "2.39.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -4052,9 +4052,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/82/68/7bbebffe9d7a2033182c92b5610e5c52840d3ca877337435e1737fe59ed3/pydantic_graph-2.33.0.tar.gz", hash = "sha256:ff4bfd7f6e10b85b0fb77c85100140733f295e9bd445ed60318221446413e224", size = 45163, upload-time = "2026-08-21T05:05:58.095Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/11/64fe78978331bc4716af4be6f1be14c6d0f59176e311f42e91da41c0b8bd/pydantic_graph-2.39.0.tar.gz", hash = "sha256:38afcb88c6dce861896fe7185735419eb435b61ff26a756260087df928b5b22e", size = 45191, upload-time = "2026-09-04T04:30:24.94Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/97/a5/73a9cd5a6dd5ca41391022597a9298aa50f9879df60299ac44f0eb7373e2/pydantic_graph-2.33.0-py3-none-any.whl", hash = "sha256:44e0ab3e0557e8e6f6ff2c939e1f15684b32029a14b55146cc88808a1c5cc464", size = 52648, upload-time = "2026-08-21T05:05:50.524Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/79/d0944b6d15ecc7930539cca29b17a5af219a62f0d97f257370617b02f02e/pydantic_graph-2.39.0-py3-none-any.whl", hash = "sha256:d754f1f0f73e5dc45e2f1f9019270d6409e4bd35e141a6f14af41d38c06e766f", size = 52701, upload-time = "2026-09-04T04:30:18.145Z" },
 ]
 
 [[package]]
@@ -4627,12 +4627,12 @@ name = "rpds-py"
 version = "2026.6.3"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version == '3.13.*'",
     "python_full_version >= '3.14' and sys_platform == 'win32'",
     "python_full_version >= '3.14' and sys_platform != 'win32'",
+    "python_full_version == '3.13.*'",
     "python_full_version == '3.12.*' and sys_platform == 'win32'",
-    "python_full_version == '3.11.*' and sys_platform == 'win32'",
     "python_full_version == '3.12.*' and sys_platform != 'win32'",
+    "python_full_version == '3.11.*' and sys_platform == 'win32'",
     "python_full_version == '3.11.*' and sys_platform != 'win32'",
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/aa/2a/9618a122aeb2a169a28b03889a2995fe297588964333d4a7d67bdf46e147/rpds_py-2026.6.3.tar.gz", hash = "sha256:1cebd1337c242e4ec2293e541f712b2da849b29f48f0c293684b71c0632625d4", size = 64051, upload-time = "2026-06-30T07:17:53.009Z" }