fix: cover defaults closures and inherited deps

Update behavior hashing so function defaults, keyword-only defaults,
and closure cell contents contribute to compute_behavior_token(). This
closes a cache-key correctness gap where semantic changes could leave
behavior tokens unchanged.

Also merge __ccflow_tokenizer_deps__ across the full MRO instead of
first-definition-wins, with deterministic deduping so subclasses can add
deps without dropping inherited ones.

Add regression tests for defaults, kwdefaults, closures, inherited deps,
and a cache_key integration check for helper default changes.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ptomecek

ccflow/tests/utils/test_behavior_hash.py

@@ -120,6 +120,38 @@ def f(self):
 
         assert compute_behavior_token(A) != compute_behavior_token(B)
 
+    def test_defaults_matter(self):
+        class A:
+            def f(self, x=1):
+                return x
+
+        class B:
+            def f(self, x=2):
+                return x
+
+        assert compute_behavior_token(A) != compute_behavior_token(B)
+
+    def test_kwdefaults_matter(self):
+        class A:
+            def f(self, *, x=1):
+                return x
+
+        class B:
+            def f(self, *, x=2):
+                return x
+
+        assert compute_behavior_token(A) != compute_behavior_token(B)
+
+    def test_closure_values_matter(self):
+        def make_model(value):
+            class M:
+                def f(self):
+                    return value
+
+            return M
+
+        assert compute_behavior_token(make_model(1)) != compute_behavior_token(make_model(2))
+
 
 # ---------------------------------------------------------------------------
 # Method collection
@@ -262,6 +294,36 @@ def f(self):
 
         assert compute_behavior_token(A) != compute_behavior_token(B)
 
+    def test_subclass_deps_extend_inherited_deps(self):
+        def base_a():
+            return 1
+
+        def base_b():
+            return 2
+
+        def sub_dep():
+            return 3
+
+        class BaseA:
+            __ccflow_tokenizer_deps__ = [base_a]
+
+            def f(self):
+                return 1
+
+        class BaseB:
+            __ccflow_tokenizer_deps__ = [base_b]
+
+            def f(self):
+                return 1
+
+        class SubA(BaseA):
+            __ccflow_tokenizer_deps__ = [sub_dep]
+
+        class SubB(BaseB):
+            __ccflow_tokenizer_deps__ = [sub_dep]
+
+        assert compute_behavior_token(SubA) != compute_behavior_token(SubB)
+
 
 # ---------------------------------------------------------------------------
 # Integration with cache_key()
@@ -329,6 +391,27 @@ class MyContext(ContextBase):
         key = cache_key(MyContext(value=1))
         assert isinstance(key, bytes)
 
+    def test_helper_default_arg_changes_key(self):
+        from ccflow import Flow
+
+        class A(CallableModel):
+            @Flow.call
+            def __call__(self, context: NullContext) -> GenericResult:
+                return GenericResult(value=self.helper())
+
+            def helper(self, x=1):
+                return x
+
+        class B(CallableModel):
+            @Flow.call
+            def __call__(self, context: NullContext) -> GenericResult:
+                return GenericResult(value=self.helper())
+
+            def helper(self, x=2):
+                return x
+
+        assert cache_key(A()) != cache_key(B())
+
     def test_opaque_evaluator_behavior_changes_key(self):
         from ccflow import Flow
 

ccflow/utils/tokenize.py

@@ -79,12 +79,40 @@ def _unwrap_function(func: object) -> Optional[Callable]:
     return func
 
 
+def _function_state(func: Callable) -> Tuple[Any, Any, Tuple[Tuple[str, bool, Any], ...] | None]:
+    """Return defaults/kwdefaults/closure state that affects runtime behavior."""
+
+    kwdefaults = getattr(func, "__kwdefaults__", None)
+    if kwdefaults is not None:
+        kwdefaults = tuple(sorted(kwdefaults.items()))
+
+    closure = getattr(func, "__closure__", None)
+    closure_state = None
+    if closure:
+        closure_state = []
+        for name, cell in zip(func.__code__.co_freevars, closure):
+            try:
+                closure_state.append((name, True, cell.cell_contents))
+            except ValueError:
+                closure_state.append((name, False, None))
+        closure_state = tuple(closure_state)
+
+    return getattr(func, "__defaults__", None), kwdefaults, closure_state
+
+
 def _hash_function_bytecode(func: Callable) -> Optional[str]:
-    """Return a SHA-256 hex digest of a function's bytecode and constants.
+    """Return a SHA-256 hex digest of a function's behavior-relevant state.
 
     The function is first unwrapped through any decorator chains, so that
     e.g. ``@Flow.call`` wrappers do not mask the real implementation.
 
+    In addition to ``co_code`` and ``co_consts``, this includes:
+    - positional defaults (``__defaults__``)
+    - keyword-only defaults (``__kwdefaults__``)
+    - closure cell contents
+    so that behavior changes that do not affect bytecode alone still change
+    the token.
+
     Returns ``None`` for objects without ``__code__`` (C builtins, etc.).
     """
     unwrapped = _unwrap_function(func)
@@ -97,9 +125,20 @@ def _hash_function_bytecode(func: Callable) -> Optional[str]:
     if consts and isinstance(consts[0], str):
         consts = consts[1:]
     h.update(repr(consts).encode("utf-8"))
+    h.update(compute_data_token(_function_state(unwrapped)).encode("utf-8"))
     return h.hexdigest()
 
 
+def _dependency_sort_key(func: Callable) -> Tuple[str, str, str]:
+    """Return a deterministic identity for dependency sorting/deduping."""
+
+    unwrapped = _unwrap_function(func) or func
+    module = getattr(unwrapped, "__module__", "")
+    qualname = getattr(unwrapped, "__qualname__", getattr(unwrapped, "__name__", repr(unwrapped)))
+    behavior = _hash_function_bytecode(unwrapped) or ""
+    return module, qualname, behavior
+
+
 def _collect_methods(cls: type) -> List[Tuple[str, Callable]]:
     """Collect callable methods from *cls* (walking MRO) plus ``__ccflow_tokenizer_deps__``.
 
@@ -108,8 +147,9 @@ def _collect_methods(cls: type) -> List[Tuple[str, Callable]]:
     ``__call__`` overrides the base class's even if the subclass doesn't
     redefine every method.
 
-    Own methods are sorted alphabetically. Dependencies are sorted by
-    qualified name so that declaration order does not affect the hash.
+    Own methods are sorted alphabetically. Dependencies are merged across the
+    MRO, deduplicated, and sorted deterministically so that declaration order
+    does not affect the hash.
 
     Internal framework attributes (``__ccflow_*``) and pydantic/python
     boilerplate methods are skipped.
@@ -133,37 +173,44 @@ def _collect_methods(cls: type) -> List[Tuple[str, Callable]]:
 
     methods.sort(key=lambda pair: pair[0])
 
-    # Collect __ccflow_tokenizer_deps__ (also walk MRO, first definition wins)
-    extra_deps = None
+    # Collect __ccflow_tokenizer_deps__ from the full MRO. Subclasses may add
+    # deps without losing inherited ones.
+    deps = []
+    seen_dep_keys = set()
     for klass in cls.__mro__:
-        if "__ccflow_tokenizer_deps__" in klass.__dict__:
-            extra_deps = klass.__dict__["__ccflow_tokenizer_deps__"]
-            break
-
-    if extra_deps is not None:
-        deps = []
+        extra_deps = klass.__dict__.get("__ccflow_tokenizer_deps__")
+        if extra_deps is None:
+            continue
         for func in extra_deps:
             unwrapped = _unwrap_function(func) or func
-            if callable(unwrapped):
-                func_id = getattr(unwrapped, "__qualname__", getattr(unwrapped, "__name__", repr(unwrapped)))
-                deps.append((f"__dep__:{func_id}", func))
-        deps.sort(key=lambda pair: pair[0])
-        methods.extend(deps)
+            if not callable(unwrapped):
+                continue
+            dep_key = _dependency_sort_key(func)
+            if dep_key in seen_dep_keys:
+                continue
+            seen_dep_keys.add(dep_key)
+            deps.append((dep_key, func))
+
+    deps.sort(key=lambda pair: pair[0])
+    methods.extend((f"__dep__:{dep_key[1]}", func) for dep_key, func in deps)
 
     return methods
 
 
 def compute_behavior_token(cls: type) -> Optional[str]:
     """Compute a SHA-256 behavior token for *cls* based on its method bytecode.
 
-    The token captures bytecode (``co_code``) and constants (``co_consts``,
-    minus docstrings) of every method in *cls*'s MRO (with standard override
-    semantics), plus any standalone functions listed in
-    ``cls.__ccflow_tokenizer_deps__``.
+    The token captures behavior-relevant state for every method in *cls*'s MRO
+    (with standard override semantics): bytecode, constants (minus docstrings),
+    defaults, keyword-only defaults, and closure cell contents. It also
+    includes any standalone functions listed in ``cls.__ccflow_tokenizer_deps__``.
 
     Decorator chains (e.g. ``@Flow.call``) are automatically unwrapped so
     that the hash reflects the user's implementation, not the wrapper.
 
+    ``__ccflow_tokenizer_deps__`` values are merged across the full MRO, so
+    subclasses can add dependencies without dropping inherited ones.
+
     Results are cached on the class in ``cls.__behavior_token_cache__``.
     The cache is stored directly on the class (not inherited), so subclass
     tokens are independent of parent tokens.