chore: update OpenAPI v3 spec + llms.txt for cache_script (#115)

- Pull latest v3 OpenAPI spec from production (includes cacheScript field)
- Regenerate llms.txt and llms-full.txt (includes Deterministic rerun page)

Co-authored-by: MagMueller <MagMueller@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: MagMueller

docs/cloud/llms-full.txt

@@ -474,7 +474,7 @@ for f in files.files:
 print(f.path, f.size)
 
 # Delete a single file
-await client.workspaces.delete_file(workspace.id, "old-report.pdf")
+await client.workspaces.delete_file(workspace.id, path="old-report.pdf")
 
 # Check workspace storage usage
 size = await client.workspaces.size(workspace.id)
@@ -498,6 +498,238 @@ You can also manage workspaces from [cloud.browser-use.com/settings](https://clo
   Deleting a workspace permanently removes all its files. This cannot be undone.
 
 
+# Deterministic rerun
+Source: https://docs.browser-use.com/cloud/agent/cache-script
+
+
+Deterministic rerun lets you run a browser task once with a full agent, then **re-execute the same task instantly** using a cached script — no LLM, up to 99% cheaper.
+
+## Quick start
+
+Use `{{double brackets}}` around values that can change between runs. The first call runs the full agent. Every subsequent call with the same template uses the cached script.
+
+```python Python
+from browser_use_sdk.v3 import AsyncBrowserUse
+
+client = AsyncBrowserUse()
+workspace = await client.workspaces.create(name="my-scraper")
+
+# First call — agent explores, creates script (~$0.10, ~60s)
+result = await client.run(
+"Get the top {{5}} stories from https://news.ycombinator.com as JSON",
+workspace_id=str(workspace.id),
+)
+
+# Second call — cached script, different param ($0 LLM, ~5s)
+result2 = await client.run(
+"Get the top {{10}} stories from https://news.ycombinator.com as JSON",
+workspace_id=str(workspace.id),
+)
+```
+```typescript TypeScript
+import { BrowserUse } from "browser-use-sdk/v3";
+
+const client = new BrowserUse();
+const workspace = await client.workspaces.create({ name: "my-scraper" });
+
+// First call — agent explores, creates script (~$0.10, ~60s)
+const result = await client.run(
+  "Get the top {{5}} stories from https://news.ycombinator.com as JSON",
+  { workspaceId: workspace.id },
+);
+
+// Second call — cached script, different param ($0 LLM, ~5s)
+const result2 = await client.run(
+  "Get the top {{10}} stories from https://news.ycombinator.com as JSON",
+  { workspaceId: workspace.id },
+);
+```
+
+## How it works
+
+The brackets mark which parts are parameters:
+
+```
+"Get prices from {{example.com}} for {{electronics}}"
+```
+
+- `{{example.com}}` → parameter 1
+- `{{electronics}}` → parameter 2
+
+The system strips the values to create a **template**: `"Get prices from {{}} for {{}}"`.
+Template `"Get prices from {{}} for {{}}"` is hashed to a unique ID like `a7f3b2c1`.
+The system checks the workspace for `scripts/a7f3b2c1.py`.
+If no script exists, the full agent runs your task. After completing it, the agent saves a standalone Python script that reproduces the result deterministically — no AI needed.
+If the script exists, it runs directly with the new parameter values. No agent, no LLM. Just the script in a sandbox with browser and proxy.
+
+## Auto-detection
+
+Caching activates **automatically** when both conditions are met:
+- The task contains `{{` and `}}`
+- A `workspace_id` is provided
+
+No extra flags needed. You can override with `cache_script`:
+
+| Value | Behavior |
+|-------|----------|
+| `None` (default) | Auto-detect from `{{brackets}}` + workspace |
+| `True` | Force-enable, even without brackets |
+| `False` | Force-disable, even if brackets are present |
+
+## Examples
+
+### Parameterized scraping
+
+Run once, then loop over different keywords at $0 LLM each:
+
+```python Python
+# Agent figures out how to scrape intro.co on first call
+result = await client.run(
+"Go to {{https://intro.co/marketplace}} and get all {{logistics}} experts as JSON",
+workspace_id=str(workspace.id),
+)
+
+# Instant reruns with different keywords
+for keyword in ["CEO", "marketing", "finance", "e-commerce"]:
+result = await client.run(
+    f"Go to {{{{https://intro.co/marketplace}}}} and get all {{{{{keyword}}}}} experts as JSON",
+    workspace_id=str(workspace.id),
+)
+print(f"{keyword}: {len(result.output)} experts, LLM cost: ${result.llm_cost_usd}")
+```
+```typescript TypeScript
+// Agent figures out how to scrape intro.co on first call
+let result = await client.run(
+  "Go to {{https://intro.co/marketplace}} and get all {{logistics}} experts as JSON",
+  { workspaceId: workspace.id },
+);
+
+// Instant reruns with different keywords
+for (const keyword of ["CEO", "marketing", "finance", "e-commerce"]) {
+  result = await client.run(
+`Go to {{https://intro.co/marketplace}} and get all {{${keyword}}} experts as JSON`,
+{ workspaceId: workspace.id },
+  );
+  console.log(`${keyword}: ${result.output.length} experts`);
+}
+```
+
+### No parameters — cache the exact task
+
+Append empty brackets `{{}}` to signal "cache this exact task":
+
+```python Python
+result = await client.run(
+"Get the current Bitcoin price from coinmarketcap.com {{}}",
+workspace_id=str(workspace.id),
+)
+
+# Same task again — cached
+result2 = await client.run(
+"Get the current Bitcoin price from coinmarketcap.com {{}}",
+workspace_id=str(workspace.id),
+)
+```
+```typescript TypeScript
+let result = await client.run(
+  "Get the current Bitcoin price from coinmarketcap.com {{}}",
+  { workspaceId: workspace.id },
+);
+
+// Same task again — cached
+result = await client.run(
+  "Get the current Bitcoin price from coinmarketcap.com {{}}",
+  { workspaceId: workspace.id },
+);
+```
+
+### Multiple parameters
+
+```python Python
+result = await client.run(
+"Go to https://help.netflix.com/en/node/24926/ax and get subscription prices for {{Germany,France,Japan}}",
+workspace_id=str(workspace.id),
+)
+
+# Different countries — cached
+result2 = await client.run(
+"Go to https://help.netflix.com/en/node/24926/ax and get subscription prices for {{US,UK,Brazil}}",
+workspace_id=str(workspace.id),
+)
+```
+```typescript TypeScript
+let result = await client.run(
+  "Go to https://help.netflix.com/en/node/24926/ax and get subscription prices for {{Germany,France,Japan}}",
+  { workspaceId: workspace.id },
+);
+
+// Different countries — cached
+result = await client.run(
+  "Go to https://help.netflix.com/en/node/24926/ax and get subscription prices for {{US,UK,Brazil}}",
+  { workspaceId: workspace.id },
+);
+```
+
+### Force enable / disable
+
+```python Python
+# Force-enable without brackets
+result = await client.run(
+"Get the top stories from Hacker News",
+workspace_id=str(workspace.id),
+cache_script=True,
+)
+
+# Force-disable even with brackets
+result = await client.run(
+"Explain what {{templates}} means in Jinja",
+workspace_id=str(workspace.id),
+cache_script=False,
+)
+```
+```typescript TypeScript
+// Force-enable without brackets
+let result = await client.run(
+  "Get the top stories from Hacker News",
+  { workspaceId: workspace.id, cacheScript: true },
+);
+
+// Force-disable even with brackets
+result = await client.run(
+  "Explain what {{templates}} means in Jinja",
+  { workspaceId: workspace.id, cacheScript: false },
+);
+```
+
+## Inspecting cached scripts
+
+You can download and inspect the scripts the agent created:
+
+```python Python
+files = await client.workspaces.files(workspace.id, prefix="scripts/")
+for f in files.files:
+print(f"{f.path}  ({f.size} bytes)")
+
+# Download a script to inspect it
+await client.workspaces.download(workspace.id, "scripts/a7f3b2c1.py", to="./my_script.py")
+```
+```typescript TypeScript
+const files = await client.workspaces.files(workspace.id, { prefix: "scripts/" });
+for (const f of files.files) {
+  console.log(`${f.path}  (${f.size} bytes)`);
+}
+```
+
+## Cost comparison
+
+| | LLM cost | Browser + proxy | Time |
+|---|---|---|---|
+| First call (agent) | ~$0.05–1.00 | Yes | ~30–120s |
+| Cached calls | **$0** | Yes | ~3–10s |
+
+The browser and proxy still run for cached calls (the script may need them), so there is a small infrastructure cost per execution. LLM cost drops to zero.
+
+
 # Human in the loop
 Source: https://docs.browser-use.com/cloud/agent/human-in-the-loop
 

docs/cloud/llms.txt

@@ -31,6 +31,7 @@ export BROWSER_USE_API_KEY=bu_your_key_here
 - [Follow-up tasks](https://docs.browser-use.com/cloud/agent/follow-up-tasks): Run multiple tasks in the same browser session.
 - [Live messages](https://docs.browser-use.com/cloud/agent/streaming): Stream the agent's messages in real time to build custom UIs or monitor progress.
 - [Workspaces & files](https://docs.browser-use.com/cloud/agent/workspaces): Upload files for the agent, download files the agent creates.
+- [Deterministic rerun](https://docs.browser-use.com/cloud/agent/cache-script): Run a task once, then re-execute it for $0 LLM cost.
 - [Human in the loop](https://docs.browser-use.com/cloud/agent/human-in-the-loop): Let a human interact with the live browser while the agent is running. Useful for approvals, payments, complex auth flows, or reviewing agent work before continuing.
 
 ## Browser