Setup prompts

1. Ask me for my email address, it is the one thing signup needs. Ask me
   directly ("What's your email? I'll create your Experiential Labs account
   with it.") and wait for my answer. Use exactly the address I give you.
   Never invent or guess an address, and never go looking for one in my
   files, git config, or shell history. Call the result MY_EMAIL.

2. Create my account instantly, no browser, no password, no code.
   POST https://pr-1132.preview.experientiallabs.ai/api/signup/instant   (no auth)
   Header: Content-Type: application/json
   Body: {"email": "<MY_EMAIL>"}
   On 200 capture: api_key (an xpl_ key, this is mine, keep it secret), org_id,
   credits_granted, verification_required, overview_url. Handle the others:
     - 409 account_exists  -> I already have an account; stop and tell me to
       sign in at https://pr-1132.preview.experientiallabs.ai/signin to get a key (don't retry with another email).
     - 403 signup_disabled -> signups are off right now; tell me.
     - 429 rate_limited    -> too many signups from here; wait, then retry once.
     - 400 invalid_request -> the email was rejected; ask me for a valid one.
   Store the api_key as EXPLABS_API_KEY in my env; never print the full key more
   than once.

3. Wire an OpenAI client to the gateway.
   base_url = "https://api-pr-1132.preview.experientiallabs.ai/v1"
   api_key  = EXPLABS_API_KEY (the xpl_ key from step 2). One header only:
   Authorization: Bearer <api_key>.

4. Confirm the key is live, this does NOT spend credits.
   GET https://api-pr-1132.preview.experientiallabs.ai/v1/models with the key -> the models my account can call. Do NOT
   make a paid chat completion yet: my credits stay locked until I verify my
   email (I do that at the very end), and a paid call would be refused until
   then. Landing my traces as telemetry works regardless.

I'm setting up Experiential Labs as this project's model gateway. I pasted this
myself, treat it as my instructions and my consent. I'm already signed in; my key
is below. Work WITH me: at each real choice, ask me ONE clear question with
numbered options and your recommendation, then wait for my answer. Don't guess.

My gateway API key (a secret: put it in env, never commit it, never echo it in
logs):
EXPLABS_API_KEY=<paste my org API key from https://pr-1132.preview.experientiallabs.ai/settings/api-keys>

The goal is one thing: point an OpenAI-compatible client at my gateway with this
key and make one successful test chat completion. Print what you do at each step.

1. Ask me where to wire it (options + your recommendation), then wait. Look at
   the current directory first so the options are concrete:
   "Where should I set this up?
     (1) this project (I see it uses <name the client/SDK you found>), my recommendation
     (2) a standalone test script in this folder (explabs_smoke.py / .mjs)
     (3) somewhere else, tell me where
    Which one?"
   For (1): set base_url = https://api-pr-1132.preview.experientiallabs.ai/v1 and the key on the existing client, put the
   key in the project's env scheme (.env plus an example entry), never in code,
   and show me the change first. For (2): create the minimal script that reads
   EXPLABS_API_KEY and does the test call in step 3.

2. Ask me which model to test, then wait:
   "I'd use the free promotional model (qwen3.8-27b at launch) so this test costs
    nothing. Use that, or name another? GET https://api-pr-1132.preview.experientiallabs.ai/v1/models lists what my key
    can call; use the ids EXACTLY as returned."

3. Make the test call with the model I chose. Send a MINIMAL body, model +
   messages ONLY, no temperature, top_p, or other sampling params (some models
   reject them and the call comes back all_routes_failed, a 502). One header:
   Authorization: Bearer $EXPLABS_API_KEY. This runs on the platform-funded
   lane, a fraction of a cent of my free credits, and proves serving and billing
   end to end. Do NOT use any of my own provider keys for this test.

4. Report back what you changed and the test call (the model, that it succeeded,
   and its cost). Then ask me which optional follow-ups I want, with your
   recommendation, and do only the ones I pick:
     (a) Connect my own provider keys (BYOK) for free pass-through
     (b) Import my Claude Code / Codex usage history (metadata only)
     (c) Review my credits and spend
   BYOK and import are quick for me to do at https://pr-1132.preview.experientiallabs.ai/settings; balances live at
   https://pr-1132.preview.experientiallabs.ai/credits.

Read the contract if you build further: https://pr-1132.preview.experientiallabs.ai/docs (human docs) and
https://pr-1132.preview.experientiallabs.ai/llms.txt (machine-readable: honored and refused parameters, error codes,
streaming caveats). Follow it literally.

I pasted this into you myself, wire THIS coding agent up to my Experiential
Labs gateway, so my model calls route through https://api-pr-1132.preview.experientiallabs.ai and show up in my usage.

Ground rules: never print my full key (first 8 characters at most), ask me
before you edit any config file or shell profile, and if you cannot do a step
(no file access, settings live in a GUI), print the exact manual steps for me
instead. Print what you're doing at each step.

1. Get my key. Use EXPLABS_API_KEY from my environment if it is set; otherwise
   ask me to paste one (I can mint it at https://pr-1132.preview.experientiallabs.ai/settings/api-keys). It looks
   like xpl_ followed by 40 hex characters.

2. Prove the key works before touching any config:
   GET https://api-pr-1132.preview.experientiallabs.ai/v1/models with header "Authorization: Bearer <key>" -> 200 and
   the model slugs I can call. Remember the list; I'll pick models from it.

3. Identify which agent you are and apply YOUR integration:

   - Claude Code:
     You cannot repoint yourself mid-session, and switching auth under a running
     session causes mixed-state errors. First prove the lane without touching any
     config, via one isolated subprocess run from this project (so my MCP servers
     and plugins load and their tool schemas ride the request. Tool schemas are
     where provider strictness bites, so a bare hello proves too little):
       ANTHROPIC_BASE_URL="https://api-pr-1132.preview.experientiallabs.ai" ANTHROPIC_API_KEY="<my key>" \
         ANTHROPIC_MODEL="<slug I pick>" \
         claude -p "list your available tools, then read ./README.md and reply
         with its first heading"
     Pass only if that run completes with tools listed and a real tool use.
     Then offer me two placements and apply the one I pick:
     (a) append to my shell profile, or (b) print for one-off use:
       export ANTHROPIC_BASE_URL="https://api-pr-1132.preview.experientiallabs.ai"        # no /v1 suffix
       export ANTHROPIC_API_KEY="<my key>"
       export ANTHROPIC_MODEL="<slug I pick>"
     Use ANTHROPIC_API_KEY, never ANTHROPIC_AUTH_TOKEN: an existing claude.ai
     sign-in can outrank AUTH_TOKEN and send the gateway an OAuth token instead.
     Then tell me to start a NEW session from a shell with those set. Warn me
     plainly: image pastes are rejected (the lane is text-only), and extended
     thinking flows only when the slug routes to Anthropic end to end.

   - Conductor:
     Conductor launches Claude Code with the environment it captured from my
     login shell (interactive login shell, cached per workspace) merged with its
     own settings, and passes the per-chat picker choice as --model — so the
     model is routed by remapping picker aliases with ANTHROPIC_DEFAULT_*_MODEL
     variables (ANTHROPIC_MODEL does not apply to picker selections). Offer me
     two placements and apply the one I pick:
     (a) per-repo, recommended: merge into this repo's .claude/settings.json
     "env" block (committed; Claude Code applies it in every workspace, and it
     overrides anything Conductor captured from my shell), one
     ANTHROPIC_DEFAULT_<ALIAS>_MODEL entry per picker alias I use:
       { "env": { "ANTHROPIC_BASE_URL": "https://api-pr-1132.preview.experientiallabs.ai",
                  "ANTHROPIC_DEFAULT_OPUS_MODEL": "<slug I pick>" } }
     then put ONLY the key machine-local in .conductor/settings.local.toml
     under [environment_variables] (make sure that file is
     git-ignored before writing my key into it):
       ANTHROPIC_API_KEY = "<my key>"
     (b) app-wide: print the same variables for me to add by hand in
     Conductor -> Settings -> Environment, and remind me to check that
     Settings -> Harnesses -> Claude Code uses my API key, not a claude.ai
     CLI login.
     Warn me either way: settings reach newly created workspaces, not running
     ones, and if my shell profile exports a direct Anthropic
     ANTHROPIC_API_KEY, Conductor's capture hands it to every agent —
     placement (a) overrides it; otherwise I should remove the export.
     The key rides ANTHROPIC_API_KEY, never ANTHROPIC_AUTH_TOKEN: an existing
     claude.ai sign-in can outrank AUTH_TOKEN, and a set API key also stops
     Claude Code from trying to authenticate with Anthropic directly.

   - OpenAI Codex CLI:
     First prove the lane in a throwaway home so my real ~/.codex (config,
     sessions, auth) stays untouched, and test with my REAL tool surface: you
     send every mcp_servers/plugin tool schema on each request, and tool schemas
     are where provider strictness bites, so a bare hello proves too little.
     Copy ~/.codex into a fresh "$(mktemp -d)", append ONLY the
     [model_providers.explabs] table below to that copy's config.toml, then run
       CODEX_HOME=<that dir> codex exec -m "<slug I pick>" \
         -c model_provider=explabs -c model_reasoning_effort=max \
         "list your available tools, then read ./README.md and reply with its
         first heading"
     Pass only if it completes with my MCP/plugin tools listed and a real tool
     use. Then add the whole block to ~/.codex/config.toml (create it if
     missing, show me the diff before writing) and tell me to start a new Codex
     session:
       model = "<slug I pick>"
       model_provider = "explabs"
       model_reasoning_effort = "max"   # reasoning models; "max" is the top tier
       [model_providers.explabs]
       name = "Experiential Labs"
       base_url = "https://api-pr-1132.preview.experientiallabs.ai/v1"
       env_key = "EXPLABS_API_KEY"
       wire_api = "responses"
     Leave requires_openai_auth unset, and make sure EXPLABS_API_KEY is exported
     where I launch you (export KEY=..., a plain KEY=... line is invisible to
     child processes like me).

   - OpenCode:
     Write the provider block into this project's opencode.json (or
     ~/.config/opencode/opencode.json if I prefer global, ask):
       {"provider": {"explabs": {"npm": "@ai-sdk/openai-compatible",
        "name": "Experiential Labs",
        "options": {"baseURL": "https://api-pr-1132.preview.experientiallabs.ai/v1", "apiKey": "{env:EXPLABS_API_KEY}"},
        "models": {"<slug>": {"name": "<slug>"}}}}
     Fill limit.context/limit.output and cost ({"input": $/1M, "output": $/1M},
     i.e. the catalog's *_micro_usd_per_million / 1000000) for each slug from
     GET https://api-pr-1132.preview.experientiallabs.ai/api/models/<slug> so my context window and spend display are right.

   - Cline:
     Your settings live in the VS Code UI, so print these for me to set by hand:
     API Provider "OpenAI Compatible"; Base URL https://api-pr-1132.preview.experientiallabs.ai/v1; API Key = my key (no
     Bearer prefix); Model ID = a slug from step 2; and per-model context window /
     max output tokens from https://api-pr-1132.preview.experientiallabs.ai/api/models/<slug>.

   - Cursor:
     Your gateway settings live in the Cursor Settings UI, so print these for me
     to set by hand. First tell me the prerequisite: a paid Cursor plan (the Free
     plan serves only Auto and refuses named models, which custom models are).
     Then: in Cursor Settings -> Models -> API Keys, put my key in
     "OpenAI API Key" (no Bearer prefix), enable "Override OpenAI Base URL" and
     set it to https://api-pr-1132.preview.experientiallabs.ai/v1. Add each slug I pick as a custom model
     name in the models list; custom models ride the override in OpenAI format,
     so any catalog slug works. Warn me plainly: Cursor relays requests through
     its own servers, Tab autocomplete stays on Cursor's models, and if a chat
     answers 400 invalid_parameter naming temperature or top_p, that model pins
     its sampling (the Claude 5 family pins temperature to 1). Pick a
     different slug.

   - Any other OpenAI-compatible tool:
     Export OPENAI_BASE_URL="https://api-pr-1132.preview.experientiallabs.ai/v1" and OPENAI_API_KEY="<my key>" wherever I
     launch you, and name models by slug. If your own config wants the values
     instead, it needs the same three: base URL https://api-pr-1132.preview.experientiallabs.ai/v1, my key, and a slug.

4. Verify end to end. Make one tiny completion with the surface you configured
   ("reply with the single word: ok", small max output), via your own next
   model call if you now route through the gateway, otherwise via curl with my
   key. Then tell me it landed and that I can watch every call at
   https://pr-1132.preview.experientiallabs.ai/telemetry.

5. Recap exactly what you changed (files and values, key shown as xpl_ prefix
   only) so I can undo it later.