@ponythewhite/base-context 1.0.0 → 1.0.2

package/skills/prime-intellect/references/environments.md

@@ -1,73 +0,0 @@
-# Environments, Evaluations & Training
-
-verifiers is Prime Intellect's Python library for LLM environments: packages that expose `load_environment` and bundle datasets, rollout logic, and reward rubrics. Environments power evaluations (local and hosted) and RL training (Hosted Training or self-managed prime-rl).
-
-Live docs: `verifiers/overview.md`, `tutorials-environments/getting-started.md`, `hosted-training/getting-started.md`, `prime-rl/overview.md` under https://docs.primeintellect.ai/ (append `.md` for raw markdown). Source: https://github.com/PrimeIntellect-ai/verifiers and https://github.com/PrimeIntellect-ai/prime-rl
-
-## Discovering Environments (Hub)
-
-```bash
-prime env list --search "math" --owner primeintellect --show-actions
-prime env list --tag tools --tag sandbox
-prime env list --mine
-prime env list --starred
-prime env info owner/name        # metadata, version, dependencies
-prime env status owner/name      # CI/action status
-prime env pull owner/name -t ./tmp-env   # pull source for inspection
-prime env install owner/name     # install locally
-```
-
-When picking candidates, prefer: `primeintellect`-owned, passing latest actions, updated within ~2 months, recent verifiers versions. Compare task type (single-turn, multi-turn, tool, sandbox, agent), reward type (binary, continuous, judge-based), and dependency/secret requirements.
-
-## Creating Environments
-
-```bash
-prime env init my-env --v1       # scaffold (add --with-harness for an explicit reusable harness)
-prime env install my-env
-prime eval run my-env -m openai/gpt-4.1-mini -n 5   # smoke test immediately
-prime env push                   # publish to the Hub
-```
-
-Build guidance:
-
-- Define the task contract first: prompt shape, allowed tools, stop conditions, rubric outputs, metrics.
-- Prefer starting from an existing Hub environment (`prime env list --search`, then `prime env install owner/name`) over building from scratch.
-- v1 environments expose `load_environment(config: vf.EnvConfig) -> vf.Env`; Taskset + Harness environments additionally expose `load_taskset(config)` and optionally `load_harness(config)` with `load_environment` delegating through `vf.load_taskset`/`vf.load_harness`.
-- The environment must install, load, evaluate, and train without hidden setup.
-
-## Evaluations
-
-`prime eval run` is the canonical eval path. Runs save automatically (visible in the Evaluations tab and `prime eval view`); do not add `--skip-upload` unless the user explicitly asks.
-
-```bash
-prime eval run my-env -m openai/gpt-4.1-mini -n 5               # smoke
-prime eval run owner/env -m openai/gpt-4.1-mini -n 200 -r 3 --shuffle -s   # scaled
-prime eval run owner/env --hosted --follow                       # hosted, streaming logs
-```
-
-- Smoke-test first; scale only after a pass. Use `--shuffle` (seed defaults to 0; set `--shuffle-seed` for reproducible reports).
-- Hosted evals require the environment to be published (`prime env push`) and support TOML configs and temporary sandbox/tunnel permissions (`--allow-tunnel-access`).
-- Prime Inference models include estimated run cost in eval output automatically.
-- Keep reusable model endpoints as aliases in `configs/endpoints.toml` (fields: `endpoint_id`, `model`, `url`, key) and reference them with `-m <endpoint_id>`.
-
-## Training
-
-Default to Hosted Training unless the user explicitly wants self-managed infrastructure.
-
-```bash
-prime lab setup                  # Lab workspace for environments, evals, GEPA, Hosted Training
-prime train models               # supported models, capacity, pricing
-prime train init                 # generate a training config
-prime train rl.toml              # launch the run
-```
-
-- Hosted Training launches from a CPU machine; no local GPUs needed.
-- Validate the environment with an eval before training (e.g. `-n 20 -r 3 -s`) and confirm reward diversity exists at baseline.
-- Self-managed path: `prime lab setup --prime-rl`, then follow prime-rl's own configs and launch commands. Treat prime-rl as a power-user path requiring local GPU access; see https://docs.primeintellect.ai/prime-rl/overview.md.
-
-## Model Family Choice
-
-Ask the user whether they want instruct or reasoning models before non-trivial runs:
-
-- Instruct (quick behavior checks): `gpt-4.1` series, `qwen3` instruct series.
-- Reasoning (harder probes, deeper coverage): `gpt-5` series, `qwen3` thinking series, `glm` series.

package/skills/prime-intellect/references/inference.md

@@ -1,47 +0,0 @@
-# Prime Inference
-
-Prime Inference is an OpenAI-compatible API for frontier and open models, routed across providers and built for large-scale evaluations.
-
-Live docs: `inference/overview.md`, `inference/usage.md`, `inference/adapter-deployments.md`, `inference/troubleshooting.md` under https://docs.primeintellect.ai/
-
-## Setup
-
-1. Create an API key on https://app.primeintellect.ai (account settings → API Keys) with the **Inference** permission enabled — without it, requests fail with authentication errors.
-2. Export it:
-
-```bash
-export PRIME_API_KEY="your-api-key-here"
-```
-
-## Via the CLI (recommended for evaluations)
-
-```bash
-prime inference models                                   # list available models
-prime eval run gsm8k -m meta-llama/llama-3.1-70b-instruct -n 25   # evals route through Prime Inference
-```
-
-Eval runs against Prime Inference models report estimated USD cost automatically.
-
-## Direct API (OpenAI-compatible)
-
-Base URL: `https://api.pinference.ai/api/v1`
-
-```python
-import openai, os
-
-client = openai.OpenAI(
-    api_key=os.environ["PRIME_API_KEY"],
-    base_url="https://api.pinference.ai/api/v1",
-)
-response = client.chat.completions.create(
-    model="meta-llama/llama-3.1-70b-instruct",
-    messages=[{"role": "user", "content": "Hello!"}],
-)
-```
-
-Anything that speaks the OpenAI API works — just point it at the base URL above. Streaming and advanced parameters are covered in `inference/usage.md`.
-
-## Teams & Adapters
-
-- Team billing: send the `X-Prime-Team-ID` header (find the ID via `prime teams list` or the Team Profile page) to use team credits instead of personal balance.
-- LoRA adapters trained with Hosted Training can be deployed and queried through the same OpenAI-compatible API (`inference/adapter-deployments.md`).

package/skills/prime-intellect/references/sandboxes.md

@@ -1,75 +0,0 @@
-# Sandboxes & Tunnels
-
-Prime Sandboxes are disposable Docker environments for running AI-generated or untrusted code in the cloud: isolated, fast to create, billed only while running (CPU $0.05/core/hr, memory $0.01/GB/hr, disk $0.001/GB/hr).
-
-Live docs: `sandboxes/overview.md`, `sandboxes/cli.md`, `sandboxes/sdk.md`, `sandboxes/images.md`, `sandboxes/tunnel.md` under https://docs.primeintellect.ai/
-
-## CLI Lifecycle
-
-```bash
-prime sandbox create python:3.11-slim --timeout-minutes 120   # any Docker image
-prime sandbox list
-prime sandbox run <sandbox-id> "python --version"
-prime sandbox get <sandbox-id>
-prime sandbox delete <sandbox-id>
-```
-
-Useful create flags:
-
-```bash
-prime sandbox create python:3.11-slim \
-  --name analytics-lab \
-  --cpu-cores 2 --memory-gb 4 --disk-size-gb 20 \
-  --timeout-minutes 240 \
-  --idle-timeout-minutes 15 \
-  --env APP_ENV=staging \
-  --secret API_KEY=sk-abc123 \
-  --start-command "python serve.py --port 8000" \
-  --yes
-```
-
-- `--timeout-minutes` caps total lifetime; `--idle-timeout-minutes` reaps the sandbox early when no exec/upload/download/file-read arrives (1 ≤ idle ≤ timeout ≤ 1440; not supported with `--vm`).
-- `--env` values are plain text; `--secret` values are encrypted at rest and obfuscated in output. Both become environment variables inside the container.
-- Default start command is `tail -f /dev/null` (idle, ready for `prime sandbox run`); `--start-command` replaces the image ENTRYPOINT.
-- Outbound internet is on by default; use `--no-network-access` for isolation when running untrusted code.
-- `--team-id` bills a team; `--yes` skips confirmation in automation.
-
-Custom images: build and push your own via Prime Images (`sandboxes/images.md`).
-
-## Python SDK
-
-`prime_sandboxes` ships `SandboxClient` (sync) and `AsyncSandboxClient` (async) with identical methods:
-
-```python
-from prime_sandboxes import SandboxClient, CreateSandboxRequest, APIClient
-
-client = SandboxClient(APIClient())
-sandbox = client.create(CreateSandboxRequest(
-    name="sdk-demo",
-    docker_image="python:3.11-slim",
-    timeout_minutes=120,
-    environment_vars={"LOG_LEVEL": "debug"},
-    secrets={"API_KEY": "sk-abc123"},
-))
-client.wait_for_creation(sandbox.id)
-result = client.execute_command(sandbox.id, "python -c 'print(42)'")
-client.upload_file(sandbox.id, "/workspace/data.csv", "./data.csv")
-client.download_file(sandbox.id, "/workspace/output.csv", "./output.csv")
-exposed = client.expose(sandbox.id, port=8000, name="web")   # public URL
-client.delete(sandbox.id)
-```
-
-Async variant: `async with AsyncSandboxClient() as sandboxes: await sandboxes.create(...)` — same methods, useful for fanning out many sandboxes concurrently.
-
-## Tunnels
-
-Prime Tunnel exposes a local (or in-sandbox) service through a secure public HTTPS URL — for dev servers, webhooks, and sharing work in progress:
-
-```python
-from prime_tunnel import Tunnel
-
-tunnel = Tunnel(local_port=8000)
-await tunnel.start()   # prints the public URL
-```
-
-Hosted evaluations can create tunnels too: launch the run with `--allow-tunnel-access` (grants tunnel permission to the temporary `PRIME_API_KEY`), then use the same flow inside the hosted sandbox.