AGENT SKILL

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

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:

  1. Alternative URLs:

    • Archive.org / Wayback Machine versions
    • Alternative domains (e.g., .org instead of .com)
    • Different subdomains or paths
  2. 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')"
  1. 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
    
  2. 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:

  1. Draft the document using available knowledge
  2. Mark uncertain citations clearly:
    [WEB_ACCESS_LIMITED: URL https://example.com/source could not be accessed]
    
  3. 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

  1. Be transparent: Always document when web access failed
  2. Preserve attempt records: Note which URLs/tools failed for future reference
  3. Distinguish knowledge types: Clearly separate embedded knowledge from current web-sourced information
  4. Prioritize critical info: If certain information is essential and cannot be generated, escalate rather than guess
  5. Enable verification: Make it easy for stakeholders to verify claims when access is restored
  6. Never stack failures: If execute_code_sandbox fails once, switch to run_shell immediately—do not retry the sandbox multiple times
  7. Complete all steps: Step 4 (Document Limitation) is mandatory, not optional—even if fallback succeeds

04 同仓库更多 Skills

HKUDS
HKUDS/AgentPilot

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.

★ 8.0k
HKUDS
HKUDS/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.

★ 8.0k
HKUDS
HKUDS/AgentPilot

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.

Skill与智能体开发
★ 8.0k
HKUDS
HKUDS/AgentPilot

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.

Skill与智能体开发
★ 8.0k
HKUDS
HKUDS/AgentPilot

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.

★ 8.0k
HKUDS
HKUDS/AgentPilot

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.

★ 8.0k