feat(agent,scripting): client reuse + usage tracking (v2.51.204)

`agent.fetch` now inherits the engine's proxy-configured HTTP client
instead of using a process-wide static — scripts go through the same
proxy / TLS / headers as the rest of the agent. Per-call fetch + script
activity is tracked in lock-free atomics on the engine.

## Client reuse
* `ScriptEngine` gains a `default_client: reqwest::Client` field plus
  `with_client(...)` builder method.
* New per-call methods `run_python_with_client` and
  `run_javascript_with_client` accept an explicit client override.
* Chrome dispatcher (`run_embedded_script`) now reads
  `engine.client.clone()` (cheap — reqwest::Client is internally Arc'd)
  and routes through the `*_with_client` variant when set. Scripts
  inherit the agent's proxy without any extra wiring.
* `Job` carries the client into the worker; native `agent.fetch` hooks
  use that client instead of the static fallback. No more per-script
  client construction.

## Usage tracking
* New `ScriptUsage` struct with atomic counters: `scripts_run`,
  `scripts_timed_out`, `scripts_failed`, `fetch_calls`, `fetch_errors`,
  `fetch_bytes_in`.
* No mutexes — counters are `AtomicU64` with `Ordering::Relaxed` (we
  want monotonic activity totals, not synchronization).
* Engine exposes `usage_snapshot() -> ScriptUsageSnapshot` for plain-data
  reads + `usage_handle() -> Arc<ScriptUsage>` for live observation.

## Tests
All 20 scripting tests still pass (parallel + --test-threads=1).
cargo fmt + clippy clean across scripting + chrome+scripting.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: j-mendez

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "spider"
-version = "2.51.203"
+version = "2.51.204"
 authors = ["j-mendez <jeff@spider.cloud>"]
 description = "A web crawler and scraper, building blocks for data curation workloads."
 repository = "https://github.com/spider-rs/spider"

spider/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spider_agent"
-version = "2.51.203"
+version = "2.51.204"
 authors = ["j-mendez <jeff@spider.cloud>"]
 description = "A concurrent-safe multimodal agent for web automation and research."
 repository = "https://github.com/spider-rs/spider"
@@ -28,8 +28,8 @@ parking_lot = "0.12"
 base64 = "0.22"
 
 # Extracted types and HTML processing
-spider_agent_types = { version = "2.51.203", path = "../spider_agent_types" }
-spider_agent_html = { version = "2.51.203", path = "../spider_agent_html" }
+spider_agent_types = { version = "2.51.204", path = "../spider_agent_types" }
+spider_agent_html = { version = "2.51.204", path = "../spider_agent_html" }
 
 # HTML processing (still needed for engine internals)
 lol_html = "2"

spider_agent/Cargo.toml

@@ -5835,9 +5835,22 @@ async fn run_embedded_script(
     };
     let timeout = timeout_ms.map(std::time::Duration::from_millis);
 
-    let result = match action {
-        "RunPython" => script.run_python(code, ctx, timeout).await,
-        "RunJavaScript" => script.run_javascript(code, ctx, timeout).await,
+    // Inherit the agent's HTTP client (proxy / TLS / headers) so `agent.fetch`
+    // from inside the script doesn't bypass the configured outbound path.
+    // Cheap clone — reqwest::Client is Arc-internal.
+    let result = match (action, engine.client.clone()) {
+        ("RunPython", Some(client)) => {
+            script
+                .run_python_with_client(code, ctx, timeout, client)
+                .await
+        }
+        ("RunPython", None) => script.run_python(code, ctx, timeout).await,
+        ("RunJavaScript", Some(client)) => {
+            script
+                .run_javascript_with_client(code, ctx, timeout, client)
+                .await
+        }
+        ("RunJavaScript", None) => script.run_javascript(code, ctx, timeout).await,
         _ => return ActionOutcome::fail(action, "unreachable: action mismatch"),
     };
 

spider_agent/src/automation/browser.rs

@@ -34,6 +34,10 @@ struct CallState {
     runtime: tokio::runtime::Handle,
     sandbox: Option<Arc<SandboxedDir>>,
     allow_network: bool,
+    /// Engine-provided HTTP client (proxy/TLS config from `engine.client`).
+    client: reqwest::Client,
+    /// Process-wide usage counters; updated atomically by `agent.fetch`.
+    usage: Arc<super::ScriptUsage>,
 }
 
 thread_local! {
@@ -101,6 +105,8 @@ pub(crate) fn run(job: &Job) -> Result<ScriptResult, String> {
         runtime: job.runtime.clone(),
         sandbox: sandbox.clone(),
         allow_network: job.config.allow_network,
+        client: job.client.clone(),
+        usage: job.usage.clone(),
     });
 
     // Install per-call state; ensure it's cleared even on panic/early return.
@@ -373,9 +379,11 @@ fn js_fetch(_this: &JsValue, args: &[JsValue], ctx: &mut Context) -> JsResult<Js
     } else {
         FetchRequest::default()
     };
-    let resp = try_with_state(|s| agent_fetch_blocking(&s.runtime, &s.interrupt, &url, req))
-        .map_err(|_| state_missing_err())?
-        .map_err(|e| JsNativeError::error().with_message(e))?;
+    let resp = try_with_state(|s| {
+        agent_fetch_blocking(&s.client, &s.runtime, &s.interrupt, &s.usage, &url, req)
+    })
+    .map_err(|_| state_missing_err())?
+    .map_err(|e| JsNativeError::error().with_message(e))?;
     let resp_json = serde_json::to_value(&resp)
         .map_err(|e| JsNativeError::error().with_message(format!("serialize: {e}")))?;
     JsValue::from_json(&resp_json, ctx)