single-live-call-hardening

Safely introduce exactly one live LLM API call into a running simulation with hard limits, operator checkpoint, batch blocking, and fallback validation

Ir para a instalação

Repositório: vortsghost2025/Genesis-Kernel-First-Humans-World-Sim
Última atividade na origem: 30 de maio de 2026 às 17:52
Idioma detectado do SKILL.md: inglês
Estrelas: 1
Forks: 0

Opções de instalação

Por padrão, está selecionado o prompt que primeiro revisa a origem. Você pode mudar para um comando direto ou baixar uma cópia local.

Revise os arquivos de origem

Leia o SKILL.md e os arquivos complementares exibidos pelo SkillsMP antes de decidir se vai instalar.

Voltar à pesquisa Voltar à instalação

name	single-live-call-hardening
description	Safely introduce exactly one live LLM API call into a running simulation with hard limits, operator checkpoint, batch blocking, and fallback validation
source	auto-skill
extracted_at	2026-05-30T06:06:53.500Z

Single Live Call Hardening

When moving from dry-run/mock to a real live LLM API call inside a simulation, introduce exactly one live call with hard limits, manual operator approval, and batch blocking. Never switch multiple agents live at once.

Provider Mode Progression

mock → nim-dry-run → nim-live-disabled → nim-live-adam-single → nim-live-eve-single → nim-live-both

Each step is validated independently before proceeding to the next.

Procedure

1. Add the single-live provider mode

PROVIDER_MODES = ("mock", "nim-dry-run", "nim-live-disabled", "nim-live-adam-single")

2. Implement live call with hard limit

class NvidiaNimProvider(BaseProvider):
    def __init__():
        ._mode = mode
        ._live_call_count = 
        ._max_live_calls =   mode ==   

     ():
        api_key = os.environ.get(._api_key_env, )

         ._mode == :
             ._live_single_call(prompt, agent, tick, api_key)
        

     ():
        
         ._live_call_count >= ._max_live_calls:
            call_log.record(..., success=, error=)
             json.dumps({: , : })

          api_key:
            call_log.record(..., success=, error=)
             json.dumps({: , : })

        
        payload = {
            : ._model,
            : [{: , : prompt}],
            : ,
            : ,
            : {: },
        }

        
        :
            url = 
            data = json.dumps(payload).encode()
            req = urllib.request.Request(url, data=data, method=)
            req.add_header(, )
            req.add_header(, )

             urllib.request.urlopen(req, timeout=)  response:
                raw = response.read().decode()
                result = json.loads(raw)

            
            content = result[][][][]

            
            ._live_call_count += 
            call_log.record(..., success=, latency_ms=...)
            logger.info(, ...)

             content

         Exception  e:
            call_log.record(..., success=, error=)
            logger.error(, ...)

def print_operator_checkpoint(self):
    print("\n" + "=" * 60)
    print("LIVE_CALL_ARMED:")
    print(f"  agent: Adam")
    print(f"  provider: NVIDIA NIM")
    print(f"  mode: {self._mode}")
    print(f"  model: {self._model}")
    print(f"  max_calls: {self._max_live_calls}")
    print(f"  live_calls_used: {self._live_call_count}")
    print(f"  eve_provider: mock")
    print(f"  batch_ticks: disabled")
    print(f"  operator_approval_required: true")
    print("=" * 60)

@app.post("/api/run")
def run_ticks(count: int = 5):
    if config.provider_mode == "nim-live-adam-single":
        return {
            "status": "blocked",
            "message": "Batch ticks disabled in nim-live-adam-single mode.",
        }
    # ... normal batch logic

// In refresh(), check _live_mode flag from /api/state
if (state._live_mode) {
    document.getElementById('btn-run5').disabled = true;
    document.getElementById('btn-run20').disabled = true;
}

@app.get("/api/state")
def get_world_state():
    return {
        ...,
        "_live_mode": config.provider_mode == "nim-live-adam-single",
    }

# In agent._safe_generate():
raw_response = self.provider.generate(prompt, self.name, self.tick)
parsed = validator.validate_and_parse(raw_response, ...)

if parsed["valid"]:
    return parsed["thought"], parsed["action"], ...

# Invalid live output → fallback to mock
return self._mock_think_action(world) + (None, f"Invalid live output — fallback.")

logger.info(
    "NIM live call: agent=%s model=%s latency_ms=%.0f "
    "prompt_tokens=%s completion_tokens=%s total_tokens=%s "
    "key_present=true live_calls=%d/%d",
    agent, self._model, elapsed_ms,
    usage.get("prompt_tokens"),
    usage.get("completion_tokens"),
    usage.get("total_tokens"),
    self._live_call_count, self._max_live_calls,
)

@app.get("/api/live-proof")
def get_live_proof():
    live_calls = [c for c in call_log.calls if "live" in c.get("provider", "").lower()]
    return {
        "provider_summary": {
            "mode": config.provider_mode,
            "total_live_calls": len(live_calls),
            "live_successes": len([c for c in live_calls if c["success"]]),
            "live_failures": len([c for c in live_calls if not c["success"]]),
        },
        "event_provenance": event_log.summary(),
        "quarantine_summary": {
            "events": len(event_log.quarantined),
            "provider_outputs": output_quarantine.count(),
        },
        "live_call_details": live_calls[-5:],
    }

def test_live_mode_builds_and_sends_request():
    provider = NvidiaNimProvider(mode="nim-live-adam-single", api_key_env="TEST_KEY")
    os.environ["TEST_KEY"] = "sk-test-key"

    with patch("urllib.request.urlopen") as mock_urlopen:
        mock_urlopen.return_value = _mock_nim_response()
        response = provider.generate("test", "Adam", 1)

    assert mock_urlopen.called, "urlopen should be called"
    assert provider.live_call_count == 1
    del os.environ["TEST_KEY"]

def test_batch_ticks_blocked_in_live_mode():
    provider = NvidiaNimProvider(mode="nim-live-adam-single", ...)
    # First call succeeds
    provider.generate("test", "Adam", 1)
    assert provider.live_call_count == 1

    # Second call blocked
    response = provider.generate("test", "Adam", 2)
    assert "limit" in json.loads(response)["thought"].lower()
    assert provider.live_call_count == 1  # Still 1

def test_eve_stays_mock_in_live_mode():
    adam.set_provider(NvidiaNimProvider(mode="nim-live-adam-single", ...))
    eve.set_provider(MockProvider(name="eve_mock"))
    # Run tick — verify Adam live, Eve mock
    assert isinstance(eve.provider, MockProvider)