web-tool-fallback
Implement fallback strategies when web-reading tools fail simultaneously
- License 许可
- MIT
- 所属仓库
- HKUDS/AgentPilot
- 最近更新
- 2026-11-12
- Stars
- ★ 8.0k
- Forks
- 944
01 前言 Front Matter
- name
- web-tool-fallback
- description
- Implement fallback strategies when web-reading tools fail simultaneously
02 资源文件 1
- 其他.skill_id31 B
03 SKILL.md 正文
Web Tool Fallback Strategy
When to Use This Skill
Apply this skill when all web-reading tools (read_webpage, search_web) fail simultaneously with unknown errors during a research or information-gathering task.
Recognition Criteria
Confirm this pattern before applying fallbacks:
- Multiple web tool calls have failed (not just one isolated failure)
- Errors are unknown/unexpected (not expected 404s or rate limits that can be handled normally)
- The information is still needed to complete the task
Fallback Procedure
Critical: execute_code_sandbox may also fail during system-wide issues. Always be prepared to immediately fall back to run_shell if sandbox execution returns errors.
Step 1: Attempt Alternative Sources
Before abandoning web access, try these alternatives:
-
Alternative URLs:
- Archive.org / Wayback Machine versions
- Alternative domains (e.g., .org instead of .com)
- Different subdomains or paths
-
Simplified Requests:
- Try reading just the domain root
- Remove query parameters from URLs
- Try HTTP instead of HTTPS (or vice versa)
# Example: Generate alternative URL formats
original_url = "https://example.com/research/report?id=123"
alternatives = [
"https://example.com/research/report",
"http://example.com/research/report?id=123",
"https://web.archive.org/web/*/https://example.com/research/report"
]
Step 2: Use execute_code_sandbox for Embedded Knowledge
Step 2: Use execute_code_sandbox for Embedded Knowledge (May Fail)
When web access is unavailable, generate content from reliable embedded knowledge. Note: execute_code_sandbox can fail during cascading system issues—if it returns errors, immediately proceed to Step 2b.
code = '''
# Generate structured information from embedded knowledge
evaluation_frameworks = {
"Kirkpatrick Model": ["Reaction", "Learning", "Behavior", "Results"],
"Bloom's Taxonomy": ["Remember", "Understand", "Apply", "Analyze", "Evaluate", "Create"],
"SMART Criteria": ["Specific", "Measurable", "Achievable", "Relevant", "Time-bound"]
}
# Create comprehensive reference material
for framework, levels in evaluation_frameworks.items():
print(f"## {framework}\\n")
for i, level in enumerate(levels, 1):
print(f"{i}. {level}")
print()
'''
If execute_code_sandbox returns any error (unknown error, timeout, execution failure):
- Do not retry execute_code_sandbox multiple times
- Immediately proceed to Step 2b (run_shell fallback)
- Document the sandbox failure in your Research Access Notes
- Established frameworks and methodologies
- Standard best practices
- Well-documented technical concepts
- Historical information that doesn't change frequently
### Step 2b: Fall Back to run_shell if execute_code_sandbox Fails
### Step 2b: Fall Back to run_shell if execute_code_sandbox Fails (REQUIRED)
**When to use**: execute_code_sandbox returns any error OR fails to produce output within reasonable time.
**Action**: Immediately switch to run_shell with direct Python execution. Do not continue attempting execute_code_sandbox.
1. **Use run_shell with direct Python execution** (simplest, most reliable):
1. **Use run_shell with direct Python execution**:
```bash
python3 -c "print('content from embedded knowledge')"
-
Use heredoc for multi-line scripts:
python3 << 'EOF' # Your Python code here frameworks = {"Kirkpatrick": ["Reaction", "Learning", "Behavior", "Results"]} for name, levels in frameworks.items(): print(f"## {name}") for level in levels: print(f"- {level}") EOF -
Capture output to file for further processing:
python3 -c "print('structured content')" > output.txt
Why run_shell works when execute_code_sandbox fails:
- Direct system Python execution bypasses sandbox restrictions
- No additional abstraction layer that could fail
- More reliable during cascading tool failures
- Should be your go-to when sandbox is compromised
Step 3: Create Document with Placeholder Citations
For tasks requiring formal documentation:
- Draft the document using available knowledge
- Mark uncertain citations clearly:
[WEB_ACCESS_LIMITED: URL https://example.com/source could not be accessed] - Use placeholder format for references:
[Reference needed: Topic - URL attempted but inaccessible]
Step 4: Document the Limitation for Stakeholders
Always create a transparent "Research Access Notes" section:
## Research Access Notes
**Access Limitation**: All web-reading tools failed simultaneously during research.
**Fallback Actions Taken**:
- [ ] Attempted alternative URLs: [Yes/No]
- [ ] Used embedded knowledge generation: [Yes/No]
- [ ] Created placeholders for citations: [Yes/No]
**Confidence Level**: [High/Medium/Low] - based on reliance on embedded knowledge vs. current web sources
**Recommendation**: Verify critical claims with current web sources when access is restored.
Decision Tree
All web tools failed?
├─ Yes → Try alternative URLs
│ ├─ Success → Complete task normally
│ └─ Failed → Can content be generated from embedded knowledge?
│ ├─ Yes → Try execute_code_sandbox (expect potential failure)
│ │ ├─ Success → Use output + document limitation
│ │ └─ Failed/Errors → **IMMEDIATELY** use run_shell + document limitation
│ └─ No → Create document with placeholders + notify Executive Director
│ └─ No → Create document with placeholders + notify Executive Director
└─ No → Handle individual failures normally
Task-Type Adaptations
| Task Type | Primary Fallback | Documentation Required |
|---|---|---|
| Research/Analysis | execute_code_sandbox | Access notes section |
| Document Creation | Placeholder citations | Limitation notice to Executive Director |
| Time-Sensitive | Proceed with available methods | Brief limitation note |
| Compliance/Legal | Escalate immediately | Full access failure report |
Example Application
# When gathering reference materials fails
try:
# Primary: read_webpage attempts (all failed)
pass
except:
# Fallback 1: Try alternative sources
alternative_content = execute_code_sandbox(generate_from_knowledge())
# Fallback 2: Create document with transparency
document = create_with_placeholders(
content=alternative_content,
citation_markers="[WEB_ACCESS_LIMITED]",
stakeholder_note="Executive Director: Web access unavailable, content from embedded knowledge"
)
Best Practices
- Be transparent: Always document when web access failed
- Preserve attempt records: Note which URLs/tools failed for future reference
- Distinguish knowledge types: Clearly separate embedded knowledge from current web-sourced information
- Prioritize critical info: If certain information is essential and cannot be generated, escalate rather than guess
- Enable verification: Make it easy for stakeholders to verify claims when access is restored
- Never stack failures: If execute_code_sandbox fails once, switch to run_shell immediately—do not retry the sandbox multiple times
- Complete all steps: Step 4 (Document Limitation) is mandatory, not optional—even if fallback succeeds
04 同仓库更多 Skills
agentpilot
Set up AgentPilot and use its single entry to prepare missing inputs and run configured RSI experiments. Use when the user requests AgentPilot installation or work with AgentPilot.
remember
Review auto-memory entries and propose promotions to OPENSPACE.md, OPENSPACE.local.md, or retained auto-memory topics; detect duplicates, stale facts, conflicts, and ambiguous entries before making changes.
skill-discovery
Search reusable OpenSpace skills locally, and browse cloud packages step by step when a cloud skill may help. Reusing proven skills saves tokens, improves reliability, and extends your capabilities beyond built-in tools.
delegate-task
Delegate tasks to OpenSpace — a full-stack autonomous worker for coding, DevOps, web research, and desktop automation, backed by an extensive MCP tool and skill library. Skills auto-improve through use, reducing token consumption over time. A cloud community lets agents share and collectively evolve reusable skills.
write-special-chars-ts-check
Workaround for write_file failures caused by special characters (apostrophes, backticks, template literals) using a Python heredoc script, plus a reliable TypeScript type-checking step that filters output to only the newly-written files to avoid being misled by pre-existing errors.
write-special-chars-readback
Workaround for write_file failures caused by special characters (apostrophes, backticks, template literals) using a Python heredoc script, with mandatory post-write verification via read_file and cleanup of /tmp helper scripts.