hyf

commit f5afdc928760ac7e83b1487e7d27a6383ce068fc
parent f22f74cd33d5a8735204a650603c2cc16f0056b7
Author: triesap <tyson@radroots.org>
Date:   Mon, 15 Jun 2026 13:50:36 -0700

provider: mark unsupported assisted fallbacks

- preserve deterministic output for assisted capabilities outside the provider surface

- attach provider_runtime unsupported_capability fallback provenance

- cover assisted semantic_rank fallback behavior on the stdio wire

Diffstat:
M
src/hyf_stdio/provider_execution.mojo
 | 
33
+++++++++++++++++++++++++++++++--
M
tests/test_stdio_contract.mojo
 | 
54
++++++++++++++++++++++++++++++++++++++++++++++++++++++

2 files changed, 85 insertions(+), 2 deletions(-)
diff --git a/src/hyf_stdio/provider_execution.mojo b/src/hyf_stdio/provider_execution.mojo
@@ -24,6 +24,7 @@ from hyf_core.errors import (
 from hyf_core.provenance import (
     CoreResponseMeta,
     ExecutionProvenance,
+    ProvenanceFallback,
     ProvenanceSourceRef,
 )
 from hyf_core.request_context import (
@@ -168,6 +169,30 @@ def _query_rewrite_fallback(
         return failed_capability(invalid_input_error(String(e)))
 
 
+def _with_deterministic_assisted_fallback_meta(
+    result: CapabilityResult, fallback_kind: String, reason: String
+) -> CapabilityResult:
+    if not result.success:
+        return result.copy()
+
+    var success = result.success.value().copy()
+    if not success.meta:
+        return result.copy()
+
+    var meta = success.meta.value().copy()
+    if not meta.provenance:
+        return result.copy()
+
+    var provenance = meta.provenance.value().copy()
+    provenance.fallback = Optional[ProvenanceFallback](
+        ProvenanceFallback(
+            fallback_kind=String(fallback_kind), reason=String(reason)
+        )
+    )
+    meta.provenance = Optional[ExecutionProvenance](provenance^)
+    return successful_capability(success.output, meta=meta^)
+
+
 def _execute_query_rewrite_with_provider(
     input: Value,
     context: RequestContext,
@@ -230,6 +255,10 @@ def execute_runtime_aware_business_capability(
 
     var deterministic_context = context.copy()
     deterministic_context.execution_mode_preference = "deterministic"
-    return execute_backend_capability(
-        capability_id, input, deterministic_context
+    return _with_deterministic_assisted_fallback_meta(
+        execute_backend_capability(
+            capability_id, input, deterministic_context
+        ),
+        "provider_runtime",
+        "unsupported_capability",
     )
diff --git a/tests/test_stdio_contract.mojo b/tests/test_stdio_contract.mojo
@@ -84,6 +84,16 @@ def _query_rewrite_assisted_request_json(request_id: String) -> String:
     )
 
 
+def _semantic_rank_assisted_request_json(request_id: String) -> String:
+    return (
+        '{"version":1,"request_id":"'
+        + request_id
+        + '","trace_id":"'
+        + request_id
+        + '","capability":"semantic_rank","context":{"execution_mode_preference":"assisted","return_provenance":true},"input":{"query":"apples near me with weekend pickup","candidates":[{"id":"listing_local_1","title":"Organic apples","farm":"Local Orchard","delivery":"pickup","distance_km":4.1,"freshness_minutes":3},{"id":"listing_regional_1","title":"Honeycrisp apples","farm":"Regional Orchard","delivery":"delivery","distance_km":28.0,"freshness_minutes":25}]}}'
+    )
+
+
 def _assert_query_rewrite_provider_fallback(
     mode: String, expected_reason: String, request_timeout_ms: Int
 ) raises:
@@ -1065,6 +1075,50 @@ def test_query_rewrite_falls_back_deterministically_when_provider_is_unavailable
                 )
 
 
+def test_assisted_semantic_rank_falls_back_as_unsupported_provider_capability() raises:
+    with TemporaryDirectory() as temp_dir:
+        var startup_config_path = Path(temp_dir) / "explicit-hyf-config.toml"
+        startup_config_path.write_text(
+            _unavailable_max_local_runtime_config_toml()
+        )
+        with ScopedEnvVar(HYF_PATHS_PROFILE_ENV, "repo_local"):
+            with ScopedEnvVar(HYF_PATHS_REPO_LOCAL_ROOT_ENV, temp_dir):
+                var response = run_stdio_entrypoint(
+                    "src/main.mojo",
+                    _semantic_rank_assisted_request_json(
+                        "rank-assisted-unsupported-1"
+                    ),
+                    "--config",
+                    startup_config_path.__fspath__(),
+                )
+
+                assert_true(response["ok"].bool_value())
+                assert_equal(
+                    response["meta"]["execution_mode"].string_value(),
+                    "deterministic",
+                )
+                assert_equal(
+                    response["meta"]["backend"].string_value(),
+                    "heuristic",
+                )
+                assert_true(not _has_key(response["meta"], "provider"))
+                assert_equal(
+                    response["meta"]["provenance"]["fallback"][
+                        "fallback_kind"
+                    ].string_value(),
+                    "provider_runtime",
+                )
+                assert_equal(
+                    response["meta"]["provenance"]["fallback"]["reason"]
+                    .string_value(),
+                    "unsupported_capability",
+                )
+                assert_equal(
+                    response["output"]["ranked_ids"][0].string_value(),
+                    "listing_local_1",
+                )
+
+
 def test_query_rewrite_uses_max_local_provider_when_ready() raises:
     with TemporaryDirectory() as temp_dir:
         var provider_port = reserve_loopback_port()