wally browser-use: a Rust browser agent that stops before payment

.gitattributes

@@ -9,3 +9,9 @@ contracts/wally-decisions-public-v1.openapi.json -text
 # The golden CLI corpus is compared byte for byte (tests/cli_golden.rs and
 # cli_formatter's own fixture tests); a CRLF checkout would fail every case.
 tests/golden/** -text
+# browser-use sends these prompts to the decision model and its tests compare
+# the request byte for byte with one recorded live; a CRLF checkout would
+# change both. The page scripts and recorded fixtures stay LF for the same reason.
+src/browser/prompts/*.txt -text
+src/browser/js/*.js -text
+tests/fixtures/browser/** -text

Cargo.toml

@@ -55,6 +55,9 @@ sha2 = "0.10"
 hex = "0.4"
 getrandom = "0.3"
 ctrlc = { version = "3", features = ["termination"] }
+# browser-use drives Chrome over its DevTools WebSocket. Sync, and no TLS:
+# DevTools listens on plain ws:// at loopback only.
+tungstenite = { version = "0.30", default-features = false, features = ["handshake"] }
 # Upstream response decompression (src/net/decompress.rs), matching the four
 # encodings cpp-httplib's Accept-Encoding advertises and decodes: gzip and
 # zlib-wrapped deflate share flate2's rust_backend (miniz_oxide) -- pure Rust,

contracts/generate_console_binding.py

@@ -43,7 +43,7 @@
 # Rust 2021 reserved/keyword identifiers among this contract's field names.
 # Escaped as a raw identifier (`r#type`) everywhere the field is named; the
 # wire key ("type") is untouched.
-RUST_KEYWORDS = {"type"}
+RUST_KEYWORDS = {"type", "true", "false"}
 
 
 def _snake_to_pascal(name: str) -> str:
@@ -65,9 +65,11 @@ def _resolve_type(schema: dict, schemas: dict) -> tuple[str, bool]:
     if "$ref" in schema:
         name = schema["$ref"].split("/")[-1]
         target = schemas.get(name, {})
+        if _is_free_form(target):
+            return "Value", False
         # Constrained scalar aliases have no emitted type of their own -- only
         # objects, unions and enums get one -- so inline their primitive.
-        if target.get("type") in {"string", "integer", "number", "boolean"} and "enum" not in target:
+        if target.get("type") in {"string", "integer", "number", "boolean", "array"} and "enum" not in target:
             return _resolve_type(target, schemas)
         return name, False
     if "const" in schema:
@@ -88,6 +90,8 @@ def _resolve_type(schema: dict, schemas: dict) -> tuple[str, bool]:
     # JSON Schema nullable form `type: ["integer", "null"]`: strip the null,
     # resolve the remaining type, and mark it optional. Same meaning as an
     # anyOf-with-null, just spelled the compact way OpenAPI 3.1 emits.
+    if _is_free_form(schema):
+        return "Value", False
     if isinstance(kind, list):
         non_null = [t for t in kind if t != "null"]
         had_null = "null" in kind
@@ -126,6 +130,14 @@ def _resolve_type(schema: dict, schemas: dict) -> tuple[str, bool]:
     raise SystemExit(f"unsupported schema shape: {schema}")
 
 
+def _is_free_form(schema: dict) -> bool:
+    """Any JSON value: `type` lists two or more non-null types (System One's
+    state, guidance and instructions). Carried as `serde_json::Value`; the
+    schema's size bounds are the server's to enforce."""
+    kind = schema.get("type")
+    return isinstance(kind, list) and len([t for t in kind if t != "null"]) > 1
+
+
 def _is_enum(schema: dict) -> bool:
     return "enum" in schema and schema.get("type") == "string"
 
@@ -137,6 +149,8 @@ def _to_value_expr(base: str, var: str, enums: set[str], objects: set[str], is_r
     (de)ref either way; only `Value::from`/`Value::Bool`, which take an owned
     primitive by value, need an explicit deref when `var` is a reference.
     """
+    if base == "Value":
+        return f"{var}.clone()"
     if base == "String":
         return f"Value::String({var}.clone())"
     if base == INT:
@@ -164,6 +178,8 @@ def _to_value_expr(base: str, var: str, enums: set[str], objects: set[str], is_r
 
 
 def _from_value_expr(base: str, var: str, enums: set[str], objects: set[str]) -> str:
+    if base == "Value":
+        return f"{var}.clone()"
     if base == "String":
         return f'{var}.as_str().ok_or_else(|| "expected a string".to_string())?.to_string()'
     if base == INT:
@@ -273,6 +289,10 @@ def _emit_struct(name: str, schema: dict, schemas: dict, enums: set[str], object
     props = schema.get("properties", {})
     fields = []
     for prop, pschema in props.items():
+        if pschema.get("type") == "null":
+            # A field the contract names only to forbid (`type: null`): never
+            # sent, so it gets no Rust field.
+            continue
         base, nullable = _resolve_type(pschema, schemas)
         optional = nullable or prop not in required
         rust_type = f"Option<{base}>" if optional else base

contracts/sync_from_inferenceinfra.py

@@ -27,6 +27,7 @@
 EXTRACT = ROOT / "wally-cli-v1.openapi.json"
 DECISIONS_CONTRACT = ROOT / "wally-decisions-public-v1.openapi.json"
 DECISIONS_BINDING = REPO / "src" / "account" / "decisions_contract.rs"
+SYSTEMONE_BINDING = REPO / "src" / "account" / "systemone_contract.rs"
 CONTROL_PLANE = "contracts/control-plane-v1.openapi.json"
 # The two files a sync regenerates from scratch. Named once so the destination
 # guard and the error message cannot drift apart.
@@ -120,6 +121,19 @@ def check_local(extract: Path = EXTRACT) -> None:
             "createDecisions",
         ]
     )
+    _run(
+        [
+            sys.executable,
+            str(GENERATOR),
+            "--check",
+            "--contract",
+            str(DECISIONS_CONTRACT),
+            "--output",
+            str(SYSTEMONE_BINDING),
+            "--operation-id",
+            "createSystemOne",
+        ]
+    )
     print(f"Wally CLI lock OK ({stamp})")
 
 

src/account/mod.rs

@@ -10,6 +10,7 @@ pub mod decisions_contract;
 pub mod decisions_output;
 pub mod model_cache;
 pub mod session;
+pub mod systemone_contract;
 pub mod usage_requests;
 
 pub use cancel_worker::*;